eco-helpers 3.0.27 → 3.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc0d97c18d012621fea4cc9df6f7f3af54ba2a29da761c123c2502e7708f2267
-  data.tar.gz: ea83680a1a302da67ecdded6a0ea22043effe995d496c88289e7f55d54c9bde1
+  metadata.gz: 3f36ef48b8d70b2ac8b50e32a823d99d8bec5e32a76975357cf2298a6247a694
+  data.tar.gz: 60c6b240668df642d9bba41bc67011a02f7602e143aaabc2e4a25d2f9aa5d5dc
 SHA512:
-  metadata.gz: 2c0c45e02b3d5ee47fe5de33d38a4b1ade68eb759d1134b1df6c0880cbbba128f78299b2687af9177ca858a353e750339c2a85fc9731f78d194fd347faf329f0
-  data.tar.gz: 96e499c457c58667a29fffd0f0779bc986b6fc5635c1de4a5d0be5526778bd6065f6305f94c39f63badebfd8474ac76c5c780c766d28ae4824d1743ddf49e986
+  metadata.gz: 70393a40919bf80751385734885c88914a80acc47a80d5a068be431b4abd2e9677d8e1707dbeaf8510de49dc519d00441df3ffe2bed4ee8f50663895caf2e778
+  data.tar.gz: 44cc94d912bdcee5ec8140ce8d78a0b2a10feb8c609944147446e4337641ca53394ee3e798b17d970cae887b07313ed511a4840e47af7fa903595311a5923eba

data/CHANGELOG.md

@@ -2,7 +2,45 @@
 
 All notable changes to this project will be documented in this file.
 
-## [3.0.27] - 2025-03-xx
+## [3.0.29] - 2025-03-xx
+
+### Added
+
+### Changed
+
+### Fixed
+
+## [3.0.28] - 2025-03-31
+
+### Added
+
+- `Language::Delegation::DelegatingMissing` (rails alike, but ending with `ing`).
+- `Language::Delegation::DelegatingMissingConst`.
+- `Language::Delegation::ChainableDelegator`
+- `Language::Strings::Underscore`
+- `Eco::API::UseCases::Lib::Files::Sftp`
+  - **Added** named argument `only_latest` to fetch only latest file (**newest**).
+
+### Changed
+
+- `Eco::API::UseCases::Lib::Files::Sftp#local_folder`
+  - **Remove** default to `.` (current/root directory).
+- **Moved** `Language::Methods::DelegateMissing` to `Language::Delegation::DelegatingMissingOnClass`
+  - **Renamed** `::delegate_missing_to` to `::delegating_missing_on_class_to`
+- **Moved** `DelegatedClass`, `ConstDelegator` and `ConstLookupHooks` from `Language::Delegation` to `Language::Delegation::ForDelegator`
+- `DelegatedClass`
+  - **Moved** `#initialize` to the **new** `ChainableDelegator` sample
+  - **Moved** requirement for base to be a `Delegator` or subclass thereof.
+    - The requirement is now part of `ConstLookupHooks`, as this particular concern only makes sense on `Delegator` subclasses.
+- **Moved** (by keeping backwards compatibility) `Eco::API::Common::ClassHelpers` to decoupled helpers in `Eco::Language::Klass`
+- **Manage Exception** on `Eco::API::Common::Session::SFTP#upload`
+  - **Added** remote `dest_file` feedback
+
+### Fixed
+
+- **Remove** recursive call on `Lib::Files::FilePattern#file_pattern_const`
+
+## [3.0.27] - 2025-03-29
 
 ### Added
 

data/eco-helpers.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   #spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_development_dependency 'byebug'
   spec.add_development_dependency 'rake',      '>= 13.0.3', '< 14'
   spec.add_development_dependency 'redcarpet', '>= 3.6.0',  '< 4'
   spec.add_development_dependency 'rspec',     '>= 3.12.0', '< 4'

data/lib/eco/api/common/class_helpers.rb

@@ -2,142 +2,7 @@ module Eco
   module API
     module Common
       module ClassHelpers
