ehbrs-tools 0.13.0 → 0.16.0

data/vendor/eac_cli/spec/lib/eac_cli/docopt/runner_extension_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_cli/docopt/runner_extension'
+
+RSpec.describe ::EacCli::Docopt::RunnerExtension do
+  let(:stub_runner) do
+    r = Class.new(::EacRubyUtils::Console::DocoptRunner) do
+      def run; end
+    end
+    r.include ::EacCli::Runner
+    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') }
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/runner'
+
+RSpec.describe ::EacCli::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
+        alt do
+          bool_opt '-a', '--opt3', 'A boolean option in a alternative.', required: true
+        end
+      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
+
+  context 'when alternative args are supplied' do
+    let(:instance) { runner_class.create(%w[--opt3]) }
+
+    it { expect(instance.parsed.opt3?).to eq(true) }
+  end
+
+  context 'when extra args are not supplied' do
+    let(:runner_class) do
+      the_module = described_class
+      ::Class.new do
+        include the_module
+
+        runner_definition do
+          pos_arg :pos1
+        end
+
+        def run; end
+      end
+    end
+
+    let(:instance) { runner_class.create(%w[aaa bbb]) }
+
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+end

data/vendor/eac_cli/spec/lib/eac_cli/runner_with/subcommands_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_cli/runner_with/subcommands'
+
+RSpec.describe ::EacCli::RunnerWith::Subcommands do
+  let(:parent_runner) do
+    the_module = described_class
+    the_child = child_runner
+    Class.new do
+      include ::EacCli::Runner
+      include the_module
+      const_set('ChildCmd', the_child)
+
+      runner_definition do
+        desc 'A stub root runner.'
+        arg_opt '-r', '--root-var', 'A root variable.'
+        subcommands
+      end
+
+      delegate :root_var, to: :parsed
+    end
+  end
+
+  let(:child_runner) do
+    ::Class.new do
+      include ::EacCli::Runner
+
+      runner_definition do
+        bool_opt '-c', '--child-opt', 'A boolean option.'
+        pos_arg :child_var
+      end
+
+      def run; end
+    end
+  end
+
+  let(:instance) { parent_runner.create(argv: parent_argv) }
+
+  context 'when subcommand is supplied' do
+    let(:parent_argv) { %w[--root-var 123 child-cmd --child-opt 456] }
+
+    it { expect(instance.parsed.root_var).to eq('123') }
+    it { expect(instance.parsed.subcommand).to eq('child-cmd') }
+    it { expect(instance.parsed.subcommand_args).to eq(%w[--child-opt 456]) }
+    it { expect(instance.subcommand_runner.parsed.child_opt).to eq(true) }
+    it { expect(instance.subcommand_runner.parsed.child_var).to eq('456') }
+  end
+
+  context 'when subcommand is not supplied' do
+    let(:instance) { parent_runner.create(%w[456]) }
+
+    it do
+      expect { instance.run }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/blank_not_blank.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'singleton'
+
+module EacRubyUtils
+  # A blank string which returns +false+ for +blank?+ method.
+  class BlankNotBlank < String
+    include ::Singleton
+
+    def initialize
+      super('')
+    end
+
+    def blank?
+      false
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/boolean.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class Boolean
+    class << self
+      def parse(value)
+        return parse_string(value) if value.is_a?(::String)
+        return parse_string(value.to_s) if value.is_a?(::Symbol)
+        return parse_number(value) if value.is_a?(::Number)
+
+        value ? true : false
+      end
+
+      private
+
+      def parse_string(value)
+        ['', 'n', 'no', 'f', 'false'].include?(value.strip.downcase) ? false : true
+      end
+
+      def parse_number(value)
+        value.zero?
+      end
+    end
+
+    attr_reader :value
+
+    def initialize(value)
+      @value = self.class.parse(value)
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/common_concern.rb

@@ -21,10 +21,10 @@ module EacRubyUtils
 
     class Setup
       include ::EacRubyUtils::SimpleCache
-      attr_reader :a_module, :common_constructor
+      attr_reader :a_module, :common_concern
 
-      def initialize(common_constructor, a_module)
-        @common_constructor = common_constructor
+      def initialize(common_concern, a_module)
+        @common_concern = common_concern
         @a_module = a_module
       end
 
@@ -47,7 +47,7 @@ module EacRubyUtils
       end
 
       def setup_after_callback(base)
-        common_constructor.after_callback.if_present do |v|
+        common_concern.after_callback.if_present do |v|
           base.instance_eval(&v)
         end
       end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/configs/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/blank_not_blank'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/paths_hash'
