eco-helpers 3.0.37 → 3.1.1

data/lib/eco/cli_default/workflow.rb

@@ -1,4 +1,3 @@
-class Eco::CliDefault::Workflow < Eco::API::Common::Loaders::Workflow
 # @todo The ones below:
 #   1. Identify the target model earlier (required_data?),
 #     provided that we can granulate the workflow.
@@ -12,183 +11,28 @@ class Eco::CliDefault::Workflow < Eco::API::Common::Loaders::Workflow
 #   5. Right on the load:data stage, set the io model
 #     based on (1).
 #
-  class << self
-    attr_accessor :rescued
-  end
-
-  # default rescue
-  exception do |err, io|
-    next io if rescued
-
-    self.rescued = true
-    log(:debug) { err.patch_full_message }
-
-    workflow.run(:close, io: io)
-  rescue StandardError => e
-    puts "Some problem in workflow.rescue: #{e}"
-  end
-
-  on(:options) do
-    cli_usecases.cli_apply(io: io)
-    io.new(options: cli.config.options_set.process(io: io))
-  end
-
-  with(:load) do |wf_load|
-    wf_load.with(:input) do |wf_in|
-      wf_in.on(:get) do
-        input_is_required = some_input_case?(io) || options.dig(:input, :entries_from)
-        missing_input     = !input || input.empty?
-        next unless missing_input && input_is_required
-
-        if options.dig(:input, :entries_from)
-          io.new(input: cli.config.input.get(io: io))
-        else
-          opt_case = cli_input_cases(io).values.first.option
-          io.new(input: cli.config.input.get(io: io, option: opt_case))
-        end
-      end
-
-      wf_in.on(:filter) do
-        next unless input && !input.empty?
-
-        io.new(input: cli.config.input_filters.process(io: io))
-      end
-    end
-
-    wf_load.before(:data) do
-      # @todo model should be set to the target model
-      #   based on the main use case that requires data!
-      io.new(model: :people)
-    end
-
-    wf_load.with(:data) do |wf_peo|
-      wf_peo.on(:get) do
-        next unless some_data_case?(io) || options.dig(:people, :get)
-
-        io.new(data: cli.config.people(io: io))
-      end
-
-      wf_peo.on(:filter) do
-        next unless data && !data.empty?
-
-        io.new(data: cli.config.people_filters.process(io: io))
-      end
-    end
-  end
-
-  before(:usecases) do
-    # save partial entries -> should be native to session.workflow
-    get_people     = options.dig(:people, :get)
-    partial_update = get_people && get_people[:type] == :partial
-
-    if !options[:dry_run] && partial_update
-      partial_file = session.config.people.partial_cache
-      session.file_manager.save_json(io.data, partial_file, :timestamp)
-    end
-  end
-
-  on(:usecases) do
-    next if cli_usecases.process(io: io)
-
-    log(:info) { 'No update operation specified... quitting' }
-    exit 0
-  end
-
-  before(:launch_jobs) do
-    available_args = cli.config.available_option_args
-    SCR.stop_on_unknown!(all_available: available_args)
-  end
-
-  on(:launch_jobs) do
-    session.jobs_launch(simulate: options[:dry_run])
-  end
-
-  before(:post_launch) do |wf_post|
-    next wf_post.skip! if session.post_launch.empty?
-
-    run_it = !options[:dry_run] || options.dig(:post_launch, :run)
-    unless run_it
-      wf_post.skip!
-
-      log(:info) {
-        msg  = 'Although there are post_launch cases, they will NOT be RUN'
-        msg << ', because we are in dry-run (simulate).' if options[:dry_run]
-        msg
-      }
-
-      next
-    end
-
-    get_people     = options.dig(:people, :get)
-    partial_update = get_people && get_people[:type] == :partial
-    refresh_data   = !options[:dry_run] && partial_update
-
-    unless refresh_data
-      log(:info) {
-        msg = 'Although there are post_launch cases, data will not be refreshed before their run'
-        if io.options[:dry_run]
-          msg << ', because we are in dry-run (simulate).'
-        elsif !partial_update
-          msg << ', because it is not a partial update (-get-partial option not present).'
-        end
-        msg
-      }
-
-      next
-    end
-
-    # get target people afresh
-    peo_aux = session.micro.people_refresh(
-      people:          data,
-      include_created: true
-    )
-    io.base.new(data: peo_aux)
-  end
-
-  with(:post_launch) do |wf_post|
-    wf_post.on(:usecases) do |_wf_pu, io|
-      session.post_launch.each do |use|
-        use.launch(io: io).base
-      rescue Eco::API::UseCases::BaseIO::MissingParameter => err
-        raise unless err.required == :people
-
-        log(:debug) {
-          "Skipping use case '#{use.name}' -- no base people detected for the current run"
-        }
-      end
-    end
-
-    wf_post.on(:launch_jobs) do |_wf_pl, _io|
-      session.jobs_launch(simulate: options[:dry_run])
-    end
-  end
-
-  on(:report) do |_wf_rep, io|
-    if (file = options.dig(:report, :people, :csv))
-      options.deep_merge!(export: {
-        options: {internal_names: true, nice_header: true, split_schemas: true},
-        file:    {name: file, format: :csv}
-      })
-
-      aux_io = io.new(data: data.updated_or_created)
-      session.process_case('to-csv', io: aux_io, type: :export)
-    end
-  end
-
-  on(:end) do
-    get_people     = options.dig(:people, :get)
-    partial_update = get_people && get_people[:type] == :partial
-
-    unless !options[:end_get] || options[:dry_run] || partial_update
-      if !some_update_case?(io)
-        # Prevent getting people when there were no use cases that used them
-        log(:info) {
-          "Won't be recaching people, as there haven't been any targetted updates"
-        }
-      elsif !people
-        people = session.micro.people_cache
-        io.new(data: people)
-      end
-    end
-  end
+class Eco::CliDefault::Workflow < Eco::API::Common::Loaders::Workflow
+  require_relative 'workflow/rescued_exception'
+  require_relative 'workflow/options'
+  require_relative 'workflow/load'
+  require_relative 'workflow/usecases'
+  require_relative 'workflow/launch_jobs'
+  require_relative 'workflow/post_launch'
+  require_relative 'workflow/report'
+  require_relative 'workflow/end'
+
+  [
+    RescuedException,
+    Options,
+    Load,
+    Usecases,
+    LaunchJobs,
+    PostLaunch,
+    Report,
+    End
+  ].each do |wf_config|
+    wf_config.config_copy(to: self, all: true)
+  end
+
+  config_apply!(all: true)
 end