-        # Creates a class and instance object methods with name `name` to resolve `klass` name
-        def class_resolver(name, klass)
-          define_singleton_method(name) { resolve_class(klass) }
-          define_method(name) { self.class.resolve_class(klass) }
-        end
-
-        # With given a `klass` name it resolves to an actual `Class`
-        # @return [Class] the class that was being searched by name `klass`.
-        def resolve_class(klass, exception: true)
-          @resolved ||= {}
-          @resolved[klass] ||=
-            case klass
-            when Class
-              klass
-            when String
-              begin
-                Kernel.const_get(klass)
-              rescue NameError
-                raise if exception
-              end
-            when Symbol
-              resolve_class(send(klass))
-            else
-              raise "Unknown class: #{klass}" if exception
-            end
-        end
-
-        # Helper to normalize `key` into a correct `ruby` **constant name**
-        # @param key [String, Symbol] to be normalized
-        # @return [String] a correct constant name
-        def to_constant(key)
-          key.to_s.strip.split(/[\-\_ ]/i).compact.map do |str|
-            str.slice(0).upcase + str.slice(1..-1).downcase
-          end.join
-        end
-
-        # Helper to create an instance variable `name`
-        # @param [String, Symbol] the name of the variable
-        # @reutrn [String] the name of the created instance variable
-        def instance_variable_name(name)
-          str = name.to_s
-          str = "@#{str}" unless str.start_with?("@")
-          str
-        end
-
-        # If the class for `name` exists, it returns it. Otherwise it generates it.
-        # @param name [String, Symbol] the name of the new class
-        # @param inherits [Class] the parent class to _inherit_ from
-        # @param parent_space [String] parent namespace of the generated class, if not given: `self`
-        # @yield [child_class] configure the new class
-        # @yieldparam child_class [Class] the new class
-        # @return [Class] the new generated class
-        def new_class(name, inherits:, parent_space: nil)
-          name            = name.to_sym.freeze
-          class_name      = to_constant(name)
-          parent_space    = parent_space ? resolve_class(parent_space) : self
-          full_class_name = "#{parent_space}::#{class_name}"
-
-          unless (target_class = resolve_class(full_class_name, exception: false))
-            target_class = Class.new(inherits)
-            parent_space.const_set class_name, target_class
-          end
-
-          target_class.tap do |klass|
-            yield(klass) if block_given?
-          end
-        end
-
-        # Finds all child classes of the current class.
-        # @param parent_class [Class] the parent class we want to find children of.
-        # @param direct [Boolean] it will only include direct child classes.
-        # @param scope [nil, Array] to only look for descendants among the ones in `scope`.
-        # @return [Arrary<Class>] the child classes in hierarchy order.
-        def descendants(parent_class: self, direct: false, scope: nil)
-          scope ||= ObjectSpace.each_object(::Class)
-          return [] if scope.empty?
-          scope.select do |klass|
-            klass < parent_class
-          end.sort do |k_1, k_2|
-            next -1 if k_2 < k_1
-            next  1 if k_1 < k_2
-            0
-          end.tap do |siblings|
-            if direct
-              siblings.reject! do |si|
-                siblings.any? {|s| si < s}
-              end
-            end
-          end
-        end
-
-        # @param parent_class [Class] the parent class we want to find children of.
-        # @param direct [Boolean] it will only include direct child classes.
-        # @return [Boolean] `true` if the current class has child classes, and `false` otherwise.
-        def descendants?(parent_class: self, direct: false)
-          descendants(parent_class: parent_class, direct: direct).length.positive?
-        end
-
-        # Keeps track on class instance variables that should be inherited by child classes.
-        # @note
-        #   - subclasses will inherit the value as is at that moment
-        #   - any change afterwards will be only on the specific class (in line with class instance variables)
-        #   - adapted from https://stackoverflow.com/a/10729812/4352306
-        # TODO: this separates the logic of the method to the instance var.
-        #   Think if would be possible to join them somehow.
-        def inheritable_class_vars(*vars)
-          @inheritable_class_vars ||= [:inheritable_class_vars]
-          @inheritable_class_vars += vars
-        end
-
-        # Builds the attr_reader and attr_writer of `attrs` and registers
-        # the associated instance variable as inheritable.
-        def inheritable_attrs(*attrs)
-          attrs.each do |attr|
-            class_eval %(
-              class << self; attr_accessor :#{attr} end
-            ), __FILE__, __LINE__ - 2
-          end
-
-          inheritable_class_vars(*attrs)
-        end
-
-        # This callback method is called whenever a subclass of the current class is created.
-        # @note
-        #   - values of the instance variables are copied as they are (no dups or clones)
-        #   - the above means: avoid methods that change the state of the mutable object on it
-        #   - mutating methods would reflect the changes on other classes as well
-        #   - therefore, `freeze` will be called on the values that are inherited.
-        def inherited(subclass)
-          super
-          inheritable_class_vars.each do |var|
-            instance_var = instance_variable_name(var)
-            value        = instance_variable_get(instance_var)
-            subclass.instance_variable_set(instance_var, value.freeze)
-          end
-        end
+        include Eco::Language::Klass::HelpersBuilt
       end
     end
   end

