eco-helpers 3.0.21 → 3.0.22

data/lib/eco/api/usecases/use_case_io.rb

@@ -7,7 +7,8 @@ module Eco
       #  - provides a helper to `chain` InputOutput between usecases
       # @attr_reader usecase [Eco::API::UseCases::UseCase] the usecase this InputOuput is linked to
       class UseCaseIO < BaseIO
-        @types  = BaseIO.types
+        require_relative 'use_case_io/chain'
+        include Chain
 
         attr_reader :usecase
 
@@ -31,17 +32,28 @@ module Eco
 
         # @param value [Eco::API::UseCases::UseCase] the usecase this InputOuput should be linked to
         def usecase=(value)
-          raise "It should be a Eco::API::UseCases::UseCase. Given: #{value}" if !value.is_a?(Eco::API::UseCases::UseCase)
+          msg = "It should be a Eco::API::UseCases::UseCase. Given: #{value}"
+          raise ArgumentError, msg unless value.is_a?(Eco::API::UseCases::UseCase)
+
           @usecase = value
         end
 
         # @return [Symbol] the `type` of the UseCase this InputOuput is linked to
         def type
-          @usecase.type
+          usecase.type
+        end
+
+        # @return [Symbol] the `model` of the UseCase this InputOuput is linked to
+        def model
+          usecase.model
+        end
+
+        def type=(_value)
+          raise "Can't modify type: depends on the usecase linked to this IO object"
         end
 
-        def type=(value)
-          raise "Can't modify type depends on the usecase linked to this IO object"
+        def model=(_value)
+          raise "Can't modify model: depends on the usecase linked to this IO object"
         end
 
         # @see Eco::API::UseCases::BaseIO#params
@@ -57,23 +69,6 @@ module Eco
             end
           end
         end
-
-        def chain(usecase:)
-          raise "It should be a UseCase. Given: #{usecase}" if !usecase.is_a?(UseCase)
-          #aux_io = self.class.new(input: input, people: people, session: session, options: options, usecase: usecase)
-          #kargs  = aux_io.params(keyed: true)
-          kargs  = params(keyed: true, all: true).merge(usecase: usecase)
-          kargs.delete(:job)
-          case self.type
-          when :import
-            kargs[:input]  = output
-          when :filter
-            kargs[:people] = output
-          when :transform, :sync, :export, :error_handler, :other
-            # no redirections => should it redirect the input?
-          end
-          self.class.new(**kargs)
-        end
       end
     end
   end

data/lib/eco/api/usecases.rb

@@ -42,6 +42,7 @@ module Eco
 
       def each(&block)
         return to_enum(:each) unless block
+
         items.each(&block)
       end
 
@@ -59,8 +60,14 @@ module Eco
       end
 
       # @return [Eco::API::UseCases::UseCase] the `name` usecase of type `type` with the defined `block`.
-      def define(name, type:, &block)
-        Eco::API::UseCases::UseCase.new(name, type: type, root: self, &block).tap do |usecase|
+      def define(name, type:, model: nil, &block)
+        Eco::API::UseCases::UseCase.new(
+          name,
+          type:  type,
+          model: model,
+          root:  self,
+          &block
+        ).tap do |usecase|
           add(usecase)
         end
       end
@@ -69,11 +76,12 @@ module Eco
       # @param usecase [Eco::API::UseCases::UseCase] the usecase to be added.
       def add(usecase)
         msg = "Expected Eco::API::UseCases::UseCase object. Given: #{usecase.class}"
-        raise ArgumentError, msg if !usecase || !usecase.is_a?(Eco::API::UseCases::UseCase)
+        raise ArgumentError, msg unless usecase.is_a?(Eco::API::UseCases::UseCase)
 
         name = usecase.name
         type = usecase.type
         puts "Warning: overriding '#{type}' case #{name}" if self.defined?(name, type: type)
+
         to_h[key(name, type)] = usecase
         @cache_init = false
         usecase
@@ -107,7 +115,7 @@ module Eco
       end
 
       def types(name)
-        return nil unless name?(name)
+        return unless name?(name)
 
         by_name[name].map(&:type)
       end

data/lib/eco/assets.rb

@@ -32,7 +32,7 @@ module Eco
       @configs ||= {}
     end
 
