eco-helpers 2.0.16 → 2.0.17

data/lib/eco/cli/config/use_cases.rb

@@ -5,18 +5,35 @@ module Eco
         include Eco::CLI::Config::Help
         attr_reader :core_config
 
+        class CaseConfig < Struct.new(:cases_config, :option, :type, :description, :casename, :callback)
+
+          def add_option(arg, desc = nil, &block)
+            core_config.options_set.add(arg, desc, namespace: option, &block)
+            self
+          end
+
+          private
+
+          def core_config
+            cases_config.core_config
+          end
+        end
+
+        class ActiveCase < Struct.new(:index, :option, :callback)
+
+        end
+
         def initialize(core_config:)
           @core_config  = core_config
           @linked_cases = {}
-          @description  = {}
         end
 
         # @return [String] summary of the use cases.
         def help
           ["The following are the available use cases:"].yield_self do |lines|
             max_len = keys_max_len(@linked_cases.keys)
-            @linked_cases.keys.sort.each do |key|
-              lines << help_line(key, @description[key], max_len)
+            @linked_cases.keys.sort.each do |option_case|
+              lines << help_line(option_case, @linked_cases[option_case].description, max_len)
             end
             lines
           end.join("\n")
@@ -33,18 +50,8 @@ module Eco
             raise "You must specify a valid 'case_name' when no block is provided" unless case_name
             raise "'case_name' expected to be a String. Given: #{case_name.class}" unless case_name.is_a?(String)
           end
-
-          @linked_cases[option_case] = {
-            type => {
-              option:   option_case,
-              type:     type,
-              casename: case_name,
-              callback: callback
-            }
-          }
-          @description[option_case]  = desc
-
-          self
+          puts "Overriding case config '#{option_case}'" if @linked_cases.key?(option_case)
+          @linked_cases[option_case] = CaseConfig.new(self, option_case, type, desc, case_name, callback)
         end
 
         # Scopes/identifies which usecases are being invoked from the command line
@@ -55,20 +62,13 @@ module Eco
         def active(io:)
           validate_io!(io)
           return @active_cases unless !@active_cases
-          active_cases = {}
-          @linked_cases.each do |option_case, types|
+          @active_cases = @linked_cases.each_with_object({}) do |(option_case, data), active_cases|
             next nil unless SCR.get_arg(option_case)
-            types.each do |type, data|
-              if usecase = get_usecase(io: io, data: data)
-                active_cases[usecase] = {
-                  index:    SCR.get_arg_index(option_case),
-                  option:   option_case,
-                  callback: data[:callback]
-                }
-              end
+            if usecase = get_usecase(io: io, data: data)
+              index = SCR.get_arg_index(option_case)
+              active_cases[usecase] = ActiveCase.new(index, option_case, data.callback)
             end
-          end
-          @active_cases = active_cases.sort_by {|c, d| d[:index]}.to_h
+          end.sort_by {|c, d| d.index}.to_h
         end
 
         def process(io:)
@@ -79,7 +79,7 @@ module Eco
             processed = true
             io = case_io(io: io, usecase: usecase)
             # some usecases have a callback to collect the parameters
-            data[:callback]&.call(*io.params)
+            data.callback&.call(*io.params)
             io = usecase.launch(io: io)
           end
           processed
@@ -100,17 +100,17 @@ module Eco
         end
 
         def get_usecase(io:, data:)
-          usecase    = if case_name = data[:casename]
-            io.session.usecases.case(case_name, type: data[:type])
+          usecase    = if case_name = data.casename
+            io.session.usecases.case(case_name, type: data.type)
           end
-          usecase  ||= if callback  = data[:callback]
+          usecase  ||= if callback  = data.callback
             # identify/retrieve usecase via callback
-            params  = io.params(keyed: true).merge(type: data[:type])
+            params  = io.params(keyed: true).merge(type: data.type)
             io      = io.new(**params, validate: false)
             callback.call(*io.params).tap do |usecase|
               unless usecase.is_a?(Eco::API::UseCases::UseCase)
                 msg  = "When adding a usecase, without specifying 'case_name:', "
