eco-helpers 3.0.18 → 3.0.20

data/lib/eco/api/usecases/default/utils/sort_csv_case.rb

@@ -0,0 +1,127 @@
+class Eco::API::UseCases::Default::Utils::SortCsv < Eco::API::Custom::UseCase
+  name 'sort-csv'
+  type :other
+
+  require_relative 'cli/sort_csv_cli'
+
+  def main(*_args)
+    if simulate?
+      count = Eco::CSV.count(input_file)
+      log(:info) { "CSV '#{input_file}' has #{count} rows." }
+    else
+      group_input_rows
+      generate_file
+    end
+  end
+
+  private
+
+  attr_reader :headers, :headers_rest
+
+  def group_input_rows
+    idx   = 0
+    first = true
+
+    Eco::CSV.foreach(input_file, headers: true, skip_blanks: true) do |row|
+      idx += 1
+
+      if first
+        first           = false
+        @output_headers = row.headers
+        require_sort_field!(row, file: input_file)
+      end
+
+      pivot_value = row[sort_field]
+      (row_groups[pivot_value] ||= []) << row
+
+      if (idx % 500).zero?
+        print "... Tracked #{idx} rows          \r"
+        $stdout.flush
+      end
+    end
+  ensure
+    log(:info) { "Tracked #{idx} rows"}
+  end
+
+  def generate_file
+    idx = 0
+
+    CSV.open(output_filename, 'wb') do |csv|
+      csv << @output_headers
+
+      row_groups.keys.sort.each do |key|
+        row_groups[key].each do |row|
+          csv << row.values_at(*@output_headers)
+
+          idx += 1
+          if (idx % 500).zero?
+            print "... Sorted #{idx} rows          \r"
+            $stdout.flush
+          end
+        end
+      end
+    end
+  ensure
+    msg = "Generated file '#{output_filename}' with #{idx} rows."
+    log(:info) { msg } unless simulate?
+  end
+
+  def row_groups
+    @row_groups ||= {}
+  end
+
+  def output_filename
+    return nil unless input_name
+
+    File.join(input_dir, "#{input_name}_sorted#{input_ext}")
+  end
+
+  def input_name
+    @input_name ||= File.basename(input_basename, input_ext)
+  end
+
+  def input_ext
+    @input_ext ||= input_basename.split('.')[1..].join('.').then do |name|
+      ".#{name}"
+    end
+  end
+
+  def input_basename
+    @input_basename ||= File.basename(input_full_filename)
+  end
+
+  def input_dir
+    @input_dir = File.dirname(input_full_filename)
+  end
+
+  def input_full_filename
+    @input_full_filename ||= File.expand_path(input_file)
+  end
+
+  def input_file
+    options.dig(:input, :file)
+  end
+
+  def require_sort_field!(row, file:)
+    return true if row.key?(sort_field)
+
+    msg = "Sort field '#{sort_field}' missing in header of file '#{file}'"
+    log(:error) { msg }
+    raise msg
+  end
+
+  def sort_field
+    @sort_field ||= opts_sort_by.tap do |pivot|
+      next if pivot
+
+      msg = "The pivot field should be specified with -by option"
+
+      log(:error) { msg }
+      raise msg
+    end
+  end
+
+  def opts_sort_by
+    options.dig(:input, :sort_by)
+  end
+end

data/lib/eco/api/usecases/default/utils/split_json_case.rb

