eco-helpers 2.0.16 → 2.0.22

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

@@ -16,6 +16,7 @@ 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
           top_line  = "  #{key}#{" "*blanks} "
           indent    = top_line.length
           first     = true

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

@@ -5,31 +5,53 @@ module Eco
         include Eco::CLI::Config::Help
         attr_reader :core_config
 
+        class OptConfig < Struct.new(:name, :namespace, :description, :callback)
+        end
+
         def initialize(core_config:)
           @core_config = core_config
-          @options_set = {}
-          @description = {}
+          @sets        = {}
         end
 
         # @return [String] summary of the options.
         def help
+          indent = 2
+          spaces = any_non_general_space_active? ? active_namespaces : namespaces
+
           ["The following are the available options:"].yield_self do |lines|
-            max_len = keys_max_len(@options_set.keys)
-            @options_set.keys.each do |key|
-              lines << help_line(key, @description[key], max_len)
+            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).each do |arg, option|
+                lines << help_line(" " * indent + "#{option.name}", option.description, max_len)
+              end
             end
             lines
           end.join("\n")
         end
 
-        # @param option [String] the command line option.
+        # @return [Array<String>] all the argument of the options in `namespaces`
+        def options_args(namespaces)
+          namespaces.each_with_object([]) do |space, args|
+            args.concat(options_set(space).keys)
+          end.uniq
+        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.
-        def add(option, desc = nil)
+        def add(option, desc = nil, namespace: :general)
           raise "Missing block to define the options builder" unless block_given?
-          callback = Proc.new
-          [option].flatten.compact.each do |opt|
-            @options_set[opt] = callback
-            @description[opt] = desc
+
+          opts = [option].flatten.compact
+          unless opts.empty?
+            callback = Proc.new
+            opts.each do |opt|
+              puts "Overriding option '#{option}' in '#{namespace}' namespace" if option_exists?(opt, namespace)
+              options_set(namespace)[opt] = OptConfig.new(opt, namespace, desc, callback)
+            end
           end
           self
         end
@@ -39,12 +61,83 @@ module Eco
             raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
           end
 
-          @options_set.each do |arg, callback|
-            callback.call(io.options, io.session) if SCR.get_arg(arg)
+          active_options.each do |option|
+            option.callback.call(io.options, io.session)
           end
+
           io.options
         end
 
+        def active_options
+          @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|
+              options << option if active_option?(arg, namespace)
+            end
+          end
+        end
+
+        def all_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
+          end
+        end
+
+        def any_non_general_space_active?
+          (active_namespaces - [:general]).length > 0
+        end
+
+        def active_namespaces
+          @active_namespaces ||= [].tap do |active|
+            active << :general
+            other = (namespaces - [:general]).select {|nm| SCR.arg?(nm)}
+            active.concat(other)
+          end
+        end
+
+
+        private
+
+        def active_namespace?(namespace)
+          (namespace == :general) || SCR.get_arg(namespace)
+        end
+
+        # Is the option active?
+        #   1. If :general namespace, it does just a direct check
+        #   2. Otherwise, the `namespace` wording should come first in the `cli` or it is considered inactive
+        def active_option?(opt, namespace = :general)
+          if namespace == :general
+            SCR.get_arg(opt)
+          else
+            active_namespace?(namespace) && SCR.arg_order?(namespace, opt) && SCR.get_arg(opt)
+          end
+        end
+
+        def option_exists?(opt, namespace = :general)
+          options_set(namespace).key?(opt)
+        end
+
+        def sets
+          @sets ||= {
+            general: {}
+          }
+        end
+
+        def namespaces
+          @sets.keys
+        end
+
+        def options_set(namespace = :general)
+          @sets[namespace] ||= {}
+        end
+
       end
     end
   end

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

@@ -5,18 +5,35 @@ module Eco
         include Eco::CLI::Config::Help
         attr_reader :core_config
 
+        class CaseConfig < Struct.new(:cases_config, :option, :type, :description, :casename, :callback)
+
+          def add_option(arg, desc = nil, &block)
+            core_config.options_set.add(arg, desc, namespace: option, &block)
+            self
+          end
+
+          private
+
+          def core_config
+            cases_config.core_config
+          end
+        end
+
+        class ActiveCase < Struct.new(:index, :option, :callback)
+
+        end
+
         def initialize(core_config:)
           @core_config  = core_config
           @linked_cases = {}
-          @description  = {}
         end
 
         # @return [String] summary of the use cases.
         def help
           ["The following are the available use cases:"].yield_self do |lines|
             max_len = keys_max_len(@linked_cases.keys)
-            @linked_cases.keys.sort.each do |key|
-              lines << help_line(key, @description[key], max_len)
+            @linked_cases.keys.sort.each do |option_case|
+              lines << help_line(option_case, @linked_cases[option_case].description, max_len)
             end
             lines
           end.join("\n")
@@ -33,18 +50,8 @@ module Eco
             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
