eco-helpers 2.7.16 → 2.7.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c94232f6124e63e5b9df716e6e4550b10e3853e2cd2ad9ee5dc6289bf4a2a56
-  data.tar.gz: 224908e975dff3cf04d03c5c6cc55fde4472a622010a0548beb731cfb1e834d0
+  metadata.gz: 35f96561e2b58978c8949c744ac79c87888f067def10f63e00e3393e94cb992c
+  data.tar.gz: 7dba34b74428c53f7167eb1075b11bbd306432b3687c05986c66610da5b69f5e
 SHA512:
-  metadata.gz: 2521d794cfa6f6d47c938df024f48540d4bf6eb2401a4c5a2e805d556814e1bdfef3949a03f492b7ab00ce98f56b752438e06a0860aebdb788c5eda056b242de
-  data.tar.gz: 245b52b949c7c8141821ce61c0b58beed8242d5b0a6efd493892e1f9c96f58198db6fa4b2c0da0c08b275ff8a6eb7c6444e099dd1c1898a532bd8310a9201c8a
+  metadata.gz: 35223b9e52a315cf78b65393b509675a5ab515976e36535906b1a1e4588ccab178272ce209ab964b4f0365f74adccae9536db778edc5b524fa0cc70b327f0ccf
+  data.tar.gz: 0b356c4f3ca79f4ae57cae1db37f97455199c0772a165f294577bf7cfe3b4f1249a3c6cbee34c8903cb2d637a3b4b28658a3897680d61b2494aeffdd026efb8f

data/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 All notable changes to this project will be documented in this file.
 
-## [2.7.16] - 2024-06-18
+## [2.7.18] - 2024-06-xx
 
 ### Added
 
@@ -10,14 +10,36 @@ All notable changes to this project will be documented in this file.
 
 ### Fixed
 
-- `RegisterUpdateCase` filters
-
-## [2.7.15] - 2024-06-18
+## [2.7.17] - 2024-06-22
 
 ### Added
 
+- **Stop on uknown** options will try to offer suggestions from now on
+- `Eco::CSV::count` class method to stream-count the number of rows
+  - Option `-start-at` allows to start the count at certain row idx
+
 ### Changed
 
+- Added options to case `-split-csv`
+  - `-start-at`
+  - `-simulate` a dry-run will return the count and won't generate the files.
+- `Eco::CSV::split`
+  - the `block` allows to filter what rows should be included
+
+### Fixed
+
+- `Workflow::Mailer`: shouldn't send notification when there is an **error** that doesn't really need to be notified.
+- `to-csv` case should accepte target folder as an argument
+- `options_set` sort namespaces
+
+## [2.7.16] - 2024-06-18
+
+### Fixed
+
+- `RegisterUpdateCase` filters
+
+## [2.7.15] - 2024-06-18
+
 ### Fixed
 
 - `Eco::API::Common::People::EntryFactor` super must be called before

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

@@ -17,7 +17,10 @@ class Eco::API::Common::Loaders::Workflow::Mailer < Eco::API::Common::Loaders::W
       next unless session.mailer?
       next if     session.config.dry_run?
       next unless session.config.run_mode_remote?
-      next unless some_update?(io) || error?
+
+      # temporary contingency
+      maybe_error_pages_or_tree_updates = other_case?(io) && error?
+      next unless some_update?(io) || maybe_error_pages_or_tree_updates
 
       subject = base_subject
 
@@ -53,6 +56,12 @@ class Eco::API::Common::Loaders::Workflow::Mailer < Eco::API::Common::Loaders::W
       end
     end
 
+    def other_case?(io)
+      cli.config.usecases.active(io: io).any? do |usecase, _data|
+        %i[other].any? { |type| usecase.type == type }
+      end
+    end
+
     def error?
       !!error
     end

data/lib/eco/api/microcases/people_cache.rb

@@ -7,18 +7,17 @@ module Eco
       def people_cache(filename = enviro.config.people.cache)
         logger.info("Going to get all the people via API")
 
-        start = Time.now
-        people = session.batch.get_people
+        start   = Time.now
+        people  = session.batch.get_people
         secs    = (Time.now - start).round(3)
         cnt     = people.count
         per_sec = (cnt.to_f / secs).round(2)
         logger.info("Loaded #{cnt} people in #{secs} seconds (#{per_sec} people/sec)")
 
-        file   = file_manager.save_json(people, filename, :timestamp)
+        file = file_manager.save_json(people, filename, :timestamp)
         logger.info("#{people.length} people loaded and saved locally to #{file}.")
         Eco::API::Organization::People.new(people)
       end
-
     end
   end
 end

data/lib/eco/api/microcases/people_load.rb

@@ -15,19 +15,23 @@ module Eco
       #   - `:file` if it is supposed to load people from a file.
       #   - `:save` if it is supposed to cache/save the data locally once obtained people from the server (`:api`)
       # @return [Eco::API::Organization::People] the `People` object with the data.
-      def people_load(filename = enviro.config.people.cache, modifier: [:newest, :api])
+      def people_load(filename = enviro.config.people.cache, modifier: %i[newest api]) # rubocop:disable Metrics/AbcSize
         modifier  = [modifier].flatten
-        load_file = [:file, :newest].any? {|flag| modifier.include?(flag)}
+        load_file = %i[file newest].any? {|flag| modifier.include?(flag)}
+
         case
         when filename && load_file
