ehbrs-tools 0.11.0 → 0.14.1

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/base_accessor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Immutable
+    class BaseAccessor
+      common_constructor :name do
+        self.name = name.to_sym
+      end
+
+      def duplicate_object(object)
+        accessor_new_value = yield(immutable_value_get(object))
+        new_values = object.send(:immutable_values_get).merge(name => accessor_new_value)
+        r = object.class.new(*object.immutable_constructor_args)
+        r.send(:immutable_values_set, new_values)
+        r
+      end
+
+      def immutable_value_get(object)
+        object.send(:immutable_values_get)[name]
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/boolean_accessor.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/immutable/common_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module Immutable
+    class BooleanAccessor < ::EacRubyUtils::Immutable::CommonAccessor
+      def apply(klass)
+        super
+        accessor = self
+        klass.send(:define_method, "#{name}?") { send(accessor.name) }
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/class_methods.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Immutable
+    module ClassMethods
+      def immutable_accessor(*accessors)
+        options = accessors.extract_options!
+        options[:type] ||= const_get('TYPE_COMMON')
+        accessors.each do |name|
+          class_name = options.fetch(:type).to_s.camelize + 'Accessor'
+          ::EacRubyUtils::Immutable.const_get(class_name).new(name).apply(self)
+        end
+      end
+
+      private
+
+      def imutable_single_accessor(name, options); end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/common_accessor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/immutable/base_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module Immutable
+    class CommonAccessor < ::EacRubyUtils::Immutable::BaseAccessor
+      def apply(klass)
+        accessor = self
+        klass.send(:define_method, name) do |*args|
+          case args.count
+          when 0 then next accessor.immutable_value_get(self)
+          when 1 then next accessor.immutable_value_set(self, args.first)
+          else
+            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 0..1)"
+          end
+        end
+      end
+
+      def immutable_value_get(object)
+        object.send(:immutable_values_get)[name]
+      end
+
+      def immutable_value_set(object, value)
+        duplicate_object(object) { |_old_value| value }
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/hash_accessor.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/immutable/base_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module Immutable
+    class HashAccessor < ::EacRubyUtils::Immutable::BaseAccessor
+      def apply(klass)
+        apply_get(klass)
+        apply_set(klass)
+      end
+
+      def immutable_value_get(object)
+        super || {}
+      end
+
+      def immutable_value_set(object, key, value)
+        duplicate_object(object) do |old_value|
+          (old_value || {}).merge(key => value)
+        end
+      end
+
+      private
+
+      def apply_get(klass)
+        accessor = self
+        klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do
+          accessor.immutable_value_get(self)
+        end
+      end
+
+      def apply_set(klass)
+        accessor = self
+        klass.send(:define_method, name) do |*args|
+          case args.count
+          when 1 then next accessor.immutable_value_get(self, args[0])
+          when 2 then next accessor.immutable_value_set(self, *args[0..1])
+          else
+            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 1..2)"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/instance_methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Immutable
+    module InstanceMethods
+      def immutable_constructor_args
+        []
+      end
+
+      private
+
+      def immutable_values_get
+        @immutable_values || {}
+      end
+
+      def immutable_values_set(new_values)
+        @immutable_values = new_values
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/inflector.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class Inflector
+    class << self
+      VARIABLE_NAME_PATTERN = /[_a-z][_a-z0-9]*/i.freeze
+
+      def variableize(string)
+        r = string.gsub(/[^_a-z0-9]/i, '_').gsub(/_+/, '_').gsub(/_\z/, '').gsub(/\A_/, '').downcase
+        m = VARIABLE_NAME_PATTERN.match(r)
+        return r if m
+
+        raise ::ArgumentError, "Invalid variable name \"#{r}\" was generated " \
+          "from string \"#{string}\""
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/listable/list.rb

@@ -12,6 +12,10 @@ module EacRubyUtils
         apply_constants
       end
 
+      def each_value(&block)
+        values.each(&block)
+      end
+
       def values
         @values.values.map(&:value)
       end
@@ -29,6 +33,11 @@ module EacRubyUtils
         find_list_by_method(name) || super
       end
 
+      def hash_keys_validate!(hash, error_class = ::StandardError)
+        hash.keys.each { |key| value_validate!(key, error_class) }
+        hash
+      end
+
       def i18n_key
         "eac_ruby_utils.listable.#{class_i18n_key}.#{item}"
       end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/listable/lists.rb

@@ -4,6 +4,7 @@ require 'active_support/hash_with_indifferent_access'
 require 'active_support/core_ext/string/inflections'
 require_relative 'integer_list'
 require_relative 'string_list'
+require_relative 'symbol_list'
 
 module EacRubyUtils
   module Listable
@@ -14,18 +15,10 @@ module EacRubyUtils
         @source = source
       end
 
-      def add_integer(item, *labels)
-        check_acts_as_listable_new_item(item)
-        acts_as_listable_items[item] = ::EacRubyUtils::Listable::IntegerList.new(
-          self, item, labels
-        )
-      end
-
-      def add_string(item, *labels)
-        check_acts_as_listable_new_item(item)
-        acts_as_listable_items[item] = ::EacRubyUtils::Listable::StringList.new(
-          self, item, labels
-        )
+      %w[integer string symbol].each do |list_type|
+        define_method "add_#{list_type}" do |item, *labels|
+          add(::EacRubyUtils::Listable.const_get("#{list_type}_list".camelize), item, labels)
+        end
       end
 
       def method_missing(name, *args, &block)
@@ -43,6 +36,11 @@ module EacRubyUtils
 
       private
 
