eac_cli 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d373480947d50978fb88bb6e55a1296d644fcae95eb3b39a7a4127250cf14e2
-  data.tar.gz: 350598588e6cb04bf5fca9cc626f8a1d662167dc5dee9fbc60bd231e2279aa0b
+  metadata.gz: 607e900ac4f5c7b6e7531c4ce9f9f6cfc8fd8ffce30f7b4d2a22ff91cdfd99bb
+  data.tar.gz: 0f49af96a89a527390ba34d2e6ecc17d2942aea7200bebbab1ba1f540398f413
 SHA512:
-  metadata.gz: 074cf7d6fe38050884bb0578d1dcd6a7b02bb384d0634bfec15d8d53b03945dc789bf7654aba4a491145e4c9bb8a7366e1a2a799ce00709e0af2940ca97004ba
-  data.tar.gz: 4da66cb205f1e58cb0c4fffb491d0d4e7aa38f7a6eeb7d7d67caa7c0f0e2177e2e98366639de29f9e588fc329c21051334d6696515e1c82711d1b2b8ec6e95b7
+  metadata.gz: 1e2a23e42fb5df31819b499f8dc1448f6ecc9d095fc22c9a0ceabe1acadf9ba6398a62d04a09943b233feeeb5e07325f62069ee883fb388b29424e7656ebe500
+  data.tar.gz: 1fefcf204e43d2ccfcf45c8507be13be885d46da72f0d6eda2ea3c3e6b7b845592e3ed989fc29b8c687a3727b795f8ea3a2d2a6526c3cda61bbf6b6f7da8df86

data/lib/eac_cli/definition.rb

@@ -8,6 +8,10 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     require_sub __FILE__
+
+    SUBCOMMAND_NAME_ARG = 'subcommand'
+    SUBCOMMAND_ARGS_ARG = 'subcommand_args'
+
     attr_accessor :description
     attr_accessor :options_argument
 
@@ -50,15 +54,27 @@ module EacCli
     end
 
     def pos_arg(name, arg_options = {})
-      positional << ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+      raise 'Positional arguments are blocked' if positional_arguments_blocked?
+
+      pos_set << ::EacCli::Definition::PositionalArgument.new(name, arg_options)
     end
 
     def positional
-      @positional ||= []
+      pos_set.to_a
+    end
+
+    def positional_arguments_blocked?
+      pos_set.any? { |e| e.optional? || e.repeat? }
     end
 
     def subcommands
-      positional << ::EacCli::Definition::PositionalArgument.new('subcommand', subcommand: true)
+      pos_arg(SUBCOMMAND_NAME_ARG, subcommand: true)
+      pos_set << ::EacCli::Definition::PositionalArgument.new(SUBCOMMAND_ARGS_ARG,
+                                                              optional: true, repeat: true)
+    end
+
+    def subcommands?
+      pos_set.any?(&:subcommand?)
     end
 
     def options_first(enable = true)
@@ -68,5 +84,11 @@ module EacCli
     def options_first?
       @options_first ? true : false
     end
+
+    private
+
+    def pos_set
+      @pos_set ||= []
+    end
   end
 end

data/lib/eac_cli/definition/base_option.rb

@@ -5,19 +5,35 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     class BaseOption
+      DEFAULT_REQUIRED = false
+
+      enable_listable
+      lists.add_symbol :option, :optional, :usage, :required
       attr_reader :short, :long, :description, :options
 
       def initialize(short, long, description, options = {})
         @short = short
         @long = long
         @description = description
-        @options = options.with_indifferent_access
+        @options = options.symbolize_keys
+        @options.assert_valid_keys(::EacCli::Definition::BaseOption.lists.option.values)
       end
 
       def identifier
         long.to_s.variableize.to_sym
       end
 
+      def required?
+        return true if options.key?(:required) && options.fetch(:required)
+        return false if options.key?(:optional) && options.fetch(:optional)
+
+        DEFAULT_REQUIRED
+      end
+
+      def to_s
+        "#{self.class.name.demodulize}[#{identifier}]"
+      end
+
       def show_on_usage?
         options[:usage]
       end

data/lib/eac_cli/definition/positional_argument.rb

@@ -5,22 +5,26 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     class PositionalArgument
-      common_constructor :name, :options, default: [{}]
+      enable_listable
+      lists.add_symbol :option, :optional, :repeat, :subcommand
+      common_constructor :name, :options, default: [{}] do
+        options.assert_valid_keys(self.class.lists.option.values)
+      end
 
       def identifier
         name.to_s.variableize.to_sym
       end
 
       def optional?
