cliqr 1.2.0 → 2.0.0

data/lib/cliqr/cli/interface.rb

@@ -1,107 +0,0 @@
-# encoding: utf-8
-
-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
-    class Interface
-      # Command line interface configuration
-      #
-      # @return [Cliqr::CLI::Config]
-      attr_accessor :config
-
-      # Create a new interface instance with a config
-      #
-      # @param [Cliqr::CLI::Config] config Config used to create this interface
-      def initialize(config)
-        @config = config
-        @executor = Executor.new(config)
-      end
-
-      # Get usage information of this command line interface instance
-      #
-      # @return [String] Defines usage of this interface
-      def usage
-        UsageBuilder.build(config)
-      end
-
-      # Execute a command
-      #
-      # @param [Array<String>] args Arguments that will be used to execute the command
-      # @param [Hash] options Options for command execution
-      #
-      # @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,
-            :environment => :bash
-        }.merge(options)
-        @executor.execute(args, options)
-      end
-
-      # Invoke the builder method for [Cliqr::CLI::Interface]
-      #
-      # @param [Cliqr::CLI::Config] config Instance of the command line config
-      #
-      # @return [Cliqr::CLI::Interface]
-      def self.build(config)
-        InterfaceBuilder.new(config).build
-      end
-    end
-
-    private
-
-    # Builder for [Cliqr::CLI::Interface]
-    #
-    # @api private
-    class InterfaceBuilder
-      # Start building a command line interface
-      #
-      # @param [Cliqr::CLI::Config] config the configuration options for the
-      # interface (validated using CLI::Validator)
-      #
-      # @return [Cliqr::CLI::ConfigBuilder]
-      def initialize(config)
-        @config = config
-      end
-
-      # 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
-        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
-  end
-end

data/lib/cliqr/cli/shell_command.rb

@@ -1,69 +0,0 @@
-# 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

@@ -1,185 +0,0 @@
-# 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/validation_set.rb

@@ -1,48 +0,0 @@
-# encoding: utf-8
-
-require 'cliqr/config_validation/validator_factory'
-
-module Cliqr
-  module ConfigValidation
-    # A collection of configured validators
-    #
-    # @api private
-    class ValidationSet
-      # Initialize a new instance of validation set
-      def initialize
-        @validations = {}
-      end
-
-      # Add a new validator
-      #
-      # @param [Symbol] name Name of the validator
-      # @param [Object] options Configuration option to initialize the validator
-      #
-      # @return [Hash] A map of all validators
-      def add(name, options)
-        @validations[name] = \
-          Hash[options.map { |type, config| [type, ValidatorFactory.get(type, config)] }]
-      end
-
-      # Iterate over each type of validators
-      #
-      # @return [Object]
-      def each_key(&block)
-        @validations.each_key(&block)
-      end
-
-      # Run the validators for a attribute against its value
-      #
-      # @param [Symbol] attribute Name of the attribute
-      # @param [Object] value Value of the attribute
-      # @param [Cliqr::Validation::Errors] errors A collection wrapper for all validation errors
-      #
-      # @return [Array] All validators that ran for the attribute against the value
-      def validate(attribute, value, errors)
-        @validations[attribute].values.each do |validator|
-          validator.validate(attribute, value, errors)
-        end
-      end
-    end
-  end
-end

data/lib/cliqr/config_validation/validator_factory.rb