data/lib/eco/api/common/loaders/config/cli.rb

@@ -5,5 +5,5 @@ class Eco::API::Common::Loaders::CliConfig < Eco::API::Common::Loaders::Config
     end
   end
 
-  delegate_missing_to :config
+  delegating_missing_on_class_to :config
 end

data/lib/eco/api/common/loaders/config/session.rb

@@ -8,5 +8,5 @@ class Eco::API::Common::Loaders::Session < Eco::API::Common::Loaders::Config
     end
   end
 
-  delegate_missing_to :workflow
+  delegating_missing_on_class_to :workflow
 end

data/lib/eco/api/common/loaders/config/workflow.rb

@@ -9,7 +9,7 @@ class Eco::API::Common::Loaders::Workflow < Eco::API::Common::Loaders::Config
 
   extend CasesExtension
 
-  delegate_missing_to :workflow
+  delegating_missing_on_class_to :workflow
 end
 
 require_relative 'workflow/mailer'

data/lib/eco/api/common/loaders/config.rb

@@ -1,8 +1,7 @@
 class Eco::API::Common::Loaders::Config
-  extend Eco::API::Common::ClassHelpers
-  extend Eco::Language::Methods::DelegateMissing
+  include Eco::Language::Delegation::DelegatingMissingOnClass
 
-  inheritable_class_vars :delegate_missing_to
+  delegating_missing_on_class_to :config
 
   class << self
     # To create samples of configurations
@@ -29,8 +28,6 @@ class Eco::API::Common::Loaders::Config
       config.active_enviro
     end
   end
-
-  delegate_missing_to :config
 end
 
 require_relative 'config/cli'

data/lib/eco/api/common/loaders/use_case/target_model.rb

@@ -4,7 +4,7 @@ class Eco::API::Common::Loaders::UseCase
       def included(base)
         super
 
-        base.extend(ClassMethods)
+        base.extend ClassMethods
       end
     end
 

data/lib/eco/api/common/loaders/use_case/type.rb

@@ -4,7 +4,7 @@ class Eco::API::Common::Loaders::UseCase
       def included(base)
         super
 
-        base.extend(ClassMethods)
+        base.extend ClassMethods
       end
     end
 

data/lib/eco/api/common/people/supervisor_helpers.rb

@@ -8,7 +8,9 @@ module Eco
         #   * `id`
         module SupervisorHelpers
           def self.included(base)
-            base.send(:include, ClassMethods)
+            super
+
+            base.send :include, ClassMethods
           end
 
           module ClassMethods

data/lib/eco/api/common/session/logger/channels.rb

@@ -9,6 +9,7 @@ module Eco
             class << self
               def included(base)
                 super
+
                 base.extend ClassMethods
               end
             end

data/lib/eco/api/common/session/sftp.rb

@@ -118,6 +118,7 @@ module Eco
           end
 
           # Upload a file to the specific `remote_folder`
+          # @return [String, FalseClass] on success returns the remote file path.
           def upload(local_file, remote_folder:, gid: nil)
             return false unless local_file && File.exist?(local_file)
 
@@ -133,9 +134,15 @@ module Eco
             end
 
             log(:info) {
-              "Uploaded '#{local_file}' (#{res})"
+              "Uploaded '#{local_file}' as '#{dest_file}' (#{res})"
             }
-            true
+
+            dest_file
+          rescue StandardError
+            log(:error) {
+              "Could not upload file '#{dest_file}' (#{res})"
+            }
+            raise
           end
 
           private

data/lib/eco/api/session/batch/job/sets.rb

@@ -5,6 +5,7 @@ class Eco::API::Session::Batch::Job
     class << self
       def included(base)
         super
+
         base.extend ClassMethods
       end
     end

data/lib/eco/api/session/batch/job/type.rb