-        options[:optional]
+        options[OPTION_OPTIONAL]
       end
 
       def repeat?
-        options[:repeat]
+        options[OPTION_REPEAT]
       end
 
       def subcommand?
-        options[:subcommand]
+        options[OPTION_SUBCOMMAND]
       end
     end
   end

data/lib/eac_cli/docopt/runner_extension.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'eac_cli/docopt/doc_builder'
+require 'eac_cli/runner'
 require 'eac_ruby_utils/console/docopt_runner'
 
 module EacCli

data/lib/eac_cli/parser/collector.rb

@@ -31,6 +31,10 @@ module EacCli
         end
       end
 
+      def supplied?(option)
+        data[option].present?
+      end
+
       private
 
       def data

data/lib/eac_cli/parser/options_collection.rb

@@ -14,18 +14,40 @@ module EacCli
       common_constructor(:definition, :argv, :collector) { collect }
       attr_reader :arguments
 
+      def options_first?
+        definition.options_first? || definition.subcommands?
+      end
+
       private
 
+      def check_required_options
+        definition.options.each do |option|
+          next unless option.required?
+          next if collector.supplied?(option)
+
+          raise ::EacCli::Parser::Error.new(
+            definition, argv, "Option \"#{option}\" is required and a value was not supplied"
+          )
+        end
+      end
+
       def collect
         build_banner
         build_options
-        @arguments = option_parser.parse(argv)
+        parse_argv
+        check_required_options
       end
 
       def option_parser_uncached
         ::OptionParser.new
       end
 
+      def parse_argv
+        @arguments = options_first? ? option_parser.order(argv) : option_parser.parse(argv)
+      rescue ::OptionParser::InvalidOption => e
+        raise ::EacCli::Parser::Error.new(definition, argv, e.message)
+      end
+
       def build_banner
         option_parser.banner = "#{definition.description}\n\n#{section('usage')}"
       end

data/lib/eac_cli/parser/parse_result.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'eac_cli/parser/error'
 require 'eac_ruby_utils/core_ext'
 
 module EacCli
@@ -8,6 +9,20 @@ module EacCli
       common_constructor :definition, :argv
 
       def result
+        result_or_error = parse(definition)
+        return result_or_error unless result_or_error.is_a?(::Exception)
+
+        definition.alternatives.each do |alternative|
+          alt_result_or_error = parse(alternative)
+          return alt_result_or_error unless alt_result_or_error.is_a?(::Exception)
+        end
+
+        raise result_or_error
+      end
+
+      private
+
+      def parse(definition)
         ::EacCli::Parser::Collector.to_data(definition) do |collector|
           ::EacCli::Parser::PositionalCollection.new(
             definition,
@@ -15,6 +30,8 @@ module EacCli
             collector
           )
         end
+      rescue ::EacCli::Parser::Error => e
+        e
       end
     end
   end

data/lib/eac_cli/parser/positional_collection.rb

@@ -10,39 +10,67 @@ module EacCli
 
       private
 
+      def argv_enum
+        @argv_enum ||= argv.each
+      end
+
+      def argv_pending?
+        argv_enum.ongoing?
+      end
+
+      def argv_pending_check
+        return unless argv_pending?
+        return unless positional_enum.stopped?
+
+        raise ::EacCli::Parser::Error.new(
+          definition, argv, "No positional left for argv \"#{argv_enum.current}\""
+        )
+      end
+
       def collected
         @collected ||= ::Set.new
       end
 
       def collect
-        argv.each { |argv_value| colect_argv_value(argv_value) }
-        return unless pending_required_positional?
+        loop do
+          break unless enums('pending?').any?
 
-        raise ::EacCli::Parser::Error.new(
-          definition, argv, 'No value for required positional ' \
-            "\"#{current_positional.identifier}\""
-        )
+          enums('pending_check')
+          collect_argv_value
+        end
+      end
+
+      def collect_argv_value
+        collector.collect(*enums('enum', &:peek))
+        collected << positional_enum.peek
+        positional_enum.next unless positional_enum.peek.repeat?
+        argv_enum.next
       end
 
-      def colect_argv_value(argv_value)
-        collector.collect(current_positional, argv_value)
-        collected << current_positional
-        positional_enumerator.next unless current_positional.repeat?
+      def enums(method_suffix, &block)
+        %w[positional argv].map do |method_prefix|
+          v = send("#{method_prefix}_#{method_suffix}")
+          block ? block.call(v) : v
+        end
       end
 
