eco-helpers 3.0.25 → 3.0.27

data/lib/eco/data/fuzzy_match.rb

@@ -23,7 +23,7 @@ module Eco
         include CharsPositionScore
         include NGramsScore
 
-        def jaro_winkler(str1, str2, **options)
+        def jaro_winkler(str_1, str_2, **options)
           return 0 if !str1 || !str2
           options = {
             ignore_case: true,
@@ -31,26 +31,26 @@ module Eco
           }.merge(options)
 
           require 'jaro_winkler'
-          JaroWinkler.distance(str1, str2, **options)
+          JaroWinkler.distance(str_1, str_2, **options)
         end
 
       end
 
       module InstanceMethods
-        FUZZY_MATCH_OPTIONS = [
-          :identities, :groupings, :stop_words, :read,
-          :must_match_grouping, :must_match_at_least_one_word,
-          :gather_last_result, :threshold
-        ]
+        FUZZY_MATCH_OPTIONS = %i[
+          identities groupings stop_words read
+          must_match_grouping must_match_at_least_one_word
+          gather_last_result threshold
+        ].freeze
 
-        JARO_OPTIONS     = [:ignore_case, :weight]
-        NGRAMS_OPTIONS   = [:range]
-        POSITION_OPTIONS = [:max_distance]
-        RESULTS_OPTIONS  = [:order, :threshold]
+        JARO_OPTIONS     = %i[ignore_case weight].freeze
+        NGRAMS_OPTIONS   = %i[range].freeze
+        POSITION_OPTIONS = %i[max_distance].freeze
+        RESULTS_OPTIONS  = %i[order threshold].freeze
 
         include StopWords
 
-        attr_accessor :fuzzy_options
+        attr_writer :fuzzy_options
 
         def fuzzy_options
           @fuzzy_options ||= {}
@@ -58,60 +58,71 @@ module Eco
 
         def fuzzy_match(haystack_data = nil, **options)
           if instance_variable_defined?(:@fuzzy_match) && !haystack_data
-            return @fuzzy_match if fuzzy_match_options == fuzzy_match_options(options)
+            return @fuzzy_match if fuzzy_match_options == fuzzy_match_options(options) # rubocop:disable Style/SoleNestedConditional
           end
+
           @fuzzy_options = options
 
           # make it run with a native C extension (for better performance: ~130 % increase of performance)
           require 'fuzzy_match'
           require 'amatch'
+
           ::FuzzyMatch.engine = :amatch
           @fuzzy_match = ::FuzzyMatch.new(haystack(haystack_data), fuzzy_match_options)
         end
 
-        # TODO: integration for options[:unique_words] => to ensure repeated words do not bring down the score are cut by threshold
+        # @todo integration for options[:unique_words] => to ensure repeated words do not bring down
+        #   the score are cut by threshold
         # @note
         #   - When the `haystack` elements are **non** `String` objects, it excludes the needle itself from the results
         # @param needle [String, Object] object is allowed when `fuzzy_options` includes `read:` key.
         # @param needle_str [String, nil] the actual value of needle_str to be used.
         # @param haystack [Enumerable] the items to find `needle` among.
         # @return [Eco::Data::FuzzyMatch::Results]
-        def find_all_with_score(needle, needle_str: nil, haystack: nil, **options)
+        def find_all_with_score(needle, needle_str: nil, haystack: nil, **options) # rubocop:disable Metrics/AbcSize
           base_match    = fuzzy_match(haystack, **options)
           match_results = base_match.find_all_with_score(needle_str || needle)
           needle_str  ||= item_string(needle)
           results       = match_results.each_with_object([]) do |fuzzy_results, results|
             item, dice, lev = fuzzy_results
-            unless item == needle
-              item_str     = item_string(item)
-
-              if item_str.to_s.strip.empty? || needle_str.to_s.strip.empty?
-                dice = lev = jaro_res = ngram_res = ngram_res = wngram_res = pos_res  = 0
-              end
+            next if item == needle
 