-
-          @linked_cases[option_case] = {
-            type => {
-              option:   option_case,
-              type:     type,
-              casename: case_name,
-              callback: callback
-            }
-          }
-          @description[option_case]  = desc
-
-          self
+          puts "Overriding case config '#{option_case}'" if @linked_cases.key?(option_case)
+          @linked_cases[option_case] = CaseConfig.new(self, option_case, type, desc, case_name, callback)
         end
 
         # Scopes/identifies which usecases are being invoked from the command line
@@ -55,20 +62,13 @@ module Eco
         def active(io:)
           validate_io!(io)
           return @active_cases unless !@active_cases
-          active_cases = {}
-          @linked_cases.each do |option_case, types|
+          @active_cases = @linked_cases.each_with_object({}) do |(option_case, data), active_cases|
             next nil unless SCR.get_arg(option_case)
-            types.each do |type, data|
-              if usecase = get_usecase(io: io, data: data)
-                active_cases[usecase] = {
-                  index:    SCR.get_arg_index(option_case),
-                  option:   option_case,
-                  callback: data[:callback]
-                }
-              end
+            if usecase = get_usecase(io: io, data: data)
+              index = SCR.get_arg_index(option_case)
+              active_cases[usecase] = ActiveCase.new(index, option_case, data.callback)
             end
-          end
-          @active_cases = active_cases.sort_by {|c, d| d[:index]}.to_h
+          end.sort_by {|c, d| d.index}.to_h
         end
 
         def process(io:)
@@ -79,7 +79,7 @@ module Eco
             processed = true
             io = case_io(io: io, usecase: usecase)
             # some usecases have a callback to collect the parameters
-            data[:callback]&.call(*io.params)
+            data.callback&.call(*io.params)
             io = usecase.launch(io: io)
           end
           processed
@@ -100,17 +100,17 @@ module Eco
         end
 
         def get_usecase(io:, data:)
-          usecase    = if case_name = data[:casename]
-            io.session.usecases.case(case_name, type: data[:type])
+          usecase    = if case_name = data.casename
+            io.session.usecases.case(case_name, type: data.type)
           end
-          usecase  ||= if callback  = data[:callback]
+          usecase  ||= if callback  = data.callback
             # identify/retrieve usecase via callback
-            params  = io.params(keyed: true).merge(type: data[:type])
+            params  = io.params(keyed: true).merge(type: data.type)
             io      = io.new(**params, validate: false)
             callback.call(*io.params).tap do |usecase|
               unless usecase.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 += "the block that integrates usecase for cli option '#{data.option}'"
                 msg += " must return an Eco::API::UseCases::UseCase object. It returns #{usecase.class}"
                 raise msg
               end

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

@@ -3,6 +3,7 @@ module Eco
     class Scripting
       module ArgsHelpers
 
+        # @return [Array<String] the command line arguments.
         def argv
           @argv || ARGV
         end
@@ -11,10 +12,18 @@ module Eco
           Argument.is_modifier?(value)
         end
 
+        # @return [Arguments] supported known arguments.
         def arguments
           @arguments ||= Arguments.new(argv)
         end
 
+        # Registers an argument as a known one.
+        def known_argument(key, with_param: false)
+          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)
           # validate only those that are options
           unknown = arguments.unknown(exclude: exclude)
@@ -23,18 +32,35 @@ module Eco
           end
 
           unless unknown.empty?
-            raise "There are unknown options in your command line arguments: #{unknown}"
+            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
         end
 
+        # @return [Boolean] if `key` is in the command line.
+        def arg?(key)
+          argv.include?(key)
+        end
+
+        # @return [Integer, nil] the position of `key` in the command line.
         def get_arg_index(key)
-          return nil if !argv.include?(key)
+          return nil if !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
+        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
-          arguments.add(key, with_param: with_param)
+          known_argument(key, with_param: with_param)
           return nil unless index = get_arg_index(key)
           value = true
           if with_param
@@ -45,13 +71,14 @@ module Eco
           return value
         end
 
+        # @return [String] the filename.
         def get_file(key, required: false, should_exist: true)
           filename = get_arg(key, with_param: true)
           if !filename && required
-            puts "You need to specify a file '#{key} file'"
+            puts "You need to specify a file or folder '#{key} file_or_folder'"
             exit(1)
           elsif !file_exists?(filename) && should_exist && required
-            puts "This file doesn't exist '#{filename}'"
+            puts "This file/folder doesn't exist '#{filename}'"
             exit(1)
           end
 

data/lib/eco/csv.rb

@@ -18,8 +18,10 @@ module Eco
         kargs = {headers: true,  skip_blanks: true}.merge(kargs)
 
         args = [file].tap do |arg|
-          coding = Eco::API::Common::Session::FileManager.encoding(file)
-          arg.push("rb:bom|utf-8") if coding == "bom"
+          encoding = Eco::API::Common::Session::FileManager.encoding(file)
+          #encoding = (encoding != "utf-8")? "#{encoding}|utf-8": encoding
+          #arg.push(encoding)
+          arg.push("rb:bom|utf-8") if encoding == "bom"
         end
 
         out = super(*args, **kargs).reject do |row|

data/lib/eco/csv/table.rb

@@ -1,4 +1,3 @@
-
 module Eco
   class CSV
     class Table < ::CSV::Table