@@ -0,0 +1,224 @@
+class Eco::API::UseCases::Default::Utils::SplitJson < Eco::API::Common::Loaders::UseCase
+  require_relative 'cli/split_json_cli'
+
+  MAX_ITEMS = 15_000
+
+  name "split-json"
+  type :other
+
+  def main(*_args)
+    if simulate?
+      count = input_json.count
+      log(:info) { "JSON '#{input_file}' has #{count} elements." }
+    else
+      split_json_into_files!
+
+      msg  = []
+      msg << "Total elements: #{total_count}"
+      msg << "Generated files:"
+      out_files.each do |file|
+        msg << "  * #{file}'"
+      end
+
+      log(:info) { msg.join("\n") }
+    end
+  end
+
+  private
+
+  def split_json_into_files!
+    first = true
+
+    while pending?
+      swap_file! if first
+      first = false
+
+      curr_json << input_json.shift
+      next_count!
+
+      swap_file! if split?
+    end
+
+    generate_file!
+  end
+
+  def split?
+    return false unless curr_count > max_items
+
+    true
+  end
+
+  def max_items
+    @max_items ||= max_items_options || self.class::MAX_ITEMS
+  end
+
+
+  # OPTIONS
+
+  def max_items_options
+    return unless (num = options.dig(:output, :file, :max_items))
+
+    num = num.to_i
+    num = nil if num.zero?
+    num
+  end
+
+  # OUTPUT JSON
+
+  # Returns the last json array and blanks the variable
+  def exporting_json!
+    curr_json.tap do
+      @curr_json = []
+    end
+  end
+
+  def curr_json
+    @curr_json ||= []
+  end
+
+  def pending?
+    !input_json.empty?
+  end
+
+  def input_json
+    @json ||= JSON.load(File.open(input_file, 'r'))
+  end
+
+  # COUNTS
+
+  def next_count!
+    @curr_count  = curr_count + 1
+    @total_count = total_count + 1
+  end
+
+  def total_count
+    @total_count ||= 0
+  end
+
+  def curr_count
+    @curr_count ||= 0
+  end
+
+  def new_count!
+    @curr_count = 0
+  end
+
+  # FILE GENERATION
+
+  def swap_file!
+    generate_file!
+    next_file!
+  end
+
+  def generate_file!
+    return unless @curr_file
+
+    if curr_json.empty?
+      log(:info) {
+        msg  = "No pending elements to be transferred "
+        msg << "(skipping creation of file '#{curr_file}')"
+        msg
+      }
+      out_files -= [curr_file]
+      return
+    end
+
+    log(:info) {
+      msg  = "Generating file at elem #{total_count} "
+      msg << "(file elements: #{curr_count})"
+      msg
+    }
+
+    save_json(exporting_json!, curr_file)
+    new_count!
+  end
+
+  def save_json(data, file)
+    File.open(file, 'w') do |fd|
+      first = true
+
+      fd << '['
+      data.each do |elem|
+        fd << "," unless first
+        first = false
+
+        fd << elem.to_json
+      end
+      fd << ']'
+    end.tap do
+      log(:info) {
+        "Generated file '#{file}'"
+      }
+    end
+  end
+
+  # OUTPUT FILES
+  attr_reader :curr_file
+
+  def file_count
+    @file_count ||= 0
+  end
+
+  def next_file!
+    @file_count = file_count + 1
+    @curr_file  = generate_name(@file_count)
+    @curr_file.tap do
+      out_files << @curr_file
+    end
+  end
+
+  def out_files
+    @out_files ||= []
+  end
+
+  def generate_name(fidx)
+    File.join(input_dir, "#{input_name}_#{file_number(fidx)}#{input_ext}")
+  end
+
+  def file_number(num)
+    "#{zeroed}#{num}"[-5..]
+  end
+
+  def zeroed
+    "0" * 5
+  end
+
+  # INPUT FILE
+
+  def input_name
+    @input_name ||= File.basename(input_basename, input_ext)
+  end
+
+  def input_ext
+    @input_ext ||= input_basename.split('.')[1..].join('.').then do |name|
+      ".#{name}"
+    end
+  end
+
+  def input_basename
+    @input_basename ||= File.basename(input_full_filename)
+  end
+
+  def input_dir
+    @input_dir = File.dirname(input_full_filename)
+  end
+
+  def input_full_filename
+    @input_full_filename ||= File.expand_path(input_file)
+  end
+
+  def input_file
+    options.dig(:source, :file).tap do |file|
+      next if file && File.exist?(file)
+
+      unless file
+        log(:warn) { 'No input file provided' }
+        exit 1
+      end
+
+      log(:warn) {
+        "File '#{file}' doesn't exist"
+      }
+    end
+  end
+end

data/lib/eco/api/usecases/default/utils.rb

@@ -10,3 +10,7 @@ module Eco
 end
 
 require_relative 'utils/split_csv_case'
+require_relative 'utils/split_json_case'
+require_relative 'utils/json_to_csv_case'
+require_relative 'utils/sort_csv_case'
+require_relative 'utils/group_csv_case'

data/lib/eco/api/usecases/default_cases/samples/sftp_case.rb

@@ -7,7 +7,7 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   name "sftp"
   type :other
 