-    def cli(&block)
+    def cli
       unless @cli_init
         @cli_init = true
         require_relative('cli_default')

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

@@ -3,23 +3,24 @@ module Eco
     class Config
       class Filters
         class PeopleFilters < Eco::CLI::Config::Filters
-
           def help(refine: nil)
             refinement = refine.is_a?(String)? " (containing: '#{refine}')" : ""
             super("The following are the available filters on people#{refinement}:", refine: refine)
           end
 
           def process(io:)
-            unless io && io.is_a?(Eco::API::UseCases::BaseIO)
+            unless 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
+              next unless SCR.get_arg(arg)
+
+              io = io.new(data: callback.call(*io.params))
             end
+
             io.people
           end
         end

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

@@ -17,8 +17,12 @@ module Eco
 
         def define(option: nil, &block)
           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
+
+          msg = "Missing option to identify the input (no default defined)"
+          raise ArgumentError, msg unless option
+
+          msg = "Missing block to define the input obtention process"
+          raise ArgumentError, msg unless block_given?
 
           @callbacks[option] = block
         end

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

@@ -57,7 +57,7 @@ module Eco
         # @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, &callback)
-          Eco::API::UseCases::UseCase.validate_type(type)
+          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
@@ -154,7 +154,9 @@ module Eco
         def validate_io!(io)
           return if io.is_a?(Eco::API::UseCases::BaseIO)
 
-          raise ArgumentError, "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          msg  = "You need to provide Eco::API::UseCases::BaseIO object. "
+          msg << "Given: #{io.class}"
+          raise ArgumentError, msg
         end
       end
     end

data/lib/eco/cli_default/people_filters.rb

@@ -111,6 +111,7 @@ ASSETS.cli.config do |cnf| # rubocop:disable Metrics/BlockLength
         session.log(:info) {
           "Filtered #{filtered.count} people out of #{people.count} total"
         }
+
         people.newFrom filtered
       end
     end

data/lib/eco/cli_default/workflow.rb

@@ -1,182 +1,193 @@
-ASSETS.cli do |cli| # rubocop:disable Metrics/BlockLength
-  ASSETS.config.workflow do |wf| # rubocop:disable Metrics/BlockLength
-    rescued = false
-
-    # default rescue
-    wf.rescue do |err, io|
-      next io if rescued
-
-      rescued = true
-      log(:debug) { err.patch_full_message }
+class Eco::CliDefault::Workflow < Eco::API::Common::Loaders::Workflow
+# @todo The ones below:
+#   1. Identify the target model earlier (required_data?),
+#     provided that we can granulate the workflow.
+#   2. Try to modularize the options check/dig.
+#   3. Review the cli.config.people and see if it can be
+#     renamed to cli.config.data and load it based on the
+#     target model.
+#   4. Decouple into multiple classes that can be loaded
+#     based on the target model. Or either define different
+#     workflows that assembly those classes?
+#   5. Right on the load:data stage, set the io model
+#     based on (1).
+
+  class << self
+    attr_accessor :rescued
+  end
 
-      wf.run(:close, io: io)
-    rescue StandardError => e
-      puts "Some problem in workflow.rescue: #{e}"
-    end
+  # default rescue
+  exception do |err, io|
+    next io if rescued
 
-    wf.on(:options) do |_wf_opt, io|
-      cli.config.usecases.cli_apply(io: io)
-      io.new(options: cli.config.options_set.process(io: io))
-    end
+    self.rescued = true
+    log(:debug) { err.patch_full_message }
 
-    wf.for(:load) do |wf_load|
-      wf_load.for(:input) do |wf_in|
-        wf_in.on(:get) do |_wf_ig, io|
-          cases_with_input = cli.config.usecases.active(io: io).select do |usecase, _data|
-            io.class.input_required?(usecase.type)
-          end
-
-          input_is_required = !cases_with_input.empty? || options.dig(:input, :entries_from)
-          missing_input     = !input || input.empty?
-          next unless missing_input && input_is_required
-
-          if options.dig(:input, :entries_from)
-            io.new(input: cli.config.input.get(io: io))
-          else
-            opt_case = cases_with_input.values.first.option
-            io.new(input: cli.config.input.get(io: io, option: opt_case))
-          end
-        end
+    workflow.run(:close, io: io)
+  rescue StandardError => e
+    puts "Some problem in workflow.rescue: #{e}"
+  end
 
