eco-helpers 2.7.16 → 2.7.18

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.18'.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.18
 platform: ruby
 authors:
 - Oscar Segura