@@ -9,6 +8,70 @@ module Eco
         super(to_rows_array(input))
       end
 
+      # @return [Hash] where keys are the groups and the values a `Eco::CSV::Table`
+      def group_by(&block)
+        rows.group_by(&block).transform_values do |rows|
+          self.class.new(rows)
+        end
+      end
+
+      # @return [Eco::CSV::Table]
+      def transform_values
+        transformed_rows = rows.map do |row|
+          res = yield(row)
+          case res
+          when Array
+            ::CSV::Row.new(row.headers, res)
+          when ::CSV::Row
+            res
+          end
+        end
+        self.class.new(transformed_rows)
+      end
+
+      # Slices the selected rows
+      # @return [Eco::CSV::Table]
+      def slice(*index)
+        case index.first
+        when Range, Numeric
+          self.class.new(rows.slice(index.first))
+        else
+          self
+        end
+      end
+
+      # @return [Eco::CSV::Table]
+      def slice_columns(*index)
+        case index.first
+        when Range, Numeric
+          columns_to_table(columns.slice(index.first))
+        when String
+          csv_cols = columns
+          csv_cols = index.each_with_object([]) do |name, cols|
+            col = csv_cols.find {|col| col.first == name}
+            cols << col if col
+          end
+          columns_to_table(csv_cols)
+        else
+          self
+        end
+      end
+
+      # @return [Eco::CSV::Table]
+      def delete_column(i)
+        csv_cols = columns
+        csv_cols.delete(i)
+        columns_to_table(csv_cols)
+      end
+
+      # Adds a new column at the end
+      # @param header_name [String] header of the new column
+      # @return [Eco::CSV::Table] with a new empty column
+      def add_column(header_name)
+        new_col = Array.new(length).unshift(header_name)
+        columns_to_table(columns.push(new_col))
+      end
+
       # @return [Array<::CSV::Row>]
       def rows
         [].tap do |out|
@@ -16,24 +79,40 @@ module Eco
         end
       end
 
+      # It removes all rows where all columns' values are the same
+      def delete_duplicates!
+        unique_rows = []
+        self.by_row!.delete_if do |row|
+          unique_rows.any? {|done| equal_rows?(row, done)}.tap do |found|
+            unique_rows << row unless found
+          end
+        end
+      end
+
+      # @param row1 [CSV:Row] row to be compared
+      # @param row2 [CSV:Row] row to be compared
+      # @param [Boolean] `true` if all values of `row1` are as of `row2`
+      def equal_rows?(row1, row2)
+        row1.fields.zip(row2.fields).all? do |(v1, v2)|
+          v1 == v2
+        end
+      end
+
       # @return [Integer] total number of rows not including the header
       def length
         to_a.length - 1
       end
 
+      def empty?
+        length < 1
+      end
+
       # @return [Array<Array>] each array is the column header followed by its values
       def columns
         to_a.transpose
       end
 
-      # Adds a new column at the end
-      # @param header_name [String] header of the new column
-      # @return [Eco::CSV::Table] with a new empty column
-      def add_column(header_name)
-        new_col = Array.new(length).unshift(header_name)
-        columns_to_table(columns.push(new_col))
-      end
-
+      # Creates a single `Hash` where each key, value is a column (header + values)
       # @note it will override columns with same header name
       # @return [Hash] keys are headers, values are arrays
       def columns_hash
@@ -42,6 +121,17 @@ module Eco
         end.to_h
       end
 
+      # Returns an array of row hashes
+      # @note it will override columns with same header
+      def to_a_h
+        rows.map(&:to_h)
+      end
+
+      # @see #to_a_h
+      def to_array_of_hashes
+        to_a_h
+      end
+
       private
 
       def columns_to_table(columns_array)
@@ -51,24 +141,34 @@ module Eco
 
       def to_rows_array(data)
         case data
-        when Array
-          return data unless data.length > 0
-          if data.first.is_a?(::CSV::Row)
-            data
-          elsif data.first.is_a?(Array)
-            headers  = data.shift
-            data.map do |arr_row|
-              CSV::Row.new(headers, arr_row)
-            end.compact
-          else
-            raise "Expected data that can be transformed into Array<Array>"
-          end
         when ::CSV::Table
           to_rows_array(data.to_a)
         when Hash
           # hash of columns header as key and column array as value
           rows_arrays = [a.keys].concat(a.values.first.zip(*a.values[1..-1]))
           to_rows_array(data.keys)
+        when Enumerable
+          data = data.dup.compact
+          return data unless data.count > 0
+          sample = data.first
+
+          case sample
+          when ::CSV::Row
+            data
+          when Array
+            headers  = data.shift
+            data.map do |arr_row|
+              ::CSV::Row.new(headers, arr_row)
+            end.compact
+          when Hash
+            headers     = sample.keys
+            headers_str = headers.map(&:to_s)
+            data.map do |hash|
+              ::CSV::Row.new(headers_str, hash.values_at(*headers))
+            end.compact
+          else
+            raise "Expected data that can be transformed into Array<::CSV::Row>. Given 'Enumerable' of '#{sample.class}'"
+          end
         else
           raise "Input type not supported. Given: #{data.class}"
         end