cliqr 1.1.0 → 1.2.0

data/lib/cliqr/cli/executor.rb

@@ -14,7 +14,6 @@ module Cliqr
       # Create a new command executor
       def initialize(config)
         @config = config
-        @router = Router.new(config)
         @validator = Cliqr::ArgumentValidation::Validator.new
       end
 
@@ -25,12 +24,17 @@ module Cliqr
       #
       # @return [Integer] Exit status of the command execution
       def execute(args, options)
-        parsed_input = parse(args)
+        args = Cliqr::Util.sanitize_args(args, @config)
+        action_config, parsed_input = parse(args)
         begin
-          command_context = CommandContext.build(parsed_input)
-          @router.handle command_context, **options
+          command_context = CommandContext.build(action_config, parsed_input, options) \
+            do |forwarded_args, forwarded_options|
+              execute(forwarded_args, options.merge(forwarded_options))
+            end
+          Router.new(action_config).handle(command_context, **options)
         rescue StandardError => e
-          raise Cliqr::Error::CommandRuntimeException.new("command '#{@config.basename}' failed", e)
+          raise Cliqr::Error::CommandRuntimeError.new(
+            "command '#{action_config.command}' failed", e)
         end
       end
 
@@ -43,11 +47,12 @@ module Cliqr
       # @throws [Cliqr::Error::ValidationError] If the input arguments do not satisfy validation
       # criteria
       #
-      # @return [Cliqr::Parser::ParsedInput] Parsed arguments wrapper
+      # @return [Cliqr::Parser::ParsedInput] Parsed [Cliqr::CLI::Config] instance and arguments
+      # wrapper
       def parse(args)
-        parsed_input = Parser.parse(@config, args)
-        @validator.validate(parsed_input, @config)
-        parsed_input
+        action_config, parsed_input = Parser.parse(@config, args)
+        @validator.validate(parsed_input, action_config)
+        [action_config, parsed_input]
       end
     end
   end

data/lib/cliqr/cli/interface.rb

@@ -2,10 +2,18 @@
 
 require 'cliqr/error'
 require 'cliqr/cli/executor'
+require 'cliqr/cli/usage_builder'
 
 module Cliqr
   # Definition and builder for command line interface
   module CLI
+    # Exit code hash map
+    EXIT_CODE = {
+        success: 0,
+        'Cliqr::Error::CommandRuntimeError'.to_sym => 1,
+        'Cliqr::Error::IllegalArgumentError'.to_sym => 2
+    }
+
     # A CLI interface instance which is the entry point for all CLI commands.
     #
     # @api private
@@ -27,12 +35,7 @@ module Cliqr
       #
       # @return [String] Defines usage of this interface
       def usage
-        template_file_path = File.expand_path('../../../../templates/usage.erb', __FILE__)
-        template = ERB.new(File.new(template_file_path).read, nil, '%')
-        result = template.result(@config.instance_eval { binding })
-
-        # remove multiple newlines from the end of usage
-        "#{result.strip}\n"
+        UsageBuilder.build(config)
       end
 
       # Execute a command
@@ -42,8 +45,20 @@ module Cliqr
       #
       # @return [Integer] Exit code of the command execution
       def execute(args = [], **options)
+        execute_internal(args, options)
+        Cliqr::CLI::EXIT_CODE[:success]
+      rescue Cliqr::Error::CliqrError => e
+        puts e.message
+        Cliqr::CLI::EXIT_CODE[e.class.to_s.to_sym]
+      end
+
+      # Executes a command without handling error conditions
+      #
+      # @return [Integer] Exit code
+      def execute_internal(args = [], **options)
         options = {
-            :output => :default
+            :output => :default,
+            :environment => :bash
         }.merge(options)
         @executor.execute(args, options)
       end

data/lib/cliqr/cli/router.rb

@@ -24,10 +24,14 @@ module Cliqr
       #
       # @return [Integer] Exit code of the command execution
       def handle(context, **options)
-        handler = @config.handler.new
+        handler = @config.handler
         runner = CommandRunnerFactory.get(options)
         runner.run do
-          handler.execute(context)
+          if handler.is_a?(Proc)
+            context.instance_eval(&handler)
+          else
+            handler.execute(context)
+          end
         end
       end
     end