-          if file = people_load_filename(filename, newest: modifier.include?(:newest))
+          file = people_load_filename(filename, newest: modifier.include?(:newest))
+
+          if file
             file_manager.load_json(file).tap do |people|
               logger.info("#{people&.length} people loaded from file #{file}") if people.is_a?(Array)
             end
           else
             logger.error("could not find the file #{file_manager.dir.file(filename)}")
             exit unless modifier.include?(:api)
-            people_load(modifier: modifier - [:newest, :file])
+
+            people_load(modifier: modifier - %i[newest file])
           end
         when modifier.include?(:api)
           logger.info("Going to get all the people via API (load)")
@@ -39,12 +43,12 @@ module Eco
             per_sec = (cnt.to_f / secs).round(2)
             logger.info("Loaded #{cnt} people in #{secs} seconds (#{per_sec} people/sec)")
 
-            if modifier.include?(:save) && people && people.length > 0
+            if modifier.include?(:save) && people && people.length.positive?
               file = file_manager.save_json(people, filename, :timestamp)
-              logger.info("#{people.length } people saved to file #{file}.")
+              logger.info("#{people.length} people saved to file #{file}.")
             end
           end
-        end.yield_self do |people|
+        end.then do |people|
           Eco::API::Organization::People.new(people)
         end
       end
@@ -61,7 +65,6 @@ module Eco
           file_manager.dir.file(filename, should_exist: true)
         end
       end
-
     end
   end
 end

data/lib/eco/api/microcases/people_refresh.rb

@@ -9,24 +9,26 @@ module Eco
       # @param people [Eco::API::Organization::People] the people that needs refresh.
       # @param include_created [Boolean] include people created during this session? (will check `:create` batch jobs).
       # @return [Eco::API::Organization::People] the `People` object with the data.
-      def people_refresh(people:, include_created: true)
+      def people_refresh(people:, include_created: true) # rubocop:disable Metrics/AbcSize
         people = people.newFrom people.select do |person|
           !person.new? || !person.dirty?
         end
+
         ini = people.length
+
         if include_created
           session.job_groups.find_jobs(type: :create).map do |job|
-            to_add = job.people.select {|person| !person.dirty?}
+            to_add = job.people.reject(&:dirty?)
             people = people.merge(to_add)
           end
         end
 
         created = people.length - ini
-        msg  = "Going to refresh #{people.length} people with server data"
-        msg += " (including #{created} that were created)" if created > 0
+        msg    = "Going to refresh #{people.length} people with server data"
+        msg   += " (including #{created} that were created)" if created.positive?
         logger.info(msg)
 
-        start = Time.now
+        start   = Time.now
         entries = session.batch.get_people(people, silent: true)
         secs    = (Time.now - start).round(3)
         cnt     = entries.count
@@ -34,11 +36,10 @@ module Eco
         logger.info("Re-loaded #{cnt} people (out of #{people.length}) in #{secs} seconds (#{per_sec} people/sec)")
 
         missing = people.length - entries.length
-        logger.error("Missed to obtain #{missing} people during the refresh") if missing > 0
+        logger.error("Missed to obtain #{missing} people during the refresh") if missing.positive?
 
         Eco::API::Organization::People.new(entries)
       end
-
     end
   end
 end

data/lib/eco/api/microcases/people_search.rb

@@ -5,52 +5,57 @@ module Eco
       # @note
       #   - this helper is normally used to **get partial** part of the people manager.
       #   - therefore, normally used with _**delta** input files_ (files with only the differences).
-      # @param data [Eco::API::Organization::People, Enumerable<Person>, Enumerable<Hash>] `People` to search against the server.
+      # @param data [Eco::API::Organization::People, Enumerable<Person>, Enumerable<Hash>]
+      #   `People` to search against the server.
       # @param options [Hash] the options.
       # @param silent [Boolean] `false` if low level search messages should be shown.
       # @return [Eco::API::Organization::People] the `People` object with the found persons.
-      def people_search(data, options: {}, silent: true)
+      def people_search(data, options: {}, silent: true) # rubocop:disable Metrics/AbcSize
         session.logger.info("Going to api get #{data.length} entries...")
 
         start = Time.now
-        people = session.batch.search(data, silent: silent).yield_self do |status|
-          secs    = (Time.now - start).round(3)
-          Eco::API::Organization::People.new(status.people).tap do |people|
+        people = session.batch.search(data, silent: silent).then do |status|
+          secs = (Time.now - start).round(3)
+          Eco::API::Organization::People.new(status.people).tap do |people| # rubocop:disable Lint/ShadowingOuterLocalVariable
             cnt     = people.count
             per_sec = (cnt.to_f / secs).round(2)
-            msg     = "... could get #{cnt} people (out of #{data.length} entries) in #{secs} seconds (#{per_sec} people/sec)"
+            msg     = "... could get #{cnt} people "
+            msg    << "(out of #{data.length} entries) in #{secs} seconds (#{per_sec} people/sec)"
             session.logger.info(msg)
           end
         end
 
         # get the supervisors of found people (current supervisors)
         supers = people_search_prepare_supers_request(people)
-        if supers.length > 0
+        if supers.length.positive?
           session.logger.info("  Going to api get #{supers.length} current supervisors...")
           start = Time.now
-          people = session.batch.search(supers, silent: silent).yield_self do |status|
+          people = session.batch.search(supers, silent: silent).then do |status|
             secs    = (Time.now - start).round(3)
             found   = status.people
             cnt     = found.count
             per_sec = (cnt.to_f / secs).round(2)
