eco-helpers 3.0.37 → 3.1.1

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

@@ -1,152 +0,0 @@
-# rubocop:disable Style/SpecialGlobalVars
-module Eco
-  module Data
-    module Files
-      DEFAULT_TIMESTAMP_PATTERN = '%Y-%m-%dT%H%M%S'.freeze
-
-      class << self
-        def included(base)
-          super
-
-          base.send :include, InstanceMethods
-          base.extend ClassMethods
-        end
-      end
-
-      module InstanceMethods
-        include Eco::Language::AuxiliarLogger
-        include Eco::Data::Files::Encoding
-
-        # It offers a resilient way to read content from a file
-        # @tolerance [Integer] the number of allowed encoding errors.
-        # @return [String] the content of the file
-        def get_file_content(file, encoding: nil, tolerance: 5)
-          read_with_tolerance(file, encoding: encoding, tolerance: tolerance)
-        end
-
-        def read_with_tolerance(file, encoding:, tolerance: 5)
-          content = get_file_content_with_encoding(file, encoding: encoding)
-          return nil unless content
-
-          content.scrub do |bytes|
-            replacement = "<#{bytes.unpack1('H*')}>"
-
-            if tolerance <= 0
-              log(:error) {
-                "There were more than 5 encoding errors in the file '#{file}'."
-              }
-              return content
-            else
-              tolerance -= 1
-              log(:error) {
-                "Encoding problem in file '#{file}': '#{replacement}'."
-              }
-              replacement
-            end
-          end
-        end
-      end
-
-      module ClassMethods
-        include Eco::Data::Files::Encoding
-
-        def create_directory(path, includes_file: false)
-          Directory.create(path, includes_file: includes_file)
-        end
-
-        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 file_name(fullname)
-          return nil unless fullname
-
-          File.basename(fullname)
-        end
-
-        def file_basename(fullname)
-          return nil unless fullname
-
-          File.basename(fullname, File.extname(fullname))
-        end
-
-        def file_fullpath(fullname)
-          return nil unless fullname
-
-          File.dirname(File.expand_path(fullname))
-        end
-
-        def file_exists?(file)
-          return false unless file
-
-          File.exist?(file) || File.exist?(File.expand_path(file))
-        end
-
-        def dir_exists?(path)
-          Dir.exist?(path) || Dir.exist?(File.expand_path(path))
-        end
-
-        def timestamp(timestamp_pattern = DEFAULT_TIMESTAMP_PATTERN, date = Time.now)
-          date.strftime(timestamp_pattern)
-        end
-
-        def timestamp_file(filename, timestamp_pattern = DEFAULT_TIMESTAMP_PATTERN)
-          file_pattern = Eco::Data::Files::FilePattern.new(filename)
-          file_pattern.resolve(start: timestamp(timestamp_pattern) + '_') # rubocop:disable Style/StringConcatenation
-        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
-
-        def file_empty?(path)
-          return true unless File.file?(path)
-
-          File.empty?(path)
-        end
-
-        def script_subfolder
-          basename = File.basename($0, File.extname($0))
-          path = File.dirname($0)
-          File.join(path, basename)
-        end
-
-        def folder_files(folder = '.', pattern = '*', regexp: nil, older_than: nil)
-          return [] unless folder.is_a?(String)
-
-          target = File.join(File.expand_path(folder), pattern)
-
-          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 regexp.is_a?(Regexp)
-              dir_files.select! do |f|
-                File.basename(f).match(regexp)
-              end
-            end
-          end.sort
-        end
-
-        def csv_files(folder = '.', regexp: nil, older_than: nil)
-          folder_files(folder, '*.csv', regexp: regexp, older_than: older_than).sort
-        end
-      end
-
-      class << self
-        include Files::InstanceMethods
-        include Files::ClassMethods
-      end
-    end
-  end
-end
-
-# rubocop:enable Style/SpecialGlobalVars

data/lib/eco/language/models/class_helpers.rb

@@ -1,136 +0,0 @@
-module Eco
-  module Language
-    module Models
-      module ClassHelpers
-        NOT_USED = 'no_used!'.freeze
-
-        def redef_without_warning(const, value)
-          self.class.send(:remove_const, const) if self.class.const_defined?(const)
-          self.class.const_set(const, value)
-        end
-
-        def class_resolver(name, klass)
-          define_singleton_method(name) { resolve_class(klass) }
-          define_method(name) { self.class.resolve_class(klass) }
-        end
-
-        # Class resolver
-        # @note it caches the resolved `klass`es
-        # @raise [Exception] when could not resolve if `exception` is `true`
-        # @param klass [Class, String, Symbol] the class to resolve
-        # @param source_class [Class] when the reference to `klass` belongs to a different inheritance chain.
-        # @param exception [Boolean] if it should raise exception when could not resolve
-        # @return [Class] the `Class` constant
-        def resolve_class(klass, source_class: self, 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
-              source_class.resolve_class(source_class.send(klass))
-            when Hash
-              referrer, referred = klass.first
-              resolve_class(referred, source_class: referrer, exception: exception)
-            else
-              raise "Unknown class: #{klass}" if exception
-            end
-        end
-
-        # Helper to normalize `key` into a correct `ruby` **constant name**
-        # @note it removes namespace syntax `::`
-        # @param key [String, Symbol] to be normalized
-        # @return [String] a correct constant name
-        def to_constant(key)
-          key.to_s.strip.split('::').compact.map do |str|
-            str.slice(0).upcase + str.slice(1..-1)
-          end.join.split(/[\-\_ :]+/i).compact.map do |str|
-            str.slice(0).upcase + str.slice(1..-1)
-          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 namespace [Class, String] an existing `constant` (class or module) the new class will be namespaced on
-        # @yield [child_class] configure the new class
-        # @yieldparam child_class [Class] the new class
-        # @return [Class] the new generated class
-        def new_class(name = "Child#{uid}", inherits: self, namespace: inherits)
-          name            = name.to_s.to_sym.freeze
-          class_name      = to_constant(name)
-
-          unless (target_class = resolve_class("#{namespace}::#{class_name}", exception: false))
-            target_class = Class.new(inherits)
-            Kernel.const_get(namespace.to_s).const_set class_name, target_class
-          end
-
-          target_class.tap do |klass|
-            yield(klass) if block_given?
-          end
-        end
-
-        # Helper to determine if a paramter has been used
-        # @note to effectivelly use this helper, you should initialize your target
-        #  paramters with the constant `NOT_USED`
-        # @param val [] the value of the paramter
-        # @return [Boolean] `true` if value other than `NOT_USED`, `false` otherwise
-        def used_param?(val)
-          val != NOT_USED
-        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 %( # rubocop:disable Style/DocumentDynamicEvalDefinition
-              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
-      end
-    end
-  end
-end