eco-helpers 1.4.2 → 1.5.4

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

@@ -0,0 +1,50 @@
+module Eco
+  class CLI
+    class Config
+      class Filters
+        include Eco::CLI::Config::Help
+        attr_reader :core_config
+
+        def initialize(core_config:)
+          @core_config = core_config
+          @filters     = {}
+          @description = {}
+        end
+
+        # @return [String] summary of the filters.
+        def help(msg = "The following are the available filters:")
+          [msg].yield_self do |lines|
+            max_len = keys_max_len(@filters.keys)
+            @filters.keys.sort.each do |key|
+              lines << help_line(key, @description[key], max_len)
+            end
+            lines
+          end.join("\n")
+        end
+
+        # @param option [String] the command line option that activates this filter.
+        # @param desc [String] description of the filter.
+        def add(option, desc = nil)
+          raise "Missing block to define the filters builder" unless block_given?
+          callback = Proc.new
+          [option].flatten.compact.each do |opt|
+            @filters[opt]     = callback
+            @description[opt] = desc
+          end
+          self
+        end
+
+        def process(io:)
+          raise "You need to override this method in child classes"
+        end
+
+        private
+
+
+      end
+    end
+  end
+end
+
+require_relative 'filters/people_filters'
+require_relative 'filters/input_filters'

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

@@ -0,0 +1,29 @@
+module Eco
+  class CLI
+    class Config
+      class Filters
+        class InputFilters < Eco::CLI::Config::Filters
+
+          def help
+            super("The following are the available filters on the input entries:")
+          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
+
+            io = io.new(type: :import)
+            @filters.each do |arg, callback|
+              if SCR.get_arg(arg)
+                io = io.new(input: callback.call(*io.params))
+              end
+            end
+            io.input
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Eco
+  class CLI
+    class Config
+      class Filters
+        class PeopleFilters < Eco::CLI::Config::Filters
+
+          def help
+            super("The following are the available filters on people:")
+          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
+
+            io = io.new(type: :transform)
+            @filters.each do |arg, callback|
+              if SCR.get_arg(arg)
+                io = io.new(people: callback.call(*io.params))
+              end
+            end
+            io.people
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Eco
+  class CLI
+    class Config
+      module Help
+
+        def help
+          raise "this needs to be reimplemented in the child class and return a string"
+        end
+
+        private
+
+        def keys_max_len(keys)
+          keys.max {|a, b| a.length <=> b.length}.length
+        end
+
+        # 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
+          top_line  = "  #{key}#{" "*blanks} "
+          indent    = top_line.length
+          first     = true
+          each_slice_words(desc, line_len - indent).each_with_object([]) do |line, lines|
+            lines << (first ? "#{top_line}#{line}" : "#{" " * indent}#{line}")
+            first = false
+          end.join("\n")
+        end
+
+        def each_slice_words(str, max_len = 100)
+          liner = ""
+          str.to_s.scan(/[^\s]+|\s+/).each_with_object([]) do |part, out|
+            if "#{liner}#{part}".length <= max_len
+              liner << part
+            else
+              yield(liner) if block_given?
+              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
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -2,18 +2,34 @@ module Eco
   class CLI
     class Config
       class OptionsSet
+        include Eco::CLI::Config::Help
         attr_reader :core_config
 
         def initialize(core_config:)
           @core_config = core_config
           @options_set = {}
+          @description = {}
         end
 
-        def add(option)
+        # @return [String] summary of the options.
+        def help
+          ["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)
+            end
+            lines
+          end.join("\n")
+        end
+
+        # @param option [String] the command line option.
+        # @param desc [String] description of the option.
+        def add(option, desc = nil)
           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
           end
           self
         end

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

@@ -2,100 +2,126 @@ module Eco
   class CLI
     class Config
       class UseCases
-
+        include Eco::CLI::Config::Help
         attr_reader :core_config
 
         def initialize(core_config:)
           @core_config  = core_config
-          @linked_opt_cases = {}
+          @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)
+            end
+            lines
+          end.join("\n")
         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