data/lib/cliqr/cli/shell_command.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require 'cliqr/cli/command'
+
+module Cliqr
+  # @api private
+  module CLI
+    # The default command executed to run a shell action
+    #
+    # @api private
+    class ShellCommand < Cliqr::CLI::Command
+      # Start a shell in the context of some other command
+      #
+      # @return [Integer] Exit code
+      def execute(context)
+        fail(Cliqr::Error::IllegalCommandError,
+             'Cannot run another shell within an already running shell') unless context.bash?
+
+        base_command = context.command[0...(context.command.rindex('shell'))].strip
+        puts "Starting shell for command \"#{base_command}\""
+        exit_code = ShellRunner.new(base_command, context).run
+        puts "shell exited with code #{exit_code}"
+        exit_code
+      end
+    end
+
+    private
+
+    # The runner for shell command
+    class ShellRunner
+      # Create the runner instance
+      def initialize(base_command, context)
+        @base_command = base_command
+        @context = context
+      end
+
+      # Start shell
+      #
+      # @return [Integer] Exit code
+      def run
+        loop do
+          command = prompt("#{@base_command} > ")
+          execute(command) unless command == 'exit'
+          break if command == 'exit'
+        end
+        0
+      end
+
+      private
+
+      # Execute a shell command
+      #
+      # @return [Integer] Exit code of the command executed
+      def execute(command)
+        @context.forward("#{@base_command} #{command}", :environment => :cliqr_shell)
+      rescue StandardError => e
+        puts e.message
+      end
+
+      # Show a prompt and ask for input
+      #
+      # @return [String]
+      def prompt(prefix = '')
+        print prefix
+        $stdin.gets.chomp
+      end
+    end
+  end
+end

data/lib/cliqr/cli/usage_builder.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+require 'cliqr/error'
+require 'cliqr/cli/executor'
+require 'erb'
+
+module Cliqr
+  module CLI
+    # Builds the usage information based on the configuration settings
+    #
+    # @api private
+    class UsageBuilder
+      # Build the usage information
+      #
+      # @param [Cliqr::CLI::Config] config Configuration of the command line interface
+      #
+      # @return [String]
+      def self.build(config)
+        template_file_path = File.expand_path('../../../../templates/usage.erb', __FILE__)
+        template = ERB.new(File.new(template_file_path).read, nil, '%')
+        usage_context = CommandUsageContext.new(config)
+        result = template.result(usage_context.instance_eval { binding })
+
+        # remove multiple newlines from the end of usage
+        "#{result.strip}\n"
+      end
+    end
+
+    # The context in which the usage template will be executed
+    #
+    # @api private
+    class CommandUsageContext
+      # Name of the current command in context
+      #
+      # @return [String]
+      attr_reader :name
+
+      # Description of the current command
+      #
+      # @return [String]
+      attr_reader :description
+
+      # Pre-configured command's actions
+      #
+      # @return [Array<Cliqr::CLI::CommandUsageContext>]
+      attr_reader :actions
+
+      # List of options configured for current context
+      #
+      # @return [Array<Cliqr::CLI::OptionUsageContext>]
+      attr_reader :options
+
+      # Command for the current context
+      #
+      # @return [String]
+      attr_reader :command
+
+      # Wrap a [Cliqr::CLI::Config] instance for usage template
+      def initialize(config)
+        @config = config
+
+        @name = config.name
+        @description = config.description
+        @actions = @config.actions.map { |action| CommandUsageContext.new(action) }
+        @options = @config.options.map { |option| OptionUsageContext.new(option) }
+        @command = @config.command
+      end
+
+      # Check if command has a description
+      def description?
+        non_empty?(@description)
+      end
+
+      # Check if there are any preconfigured options
+      def options?
+        non_empty?(@config.options)
+      end
+
+      # Check if current command allows arguments
+      def arguments?
+        @config.arguments == Cliqr::CLI::ENABLE_CONFIG
+      end
+
+      # Check if current command has any actions
+      def actions?
+        non_empty?(@actions)
+      end
+
+      # Check if the help is enabled
+      #
+      # @return [Boolean]
+      def help?
+        @config.help?
+      end
+
+      private
+
+      # Check if a obj is non-empty
+      def non_empty?(obj)
+        !(obj.nil? || obj.empty?)
+      end
+    end
+
+    # Wrapper of [Cliqr::CLI::OptionConfig] to be used in usage rendering
+    #
+    # @api private
+    class OptionUsageContext
+      # Name of the option
+      #
+      # @return [String]
+      attr_reader :name
+
+      # Short name of the option
+      #
+      # @return [String]
+      attr_reader :short
+
+      # Option's type
+      #
+      # @return [Symbol]
+      attr_reader :type
+
+      # Option's description
+      #
+      # @return [String]
+      attr_reader :description
+
+      # Default value for this option
+      #
+      # @return [Object]
+      attr_reader :default
+
+      # Create a new option usage context
+      def initialize(option_config)
+        @option_config = option_config
+
+        @name = @option_config.name
+        @short = @option_config.short
+        @type = @option_config.type
+        @description = @option_config.description
+        @default = @option_config.default
+      end
+
+      # Check if current option is a boolean option
+      def boolean?
+        @option_config.boolean? && !help? && !version?
+      end
+
+      # Check if the option has a short name
+      def short?
+        @option_config.short?
+      end
+
+      # Check if the option has non-empty description
+      def description?
+        @option_config.description?
+      end
+
+      # Assert if the details of this options should be printed
+      def details?
+        @option_config.description? || @option_config.type? || @option_config.default?
+      end
+
+      # Check if the option has a non-default type
+      def type?
+        @option_config.type? && !help? && !version?
+      end
+
+      # check if the option should display default setting
+      def default?
+        @option_config.default? && !help? && !version?
+      end
+
+      # Check if the option is for getting help
+      def help?
+        @option_config.name == 'help'
+      end
+
+      # Check if the option is for version
+      def version?
+        @option_config.name == 'version'
+      end
+    end
+  end
+end