+
+module EacRubyUtils
+  class Configs
+    class Base
+      enable_simple_cache
+
+      common_constructor :data, default: [{}] do
+        self.data = ::EacRubyUtils::PathsHash.new(data)
+      end
+
+      def []=(entry_key, entry_value)
+        write(entry_key, entry_value)
+      end
+
+      def [](entry_key)
+        read(entry_key)
+      end
+
+      def clear
+        replace({})
+      end
+
+      def read(entry_key)
+        return nil unless data.key?(entry_key)
+
+        data.fetch(entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
+      end
+
+      def replace(new_data)
+        self.data = ::EacRubyUtils::PathsHash.new(new_data)
+      end
+
+      def write(entry_key, entry_value)
+        data[entry_key] = entry_value
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/configs/file.rb

@@ -1,27 +1,18 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/string'
+require 'eac_ruby_utils/configs/base'
 require 'yaml'
-require 'eac_ruby_utils/patches/hash/sym_keys_hash'
-require 'eac_ruby_utils/paths_hash'
-require 'eac_ruby_utils/simple_cache'
 
 module EacRubyUtils
   class Configs
-    class File
-      include ::EacRubyUtils::SimpleCache
-
+    class File < ::EacRubyUtils::Configs::Base
       attr_reader :path, :options
 
       # Valid options: [:autosave]
       def initialize(path, options = {})
         @path = path
         @options = options.to_sym_keys_hash.freeze
-        load
-      end
-
-      def clear
-        self.data = ::EacRubyUtils::PathsHash.new({})
+        super(raw_data_from_file)
       end
 
       def save
@@ -30,37 +21,27 @@ module EacRubyUtils
       end
 
       def load
-        self.data = if ::File.exist?(path) && ::File.size(path).positive?
-                      ::EacRubyUtils::PathsHash.new(YAML.load_file(path))
-                    else
-                      {}
-                    end
-      end
-
-      def []=(entry_key, entry_value)
-        write(entry_key, entry_value)
+        replace(raw_data_from_file)
       end
 
       def write(entry_key, entry_value)
-        data[entry_key] = entry_value
+        super
         save if autosave?
       end
 
-      def [](entry_key)
-        read(entry_key)
-      end
-
-      def read(entry_key)
-        data[entry_key]
-      end
-
       def autosave?
         options[:autosave] ? true : false
       end
 
       private
 
-      attr_accessor :data
+      def raw_data_from_file
+        if ::File.exist?(path) && ::File.size(path).positive?
+          ::YAML.load_file(path)
+        else
+          {}
+        end
+      end
     end
   end
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/common_constructor'
 require 'eac_ruby_utils/configs'
-require 'eac_ruby_utils/console/speaker'
-require 'eac_ruby_utils/options_consumer'
-require 'eac_ruby_utils/patches/object/asserts'
-require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/core_ext'
 
 module EacRubyUtils
   module Console
     class Configs
-      include ::EacRubyUtils::Console::Speaker
+      require_sub __FILE__
+      enable_console_speaker
 
       class << self
         def entry_key_to_envvar_name(entry_key)
@@ -34,7 +31,7 @@ module EacRubyUtils
       end
 
       def read_password(entry_key, options = {})
-        options = options.merge(noecho: true)
+        options = ReadEntryOptions.new(options.merge(noecho: true))
         if store_passwords?
           read_entry(entry_key, options)
         else
@@ -66,7 +63,10 @@ module EacRubyUtils
       protected
 
       def envvar_read_entry(entry_key)
-        ENV[self.class.entry_key_to_envvar_name(entry_key)]
+        env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
+        return nil unless ENV.key?(env_entry_key)
+
+        ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
       end
 
       def read_entry_from_console(entry_key, options)
@@ -98,38 +98,6 @@ module EacRubyUtils
         warn('Entered value is blank') if entry_value.blank?
         entry_value
       end
-
-      class ReadEntryOptions
-        include ::EacRubyUtils::SimpleCache
-        ::EacRubyUtils::CommonConstructor.new(:options).setup_class(self)
-
-        DEFAULT_VALUES = {
-          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
-          required: true, validator: nil
-        }.freeze
-
-        def [](key)
-          values.fetch(key.to_sym)
-        end
-
-        def request_input_options
-          values.slice(:bool, :list, :noecho)
-        end
-
-        private
-
-        def values_uncached
-          consumer = ::EacRubyUtils::OptionsConsumer.new(options)
-          r = {}
-          DEFAULT_VALUES.each do |key, default_value|
-            value = consumer.consume(key)
-            value = default_value if value.nil?
-            r[key] = value
-          end
-          consumer.validate
-          r
-        end
-      end
     end
   end
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/read_entry_options.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRubyUtils
+  module Console
+    class Configs
+      class ReadEntryOptions
+        enable_simple_cache
+        common_constructor :options
+
+        DEFAULT_VALUES = {
+          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
+          required: true, validator: nil
+        }.freeze
+
+        def [](key)
+          values.fetch(key.to_sym)
+        end
+
+        def request_input_options
+          values.slice(:bool, :list, :noecho)
+        end
+
+        private
+
+        def values_uncached
+          consumer = options.to_options_consumer
+          r = {}
+          DEFAULT_VALUES.each do |key, default_value|
+            value = consumer.consume(key)
+            value = default_value if value.nil?
+            r[key] = value
+          end
+          consumer.validate
+          r
+        end
+      end
+    end
+  end
+end