ehbrs-tools 0.16.1 → 0.16.2

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder.rb

@@ -6,71 +6,49 @@ require 'eac_ruby_utils/console/docopt_runner'
 module EacCli
   module Docopt
     class DocBuilder
+      require_sub __FILE__
       common_constructor :definition
 
       SEP = ' '
       IDENT = SEP * 2
       OPTION_DESC_SEP = IDENT * 2
 
-      def positional_argument(positional)
-        if positional.subcommand?
-          ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
-        else
-          r = "<#{positional.name}>"
-          r += '...' if positional.repeat?
-          r = "[#{r}]" if positional.optional?
-          r
+      class << self
+        def option_long(option)
+          b = option.long
+          b += '=<value>' if option.argument?
+          b
         end
       end
 
-      def option_argument(option)
-        option_long(option)
-      end
-
       def option_definition(option)
-        option.short + SEP + option_long(option) + OPTION_DESC_SEP + option.description
-      end
-
-      def option_long(option)
-        b = option.long
-        b += '=<value>' if option.argument?
-        b
+        option.short + SEP + self.class.option_long(option) + OPTION_DESC_SEP + option.description
       end
 
       def section(header, include_header = true)
         b = include_header ? "#{header.humanize}:\n" : ''
         b += send("self_#{header}") + "\n"
         definition.alternatives.each do |alternative|
-          b += self.class.new(alternative).section(header, false)
+          b += IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
         end
         b
       end
 
