cliqr 1.2.0 → 2.0.0

data/lib/cliqr/{cli → command}/command_context.rb

@@ -1,14 +1,23 @@
 # encoding: utf-8
 
-require 'cliqr/cli/argument_operator_context'
+require 'cliqr/command/color'
+require 'cliqr/command/argument_operator_context'
+require 'cliqr/events/invoker'
 
 module Cliqr
   # Definition and builder for command context
-  module CLI
+  module Command
     # Manages things like arguments and input/output for a command
     #
     # @api private
     class CommandContext
+      include Cliqr::Command::Color
+
+      # Base command name
+      #
+      # @return [String]
+      attr_accessor :base_command
+
       # Command name
       #
       # @return [String]
@@ -24,29 +33,37 @@ module Cliqr
       # @return [String]
       attr_accessor :action_name
 
+      # Environment type
+      #
+      # @return [String]
+      attr_reader :environment
+
       # Build a instance of command context based on the parsed set of arguments
       #
-      # @param [Cliqr::CLI::Config] config The configuration settings for command's action config
+      # @param [Cliqr::Config::Command] config The configuration settings
       # @param [Cliqr::Parser::ParsedInput] parsed_input Parsed input object
       # @param [Hash] options Options for command execution
       # @param [Proc] executor Executes forwarded commands
       #
-      # @return [Cliqr::CLI::CommandContext]
+      # @return [Cliqr::Command::CommandContext]
       def self.build(config, parsed_input, options, &executor)
         CommandContextBuilder.new(config, parsed_input, options, executor).build
       end
 
       # Initialize the command context (called by the CommandContextBuilder)
       #
-      # @return [Cliqr::CLI::CommandContext]
+      # @return [Cliqr::Command::CommandContext]
       def initialize(config, options, arguments, environment, executor)
+        super(config)
+
         @config = config
+        @base_command = config.root.name
         @command = config.command
         @arguments = arguments
         @action_name = config.name
-        @context = self
         @environment = environment
         @executor = executor
+        @event_invoker = Events::Invoker.new(config, self)
 
         # make option map from array
         @options = Hash[*options.collect { |option| [option.name, option] }.flatten]
@@ -54,22 +71,22 @@ module Cliqr
 
       # List of parsed options
       #
-      # @return [Array<Cliqr::CLI::CommandOption>]
+      # @return [Array<Cliqr::Command::CommandOption>]
       def options
         @options.values
       end
 
-      # Get a option by name
+      # Get an option by name
       #
       # @param [String] name Name of the option
       #
-      # @return [Cliqr::CLI::CommandOption] Instance of CommandOption for option
+      # @return [Cliqr::Command::CommandOption] Instance of CommandOption for option
       def option(name)
         return @options[name] if option?(name)
         default(name)
       end
 
-      # Check if a option with a specified name has been passed
+      # Check if an option with a specified name has been passed
       #
       # @param [String] name Name of the option
       #
@@ -78,10 +95,17 @@ module Cliqr
         @options.key?(name)
       end
 
-      # Check whether the current context is based off of a sub-action
+      # Check whether a action is valid in current context
+      #
+      # @param [String] name Name of the action to check
       #
-      # @return [Boolean] <tt>true</tt> if this context is based off a sub-action
-      def action?
+      # @return [Boolean] <tt>true</tt> if this context has the requested action
+      def action?(name)
+        @config.action?(name)
+      end
+
+      # Check if the current context if for a action
+      def action_type?
         @config.parent?
       end
 
@@ -92,10 +116,24 @@ module Cliqr
         @executor.call(args, options)
       end
 
+      # Invoke an event
+      #
+      # @return [Boolean] <tt>true</tt> if the event was handled by any event handler
+      def invoke(event_name, *args)
+        @event_invoker.invoke(event_name, nil, *args)
+      end
+
       # Handle the case when a method is invoked to get an option value
       #
       # @return [Object] Option's value
       def method_missing(name, *_args, &_block)
+        get_or_check_option(name)
+      end
+
+      # Get option value or check if it exists
+      #
+      # @return [Object]
+      def get_or_check_option(name)
         option_name = name.to_s.chomp('?')
         existence_check = name.to_s.end_with?('?')
         existence_check ? option?(option_name) : option(option_name).value \