-        wf_in.on(:filter) do |_wf_if, io|
-          next unless input && !input.empty?
+  on(:options) do
+    cli_usecases.cli_apply(io: io)
+    io.new(options: cli.config.options_set.process(io: io))
+  end
 
-          io.new(input: cli.config.input_filters.process(io: io))
+  with(:load) do |wf_load|
+    wf_load.with(:input) do |wf_in|
+      wf_in.on(:get) do
+        input_is_required = some_input_case?(io) || options.dig(:input, :entries_from)
+        missing_input     = !input || input.empty?
+        next unless missing_input && input_is_required
+
+        if options.dig(:input, :entries_from)
+          io.new(input: cli.config.input.get(io: io))
+        else
+          opt_case = cli_input_cases(io).values.first.option
+          io.new(input: cli.config.input.get(io: io, option: opt_case))
         end
       end
 
-      wf_load.for(:people) do |wf_peo|
-        wf_peo.on(:get) do |_wf_pg, io|
-          cases_with_people = cli.config.usecases.active(io: io).select do |usecase, _data|
-            io.class.people_required?(usecase.type)
-          end
+      wf_in.on(:filter) do
+        next unless input && !input.empty?
 
-          next if cases_with_people.empty? && !options.dig(:people, :get)
+        io.new(input: cli.config.input_filters.process(io: io))
+      end
+    end
 
-          io.new(people: cli.config.people(io: io))
-        end
+    wf_load.before(:data) do
+      # @todo model should be set to the target model
+      #   based on the main use case that requires data!
+      io.new(model: :people)
+    end
 
-        wf_peo.on(:filter) do |_wf_pf, io|
-          next unless people && !people.empty?
+    wf_load.with(:data) do |wf_peo|
+      wf_peo.on(:get) do
+        next unless some_data_case?(io) || options.dig(:people, :get)
 
-          io.new(people: cli.config.people_filters.process(io: io))
-        end
+        io.new(data: cli.config.people(io: io))
       end
-    end
 
-    wf.before(:usecases) do |_wf_ca, io|
-      # save partial entries -> should be native to session.workflow
-      get_people     = options.dig(:people, :get)
-      partial_update = get_people && get_people[:type] == :partial
+      wf_peo.on(:filter) do
+        next unless data && !data.empty?
 
-      if !options[:dry_run] && partial_update
-        partial_file = session.config.people.partial_cache
-        session.file_manager.save_json(io.people, partial_file, :timestamp)
+        io.new(data: cli.config.people_filters.process(io: io))
       end
     end
+  end
 
-    wf.on(:usecases) do |_wf_ca, io|
-      next if cli.config.usecases.process(io: io)
+  before(:usecases) do
+    # save partial entries -> should be native to session.workflow
+    get_people     = options.dig(:people, :get)
+    partial_update = get_people && get_people[:type] == :partial
 
-      log(:info) { "No update operation specified... quitting" }
-      exit 0
+    if !options[:dry_run] && partial_update
+      partial_file = session.config.people.partial_cache
+      session.file_manager.save_json(io.data, partial_file, :timestamp)
     end
+  end
 
-    wf.before(:launch_jobs) do |_wf_jobs, _io|
-      available_args = cli.config.available_option_args
-      SCR.stop_on_unknown!(all_available: available_args)
-    end
+  on(:usecases) do
+    next if cli_usecases.process(io: io)
 
-    wf.on(:launch_jobs) do
-      session.jobs_launch(simulate: options[:dry_run])
-    end
+    log(:info) { "No update operation specified... quitting" }
+    exit 0
+  end
 
-    wf.before(:post_launch) do |wf_post, io|
-      next wf_post.skip! if session.post_launch.empty?
+  before(:launch_jobs) do
+    available_args = cli.config.available_option_args
+    SCR.stop_on_unknown!(all_available: available_args)
+  end
 
-      run_it = !options[:dry_run] || options.dig(:post_launch, :run)
-      unless run_it
-        wf_post.skip!
+  on(:launch_jobs) do
+    session.jobs_launch(simulate: options[:dry_run])
+  end
 