@@ -1,319 +0,0 @@
-# encoding: utf-8
-
-module Cliqr
-  module ConfigValidation
-    # A factory class to retrieve a attribute validator based on the configuration type
-    #
-    # @api private
-    module ValidatorFactory
-      # Does not validates anything, used by default if a unknown validator type is used
-      class Validator
-        # Run this validator against an attribute value
-        #
-        # @param [String] name Name of the attribute
-        # @param [Object] value Value of the attribute
-        # @param [Cliqr::ValidationErrors] errors Errors after validation finished
-        #
-        # @return [Boolean] <tt>true</tt> if validation passed
-        def validate(name, value, errors)
-          validation_sequence(name, value, errors)
-        end
-
-        private
-
-        # Recursively validate using parent validator then apply itself
-        #
-        # @return [Boolean] <tt>true</tt> if validation passed
-        def validation_sequence(name, value, errors)
-          return false unless validate_parent(name, value, errors)
-
-          local_errors = ValidationErrors.new
-          @class_stack.last.instance_method(:do_validate).bind(self).call(name, value, local_errors)
-          errors.merge(local_errors)
-          local_errors.empty?
-        end
-
-        # Validate attribute using the parent validator's logic
-        #
-        # @return [Boolean] <tt>true</tt> if parent class' validation passed
-        def validate_parent(name, value, errors)
-          @class_stack = (@class_stack || [self.class])
-          parent_class = (@class_stack.last || self.class).superclass
-          @class_stack.push(parent_class)
-          begin
-            return parent_class.instance_method(:validate).bind(self) \
-              .call(name, value, errors) if parent_class < Validator
-            true
-          ensure
-            @class_stack.pop
-          end
-        end
-      end
-
-      # This is used in case a unknown validation is used
-      class NOOPValidator < Validator
-        # Initialize a new no-op validator
-        def initialize(type)
-          @type = type
-        end
-
-        protected
-
-        # Fails if invoked
-        #
-        # @return [Object]
-        def do_validate(_name, _value, _errors)
-          fail Cliqr::Error::UnknownValidatorType, "unknown validation type: '#{@type}'"
-        end
-      end
-
-      # Verifies that an attribute's value is non-nil
-      class NonNilValidator < Validator
-        # Initialize a new non-nil validator
-        def initialize(enabled)
-          @enabled = enabled
-        end
-
-        protected
-
-        # Validate presence of an attribute's value
-        #
-        # @return [Cliqr::ValidationErrors] Errors after the validation has finished
-        def do_validate(name, value, errors)
-          errors.add("'#{name}' cannot be nil") if @enabled && value.nil?
-          errors
-        end
-      end
-
-      # Verifies that an attribute's value is non-empty
-      class NonEmptyValidator < NonNilValidator
-        # Create a new non-empty validator
-        def initialize(enabled)
-          super(enabled)
-          @enabled = enabled
-        end
-
-        protected
-
-        # Validate that a attribute's value is not empty
-        #
-        # @return [Cliqr::ValidationErrors] Errors after the validation has finished
-        def do_validate(name, value, errors)
-          errors.add("'#{name}' cannot be empty") \
-            if @enabled && value.respond_to?(:empty?) && value.empty?
-          errors
-        end
-      end
-
-      # Validates the value of an attribute against a regex pattern
-      class FormatValidator < NonNilValidator
-        # Initialize a new format validator
-        #
-        # @param [Regex] format Format of the value to validate required
-        def initialize(format)
-          super(true)
-          @format = format
-        end
-
-        protected
-
-        # Run the format validator to check attribute value's format
-        #
-        # @return [Boolean] <tt>true</tt> if there were any errors during validation
-        def do_validate(name, value, errors)
-          errors.add("value for '#{name}' must match /#{@format.source}/; " \
-                     "actual: #{value.inspect}") \
-              if !value.nil? && @format.match(value).nil?
-          errors
-        end
-      end
-
-      # Validates that a value matches a pattern and it is not empty
-      class NonEmptyFormatValidator < NonEmptyValidator
-        # Initialize a new non-empty format validator
-        #
-        # @param [Regex] format Format of the value to validate required
-        def initialize(format)
-          super(true)
-          @format = format
-        end
-
-        protected
-
-        # Run the format validator along with non-empty check
-        #
-        # @return [Boolean] <tt>true</tt> if there were any errors during validation
-        def do_validate(name, value, errors)
-          FormatValidator.new(@format).validate(name, value, errors)
-        end
-      end
-
-      # Validates that a value matches a pattern and it is not empty; nil value allowed
-      class NonEmptyNilOkFormatValidator < Validator
-        # Initialize a new non-empty-nil-ok format validator
-        #
-        # @param [Regex] format Format of the value to validate required
-        def initialize(format)
-          @format = format
-        end
-
-        protected
-
-        # Run the validator
-        #
-        # @return [Boolean] <tt>true</tt> if there were any errors during validation
-        def do_validate(name, value, errors)
-          unless value.nil?
-            local_errors = ValidationErrors.new
-            local_errors.add("'#{name}' cannot be empty") \
-              if value.respond_to?(:empty?) && value.empty?
-            FormatValidator.new(@format).validate(name, value, local_errors) \
-              if local_errors.empty?
-            errors.merge(local_errors)
-          end
-          errors
-        end
-      end
-
-      # Validates that the value of an attribute is of a type that extends from another
-      class TypeHierarchyValidator < NonNilValidator
-        # Create a new instance of type hierarchy validator
-        #
-        # @param [Class] super_type Class reference that the validated variable must extend from
-        def initialize(super_type)
-          super(true)
-          @super_type = super_type
-        end
-
-        protected
-
-        # Check if the type of <tt>value</tt> is extensible from a <tt>super_type</tt>
-        #
-        # @return [Boolean] <tt>true</tt> if there were any errors during validation
-        def do_validate(name, value, errors)
-          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
-
-      # Validates each element inside a collection
-      class CollectionValidator < TypeHierarchyValidator
-        # Create a new collection validator
-        def initialize(_config)
-          super(Array)
-        end
-
-        protected
-
-        # Validate each element inside a collection and prepend index to error
-        #
-        # @return [Boolean] <tt>true</tt> if there were any errors during validation
-        def do_validate(name, values, errors)
-          valid = true
-          values.each_with_index do |value, index|
-            valid = false unless value.valid?
-            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
-      end
-
-      # Validate that a attribute value is included in a predefined set
-      class InclusionValidator < NonNilValidator
-        # Create a new inclusion validator
-        #
-        # @param [Array<Symbol>] allowed_values A set of allowed values
-        def initialize(allowed_values)
-          @allowed_values = allowed_values
-        end
-
-        protected
-
-        # Validate that a value is included in <tt>allowed_values</tt>
-        #
-        # @return [Nothing]
-        def do_validate(_name, value, errors)
-          errors.add("invalid type '#{value}'") unless @allowed_values.include?(value)
-        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,
-          :non_empty_format => NonEmptyFormatValidator,
-          :non_empty_nil_ok_format => NonEmptyNilOkFormatValidator,
-          :format => FormatValidator,
-          :extend => TypeHierarchyValidator,
-          :collection => CollectionValidator,
-          :inclusion => InclusionValidator,
-          :one_of => OneOfValidator,
-          :type_of => TypeOfValidator
-      }
-
-      # Get a new validator based on the type and config param
-      #
-      # @return [Cliqr::Validation::ValidatorFactory::Validator]
-      def self.get(validator_type, config)
-        validator_class = VALIDATORS[validator_type]
-        if validator_class.nil?
-          NOOPValidator.new(validator_type)
-        else
-          validator_class.new(config)
-        end
-      end
-    end
-  end
-end