-      def pending_required_positional?
-        !(current_positional.blank? || current_positional.optional? ||
-            collected.include?(current_positional))
+      def positional_enum
+        @positional_enum ||= definition.positional.each
       end
 
-      def positional_enumerator
-        @positional_enumerator ||= definition.positional.each
+      def positional_pending?
+        !(positional_enum.stopped? || positional_enum.current.optional? ||
+            collected.include?(positional_enum.current))
       end
 
-      def current_positional
-        positional_enumerator.peek
-      rescue ::StopIteration
-        nil
+      def positional_pending_check
+        return unless positional_pending?
+        return unless argv_enum.stopped?
+
+        raise ::EacCli::Parser::Error.new(
+          definition, argv, 'No value for required positional ' \
+            "\"#{positional_enum.current.identifier}\""
+        )
       end
     end
   end

data/lib/eac_cli/patches/object/runner_with.rb

@@ -5,13 +5,14 @@ require 'eac_cli/runner'
 require 'eac_cli/runner_with'
 
 class Object
-  def runner_with(*runners)
+  def runner_with(*runners, &block)
     include ::EacCli::Runner
     enable_simple_cache
     enable_console_speaker
     runners.each do |runner|
       include runner_with_to_module(runner)
     end
+    runner_definition(&block) if block
   end
 
   private

data/lib/eac_cli/runner.rb

@@ -18,6 +18,10 @@ module EacCli
         end
       end
 
+      def runner?(object)
+        object.is_a?(::Class) && object.included_modules.include?(::EacCli::Runner)
+      end
+
       private
 
       def alias_class_method(klass, from, to)

data/lib/eac_cli/runner_with/subcommands.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module RunnerWith
+    module Subcommands
+      common_concern do
+        include ::EacCli::Runner
+      end
+
+      EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
+
+      def available_subcommands
+        @available_subcommands ||= available_subcommands_auto.merge(available_subcommands_extra)
+      end
+
+      def available_subcommands_auto
+        self.class.constants
+            .map { |name| [name.to_s.underscore.gsub('_', '-'), self.class.const_get(name)] }
+            .select { |c| ::EacCli::Runner.runner?(c[1]) }
+            .to_h.with_indifferent_access
+      end
+
+      def available_subcommands_extra
+        if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
+          send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
+        else
+          {}
+        end
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        return run_with_subcommand(*arguments, &block) if
+        run_with_subcommand_alias_run?(method_name)
+
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        run_with_subcommand_alias_run?(method_name) || super
+      end
+
+      def run_with_subcommand
+        if subcommand_name
+          subcommand_runner.run
+        else
+          run_without_subcommand
+        end
+      end
+
+      def run_with_subcommand_alias_run?(method_name)
+        subcommands? && method_name.to_sym == :run
+      end
+
+      def run_without_subcommand
+        "Method #{__method__} should be overrided in #{self.class.name}"
+      end
+
+      def subcommands?
+        self.class.runner_definition.subcommands?
+      end
+
+      def subcommand_args
+        parsed.fetch(::EacCli::Definition::SUBCOMMAND_ARGS_ARG)
+      end
+
+      def subcommand_class
+        available_subcommands[subcommand_name].if_present { |v| return v }
+
+        raise(::EacCli::Parser::Error.new(
+                self.class.runner_definition, runner_context.argv,
+                "Subcommand \"#{subcommand_name}\" not found " \
+                  "(Available: #{available_subcommands.keys}"
+              ))
+      end
+
+      def subcommand_name
+        parsed.fetch(::EacCli::Definition::SUBCOMMAND_NAME_ARG)
+      end
+
+      def subcommand_program
+        subcommand_name
+      end
+
+      def subcommand_runner
+        @subcommand_runner ||= subcommand_class.create(
+          argv: subcommand_args,
+          program_name: subcommand_program,
+          parent: self
+        )
+      end
+    end
+  end
+end

data/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.9.0'
+  VERSION = '0.10.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eac_cli
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Esquilo Azul Company
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-14 00:00:00.000000000 Z
+date: 2020-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eac_ruby_utils
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.45'
+        version: '0.50'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.45'
+        version: '0.50'
 - !ruby/object:Gem::Dependency
   name: eac_ruby_gem_support
   requirement: !ruby/object:Gem::Requirement
@@ -75,6 +75,7 @@ files:
 - lib/eac_cli/runner_with.rb
 - lib/eac_cli/runner_with/help.rb
 - lib/eac_cli/runner_with/output_file.rb
+- lib/eac_cli/runner_with/subcommands.rb
 - lib/eac_cli/version.rb
 homepage: 
 licenses: []