-              jaro_res     ||= jaro(needle_str, item_str)
-              ngram_res    ||= ngram(needle_str, item_str)
-              wngram_res   ||= words_ngram(needle_str, item_str)
-              pos_res      ||= position(needle_str, item_str)
+            item_str = item_string(item)
 
-              results << Result.new(item, item_str, needle_str, dice, lev, jaro_res, ngram_res, wngram_res, pos_res)
+            if item_str.to_s.strip.empty? || needle_str.to_s.strip.empty?
+              dice = lev = jaro_res = ngram_res = ngram_res = wngram_res = pos_res  = 0
             end
+
+            jaro_res     ||= jaro(needle_str, item_str)
+            ngram_res    ||= ngram(needle_str, item_str)
+            wngram_res   ||= words_ngram(needle_str, item_str)
+            pos_res      ||= position(needle_str, item_str)
+
+            results << Result.new(item, item_str, needle_str, dice, lev, jaro_res, ngram_res, wngram_res, pos_res)
           end
+
           Results.new(needle, needle_str, results).tap do |res|
             res.order     = fuzzy_options[:order]     if fuzzy_options[:order]
             res.threshold = fuzzy_options[:threshold] if fuzzy_options[:threshold]
           end.relevant_results
         end
 
-        def recalculate_results(results, needle_str: nil, **options)
-          raise "You should provide a block |needle_str, item_str, needle, item|" unless block_given?
+        def recalculate_results(results, needle_str: nil, **options) # rubocop:disable Metrics/AbcSize
+          msg = "You should provide a block |needle_str, item_str, needle, item|"
+          raise msg unless block_given?
+
           new_results = results.each_with_object([]) do |result, new_results|
-            nstr, istr = yield(needle_str || results.value, result.value, results.needle, result.match)
+            nstr, istr = yield(
+              needle_str || results.value,
+              result.value,
+              results.needle,
+              result.match
+            )
 
             if istr.to_s.strip.empty?
               dice = lev = jaro_res = ngram_res = ngram_res = wngram_res = pos_res  = 1
             elsif nstr.to_s.strip.empty?
-              unless istr = needle_str
+              unless (istr = needle_str)
                 dice = lev = jaro_res = ngram_res = ngram_res = wngram_res = pos_res  = 0
               end
             end
@@ -119,7 +130,7 @@ module Eco
             require 'fuzzy_match'
             require 'amatch'
             res          = ::FuzzyMatch.score_class.new(nstr, istr) unless dice && lev
-            
+
             dice       ||= res&.dices_coefficient_similar || 0
             lev        ||= res&.levenshtein_similar       || 0
             jaro_res   ||= jaro(nstr, istr)
@@ -129,6 +140,7 @@ module Eco
 
             new_results << Result.new(*result.values_at(:match, :value, :needle_str), dice, lev, jaro_res, ngram_res, wngram_res, pos_res)
           end
+
           Results.new(results.needle, results.value, new_results).tap do |res|
             res.order     = options[:order]     if options[:order]
             res.threshold = options[:threshold] if options[:threshold]
@@ -137,24 +149,24 @@ module Eco
 
         private
 
-        def jaro(str1, str2)
+        def jaro(str_1, str_2)
           options = fuzzy_options.slice(*JARO_OPTIONS)
-          self.class.jaro_winkler(str1, str2, **options)
+          self.class.jaro_winkler(str_1, str_2, **options)
         end
 
-        def ngram(str1, str2)
+        def ngram(str_1, str_2)
           options = { range: 3..5 }.merge(fuzzy_options.slice(*NGRAMS_OPTIONS))
-          self.class.ngrams_score(str1, str2, **options).ratio
+          self.class.ngrams_score(str_1, str_2, **options).ratio
         end
 
-        def words_ngram(str1, str2)
+        def words_ngram(str_1, str_2)
           options = { range: 3..7 }.merge(fuzzy_options.slice(*NGRAMS_OPTIONS))
-          self.class.words_ngrams_score(str1, str2, **options).ratio
+          self.class.words_ngrams_score(str_1, str_2, **options).ratio
         end
 
