vagrant-devcommands 0.7.2 → 0.8.0

data/lib/vagrant/devcommands/internal_command/help.rb

@@ -5,6 +5,7 @@ module VagrantPlugins
       class Help
         UTIL     = VagrantPlugins::DevCommands::Util
         MESSAGES = VagrantPlugins::DevCommands::Messages
+        PRINTER  = VagrantPlugins::DevCommands::HelpPrinter
 
         def initialize(env, registry)
           @env      = env
@@ -16,120 +17,82 @@ module VagrantPlugins
 
           command = argv[0]
 
-          return plugin_help(command) unless @registry.valid_command?(command)
+          return plugin_help(command) unless @registry.available?(command)
           return internal_help(command) if @registry.reserved_command?(command)
 
-          command_help(command)
+          help(command)
         end
 
         private
 
-        def command_help(command)
-          command_help_header(command)
-          command_help_parameters(command)
-          command_help_body(@registry.commands[command].help)
-        end
-
-        def command_help_body(help)
-          @env.ui.info ''
-
-          if help.nil?
-            message(:no_help)
+        def help(command)
+          if @registry.valid_chain?(command)
+            PRINTER::Chain.new(@env).output(@registry.chains[command])
           else
-            @env.ui.info help.strip
+            PRINTER::Command.new(@env).output(@registry.commands[command])
           end
         end
 
-        def command_help_header(command)
-          usage = "vagrant run [box] #{command}"
-          usage = usage_params(usage, @registry.commands[command])
-
-          unless @registry.commands[command].usage.nil?
-            usage = @registry.commands[command].usage % { command: command }
-          end
-
-          @env.ui.info "Usage: #{usage}"
-        end
-
-        def command_help_parameters(command)
-          return if @registry.commands[command].parameters.nil?
-
-          @env.ui.info ''
-          @env.ui.info 'Parameters:'
-
-          command_help_parameters_body(command)
-        end
-
-        def command_help_parameters_body(command)
-          params = @registry.commands[command].parameters
-          pad_to = UTIL.pad_to(params)
-
-          params.sort.each do |name, options|
-            @env.ui.info UTIL.padded_columns(pad_to, name, options[:desc])
-          end
+        def info(msg, pre_ln = false)
+          @env.ui.info '' if pre_ln
+          @env.ui.info msg
         end
 
         def internal_commands
-          VagrantPlugins::DevCommands::Internal::COMMANDS
+          VagrantPlugins::DevCommands::Runner::InternalCommand::COMMANDS
         end
 
         def internal_help(command)
           internal_help_header(command)
+          info(internal_commands[command].help.strip, true)
 
-          @env.ui.info ''
-          @env.ui.info internal_commands[command].help.strip
+          message(:plugin_readme, true) if 'help' == command
         end
 
         def internal_help_header(command)
           spec  = internal_commands[command]
-          usage = spec.usage % { command: command }
+          usage = format(spec.usage, command: command)
 
-          @env.ui.info "Usage: #{usage}"
+          info(I18n.t('vagrant_devcommands.internal.help.usage', what: usage))
         end
 
-        def message(msg)
-          MESSAGES.public_send(msg, &@env.ui.method(:info))
+        def message(msg, pre_ln = false)
+          if pre_ln
+            MESSAGES.pre_ln(msg, &@env.ui.method(:info))
+          else
+            MESSAGES.public_send(msg, &@env.ui.method(:info))
+          end
         end
 
         def plugin_help(command)
           message(:plugin_usage) unless '--commands' == command
 
-          pad_to = UTIL.pad_to(internal_commands.merge(@registry.commands))
+          pad_to = UTIL.max_pad([internal_commands,
+                                 @registry.commands,
+                                 @registry.chains])
 
           plugin_help_commands('Available', @registry.commands, pad_to)
+          plugin_help_chains(@registry.chains, pad_to)
           plugin_help_commands('Internal', internal_commands, pad_to)
-
-          message(:plugin_usage_info) unless '--commands' == command
         end
 
