cliqr 0.1.0 → 1.0.0

data/lib/cliqr/cli/executor.rb

@@ -2,8 +2,8 @@
 
 require 'cliqr/cli/router'
 require 'cliqr/cli/command_context'
-require 'cliqr/cli/argument_validator'
-require 'cliqr/cli/parser/argument_parser'
+require 'cliqr/argument_validation/validator'
+require 'cliqr/parser/argument_parser'
 
 module Cliqr
   module CLI
@@ -15,7 +15,7 @@ module Cliqr
       def initialize(config)
         @config = config
         @router = Router.new(config)
-        @validator = ArgumentValidator.new
+        @validator = Cliqr::ArgumentValidation::Validator.new
       end
 
       # Execute the command
@@ -25,10 +25,13 @@ module Cliqr
       #
       # @return [Integer] Exit status of the command execution
       def execute(args, options)
-        command_context = CommandContext.build(parse(args))
-        @router.handle command_context, **options
-      rescue StandardError => e
-        raise Cliqr::Error::CommandRuntimeException.new("command '#{@config.basename}' failed", e)
+        parsed_input = parse(args)
+        begin
+          command_context = CommandContext.build(parsed_input)
+          @router.handle command_context, **options
+        rescue StandardError => e
+          raise Cliqr::Error::CommandRuntimeException.new("command '#{@config.basename}' failed", e)
+        end
       end
 
       private
@@ -37,11 +40,14 @@ module Cliqr
       #
       # @param [Array<String>] args List of arguments that needs to parsed
       #
-      # @return [Hash] Parsed hash of command line arguments
+      # @throws [Cliqr::Error::ValidationError] If the input arguments do not satisfy validation
+      # criteria
+      #
+      # @return [Cliqr::Parser::ParsedInput] Parsed arguments wrapper
       def parse(args)
-        parsed_args = Parser.parse(@config, args)
-        @validator.validate(parsed_args)
-        parsed_args
+        parsed_input = Parser.parse(@config, args)
+        @validator.validate(parsed_input, @config)
+        parsed_input
       end
     end
   end

data/lib/cliqr/cli/interface.rb

@@ -1,9 +1,7 @@
 # encoding: utf-8
 
 require 'cliqr/error'
-
 require 'cliqr/cli/executor'
-require 'cliqr/cli/config_validator'
 
 module Cliqr
   # Definition and builder for command line interface
@@ -79,8 +77,14 @@ module Cliqr
       # Validate and build a cli interface based on the configuration options
       #
       # @return [Cliqr::CLI::Interface]
+      #
+      # @throws [Cliqr::Error::ConfigNotFound] if a config is <tt>nil</tt>
+      # @throws [Cliqr::Error::ValidationError] if the validation for config fails
       def build
-        ConfigValidator.validate @config
+        fail Cliqr::Error::ConfigNotFound, 'a valid config should be defined' if @config.nil?
+        fail Cliqr::Error::ValidationError, \
+             "invalid Cliqr interface configuration - [#{@config.errors}]" unless @config.valid?
+
         Interface.new(@config)
       end
     end

data/lib/cliqr/error.rb

@@ -25,12 +25,19 @@ module Cliqr
       # @return [String] Error message including the cause of the error
       def message
         if cause?
-          "#{@error_message}\n\nCause: #{@cause.class} - #{@cause.message}"
+          "#{@error_message}\n\nCause: #{@cause.class} - #{@cause.message}\n"
         else
           @error_message
         end
       end
 
+      # Get string representation of the error
+      #
+      # @return [String]
+      def to_s
+        message
+      end
+
       private
 
       # Check if there was a nested cause for this error
@@ -42,16 +49,10 @@ module Cliqr
     end
 
     # Raised when the config parameter is nil
-    class ConfigNotFound < StandardError; end
+    class ConfigNotFound < CliqrError; end
 
-    # Raised when basename is not defined
-    class BasenameNotDefined < StandardError; end
-
-    # Raised when a command handler is not defined
-    class HandlerNotDefined < StandardError; end
-
-    # Raised if command handler does not extend from Cliqr::CLI::Command
-    class InvalidCommandHandler < StandardError; end
+    # Signifies that the validation of the configuration settings failed
+    class ValidationError < CliqrError; end
 
     # Encapsulates the error that gets thrown during a command execution
     class CommandRuntimeException < CliqrError; end
@@ -59,12 +60,6 @@ module Cliqr
     # Error to signify that a command's runner is not available
     class UnknownCommandRunnerException < CliqrError; end
 
