dip 4.2.0 → 7.0.0

data/lib/dip/commands/list.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../command'
-require_relative '../interaction_tree'
+require_relative "../command"
+require_relative "../interaction_tree"
 
 module Dip
   module Commands
@@ -12,7 +12,7 @@ module Dip
         longest_name = tree.keys.map(&:size).max
 
         tree.each do |name, command|
-          puts "#{name.ljust(longest_name)}  ##{command[:description] ? ' ' + command[:description] : ''}"
+          puts "#{name.ljust(longest_name)}  ##{command[:description] ? " #{command[:description]}" : ""}"
         end
       end
     end

data/lib/dip/commands/nginx.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "shellwords"
-require_relative '../command'
+require_relative "../command"
 
 module Dip
   module Commands
@@ -25,15 +25,15 @@ module Dip
         private
 
         def container_args
-          result = %w(--detach)
+          result = %w[--detach]
           result << "--volume #{@socket}:/tmp/docker.sock:ro"
           result << "--volume #{@certs}:/etc/nginx/certs" unless @certs.to_s.empty?
           result << "--restart always"
-          result << Array(@publish).map { |p| "--publish #{p}" }.join(' ')
+          result << Array(@publish).map { |p| "--publish #{p}" }.join(" ")
           result << "--net #{@net}"
           result << "--name #{@name}"
           result << "--label com.dnsdock.alias=#{@domain}"
-          result.join(' ')
+          result.join(" ")
         end
       end
 

data/lib/dip/commands/provision.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../command'
+require_relative "../command"
 
 module Dip
   module Commands

data/lib/dip/commands/run.rb

@@ -1,50 +1,57 @@
 # frozen_string_literal: true
 
-require 'shellwords'
-require_relative '../command'
-require_relative '../interaction_tree'
-require_relative 'compose'
+require "shellwords"
+require_relative "../../../lib/dip/run_vars"
+require_relative "../command"
+require_relative "../interaction_tree"
+require_relative "compose"
 
 module Dip
   module Commands
     class Run < Dip::Command
-      def initialize(cmd, *argv)
-        @command, @argv = InteractionTree.
-                          new(Dip.config.interaction).
-                          find(cmd, *argv)&.
-                          values_at(:command, :argv)
+      def initialize(cmd, *argv, publish: nil)
+        @publish = publish
 
-        raise Dip::Error, "Command `#{[cmd, *argv].join(' ')}` not recognized!" unless command
+        @command, @argv = InteractionTree
+          .new(Dip.config.interaction)
+          .find(cmd, *argv)&.values_at(:command, :argv)
+
+        raise Dip::Error, "Command `#{[cmd, *argv].join(" ")}` not recognized!" unless command
 
         Dip.env.merge(command[:environment])
       end
 
       def execute
-        Dip::Commands::Compose.new(
-          command[:compose][:method],
-          *compose_arguments
-        ).execute
+        if command[:service].nil?
+          shell(command[:command], get_args)
+        else
+          Dip::Commands::Compose.new(
+            command[:compose][:method],
+            *compose_arguments
+          ).execute
+        end
       end
 
       private
 
-      attr_reader :command, :argv
+      attr_reader :command, :argv, :publish
 
       def compose_arguments
         compose_argv = command[:compose][:run_options].dup
 
         if command[:compose][:method] == "run"
           compose_argv.concat(run_vars)
+          compose_argv.concat(published_ports)
           compose_argv << "--rm"
         end
 
         compose_argv << command.fetch(:service)
 
-        unless (cmd = command[:command].to_s).empty?
-          compose_argv.concat(cmd.shellsplit)
+        unless (cmd = command[:command]).empty?
+          compose_argv << cmd
         end
 
-        compose_argv.concat(argv.any? ? argv : command[:default_args])
+        compose_argv.concat(get_args)
 
         compose_argv
       end
@@ -53,7 +60,25 @@ module Dip
         run_vars = Dip::RunVars.env
         return [] unless run_vars
 
-        run_vars.map { |k, v| ["-e", "#{k}=#{v}"] }.flatten
+        run_vars.map { |k, v| ["-e", "#{k}=#{Shellwords.escape(v)}"] }.flatten
+      end
+
+      def published_ports
+        if publish.respond_to?(:each)
+          publish.map { |p| "--publish=#{p}" }
+        else
+          []
+        end
+      end
+
+      def get_args
+        if argv.any?
+          argv
+        elsif !(default_args = command[:default_args]).empty?
+          Array(default_args)
+        else
+          []
+        end
       end
     end
   end