-        def plugin_help_commands(type, commands, pad_to)
-          @env.ui.info ''
-          @env.ui.info "#{type} commands:"
+        def plugin_help_chains(chains, pad_to)
+          return if chains.empty?
 
-          commands.sort.each do |name, command|
-            @env.ui.info UTIL.padded_columns(pad_to, name, command.desc)
+          info('Command chains:', true)
+
+          chains.sort.each do |name, chain|
+            info(UTIL.padded_columns(pad_to, name, chain.desc))
           end
         end
 
-        def usage_params(usage, command)
-          return usage if command.parameters.nil?
-
-          [
-            usage,
-            usage_params_mandatory(command.parameters),
-            usage_params_optional(command.parameters)
-          ].flatten.compact.join(' ').strip
-        end
+        def plugin_help_commands(type, commands, pad_to)
+          return if commands.empty?
 
-        def usage_params_mandatory(params)
-          params.collect do |key, opts|
-            "--#{key}=<#{key}>" unless opts[:optional]
-          end
-        end
+          info("#{type} commands:", true)
 
-        def usage_params_optional(params)
-          params.collect do |key, opts|
-            "[--#{key}=<#{key}>]" if opts[:optional]
+          commands.sort.each do |name, command|
+            info(UTIL.padded_columns(pad_to, name, command.desc))
           end
         end
       end

data/lib/vagrant/devcommands/internal_spec.rb

@@ -2,18 +2,20 @@ module VagrantPlugins
   module DevCommands
     # Contains the specs for internal commands
     class InternalSpec
+      I18N_KEY = 'vagrant_devcommands.internal'.freeze
+
       HELP = {
-        desc:  I18n.t('vagrant_devcommands.internal.help.desc'),
+        desc:  I18n.t("#{I18N_KEY}.help.desc"),
         name:  'help',
         usage: 'vagrant run %{command} [command]',
-        help:  I18n.t('vagrant_devcommands.internal.help.help')
+        help:  I18n.t("#{I18N_KEY}.help.help")
       }.freeze
 
       VERSION = {
-        desc:  I18n.t('vagrant_devcommands.internal.version.desc'),
+        desc:  I18n.t("#{I18N_KEY}.version.desc"),
         name:  'version',
         usage: 'vagrant run %{command}',
-        help:  I18n.t('vagrant_devcommands.internal.version.help')
+        help:  I18n.t("#{I18N_KEY}.version.help")
       }.freeze
     end
   end

data/lib/vagrant/devcommands/messages.rb

@@ -4,29 +4,39 @@ module VagrantPlugins
   module DevCommands
     # Provides access to messages used by the plugin
     class Messages
-      def self.no_help(&out)
-        out.call 'No detailed help for this command available.'
+      I18N_KEY = 'vagrant_devcommands.message'.freeze
+
+      def self.chain_no_help(&out)
+        out.call I18n.t("#{I18N_KEY}.chain_no_help")
       end
 
-      def self.no_commands(&out)
-        out.call 'No commands defined!'
+      def self.command_no_help(&out)
+        out.call I18n.t("#{I18N_KEY}.command_no_help")
       end
 
-      def self.plugin_usage(&out)
-        out.call 'Usage: vagrant run [box] <command>'
-        out.call 'Help:  vagrant run help <command>'
+      def self.missing_commandfile(&out)
+        out.call I18n.t("#{I18N_KEY}.missing_commandfile")
+      end
+
+      def self.no_commands(&out)
+        out.call I18n.t("#{I18N_KEY}.no_commands")
       end
 
-      def self.plugin_usage_info(&out)
+      def self.plugin_readme(&out)
         curdir = File.expand_path(File.dirname(__FILE__))
         readme = File.expand_path(File.join(curdir, '../../../README.md'))
 
+        out.call I18n.t("#{I18N_KEY}.plugin_readme", readme: readme)
+      end
+
+      def self.plugin_usage(&out)
+        out.call I18n.t("#{I18N_KEY}.plugin_usage")
+      end
+
+      def self.pre_ln(msg, &out)
         out.call ''