@@ -114,7 +152,17 @@ module Cliqr
       #
       # @return [Boolean]
       def bash?
-        @environment == :bash
+        @environment == :cli
+      end
+
+      # Transform this context to the root context
+      #
+      # @param [Symbol] environment_type Optional environment type
+      #
+      # @return [Cliqr::Command::CommandContext]
+      def root(environment_type = nil)
+        environment_type = @environment if environment_type.nil?
+        CommandContext.new(@config.root, [], [], environment_type, @executor)
       end
 
       private :initialize, :default
@@ -128,12 +176,12 @@ module Cliqr
     class CommandContextBuilder
       # Initialize builder for CommandContext
       #
-      # @param [Cliqr::CLI::Config] config The configuration settings for command's action config
+      # @param [Cliqr::Command::Config] config The configuration settings
       # @param [Cliqr::Parser::ParsedInput] parsed_input Parsed and validated command line arguments
       # @param [Hash] options Options for command execution
       # @param [Proc] executor Executes forwarded commands
       #
-      # @return [Cliqr::CLI::CommandContextBuilder]
+      # @return [Cliqr::Command::CommandContextBuilder]
       def initialize(config, parsed_input, options, executor)
         @config = config
         @parsed_input = parsed_input
@@ -143,7 +191,7 @@ module Cliqr
 
       # Build a new instance of CommandContext
       #
-      # @return [Cliqr::CLI::CommandContext] A newly created CommandContext instance
+      # @return [Cliqr::Command::CommandContext] A newly created CommandContext instance
       def build
         option_contexts = @parsed_input.options.map do |option|
           CommandOption.new(option, @config.option(option.first))
@@ -174,9 +222,9 @@ module Cliqr
       # Create a new command line option instance
       #
       # @param [Array] option Parsed arguments for creating a command line option
-      # @param [Cliqr::CLI::OptionConfig] option_config Option's config settings
+      # @param [Cliqr::Config::Option] option_config Option's config settings
       #
-      # @return [Cliqr::CLI::CommandContext] A new CommandOption object
+      # @return [Cliqr::Command::CommandContext] A new CommandOption object
       def initialize(option, option_config)
         @value = run_value_operator(option.pop, option_config.operator)
         @name = option.pop
@@ -189,7 +237,7 @@ module Cliqr
       # @return [Nothing]
       def run_value_operator(value, operator)
         if operator.is_a?(Proc)
-          ArgumentOperatorContext.new(value).instance_eval(&operator)
+          Command::ArgumentOperatorContext.new(value).instance_eval(&operator)
         else
           operator.operate(value)
         end

data/lib/cliqr/command/shell_banner_builder.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Cliqr
+  module Command
+    # Used to build a banner string for shell
+    #
+    # @api private
+    class ShellBannerBuilder
+      # Build the banner based on current context
+      #
+      # @return [String]
+      def build(context)
+        "Starting shell for command \"#{context.command}\""
+      end
+    end
+  end
+end