-      def self_options
-        definition.options.map { |option| IDENT + option_definition(option) }.join("\n")
-      end
-
-      def self_usage
-        IDENT + self_usage_arguments.join(SEP)
-      end
-
-      def self_usage_arguments
-        [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
-          definition.options_argument.if_present([]) { |_v| ['[options]'] } +
-          self_usage_arguments_options +
-          self_usage_arguments_positional
-      end
-
-      def self_usage_arguments_options
-        definition.options.select(&:show_on_usage?).map { |option| option_argument(option) }
+      def options_section
+        "Options:\n" +
+          definition.alternatives.flat_map(&:options)
+                    .map { |option| IDENT + option_definition(option) + "\n" }.join
       end
 
-      def self_usage_arguments_positional
-        definition.positional.map { |p| positional_argument(p) }
+      def usage_section
+        "Usage:\n" +
+          definition.alternatives.map do |alternative|
+            IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
+          end.join
       end
 
       def to_s
-        "#{definition.description}\n\n#{section('usage')}\n#{section('options')}\n"
+        "#{definition.description}\n\n#{usage_section}\n#{options_section}\n"
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder/alternative.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/console/docopt_runner'
+
+module EacCli
+  module Docopt
+    class DocBuilder
+      class Alternative
+        common_constructor :alternative
+
+        def to_s
+          (
+            [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
+              alternative.options_argument?.if_present([]) { |_v| ['[options]'] } +
+              options +
+              positionals
+          ).join(::EacCli::Docopt::DocBuilder::SEP)
+        end
+
+        def options
+          alternative.options.select(&:show_on_usage?).map do |option|
+            ::EacCli::Docopt::DocBuilder.option_long(option)
+          end
+        end
+
+        def option_argument(option)
+          b = option.long
+          b += '=<value>' if option.argument?
+          b
+        end
+
+        def positionals
+          alternative.positional.map { |p| positional(p) }
+        end
+
+        def positional(positional)
+          if positional.subcommand?
+            ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
+          else
+            r = "<#{positional.name}>"
+            r += '...' if positional.repeat?
+            r = "[#{r}]" if positional.optional?
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/parser.rb

@@ -5,10 +5,28 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Parser
     require_sub __FILE__
-    common_constructor :definition
+    enable_simple_cache
+    common_constructor :definition, :argv
 
-    def parse(argv)
-      ::EacCli::Parser::ParseResult.new(definition, argv).result
+    private
+
+    def parsed_uncached
+      raise 'Definition has no alternatives' if alternatives.empty?
+
+      alternatives.each do |alt_parser|
+        return alt_parser.parsed unless alt_parser.error?
+      end
+
+      raise first_error
+    end
+
+    def alternatives_uncached
+      definition.alternatives
+                .map { |alternative| ::EacCli::Parser::Alternative.new(alternative, argv) }
+    end
+
+    def first_error_uncached
+      alternatives.lazy.select(&:error?).map(&:error).first
     end
   end
 end

data/vendor/eac_cli/lib/eac_cli/parser/alternative.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'eac_cli/parser/collector'
+require 'eac_cli/parser/error'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    class Alternative
+      require_sub __FILE__, include_modules: true
+      enable_listable
+      lists.add_symbol :phase, :any, :option_argument, :positional
+      attr_reader :error
+
+      common_constructor :alternative, :argv do
+        alternative.assert_argument(::EacCli::Definition::Alternative, :alternative)
+        self.phase = PHASE_ANY
+        collect
+      end
+
+      def error?
+        error.present?
+      end
+
+      def parsed
+        @parsed ||= collector.to_data.freeze
+      end
+
+      private
+
+      attr_accessor :phase
+
+      def any_collect_argv_value
+        if argv_current_option?
+          option_collect_argv_value
+        else
+          positional_collect_argv_value
+        end
+      end
+
+      def collector
+        @collector ||= ::EacCli::Parser::Collector.new(alternative)
+      end
+
+      def collect
+        loop do
+          break unless argv_pending?
+
+          collect_argv_value
+        end
+        validate
+      rescue ::EacCli::Parser::Error => e
+        @error = e
+      end
+
+      def collect_argv_value
+        send("#{phase}_collect_argv_value")
+        argv_enum.next
+      end
+
+      def collect_option_argv_value
+        alternative.options.each do |option|
+        end
+
+        raise ::EacCli::Parser::Error.new(
+          alternative, argv, "Invalid option: #{argv_enum.current}"
+        )
+      end
+
+      def raise_error(message)
+        raise ::EacCli::Parser::Error.new(alternative, argv, message)
+      end
+
+      def validate
+        (alternative.options + alternative.positional).each do |option|
+          validate_option(option)
+        end
+      end
+
+      def validate_option(option)
+        return unless option.required?
+        return if collector.supplied?(option)
+
+        raise_error("Required option/positional #{option} not supplied")
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/parser/alternative/argv.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Argv
+        def argv_enum
+          @argv_enum ||= argv.each
+        end
+
+        def argv_pending?
+          argv_enum.ongoing?
+        end
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/parser/alternative/double_dash.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module DoubleDash
+        DOUBLE_DASH = '--'
+
+        private
+
+        attr_accessor :double_dash
+
+        def argv_current_double_dash?
+          argv_enum.peek == DOUBLE_DASH && !double_dash
+        end
+
+        def double_dash_collect_argv_value
+          self.phase = PHASE_POSITIONAL
+          self.double_dash = true
+        end
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/parser/alternative/options.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Options
+        DOUBLE_DASH = '--'
+
+        private
+
+        attr_accessor :argument_option, :double_dash
+
+        def argument_option_collect_argv(option)
+          self.argument_option = option
+          self.phase = PHASE_OPTION_ARGUMENT
+        end
+
+        def argv_current_option?
+          phase == PHASE_ANY && argv_enum.peek.start_with?('-')
+        end
+
+        def argv_current_double_dash?
+          argv_enum.peek == DOUBLE_DASH && !double_dash
+        end
+
+        def boolean_option_collect_argv(option)
+          collector.collect(option, true)
+        end
+
+        def option_argument_collect_argv_value
+          collector.collect(argument_option, argv_enum.peek)
+          self.argument_option = nil
+          self.phase = PHASE_ANY
+        end
+
+        def option_collect_argv_value
+          return double_dash_collect_argv_value if argv_current_double_dash?
+
+          alternative.options.any? do |option|
+            next false unless [option.short, option.long].include?(argv_enum.peek)
+
+            if option.argument?
+              argument_option_collect_argv(option)
+            else
+              boolean_option_collect_argv(option)
+            end
+
+            true
+          end || raise_argv_current_invalid_option
+        end
+
+        def raise_argv_current_invalid_option
+          raise_error "Invalid option: \"#{argv_enum.peek}\""
+        end
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/parser/alternative/positionals.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Positionals
+        private
+
+        def positional_collect_argv_value
+          positional_check
+          collector.collect(positional_enum.peek, argv_enum.peek)
+          positional_next
+        end
+
+        def positional_enum
+          @positional_enum ||= alternative.positional.each
+        end
+
+        def positional_check
+          raise_error("Invalid positional: #{argv_enum.peek}") if positional_enum.stopped?
+        end
+
+        def positional_next
+          self.phase = PHASE_POSITIONAL if positional_enum.peek.subcommand?
+          positional_enum.next unless positional_enum.peek.repeat?
+        end
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/runner.rb

@@ -28,7 +28,7 @@ module EacCli
         sklass = klass.singleton_class
         return unless sklass.method_defined?(from)
 
-        sklass.alias_method to, from
+        sklass.send(:alias_method, to, from)
       end
 
       def build_method_name(name, suffix)
@@ -84,7 +84,7 @@ module EacCli
       end
 
       def parsed
-        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition).parse(runner_context.argv)
+        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition, runner_context.argv).parsed
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/runner_with/help.rb

@@ -10,7 +10,7 @@ module EacCli
         include ::EacCli::Runner
 
         runner_definition.alt do
-          options_arg false
+          options_argument false
           bool_opt '-h', '--help', 'Show help.', usage: true
         end
       end

data/vendor/eac_cli/lib/eac_cli/runner_with/output_file.rb

@@ -2,12 +2,16 @@
 
 require 'eac_cli/runner'
 require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/abstract_methods'
 
 module EacCli
   module RunnerWith
     module OutputFile
       common_concern do
         include ::EacCli::Runner
+        include ::EacRubyUtils::AbstractMethods
+
+        abstract_methods :output_content
 
         runner_definition do
           arg_opt '-o', '--output-file', 'Output to file.'
@@ -18,7 +22,7 @@ module EacCli
         if parsed.output_file.present?
           ::File.write(parsed.output_file, output_content)
         else
-          out output_content
+          $stdout.write(output_content)
         end
       end
     end