dip 4.2.0 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de28bb80ddff1548082c5b8ccd0115bcd650cbdba9a930c666b02751cf0ba976
-  data.tar.gz: 96a4a6d5b2f78b559ef429f793e1899ec8d35edc7f10ac90693632b8a9e2be06
+  metadata.gz: 5df0e0954a241e561cfe313fc0f6a8000644e8ebe102a954ba721e81752046a6
+  data.tar.gz: 89c96af17e4dc28d2d0953deb411075e662eb7815193517634b08242d9a31761
 SHA512:
-  metadata.gz: 404af36fd19249124ab8bf8ce3f765c03f8e72ef9d6c1138424704233caf543c7ce2cf8ea7a86ece144407597bfba895cdb140ef277aa71042201a77221c974c
-  data.tar.gz: 4b788801e5c6e73e259f0de5b4c137aa5dcce5a7e681dae1d21b2c403118cdafdf0870c22bd80be350c25f943e100930c0f8296927898196e0c812e0f1f66254
+  metadata.gz: 6730c668a3850de7625f819045787dd901546868df56ecde7264796736b567e66a3ef96a7db7b7855585f6b6a47ba0b241e0ce7b07177692cf0df783a35bc313
+  data.tar.gz: d32638715384461a37cb62ed6f2f0f41b6b3ea3618e9b7dd006d3d57b88325f3c37ac9faa5e82727fda56297473153b59736c97f162d326e8ffb3d1020519d45

data/README.md