-    # Raised if config's option array is nil
-    class OptionsNotDefinedException < CliqrError; end
-
-    # Indicates to the user that the command line option is invalid
-    class InvalidCommandOption < CliqrError; end
-
     # Indicates to the user that the command line option is invalid
     class UnknownCommandOption < CliqrError; end
 
@@ -77,10 +72,13 @@ module Cliqr
     # Raised if two options are defined with same long or short name
     class DuplicateOptions < CliqrError; end
 
-    # Raised if an option is not defined properly
-    class InvalidOptionDefinition < CliqrError; end
-
     # Raised if an option is not defined properly
     class InvalidArgumentError < CliqrError; end
+
+    # Raised if an argument does not conform to the option's type
+    class IllegalArgumentError < CliqrError; end
+
+    # Indicates that a unknown validator type is being used in a class
+    class UnknownValidatorType < CliqrError; end
   end
 end

data/lib/cliqr/parser/argument_parser.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'cliqr/parser/argument_tree_walker'
+
+module Cliqr
+  # A set of utility methods and classes used to parse the command line arguments
+  #
+  # @api private
+  module Parser
+    # Parse command line arguments based on [Cliqr::CLI::Config]
+    #
+    # @param [Cliqr::CLI::Config] config Command line configuration
+    # @param [Array<String>] args An array of arguments from command line
+    #
+    # @return [Hash] Parsed hash of command linet arguments
+    def self.parse(config, args)
+      tree_walker = ArgumentTreeWalker.new(config)
+      tree_walker.walk(args)
+    end
+  end
+end

data/lib/cliqr/parser/argument_tree_walker.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'cliqr/parser/parsed_input_builder'
+require 'cliqr/parser/token_factory'
+
+module Cliqr
+  module Parser
+    # Walks the list of arguments and parses them one token at a time
+    #
+    # @api private
+    class ArgumentTreeWalker
+      # Create a new instance
+      #
+      # @param [Cliqr::CLI::Config] config Configuration settings for the command line interface
+      #
+      # @return [Cliqr::CLI::Parser::ArgumentTreeWalker]
+      def initialize(config)
+        @config = config
+      end
+
+      # Parse the arguments and generate tokens by iterating over command line arguments
+      #
+      # @param [Array<String>] args List of arguments that needs to parsed
+      #
+      # @return [Hash] Parsed hash of command line arguments
+      def walk(args)
+        argument_builder = ParsedInputBuilder.new(@config)
+        token_factory = TokenFactory.new(@config)
+        token = token_factory.get_token
+        args.each do |arg|
+          token = handle_argument(arg, token, token_factory)
+          argument_builder.add_token(token) unless token.active?
+        end
+        token.finalize if token.active?
+        argument_builder.build
+      end
+
+      # Handle the next argument in the context of the current token
+      #
+      # @return [Cliqr::CLI::Parser::Token] The new active token in case <tt>current_token</tt>
+      # becomes inactive
+      def handle_argument(arg, current_token, token_factory)
+        if current_token.active?
+          current_token.append(arg)
+        else
+          token_factory.get_token(arg)
+        end
+      end
+    end
+  end
+end

data/lib/cliqr/parser/boolean_option_token.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Cliqr
+  module Parser
+    # Token handler for parsing a boolean option
+    #
+    # @api private
+    class BooleanOptionToken < Token
+      # Create a new option token to store boolean value
+      def initialize(name, arg)
+        super(name, arg)
+        @value = !arg.to_s.start_with?('--no-')
+      end
+
+      # Get the token representation
+      #
+      # @return [Hash] A hash of the option name and its value (<tt>true</tt> or <tt>false</tt>)
+      def build
+        {
+            :name => @name.to_s,
+            :value => @value
+        }
+      end
+    end
+  end
+end

data/lib/cliqr/parser/parsed_input.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+module Cliqr
+  module Parser
+    # A wrapper to keep the parsed input arguments
+    #
+    # @api private
+    class ParsedInput
+      # Command name
+      #
+      # @return [String]
+      attr_accessor :command
+
+      # Hash of options parsed from the command line
+      #
+      # @return [Hash]
+      attr_accessor :options
+
+      # Initialize a new parsed input
+      def initialize(parsed_arguments)
+        @command = parsed_arguments[:command]
+
+        @options = Hash[parsed_arguments[:options].collect \
+            { |option| [option[:name], option[:value]] }
+          ]
+      end
+
+      # Get a value of an option
+      #
+      # @param [String] name Name of the option
+      #
+      # @return [String]
+      def option(name)
+        @options[name]
+      end
+
+      # Test equality with another object
+      #
+      # @return [Boolean] <tt>true</tt> if this object is equal to <tt>other</tt>
+      def eql?(other)
+        self.class.equal?(other.class) &&
+          @command == other.command &&
+          @options == other.options
+      end
+
+      # Test equality with another object
+      #
+      # @return [Boolean] <tt>true</tt> if this object is equal to <tt>other</tt>
+      def ==(other)
+        eql?(other)
+      end
+    end
+  end
+end