+      def add(list_class, item, labels)
+        check_acts_as_listable_new_item(item)
+        acts_as_listable_items[item] = list_class.new(self, item, labels)
+      end
+
       def check_acts_as_listable_new_item(item)
         return unless acts_as_listable_items.key?(item)
 

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/listable/symbol_list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'list'
+
+module EacRubyUtils
+  module Listable
+    class SymbolList < ::EacRubyUtils::Listable::List
+      protected
+
+      def parse_labels(labels)
+        if labels.first.is_a?(Hash)
+          Hash[labels.first.map { |k, v| [k.to_sym, v.to_sym] }]
+        else
+          Hash[labels.map { |v| [v.to_sym, v.to_sym] }]
+        end
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/listable/value.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'eac_ruby_utils/inflector'
+
 module EacRubyUtils
   module Listable
     class Value
@@ -16,8 +18,7 @@ module EacRubyUtils
       end
 
       def constant_name
-        "#{@list.item}_#{@key}".gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_')
-                               .gsub(/(?:\A_|_\z)/, '').upcase
+        ::EacRubyUtils::Inflector.variableize("#{@list.item}_#{@key}").upcase
       end
 
       def label

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_concern'
+require 'eac_ruby_utils/console/speaker'
+
+class Module
+  def common_concern(&after_callback)
+    ::EacRubyUtils::CommonConcern.new(&after_callback).setup(self)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/immutable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/immutable'
+
+class Module
+  def enable_immutable
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::Immutable)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/patch.rb

@@ -4,6 +4,6 @@ require 'eac_ruby_utils/patch'
 
 class Module
   def patch(patch_module)
-    ::Eac::Ruby::Utils.patch(self, patch_module)
+    ::EacRubyUtils.patch(self, patch_module)
   end
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/require_sub.rb

@@ -3,7 +3,7 @@
 require 'eac_ruby_utils/require_sub'
 
 class Module
-  def require_sub(file_path)
-    ::EacRubyUtils.require_sub(file_path)
+  def require_sub(file_path, options = {})
+    ::EacRubyUtils.require_sub(file_path, { base: self }.merge(options))
   end
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/if_present.rb

@@ -5,7 +5,7 @@ require 'active_support/core_ext/object/blank'
 class Object
   # @return +block.call(self)+ if +self+ is present, +default_value+ otherwise.
   def if_present(default_value = nil)
-    return default_value unless present?
+    return default_value if blank?
 
     block_given? ? yield(self) : self
   end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/if_respond.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+class Object
+  # @return +block.call(self.method_name)+ if +self+ responds to +method_name+, +default_value+
+  # otherwise.
+  def if_respond(method_name, default_value = nil)
+    return default_value unless respond_to?(method_name)
+
+    value = send(method_name)
+
+    block_given? ? yield(value) : value
+  end
+
+  # @return +yield+ if +self+ is blank.
+  def if_blank
+    return yield if blank? && block_given?
+
+    self
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/string.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+::EacRubyUtils.require_sub __FILE__

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/string/inflector.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/inflector'
+
+class String
+  def variableize
+    ::EacRubyUtils::Inflector.variableize(self)
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/paths_hash.rb

@@ -33,9 +33,7 @@ module EacRubyUtils
       root.write_entry(self.class.parse_entry_key(entry_key), entry_value, [])
     end
 
-    def to_h
-      root.to_h
-    end
+    delegate :to_h, to: :root
 
     private
 

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/require_sub.rb

@@ -1,11 +1,81 @@
 # frozen_string_literal: true
 
+require 'active_support/inflector'
+require 'eac_ruby_utils/listable'
+
 module EacRubyUtils
   class << self
-    def require_sub(file)
+    def require_sub(file, options = {})
+      ::EacRubyUtils::RequireSub.new(file, options).apply
+    end
+  end
+
+  class RequireSub
+    include ::EacRubyUtils::Listable
+    lists.add_symbol :option, :base, :include_modules, :require_dependency
+
+    attr_reader :file, :options
+
+    def initialize(file, options = {})
+      @file = file
+      @options = self.class.lists.option.hash_keys_validate!(options)
+    end
+
+    def apply
+      require_sub_files
+      include_modules
+    end
+
+    private
+
+    def active_support_require(path)
+      return false unless options[OPTION_REQUIRE_DEPENDENCY]
+
+      ::Kernel.require_dependency(path)
+      true
+    end
+
+    def autoload_require(path)
+      return false unless base?
+
+      basename = ::File.basename(path, '.*')
+      return false if basename.start_with?('_')
+
+      base.autoload ::ActiveSupport::Inflector.camelize(basename), path
+      true
+    end
+
+    def include_modules
+      return unless options[OPTION_INCLUDE_MODULES]
+
+      base.constants.each do |constant_name|
+        constant = base.const_get(constant_name)
+        next unless constant.is_a?(::Module) && !constant.is_a?(::Class)
+
+        base.include(constant)
+      end
+    end
+
+    def base
+      options[OPTION_BASE] || raise('Option :base not setted')
+    end
+
+    def base?
+      options[OPTION_BASE] ? true : false
+    end
+
+    def kernel_require(path)
+      ::Kernel.require(path)
+    end
+
+    def require_sub_files
       Dir["#{File.dirname(file)}/#{::File.basename(file, '.*')}/*.rb"].sort.each do |path|
-        require path
+        require_sub_file(path)
       end
     end
+
+    def require_sub_file(path)
+      active_support_require(path) || autoload_require(path) || kernel_require(path)
+    end
   end
 end