data/lib/eco/data/count_trace.rb

@@ -0,0 +1,51 @@
+module Eco
+  module Data
+    class CountTrace
+      include Eco::Language::Delegation::DelegatingMissing
+
+      delegating_missing_to :subject
+
+      attr_reader :trace
+
+      def initialize(subject)
+        @subject = subject
+        @trace   = {}
+      end
+
+      def reset!
+        @trace.clear
+      end
+
+      def trace!(value, count: 1)
+        trace[value] ||= 0
+        trace[value]  += count
+      end
+
+      def report!(msg: nil, level: :warn)
+        str_report(msg: msg).tap do |str|
+          log(level.to_sym) { str }
+
+          reset!
+        end
+      end
+
+      def str_report(msg: nil)
+        return if trace.empty?
+
+        msg  ||= ''
+        sorted = trace.sort_by {|value, count| [count * -1, value]}
+
+        msg << "\n  * "
+        msg << sorted.map.with_index do |(value, count), idx|
+          "#{idx}. (#{count}) '#{value}'"
+        end.join("\n  * ")
+
+        msg
+      end
+
+      private
+
+      attr_reader :subject
+    end
+  end
+end

data/lib/eco/data/files/content.rb

@@ -0,0 +1,39 @@
+module Eco
+  module Data
+    module Files
+      module Content
+        include Eco::Language::AuxiliarLogger
+        include 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 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
+    end
+  end
+end

data/lib/eco/data/files/directory.rb

@@ -3,45 +3,43 @@ module Eco
     module Files
       class Directory
         class << self