data/lib/cliqr/command/shell_command.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+module Cliqr
+  # @api private
+  module Command
+    # The default command executed to run a shell action
+    #
+    # @api private
+    class ShellCommand < Cliqr::Command::BaseCommand
+      # Create a new shell command handler
+      def initialize(shell_config)
+        @shell_config = shell_config
+      end
+
+      # Start a shell in the context of some other command
+      #
+      # @return [Integer] Exit code
+      def execute(context)
+        validate_environment(context)
+
+        root_context = context.root(:shell)
+
+        puts banner(root_context, build_proc(@shell_config.banner))
+
+        context.invoke(:shell_start)
+        exit_code = build_runner(context, root_context).run
+        context.invoke(:shell_stop)
+        puts "shell exited with code #{exit_code}"
+        exit_code
+      end
+
+      private
+
+      # Build an instance of the ShellRunner
+      #
+      # @return [Cliqr::Command::ShellRunner]
+      def build_runner(context, root_context)
+        ShellRunner.new(context.base_command,
+                        root_context,
+                        build_proc(@shell_config.prompt))
+      end
+
+      # Make sure a shell cannot be run inside an already running shell
+      #
+      # @return Nothing
+      def validate_environment(context)
+        fail(Cliqr::Error::IllegalCommandError,
+             'Cannot run another shell within an already running shell') unless context.bash?
+      end
+
+      # Banner string for current command
+      #
+      # @return [String]
+      def banner(context, block)
+        context.instance_eval(&block)
+      end
+
+      # Build an anonymous method to wrap an attribute value
+      #
+      # @return [Proc]
+      def build_proc(value)
+        if value.is_a?(String)
+          proc { value }
+        elsif value.is_a?(Proc)
+          return value
+        else
+          builder = value
+          builder = value.new if value.is_a?(Class)
+          proc do
+            builder.build(self)
+          end
+        end
+      end
+    end
+
+    private
+
+    # The runner for shell command
+    class ShellRunner
+      # Create the runner instance
+      def initialize(base_command, context, prompt)
+        @base_command = base_command
+        @context = context
+        @prompt = prompt
+      end
+
+      # Start shell
+      #
+      # @return [Integer] Exit code
+      def run
+        loop do
+          command = prompt
+          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)
+        return if command.empty?
+        action_name = command.split(' ').first
+        unless @context.action?(action_name)
+          puts "unknown action \"#{action_name}\""
+          return Cliqr::Executor::ExitCode.code(nil)
+        end
+        @context.forward("#{@base_command} #{command}", :environment => @context.environment)
+      rescue StandardError => e
+        puts e.message
+      end
+
+      # Show a prompt and ask for input
+      #
+      # @return [String]
+      def prompt
+        print @context.instance_eval(&@prompt)
+        $stdin.gets.chomp
+      end
+    end
+  end
+end

data/lib/cliqr/command/shell_prompt_builder.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Cliqr
+  module Command
+    # Builds a shell prompt
+    #
+    # @api private
+    class ShellPromptBuilder
+      include Cliqr::Command::Color
+
+      # Create a new shell prompt builder with optional command config
+      def initialize(config = nil)
+        super
+        @count = 0
+      end
+
+      # Build a prompt for current command
+      #
+      # @return [String]
+      def build(context)
+        @count += 1
+        "[#{cyan(context.command)}][#{@count}] #{bold('$')} "
+      end
+    end
+  end
+end

data/lib/cliqr/config/action.rb