data/lib/cliqr/config_validation/validator_factory.rb

@@ -191,9 +191,10 @@ module Cliqr
         #
         # @return [Boolean] <tt>true</tt> if there were any errors during validation
         def do_validate(name, value, errors)
-          errors.add("value '#{value}' of type '#{value.class.name}' for '#{name}' " \
-                     "does not extend from '#{@super_type}'") \
-                         unless value.is_a?(@super_type) || value < @super_type
+          return if value.is_a?(@super_type) || \
+                    (value.respond_to?(:<) ? value < @super_type : value.is_a?(@super_type))
+          errors.add("#{name} of type '#{value.class.name}' " \
+                     "does not extend from '#{@super_type}'")
         end
       end
 
@@ -213,7 +214,13 @@ module Cliqr
           valid = true
           values.each_with_index do |value, index|
             valid = false unless value.valid?
-            value.errors.each { |error| errors.add("#{name}[#{index + 1}] - #{error}") }
+            value.errors.each do |error|
+              if value.name.nil? || value.name.empty?
+                errors.add("#{name}[#{index + 1}] - #{error}")
+              else
+                errors.add("#{name.to_s.gsub(/s$/, '')} \"#{value.name}\" - #{error}")
+              end
+            end
           end
           valid
         end
@@ -238,6 +245,51 @@ module Cliqr
         end
       end
 
+      # Validate the type of a attribute's value
+      class TypeOfValidator < NonNilValidator
+        # Create a new <tt>:type_of</tt> validator
+        def initialize(type)
+          super(true)
+          @type = type
+        end
+
+        protected
+
+        # Run the <tt>:type_of</tt> validation check
+        #
+        # @return [Nothing]
+        def do_validate(name, value, errors)
+          errors.add("#{name} should be a '#{@type}' not '#{value.class}'") \
+            unless value.class == @type
+        end
+      end
+
+      # Run multiple validators on a value to assert at-least one of them passes
+      class OneOfValidator < Validator
+        # Create a new <tt>:one_of</tt> validator
+        def initialize(validators)
+          @validators = validators.map { |type, config| ValidatorFactory.get(type, config) }
+        end
+
+        protected
+
+        # Run each validator one by one until one passes
+        #
+        # @return [Nothing]
+        def do_validate(name, value, errors)
+          local_errors = ValidationErrors.new
+          passing_validator = @validators.find do |validator|
+            validator_errors = ValidationErrors.new.tap do |temp_errors|
+              validator.validate(name, value, temp_errors)
+              local_errors.merge(temp_errors)
+            end
+            validator_errors.empty?
+          end
+          errors.add("invalid value for #{name}; fix one of - [#{local_errors}]") \
+            if passing_validator.nil?
+        end
+      end
+
       # A hash of validator type id to validator class
       VALIDATORS = {
           :non_empty => NonEmptyValidator,
@@ -246,7 +298,9 @@ module Cliqr
           :format => FormatValidator,
           :extend => TypeHierarchyValidator,
           :collection => CollectionValidator,
-          :inclusion => InclusionValidator
+          :inclusion => InclusionValidator,
+          :one_of => OneOfValidator,
+          :type_of => TypeOfValidator
       }
 
       # Get a new validator based on the type and config param