@@ -5,6 +5,7 @@ class Eco::API::Session::Batch::Job
     class << self
       def included(base)
         super
+
         base.extend ClassMethods
       end
     end

data/lib/eco/api/session/batch/launcher/valid_methods.rb

@@ -8,8 +8,9 @@ module Eco
 
             def self.included(base)
               super
-              base.extend(ClassMethods)
-              base.send(:include, InstanceMethods)
+
+              base.extend ClassMethods
+              base.send :include, InstanceMethods
             end
 
             module ClassMethods

data/lib/eco/api/usecases/base_case/model.rb

@@ -17,7 +17,8 @@ class Eco::API::UseCases::BaseCase
     class << self
       def included(base)
         super
-        base.extend(ClassMethods)
+
+        base.extend ClassMethods
       end
     end
 

data/lib/eco/api/usecases/base_case/type.rb

@@ -21,7 +21,8 @@ class Eco::API::UseCases::BaseCase
     class << self
       def included(base)
         super
-        base.extend(ClassMethods)
+
+        base.extend ClassMethods
       end
     end
 

data/lib/eco/api/usecases/base_io/validations.rb

@@ -29,7 +29,8 @@ class Eco::API::UseCases::BaseIO
     class << self
       def included(base)
         super
-        base.extend(ClassMethods)
+
+        base.extend ClassMethods
       end
     end
 

data/lib/eco/api/usecases/graphql/helpers/location/command/diffs/stages/commandable.rb

@@ -4,8 +4,9 @@ class Eco::API::UseCases::GraphQL::Helpers::Location::Command::Diffs
       class << self
         def included(base)
           super
-          base.extend(ClassMethods)
-          base.send(:include, DiffSortable)
+
+          base.extend ClassMethods
+          base.send :include, DiffSortable
         end
       end
 

data/lib/eco/api/usecases/lib/files/file_pattern.rb

@@ -29,8 +29,6 @@ module Eco::API::UseCases::Lib::Files
         rescue NameError
           self.class.const_get(fpc)
         end
-      elsif respond_to?(:file_pattern, true)
-        file_pattern
       elsif self.class.const_defined?(:FILE_PATTERN)
         self.class::FILE_PATTERN
       end

data/lib/eco/api/usecases/lib/files/sftp.rb

@@ -8,6 +8,7 @@ module Eco::API::UseCases::Lib::Files
 
     private
 
+    # @return [String, FalseClass] the path of the remote file or `false` if failed.
     def upload(local_file, subfolder: remote_subfolder, gid: sftp_group_id)
       sftp_session.upload(
         local_file,
@@ -34,15 +35,19 @@ module Eco::API::UseCases::Lib::Files
       subfolder:    remote_subfolder,
       pattern:      nil,
       local_folder: self.local_folder,
+      only_latest:  false,
       &block
     )
       remote_files = with_remote_files(subfolder: subfolder, pattern: pattern)
-      return [] if remote_files.empty?
+
+      return []                           if remote_files.empty?
+      remote_files = [remote_files.first] if only_latest
 
       file_names = remote_files.map {|file| to_remote_path(file.name, subfolder: subfolder)}
 
       log(:info) {
-        msg  = "Getting the following files into the local folder '#{local_folder}':\n"
+        msg  = "Getting the following files into the local folder "
+        msg << "'#{local_folder || '.'}':\n"
         msg << '  * '
         msg << file_names.join("\n  * ")
         msg
@@ -118,8 +123,6 @@ module Eco::API::UseCases::Lib::Files
         local_dir
       elsif self.class.const_defined?(:LOCAL_FOLDER)
         self.class::LOCAL_FOLDER
-      else
-        '.'
       end
     end
 

data/lib/eco/api/usecases/samples/drivers/sftp_sample.rb

@@ -37,7 +37,9 @@ class Eco::API::UseCases::Samples::Drivers::Sftp < Eco::API::Common::Loaders::Us
 
       file_names = files.map {|file| to_remote_path(file.name)}
 
-      puts "Getting the following files into the local folder '#{local_folder}':"
+      msg  = "Getting the following files into the local folder "
+      msg << "'#{local_folder || '.'}':"
+      puts msg
       puts file_names
 
       sftp.download(file_names, local_folder: local_folder)

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

@@ -6,8 +6,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
 

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
 

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_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/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