eco-helpers 3.0.21 → 3.0.23

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

data/lib/eco/language/methods/dsl_able.rb

@@ -1,13 +1,22 @@
 module Eco
   module Language
     module Methods
+      # Adds #evaluate, which will run `&block` where `DslAble` has been included.
+      # @note
+      #   1. If a method is missing on the evaluation object, it will re-try it on
+      #     on the block context.
+      #   2. **Override behaviour**: the above gives precedence to
+      #     methods defined in the context of the object that evaluates,
+      #     over those in the block context.
       module DslAble
         # It runs the `block` within this object context
         # @note if the object misses any method, redirects the method to the
         #   original evaluate caller.
         def evaluate(*args, **kargs, &block)
           return unless block_given?
+
           @self_before_evaluate = eval('self', block.binding, __FILE__, __LINE__)
+
           instance_exec(*args, **kargs, &block).tap do
             @self_before_evaluate = nil
           end
@@ -17,6 +26,7 @@ module Eco
         # @see https://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
         def method_missing(method, *args, **kargs, &block)
           super unless @self_before_evaluate
+
           @self_before_evaluate.send(method, *args, **kargs, &block)
         end
 

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = '3.0.21'.freeze
+  VERSION = '3.0.23'.freeze
 end