eco-helpers 3.0.37 → 3.1.1

data/lib/eco/data/files/folder.rb

@@ -0,0 +1,196 @@
+module Eco
+  module Data
+    module Files
+      module Folder
+        PRESERVED_FILES = [
+          /.*\.rb$/,
+          /.*\.sh$/,
+          /.*\.ps1$/,
+          /.*\.ya?ml$/,
+          /.*\.md$/,
+          /.*\.gemspec$/,
+          /Gem/,
+          /Rake/,
+          /LICENSE/,
+          /(?:^|[\\\/])\.[^\\\/]+$/ # i.e. `.env`, `.gitignore`
+        ].freeze
+
+        include Eco::Language::AuxiliarLogger
+        include RelativePath
+
+        # It ensure that the path to the file exists
+        def ensure_file_path!(filename)
+          return if File.exist?(filename)
+
+          FileUtils.mkdir_p(File.dirname(filename))
+        end
+
+        # @param pattern [String, Symbol] the `Dir` expression to match
+        #   the target files. When a Symbol is provided, it is used as
+        #   the expected extension of the files in the target folder `folder`.
+        # @param regexp [Regexp] a regular expression that will be matched
+        #   against the **basename** of the files in the `folder` that
+        #   matched the `pattern`.
+        # @param older_than [Integer] days
+        # @param newer_than [Integer] days
+        def folder_files( # rubocop:disable Metrics/AbcSize
+          folder  =   '.',
+          pattern =   '*',
+          regexp:     nil,
+          older_than: nil,
+          newer_than: nil,
+          &block
+        )
+          return [] unless folder.is_a?(String)
+
+          unless Dir.exist?(folder)
+            log(:error) {
+              "Folder '#{folder}' does not exist"
+            }
+            return []
+          end
+
+          folder    = to_relative_path(folder)
+          pattern ||= '.'
+          pattern   = "*.#{pattern}" if pattern.is_a?(Symbol)
+          target    = File.join(File.expand_path(folder), pattern)
+
+          to_relative_path(
+            Dir[target]
+          ).tap do |dir_files|
+            dir_files.select! {|f| File.file?(f)}
+
+            if older_than
+              dir_files.select! do |f|
+                File.mtime(f) < (Time.now - (60*60*24*older_than))
+              end
+            end
+
+            if newer_than
+              dir_files.select! do |f|
+                File.mtime(f) > (Time.now - (60*60*24*newer_than))
+              end
+            end
+
+            if regexp.is_a?(Regexp)
+              dir_files.select! do |f|
+                File.basename(f).match(regexp)
+              end
+            end
+          end.sort.tap do |files|
+            if files.empty?
+              matchers = [pattern, regexp].compact
+              log(:info) {
+                "Couldn't find local files (#{matchers}): in folder '#{folder}'"
+              }
+            else
+              log(:info) {
+                msg  = 'Found local files: '
+                msg << "\n  • "
+                msg << files.join("\n  • ")
+                msg << "\n"
+                msg
+              }
+            end
+
+            next unless block_given?
+
+            files.each(&block)
+          end
+        end
+
+        def csv_files(
+          folder =    '.',
+          regexp:     nil,
+          older_than: nil,
+          newer_than: nil,
+          &block
+        )
+          folder_files(
+            folder,
+            '*.csv',
+            regexp:     regexp,
+            older_than: older_than,
+            newer_than: newer_than,
+            &block
+          )
+        end
+
+        # @note it will exclude files matching any of the patterns defined
+        #   in `PRESERVED_FILES`
+        # @note never make `folder` an argument with default
+        #   (force it to be explicitly declared)
+        def clear_folder(
+          folder,
+          pattern =   '*',
+          regexp:     nil,
+          older_than: nil,
+          newer_than: nil,
+          timeout: 3
+        )
+          target_files = folder_files(
+            folder,
+            pattern,
+            regexp:     regexp,
+            older_than: older_than,
+            newer_than: newer_than
+          ).select do |file|
+            File.file?(file)
+          end
+
+          # safety check (exclude certain files)
+          PRESERVED_FILES.reduce(target_files) do |mem, rex|
+            mem.grep_v(rex) # excluse those matching pattern
+          end.tap do |files|
+            next if files.empty?
+
+            msg  = '  • '
+            msg << files.join("\n  • ")
+            msg << "\n"
+
+            if respond_to?(:session, true)
+              msg = "The following files will be removed:\n#{msg}"
+
+              send(:session).prompt_user(
+                'Do you want to proceed? (Y/n):',
+                explanation: msg,
+                default:     'Y',
+                timeout:     timeout
+              ) do |response|
+                next unless response.upcase.start_with?('Y')
+
+                File.delete(*files)
+              end
+            else
+              msg = "The following files have been removed:\n#{msg}"
+
+              File.delete(*files)
+
+              log(:info) { msg }
+            end
+          end
+        end
+
+        def archive_file(filename, subfolder: 'Archive')
+          src_folder    = File.dirname(filename)
+          subpath       = File.join(src_folder, subfolder)
+          FileUtils.mkdir_p(subpath)
+
+          basename      = File.basename(filename)
+          archived_file = to_relative_path(File.join(subpath, basename))
+
+          log(:info) {
+            msg  = []
+            msg << "Moving file:"
+            msg << "  • from: '#{to_relative_path(filename)}'"
+            msg << "  • to:   '#{archived_file}'"
+            msg.join("\n")
+          }
+
+          File.rename(filename, archived_file)
+          archived_file
+        end
+      end
+    end
+  end
+end