-  CONST_REFERRAL = /^(?:::)?(?:[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)$/.freeze
+  CONST_REFERRAL = /^(?:::)?(?:[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)$/
 
   def main(session, options, _usecase)
     options[:end_get] = false
@@ -31,7 +31,7 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   def file_pattern(require: true)
     fpc = file_pattern_const
     return fpc if fpc
-    return unless require
+    return     unless require
 
     msg  = "(#{self.class}) You should redefine the file_pattern function "
     msg << "as a RegEx expression that matches the target remote file"
@@ -41,6 +41,7 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   def file_pattern_const
     if (fpc = options.dig(:sftp, :file_pattern_const))
       raise WrongConst, "(#{self.class}) Invalid file pattern const referral: #{fpc}" unless fpc.match(CONST_REFERRAL)
+
       begin
         self.eval(fpc)
       rescue NameError
@@ -54,6 +55,7 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   # Ex: "/IN/Personnel"
   def remote_subfolder(require: true)
     rm_sf = options.dig(:sftp, :remote_subfolder)
+
     return rm_sf if rm_sf
     return unless require
 
@@ -78,7 +80,7 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
     options.dig(:sftp, :local_folder) || "."
   end
 
-  def with_remote_files(folder: self.remote_folder, pattern: self.file_pattern)
+  def with_remote_files(folder: remote_folder, pattern: file_pattern)
     sftp.files(folder, pattern: pattern).each do |remote_file|
       yield(remote_file) if block_given?
     end
@@ -100,22 +102,25 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
 
   def get_files
     with_remote_files.tap do |files|
-      unless files.empty?
-        file_names = files.map {|file| to_remote_path(file.name)}
-        puts "Getting the following files into the local folder '#{local_folder}':"
-        puts file_names
-        sftp.download(file_names, local_folder: local_folder)
-      end
+      next if files.empty?
+
+      file_names = files.map {|file| to_remote_path(file.name)}
+
+      puts "Getting the following files into the local folder '#{local_folder}':"
+      puts file_names
+
+      sftp.download(file_names, local_folder: local_folder)
     end
   end
 
   def get_last
     with_remote_files.last.tap do |file|
-      if file
-        file_name = to_remote_path(file.name)
-        puts "Getting the following file: #{file_name}"
-        sftp.download(file_name, local_folder: local_folder)
-      end
+      next unless file
+
+      file_name = to_remote_path(file.name)
+      puts "Getting the following file: #{file_name}"
+
+      sftp.download(file_name, local_folder: local_folder)
     end
   end
 
@@ -125,7 +130,9 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
       dest   = to_remote_path("#{archive_subfolder}/#{file.name}")
       move_file(source, dest)
     end.tap do |files|
-      puts "Moved the file(s) to the #{archive_subfolder} folder" unless files.empty?
+      next if files.empty?
+
+      puts "Moved the file(s) to the #{archive_subfolder} folder"
     end
   end
 

data/lib/eco/api/usecases/ooze_cases/export_register_case.rb

@@ -40,7 +40,7 @@ class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::Oo
 
   def build_tags_filter(mode = :any)
     tags = option_tags(mode)
-    return nil if !tags || tags.empty?
+    return if !tags || tags.empty?
 
     tags_filter(tags, any: mode == :any)
   end
@@ -48,7 +48,7 @@ class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::Oo
   def build_range_filter(key = :update_at)
     from = from_date(key)
     to   = to_date(key)
-    return nil unless from || to
+    return unless from || to
 
     date_range_filter(from: from, to: to, key: key)
   end
@@ -92,10 +92,10 @@ class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::Oo
 
   def filename
     @filename ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
-      unless filename
-        log(:error) { "Destination file not specified" }
-        return false
-      end
+      next if filename
+
+      log(:error) { "Destination file not specified" }
+      return false
     end
   end
 end

data/lib/eco/api/usecases/ooze_samples/helpers/exportable_register.rb

@@ -48,6 +48,7 @@ module Eco
 
             def header(refresh: false)
               return @header if instance_variable_defined?(:@header) && !refresh
+
               @header = typed_header.map do |name|
                 ExportableOoze.key_to_label(name)
               end

data/lib/eco/api/usecases/ooze_samples/ooze_base_case.rb

@@ -234,7 +234,7 @@ class Eco::API::UseCases::OozeSamples::OozeBaseCase < Eco::API::Common::Loaders:
 
   def dry_count
     @dry_count ||= 0
-    @dry_count += 1
+    @dry_count  += 1
   end
 
   def dry_run_feedback(entry = target)

data/lib/eco/api/usecases/ooze_samples/ooze_run_base_case.rb

@@ -3,17 +3,19 @@ class Eco::API::UseCases::OozeSamples::OozeRunBaseCase < Eco::API::UseCases::Ooz
   name "ooze-run-base"
   type :other
 
-  SAVE_PATCH = "ooze_patch_update.json"
+  SAVE_PATCH = "ooze_patch_update.json".freeze
 
   def main(session, options, usecase)
     super(session, options, usecase) do
-      if method(:process_ooze).parameters.count == 0
+      if method(:process_ooze).parameters.count.zero?
         ooze # retrieve ooze
         process_ooze
       else
         process_ooze(ooze)
       end
+
       yield(target) if block_given?
+
       exit_if_no_changes!
       update_ooze(target)
     end
@@ -30,7 +32,7 @@ class Eco::API::UseCases::OozeSamples::OozeRunBaseCase < Eco::API::UseCases::Ooz
   end
 
   def stage(stage_id_name = stage_id, ooze: target)
-    super(stage_id_name, ooze: ooze)
+    super
   end
 
   def ooze_id
@@ -43,11 +45,12 @@ class Eco::API::UseCases::OozeSamples::OozeRunBaseCase < Eco::API::UseCases::Ooz
 
   def update_ooze(ooz = target)
     prompt_to_confirm!
-    super(ooz)
+
+    super
   end
 
   def exit_if_no_changes!
-    return if (changes = !!patch_doc["page"])
+    return if !!patch_doc["page"]
 
     log(:info) { "No Changes!!" }
     exit(0)

data/lib/eco/cli_default/workflow.rb

@@ -1,12 +1,14 @@
 ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
   ASSETS.config.workflow do |wf| # rubocop:disable Metrics/BlockLength
     rescued = false
+
     # default rescue
     wf.rescue do |err, io|
       next io if rescued
 
       rescued = true
       log(:debug) { err.patch_full_message }
+
       wf.run(:close, io: io)
     rescue StandardError => e
       puts "Some problem in workflow.rescue: #{e}"
@@ -74,10 +76,10 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
     end
 
     wf.on(:usecases) do |_wf_ca, io|
-      unless cli.config.usecases.process(io: io)
-        log(:info) { "No update operation specified... quitting" }
-        exit 0
-      end
+      next if cli.config.usecases.process(io: io)
+
+      log(:info) { "No update operation specified... quitting" }
+      exit 0
     end
 
     wf.before(:launch_jobs) do |_wf_jobs, _io|
@@ -95,11 +97,13 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
       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
 
@@ -117,6 +121,7 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
           end
           msg
         }
+
         next
       end
 
@@ -131,6 +136,7 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
           use.launch(io: io).base
         rescue Eco::API::UseCases::BaseIO::MissingParameter => e
           raise unless e.required == :people
+
           log(:debug) {
             "Skipping use case '#{use.name}' -- no base people detected for the current run"
           }

data/lib/eco/csv/stream.rb

@@ -7,6 +7,7 @@ module Eco
 
       def initialize(filename, **kargs)
         raise ArgumentError, "File '#{filename}' does not exist" unless ::File.exist?(filename)
+
         @filename = filename
         @params   = {
           headers:     true,
@@ -55,6 +56,7 @@ module Eco
       # see https://dalibornasevic.com/posts/68-processing-large-csv-files-with-ruby
       def csv
         return @csv if instance_variable_defined?(:@csv)
+
         @fd  = ::File.open(filename, 'r')
         @csv = Eco::CSV.new(fd, **params)
       end

data/lib/eco/csv.rb

@@ -5,9 +5,9 @@ module Eco
       include Eco::Data::Files
 
       # @return [Eco::CSV::Table]
-      def parse(data, **kargs, &block)
+      def parse(data, **kargs)
         kargs = {headers: true, skip_blanks: true}.merge(kargs)
-        Eco::CSV::Table.new(super(data, **kargs, &block))
+        Eco::CSV::Table.new(super)
       end
 
       # @return [Eco::CSV::Table]
@@ -51,6 +51,7 @@ module Eco
           included = yield(row) if block_given?
           count += 1            if included
         end
+
         count
       end
     end

data/lib/eco/language/methods/delegate_missing.rb

@@ -7,7 +7,7 @@ module Eco
         end
 
         def method_missing(method_name, *args, **kargs, &block)
-          super unless receiver = object_missing_delegated_to
+          super unless (receiver = object_missing_delegated_to)
           receiver.send(method_name, *args, **kargs, &block)
         end
 
@@ -19,8 +19,9 @@ module Eco
 
         # retrieve the delegate_missing_to object
         def object_missing_delegated_to
-          return nil unless @delegate_missing_to
-          self.method(@delegate_missing_to).call
+          return unless @delegate_missing_to
+
+          method(@delegate_missing_to).call
         end
       end
     end

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = '3.0.18'.freeze
+  VERSION = '3.0.20'.freeze
 end