-            msg     = "... could find #{cnt} current supers (out of #{supers.length}) in #{secs} seconds (#{per_sec} people/sec)"
+            msg     = "... could find #{cnt} current supers "
+            msg    << "(out of #{supers.length}) in #{secs} seconds (#{per_sec} people/sec)"
             session.logger.info(msg)
+
             people.merge(found, strict: micro.strict_search?(options))
           end
         end
 
         # get the supervisors referred in the input data (future supervisors)
         supers = people_search_prepare_supers_request(data, people)
-        if supers.length > 0
+        if supers.length.positive?
           session.logger.info("  Going to api get #{supers.length} supervisors as per input entries...")
           start = Time.now
 
-          people = session.batch.search(supers, silent: silent).yield_self do |status|
+          people = session.batch.search(supers, silent: silent).then do |status|
             secs    = (Time.now - start).round(3)
             found   = status.people
             cnt     = found.count
             per_sec = (cnt.to_f / secs).round(2)
-            msg     = "... could find #{cnt} input supers (out of #{supers.length}) in #{secs} seconds (#{per_sec} people/sec)"
+            msg     = "... could find #{cnt} input supers "
+            msg    << "(out of #{supers.length}) in #{secs} seconds (#{per_sec} people/sec)"
             session.logger.info(msg)
             people.merge(found, strict: micro.strict_search?(options))
           end
@@ -66,25 +71,26 @@ module Eco
       def people_search_prepare_supers_request(data, people = data)
         data.each_with_object([]) do |entry, request|
           spr = {"id" => (sup_id = people_search_super_id(entry))}
-          unless !sup_id || request.include?(spr)
-            micro.with_supervisor(sup_id, people) do |supervisor|
-              request.push(spr) unless supervisor
-            end
+          next if !sup_id || request.include?(spr)
+
+          micro.with_supervisor(sup_id, people) do |supervisor|
+            request.push(spr) unless supervisor
           end
         end
       end
 
       # Gets the `supervisor_id` from `value`
       def people_search_super_id(value)
-        sup_id = if value.respond_to?(:supervisor_id)
-                value.supervisor_id
-              elsif value.is_a?(Hash) && value.key("supervisor_id")
-                value["supervisor_id"]
-              end
+        sup_id =
+          if value.respond_to?(:supervisor_id)
+            value.supervisor_id
+          elsif value.is_a?(Hash) && value.key("supervisor_id")
+            value["supervisor_id"]
+          end
+
         sup_id = nil if sup_id.to_s.strip.empty?
         sup_id
       end
-
     end
   end
 end

data/lib/eco/api/usecases/cli/dsl.rb

@@ -7,9 +7,10 @@ module Eco
           def apply!(arg_case = cli_name)
             #puts "DEFINING CLI for '#{arg_case}' via #{self}"
             if applied?(arg_case)
-              puts  "Warning: (#{self}) Tried to call again cli.apply! on '#{arg_case}'"
+              puts "Warning: (#{self}) Tried to call again cli.apply! on '#{arg_case}'"
               return self
             end
+
             cli_config_case(arg_case)
             apply_options(arg_case)
             applied!(arg_case)
@@ -29,10 +30,11 @@ module Eco
           end
 
           attr_writer :usecase
+
           # Unless specified, assume Cli class hangs from its case namespace
           def usecase
-            raise "#{self} is to use to extend a class" unless self.is_a?(Class)
-            @usecase ||= Kernel.const_get(self.to_s.split('::')[0..-2].join('::'))
+            raise "#{self} is to use to extend a class" unless is_a?(Class)
+            @usecase ||= Kernel.const_get(to_s.split('::')[0..-2].join('::'))
           end
 
           def description(value = nil)
@@ -50,7 +52,7 @@ module Eco
 
           # It defaults to the use case preceded by dash
           def cli_name(arg_name = nil)
-            @cli_name = (arg_name.nil? ? @cli_name : arg_name).yield_self do |value|
+            @cli_name = (arg_name.nil? ? @cli_name : arg_name).then do |value|
               value = "-#{name}" if value.nil?
               value
             end
@@ -66,7 +68,7 @@ module Eco
           end
 
           def add_option(arg, desc = nil, &block)
-            self.tap do
+            tap do
               "Overriding option '#{arg}' on case '#{name}'" if options.key?(arg)
               @options[arg] = Eco::API::UseCases::Cli::Option.new(arg, desc, &block)
             end
@@ -75,7 +77,7 @@ module Eco
           private
 
           def apply_options(arg_case)
-            options.each do |_key, option|
+            options.each_value do |option|
               option.link_case(cli_config_case(arg_case))
             end
           end

data/lib/eco/api/usecases/cli/option.rb

@@ -13,6 +13,7 @@ class Eco::API::UseCases::Cli
 
     def link_case(cli_config_case)
       raise ArgumentError, "cli_config_case must have an 'add_option' method. Given: #{cli_config_case.class}" unless cli_config_case.respond_to?(:add_option)
+
       cli_config_case.add_option(name, desc, &callback)
     end
   end

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

@@ -11,5 +11,10 @@ class Eco::API::UseCases::Default::People::Utils::SplitCsv
       count = SCR.get_arg("-max-rows", with_param: true)
       options.deep_merge!(output: {file: {max_rows: count}})
     end