data/lib/eco/data/files/relative_path.rb

@@ -0,0 +1,54 @@
+# rubocop: disable Naming/MethodParameterName
+
+module Eco
+  module Data
+    module Files
+      module RelativePath
+        def to_relative_path(of, from: '.')
+          require 'pathname'
+
+          pn_from = to_pathname(from)
+
+          case of
+          when String, Pathname
+            pn_of = to_pathname(of)
+
+            begin
+              pn_of.relative_path_from(pn_from).to_s
+            rescue ArgumentError => err
+              puts err
+              of
+            end
+          when Array
+            of.map do |path|
+              to_relative_path(path, from: pn_from)
+            end
+          else
+            msg  = 'Expected `of` argument to be '
+            msg << 'String, Pathname, Array<String>, or Array<Pathname>. '
+            msg << "Given: #{of.class}"
+            raise ArgumentError, msg
+          end
+        end
+
+        private
+
+        def to_pathname(value)
+          abs_path =
+            case value
+            when String, Pathname
+              File.expand_path(value.to_s)
+            else
+              msg << 'String, or Pathname. '
+              msg << "Given: #{value.class}"
+              raise ArgumentError, msg
+            end
+
+          Pathname.new(abs_path)
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodParameterName

data/lib/eco/data/files/timestamp.rb

@@ -0,0 +1,18 @@
+module Eco
+  module Data
+    module Files
+      module Timestamp
+        DEFAULT_TIMESTAMP = '%Y-%m-%dT%H%M%S'.freeze
+
+        def timestamp(timestamp_pattern = DEFAULT_TIMESTAMP, date = Time.now)
+          date.strftime(timestamp_pattern)
+        end
+
+        def timestamp_file(filename, timestamp_pattern = DEFAULT_TIMESTAMP)
+          file_pattern = Eco::Data::Files::FilePattern.new(filename)
+          file_pattern.resolve(start: "#{timestamp(timestamp_pattern)}_")
+        end
+      end
+    end
+  end
+end

data/lib/eco/data/files.rb

@@ -1,11 +1,52 @@
+require 'fileutils'
+
+require_relative 'files/encoding'
+require_relative 'files/content'
+require_relative 'files/relative_path'
+require_relative 'files/folder'
+require_relative 'files/file_pattern'
+require_relative 'files/timestamp'
+require_relative 'files/directory'
+
 module Eco
   module Data
     module Files