-                msg += "the block that integrates usecase for cli option '#{data[:option]}'"
+                msg += "the block that integrates usecase for cli option '#{data.option}'"
                 msg += " must return an Eco::API::UseCases::UseCase object. It returns #{usecase.class}"
                 raise msg
               end

data/lib/eco/cli/scripting/args_helpers.rb

@@ -3,6 +3,7 @@ module Eco
     class Scripting
       module ArgsHelpers
 
+        # @return [Array<String] the command line arguments.
         def argv
           @argv || ARGV
         end
@@ -11,10 +12,18 @@ module Eco
           Argument.is_modifier?(value)
         end
 
+        # @return [Arguments] supported known arguments.
         def arguments
           @arguments ||= Arguments.new(argv)
         end
 
+        # Registers an argument as a known one.
+        def known_argument(key, with_param: false)
+          arguments.add(key, with_param: with_param)
+        end
+
+
+        # Validation to stop the `script` if among `argv` there's any **unknown** argument.
         def stop_on_unknown!(exclude: [], only_options: false)
           # validate only those that are options
           unknown = arguments.unknown(exclude: exclude)
@@ -23,18 +32,35 @@ module Eco
           end
 
           unless unknown.empty?
-            raise "There are unknown options in your command line arguments: #{unknown}"
+            msg  = "There are unknown options in your command line arguments:\n"
+            msg += "#{unknown}\n"
+            msg += "Please, remember that use case specific options should come after the use case in the command line.\n"
+            msg += "Use 'ruby main.rb -org [-usecase] --help -options' for more information"
+            raise msg
           end
         end
 
+        # @return [Boolean] if `key` is in the command line.
+        def arg?(key)
+          argv.include?(key)
+        end
+
+        # @return [Integer, nil] the position of `key` in the command line.
         def get_arg_index(key)
-          return nil if !argv.include?(key)
+          return nil if !arg?(key)
           argv.index(key)
         end
 
+        # @return [Boolean] if `key1` precedes `key2` in the command line.
+        def arg_order?(key1, key2)
+          return false unless (k1 = get_arg_index(key1)) && k2 = get_arg_index(key2)
+          k1 < k2
+        end
+
+        # @return [String, Boolean] the argument value if `with_param` or a `Boolean` if not.
         def get_arg(key, with_param: false, valid: true)
           # track what a known option looks like
-          arguments.add(key, with_param: with_param)
+          known_argument(key, with_param: with_param)
           return nil unless index = get_arg_index(key)
           value = true
           if with_param
@@ -45,6 +71,7 @@ module Eco
           return value
         end
 
+        # @return [String] the filename.
         def get_file(key, required: false, should_exist: true)
           filename = get_arg(key, with_param: true)
           if !filename && required

data/lib/eco/data.rb

@@ -6,3 +6,4 @@ end
 require_relative 'data/crypto'
 require_relative 'data/files'
 require_relative 'data/mapper'
+require_relative 'data/fuzzy_match'

data/lib/eco/data/crypto/encryption.rb

@@ -1,7 +1,7 @@
 require 'openssl'
-require 'json'
+# 'json'
 require 'base64'
-require 'pp'
+#require 'pp'
 
 require_relative '../../cli/scripting'
 
@@ -147,7 +147,7 @@ module Eco
           return str_c
           #EncryptedData.new({content: str_c, key: key, iv: iv})
 
-          
+
         end
         def aes256_decrypt(data, key: , iv: , block_octets: BLOCK_OCTETS)
           block_bits = block_bits * 8

data/lib/eco/data/files/helpers.rb

@@ -3,11 +3,13 @@ module Eco
     module Files
       DEFAULT_TIMESTAMP_PATTERN = '%Y-%m-%dT%H%M%S'
 