-        def position(str1, str2)
+        def position(str_1, str_2)
           options = fuzzy_options.slice(*POSITION_OPTIONS)
-          self.class.chars_position_score(str1, str2, **options).ratio
+          self.class.chars_position_score(str_1, str_2, **options).ratio
         end
 
         # @note
@@ -162,12 +174,18 @@ module Eco
         # @param data [Enumerable, nil]
         # @return [Array<Object>] the non-repeated values of `data`
         def haystack(data = nil)
-          data = self if self.is_a?(Enumerable) && !data
-          raise "'data' should be an Enumerable. Given: #{data.class}" unless data.is_a?(Enumerable)
-          data = self.is_a?(Hash) ? self.values.flatten : to_a.flatten
+          data = self if is_a?(Enumerable) && !data
+
+          msg = "'data' should be an Enumerable. Given: #{data.class}"
+          raise ArgumentError, msg unless data.is_a?(Enumerable)
+
+          data = is_a?(Hash) ? values.flatten : to_a.flatten
+
           data.uniq.compact.tap do |items|
-            if !fuzzy_read_method && found = items.find {|item| !item.is_a?(String)}
-              raise "To use non String objects as 'haystack' you should provide `read:` or `options[:read]`. Given element: #{found.class}"
+            if !fuzzy_read_method && (found = items.find {|item| !item.is_a?(String)})
+              msg  = "To use non String objects as 'haystack' you should provide `read:` or `options[:read]`. "
+              msg << "Given element: #{found.class}"
+              raise ArgumentError, msg
             end
           end
         end
@@ -175,12 +193,13 @@ module Eco
         def item_string(item, attr = fuzzy_read_method)
           return item if !item || item.is_a?(String) || !attr
           return attr.call(item) if attr.is_a?(Proc)
+
           attr = attr.to_sym
-          return item.send(attr) if item.respond_to?(attr)
+          item.send(attr) if item.respond_to?(attr, true)
         end
 
         def fuzzy_match_options(options = nil)
-          options = fuzzy_options unless options
+          options ||= fuzzy_options
           options.slice(*FUZZY_MATCH_OPTIONS).merge({
             stop_words: PREPOSITIONS + PRONOUNS + ARTICLES
           })
@@ -189,13 +208,11 @@ module Eco
         def fuzzy_read_method
           fuzzy_match_options[:read]
         end
-
       end
 
       class << self
         include FuzzyMatch::ClassMethods
       end
-
     end
   end
 end

data/lib/eco/data/locations/node_base/treeify.rb

@@ -16,7 +16,7 @@ module Eco::Data::Locations::NodeBase
       raise ArgumentError, msg unless node.is_a?(Eco::Data::Locations::NodeBase)
 
       node.node_hash.tap do |json|
-        json.merge!({"parent_id" => parent_id}) unless parent_id == :unused
+        json.merge!({'parent_id' => parent_id}) unless parent_id == :unused
         json.merge!(yield(node, json))          if block_given?
       end
     end
@@ -90,7 +90,7 @@ module Eco::Data::Locations::NodeBase
 
         node_hash = serialize_node(child, parent_id: node_id, &block)
         results  << node_hash