-        log(:info) {
-          msg  = "Although there are post_launch cases, they will NOT be RUN"
-          msg << ", because we are in dry-run (simulate)." if options[:dry_run]
-          msg
-        }
+  before(:post_launch) do |wf_post|
+    next wf_post.skip! if session.post_launch.empty?
 
-        next
-      end
+    run_it = !options[:dry_run] || options.dig(:post_launch, :run)
+    unless run_it
+      wf_post.skip!
 
-      get_people     = options.dig(:people, :get)
-      partial_update = get_people && get_people[:type] == :partial
-      refresh_data   = !options[:dry_run] && partial_update
+      log(:info) {
+        msg  = "Although there are post_launch cases, they will NOT be RUN"
+        msg << ", because we are in dry-run (simulate)." if options[:dry_run]
+        msg
+      }
 
-      unless refresh_data
-        log(:info) {
-          msg = "Although there are post_launch cases, data will not be refreshed before their run"
-          if io.options[:dry_run]
-            msg << ", because we are in dry-run (simulate)."
-          elsif !partial_update
-            msg << ", because it is not a partial update (-get-partial option not present)."
-          end
-          msg
-        }
+      next
+    end
 
-        next
-      end
+    get_people     = options.dig(:people, :get)
+    partial_update = get_people && get_people[:type] == :partial
+    refresh_data   = !options[:dry_run] && partial_update
+
+    unless refresh_data
+      log(:info) {
+        msg = "Although there are post_launch cases, data will not be refreshed before their run"
+        if io.options[:dry_run]
+          msg << ", because we are in dry-run (simulate)."
+        elsif !partial_update
+          msg << ", because it is not a partial update (-get-partial option not present)."
+        end
+        msg
+      }
 
-      # get target people afresh
-      peo_aux = session.micro.people_refresh(people: people, include_created: true)
-      io.base.new(people: peo_aux)
+      next
     end
 
-    wf.for(:post_launch) do |wf_post|
-      wf_post.on(:usecases) do |_wf_pu, io|
-        session.post_launch.each do |use|
-          use.launch(io: io).base
-        rescue Eco::API::UseCases::BaseIO::MissingParameter => e
-          raise unless e.required == :people
+    # get target people afresh
+    peo_aux = session.micro.people_refresh(
+      people:          data,
+      include_created: true
+    )
+    io.base.new(data: peo_aux)
+  end
 
-          log(:debug) {
-            "Skipping use case '#{use.name}' -- no base people detected for the current run"
-          }
-        end
-      end
+  with(:post_launch) do |wf_post|
+    wf_post.on(:usecases) do |_wf_pu, io|
+      session.post_launch.each do |use|
+        use.launch(io: io).base
+      rescue Eco::API::UseCases::BaseIO::MissingParameter => err
+        raise unless err.required == :people
 
-      wf_post.on(:launch_jobs) do |_wf_pl, _io|
-        session.jobs_launch(simulate: options[:dry_run])
+        log(:debug) {
+          "Skipping use case '#{use.name}' -- no base people detected for the current run"
+        }
       end
     end
 
-    wf.on(:report) do |_wf_rep, io|
-      if (file = options.dig(:report, :people, :csv))
-        options.deep_merge!(export: {
-          options: {internal_names: true, nice_header: true, split_schemas: true},
-          file:    {name: file, format: :csv}
-        })
-        aux_io = io.new(people: people.updated_or_created)
-        session.process_case("to-csv", io: aux_io, type: :export)
-      end
+    wf_post.on(:launch_jobs) do |_wf_pl, _io|
+      session.jobs_launch(simulate: options[:dry_run])
     end
+  end
 
-    wf.on(:end) do |_wf_end, io|
-      get_people     = options.dig(:people, :get)
-      partial_update = get_people && get_people[:type] == :partial
+  on(:report) do |_wf_rep, io|
+    if (file = options.dig(:report, :people, :csv))
+      options.deep_merge!(export: {
+        options: {internal_names: true, nice_header: true, split_schemas: true},
+        file:    {name: file, format: :csv}
+      })
 