-        out.call 'For detailed usage please read the'
-        out.call 'README.md at the original source location:'
-        out.call '>>> https://github.com/mneudert/vagrant-devcommands'
-        out.call 'A copy of this file should be locally available at'
-        out.call ">>> #{readme}"
+
+        public_send(msg, &out)
       end
     end
   end

data/lib/vagrant/devcommands/model/chain.rb

@@ -0,0 +1,28 @@
+module VagrantPlugins
+  module DevCommands
+    module Model
+      # Definition of an executable command chain
+      class Chain
+        attr_reader :name
+        attr_reader :commands
+
+        attr_reader :desc
+        attr_reader :help
+
+        def initialize(spec)
+          @name     = spec[:name]
+          @commands = spec[:commands]
+
+          @desc = spec[:desc]
+          @help = spec[:help]
+
+          @break_on_error = false != spec[:break_on_error]
+        end
+
+        def break_on_error?
+          @break_on_error
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/devcommands/model/command.rb

@@ -0,0 +1,107 @@
+require 'optparse'
+
+module VagrantPlugins
+  module DevCommands
+    module Model
+      # Definition of an executable command
+      class Command
+        attr_reader :name
+
+        attr_reader :flags
+        attr_reader :parameters
+        attr_reader :script
+
+        attr_reader :box
+        attr_reader :desc
+        attr_reader :help
+        attr_reader :usage
+
+        def initialize(spec)
+          @name = spec[:name]
+
+          @flags      = spec[:flags]
+          @parameters = spec[:parameters]
+          @script     = spec[:script]
+
+          @box   = spec[:box]
+          @desc  = spec[:desc]
+          @help  = spec[:help]
+          @usage = spec[:usage]
+        end
+
+        def run_script(argv)
+          script = @script
+          script = script.call if script.is_a?(Proc)
+
+          opts = {}
+          opts = parse_argv(argv) if @flags || @parameters
+
+          (script % opts).strip
+        end
+
+        private
+
+        def escape_option_values(options)
+          (@parameters || {}).each do |key, conf|
+            next if conf[:escape].nil?
+
+            conf[:escape].each do |char, with|
+              char         = char.to_s unless char.is_a?(String)
+              options[key] = options[key].sub(char, "#{with}#{char}")
+            end
+          end
+
+          options
+        end
+
+        def options_with_defaults
+          options = {}
+
+          (@parameters || {}).each do |key, conf|
+            options[key] = '' if conf[:optional]
+            options[key] = conf[:default] unless conf[:default].nil?
+          end
+
+          options
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def parse_argv(argv)
+          options = options_with_defaults
+
+          OptionParser.new do |opts|
+            (@flags || {}).each do |key, conf|
+              options[key] = ''
+
+              opts.on("--#{key}", "Flag: #{key}") do
+                options[key] = conf[:value] || "--#{key}"
+              end
+            end
+
+            (@parameters || {}).each do |key, _conf|
+              opts.on("--#{key} OPTION", "Parameter: #{key}") do |o|
+                options[key] = o
+              end
+            end
+          end.parse!(argv)
+
+          wrap_option_values(escape_option_values(options))
+        end
+
+        def wrap_option_values(options)
+          (@parameters || {}).each do |key, conf|
+            next if conf[:wrap].nil?
+
+            if conf[:default].nil?
+              next if options[key].nil? || options[key].empty?
+            end
+
+            options[key] = conf[:wrap] % options[key]
+          end
+
+          options
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/devcommands/plugin.rb

@@ -3,7 +3,7 @@ module VagrantPlugins
     # Vagrant plugin definition
     class Plugin < Vagrant.plugin(2)
       name 'vagrant-devcommands'
-      description 'Runs vagrant commands from a Commandfile'
+      description VagrantPlugins::DevCommands::SYNOPSIS
 
       command :run do
         Command

data/lib/vagrant/devcommands/registry.rb

@@ -2,15 +2,24 @@ module VagrantPlugins
   module DevCommands
     # Vagrant command registry
     class Registry