+
+    add_option("-start-at", "Get only the last N-start_at rows") do |options|
+      count = SCR.get_arg("-start-at", with_param: true)
+      options.deep_merge!(output: {file: {start_at: count}})
+    end
   end
 end

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

@@ -7,15 +7,27 @@ class Eco::API::UseCases::Default::People::Utils::SplitCsv < Eco::API::Common::L
   type :other
 
   def main(*_args)
-    Eco::CSV.split(input_file, max_rows: max_rows).each do |file|
-      log(:info) {
-        "Generated file '#{file}'"
-      }
+    if simulate?
+      count = Eco::CSV.count(input_file, start_at: start_at)
+      log(:info) { "CSV '#{input_file}' has #{count} rows." }
+    else
+      Eco::CSV.split(
+        input_file,
+        max_rows: max_rows,
+        start_at: start_at,
+        &filter
+      ).each do |file|
+        log(:info) { "Generated file '#{file}'" }
+      end
     end
   end
 
   private
 
+  def filter
+    nil
+  end
+
   def input_file
     options.dig(:source, :file)
   end
@@ -31,4 +43,12 @@ class Eco::API::UseCases::Default::People::Utils::SplitCsv < Eco::API::Common::L
     num = nil if num.zero?
     num
   end
+
+  def start_at
+    return nil unless (num = options.dig(:output, :file, :start_at))
+
+    num = num.to_i
+    num = nil if num.zero?
+    num
+  end
 end

data/lib/eco/api/usecases/default_cases/to_csv_case.rb

@@ -2,6 +2,8 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
   name "to-csv"
   type :export
 
+  OUT_FILENAME = 'pm'
+
   attr_reader :people
 
   def main(people, _session, options, _usecase)
@@ -16,8 +18,9 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
     if options.dig(:export, :options, :split_schemas)
       by_schema.each do |id, people|
         sch_name = schemas.to_name(id)
-        prefix = sch_name ? sch_name.gsub(" ", "_") : "No_Schema"
-        create_file!("#{prefix}_#{file}", people)
+        prefix   = sch_name ? sch_name.gsub(" ", "_").downcase : "no_schema"
+        filename = in_folder("#{prefix}_#{File.basename(file)}")
+        create_file!(filename, people)
       end
     else
       create_file!(file, people)
@@ -61,15 +64,13 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
   end
 
   def nice_header_names(header, schema: nil)
-    schema ||= session.schema
-    name_maps = schema.fields_by_alt_id.each_with_object({}) do |(alt_id, fld), mappings|
-      mappings[alt_id] = fld.name
-    end.merge(nice_header_maps)
+    schema  ||= session.schema
+    name_maps = schema.fields_by_alt_id.transform_values(&:name).merge(nice_header_maps)
     header.map {|name| name_maps[name] || name}
   end
 
   def to_entry_type(person)
-    session.new_entry(person, dependencies: deps).yield_self do |person_entry|
+    session.new_entry(person, dependencies: deps).then do |person_entry|
       options.dig(:export, :options, :internal_names) ? person_entry.mapped_entry : person_entry.external_entry
     end
   end
@@ -79,14 +80,37 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
   end
 
   def file
-    @file ||= (options[:file] || options.dig(:export, :file, :name)).tap do |filename|
-      unless filename
-        session.logger.error("Destination file not specified")
-        return false
-      end
+    @file ||= out_filename.tap do |filename|
+      next if filename
+
+      log(:error) { "Destination file not specified" }
+      return false
     end
   end
 
+  def out_filename
+    return options_file unless options_folder?
+
+    File.join(options_file, "#{config.active_enviro}_#{OUT_FILENAME}.csv")
+  end
+
+  def in_folder(filename)
+    basename = File.basename(filename)
+    return basename unless options_folder?
+
+    File.join(options_file, basename)
+  end
+
+  def options_folder?
+    return false unless (value = options_file)
+
+    File.directory?(value)
+  end
+
+  def options_file
+    options[:file] || options.dig(:export, :file, :name)
+  end
+
   def by_schema
     people.group_by do |person|
       if (details = person.details)

data/lib/eco/cli/config/filters.rb

@@ -15,7 +15,8 @@ module Eco
         def help(msg = nil, refine: nil)
           refinement = refine.is_a?(String)? " (containing: '#{refine}')" : ""
           msg ||= "The following are the available filters#{refinement}:"
-          [msg].yield_self do |lines|
+
+          [msg].then do |lines|
             max_len = keys_max_len(@filters.keys)
             @filters.keys.sort.select do |key|
               !refine.is_a?(String) || key.include?(refine)
@@ -26,10 +27,19 @@ module Eco
           end.join("\n")
         end
 
+        def available(keys: false)
+          return @filters.keys if keys
+
+          @filters.keys.map do |key|
+            [key, @filters[key], @description[key]]
+          end
+        end
+
         # @param option [String] the command line option that activates this filter.
         # @param desc [String] description of the filter.
         def add(option, desc = nil, &block)
-          raise "Missing block to define the filters builder" unless block_given?
+          raise ArgumentError, "Missing block to define the filters builder" unless block_given?
+
           callback = block
           [option].flatten.compact.each do |opt|
             @filters[opt]     = callback
@@ -38,7 +48,7 @@ module Eco
           self
         end
 
-        def process(io:)
+        def process(*)
           raise "You need to override this method in child classes"
         end
       end

data/lib/eco/cli/config/help.rb