-      def self.included(base)
-        base.send(:include, InstanceMethods)
-        base.extend(ClassMethods)
+      class << self
+        def included(base)
+          base.send(:include, InstanceMethods)
+          base.extend(ClassMethods)
+        end
       end
-
+      
       module InstanceMethods
 
       end

data/lib/eco/data/fuzzy_match.rb

@@ -0,0 +1,119 @@
+require 'fuzzy_match'
+require 'amatch'
+require 'jaro_winkler'
+
+require_relative 'fuzzy_match/stop_words'
+require_relative 'fuzzy_match/array_helpers'
+require_relative 'fuzzy_match/string_helpers'
+require_relative 'fuzzy_match/pairing'
+require_relative 'fuzzy_match/chars_position_score'
+require_relative 'fuzzy_match/ngrams_score'
+
+module Eco
+  module Data
+    module FuzzyMatch
+
+      class << self
+        def included(base)
+          base.send(:include, InstanceMethods)
+          base.extend(ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        include ArrayHelpers
+        include StringHelpers
+        include Pairing
+        include CharsPositionScore
+        include NGramsScore
+
+        def jaro_winkler(str1, str2)
+          options = {
+            ignore_case: true,
+            weight:      0.25
+          }
+          JaroWinkler.distance(str1, str2, **options)
+        end
+
+      end
+
+      module InstanceMethods
+        include StopWords
+
+        attr_accessor :fuzzy_options
+
+        def fuzzy_options
+          @fuzzy_options ||= {}
+        end
+
+        def fuzzy_match(haystack = nil, **options)
+          return @fuzzy_match if instance_variable_defined?(:@fuzzy_match)
+          @fuzzy_options = options.merge({
+            stop_words: PREPOSITIONS + PRONOUNS + ARTICLES
+          })
+          # make it run with a native C extension (for better performance: ~130 % increase of performance)
+          ::FuzzyMatch.engine = :amatch
+          haystack = obtain_haystack(haystack).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}"
+            end
+          end
+          @fuzzy_match = ::FuzzyMatch.new(haystack, fuzzy_options)
+        end
+
+        # @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
+        # @return [Eco::Data::FuzzyMatch::Results]
+        def find_all_with_score(needle, **options)
+          results = fuzzy_match(**options).find_all_with_score(needle).each_with_object([]) do |fuzzy_results, results|
+            item, dice, lev = fuzzy_results
+            unless item == needle
+              needle_str = item_string(needle)
+              item_str   = item_string(item)
+              jaro_res   = self.class.jaro_winkler(needle_str, item_str)
+              ngram_res  = self.class.ngrams_score(needle_str, item_str, range: 3..5).ratio
+              wngram_res = self.class.words_ngrams_score(needle_str, item_str, range: 3..7).ratio
+              pos_res    = self.class.chars_position_score(needle_str, item_str).ratio
+              results << Result.new(item, item_str, dice, lev, jaro_res, ngram_res, wngram_res, pos_res)
+            end
+          end
+          Results.new(needle, item_string(needle), results)
+        end
+
+        private
+
+        # @note
+        #   - When used in an `Enumerable` it will use `to_a`, or `values` if it's a `Hash`
+        # @param data [Enumerable, nil]
+        # @return [Array<Object>] the non-repeated values of `data`
+        def obtain_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.uniq.compact
+        end
+
+        def item_string(item, attr = fuzzy_read_method)
+          return item if !item || item.is_a?(String) || !attr
+          attr = attr.to_sym
+          return item.send(attr) if item.respond_to?(attr)
+        end
+
+        def fuzzy_read_method
+          fuzzy_options[:read]
+        end
+
+      end
+
+      class << self
+        include FuzzyMatch::ClassMethods
+      end
+
+    end
+  end
+end
+
+require_relative 'fuzzy_match/score'
+require_relative 'fuzzy_match/result'
+require_relative 'fuzzy_match/results'

data/lib/eco/data/fuzzy_match/array_helpers.rb