@@ -0,0 +1,226 @@
+# encoding: utf-8
+
+require 'cliqr/util'
+require 'cliqr/command/base_command'
+require 'cliqr/config/base'
+require 'cliqr/config/option_based'
+
+module Cliqr
+  module Config
+    # Configuration setting for an action
+    #
+    # @api private
+    class Action < Cliqr::Config::OptionBased
+      # Command handler for the base command
+      #
+      # @return [Class<Cliqr::Command::BaseCommand>]
+      attr_accessor :handler
+      validates :handler,
+                one_of: [
+                  { extend: Cliqr::Command::BaseCommand },
+                  { type_of: Proc }
+                ]
+
+      #  Dictates whether this command can take arbitrary arguments (optional)
+      #
+      # @return [Symbol] Either <tt>#ENABLE_CONFIG</tt> or <tt>#DISABLE_CONFIG</tt>
+      attr_accessor :arguments
+      validates :arguments,
+                inclusion: [ENABLE_CONFIG, DISABLE_CONFIG]
+
+      # Array of children action configs for this action
+      #
+      # @return [Array<Cliqr::CLI::Config>]
+      attr_accessor :actions
+      validates :actions,
+                collection: true
+
+      # Enable or disable help command and option
+      #
+      # @return [Symbol] Either <tt>#ENABLE_CONFIG</tt> or <tt>#DISABLE_CONFIG</tt>
+      attr_accessor :help
+      validates :help,
+                inclusion: [ENABLE_CONFIG, DISABLE_CONFIG]
+
+      # Parent configuration
+      #
+      # @return [Cliqr::Config::CommandConfig]
+      attr_accessor :parent
+
+      # New config instance with all attributes set as UNSET
+      def initialize
+        super
+
+        @handler = UNSET
+        @arguments = UNSET
+        @help = UNSET
+
+        @actions = []
+        @action_index = {}
+      end
+
+      # Finalize config by adding default values for unset values
+      #
+      # @return [Cliqr::Config::Action]
+      def finalize
+        super
+
+        @handler = Util.ensure_instance(Config.get_if_unset(@handler, nil))
+        @arguments = Config.get_if_unset(@arguments, ENABLE_CONFIG)
+        @help = Config.get_if_unset(@help, ENABLE_CONFIG)
+
+        self
+      end
+
+      # Set up default attributes for this configuration
+      #
+      # @return [Cliqr::Config::Command] Update config
+      def setup_defaults
+        add_help
+        @handler = Cliqr::Util.forward_to_help_handler if @handler.nil? && help? && actions?
+        @actions.each(&:setup_defaults)
+      end
+
+      # Set value for a config option
+      #
+      # @param [Symbol] name Name of the config parameter
+      # @param [Object] value Value for the config parameter
+      # @param [Proc] block Function which populates configuration for a sub-attribute
+      #
+      # @return [Object] if setting a attribute's value
+      # @return [Cliqr::Config::Base] if adding a new action or option
+      def set_config(name, value, *args, &block)
+        case name
+        when :action
+          handle_action(value, &block) # value is action's name
+        else
+          super
+        end
+      end
+
+      # Check if particular action exists
+      #
+      # @param [String] name Name of the action to check
+      #
+      # @return [Boolean] <tt>true</tt> if the action exists in the configuration
+      def action?(name)
+        return false if name.nil?
+        @action_index.key?(name.to_sym)
+      end
+
+      # Check if this config has sub actions
+      #
+      # @return [Boolean]
+      def actions?
+        !@actions.empty?
+      end
+
+      # Get action config by name
+      #
+      # @param [String] name Name of the action
+      #
+      # @return [Cliqr::Config::Action] Configuration of the action
+      def action(name)
+        @action_index[name.to_sym]
+      end
+
+      # Check if arguments are enabled for this configuration
+      #
+      # @return [Boolean] <tt>true</tt> if arguments are enabled
+      def arguments?
+        @arguments == ENABLE_CONFIG
+      end
+
+      # Get name of the command along with the action upto this config
+      #
+      # @return [String] Serialized command name
+      def command
+        return name unless parent?
+        "#{@parent.command} #{name}"
+      end
+
+      # Check if this config has a parent config
+      #
+      # @return [Boolean] <tt>true</tt> if there exists a parent action for this action
+      def parent?
+        !@parent.nil?
+      end
+
+      # Check if help is enabled for this command
+      #
+      # @return [Boolean] <tt>true</tt> if help is enabled
+      def help?
+        @help == ENABLE_CONFIG
+      end
+
+      # The root of action config is itself unless otherwise configured
+      #
+      # @return [Cliqr::Config::Action]
+      def root
+        self
+      end
+
+      # Check if this action is the root
+      def root?
+        self == root
+      end
+
+      private
+
+      # Handle configuration for a new action
+      #
+      # @param [String] name Name of the action
+      # @param [Function] block The block which configures this action
+      #
+      # @return [Cliqr::Config::Action] The newly configured action
+      def handle_action(name, &block)
+        action_config = Action.build(&block)
+        action_config.name = name
+        add_action(action_config)
+      end
+
+      # Add a new action
+      #
+      # @return [Cliqr::Config::Action] The newly added action
+      def add_action(action_config)
+        parent = self
+        action_config.parent = parent
+        action_config.instance_eval do
+          def root
+            parent.root
+          end
+        end
+
+        validate_action_name(action_config)
+
+        @actions.push(action_config)
+        @action_index[action_config.name.to_sym] = action_config \
+          unless action_config.name.nil?
+
+        action_config
+      end
+
+      # Make sure that the action's name is unique
+      #
+      # @param [Cliqr::Config::Action] action_config Config for this particular action
+      #
+      # @return [Cliqr::Config::Action] Validated action's Config instance
+      def validate_action_name(action_config)
+        fail Cliqr::Error::DuplicateActions,
+             "multiple actions named \"#{action_config.name}\"" \
+             if action?(action_config.name)
+
+        action_config
+      end
+
+      # Add help command and option to this config
+      #
+      # @return [Cliqr::Config::Base] Updated config
+      def add_help
+        return self unless help?
+        add_action(Cliqr::Util.build_help_action(self)) unless action?('help')
+        add_option(Cliqr::Util.build_help_option(self)) unless option?('help')
+      end
+    end
+  end
+end