ehbrs-tools 0.13.0 → 0.16.0

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

@@ -1,21 +1,25 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/object'
-require 'eac_ruby_utils/patches/object/asserts'
+require 'eac_ruby_utils/core_ext'
 
 module EacRubyUtils
   class PathsHash
+    require_sub __FILE__
+
     class << self
       def parse_entry_key(entry_key)
         r = entry_key.to_s.strip
-        raise EntryKeyError, 'Entry key cannot start or end with dot' if
+        raise ::EacRubyUtils::PathsHash::EntryKeyError, 'Entry key cannot start or end with dot' if
         r.start_with?('.') || r.end_with?('.')
 
         r = r.split('.').map(&:strip)
-        raise EntryKeyError, "Entry key \"#{entry_key}\" is empty" if r.empty?
+        if r.empty?
+          raise ::EacRubyUtils::PathsHash::EntryKeyError, "Entry key \"#{entry_key}\" is empty"
+        end
         return r.map(&:to_sym) unless r.any?(&:blank?)
 
-        raise EntryKeyError, "Entry key \"#{entry_key}\" has at least one blank part"
+        raise ::EacRubyUtils::PathsHash::EntryKeyError,
+              "Entry key \"#{entry_key}\" has at least one blank part"
       end
     end
 
@@ -26,68 +30,27 @@ module EacRubyUtils
     end
 
     def [](entry_key)
-      root.read_entry(self.class.parse_entry_key(entry_key), [])
+      root.read_entry(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
     end
 
     def []=(entry_key, entry_value)
-      root.write_entry(self.class.parse_entry_key(entry_key), entry_value, [])
+      root.write_entry(
+        ::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key), entry_value
+      )
     end
 