-          def create(path, includes_file: false)
-            return true if Files.file_exists?(path)
-
-            parts    = Files.split(File.expand_path(path))
-            filename = parts.pop if includes_file
-
-            return true if Files.dir_exists?(File.join(*parts))
-
-            subpath = nil
-            begin
-              parts.each do |curr|
-                subpath =  subpath ? File.join(subpath, curr) : curr
-                Dir.mkdir(subpath) unless Files.dir_exists?(subpath)
-              end
-            rescue Exception => e
-              pp e
-              return false
-            end
-            true
+          # rubocop:disable Style/SpecialGlobalVars
+
+          def script_subfolder
+            basename = File.basename($0, File.extname($0))
+            path     = File.dirname($0)
+
+            File.join(path, basename)
           end
+
+          # rubocop:enable Style/SpecialGlobalVars
         end
 
         attr_reader :dir_path
 
         def initialize(dir_path = Dir.pwd)
-          dir_path = script_subfolder if dir_path == :script
-          raise "Cannot initialize with directory: '#{dir_path.to_s}'" if !dir_path || dir_path.is_a?(Symbol)
+          dir_path = self.class.script_subfolder if dir_path == :script
+
+          msg = "Cannot initialize with directory: '#{dir_path}'"
+          raise ArgumentError, msg if !dir_path || dir_path.is_a?(Symbol)
+
           @dir_path = dir_path
         end
 
-        def exists?
-          Files.dir_exists?(@dir_path)
+        def exist?
+          Dir.exist?(@dir_path)
         end
 
-        def create
-          return self.full_path if self.exists?
-          if succeed = Directory.create(File.expand_path(@dir_path))
-            return self.full_path
-          end
+        def create(exception: false)
+          return full_path if exist?
+
+          FileUtils.mkdir_p(@dir_path)
+
+          true
+        rescue StandardError => err
+          raise if exception
+          pp err
+          false
         end
 
         def full_path
@@ -49,29 +47,48 @@ module Eco
         end
 
         def dir_files(file: nil, pattern: dir_pattern)
-          find = !!file ? file_pattern(file) : file_pattern(pattern)
-          Dir.glob(find).sort
+          find = file_pattern(file || pattern)
+          Dir.glob(find).sort # rubocop:disable Lint/RedundantDirGlobSort
         end
 
+        # @params files_list [Array]
+        # @params file [String]
+        # @return [String] the last modified file.
         def newest_file(files_list = nil, file: nil)
-          files_list = files_list || dir_files(file: file)
-          return nil unless files_list && files_list.is_a?(Array) && (files_list.length > 0) # files available?
+          files_list ||= dir_files(file: file)
+
+          return unless files_list.is_a?(Array)
+          return unless files_list.length.positive?
+
           files_list.max_by {|f| File.mtime(f) }
         end
 
+        # Resolves the `filename` path.
+        # @return [String] the file path (relative or absolute)
         def file(filename, should_exist: false)
-          return nil if !filename
+          return unless filename
+
+          # as incoming absolute path
           if File.expand_path(filename) == filename
-            return filename if !should_exist || Files.file_exists?(filename)
+            return filename unless should_exist
+            return filename if File.exist?(filename)
           end
 
-          file = FilePattern.new(filename).resolve(dir: @dir_path)
-          return file if !should_exist || Files.file_exists?(file)
+          # as relative path to this directory
+          file = to_relative_path(filename)
+          return file unless should_exist
+          return file if File.exist?(file)
 
+          # as interpreted to be an absolute path
           file = File.expand_path(filename)
-          return file if !should_exist || Files.file_exists?(file)
+          return file unless should_exist
+          file        if File.exist?(file)
+        end
 
-          nil
+        def file?(filename)
+          return true if file_abolute_path_exist?(filename)
+
+          file_relative_path_exist?(filename)
         end
 
         def join(*args)
@@ -81,21 +98,37 @@ module Eco
 
         private
 
+        def to_relative_path(filename)
+          return unless filename
+
+          FilePattern.new(
+            filename
+          ).resolve(dir: @dir_path)
+        end
+
+        def file_abolute_path_exist?(filename)
+          return false unless filename
+
+          File.exist?(filename)
+        end
+
+        def file_relative_path_exist?(filename)
+          return false unless filename
+
+          File.exist?(to_relative_path(filename))
+        end
+
         def file_pattern(value)
           case value
