eco-helpers 1.5.1 → 1.5.6

data/lib/eco/cli/config/default/workflow.rb

@@ -4,7 +4,7 @@ ASSETS.cli.config do |config|
     io = nil
     # default rescue
     wf.rescue do |exception, io|
-      io.session.logger.error(exception.patch_full_message)
+      io.session.logger.debug(exception.patch_full_message)
       wf.run(:close, io: io)
       io
     end
@@ -14,38 +14,42 @@ ASSETS.cli.config do |config|
     end
 
     wf.for(:load) do |wf_load|
-      active_cases = nil
-
-      wf_load.on(:input) do |wf_input, io|
-        active_cases     = config.usecases.active(io: io)
+      wf_load.for(:input) do |wf_input|
+        wf_input.on(:get) do |wf_input_get, io|
+          cases_with_input =  config.usecases.active(io: io).select do |usecase, data|
+            io.class.input_required?(usecase.type)
+          end
+          next io unless (!io.input || io.input.empty?) && !cases_with_input.empty?
 
-        cases_with_input = active_cases.select do |usecase, data|
-          io.class.input_required?(usecase.type)
+          if io.options.dig(:input, :entries_from)
+            io = io.new(input: config.input.get(io: io))
+          else
+            opt_case = cases_with_input.values.first[:option]
+            io = io.new(input: config.input.get(io: io, option: opt_case))
+          end
+          io
         end
 
-        next io unless (!io.input || io.input.empty?) && !cases_with_input.empty?
-
-        if io.options.dig(:input, :entries_from)
-          io = io.new(input: config.input.get(io: io))
-        else
-          opt_case = cases_with_input.values.first[:option]
-          io = io.new(input: config.input.get(io: io, option: opt_case))
+        wf_input.on(:filter) do |wf_input_filter, io|
+          next io unless io.input && !io.input.empty?
+          io = io.new(input:  config.input_filters.process(io: io))
         end
-        io
       end
 
-      wf_load.on(:people) do |wf_people, io|
-        cases_with_people = active_cases.select do |usecase, data|
-          io.class.people_required?(usecase.type)
+      wf_load.for(:people) do |wf_people|
+        wf_people.on(:get) do |wf_people_get, io|
+          cases_with_people = config.usecases.active(io: io).select do |usecase, data|
+            io.class.people_required?(usecase.type)
+          end
+          get_people = io.options.dig(:people, :get, :from) == :remote
+          next io unless !cases_with_people.empty? || get_people
+          io = io.new(people:  config.people(io: io))
         end
-        get_people = io.options.dig(:people, :get, :from) == :remote
-        next io unless !cases_with_people.empty? || get_people
-        io = io.new(people:  config.people(io: io))
-      end
 
-      wf_load.on(:filter) do |wf_filter, io|
-        next io unless io.people && !io.people.empty?
-        io = io.new(people:  config.people_filters.process(io: io))
+        wf_people.on(:filter) do |wf_people_filter, io|
+          next io unless io.people && !io.people.empty?
+          io = io.new(people:  config.people_filters.process(io: io))
+        end
       end
     end
 
@@ -85,7 +89,7 @@ ASSETS.cli.config do |config|
         partial_update = io.options.dig(:people, :get, :type) == :partial
         if !io.options[:dry_run] && partial_update
           # get target people afresh
-          people = io.session.do.people_refresh(people: io.people, include_created: true)
+          people = io.session.micro.people_refresh(people: io.people, include_created: true)
           io     = io.new(people: people)
         else
           wf_post.skip!
@@ -116,10 +120,16 @@ ASSETS.cli.config do |config|
       end
     end
 
+    wf.on(:report) do |wf_report, io|
+      #config.reports.active(io: io)
+      #io.session.reports
+      io
+    end
+
     wf.on(:end) do |wf_end, io|
       partial_update = io.options.dig(:people, :get, :type) == :partial
       unless !io.options[:end_get] || io.options[:dry_run] || partial_update
-        people = io.session.do.file_people
+        people = io.session.micro.people_cache
         io     = io.new(people: people)
       end
       io

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, all: 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