data/lib/cliqr/parser/parsed_input_builder.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'cliqr/parser/parsed_input'
+
+module Cliqr
+  module Parser
+    # Builder for collecting parsed command line arguments that can be used to
+    # build a command context
+    #
+    # @api private
+    class ParsedInputBuilder
+      # Initialize a new instance
+      #
+      # @param [Cliqr::CLI::Config] config Configuration settings for the command line interface
+      #
+      # @return [Cliqr::CLI::Parser::ParsedInputBuilder]
+      def initialize(config)
+        @config = config
+        @options = []
+        @option_names = Set.new
+      end
+
+      # Add a new parsed token from the list of arguments
+      #
+      # @param [Cliqr::CLI::Parser::Token] token A parsed token from command line arguments
+      #
+      # @return [Boolean] <tt>true</tt> if the token was added
+      def add_token(token)
+        return false unless token.valid?
+
+        add_option_name(token)
+        @options.push(token.build)
+        true
+      end
+
+      # Build the hash of parsed command line arguments
+      #
+      # @return [Cliqr::Parser::ParsedInput] Parsed arguments wrapper
+      def build
+        ParsedInput.new(:command => @config.basename,
+                        :options => @options)
+      end
+
+      private
+
+      # Add option's name to a list of already added options and fail if duplicate
+      #
+      # @param [Cliqr::CLI::Parser::Token] token A parsed token from command line arguments
+      #
+      # @return [Set<String>] Current list of option names
+      def add_option_name(token)
+        option_config = @config.option(token.name)
+        old_config = @option_names.add?(option_config.name)
+        fail Cliqr::Error::MultipleOptionValues,
+             "multiple values for option \"#{token.arg}\"" if old_config.nil?
+        @option_names.add(option_config.short) if option_config.short?
+        @option_names
+      end
+    end
+  end
+end

data/lib/cliqr/parser/single_valued_option_token.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Cliqr
+  module Parser
+    # Token handler for parsing a option and its value
+    #
+    # @api private
+    class SingleValuedOptionToken < Token
+      # Create a new option token. Initial state will be <tt>active</tt>
+      def initialize(name, arg)
+        super(name, arg)
+        @value = nil
+        @active = true
+      end
+
+      # Check if the token handler is active and needs more arguments
+      #
+      # @return [Boolean] <tt>true</tt> if the token handler is active
+      def active?
+        @active
+      end
+
+      # Append the next argument in the series and set token to inactive
+      #
+      # @param [String] arg Argument value of the next command line parameter
+      #
+      # @return [Cliqr::Parser::SingleValuedOptionToken]
+      def append(arg)
+        @value = arg
+        @active = false
+        self
+      end
+
+      # Get the token representation
+      #
+      # @return [Hash] Token name and value in a hash
+      def build
+        {
+            :name => @name.to_s,
+            :value => @value
+        }
+      end
+
+      # Called if this token handler was still active once the argument list ends
+      #
+      # @return [Cliqr::CLI::Parser::OptionToken] Current instance object
+      def finalize
+        # should not be called
+        fail Cliqr::Error::OptionValueMissing, "a value must be defined for option \"#{@arg}\""
+      end
+    end
+  end
+end

data/lib/cliqr/parser/token.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Cliqr
+  module Parser
+    # A NO-OP argument token
+    #
+    # @api private
+    class Token
+      # Name of the option token
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # Argument that was used to parse the option name from
+      #
+      # @return [String]
+      attr_accessor :arg
+
+      # Create a new option token
+      #
+      # @param [String] name Long name of the option
+      # @param [String] arg Value of the option
+      #
+      # @return [Cliqr::CLI::Parser::OptionToken] A new Token instance
+      def initialize(name = nil, arg = nil)
+        @name = name
+        @arg = arg
+      end
+
+      # This token is never active
+      #
+      # @return [Boolean] This will always return <tt>false</tt> in this case
+      def active?
+        false
+      end
+
+      # A token is not valid if it does not have a name
+      #
+      # @return [Boolean] <tt>false</tt> if the token's name is nil
+      def valid?
+        !@name.nil?
+      end
+    end
+  end
+end