@@ -2,8 +2,7 @@ module Eco
   class CLI
     class Config
       module Help
-
-        def help(*args)
+        def help(*_args)
           raise "this needs to be reimplemented in the child class and return a string"
         end
 
@@ -16,11 +15,12 @@ module Eco
         # Creatas a well aligned line
         def help_line(key, desc, keys_max_len = key.length, line_len = 100)
           blanks    = keys_max_len + 3 - key.length
-          blanks    = blanks < 0 ? 0 : blanks
+          blanks    = [blanks, 0].max
           top_line  = "  #{key}#{" "*blanks} "
           indent    = top_line.length
           first     = true
-          each_slice_words(desc, line_len - indent).each_with_object([]) do |line, lines|
+
+          each_slice_words(desc, line_len - indent).each_with_object([]) do |line, lines| # rubocop:disable Style/RedundantEach
             lines << (first ? "#{top_line}#{line}" : "#{" " * indent}#{line}")
             first = false
           end.join("\n")
@@ -33,14 +33,16 @@ module Eco
               liner << part
             else
               yield(liner) if block_given?
-              out << liner
+
+              out  << liner
               liner = part.strip
             end
           end.tap do |out|
-            if out.empty? || !liner.empty?
-              yield(liner) if block_given?
-              out << liner if liner
-            end
+            next unless out.empty? || !liner.empty?
+
+            yield(liner) if block_given?
+
+            out << liner if liner
           end
         end
       end

data/lib/eco/cli/config/input.rb

@@ -2,14 +2,13 @@ module Eco
   class CLI
     class Config
       class Input
-
         attr_reader :core_config
         attr_reader :default_option
 
         def initialize(core_config:, default_option: nil)
           @core_config    = core_config
           @default_option = default_option
-          @callbacks = {}
+          @callbacks      = {}
         end
 
         def default_option?
@@ -20,16 +19,17 @@ module Eco
           option ||= default_option
           raise "Missing option to identify the input (no default defined)" unless !!option
           raise "Missing block to define the input obtention process" unless block
+
           @callbacks[option] = block
         end
 
         def get(io:, option: nil)
-          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
-            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
-          end
+          msg = "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          raise ArgumentError, msg unless io.is_a?(Eco::API::UseCases::BaseIO)
 
           option ||= default_option
-          raise "Missing option to identify the input (no default defined)" unless !!option
+          raise "Missing option to identify the input (no default defined)" unless option
+
           callback = @callbacks[option] || @callbacks[default_option]
           callback.call(io.session, option, io.options)
         end

data/lib/eco/cli/config/options_set.rb

@@ -3,10 +3,10 @@ module Eco
     class Config
       class OptionsSet
         include Eco::CLI::Config::Help
+
         attr_reader :core_config
 
-        class OptConfig < Struct.new(:name, :namespace, :description, :callback)
-        end
+        OptConfig = Struct.new(:name, :namespace, :description, :callback)
 
         def initialize(core_config:)
           @core_config = core_config
@@ -15,19 +15,21 @@ module Eco
 
         # @return [String] summary of the options.
         def help(refine: nil)
-          indent = 2
-          spaces = any_non_general_space_active? ? active_namespaces : namespaces
+          indent     = 2
+          spaces     = any_non_general_space_active? ? active_namespaces : namespaces
           refinement = refine.is_a?(String)? " (containing: '#{refine}')" : ""
-          ["The following are the available options#{refinement}:"].yield_self do |lines|
+
+          ["The following are the available options#{refinement}:"].then do |lines|
             max_len = keys_max_len(options_args(spaces)) + indent
             spaces.each do |namespace|
               is_general = (namespace == :general)
               str_indent = is_general ? "" : " " * indent
               lines << help_line(namespace, "", max_len) unless is_general
-              options_set(namespace).select do |arg, option|
+
+              options_set(namespace).select do |_arg, option| # rubocop:disable Style/HashEachMethods
                 !refine.is_a?(String) || option.name.include?(refine)
-              end.each do |arg, option|
-                lines << help_line(" " * indent + "#{option.name}", option.description, max_len)
+              end.each do |_arg, option|
+                lines << help_line("#{str_indent}#{option.name}", option.description, max_len)
               end
             end
             lines
@@ -41,6 +43,19 @@ module Eco
           end.uniq
         end
 
+        # Options that are known for active namespaces (CLI-present)
+        def available(keys: false)
+          sets.select do |namespace, _opts_set|
+            active_namespace?(namespace)
+          end.each_value.with_object([]) do |opts_set, options|
+            options.concat(opts_set.values)
+          end.then do |options|
+            next options unless keys
+
+            options.map(&:name)
+          end
+        end
+
         # @param option [String, Array<String>] the command line option(s).
         # @param namespace [String] preceding command(s) argument that enables this option.
         # @param desc [String] description of the option.
@@ -51,17 +66,18 @@ module Eco
           unless opts.empty?
             callback = block
             opts.each do |opt|
-              puts "Overriding CLI option '#{option}' in '#{namespace}' CLI case / namespace" if option_exists?(opt, namespace)
+              msg = "Overriding CLI option '#{option}' in '#{namespace}' CLI case / namespace"
+              puts msg if option_exists?(opt, namespace)
               options_set(namespace)[opt] = OptConfig.new(opt, namespace, desc, callback)
             end
           end
+
           self
         end
 
         def process(io:)