-    delegate :to_h, to: :root
-
-    private
-
-    attr_reader :data
-
-    class EntryKeyError < StandardError
+    def fetch(entry_key)
+      root.fetch(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
     end
 
-    class Node
-      def initialize(source_hash)
-        source_hash.assert_argument(Hash, 'source_hash')
-        @data = source_hash.map { |k, v| [k.to_sym, v.is_a?(Hash) ? Node.new(v) : v] }.to_h
-      end
-
-      def to_h
-        data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
-      end
-
-      def read_entry(path, current)
-        validate_path(path, current)
-        node_key = path.shift
-        node = data[node_key]
-        return (node.is_a?(Node) ? node.to_h : node) if path.empty?
-        return nil if node.blank?
-        return node.read_entry(path, current + [node_key]) if node.is_a?(Node)
-
-        raise(EntryKeyError,
-              "Path #{current.join(',')} is not a Node and path continues (#{current + path})")
-      end
-
-      def write_entry(path, value, current)
-        validate_path(path, current)
-        node_key = path.shift
-        write_entry_value(path, node_key, value, current)
-      end
-
-      private
+    def key?(entry_key)
+      root.entry?(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
+    end
 
-      def write_entry_value(path, node_key, value, current)
-        if path.empty?
-          data[node_key] = value.is_a?(Hash) ? Node.new(value) : value
-        else
-          data[node_key] = Node.new({}) unless data[node_key].is_a?(Node)
-          data[node_key].write_entry(path, value, current + [node_key])
-        end
-      end
+    delegate :to_h, to: :root
 
-      def validate_path(path, current)
-        path.assert_argument(Array, 'path')
-        current.assert_argument(Array, 'current')
-        raise EntryKeyError, 'Path is empty' if path.empty?
-      end
+    private
 
-      attr_reader :data
-    end
+    attr_reader :data
   end
 end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class PathsHash
+    class EntryKeyError < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/paths_hash/entry_key_error'
+
+module EacRubyUtils
+  class PathsHash
+    class Node
+      PATH_SEARCH_UNENDED_ERROR_MESSAGE = 'Path search is not a Node and is not ended'
+
+      def initialize(source_hash)
+        source_hash.assert_argument(Hash, 'source_hash')
+        @data = source_hash.map { |k, v| [k.to_sym, v.is_a?(Hash) ? Node.new(v) : v] }.to_h
+      end
+
+      def entry?(path_search)
+        return false unless data.key?(path_search.cursor)
+        return true if path_search.ended?
+        return data.fetch(path_search.cursor).entry?(path_search.succeeding) if
+          data.fetch(path_search.cursor).is_a?(Node)
+
+        false # Paths continue and there is not available nodes
+      end
+
+      def fetch(path_search)
+        if data.key?(path_search.cursor)
+          node = data.fetch(path_search.cursor)
+          return (node.is_a?(Node) ? node.to_h : node) if path_search.ended?
+          return nil if node.blank?
+          return node.fetch(path_search.succeeding) if node.is_a?(Node)
+        end
+
+        path_search.raise_error(PATH_SEARCH_UNENDED_ERROR_MESSAGE)
+      end
+
+      def to_h
+        data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
+      end
+
+      def read_entry(path_search)
+        node = data[path_search.cursor]
+        return (node.is_a?(Node) ? node.to_h : node) if path_search.ended?
+        return nil if node.blank?
+        return node.read_entry(path_search.succeeding) if node.is_a?(Node)
+
+        path_search.raise_error(PATH_SEARCH_UNENDED_ERROR_MESSAGE)
+      end
+
+      def write_entry(path_search, value)
+        if path_search.ended?
+          data[path_search.cursor] = value.is_a?(Hash) ? self.class.new(value) : value
+        else
+          assert_data_node(path_search.cursor).write_entry(path_search.succeeding, value)
+        end
+      end
+
+      private
+
+      attr_reader :data
+
+      def assert_data_node(key)
+        data[key] = self.class.new({}) unless data[key].is_a?(Node)
+        data[key]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class PathsHash
+    class PathSearch
+      class << self
+        def parse_entry_key(string)
+          new(::EacRubyUtils::PathsHash.parse_entry_key(string), [])
+        end
+      end
+
+      common_constructor :current, :previous do
+        self.current = current.assert_argument(Array, 'current').freeze
+        self.previous = previous.assert_argument(Array, 'previous')
+        raise ::EacRubyUtils::PathsHash::EntryKeyError, 'Current is empty' if current.empty?
+      end
+
+      def cursor
+        current.first
+      end
+
+      def ended?
+        current.count <= 1
+      end
+
+      def raise_error(message)
+        raise ::EacRubyUtils::PathsHash::EntryKeyError, "#{message} (#{self})"
+      end
+
+      def succeeding
+        self.class.new(current[1..-1], previous + [cursor])
+      end
+
+      def to_s
+        "#{self.class}[Current: #{current}, Previous: #{previous}]"
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_support/inflector'
+require 'eac_ruby_utils/listable'
 
 module EacRubyUtils
   class << self
@@ -10,15 +11,14 @@ module EacRubyUtils
   end
 
   class RequireSub
-    BASE_OPTION_KEY = :base
-    INCLUDE_MODULES_OPTION_KEY = :include_modules
-    REQUIRE_DEPENDENCY_OPTION_KEY = :require_dependency
+    include ::EacRubyUtils::Listable
+    lists.add_symbol :option, :base, :include_modules, :require_dependency
 
     attr_reader :file, :options
 
     def initialize(file, options = {})
       @file = file
-      @options = options
+      @options = self.class.lists.option.hash_keys_validate!(options)
     end
 
     def apply
@@ -29,7 +29,7 @@ module EacRubyUtils
     private
 
     def active_support_require(path)
-      return false unless options[REQUIRE_DEPENDENCY_OPTION_KEY]
+      return false unless options[OPTION_REQUIRE_DEPENDENCY]
 
       ::Kernel.require_dependency(path)
       true
@@ -46,7 +46,7 @@ module EacRubyUtils
     end
 
     def include_modules
-      return unless options[INCLUDE_MODULES_OPTION_KEY]
+      return unless options[OPTION_INCLUDE_MODULES]
 
       base.constants.each do |constant_name|
         constant = base.const_get(constant_name)
@@ -57,11 +57,11 @@ module EacRubyUtils
     end
 
     def base
-      options[BASE_OPTION_KEY] || raise('Option :base not setted')
+      options[OPTION_BASE] || raise('Option :base not setted')
     end
 
     def base?
-      options[BASE_OPTION_KEY] ? true : false
+      options[OPTION_BASE] ? true : false
     end
 
     def kernel_require(path)

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/ruby/command.rb

@@ -8,7 +8,8 @@ module EacRubyUtils
     # A [EacRubyUtils::Envs::Command] which runs in a clean Ruby environment.
     class Command < ::EacRubyUtils::Envs::Command
       def initialize(bundle_args, extra_options = {})
-        super(::EacRubyUtils::Envs.local, bundle_args, extra_options)
+        host_env = extra_options.delete(:host_env)
+        super(host_env || ::EacRubyUtils::Envs.local, bundle_args, extra_options)
       end
 
       %w[system execute].each do |method_prefix|

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/simple_cache.rb

@@ -21,8 +21,12 @@ module EacRubyUtils
       end
     end
 
-    def reset_cache
-      @cache_keys = nil
+    def reset_cache(*keys)
+      if keys.any?
+        keys.each { |key| cache_keys.delete(key) }
+      else
+        @cache_keys = nil
+      end
     end
 
     private

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/struct.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/object/blank'
+
+module EacRubyUtils
+  class Struct
+    def initialize(initial_data = {})
+      self.data = ::ActiveSupport::HashWithIndifferentAccess.new(initial_data)
+    end
+
+    def [](key)
+      key, bool = parse_key(key)
+      bool ? self[key].present? : data[key]
+    end
+
+    def fetch(key)
+      key, bool = parse_key(key)
+      bool ? fetch(key).present? : data.fetch(key)
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      property_method?(method_name) ? fetch(method_name) : super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      property_method?(method_name) || super
+    end
+
+    def slice_fetch(*keys)
+      self.class.new(keys.map { |key| [key, fetch(key)] }.to_h)
+    end
+
+    def to_h
+      data.dup
+    end
+
+    delegate :to_s, to: :data
+
+    private
+
+    attr_accessor :data
+
+    def parse_key(key)
+      m = /\A(.+)\?\z/.match(key.to_s)
+      [(m ? m[1] : key.to_s).to_sym, m ? true : false]
+    end
+
+    def property_method?(key)
+      property_methods.include?(key.to_sym)
+    end
+
+    def property_methods
+      data.keys.flat_map { |k| [k.to_sym, "#{k}?".to_sym] }
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  VERSION = '0.40.0'
+  VERSION = '0.50.0'
 end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/blank_not_blank_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/blank_not_blank'
+
+RSpec.describe ::EacRubyUtils::BlankNotBlank do
+  let(:instance) { described_class.instance }
+
+  it do
+    expect { described_class.new }.to raise_error(::NoMethodError)
+  end
+
+  it { expect(instance).to be_present }
+  it { expect(instance).not_to be_blank }
+  it { expect(instance).to be_truthy }
+  it { expect(instance).to eq('') }
+end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/configs_spec.rb

@@ -28,4 +28,19 @@ RSpec.describe ::EacRubyUtils::Configs do
 
     it { expect(::YAML.load_file(storage_path)).to eq(parent: { child: 'value1' }) }
   end
+
+  describe '#read' do
+    let(:present_key) { 'a.present.key' }
+    let(:blank_key) { 'a.blank.key' }
+
+    before do
+      instance[present_key] = 'A value'
+      instance[blank_key] = ''
+      instance.save
+      instance.load
+    end
+
+    it { expect(instance[present_key]).to be_present }
+    it { expect(instance[blank_key]).to be_present }
+  end
 end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/inflector_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/inflector'
+
+RSpec.describe ::EacRubyUtils::Inflector do
+  describe '#variableize' do
+    {
+      '_A_variableName' => 'a_variablename'
+    }.each do |source, expected|
+      context "when source is \"#{source}\"" do
+        it { expect(described_class.variableize(source)).to eq(expected) }
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/current_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/enumerator/current'
+
+RSpec.describe ::Enumerator do
+  let(:list) { %w[a b] }
+  let(:instance) { list.each }
+
+  it { expect(instance).to be_a(described_class) }
+  it { expect(instance.current).to eq('a') }
+
+  context 'with first next' do
+    before { instance.next }
+
+    it { expect(instance.current).to eq('b') }
+  end
+
+  context 'with last next' do
+    before do
+      instance.next
+      instance.next
+    end
+
+    it { expect(instance.current).to eq(nil) }
+  end
+end