@@ -16,9 +16,11 @@ A command-line utility that gives the "native" interaction with applications con
 ## Presentations and examples
 
 - [Local development with Docker containers](https://slides.com/bibendi/dip)
-- Dockerized Ruby on Rails applications: [one](https://github.com/bibendi/dip-example-rails), [two](https://github.com/evilmartians/evil_chat)
-- [Dockerized Node.js application](https://github.com/bibendi/yt-graphql-react-event-booking-api)
+- Dockerized Ruby on Rails applications: [one](https://github.com/lewagon/rails-k8s-demo), [two](https://github.com/bibendi/dip-example-rails), [three](https://github.com/evilmartians/evil_chat)
+- Dockerized Node.js application: [one](https://github.com/bibendi/twinkle.js), [two](https://github.com/bibendi/yt-graphql-react-event-booking-api)
 - [Dockerized Ruby gem](https://github.com/bibendi/schked)
+- [Dockerizing Ruby and Rails development](https://evilmartians.com/chronicles/ruby-on-whales-docker-for-ruby-rails-development)
+- [Reusable development containers with Docker Compose and Dip](https://evilmartians.com/chronicles/reusable-development-containers-with-docker-compose-and-dip)
 
 [![asciicast](https://asciinema.org/a/210236.svg)](https://asciinema.org/a/210236)
 
@@ -36,6 +38,7 @@ After that we can type commands without `dip` prefix. For example:
 <run-command> *any-args
 compose *any-compose-arg
 up <service>
+build
 down
 provision
 ```
@@ -53,41 +56,11 @@ After that, it will be automatically applied when you open your preferred termin
 
 ## Installation
 
-You have many ways.
-
-### Homebrew
-
-
-You can use [Homebrew](https://brew.sh) on macOS (or [Linux](https://docs.brew.sh/Homebrew-on-Linux)).
-
-Today Homebrew tap for DIP is located at https://github.com/bibendi/homebrew-dip
-
-```sh
-brew tap bibendi/dip
-brew install dip
-```
-
-### Ruby Gem
-
 ```sh
 gem install dip
 ```
 
-### Precompiled binary
-
-If you don't have installed Ruby, then you could copy a precompiled binary to your system.
-It can be found at [releases page](https://github.com/bibendi/dip/releases)
-or type bellow into your terminal:
-
-```sh
-curl -L https://github.com/bibendi/dip/releases/download/4.2.0/dip-`uname -s`-`uname -m` > /usr/local/bin/dip
-chmod +x /usr/local/bin/dip
-```
-
-## Docker installation
-
-- [Ubuntu](docs/docker-ubuntu-install.md)
-- [Mac OS](docs/docker-for-mac-install.md)
+The compiled binary is no more provided since version 7, because of new version of [Ruby Packer](https://github.com/pmq20/ruby-packer) not released for a long time with recent Ruby version. Also there was a lot of work to prepare each release of Dip for MacOS version.
 
 ## Usage
 
@@ -98,17 +71,17 @@ dip SUBCOMMAND --help
 
 ### dip.yml
 
-The configuration file `dip.yml` should be placed in a project root directory.
+The configuration is loaded from `dip.yml` file. It may be located in a working directory, or it will be found in the nearest parent directory up to the file system root. If nearby places `dip.override.yml` file, it will be merged into the main config.
+
 Also, in some cases, you may want to change the default config path by providing an environment variable `DIP_FILE`.
-If nearby places `dip.override.yml` file it would be merged into the main config.
 
 Below is an example of a real config.
-`dip.yml` reference will be written soon.
-Also, you can check out examples in the top.
+Config file reference will be written soon.
+Also, you can check out examples at the top.
 
 ```yml
 # Required minimum dip version
-version: '4.1'
+version: '7.0'
 
 environment:
   COMPOSE_EXT: development
@@ -121,9 +94,10 @@ compose:
   project_name: bear
 
 interaction:
-  bash:
+  shell:
     description: Open the Bash shell in app's container
     service: app
+    command: bash
     compose:
       run_options: [no-deps]
 
@@ -153,7 +127,7 @@ interaction:
         description: Run Rails server at http://localhost:3000
         service: web
         compose:
-          run_options: [service-ports]
+          run_options: [service-ports, use-aliases]
 
   sidekiq:
     description: Run sidekiq in background
@@ -168,12 +142,55 @@ interaction:
     default_args: db_dev
     command: psql -h pg -U postgres
 
+  clean_cache:
+    description: Delete cache files on the host machine
+    command: rm -rf $(pwd)/tmp/cache/*
+
 provision:
   - dip compose down --volumes
+  - dip clean_cache
   - dip compose up -d pg redis
   - dip bash -c ./bin/setup
 ```
 
+### Predefined environment variables
+
+#### $DIP_OS
+
+Current OS architecture (e.g. `linux`, `darwin`, `freebsd`, and so on). Sometime it may be useful to have one common `docker-compose.yml` and OS-dependent Compose configs.
+
+#### $DIP_WORK_DIR_REL_PATH
+
+Relative path from the current directory to the nearest directory where a Dip's config is found. It is useful when you need to mount a specific local directory to a container along with ability to change its working dir. For example:
+
+```
+- project_root
+  |- dip.yml (1)
+  |- docker-compose.yml (2)
+  |- sub-project-dir
+     |- your current directory is here <<<
+```
+
+```yml
+# dip.yml (1)
+environment:
+  WORK_DIR: /app/${DIP_WORK_DIR_REL_PATH}
+```
+
+```yml
+# docker-compose.yml (2)
+services:
+  app:
+    working_dir: ${WORK_DIR:-/app}
+```
+
+```sh
+cd sub-project-dir
+dip run bash -c pwd
+```
+
+returned is `/app/sub-project-dir`.
+
 ### dip run
 
 Run commands defined within the `interaction` section of dip.yml
@@ -183,16 +200,27 @@ dip run rails c
 dip run rake db:migrate
 ```
 
-`run` argument can be omitted
+Also, `run` argument can be omitted
 
 ```sh
 dip rake db:migrate
+```
+
+You can pass in a custom environment variable into a container:
+
+```sh
 dip VERSION=12352452 rake db:rollback
 ```
 
+Use options `-p, --publish=[]` if you need to additionally publish a container's port(s) to the host unless this behaviour is not configured at dip.yml:
+
+```sh
+dip run -p 3000:3000 bundle exec rackup config.ru
+```
+
 ### dip ls
 
-List al available run commands.
+List all available run commands.
 
 ```sh
 dip ls
@@ -242,6 +270,21 @@ volumes:
       name: ssh_data
 ```
 
+if you want to use non-root user you can specify UID like so:
+
+```
+dip ssh up -u 1000
+```
+
+This especially helpful if you have something like this in your docker-compose.yml:
+
+```
+services:
+  web:
+    user: "1000:1000"
+
+```
+
 ### dip nginx
 
 Runs Nginx server container based on [bibendi/nginx-proxy](https://github.com/bibendi/nginx-proxy) image. An application's docker-compose.yml should contain environment variable `VIRTUAL_HOST` and `VIRTUAL_PATH` and connects to external network `frontend`.

data/exe/dip

@@ -1,20 +1,20 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-lib_path = File.expand_path('../lib', __dir__)
+lib_path = File.expand_path("../lib", __dir__)
 $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
 
-require 'dip'
-require 'dip/cli'
-require 'dip/run_vars'
-
 begin
-  require 'pry-byebug' if Dip.debug?
+  require "pry-byebug" if ENV["DIP_ENV"] == "debug"
 rescue LoadError
-  puts "pry-byebug not found!"
+  # do nothing
 end
 
-Signal.trap('INT') do
+require "dip"
+require "dip/cli"
+require "dip/run_vars"
+
+Signal.trap("INT") do
   warn("\n#{caller.join("\n")}: interrupted")
   exit(1)
 end

data/lib/dip.rb

@@ -11,14 +11,14 @@ module Dip
     end
 
     def env
-      @env ||= Dip::Environment.new(Dip::Config.exist? ? config.environment : {})
+      @env ||= Dip::Environment.new(config.exist? ? config.environment : {})
     end
 
     def bin_path
       $PROGRAM_NAME.start_with?("./") ? File.expand_path($PROGRAM_NAME) : "dip"
     end
 
-    %w(test debug).each do |key|
+    %w[test debug].each do |key|
       define_method("#{key}?") do
         ENV["DIP_ENV"] == key
       end

data/lib/dip/cli.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
-require 'thor'
-require 'dip/run_vars'
+require "thor"
+require "dip/run_vars"
 
 module Dip
   class CLI < Thor
+    TOP_LEVEL_COMMANDS = %w[help version ls compose up stop down run provision ssh dns nginx console].freeze
+
     class << self
       # Hackery. Take the run method away from Thor so that we can redefine it.
       def is_thor_reserved_word?(word, type)
@@ -13,44 +15,49 @@ module Dip
         super
       end
 
-      def start(argv)
-        super Dip::RunVars.call(argv, ENV)
+      def exit_on_failure?
+        true
       end
-    end
 
-    stop_on_unknown_option! :up
+      def start(argv)
+        argv = Dip::RunVars.call(argv, ENV)
 
-    def method_missing(cmd, *args)
-      if Dip.config.interaction.key?(cmd.to_sym)
-        self.class.start(["run", cmd.to_s, *args])
-      else
-        super
+        cmd = argv.first
+
+        if cmd && !TOP_LEVEL_COMMANDS.include?(cmd) && Dip.config.exist? && Dip.config.interaction.key?(cmd.to_sym)
+          argv.unshift("run")
+        end
+
+        super Dip::RunVars.call(argv, ENV)
       end
     end
 
-    def respond_to_missing?(cmd)
-      Dip.config.interaction.key?(cmd.to_sym)
-    end
+    stop_on_unknown_option! :run
 
-    desc 'version', 'dip version'
+    desc "version", "dip version"
     def version
-      require_relative 'version'
+      require_relative "version"
       puts Dip::VERSION
     end
-    map %w(--version -v) => :version
+    map %w[--version -v] => :version
 
-    desc 'ls', 'List available run commands'
+    desc "ls", "List available run commands"
     def ls
-      require_relative 'commands/list'
+      require_relative "commands/list"
       Dip::Commands::List.new.execute
     end
 
-    desc 'compose CMD [OPTIONS]', 'Run docker-compose commands'
+    desc "compose CMD [OPTIONS]", "Run docker-compose commands"
     def compose(*argv)
-      require_relative 'commands/compose'
+      require_relative "commands/compose"
       Dip::Commands::Compose.new(*argv).execute
     end
 
+    desc "build [OPTIONS] SERVICE", "Run `docker-compose build` command"
+    def build(*argv)
+      compose("build", *argv)
+    end
+
     desc "up [OPTIONS] SERVICE", "Run `docker-compose up` command"
     def up(*argv)
       compose("up", *argv)
@@ -61,42 +68,49 @@ module Dip
       compose("stop", *argv)
     end
 
-    desc "down all services [OPTIONS]", "Run `docker-compose down` command"
+    desc "down [OPTIONS]", "Run `docker-compose down` command"
     def down(*argv)
       compose("down", *argv)
     end
 
-    desc 'CMD or dip run CMD [OPTIONS]', 'Run configured command in a docker-compose service'
+    desc "run [OPTIONS] CMD [ARGS]", "Run configured command in a docker-compose service. `run` prefix may be omitted"
+    method_option :publish, aliases: "-p", type: :string, repeatable: true,
+                            desc: "Publish a container's port(s) to the host"
+    method_option :help, aliases: "-h", type: :boolean, desc: "Display usage information"
     def run(*argv)
-      require_relative 'commands/run'
-      Dip::Commands::Run.new(*argv).execute
+      if argv.empty? || options[:help]
+        invoke :help, ["run"]
+      else
+        require_relative "commands/run"
+        Dip::Commands::Run.new(*argv, publish: options[:publish]).execute
+      end
     end
 
     desc "provision", "Execute commands within provision section"
-    method_option :help, aliases: '-h', type: :boolean,
-                         desc: 'Display usage information'
+    method_option :help, aliases: "-h", type: :boolean,
+                         desc: "Display usage information"
     def provision
       if options[:help]
-        invoke :help, ['provision']
+        invoke :help, ["provision"]
       else
-        require_relative 'commands/provision'
+        require_relative "commands/provision"
         Dip::Commands::Provision.new.execute
       end
     end
 
-    require_relative 'cli/ssh'
+    require_relative "cli/ssh"
     desc "ssh", "ssh-agent container commands"
     subcommand :ssh, Dip::CLI::SSH
 
-    require_relative 'cli/dns'
+    require_relative "cli/dns"
     desc "dns", "DNS server for automatic docker container discovery"
     subcommand :dns, Dip::CLI::DNS
 
-    require_relative 'cli/nginx'
+    require_relative "cli/nginx"
     desc "nginx", "Nginx reverse proxy server"
     subcommand :nginx, Dip::CLI::Nginx
 
-    require_relative 'cli/console'
+    require_relative "cli/console"
     desc "console", "Integrate Dip commands into shell (only ZSH and Bash is supported)"
     subcommand :console, Dip::CLI::Console
   end

data/lib/dip/cli/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dip
+  class CLI
+    class Base < Thor
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/dip/cli/console.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-require 'thor'
+require "thor"
+require_relative "./base"
 require_relative "../commands/console"
 
 module Dip
   class CLI
-    class Console < Thor
+    class Console < Base
       desc "start", "Integrate Dip into current shell"
-      method_option :help, aliases: '-h', type: :boolean,
-                           desc: 'Display usage information'
+      method_option :help, aliases: "-h", type: :boolean,
+                           desc: "Display usage information"
       def start
         if options[:help]
-          invoke :help, ['start']
+          invoke :help, ["start"]
         else
           Dip::Commands::Console::Start.new.execute
         end
@@ -20,11 +21,11 @@ module Dip
       default_task :start
 
       desc "inject", "Inject aliases"
-      method_option :help, aliases: '-h', type: :boolean,
-                           desc: 'Display usage information'
+      method_option :help, aliases: "-h", type: :boolean,
+                           desc: "Display usage information"
       def inject
         if options[:help]
-          invoke :help, ['inject']
+          invoke :help, ["inject"]
         else
           Dip::Commands::Console::Inject.new.execute
         end