@@ -0,0 +1,75 @@
+module Eco
+  module Data
+    module FuzzyMatch
+      module ArrayHelpers
+        # Keeps the start order of the `values` and consecutive `values` together/consecutive.
+        # @param values [Array] the input array with the values.
+        # @param range [Integer, Range] determine the lenght of the generated values.
+        # @return [Array<Array<Value>>] combinations of `range` length of `values`.
+        def ngrams(values, range=2..3)
+          [].tap do |out|
+            if range.is_a?(Integer)
+              n           = range
+              values_count = values.length
+              values.each_with_index do |word, i|
+                min = i
+                max = i + (n - 1)
+                break if values_count <= max
+                out << values[min..max].join(' ')
+              end
+              out.uniq!
+            else
+              range.each {|n| out.concat(ngrams(values, n))}
+              out.uniq!
+            end
+          end
+        end
+
+        # Keeps the start order of the `values` of the input `Array` `values`.
+        # It does **not** keep consecutive `values` together (it can jump/skip items).
+        # @param values [Array] the input array with the values.
+        # @param range [Integer, Range] determine the lenght of the generated values.
+        # @return [Array<Array<Value>>] combinations of `range` length of `values`
+        def combinations(values, range=2..3)
+          if range.is_a?(Integer)
+            values.combination(range).to_a
+          else
+            range.flat_map {|size| values.combination(size).to_a}
+          end
+        end
+
+        # It includes `combinations` that break the initial order of the `Array`.
+        # It does **not** keep consecutive `values` together (it can jump/skip items).
+        # @param values [Array] the input array with the values.
+        # @param range [Integer, Range] determine the lenght of the generated values.
+        # @return [Array<Array<Value>>] permutations of `range` length of `values`
+        def permutations(values, range=2..3)
+          combinations(values, range).tap do |out|
+            range = range.is_a?(Integer)? (range..range) : range
+            out.dup.select do |item|
+              range.include?(item.length)
+            end.each do |comb|
+              comb.permutation.to_a.tap do |perms|
+                perms.each {|perm| out << perm}
+              end
+            end
+            out.uniq!
+          end
+        end
+
+        # Helper to praper facet structure
+        # @param values1 [Array] the input array with the values to have their facet against.
+        # @param values2 [Array] the input array with the values to facet against.
+        # @return [Hash] where `keys` are `values1` and `value` of each `key` all `values2`
+        def facet(values1, values2)
+          {}.tap do |out|
+            next unless values1.is_a?(Enumerable)
+            values1 = values1.is_a?(Hash) ? values1.values : values1.to_a
+            values1.each {|val| out[val] = values2.dup}
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/data/fuzzy_match/chars_position_score.rb

@@ -0,0 +1,37 @@
+module Eco
+  module Data
+    module FuzzyMatch
+      module CharsPositionScore
+        # For each character in `str1`, a search is performed on `str2`.
+        # The search is deemed successful if a character is found in `str2` within `max_distance` characters of the current position.
+        # A score is kept of matching characters.
+        # @note This algorithm is best suited for matching mis-spellings.
+        # @max_distance [Integer] maximum char position distance to score.
+        # @normalized [Boolean] to avoid double ups in normalizing.
+        # @return [Score] the score object with the result.
+        def chars_position_score(str1, str2, max_distance: 3, normalized: false)
+          str1, str2 = normalize_string([str1, str2]) unless normalized
+          len1 = str1 && str1.length; len2 = str2 && str2.length
+          Score.new(0, len1 || 0).tap do |score|
+            next if !str1 || !str2
+            next score.increase(score.total) if str1 == str2
+            next if len1 < 2
+            pos = 0
+            len1.times do |i|
+              start = pos + 1
+              found = false
+              if pos = str2.index(str1[i])
+                if pos < (start + max_distance)
+                  found = true
+                  score.increase
+                end
+              end
+              pos = start unless found
+            end
+          end
+        end
+
+      end
+    end
+  end
+end