data/lib/dip/commands/ssh.rb

@@ -1,22 +1,26 @@
 # frozen_string_literal: true
 
 require "shellwords"
-require_relative '../command'
+require_relative "../command"
 
 module Dip
   module Commands
     module SSH
       class Up < Dip::Command
-        def initialize(key:, volume:, interactive:)
+        def initialize(key:, volume:, interactive:, user: nil)
           @key = key
           @volume = volume
           @interactive = interactive
+          @user = user
         end
 
         def execute
           subshell("docker", "volume create --name ssh_data".shellsplit, out: File::NULL, err: File::NULL)
 
-          subshell("docker", "run --detach --volume ssh_data:/ssh --name=ssh-agent whilp/ssh-agent".shellsplit)
+          subshell(
+            "docker",
+            "run #{user_args} --detach --volume ssh_data:/ssh --name=ssh-agent whilp/ssh-agent".shellsplit
+          )
 
           key = Dip.env.interpolate(@key)
           subshell("docker", "run #{container_args} whilp/ssh-agent ssh-add #{key}".shellsplit)
@@ -24,13 +28,17 @@ module Dip
 
         private
 
+        def user_args
+          "-u #{@user}" if @user
+        end
+
         def container_args
-          result = %w(--rm)
+          result = %w[--rm]
           volume = Dip.env.interpolate(@volume)
           result << "--volume ssh_data:/ssh"
           result << "--volume #{volume}:#{volume}"
           result << "--interactive --tty" if @interactive
-          result.join(' ')
+          result.join(" ")
         end
       end
 

data/lib/dip/config.rb

@@ -2,6 +2,7 @@
 
 require "yaml"
 require "erb"
+require "pathname"
 
 require "dip/version"
 require "dip/ext/hash"
@@ -12,47 +13,98 @@ module Dip
   class Config
     DEFAULT_PATH = "dip.yml"
 
-    class << self
-      def exist?
-        File.exist?(path)
+    CONFIG_DEFAULTS = {
+      environment: {},
+      compose: {},
+      interation: {},
+      provision: []
+    }.freeze
+
+    ConfigKeyMissingError = Class.new(ArgumentError)
+
+    class ConfigFinder
+      attr_reader :file_path
+
+      def initialize(work_dir, override: false)
+        @override = override
+
+        @file_path = if ENV["DIP_FILE"]
+          Pathname.new(prepared_name(ENV["DIP_FILE"]))
+        else
+          find(Pathname.new(work_dir))
+        end
       end
 
-      def path
-        ENV["DIP_FILE"] || File.join(Dir.pwd, DEFAULT_PATH)
+      def exist?
+        file_path&.exist?
       end
 
-      def override_path
+      private
+
+      attr_reader :override
+
+      def prepared_name(path)
+        return path unless override
+
         path.gsub(/\.yml$/, ".override.yml")
       end
 
+      def find(path)
+        file = path.join(prepared_name(DEFAULT_PATH))
+        return file if file.exist?
+        return if path.root?
+
+        find(path.parent)
+      end
+    end
+
+    class << self
       def load_yaml(file_path = path)
         return {} unless File.exist?(file_path)
 
         YAML.safe_load(
           ERB.new(File.read(file_path)).result,
           [], [], true
-        ).deep_symbolize_keys!
+        )&.deep_symbolize_keys! || {}
       end
     end
 
-    %i[environment compose interaction provision].each do |key|
-      define_method(key) do
-        config[key]
-      end
+    def initialize(work_dir = Dir.pwd)
+      @work_dir = work_dir
+    end
+
+    def file_path
+      finder.file_path
+    end
+
+    def exist?
+      finder.exist?
     end
 
     def to_h
       config
     end
 
+    %i[environment compose interaction provision].each do |key|
+      define_method(key) do
+        config[key] || (raise config_missing_error(key))
+      end
+    end
+
     private
 
+    attr_reader :work_dir
+
+    def finder
+      @finder ||= ConfigFinder.new(work_dir)
+    end
+
     def config
       return @config if @config
 
-      raise ArgumentError, "Dip config not found at path '#{self.class.path}'" unless self.class.exist?
+      raise Dip::Error, "Could not find dip.yml config" unless finder.exist?
 