-        # @param case_name [String, nil] the name of the usecase as defined
-        def add(option_case, type, case_name: nil)
+        # 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.
+        # @param desc [String] description of the case.
+        # @param case_name [String, nil] the name of the usecase as defined.
+        def add(option_case, type, desc = nil, case_name: nil)
           Eco::API::UseCases::UseCase.validate_type(type)
           unless callback = block_given?? Proc.new : nil
             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_opt_cases[option_case] = {
+          @linked_cases[option_case] = {
             type => {
+              option:   option_case,
+              type:     type,
               casename: case_name,
               callback: callback
             }
           }
+          @description[option_case]  = desc
 
           self
         end
 
         # Scopes/identifies which usecases are being invoked from the command line
+        # @note
+        #   - this method will sort the active usecases by the position they hold in the command line
         # @param io [Eco::API::UseCases::BaseIO] the input/output object
         # @return [Hash] where keys are cases and values a `Hash` with `option` String and `callback`
         def active(io:)
+          validate_io!(io)
           return @active_cases unless !@active_cases
-          @active_cases = {}.tap do |opt_cases|
-            @linked_opt_cases.each do |option_case, types|
-              types.each do |type, data|
-                if SCR.get_arg(option_case)
-                  usecase = nil
-                  if case_name = data[:casename]
-                    usecase = io.session.usecases.case(case_name, type: type)
-                  end
-
-                  if callback = data[:callback]
-                    unless usecase
-                      # identify usecase
-                      params = io.params(keyed: true).merge(type: type)
-                      io     = io.new(**params, validate: false)
-
-                      usecase = callback.call(*io.params)
-                      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 '#{option_case}'"
-                        msg += " must return an Eco::API::UseCases::UseCase object. It returns #{usecase.class}"
-                        raise msg
-                      end
-                    end
-                  end
-
-                  if usecase
-                    opt_cases[usecase] = {
-                        option:   option_case,
-                        callback: data[:callback]
-                    }
-                  end
-
-                end
+          active_cases = {}
+          @linked_cases.each do |option_case, types|
+            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
             end
-
           end
+          @active_cases = active_cases.sort_by {|c, d| d[:index]}.to_h
         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
-
+          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
+            data[:callback]&.call(*io.params)
+            io = usecase.launch(io: io)
+          end
+          processed
+        end
 
-            params = io.params(keyed: true).merge(type: usecase.type)
-            io     = io.new(**params)
+        private
+
+        # Gets a `UseCaseIO`
+        def case_io(io:, usecase:)
+          validate_io!(io)
+          case io
+          when Eco::API::UseCases::UseCaseIO
+            io.chain(usecase: usecase)
+          when Eco::API::UseCases::BaseIO
+            params = io.params(keyed: true).merge(usecase: usecase)
+            Eco::API::UseCases::UseCaseIO.new(**params)
+          end
+        end
 
-            if callback = data[:callback]
-              callback.call(*io.params)
+        def get_usecase(io:, data:)
+          usecase    = if case_name = data[:casename]
+            io.session.usecases.case(case_name, type: data[:type])
+          end
+          usecase  ||= if callback  = data[:callback]
+            # identify/retrieve usecase via callback
+            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 += " must return an Eco::API::UseCases::UseCase object. It returns #{usecase.class}"
+                raise msg
+              end
             end
+          end
+        end
 
-            usecase.launch(io: io)
+        def validate_io!(io)
+          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
+            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
           end
-          processed
         end
 
       end

data/lib/eco/cli/scripting.rb

@@ -7,8 +7,16 @@ module Eco
     class Scripting
       include Scripting::ArgsHelpers
 
+      def initialize(argv = ARGV)
+        @argv = argv
+      end
+
+      def argv
+        @argv.dup
+      end
+
       def args_contain?(*values)
-        match?(ARGV, patterns, [:any, :or, :insensitive, :pattern])
+        match?(argv, patterns, [:any, :or, :insensitive, :pattern])
       end
 
       def modifiers(*values)
@@ -20,4 +28,4 @@ module Eco
 end
 
 
-SCR = Eco::CLI::Scripting.new
+SCR = Eco::CLI::Scripting.new(ARGV)

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

@@ -3,12 +3,16 @@ module Eco
     class Scripting
       module ArgsHelpers
 
+        def argv
+          @argv || ARGV
+        end
+
         def is_modifier?(value)
           Argument.is_modifier?(value)
         end
 
         def arguments
-          @arguments ||= Arguments.new
+          @arguments ||= Arguments.new(argv)
         end
 
         def stop_on_unknown!(exclude: [], only_options: false)
@@ -23,38 +27,44 @@ module Eco
           end
         end
 
+        def get_arg_index(key)
+          return nil if !argv.include?(key)
+          argv.index(key)
+        end
+
         def get_arg(key, with_param: false, valid: true)
           # track what a known option looks like
           arguments.add(key, with_param: with_param)
-          return nil if !ARGV.include?(key)
+          return nil unless index = get_arg_index(key)
           value = true
           if with_param
-            next_i = ARGV.index(key) + 1
-            value = ARGV[next_i]
+            value  = argv[index + 1]
             #puts "modifier argument: #{value}"
-            value = nil if valid && is_modifier?(value)
+            value  = nil if valid && is_modifier?(value)
           end
           return value
         end
 
         def get_file(key, required: false, should_exist: true)
           filename = get_arg(key, with_param: true)
-          if !filename
-              if required
-                puts "you need to specify a file '#{key} file'"
-                exit(1)
-              end
-          elsif  !(File.exists?(filename) || File.exists?(File.expand_path(filename)))
-            if should_exist && required
-              puts "file doesn't exist #{filename}"
-              exit
-            end
+          if !filename && required
+            puts "You need to specify a file '#{key} file'"
+            exit(1)
+          elsif !file_exists?(filename) && should_exist && required
+            puts "This file doesn't exist '#{filename}'"
+            exit(1)
           end
 
           filename = File.expand_path(filename) if filename && should_exist
           filename
         end
 
+        private
+
+        def file_exists?(filename)
+          File.exists?(filename) || File.exists?(File.expand_path(filename))
+        end
+
       end
     end
   end