ehbrs-tools 0.14.1 → 0.16.3

data/vendor/eac_docker/spec/lib/eac_docker/images/templatized_spec_files/stub_docker_image/Dockerfile

@@ -0,0 +1 @@
+from ubuntu:bionic

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/abstract_methods.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/common_concern'
+
+module EacRubyUtils
+  # Support to abstract methods.
+  #
+  # Usage:
+  #
+  #   require 'eac_ruby_utils/abstract_methods'
+  #
+  #   class BaseClass
+  #     include EacRubyUtils::AbstractMethods
+  #
+  #     abstract_methods :mymethod
+  #   end
+  #
+  #   BaseClass.new.mymethod # raise "Abstract method: mymethod"
+  #
+  #   class SubClass
+  #     def mymethod
+  #       "Implemented"
+  #     end
+  #   end
+  #
+  #   SubClass.new.mymethod # return "Implemented"
+  module AbstractMethods
+    common_concern
+
+    module ClassMethods
+      def abstract_methods(*methods_names)
+        methods_names.each do |method_name|
+          define_method method_name do
+            raise_abstract_method(method_name)
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      def respond_to_missing?(method_name, include_private = false)
+        super || abstract_method?(method_name)
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        raise_abstract_method(method_name) if abstract_method?(method_name)
+
+        super
+      end
+
+      def abstract_method?(method_name)
+        self.class.abstract_methods.include?(method_name.to_sym)
+      end
+
+      def raise_abstract_method(method_name)
+        raise ::NoMethodError, "Abstract method \"#{method_name}\" hit in \"#{self}\""
+      end
+    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/common_concern.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-require 'eac_ruby_utils/simple_cache'
-require 'eac_ruby_utils/patches/object/if_present'
+require 'eac_ruby_utils/common_concern/module_setup'
 
 module EacRubyUtils
   class CommonConcern
@@ -16,53 +14,7 @@ module EacRubyUtils
     end
 
     def setup(a_module)
-      Setup.new(self, a_module).run
-    end
-
-    class Setup
-      include ::EacRubyUtils::SimpleCache
-      attr_reader :a_module, :common_concern
-
-      def initialize(common_concern, a_module)
-        @common_concern = common_concern
-        @a_module = a_module
-      end
-
-      def run
-        setup = self
-        a_module.extend(::ActiveSupport::Concern)
-        a_module.included do
-          %w[class_methods instance_methods after_callback].each do |suffix|
-            setup.send("setup_#{suffix}", self)
-          end
-        end
-      end
-
-      def setup_class_methods(base)
-        class_methods_module.if_present { |v| base.extend v }
-      end
-
-      def setup_instance_methods(base)
-        instance_methods_module.if_present { |v| base.include v }
-      end
-
-      def setup_after_callback(base)
-        common_concern.after_callback.if_present do |v|
-          base.instance_eval(&v)
-        end
-      end
-
-      def class_methods_module_uncached
-        a_module.const_get(CLASS_METHODS_MODULE_NAME)
-      rescue NameError
-        nil
-      end
-
-      def instance_methods_module_uncached
-        a_module.const_get(INSTANCE_METHODS_MODULE_NAME)
-      rescue NameError
-        nil
-      end
+      ::EacRubyUtils::CommonConcern::ModuleSetup.new(self, a_module).run
     end
   end
 end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/patches/object/if_present'
+
+module EacRubyUtils
+  class CommonConcern
+    class ClassSetup
+      include ::EacRubyUtils::SimpleCache
+      attr_reader :a_class, :module_setup, :include_method
+
+      def initialize(module_setup, a_class, include_method)
+        @module_setup = module_setup
+        @a_class = a_class
+        @include_method = include_method
+      end
+
+      def run
+        %w[class_methods instance_methods after_callback].each do |suffix|
+          send("setup_#{suffix}")
+        end
+      end
+
+      def setup_class_methods
+        class_methods_module.if_present { |v| a_class.extend v }
+      end
+
+      def setup_instance_methods
+        instance_methods_module.if_present { |v| a_class.send(include_method, v) }
+      end
+
+      def setup_after_callback
+        module_setup.common_concern.after_callback.if_present do |v|
+          a_class.instance_eval(&v)
+        end
+      end
+
+      def class_methods_module_uncached
+        module_setup.a_module.const_get(CLASS_METHODS_MODULE_NAME)
+      rescue NameError
+        nil
+      end
+
+      def instance_methods_module_uncached
+        module_setup.a_module.const_get(INSTANCE_METHODS_MODULE_NAME)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'eac_ruby_utils/common_concern/class_setup'
+require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/patches/object/if_present'
+
+module EacRubyUtils
+  class CommonConcern
+    class ModuleSetup
+      include ::EacRubyUtils::SimpleCache
+      attr_reader :a_module, :common_concern
+
+      def initialize(common_concern, a_module)
+        @common_concern = common_concern
+        @a_module = a_module
+      end
+
+      def run
+        setup = self
+        a_module.extend(::ActiveSupport::Concern)
+        a_module.included do
+          ::EacRubyUtils::CommonConcern::ClassSetup.new(setup, self, :include).run
+        end
+        a_module.prepended do
+          ::EacRubyUtils::CommonConcern::ClassSetup.new(setup, self, :prepend).run
+        end
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/common_constructor.rb

