add docker compose profiles support (bibendi#163)

* add docker compose profiles support

```
  full:
    description: Run all services
    runner: docker_compose
    compose:
      profiles: [workers, backend]
```
Config like this will run `docker compose --profile workers --profile backend up`
command. Run options and service configs are ignored even if provided.
Can also be a part of subcommand:
```
  rails:
    description: Run Rails commands
    service: backend
    command: bundle exec rails
    subcommands:
      all:
        description: Run Rails server, Sidekiq and RabbitMQ workers
        compose:
          profiles: [workers, backend]
```

* fix rubocop findings

* do not nullify `service` option when profiles are used

README.md

@@ -132,6 +132,12 @@ interaction:
         compose:
           run_options: [service-ports, use-aliases]
 
+  stack:
+    description: Run full stack (server, workers, etc.)
+    runner: docker_compose
+    compose:
+      profiles: [web, workers]
+
   sidekiq:
     description: Run sidekiq in background
     service: worker

lib/dip/cli.rb

@@ -78,7 +78,7 @@ def down(*argv)
         require_relative "commands/down_all"
         Dip::Commands::DownAll.new.execute
       else
-        compose("down", *argv)
+        compose("down", *argv.push("--remove-orphans"))
       end
     end
 

lib/dip/commands/compose.rb

@@ -13,7 +13,7 @@ class Compose < Dip::Command
       attr_reader :argv, :config, :shell
 
       def initialize(*argv, shell: true)
-        @argv = argv
+        @argv = argv.compact
         @shell = shell
         @config = ::Dip.config.compose || {}
       end

lib/dip/commands/runners/docker_compose_runner.rb

@@ -9,6 +9,7 @@ module Runners
       class DockerComposeRunner < Base
         def execute
           Commands::Compose.new(
+            *compose_profiles,
             command[:compose][:method],
             *compose_arguments,
             shell: command[:shell]
@@ -17,6 +18,16 @@ def execute
 
         private
 
+        def compose_profiles
+          return [] if command[:compose][:profiles].empty?
+
+          update_command_for_profiles
+
+          command[:compose][:profiles].each_with_object([]) do |profile, argv|
+            argv.concat(["--profile", profile])
+          end
+        end
+
         def compose_arguments
           compose_argv = command[:compose][:run_options].dup
 
@@ -57,6 +68,16 @@ def published_ports
             []
           end
         end
+
+        def update_command_for_profiles
+          # NOTE: When using profiles, the method is always `up`.
+          #       This is because `docker-compose` does not support profiles
+          #       for other commands. Also, run options need to be removed
+          #       because they are not supported by `up`.
+          command[:compose][:method] = "up"
+          command[:command] = ""
+          command[:compose][:run_options] = []
+        end
       end
     end
   end

lib/dip/interaction_tree.rb

@@ -68,6 +68,7 @@ def build_command(entry)
         environment: entry[:environment] || {},
         compose: {
           method: entry.dig(:compose, :method) || entry[:compose_method] || "run",
+          profiles: Array(entry.dig(:compose, :profiles)),
           run_options: compose_run_options(entry.dig(:compose, :run_options) || entry[:compose_run_options])
         }
       }

spec/lib/dip/commands/compose_spec.rb

@@ -76,16 +76,16 @@
   context "when config contains multiple docker-compose files", config: true do
     context "and some files are not exist" do
       let(:config) { {compose: {files: %w[file1.yml file2.yml file3.yml]}} }
-      let(:file1) { fixture_path("empty", "file1.yml") }
-      let(:file2) { fixture_path("empty", "file2.yml") }
-      let(:file3) { fixture_path("empty", "file3.yml") }
+      let(:global_file) { fixture_path("empty", "file1.yml") }
+      let(:local_file) { fixture_path("empty", "file2.yml") }
+      let(:override_file) { fixture_path("empty", "file3.yml") }
 
       before do
         allow_any_instance_of(Pathname).to receive(:exist?) do |obj|
           case obj.to_s
-          when file1, file3
+          when global_file, override_file
             true
-          when file2
+          when local_file
             false
           else
             File.exist?(obj.to_s)
@@ -95,7 +95,7 @@
         cli.start "compose run".shellsplit
       end
 
-      it { expected_exec("docker-compose", ["--file", file1, "--file", file3, "run"]) }
+      it { expected_exec("docker-compose", ["--file", global_file, "--file", override_file, "run"]) }
     end
 
     context "and a file name contains env var", env: true do

spec/lib/dip/commands/runners/docker_compose_runner_spec.rb

@@ -136,6 +136,22 @@
     it { expected_exec("docker-compose", ["run", "--rm", "app", "rspec"], env: hash_including("RAILS_ENV" => "test")) }
   end
 
+  context "when config with profiles" do
+    let(:commands) do
+      {
+        stack: {
+          runner: "docker_compose",
+          compose_run_options: ["foo", "-bar", "--baz=qux"],
+          compose: {profiles: ["foo", "bar"]}
+        }
+      }
+    end
+
+    before { cli.start "run stack".shellsplit }
+
+    it { expected_exec("docker-compose", ["--profile", "foo", "--profile", "bar", "up"]) }
+  end
+
   context "when config with subcommands" do
     let(:commands) { {rails: {service: "app", command: "rails", subcommands: subcommands}} }
     let(:subcommands) { {s: {command: "rails server"}} }
@@ -188,5 +204,20 @@
           env: hash_including("RAILS_ENV" => "test"))
       end
     end
+
+    context "when config with profiles" do
+      let(:subcommands) do
+        {
+          all: {
+            compose_run_options: ["foo", "-bar", "--baz=qux"],
+            compose: {profiles: ["foo", "bar"]}
+          }
+        }
+      end
+
+      before { cli.start "run rails all".shellsplit }
+
+      it { expected_exec("docker-compose", ["--profile", "foo", "--profile", "bar", "up", "app"]) }
+    end
   end
 end