-        node_hash["nodes"] = get_children(
+        node_hash['nodes'] = get_children(
           child.id,          parents,
           parent: child,     done_ids: done_ids,
           level:  level + 1, skipped:  skipped,
@@ -105,7 +105,7 @@ module Eco::Data::Locations::NodeBase
     end
 
     def parent_msg(parent)
-      parent ? "child of '#{parent.id}'" : "top level"
+      parent ? "child of '#{parent.id}'" : 'top level'
     end
 
     def level_msg(level)
@@ -113,7 +113,7 @@ module Eco::Data::Locations::NodeBase
     end
 
     def indent(level)
-      " " * level
+      ' ' * level
     end
 
     # Method to ensure the results are consistent
@@ -122,7 +122,7 @@ module Eco::Data::Locations::NodeBase
     #     because otherwise would be part of `done_ids` anyway.
     # @param unlinked_trees [Array<Hash>] by excluding those done and skipped,
     #   it will treeify the unlinked nodes (the exclusion applies to `parants_hash`)
-    def check_results( # rubocop:disable Metrics/AbcSize
+    def check_results( # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       _tree,        nodes,       parents,
       done_ids: {}, skipped: [], unlinked_trees: [],
       warns:    [], &block
@@ -138,9 +138,9 @@ module Eco::Data::Locations::NodeBase
 
       # The reason of missing nodes in the output tree is unknown!
       if skipped.empty? && unlinked_parent_ids.empty?
-        msg = []
-        msg << "BUG in this library (open issue with maintainers)."
-        msg << "There were no skipped nodes nor missin referred parents, and yet:"
+        msg  = []
+        msg << 'BUG in this library (open issue with maintainers).'
+        msg << 'There were no skipped nodes nor missin referred parents, and yet:'
         msg << "  * the tree nodes count: #{done_ids.count} ..."
         msg << "  * doesn't match the original nodes count: #{nodes.count}"
         raise msg.join("\n")
@@ -181,7 +181,7 @@ module Eco::Data::Locations::NodeBase
         str_skipped = (residual_skipped.count < 15 ? " => #{residual_skipped.map(&:id).join(', ')}" : '')
 
         msg = []
-        msg << "After treeifying via the unlinked_parents:"
+        msg << 'After treeifying via the unlinked_parents:'
         msg << "  * total_nodes: #{nodes.count}"
         msg << "  * tracked_nodes: #{tracked_nodes.count}"
         msg << "  * untracked_nodes: #{untracked_nodes.count}"
@@ -230,14 +230,16 @@ module Eco::Data::Locations::NodeBase
         node_hash   = serialize_node(child, parent_id: node_id, &block) unless src_plain
         descendants = get_tree_nodes_raw(child.id, parents, src_plain: src_plain, &block).tap do |desc|
           next unless (nil_count = desc.count(nil)).positive?
+
           log(:debug) {
             "get_tree_nodes_raw gave #{nil_count} nil values for nodes of #{child.id}"
           }
         end
+
         next results.concat(descendants) if src_plain
 
         results << node_hash.merge({
-          "nodes" => descendants.compact
+          'nodes' => descendants.compact
         })
       end
     end
@@ -256,7 +258,7 @@ module Eco::Data::Locations::NodeBase
 
     # With given a skipped `node` (repeated `id`), it gives different warnings,
     # provided that the context in which the double-up `id` happened is identified.
-    def report_skipped_node( # rubocop:disable Metrics/AbcSize
+    def report_skipped_node( # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists, Metrics/MethodLength
       node,        parent,
       done_ids,    level,
       level_ids,   parents,

data/lib/eco/data/mapper.rb

@@ -2,7 +2,7 @@ module Eco
   module Data
     class Mapper
       # it expects [[v1a, v1b], [v2a, v2b] ...]
-      def initialize (array_of_arrays = [], internal: :last, insensitive: false)
+      def initialize(array_of_arrays = [], internal: :last, insensitive: false)
         @internal_order = internal
         @source         = array_of_arrays
         @insensitive    = insensitive
@@ -23,7 +23,7 @@ module Eco
           end
         end
 
-        @by_internal = @source.reverse.map(&:reverse).to_h.tap do |h_data|
+        @by_internal = @source.reverse.to_h(&:reverse).tap do |h_data|
           next unless insensitive?
 
           h_data.dup.each do |key, value|
@@ -57,7 +57,7 @@ module Eco
         src_dup.map(&:reverse)
       end
 
-      def +(array_of_arrays)
+      def +(array_of_arrays) # rubocop:disable Naming/BinaryOperatorParameterName
         self.class.new(array_of_arrays + to_a, internal: @internal_order)
       end
 
@@ -70,7 +70,7 @@ module Eco
       end
 
       def internal?(value)
-        return true         unless @source
+        return true unless @source
 
         value = value.downcase if insensitive?
         @by_internal.key?(value)

data/lib/eco/language/auxiliar_logger.rb

@@ -9,8 +9,8 @@ module Eco
       def logger
         if instance_variable_defined?(:@session) && !@session.nil?
           @session.logger
-        elsif respond_to?(:session)
-          session.logger
+        elsif respond_to?(:session, true)
+          send(:session).logger
         elsif Object.const_defined?(:ASSETS)
           ASSETS.session.logger
         elsif defined?(super)
@@ -31,8 +31,8 @@ module Eco
         levels = levels.compact.uniq.map(&:to_sym)
         levels.unshift(:info) if levels.include?(:general) && levels.length == 1
 
-        levels.each do |level|
-          next unless logger.respond_to?(:level)
+        levels.uniq.each do |level|
+          next unless logger.respond_to?(:level, true)
 
           logger.send(level, &block)
         end

data/lib/eco/language/delegation/const_delegator.rb

@@ -0,0 +1,64 @@
+module Eco::Language::Delegation
+  # Module that is to be used with ruby `Delegator` or related helpers,
+  # such as `SimpleDelegator` or `Forwardable`.
+  # @note it includes `DelegatedClass`
+  # @note it looks up the constant via `delegated_class`. This is because
+  #   on `Delegator` approaches, the intance object (`self`) points to the
+  #   delegated object, which doesn't allow to refer to `self.class` to
+  #   implement a delegation of constants that other way.
+  #   For example, `self.class::CONSTANT` will not point to the delegator
+  #   class constant, but to the constant of the delegated object's class.
+  module ConstDelegator
+    class << self
+      private
+
+      def included(base)
+        super
+
+        base.send :include, Eco::Language::DelegatedClass
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def const_defined?(str, inherit = true, delegated: true)
+        return super(str, inherit) if super(str, inherit) || !delegated
+        return true                if delegated_class&.const_defined?(str, inherit)
+
+        false
+      end
+
+      def const_get(str)
+        return super                          if const_defined?(str, delegated: false)
+        return delegated_class.const_get(str) if delegated_class&.const_defined?(str)
+
+        super
+      end
+
+      def const_missing(str)
+        return super unless const_defined?(str)
+
+        const_get(str)
+      end
+
+      def constants(inherited = true, delegated: true)
+        super(inherited).dup.tap do |consts|
+          next unless delegated && delegated_class
+
+          delegated_class.constants(inherited).each do |const|
+            consts.unshift(const)
+          end
+        end
+      end
+
+      private
+
+      def remove_const(str)
+        return super unless const_defined?(str)
+        return super if const_defined?(str, delegated: false)
+
+        raise NameError, "#{str} not defined (is delegated to #{delegated_class})"
+      end
+    end
+  end
+end

data/lib/eco/language/delegation/const_lookup_hooks.rb

@@ -0,0 +1,81 @@
+module Eco::Language::Delegation
+  # This approach only makes sense to be used in `Delegator` and related helpers.
+  # @note it includes `ConstDelegator` (which includes `DelegatedClass`)
+  # @note for each not inherited constant that isn't part of the delegated object's
+  #   class, it will create a undercore/snake named instance method, to ease
+  #   constant lookup througout chained/wrapped delegators.
+  module ConstLookupHooks
+    class << self
+      private
+
+      def included(base)
+        super
+
+        base.send :include, Eco::Language::Delegation::ConstDelegator
+
+        base.extend(ClassMethods)
+        base.send :install_constant_lookup_hooks
+      end
+    end
+
+    module ClassMethods
+      private
+
+      def inherited(subclass)
+        super
+
+        subclass.send :install_constant_lookup_hooks
+      end
+
+      def const_added(sym)
+        install_constant_lookup_hook(const: sym)
+      end
+
+      # Drawback is this will also create methods for modules and classes hanging
+      # from `base` namespace. Unfortunatelly, we need to go with them, because
+      # it might happen a constant points to one of them to implement some behaviour.
+      def install_constant_lookup_hooks(base = self)
+        # Only method-hook constants that are not inherited,
+        # nor delegated to the decorated class.
+        # This constraint ensure that we don't overpopulate with hook methods,
+        # and that the lookup respects the order in which the decorators are
+        # wrapped (i.e. Sugar.new(Milk.new(Coffe.new)) < Sugar(Milk(Coffee)) ).
+        base.constants(false, delegated: false).each do |const|
+          install_constant_lookup_hook(base, const: const)
+        end
+      end
+
+      def install_constant_lookup_hook(base = self, const:)
+        meth_name = underscore(const).to_sym
+        return if instance_method?(base, name: meth_name, include_private: true)
+
+        method_def = proc do |*args, **kargs, &block|
+          return super(*args, **kargs, &block) if defined?(super)
+
+          base.const_get(const)
+        end
+
+        base.define_method(meth_name, &method_def)
+      end
+
+      # @see https://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-underscore
+      def underscore(sym)
+        return super if defined?(super)
+        return sym.to_s.dup unless /[A-Z-]|::/.match?(sym)
+
+        word = sym.to_s.gsub('::', '/')
+        word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, '_')
+        word.tr!('-', '_')
+        word.downcase!
+        word
+      end
+
+      def instance_method?(base = self, name:, include_private: false)
+        return true  if base.method_defined?(name)
+        return false unless include_private
+
+        base.private_instance_methods.include?(name.to_sym)
+      end
+    end
+  end
+end

data/lib/eco/language/delegation/delegated_class.rb

@@ -0,0 +1,84 @@
+module Eco::Language::Delegation
+  module DelegatedClass
+    class << self
+      private
+
+      def included(base)
+        super
+
+        base.extend(ClassMethods)
+        base.send :patch_class_compare
+      end
+    end
+
+    module ClassMethods
+      def delegated_class(klass = nil)
+        return @delegated_class if klass.nil?
+
+        @delegated_class = klass
+      end
+
+      private
+
+      def inherited(subclass)
+        super
+
+        subclass.instance_variable_set(:@delegated_class, @delegated_class)
+      end
+
+      def patch_class_compare(base = self)
+        %i[< <= ==].each do |op|
+          base.singleton_class.define_method(op) do |other|
+            return super(other) unless delegated_class
+            return true         if super(other)
+
+            delegated_class.send(op, other)
+          end
+        end
+      end
+    end
+
+    # Instance methods
+
+    # It allows to chain delegators, when the first parameter is an
+    # instance of `delegated_class`.
+    # @note it also allows to create an instance of `delegated_class`
+    #   on initialization.
+    def initialize(*args, **kargs, &block)
+      obj = args.first
+      obj = new(*args, **kargs, &block) unless of_kind?(obj)
+
+      super(obj)
+    end
+
+    def delegated_class
+      self.class.delegated_class
+    end
+
+    def new(...)
+      delegated_class.new(...)
+    end
+
+    def of_kind?(obj)
+      return true  if obj.is_a?(delegated_class)
+      return false unless obj.is_a(Delegator)
+      return true  if obj.__get_obj__.is_a?(delegated_class)
+
+      false
+    end
+
+    def is_a?(base)
+      return true  if super
+      return false unless delegated_class
+      return true  if delegated_class <= base
+
+      false
+    end
+
+    def instance_of?(base)
+      return true if base == delegated_class
+
+      super
+    end
+  end
+end

data/lib/eco/language/delegation.rb

@@ -0,0 +1,8 @@
+module Eco::Language
+  module Delegation
+  end
+end
+
+require_relative 'delegation/delegated_class'
+require_relative 'delegation/const_delegator'
+require_relative 'delegation/const_lookup_hooks'

data/lib/eco/language/klass/when_inherited.rb

@@ -9,6 +9,7 @@ module Eco
 
         def when_inherited(&block)
           return @when_inherited unless block_given?
+
           @when_inherited = block
         end
       end

data/lib/eco/language/methods/delegate_missing.rb

@@ -8,6 +8,7 @@ module Eco
 
         def method_missing(method_name, *args, **kargs, &block)
           super unless (receiver = object_missing_delegated_to)
+
           receiver.send(method_name, *args, **kargs, &block)
         end