-      config = self.class.load_yaml
+      config = self.class.load_yaml(finder.file_path)
 
       unless Gem::Version.new(Dip::VERSION) >= Gem::Version.new(config.fetch(:version))
         raise VersionMismatchError, "Your dip version is `#{Dip::VERSION}`, " \
@@ -60,9 +112,15 @@ module Dip
                                     "Please upgrade your dip!"
       end
 
-      config.deep_merge!(self.class.load_yaml(self.class.override_path))
+      override_finder = ConfigFinder.new(work_dir, override: true)
+      config.deep_merge!(self.class.load_yaml(override_finder.file_path)) if override_finder.exist?
+
+      @config = CONFIG_DEFAULTS.merge(config)
+    end
 
-      @config = config
+    def config_missing_error(config_key)
+      msg = "config for %<key>s is not defined in %<path>s" % {key: config_key, path: finder.file_path}
+      ConfigKeyMissingError.new(msg)
     end
   end
 end

data/lib/dip/environment.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 module Dip
   class Environment
-    VAR_REGEX = /\$[\{]?(?<var_name>[a-zA-Z_][a-zA-Z0-9_]*)[\}]?/.freeze
-    SPECIAL_VARS = {"DIP_OS" => :find_dip_os}.freeze
+    VAR_REGEX = /\$\{?(?<var_name>[a-zA-Z_][a-zA-Z0-9_]*)\}?/.freeze
+    SPECIAL_VARS = %i[os work_dir_rel_path].freeze
 
     attr_reader :vars
 
@@ -24,28 +26,42 @@ module Dip
       vars.fetch(name) { ENV[name] }
     end
 
+    def fetch(name, &block)
+      vars.fetch(name) { ENV.fetch(name, &block) }
+    end
+
     def []=(key, value)
       @vars[key] = value
     end
 
     def interpolate(value)
-      value.gsub(VAR_REGEX) do
+      value.gsub(VAR_REGEX) do |match|
         var_name = Regexp.last_match[:var_name]
 
-        if SPECIAL_VARS.key?(var_name)
-          self[var_name] || send(SPECIAL_VARS[var_name])
+        if special_vars.key?(var_name)
+          fetch(var_name) { send(special_vars[var_name]) }
         else
-          self[var_name]
+          fetch(var_name) { match }
         end
       end
     end
 
-    alias replace interpolate
+    alias_method :replace, :interpolate
 
     private
 
-    def find_dip_os
+    def special_vars
+      @special_vars ||= SPECIAL_VARS.each_with_object({}) do |key, memo|
+        memo["DIP_#{key.to_s.upcase}"] = "find_#{key}"
+      end
+    end
+
+    def find_os
       @dip_os ||= Gem::Platform.local.os
     end
+
+    def find_work_dir_rel_path
+      @find_work_dir_rel_path ||= Pathname.getwd.relative_path_from(Dip.config.file_path.parent).to_s
+    end
   end
 end

data/lib/dip/ext/hash.rb

@@ -24,7 +24,7 @@ module ActiveSupportHashHelpers
       merge!(other_hash) do |key, this_val, other_val|
         if this_val.is_a?(Hash) && other_val.is_a?(Hash)
           this_val.deep_merge(other_val, &block)
-        elsif block_given?
+        elsif block
           block.call(key, this_val, other_val)
         else
           other_val

data/lib/dip/interaction_tree.rb

@@ -58,9 +58,9 @@ module Dip
     def build_command(entry)
       {
         description: entry[:description],
-        service: entry.fetch(:service),
-        command: entry[:command],
-        default_args: prepare_default_args(entry[:default_args]),
+        service: entry[:service],
+        command: entry[:command].to_s.strip,
+        default_args: entry[:default_args].to_s.strip,
         environment: entry[:environment] || {},
         compose: {
           method: entry.dig(:compose, :method) || entry[:compose_method] || "run",
@@ -76,19 +76,6 @@ module Dip
       entry[:description] ||= nil
     end
 
-    def prepare_default_args(args)
-      return [] if args.nil?
-
-      case args
-      when Array
-        args
-      when String
-        args.shellsplit
-      else
-        raise ArgumentError, "Unknown type for default_args: #{args.inspect}"
-      end
-    end
-
     def compose_run_options(value)
       return [] unless value