-          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
-            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
-          end
+          msg = "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          raise ArgumentError, msg unless io.is_a?(Eco::API::UseCases::BaseIO)
 
           active_options.each do |option|
             option.callback.call(io.options, io.session)
@@ -70,8 +86,9 @@ module Eco
           io.options
         end
 
+        # Options that have been invoked via CLI
         def active_options
-          @active_options ||= sets.select do |namespace, opts_set|
+          @active_options ||= sets.select do |namespace, _opts_set|
             active_namespace?(namespace)
           end.each_with_object([]) do |(namespace, opts_set), options|
             opts_set.each do |arg, option|
@@ -81,19 +98,20 @@ module Eco
         end
 
         def all_options
-          sets.each_with_object([]) do |(namespace, opts_set), options|
+          sets.each_with_object([]) do |(_namespace, opts_set), options|
             options << opts_set.values
           end
         end
 
         def namespaces
           sets.keys.sort_by do |key|
-            key == :general
+            next 1 if key == :general
+            0
           end
         end
 
         def any_non_general_space_active?
-          (active_namespaces - [:general]).length > 0
+          (active_namespaces - [:general]).length.positive?
         end
 
         def active_namespaces
@@ -104,7 +122,6 @@ module Eco
           end
         end
 
-
         private
 
         def active_namespace?(namespace)
@@ -132,10 +149,6 @@ module Eco
           }
         end
 
-        def namespaces
-          @sets.keys
-        end
-
         def options_set(namespace = :general)
           @sets[namespace] ||= {}
         end

data/lib/eco/cli/config/use_cases.rb

@@ -39,6 +39,15 @@ module Eco
           end.join("\n")
         end
 
+        # The linked cases
+        def available(keys: false)
+          @linked_cases.values.then do |cases|
+            next cases unless keys
+
+            cases.map(&:option)
+          end
+        end
+
         # Integrates a usecase to the command line.
         # @param option_case [String] the command line option to invoke the usecase.
         # @param type [Symbol] the type of usecase.
@@ -46,10 +55,12 @@ module Eco
         # @param case_name [String, nil] the name of the usecase as defined.
         def add(option_case, type, desc = nil, case_name: nil, &callback)
           Eco::API::UseCases::UseCase.validate_type(type)
+
           unless block_given?
             raise "You must specify a valid 'case_name' when no block is provided" unless case_name
             raise "'case_name' expected to be a String. Given: #{case_name.class}" unless case_name.is_a?(String)
           end
+
           puts "Overriding CLI case '#{option_case}'" if @linked_cases.key?(option_case)
           @linked_cases[option_case] = CaseConfig.new(self, option_case, type, desc, case_name, callback)
         end
@@ -60,6 +71,7 @@ module Eco
           io.session.usecases.each do |usecase|
             next unless usecase.respond_to?(:classed_definition)
             next unless (original_case = usecase.classed_definition)
+
             original_case.cli_apply!
           end
         end
@@ -84,9 +96,12 @@ module Eco
 
         def process(io:)
           validate_io!(io)
+
           processed = false
+
           active(io: io).each do |usecase, data|
             raise "Something went wrong when scoping active cases" unless data
+
             processed = true
             io = case_io(io: io, usecase: usecase)
             # some usecases have a callback to collect the parameters
@@ -101,6 +116,7 @@ module Eco
         # Gets a `UseCaseIO`
         def case_io(io:, usecase:)
           validate_io!(io)
+
           case io
           when Eco::API::UseCases::UseCaseIO
             io.chain(usecase: usecase)
@@ -122,12 +138,12 @@ module Eco
               params  = io.params(keyed: true).merge(type: data.type)
               io      = io.new(**params, validate: false)
               callback.call(*io.params).tap do |use|
-                unless use.is_a?(Eco::API::UseCases::UseCase)
-                  msg  = "When adding a usecase, without specifying 'case_name:', "
-                  msg += "the block that integrates usecase for cli option '#{data.option}'"
-                  msg += " must return an Eco::API::UseCases::UseCase object. It returns #{use.class}"
-                  raise msg
-                end
+                next if use.is_a?(Eco::API::UseCases::UseCase)
+
+                msg  = "When adding a usecase, without specifying 'case_name:', "
+                msg << "the block that integrates usecase for cli option '#{data.option}'"
+                msg << "must return an Eco::API::UseCases::UseCase object. It returns #{use.class}"
+                raise msg
               end
             end
         end

data/lib/eco/cli/config.rb

@@ -1,7 +1,6 @@
 module Eco
   class CLI
     class Config
-
       attr_reader :cli
 
       def initialize(cli:)
@@ -16,6 +15,16 @@ module Eco
         cli.args
       end
 
+      # All the available known option args that can be used in the CLI
+      def available_option_args
+        [
+          usecases.available(keys: true),
+          options_set.available(keys: true),
+          people_filters.available(keys: true),
+          input_filters.available(keys: true)
+        ].flatten.uniq
+      end
+
       def options_set
         @opions_set ||= Eco::CLI::Config::OptionsSet.new(core_config: self)
         @opions_set.tap do |opts_set|
@@ -25,12 +34,10 @@ module Eco
 
       def input(default_option: nil, &block)
         @input ||= Eco::CLI::Config::Input.new(core_config: self, default_option: default_option)
-        if block_given?
-          @input.define(&block)
-          self
-        else
-          @input
-        end
+        return @input unless block_given?
+
+        @input.define(&block)
+        self
       end
 
       def people(io: nil, &block)