-      unless !options[:end_get] || options[:dry_run] || partial_update
-        people_update_cases = cli.config.usecases.active(io: io).any? do |usecase, _data|
-          %i[transform sync].any? { |type| usecase.type == type }
-        end
+      aux_io = io.new(data: data.updated_or_created)
+      session.process_case('to-csv', io: aux_io, type: :export)
+    end
+  end
 
-        if !people_update_cases
-          # Prevent getting people when there were no use cases that used them
-          log(:info) {
-            "Won't be recaching people, as there haven't been any targetted updates"
-          }
-        elsif !people
-          people = session.micro.people_cache
-          io.new(people: people)
-        end
+  on(:end) do
+    get_people     = options.dig(:people, :get)
+    partial_update = get_people && get_people[:type] == :partial
+
+    unless !options[:end_get] || options[:dry_run] || partial_update
+      if !some_update_case?(io)
+        # Prevent getting people when there were no use cases that used them
+        log(:info) {
+          "Won't be recaching people, as there haven't been any targetted updates"
+        }
+      elsif !people
+        people = session.micro.people_cache
+        io.new(data: people)
       end
     end
   end

data/lib/eco/data/mapper.rb

@@ -1,24 +1,43 @@
 module Eco
   module Data
     class Mapper
-
       # it expects [[v1a, v1b], [v2a, v2b] ...]
-      def initialize (array_of_arrays = [], internal: :last)
+      def initialize (array_of_arrays = [], internal: :last, insensitive: false)
         @internal_order = internal
         @source         = array_of_arrays
+        @insensitive    = insensitive
+
+        return unless @source
+
+        # internal should be always last in @source
+        @source = @source.map(&:reverse) unless internal == :last
+
+        # first declarations take priority
+        @by_external = @source.reverse.to_h.tap do |h_data|
+          next unless insensitive?
+
+          h_data.dup.each do |key, value|
+            next if h_data.key?(key.downcase)
 
-        if @source
-          # internal should be always last in @source
-          @source = @source.map { |a| a.reverse } unless internal == :last
+            h_data[key.downcase] = value
+          end
+        end
+
+        @by_internal = @source.reverse.map(&:reverse).to_h.tap do |h_data|
+          next unless insensitive?
+
+          h_data.dup.each do |key, value|
+            next if h_data.key?(key.downcase)
 
-          # first declarations take priority
-          @by_external = @source.reverse.to_h
-          @by_internal = @source.reverse.map do |pair|
-            pair.reverse
-          end.to_h
+            h_data[key.downcase] = value
+          end
         end
       end
 
+      def insensitive?
+        @insensitive
+      end
+
       def as_json(internal: @internal_order)
         to_a(internal: internal)
       end
@@ -27,13 +46,15 @@ module Eco
         content = as_json(internal: internal).map do |pair|
           "  " + pair.to_json
         end.join(",\n")
+
         "[\n#{content}\n]"
       end
 
       def to_a(internal: @internal_order)
-        @by_internal.map do |int, ext|
-          internal == :last ? [ext, int] : [int, ext]
-        end
+        src_dup = @source.map {|pair| pair[0..]}
+        return src_dup if internal == :last
+
+        src_dup.map(&:reverse)
       end
 
       def +(array_of_arrays)
@@ -41,40 +62,51 @@ module Eco
       end
 
       def list(type = :internal)
-        return [] if !@source
+        return [] unless @source
+
         @source.map do |pair|
           type == :internal ? pair.last : pair.first
         end.uniq
       end
 
       def internal?(value)
-        return true if !@source
+        return true         unless @source
+
+        value = value.downcase if insensitive?
         @by_internal.key?(value)
       end
 
       def external?(value)
-        return true if !@source
+        return true unless @source
+
+        value = value.downcase if insensitive?
         @by_external.key?(value)
       end
 
       def include?(value)
-        return true if !@source
+        return true unless @source
+
         internal?(value) || external?(value)
       end
 
       # Whether `value` maps to itself
       def self_mapped?(value)
         return false unless include?(value)
+
         value == to_internal(value)
       end
 
       def to_internal(value)
-        return value if !@source
+        return value unless @source
+
+        value = value.downcase if insensitive?
         @by_external[value]
       end
 
       def to_external(value)
-        return value if !@source
+        return value unless @source
+
+        value = value.downcase if insensitive?
         @by_internal[value]
       end
     end