eco-helpers 3.0.26 → 3.0.28

data/lib/eco/data/fuzzy_match.rb

@@ -11,8 +11,10 @@ module Eco
 
       class << self
         def included(base)
-          base.send(:include, InstanceMethods)
-          base.extend(ClassMethods)
+          super
+
+          base.send :include, InstanceMethods
+          base.extend ClassMethods
         end
       end
 
@@ -23,7 +25,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 +33,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 +60,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)
+            next if item == needle
 
-              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
+            item_str = item_string(item)
 
-              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)
+            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 +132,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 +142,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 +151,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 +176,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 +195,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 +210,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/hashes/diff_result/meta.rb

@@ -5,7 +5,8 @@ module Eco
         module Meta
           class << self
             def included(base)
-              super(base)
+              super
+
               base.extend Eco::Language::Models::ClassHelpers
               base.extend ClassMethods
               base.inheritable_class_vars :key, :compared_attrs, :case_sensitive

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/locations/node_diff/accessors.rb

@@ -2,7 +2,8 @@ class Eco::Data::Locations::NodeDiff
   module Accessors
     class << self
       def included(base)
-        super(base)
+        super
+
         base.extend Eco::Language::Models::ClassHelpers
         base.extend ClassMethods
         base.inheritable_class_vars :exposed_attrs

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/chainable_delegator.rb

@@ -0,0 +1,18 @@
+module Eco::Language::Delegation
+  class ChainableDelegator < SimpleDelegator
+    include ForDelegator::DelegatedClass
+    include ForDelegator::ConstDelegator
+    include ForDelegator::ConstLookupHooks
+
+    # 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
+  end
+end

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

@@ -0,0 +1,104 @@
+# rubocop:disable Naming/MethodParameterName
+
+module Eco::Language::Delegation
+  module DelegatingMissing
+    class << self
+      def included(base)
+        super
+
+        base.extend Eco::Language::Klass::HelpersBuilt
+        base.extend ClassMethods
+        base.inheritable_class_vars :_delegating_missing, :delegating_missing_to
+      end
+    end
+
+    module ClassMethods
+      def delegating_missing(*these, to:)
+        msg = "Delegating to: should be String or Symbol. Given: #{to.class}"
+        raise ArgumentError, msg unless sym_or_string?(to)
+
+        these.map do |this|
+          msg = "Expecting String or Symbol. Given: #{this}."
+          raise ArgumentError, msg unless sym_or_string?(this)
+
+          this.to_sym
+        end.each do |this|
+          _delegating_missing[this] = to
+        end
+
+        self
+      end
+
+      def delegating_missing_to(to = nil)
+        return @delegating_missing_to if to.nil?
+
+        msg = "Expecting String or Symbol. Given: #{to}."
+        raise ArgumentError, msg unless sym_or_string?(to)
+
+
+        @delegating_missing_to = to.to_sym
+      end
+
+      def delegating_missing?(sym)
+        return true  if sym.nil? && delegating_missing_to
+        return false unless sym_or_string?(sym)
+        return true  if _delegating_missing.key?(sym.to_sym)
+        return true  if delegating_missing_to
+
+        false
+      end
+
+      def delegating_missing_target(instance, at: nil)
+        return unless delegating_missing?(at)
+        return unless (subject_ref = _delegating_missing[at] || delegating_missing_to)
+
+        instance_has_method =
+          instance.methods.include?(subject_ref) ||
+          instance.private_methods.include?(subject_ref)
+
+        return instance.method(subject_ref).call if instance_has_method
+        return                                   unless at.to_s.start_with?('@')
+        return                                   unless instance.instance_variable_defined?(at)
+
+        instance.instance_variable_get(at)
+      end
+
+      private
+
+      def _delegating_missing
+        @_delegating_missing ||= {}
+      end
+
+      def sym_or_string?(value)
+        return false unless value.is_a?(Symbol) || value.is_a?(String)
+        return false if value.to_s.strip.empty?
+
+        true
+      end
+    end
+
+    # INSTANCE Methods
+
+    def respond_to_missing?(method_name, include_private = false)
+      super
+    end
+
+    private
+
+    # @note if missing, redirect all parameters to `receiver`,
+    #   as long as responds_to `method_name`
+    def method_missing(method_name, *args, **kargs, &block)
+      return super unless self.class.delegating_missing?(method_name)
+
+      target = self.class.delegating_missing_target(self, at: method_name)
+
+      if method_name.to_s.start_with?('@')
+        target.instance_variable_get(method_name)
+      else
+        target.send(method_name, *args, **kargs, &block)
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodParameterName

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

@@ -0,0 +1,53 @@
+module Eco::Language::Delegation
+  # Class to lookup constants through `delegated_class`.
+  # @note it uses `DelegatingMissing`.
+  # @note it tries to lookup on the `class` of the `delegating_missing_to`
+  #   object. Which requires an instance of the delegator to exist, with
+  #   the aim of scoping its class (so it can chain constant lookup), unless
+  #   `delegated_class` is explicitly stated.
+  # @note that not setting `delegated_class` explicitly could fail
+  #   to chain the looup.
+  module DelegatingMissingConst
+    class << self
+      def included(base)
+        super
+
+        base.send :include, DelegatingMissing
+        base.send :include, ForDelegator::ConstDelegator
+        base.extend ClassMethods
+
+        # because we inject `#initialize`
+        base.send :prepend, InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      # Set always `delegated_class` when fetching the
+      # `delegating_missing_to` object.
+      def delegating_missing_target(instance, at: nil)
+        super.tap do |target|
+          next unless target
+          next unless at.nil?
+
+          delegated_class target.class
+        end
+      end
+    end
+
+    module InstanceMethods
+      # Set the `delegated_class` to chain **constant lookup**
+      # via `delegating_missing_to.class`.
+      # @note this requires that the target can be fetched without passing
+      #   parameters (as it is typically the case with `delegating_missing_to`).
+      def initialize(...)
+        super if defined?(super)
+
+        delegated_class.tap do |klass|
+          next unless (target = self.class.delegating_missing_target(self))
+
+          self.class.delegated_class target.class
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Eco::Language::Delegation
+  module DelegatingMissingOnClass
+    class << self
+      def included(base)
+        super
+
+        base.extend Eco::Language::Klass::HelpersBuilt
+        base.extend ClassMethods
+        base.inheritable_class_vars :delegating_missing_on_class_to
+      end
+    end
+
+    module ClassMethods
+      def delegating_missing_on_class_to(to = nil)
+        return @delegating_missing_on_class_to if to.nil?
+
+        msg = "Expecting String or Symbol. Given: #{to}."
+        raise ArgumentError, msg unless sym_or_string?(to)
+
+        @delegating_missing_on_class_to = to
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        super
+      end
+
+      private
+
+      # @note if missing, redirect all parameters to `target`,
+      #   as long as responds_to `method_name`
+      def method_missing(method_name, *args, **kargs, &block)
+        return super unless (target = delegating_missing_on_class_target)
+
+        target.send(method_name, *args, **kargs, &block)
+      end
+
+      # retrieves the delegating_missing_on_class_to object
+      def delegating_missing_on_class_target
+        return unless @delegating_missing_on_class_to
+
+        # fetch the object behind the method
+        method(@delegating_missing_on_class_to).call
+      end
+
+      def sym_or_string?(value)
+        return false unless value.is_a?(Symbol) || value.is_a?(String)
+        return false if value.to_s.strip.empty?
+
+        true
+      end
+    end
+  end
+end