@@ -38,10 +45,11 @@ module Eco
           @people_load = block
           self
         else
-          raise "There is no definition on how to load people" unless instance_variable_defined?(:@people_load) && @people_load
-          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
-            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
-          end
+          msg = "There is no definition on how to load people"
+          raise msg unless instance_variable_defined?(:@people_load) && @people_load
+
+          msg = "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          raise msg unless io.is_a?(Eco::API::UseCases::BaseIO)
 
           io = io.new(type: :import, input: io.input || [])
           @people_load.call(*io.params)

data/lib/eco/cli/scripting/args_helpers.rb

@@ -7,7 +7,7 @@ module Eco
           @argv || ARGV
         end
 
-        def is_modifier?(value)
+        def is_modifier?(value) # rubocop:disable Naming/PredicateName
           Argument.is_modifier?(value)
         end
 
@@ -21,22 +21,34 @@ module Eco
           arguments.add(key, with_param: with_param)
         end
 
-
         # Validation to stop the `script` if among `argv` there's any **unknown** argument.
-        def stop_on_unknown!(exclude: [], only_options: false)
+        def stop_on_unknown!(exclude: [], only_options: false, all_available: nil)
           # validate only those that are options
-          unknown = arguments.unknown(exclude: exclude)
-          if only_options
-            unknown = unknown..select {|arg| is_modifier?(arg)}
+          suggestions = {}
+          args        = {
+            exclude:       exclude,
+            all_available: all_available
+          }
+          unknown = arguments.unknown(**args) do |key, correct|
+            suggestions[key] = correct unless correct.empty?
           end
+          unknown = unknown.select {|arg| is_modifier?(arg)} if only_options
 
-          unless unknown.empty?
-            msg  = "There are unknown options in your command line arguments:\n"
-            msg += "#{unknown}\n"
-            msg += "Please, remember that use case specific options should come after the use case in the command line.\n"
-            msg += "Use 'ruby main.rb -org [-usecase] --help -options' for more information"
-            raise msg
-          end
+          return if unknown.empty?
+
+          suggestions_str = suggestions.slice(*unknown).map do |key, correct|
+            str      = "Unknown option '#{key}'."
+            str_corr = correct.map {|key| "'#{key}'"}
+            str     << " Did you mean: #{str_corr.join(', ')}" unless correct.empty?
+            str
+          end.join("\n  * ")
+
+          msg  = "\nThere are UNKNOWN OPTIONS in your command line arguments !!"
+          msg << "\n  * #{suggestions_str}\n"
+          msg << "\nUse 'ruby main.rb -org [-usecase] --help -options' for more information"
+          msg << "\n  - Please, remember that use case specific options "
+          msg << "should come after the use case in the command line.\n"
+          raise msg
         end
 
         # @return [Boolean] if `key` is in the command line.
@@ -46,28 +58,31 @@ module Eco
 
         # @return [Integer, nil] the position of `key` in the command line.
         def get_arg_index(key)
-          return nil if !arg?(key)
+          return unless arg?(key)
+
           argv.index(key)
         end
 
         # @return [Boolean] if `key1` precedes `key2` in the command line.
-        def arg_order?(key1, key2)
-          return false unless (k1 = get_arg_index(key1)) && k2 = get_arg_index(key2)
-          k1 < k2
+        def arg_order?(key_1, key_2)
+          k_1 = get_arg_index(key_1)
+          k_2 = get_arg_index(key_2)
+          return false unless k_1 && k_2
+
+          k_1 < k_2
         end
 
         # @return [String, Boolean] the argument value if `with_param` or a `Boolean` if not.
         def get_arg(key, with_param: false, valid: true)
           # track what a known option looks like
           known_argument(key, with_param: with_param)
-          return nil unless index = get_arg_index(key)
-          value = true
-          if with_param
-            value  = argv[index + 1]
-            #puts "modifier argument: #{value}"
-            value  = nil if valid && is_modifier?(value)
-          end
-          return value
+          return nil  unless (index = get_arg_index(key))
+          return true unless with_param
+
+          value  = argv[index + 1]
+          #puts "modifier argument: #{value}"
+          value  = nil if valid && is_modifier?(value)
+          value
         end
 
         # @return [String] the filename.

data/lib/eco/cli/scripting/arguments.rb

@@ -13,6 +13,7 @@ module Eco
 
         def each(&block)
           return to_enum(:each) unless block
+
           @known.values.each(&block)
         end
 
@@ -22,7 +23,8 @@ module Eco
 
         def <<(arg)
           raise "Expected Argument. Given #{arg.class}" unless arg.is_a?(Argument)
-          if karg = @known[arg.key]
+
+          if (karg = @known[arg.key])
             #puts "Found already existent option #{arg.key} (with_param: arg.with_param?)"
             karg.with_param! if arg.with_param?
           else
@@ -40,14 +42,33 @@ module Eco
           @known.keys
         end
 
-        def unknown(exclude: [])
+        def unknown(exclude: [], all_available: nil)
           reduce(args.dup - exclude) do |not_known, arg|
             arg.args_slice(*not_known)
+          end.compact.tap do |list|
+            list.each do |key|
+              next unless block_given?
+
+              yield(key, unknown_suggestions(key, all_available: all_available))
+            end
           end
         end
 
