ehbrs-tools 0.9.0 → 0.13.1

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/struct'
+
+module EacCli
+  class Parser
+    class Collector
+      class << self
+        def to_data(definition)
+          collector = new(definition)
+          yield(collector)
+          collector.to_data
+        end
+      end
+
+      common_constructor :definition do
+        default_values
+      end
+
+      # @return [OpenStruct]
+      def to_data
+        ::EacRubyUtils::Struct.new(data.transform_keys(&:identifier))
+      end
+
+      def collect(option, value)
+        if data[option].is_a?(::Array)
+          data[option] << value
+        else
+          data[option] = value
+        end
+      end
+
+      private
+
+      def data
+        @data ||= {}
+      end
+
+      def default_values
+        definition.options.each { |option| data[option] = option_default_value(option) }
+        definition.positional.each do |positional|
+          data[positional] = positional_default_value(positional)
+        end
+      end
+
+      def option_default_value(option)
+        option.argument? ? nil : false
+      end
+
+      def positional_default_value(positional)
+        positional.repeat? ? [] : nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    class Error < ::StandardError
+      def initialize(definition, argv, message)
+        @definition = definition
+        @argv = argv
+        super(message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'optparse'
+
+module EacCli
+  class Parser
+    class OptionsCollection
+      SEP = ' '
+      IDENT = SEP * 2
+      OPTION_DESC_SEP = IDENT * 2
+
+      enable_simple_cache
+      common_constructor(:definition, :argv, :collector) { collect }
+      attr_reader :arguments
+
+      private
+
+      def collect
+        build_banner
+        build_options
+        @arguments = option_parser.parse(argv)
+      end
+
+      def option_parser_uncached
+        ::OptionParser.new
+      end
+
+      def build_banner
+        option_parser.banner = "#{definition.description}\n\n#{section('usage')}"
+      end
+
+      def build_options
+        definition.options.each do |option|
+          build_option(option)
+        end
+      end
+
+      def build_option(option)
+        option_parser.on(
+          *[option_short(option), option_long(option), option.description].reject(&:blank?)
+        ) do |value|
+          collector.collect(option, value)
+        end
+      end
+
+      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
+        end
+      end
+
+      def option_argument(option)
+        option_long(option)
+      end
+
+      def option_long(option)
+        b = option.long
+        b += '=VALUE' if option.argument?
+        b
+      end
+
+      def option_short(option)
+        b = option.short
+        b += 'VALUE' if option.argument?
+        b
+      end
+
+      def section(header, include_header = true)
+        b = include_header ? "#{header.humanize}:\n" : ''
+        b += send("self_#{header}") + "\n"
+        # TO-DO: implement alternatives
+        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) }
+      end
+
+      def self_usage_arguments_positional
+        definition.positional.map { |p| positional_argument(p) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    class ParseResult
+      common_constructor :definition, :argv
+
+      def result
+        ::EacCli::Parser::Collector.to_data(definition) do |collector|
+          ::EacCli::Parser::PositionalCollection.new(
+            definition,
+            ::EacCli::Parser::OptionsCollection.new(definition, argv, collector).arguments,
+            collector
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/parser/error'
+
+module EacCli
+  class Parser
+    class PositionalCollection
+      common_constructor(:definition, :argv, :collector) { collect }
+
+      private
+
+      def collected
+        @collected ||= ::Set.new
+      end
+
+      def collect
+        argv.each { |argv_value| colect_argv_value(argv_value) }
+        return unless pending_required_positional?
+
+        raise ::EacCli::Parser::Error.new(
+          definition, argv, 'No value for required positional ' \
+            "\"#{current_positional.identifier}\""
+        )
+      end
+
+      def colect_argv_value(argv_value)
+        collector.collect(current_positional, argv_value)
+        collected << current_positional
+        positional_enumerator.next unless current_positional.repeat?
+      end
+
+      def pending_required_positional?
+        !(current_positional.blank? || current_positional.optional? ||
+            collected.include?(current_positional))
+      end
+
+      def positional_enumerator
+        @positional_enumerator ||= definition.positional.each
+      end
+
+      def current_positional
+        positional_enumerator.peek
+      rescue ::StopIteration
+        nil
+      end
+    end
+  end
+end

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

@@ -1,29 +1,49 @@
 # frozen_string_literal: true
 
-require 'eac_cli/runner/definition'
-require 'eac_cli/runner/docopt_doc'
+require 'eac_cli/definition'
+require 'eac_cli/docopt/runner_extension'
+require 'eac_cli/parser'
 require 'eac_ruby_utils/core_ext'
 
 module EacCli
   module Runner
+    require_sub __FILE__
     extend ::ActiveSupport::Concern
 
     included do
       extend ClassMethods
       include InstanceMethods
+      ::EacCli::Docopt::RunnerExtension.check(self)
     end
 
     module ClassMethods
+      def create(*context_args)
+        r = new
+        r.context = ::EacCli::Runner::Context.new(*context_args)
+        r
+      end
+
       def runner_definition(&block)
-        @runner_definition ||= ::EacCli::Runner::Definition.new
+        @runner_definition ||= ::EacCli::Definition.new
         @runner_definition.instance_eval(&block) if block
         @runner_definition
       end
     end
 
     module InstanceMethods
-      def doc
-        ::EacCli::Runner::DocoptDoc.new(self.class.runner_definition).to_s
+      def context
+        return @context if @context
+
+        raise 'Context was required, but was not set yet'
+      end
+
+      def context=(new_context)
+        @context = new_context
+        @parsed = nil
+      end
+
+      def parsed
+        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition).parse(context.argv)
       end
     end
   end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module Runner
+    class Context
+      attr_reader :argv, :parent, :program_name
+
+      def initialize(*context_args)
+        options = context_args.extract_options!
+        @argv = (context_args[0] || options.delete(:argv)).freeze
+        @parent = context_args[1] || options.delete(:parent)
+        @program_name = options.delete(:program_name)
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/version.rb

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

data/vendor/eac_cli/spec/lib/eac_cli/runner_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/runner'
+
+RSpec.describe ::EacCli::Runner do
+  let(:stub_runner) do
+    r = Class.new(::EacRubyUtils::Console::DocoptRunner) do
+      def run; end
+    end
+    r.include described_class
+    r.runner_definition do
+      desc 'A stub runner.'
+      arg_opt '-o', '--opt1', 'A argument option'
+      pos_arg 'pos1'
+    end
+    r
+  end
+
+  let(:instance) { stub_runner.new(argv: %w[-o aaa bbb]) }
+
+  before { instance.run }
+
+  it { expect(instance.options.fetch('--opt1')).to eq('aaa') }
+  it { expect(instance.options.fetch('<pos1>')).to eq('bbb') }
+
+  context 'without docopt runner' do
+    let(:runner_class) do
+      the_module = described_class
+      ::Class.new do
+        include the_module
+
+        runner_definition do
+          arg_opt '-o', '--opt1', 'A arg option.'
+          bool_opt '-o', '--opt2', 'A boolean option'
+          pos_arg :pos1
+          pos_arg :pos2, repeat: true, optional: true
+        end
+
+        def run; end
+      end
+    end
+
+    context 'when all args are supplied' do
+      let(:instance) { runner_class.create(%w[--opt1 aaa --opt2 bbb ccc ddd]) }
+
+      it { expect(instance.parsed.opt1).to eq('aaa') }
+      it { expect(instance.parsed.opt2?).to eq(true) }
+      it { expect(instance.parsed.pos1).to eq('bbb') }
+      it { expect(instance.parsed.pos2).to eq(%w[ccc ddd]) }
+    end
+
+    context 'when only required args are supplied' do
+      let(:instance) { runner_class.create(%w[bbb]) }
+
+      it { expect(instance.parsed.opt1).to be_nil }
+      it { expect(instance.parsed.opt2?).to eq(false) }
+      it { expect(instance.parsed.pos1).to eq('bbb') }
+      it { expect(instance.parsed.pos2).to eq([]) }
+    end
+
+    context 'when required args are not supplied' do
+      let(:instance) { runner_class.create(%w[]) }
+
+      it do
+        expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+      end
+    end
+  end
+end

data/vendor/eac_docker/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/vendor/eac_docker/eac_docker.gemspec

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'eac_docker/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eac_docker'
+  s.version     = EacDocker::VERSION
+  s.authors     = ['Put here the authors']
+  s.summary     = 'Put here de description.'
+
+  s.files = Dir['{lib}/**/*']
+
+  s.add_dependency 'eac_ruby_utils', '~> 0.36'
+
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.1', '>= 0.1.1'
+end

data/vendor/eac_docker/lib/eac_docker.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacDocker
+  require_sub __FILE__
+end

data/vendor/eac_docker/lib/eac_docker/container.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacDocker
+  class Container
+    enable_immutable
+    immutable_accessor :interactive, :temporary, :tty, type: :boolean
+    immutable_accessor :env, type: :hash
+    immutable_accessor :command_arg, :volume, type: :array
+    common_constructor :image
+
+    def immutable_constructor_args
+      [image]
+    end
+
+    alias immutable_volume volume
+
+    def volume(left_part, right_part = null)
+      immutable_volume(right_part.if_present(left_part) { |v| "#{left_part}:#{v}" })
+    end
+
+    def run_command
+      ::EacDocker::Executables.docker.command('run', *run_command_args)
+    end
+
+    def run_command_args
+      run_command_boolean_args + run_command_envs_args + run_command_volumes_args + [image.id] +
+        command_args
+    end
+
+    private
+
+    def run_command_boolean_args
+      r = []
+      r << '--interactive' if interactive?
+      r << '--tty' if tty?
+      r << '--rm' if temporary?
+      r
+    end
+
+    def run_command_volumes_args
+      volumes.flat_map { |volume| ['--volume', volume] }
+    end
+
+    def run_command_envs_args
+      envs.flat_map { |name, value| ['--env', "#{name}=#{value}"] }
+    end
+  end
+end