+      class << self
+        def included(base)
+          super
+
+          base.send :include, InstanceMethods
+          base.extend ClassMethods
+        end
+      end
+
+      module InstanceMethods
+        include Eco::Data::Files::Content
+      end
+
+      module ClassMethods
+        include Eco::Data::Files::Encoding
+        include Eco::Data::Files::Folder
+        include Eco::Data::Files::Timestamp
+        include Eco::Data::Files::RelativePath
+
+        # @todo: change method name to `split_path`
+        def split(path)
+          dir_path, file = File.split(path)
+          dir_path       = dir_path.gsub(File::SEPARATOR, File::ALT_SEPARATOR || File::SEPARATOR)
+          dir_path.split(File::ALT_SEPARATOR || File::SEPARATOR).push(file)
+        end
+
+        def copy_file(source_file, dest_file, time_stamp: false)
+          dest_file = timestamp_file(dest_file) if time_stamp
+          File.write(dest_file, File.read(source_file))
+        end
+      end
+
+      class << self
+        include Files::InstanceMethods
+        include Files::ClassMethods
+      end
     end
   end
 end
-
-require_relative 'files/encoding'
-require_relative 'files/helpers'
-require_relative 'files/file_pattern'
-require_relative 'files/directory'

data/lib/eco/data/fuzzy_match.rb

@@ -8,7 +8,6 @@ require_relative 'fuzzy_match/ngrams_score'
 module Eco
   module Data
     module FuzzyMatch
-
       class << self
         def included(base)
           super
@@ -27,6 +26,7 @@ module Eco
 
         def jaro_winkler(str_1, str_2, **options)
           return 0 if !str1 || !str2