-          when Files::FilePattern
+          when FilePattern
             value
           else
-            Files::FilePattern.new(value).pattern(@dir_path)
+            FilePattern.new(value).pattern(@dir_path)
           end
         end
 
         def dir_pattern
-          Files::FilePattern.new.pattern(@dir_path)
-        end
-
-        def script_subfolder
-          Files.script_subfolder
+          FilePattern.new.pattern(@dir_path)
         end
       end
     end

data/lib/eco/data/files/encoding.rb

@@ -6,9 +6,12 @@ module Eco
 
         BOM_BYTES = [239, 187, 191].freeze
 
-        def has_bom?(path)
-          return false if !path || file_empty?(path)
-          File.open(path, "rb") do |f|
+        def bom?(path)
+          return false unless path
+          return false unless File.file?(path)
+          return false if File.empty?(path)
+
+          File.open(path, 'rb') do |f|
             bytes = f.read(3)
             return bytes.unpack('C*') == BOM_BYTES
           end
@@ -24,7 +27,7 @@ module Eco
           end
 
           bom_enc = encoding && encoding.split('|')[0] == 'bom'
-          if has_bom?(file) || bom_enc
+          if bom?(file) || bom_enc
             content  = remove_bom(File.read(file, encoding: 'utf-8'))
             encoding = 'utf-8'
           else
@@ -33,7 +36,7 @@ module Eco
 
           return unless content
 
-          content = content.encode("utf-8") unless encoding.include?('utf-8')
+          content = content.encode('utf-8') unless encoding.include?('utf-8')
           content
         end
 
@@ -50,32 +53,20 @@ module Eco
         end
 
         def encoding(path)
-          has_bom?(path) ? "bom" : "utf-8"
+          bom?(path) ? 'bom' : 'utf-8'
         end
 
         # Gives the parameter as it should
         def scoped_encoding(path)
-          unless file_exists?(path)
+          unless File.exist?(path)
             log(:error) { "File does not exist: #{path}" }
-            return nil
+            return
           end
 
           encoding ||= encoding(path)
-          encoding   = "#{encoding}|utf-8" if encoding == "bom"
+          encoding   = "#{encoding}|utf-8" if encoding == 'bom'
           encoding
         end
-
-        def file_exists?(file)
-          return false unless file
-
-          File.exist?(file) || File.exist?(File.expand_path(file))
-        end
-
-        def file_empty?(path)
-          return true unless File.file?(path)
-
-          File.zero?(path)
-        end
       end
     end
   end

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

@@ -1,30 +1,37 @@
 module Eco
   module Data
     module Files
+      # Helper class to build regex patterns relative to a source folder.
       class FilePattern
-        def initialize(file = "")
+        def initialize(file = '')
           @source_file = file
         end
 
-        def resolve(dir: nil, start: "")
+        def resolve(dir: nil, start: '')
           pattern(dir).gsub('*', start)
         end
 
         def match?(file, dir: nil)
-          /#{Regexp.escape(self.pattern(dir))}/i.match?(file)
+          /#{Regexp.escape(pattern(dir))}/i.match?(file)
         end
 
         def any?(files, dir: nil)
           return false unless files.is_a?(Array)
-          files.any? { |file|  match?(file, dir: dir) }
+
+          files.any? { |file| match?(file, dir: dir) }
         end
 
         def pattern(dir = nil)
-          return File.join(dir, "*") if @source_file.to_s.empty?
+          return File.join(dir, '*') if @source_file.to_s.empty?
+
           filename = File.basename(@source_file)
-          path = File.dirname(@source_file)
-          path = File.join(dir, path) if dir
-          wildcard = (filename =~ /\*/)? "" : "*"
+          path     = File.dirname(@source_file)
+
+          path     = File.join(dir, path) if dir
+
+          wildcard = '*'
+          wildcard = '' if filename =~ /\*/
+
           File.join(path, wildcard + filename)
         end
       end