-      RESERVED_COMMANDS = %w(help version).freeze
+      I18N_KEY        = 'vagrant_devcommands.registry'.freeze
+      NAMESPACE_MODEL = VagrantPlugins::DevCommands::Model
 
+      RESERVED_COMMANDS = %w[help version].freeze
+
+      attr_accessor :chains
       attr_accessor :commands
 
       def initialize(env)
+        @chains   = {}
         @commands = {}
         @env      = env
       end
 
+      def available?(name)
+        valid_command?(name) || valid_chain?(name)
+      end
+
       def read_commandfile(commandfile)
         global = commandfile.path_global
         local  = commandfile.path
@@ -20,18 +29,35 @@ module VagrantPlugins
         contents += "\n" + local.read unless nil == local
 
         instance_eval(contents)
+        resolve_naming_conflicts
+        validate_chains
       end
 
       def reserved_command?(command)
         RESERVED_COMMANDS.include?(command)
       end
 
+      def valid_chain?(chain)
+        @chains.include?(chain)
+      end
+
       def valid_command?(command)
         @commands.include?(command) || reserved_command?(command)
       end
 
       private
 
+      def chain(name, options = nil)
+        options            = {} unless options.is_a?(Hash)
+        options[:commands] = {} unless options.key?(:commands)
+
+        return empty_chain_warning(name) if options[:commands].empty?
+
+        options[:name] = name
+
+        @chains[name] = NAMESPACE_MODEL::Chain.new(options)
+      end
+
       def command(name, options = nil)
         return reserved_warning(name) if reserved_command?(name)
 
@@ -41,21 +67,43 @@ module VagrantPlugins
 
         options[:name] = name
 
-        @commands[name] = CommandDef.new(options)
+        @commands[name] = NAMESPACE_MODEL::Command.new(options)
       end
 
-      def script_warning(name)
-        @env.ui.warn "The command '#{name}' has no script defined to execute."
-        @env.ui.warn 'Your definition of it will be ignored.'
+      def empty_chain_warning(name)
+        @env.ui.warn I18n.t("#{I18N_KEY}.empty_chain", name: name)
+        @env.ui.warn I18n.t("#{I18N_KEY}.def_ignored")
+        @env.ui.warn ''
+      end
+
+      def missing_chain_command_warning(chain, command)
+        i18n_args = { chain: chain, command: command }
+
+        @env.ui.warn I18n.t("#{I18N_KEY}.missing_command", i18n_args)
+        @env.ui.warn I18n.t("#{I18N_KEY}.def_ignored")
         @env.ui.warn ''
       end
 
       def reserved_warning(name)
-        @env.ui.warn(
-          "The command name '#{name}' is reserved for internal usage."
-        )
+        @env.ui.warn I18n.t("#{I18N_KEY}.reserved", name: name)
+        @env.ui.warn I18n.t("#{I18N_KEY}.def_ignored")
+        @env.ui.warn ''
+      end
+
+      def resolve_naming_conflicts
+        @chains.keys.each do |chain|
+          next unless @commands.key?(chain)
+
+          @env.ui.warn I18n.t("#{I18N_KEY}.conflict", name: chain)
+          @env.ui.warn I18n.t("#{I18N_KEY}.chain_ignored")
+
+          @chains.delete(chain)
+        end
+      end
 
-        @env.ui.warn 'Your definition of it will be ignored.'
+      def script_warning(name)
+        @env.ui.warn I18n.t("#{I18N_KEY}.no_script", name: name)
+        @env.ui.warn I18n.t("#{I18N_KEY}.def_ignored")
         @env.ui.warn ''
       end
 
@@ -67,6 +115,21 @@ module VagrantPlugins
 
         true
       end
+
+      def validate_chains
+        @chains.all? do |chain, chain_def|
+          chain_def.commands.each do |element|
+            next unless element.is_a?(Hash)
+            next if valid_command?(element[:command])
+
+            missing_chain_command_warning(chain, element)
+
+            @chains.delete(chain)
+
+            break
+          end
+        end
+      end
     end
   end
 end