+
           options = {
             ignore_case: true,
             weight:      0.25

data/lib/eco/data/hashes/array_diff.rb

@@ -2,7 +2,7 @@ module Eco
   module Data
     module Hashes
       class ArrayDiff
-        extend Eco::Language::Models::ClassHelpers
+        extend Eco::Language::Klass::HelpersBuilt
         # We can change the `DiffResult` class (items)
         class_resolver :diff_result_class, "Eco::Data::Hash::DiffResult"
 
@@ -36,9 +36,10 @@ module Eco
         # All the items that contain the diff of a node.
         # @return [Array<Eco::Data::Hash::DiffResult>]
         def source_results
-          @source_results ||= paired_sources.each_with_object([]) do |(src_1, src_2), res|
-            res << diff_result_class.new(src_1, src_2)
-          end
+          @source_results ||=
+            paired_sources.each_with_object([]) do |(src_1, src_2), res|
+              res << diff_result_class.new(src_1, src_2)
+            end
         end
 
         protected
@@ -55,7 +56,11 @@ module Eco
         # @return [String] the `key` attribute of `diff_result_class`
         def key
           diff_result_class.key.tap do |k|
-            raise "#{diff_result_class}: missing main key attr to pair records. Given: #{k}" unless k.is_a?(String)
+            next if k.is_a?(String)
+
+            msg  = "#{diff_result_class}: missing main key attr to pair records. "
+            msg << "Given: #{k}"
+            raise msg
           end
         end
 
@@ -85,6 +90,7 @@ module Eco
             log(:error) {
               "(ArrayDiff) Input data as 'Hash' not supported. Expecting 'Enumerable' or 'String'"
             }
+
             exit(1)
           when String
             to_array_of_hashes(Eco::CSV.parse(content))

data/lib/eco/data/hashes/diff_result/meta.rb

@@ -7,7 +7,7 @@ module Eco
             def included(base)
               super
 
-              base.extend Eco::Language::Models::ClassHelpers
+              base.extend Eco::Language::Klass::HelpersBuilt
               base.extend ClassMethods
               base.inheritable_class_vars :key, :compared_attrs, :case_sensitive
             end
@@ -18,6 +18,7 @@ module Eco
             # @return [String] the attribute that is key of the node diff elements.
             def key(value = nil)
               return @key unless value
+
               @key = value.to_s
             end
 
@@ -41,7 +42,8 @@ module Eco
             # Whether or not the diff calc of a node should be done case sensitive or insensitive.
             def case_sensitive(value = nil)
               @case_sensitive = false unless instance_variable_defined?(:@case_sensitive)
-              return @case_sensitive unless value
+              return @case_sensitive  unless value
+
               @case_sensitive = !!value
             end
 
@@ -92,6 +94,7 @@ module Eco
             return true  if val_1 == val_2
             return false if case_sensitive?
             return false unless val_2 && val_1
+
             val_1.upcase == val_2.upcase
           end
 
@@ -102,8 +105,10 @@ module Eco
           def eq_ary?(val_1, val_2)
             return false unless [val_1, val_2].all? {|v| v.is_a?(Array)}
             return true  if val_1 == val_2
+
             v_1    = case_sensitive?? val_1 : val_1.map {|v| v&.upcase}
             v_2    = case_sensitive?? val_2 : val_2.map {|v| v&.upcase}
+
             joined = (v_1 | v_2)
             (joined & v_1) == (joined & v_2)
           end
@@ -112,17 +117,20 @@ module Eco
           # @note DSL to be able to modify behaviour
           #   (i.e. indifferent access for camel and snake case keys)
           def get_attr(src, key)
-            return nil unless src
+            return unless src
+
             src[key.to_s]
           end
 
           def slice_attrs(src, *keys)
-            return nil unless src
+            return unless src
+
             src.slice(*keys)
           end
 
           def key_present?(src, key)
             return false unless src
+
             src.key?(key)
           end
         end

data/lib/eco/data/locations/node_diff/accessors.rb

@@ -4,7 +4,7 @@ class Eco::Data::Locations::NodeDiff
       def included(base)
         super
 
-        base.extend Eco::Language::Models::ClassHelpers
+        base.extend Eco::Language::Klass::HelpersBuilt
         base.extend ClassMethods
         base.inheritable_class_vars :exposed_attrs
       end

data/lib/eco/data/mapper.rb

@@ -34,6 +34,10 @@ module Eco
         end
       end
 
+      def empty?
+        @by_external.empty? && @by_internal.empty?
+      end
+
       def insensitive?
         @insensitive
       end
@@ -44,7 +48,7 @@ module Eco
 
       def to_json(internal: @internal_order)
         content = as_json(internal: internal).map do |pair|
-          "  " + pair.to_json
+          "  #{pair.to_json}"
         end.join(",\n")
 
         "[\n#{content}\n]"

data/lib/eco/data.rb

@@ -6,6 +6,7 @@ end
 require_relative 'data/strings'
 require_relative 'data/files'
 require_relative 'data/mapper'
+require_relative 'data/count_trace'
 require_relative 'data/fuzzy_match'
 require_relative 'data/hashes'
 require_relative 'data/locations'

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

@@ -6,7 +6,7 @@ module Eco::Language::Delegation
       def included(base)
         super
 
-        base.extend Eco::Language::Klass::HelpersBuilt
+        base.extend Eco::Language::Klass::InheritableClassVars
         base.extend ClassMethods
         base.inheritable_class_vars :_delegating_missing, :delegating_missing_to
       end

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

@@ -6,7 +6,7 @@ module Eco::Language::Delegation
   #   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.
+  #   to chain the lookup.
   module DelegatingMissingConst
     class << self
       def included(base)

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

@@ -4,7 +4,7 @@ module Eco::Language::Delegation
       def included(base)
         super
 
-        base.extend Eco::Language::Klass::HelpersBuilt
+        base.extend Eco::Language::Klass::InheritableClassVars
         base.extend ClassMethods
         base.inheritable_class_vars :delegating_missing_on_class_to
       end

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

@@ -6,7 +6,7 @@ module Eco::Language::Delegation::ForDelegator
       def included(base)
         super
 
-        base.extend Eco::Language::Klass::HelpersBuilt
+        base.extend Eco::Language::Klass::InheritableClassVars
         base.extend ClassMethods
 
         base.inheritable_class_vars :delegated_class

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

@@ -0,0 +1,129 @@
+module Eco::Language::Klass
+  # Helpers for dynamic object loading based on class declaration
+  # @note
+  #   - this helpers aim to boost the usage of the ruby language
+  #     in complex integration configurations.
+  module AutoLoader
+    include Resolver
+    include Hierarchy
+
+    # It loads/creates a new instance of children classes pending to be loaded.
+    # @note This method **should be explicitly called**.
+    # @return [Boolean] `true` if there were children loaded, `false` otherwise.
+    def autoload_children!(object)
+      return false if @loading_children
+      return false unless autoloaded_class
+
+      pending_children = unloaded_children
+      return false if pending_children.empty?
+
+      @loading_children = true
+
+      pending_children.each do |klass|
+        @child = klass.new(object)
+      rescue TypeError => _e
+        # Can't create from this class (must be the singleton class)
+        # Just ignore
+      ensure
+        autoloaded_children.push(klass)
+      end
+
+      true
+    ensure
+      @loading_children = false
+    end
+
+    # To enable the class autoloader, you should use this  method
+    def autoloads_children_of(klass)
+      class_resolver :autoloader_class, klass
+      @autoloaded_class = klass
+    end
+
+    # Resolves the class `autoloader_class` if it has been defined via `autoloads_children_of`
+    def autoloaded_class
+      return unless @autoloaded_class
+
+      autoloader_class
+    end
+
+    # To which restricted namespaces this class autoloads from
+    def autoloaded_namespaces(type = :include)
+      @autoloaded_namespaces       ||= {}
+      @autoloaded_namespaces[type] ||= []
+    end
+
+    # To restrict which namespaces it is allowed to load from
+    def autoload_namespace(*namespaces)
+      _autoload_namespace(:include, *namespaces)
+    end
+
+    # To ignore certain namespaces this class should not autoload from
+    def autoload_namespace_ignore(*namespaces)
+      _autoload_namespace(:ignore, *namespaces)
+    end
+
+    def _autoload_namespace(type, *namespaces)
+      autoloaded_namespaces(type).concat(namespaces) unless namespaces.empty?
+    end
+
+    # @param constant [Class, String] a class or namespace we want to check auto-load entitlement thereof.
+    # @return [Boolean] determines if a given namespace is entitled for autoloading
+    def autoload_class?(constant)
+      constants = constant.to_s.split("::").compact
+      autoload  = true
+
+      unless autoloaded_namespaces(:include).empty?
+        autoload = autoloaded_namespaces(:include).any? do |ns|
+          ns.to_s.split("::").compact.zip(constants).all? {|(r, c)| r == c}
+        end
+      end
+
+      unless autoloaded_namespaces(:ignore).empty?
+        autoload &&= autoloaded_namespaces(:ignore).none? do |ns|
+          ns.to_s.split("::").compact.zip(constants).all? {|(r, c)| r == c}
+        end
+      end
+
+      autoload
+    end
+
+    # As children are loaded as they are declared, we should not load twice same children.
+    def autoloaded_children
+      @auto_loaded_children ||= [] # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+
+    # Children classes of `autoloader_class` that have not been created an instance of.
+    def unloaded_children
+      return [] unless autoloaded_class
+
+      new_detected = new_classes
+      known_class!(*new_detected)
+
+      descendants(
+        parent_class: autoloaded_class,
+        scope:        new_detected
+      ).select do |child_class|
+        next false if autoloaded_children.include?(child_class)
+        next false unless autoload_class?(child_class)
+
+        true
+      end.sort
+    end
+
+    # Known namespaces serves the purpose to discover recently added namespaces
+    #   provided that the namespace discovery is optimized
+    def known_classes
+      @known_classes ||= []
+    end
+
+    # Add to known namespaces
+    def known_class!(*classes)
+      known_classes.concat(classes)
+    end
+
+    # List all new namespaces
+    def new_classes
+      ObjectSpace.each_object(::Class).to_a - known_classes
+    end
+  end
+end