+        def unknown_suggestions(str, all_available: nil)
+          return [] if str.nil?
+
+          str = str.to_s.strip
+          return [] if str.empty?
+
+          all_available ||= @known.keys
+          spell_checker   = DidYouMean::SpellChecker.new(
+            dictionary: all_available
+          )
+          spell_checker.correct(str)
+        end
+
         def any_unknown?(exclude: [])
-          unknown(exclude: exclude).length > 0
+          unknown(exclude: exclude).length.positive?
         end
 
         private

data/lib/eco/cli.rb

@@ -1,6 +1,5 @@
 module Eco
   class CLI
-
     def initialize
       @config = nil
     end

data/lib/eco/cli_default/workflow.rb

@@ -74,8 +74,9 @@ ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
       end
     end
 
-    wf.before(:launch_jobs) do
-      SCR.stop_on_unknown!
+    wf.before(:launch_jobs) do |_wf_jobs, io|
+      available_args = cli.config.available_option_args
+      SCR.stop_on_unknown!(all_available: available_args)
     end
 
     wf.on(:launch_jobs) do

data/lib/eco/csv/split.rb

@@ -5,10 +5,13 @@ module Eco
 
       attr_reader :filename
 
-      def initialize(filename, max_rows:, **kargs)
-        raise ArgumentError, "File '#{filename}' does not exist" unless ::File.exist?(filename)
+      def initialize(filename, max_rows:, start_at: nil, **kargs)
+        msg = "File '#{filename}' does not exist"
+        raise ArgumentError, msg unless ::File.exist?(filename)
+
         @filename = filename
         @max_rows = max_rows
+        @start_at = start_at
         @params   = kargs
         init
       end
@@ -20,7 +23,7 @@ module Eco
       #   - If `nil` it will create its own filename convention
       # @return [Array<String>] names of the generated files
       def call(&block)
-        stream.for_each do |row, ridx|
+        stream.for_each(start_at_idx: start_at) do |row, ridx|
           copy_row(row, ridx, &block)
         end
         out_files
@@ -32,7 +35,7 @@ module Eco
       private
 
       attr_reader :params
-      attr_reader :idx, :max_rows
+      attr_reader :idx, :max_rows, :start_at
       attr_reader :headers, :row_idx
 
       attr_accessor :exception
@@ -40,19 +43,29 @@ module Eco
       def copy_row(row, ridx, &block)
         @headers ||= row.headers
         @row_idx   = ridx
-        current_csv(ridx, &block) << row.fields
+
+        current_csv(ridx) do |csv, fidx, file_out|
+          included   = true
+          included &&= !block || yield(row, ridx, fidx, file_out)
+          next unless included
+
+          csv << row.fields
+        end
       end
 
       def current_csv(ridx)
         if split?(ridx) || @csv.nil?
           puts "Split at row #{row_idx}"
           @csv&.close
-          out_filename = generate_name(nidx = next_idx)
-          out_filename = yield(nidx, out_filename) if block_given?
-          @csv       = ::CSV.open(out_filename, "w")
-          @csv      << headers
-          out_files << out_filename
+
+          out_filename = generate_name(next_idx)
+          @csv         = ::CSV.open(out_filename, "w")
+          @csv        << headers
+          out_files   << out_filename
         end
+
+        yield(@csv, idx, out_files.last) if block_given?
+
         @csv
       end
 

data/lib/eco/csv/stream.rb

@@ -37,6 +37,7 @@ module Eco
       end
 
       def move_to_idx(start_at_idx)
+        start_at_idx ||= 0
         next_idx while (idx < start_at_idx) && (self.row = csv.shift)
       end
 

data/lib/eco/csv.rb

@@ -18,16 +18,38 @@ module Eco
         parse(get_file_content(file, **params), **kargs)
       end
 
-      # @yield [idx, file] a block to spot the filename
-      # @yieldparam idx [Integer] the number of the file
+      # Splits the csv `filename` into `max_rows`
+      # @yield [row, ridx, fidx, file]
+      # @yieldparam row [Integer] the row
+      # @yieldparam ridx [Integer] the index of the row in the source file
+      # @yieldparam fidx [Integer] the number of the file
       # @yieldparam file [String] the default name of the file
-      # @yieldreturn [String] the filename of the file `idx`.
-      #   - If `nil` it will create its own filename convention
+      # @yieldreturn [Bollean] whether the row should be included
       # @param filename [String] the orignal file
       # @param max_rows [Integer] number of rows per file
+      # @param start_at [Integer] row that sets the starting point.
+      #   Leave empty for the full set of rows.
       # @see Eco::CSV::Split#call
-      def split(filename, max_rows:, **kargs, &block)
-        Eco::CSV::Split.new(filename, max_rows: max_rows, **kargs).call(&block)
+      def split(filename, max_rows:, start_at: nil, **kargs, &block)
+        Eco::CSV::Split.new(
+          filename,
+          max_rows: max_rows,
+          start_at: start_at,
+          **kargs
+        ).call(&block)
+      end
+
+      # @note it excludes headers by default
+      # @return [Integer] the number of rows of the file
+      def count(filename, start_at: nil, **kargs)
+        count = 0
+        streamer = Eco::CSV::Stream.new(filename, **kargs)
+        streamer.for_each(start_at_idx: start_at) do |row|
+          included = true
+          included = yield(row) if block_given?
+          count += 1            if included
+        end
+        count
       end
     end
   end

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = '2.7.16'.freeze
+  VERSION = '2.7.17'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.7.16
+  version: 2.7.17
 platform: ruby
 authors:
 - Oscar Segura