@@ -61,6 +61,8 @@ module EacRubyUtils
       setup_class_attr_readers(klass)
       setup_class_attr_writers(klass)
       setup_class_initialize(klass)
+
+      klass
     end
 
     def setup_class_attr_readers(klass)
@@ -79,9 +81,14 @@ module EacRubyUtils
       klass.define_callbacks :initialize
       klass.send(:define_method, :initialize) do |*args|
         Initialize.new(common_constructor, args, self).run
+        super(*SuperArgs.new(common_constructor, args, self).result)
       end
     end
 
+    def super_args
+      options[:super_args]
+    end
+
     class Initialize
       attr_reader :common_constructor, :args, :object
 
@@ -129,5 +136,51 @@ module EacRubyUtils
           " (given #{args.count}, expected #{common_constructor.args_count})"
       end
     end
+
+    class SuperArgs
+      attr_reader :common_constructor, :args, :object
+
+      def initialize(common_constructor, args, object)
+        @common_constructor = common_constructor
+        @args = args
+        @object = object
+      end
+
+      def auto_result
+        r = []
+        sub_args.each do |name, value|
+          i = super_arg_index(name)
+          r[i] = value if i
+        end
+        r
+      end
+
+      def result
+        result_from_options || auto_result
+      end
+
+      def result_from_options
+        return unless common_constructor.super_args
+
+        object.instance_exec(&common_constructor.super_args)
+      end
+
+      def sub_args
+        common_constructor.args.each_with_index.map do |name, index|
+          [name, args[index]]
+        end.to_h
+      end
+
+      def super_arg_index(name)
+        super_method.parameters.each_with_index do |arg, index|
+          return index if arg[1] == name
+        end
+        nil
+      end
+
+      def super_method
+        object.class.superclass ? object.class.superclass.instance_method(:initialize) : nil
+      end
+    end
   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,31 +1,20 @@
 # 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)
-          path = if entry_key.is_a?(::Array)
-                   entry_key
-                 else
-                   ::EacRubyUtils::PathsHash.parse_entry_key(entry_key)
-                 end
-          path.join('_').gsub(/[^a-z0-9_]/i, '').gsub(/\A_+/, '').gsub(/_+\z/, '')
-              .gsub(/_{2,}/, '_').upcase
+          ::EacRubyUtils::Console::Configs::EntryReader.entry_key_to_envvar_name(entry_key)
         end
       end
 
-      STORE_PASSWORDS_KEY = 'core.store_passwords'
-
       attr_reader :configs
 
       def initialize(configs_key, options = {})
@@ -34,101 +23,15 @@ module EacRubyUtils
       end
 
       def read_password(entry_key, options = {})
-        options = options.merge(noecho: true)
-        if store_passwords?
-          read_entry(entry_key, options)
-        else
-          looped_entry_value_from_input(entry_key, options)
-        end
+        ::EacRubyUtils::Console::Configs::PasswordEntryReader.new(self, entry_key, options).read
       end
 
       def read_entry(entry_key, options = {})
-        options = ReadEntryOptions.new(options)
-        unless options[:noenv]
-          envvar_value = envvar_read_entry(entry_key)
-          return envvar_value if envvar_value.present?
-        end
-        stored_value = configs.read_entry(entry_key)
-        return stored_value if stored_value
-        return read_entry_from_console(entry_key, options) unless options[:noinput]
-
-        raise "No value found for entry \"#{entry_key}\"" if options[:required]
+        ::EacRubyUtils::Console::Configs::EntryReader.new(self, entry_key, options).read
       end
 
       def store_passwords?
-        read_entry(
-          STORE_PASSWORDS_KEY,
-          before_input: -> { store_password_banner },
-          validator: ->(entry_value) { %w[yes no].include?(entry_value) }
-        ) == 'yes'
-      end
-
-      protected
-
-      def envvar_read_entry(entry_key)
-        ENV[self.class.entry_key_to_envvar_name(entry_key)]
-      end
-
-      def read_entry_from_console(entry_key, options)
-        options[:before_input].call if options[:before_input].present?
-        entry_value = looped_entry_value_from_input(entry_key, options)
-        configs.write_entry(entry_key, entry_value)
-        entry_value
-      end
-
-      def store_password_banner
-        infom 'Do you wanna to store passwords?'
-        infom "Warning: the passwords will be store in clear text in \"#{configs.storage_path}\""
-        infom 'Enter "yes" or "no"'
-      end
-
-      def looped_entry_value_from_input(entry_key, options)
-        loop do
-          entry_value = entry_value_from_input(entry_key, options)
-          next if entry_value.blank?
-          next if options[:validator] && !options[:validator].call(entry_value)
-
-          return entry_value
-        end
-      end
-
-      def entry_value_from_input(entry_key, options)
-        entry_value = request_input("Value for entry \"#{entry_key}\"",
-                                    options.request_input_options)
-        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
+        ::EacRubyUtils::Console::Configs::StorePasswordsEntryReader.new(self) == 'yes'
       end
     end
   end