eco-helpers 2.6.3 → 2.7.0

data/lib/eco/api/session/config/workflow.rb

@@ -7,13 +7,13 @@ module Eco
 
           WORKFLOW_MODEL = [
             :options,
-            {load: [{input: [:get, :filter]}, {people: [:get, :filter]}, :filter]},
+            {load: [{input: %i[get filter]}, {people: %i[get filter]}, :filter]},
             :usecases, :launch_jobs,
-            {post_launch: [:usecases, :launch_jobs]},
+            {post_launch: %i[usecases launch_jobs]},
             :report,
             :end,
             :close
-          ]
+          ].freeze
 
           class << self
             def stages
@@ -40,7 +40,7 @@ module Eco
           self.model = WORKFLOW_MODEL
           attr_reader :config
 
-          def initialize(name = nil, _parent: self, config:)
+          def initialize(name = nil, config:, _parent: self) # rubocop:disable Lint/UnderscorePrefixedVariableName
             @config   = config
             @name     = name
 
@@ -97,7 +97,7 @@ module Eco
           #   2. if block is not provided, it returns the **stage** referred by `key`
           def for(key = nil, &block)
             raise ArgumentError, "With no 'key', a block should be given." unless key || block_given?
-            self.tap do
+            tap do
               next yield(self)            unless key
               next stage(key).for(&block) if block_given?
               return stage(key)
@@ -106,7 +106,8 @@ module Eco
           alias_method :with, :for
 
           # Used in **configuration** time **to define** the **behaviour**  the target (sub)stage `key`
-          # @note if a `block` is provided it will **not** `yield` the target stage immediately, but when the _workflow_ reaches the stage
+          # @note if a `block` is provided it will **not** `yield` the target stage immediately,
+          #   but when the _workflow_ reaches the stage
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
@@ -117,16 +118,18 @@ module Eco
           # @return [Eco::API::Session::Config::Workflow] the current stage object (to ease chainig).
           def on(key = nil, &block)
             raise ArgumentError, "A block should be given." unless block_given?
-            if !key
-              @on = block
-            else
+            if key
               stage(key).on(&block)
+            else
+              @on = block
             end
             self
           end
 
-          # When there is an `Exception`, you might have defined some `callback` to do something with it (i.e. register, email)
-          # @yield [exception, io] the `callback` to do something with an `Exception` raised within this _workflow_ stage
+          # When there is an `Exception`, you might have defined some `callback`
+          # to do something with it (i.e. register, email)
+          # @yield [exception, io] the `callback` to do something with
+          #   an `Exception` raised within this _workflow_ stage
           # @yieldparam exception [Exception] the exception object that was raised
           # @yieldparam io [Eco::API::UseCases::BaseIO] the input/output object carried througout all the _workflow_
           # @yieldreturn [Eco::API::UseCases::BaseIO] the `io` input/output object carried througout all the _workflow_
@@ -146,46 +149,50 @@ module Eco
             self
           end
 
-          # Used in **configuration** time **add previous** `callbacks` **before** the `on` _callback_ of the (sub)stage `key` is actually `run`
+          # Used in **configuration** time **add previous** `callbacks`
+          # **before** the `on` _callback_ of the (sub)stage `key` is actually `run`
           # @note
           #   - it will **not** `yield` it immediately, but when the _workflow_ reaches the target stage
           #   - in this case, you can define multiple `callbacks`
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
-          # @yield [stage_workflow, io] one of the things to do **before** the `on` _callback_ of the (sub)stage `key` is actually `run`
+          # @yield [stage_workflow, io] one of the things to do **before** the
+          #  `on` _callback_ of the (sub)stage `key` is actually `run`
           # @yieldparam stage_workflow [Eco::API::Session::Config::Workflow] the _target stage_  referred by `key`
           # @yieldparam io [Eco::API::UseCases::BaseIO] the input/output object carried througout all the _workflow_
           # @yieldreturn [Eco::API::UseCases::BaseIO] `io` the input/output object carried througout all the _workflow_
           # @return [Eco::API::Session::Config::Workflow] the current stage object (to ease chainig).
           def before(key = nil, &block)
             raise ArgumentError, "A block should be given." unless block_given?
-            if !key
-              @before.push(block)
-            else
+            if key
               stage(key).before(&block)
+            else
+              @before.push(block)
             end
             self
           end
 
-          # Used in **configuration** time **add previous** `callbacks` **after** the `on` _callback_ of the (sub)stage `key` is actually `run`
+          # Used in **configuration** time **add previous** `callbacks` **after** the `on` _callback_
+          # of the (sub)stage `key` is actually `run`
           # @note
           #   - it will **not** `yield` it immediately, but when the _workflow_ reaches the target stage
           #   - in this case, you can define multiple `callbacks`
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
-          # @yield [stage_workflow, io] one of the things to do **after** the `on` _callback_ of the (sub)stage `key` is actually `run`
+          # @yield [stage_workflow, io] one of the things to do **after** the
+          #   `on` _callback_ of the (sub)stage `key` is actually `run`
           # @yieldparam stage_workflow [Eco::API::Session::Config::Workflow] the _target stage_  referred by `key`
           # @yieldparam io [Eco::API::UseCases::BaseIO] the input/output object carried througout all the _workflow_
           # @yieldreturn [Eco::API::UseCases::BaseIO] `io` the input/output object carried througout all the _workflow_
           # @return [Eco::API::Session::Config::Workflow] the current stage object (to ease chainig).
           def after(key = nil, &block)
             raise ArgumentError, "A block should be given." unless block_given?
-            if !key
-              @after.push(block)
-            else
+            if key
               stage(key).after(&block)
+            else
+              @after.push(block)
             end
             self
           end
@@ -202,8 +209,8 @@ module Eco
           #   - it will **not** run the `callback` for `on` defined during the configuration time
           #   - it will rather `yield` the target stage after all the `before` _callbacks_ have been run
           #   - aside of this, the rest will be the same as when the _block_ is provided (see previous note)
-          # @note [if the object returned by `before`, `after` and `run` callbacks is not an `Eco::API::UseCases::BaseIO`,
-          #   the original `io` object will be returned instead.
+          # @note [if the object returned by `before`, `after` and `run` callbacks
+          #   is not an `Eco::API::UseCases::BaseIO`, the original `io` object will be returned instead.
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
@@ -216,71 +223,81 @@ module Eco
           def run(key = nil, io:, &block)
             raise "Missing BaseIO object" unless io.is_a?(Eco::API::UseCases::BaseIO)
 
-            if key
-              io = io_result(io: io) do
-                stage(key).run(io: io, &block)
-              end
-            elsif pending?
-              @before.each do |c|
+            rescuable(io) do
+              if key
                 io = io_result(io: io) do
-                  io.evaluate(self, io, &c)
+                  stage(key).run(io: io, &block)
                 end
+              elsif pending?
+                io = run_before(io)
+                io = run_it(io, &block) unless skip?
+                io = run_after(io)
               end
+              io
+            ensure
+              @pending = false
+            end
+          end
 
-              unless skip?
-                io.session.logger.debug("(Workflow: #{path}) running now")
-                if block
-                  io = io_result(io: io) do
-                    io.evaluate(self, io, &block)
-                  end
-                else
-                  existing_stages.each do |stg|
-                    io = io_result(io: io) do
-                      stg.run(io: io)
-                    end
-                  end
-
-                  unless ready?
-                    msg = "(Workflow: #{path}) 'on' callback is not defined, nor block given"
-                    io.session.logger.debug(msg)
-                  end
-                  io = io_result(io: io) do
-                    io.evaluate(self, io, &@on)
-                  end
-                end
-                @pending = false
+          protected
+
+          def root?
+            @_parent == self
+          end
+
+          def path
+            return name if root?
+            "#{@_parent.path}:#{name}"
+          end
+
+          def ready?
+            !!@on
+          end
+
+          def run_before(io)
+            @before.each do |c|
+              io = io_result(io: io) do
+                io.evaluate(self, io, &c)
               end
+            end
+            io
+          end
+
+          def run_after(io)
+            @after.each do |c|
+              io = io_result(io: io) do
+                io.evaluate(self, io, &c)
+              end
+            end
+            io
+          end
 
-              @after.each do |c|
+          def run_it(io, &block)
+            io.session.logger.debug("(Workflow: #{path}) running now")
+            if block
+              io = io_result(io: io) do
+                io.evaluate(self, io, &block)
+              end
+            else
+              existing_stages.each do |stg|
                 io = io_result(io: io) do
-                  io.evaluate(self, io, &c)
+                  stg.run(io: io)
                 end
               end
+
+              unless ready?
+                msg = "(Workflow: #{path}) 'on' callback is not defined, nor block given"
+                io.session.logger.debug(msg)
+              end
+              io = io_result(io: io) do
+                io.evaluate(self, io, &@on)
+              end
             end
             io
-          rescue SystemExit => e
-            io = io_result(io: io) do
-              io.evaluate(e, io, &self.exit_handle)
-            end
-            exit e.status
-          rescue Interrupt => i
-            raise
-          rescue Exception => e
-            # raise unless self.rescue
-            io = io_result(io: io) do
-              io.evaluate(e, io, &self.rescue)
-            end
-            raise
           ensure
             @pending = false
           end
 
-          protected
-
-          def root?
-            @_parent == self
-          end
-
           # It ensures an `Eco::API::UseCases::BaseIO` is returned
           # @note it always brings the IO to be a `BaseIO`.
           #   As the `output` and the type is captured, it just cleans usecase related
@@ -296,19 +313,6 @@ module Eco
             io.instance_of?(klass) ? io : io.base
           end
 
-          def path
-            return name if root?
-            "#{@_parent.path}:#{name}"
-          end
-
-          def root?
-            @_parent == self
-          end
-
-          def ready?
-            !!@on
-          end
-
           def existing_stages
             # sort defined stages by stage order
             sorted_keys = self.class.stages & @stages.keys
@@ -316,17 +320,38 @@ module Eco
           end
 
           def ready_stages
-            exiting_stages.select {|s| s.ready?}
+            exiting_stages.select(&:ready?)
           end
 
           def stages_ready?
-            existing_stages.all? {|s| s.ready?}
+            existing_stages.all?(&:ready?)
           end
 
           def stage(key)
             self.class.validate_stage(key)
             @stages[key] ||= self.class.workflow_class(key).new(key, _parent: self, config: config)
           end
+
+          # helper to treat trigger the exit and rescue handlers
+          def rescuable(io)
+            yield
+          # rescue SystemStackError => err
+          #   puts err.patch_full_message(trace_count: 100)
+          #   exit 1
+          rescue SystemExit => err
+            io = io_result(io: io) do
+              io.evaluate(err, io, &exit_handle)
+            end
+            exit err.status
+          rescue Interrupt => _int
+            raise
+          rescue StandardError => err
+            # raise unless self.rescue
+            io = io_result(io: io) do
+              io.evaluate(err, io, &self.rescue)
+            end
+            raise
+          end
         end
       end
     end

data/lib/eco/api/session/config.rb

@@ -238,6 +238,12 @@ module Eco
           tagtree_config.structure_id = value
         end
 
+        # The location node classifications of the organization
+        # @return [Eco::API::Organization::NodeClassifications]
+        def node_classifications(active: true)
+          tagtree_config.node_classifications(active: active)
+        end
+
         # It uses the `tagtree.json` file and in its absence, if `graphql` enabled, the largest `life_tagtree`
         # @note it does NOT include archived nodes by default.
         #   - This is for legacy (most usecases don't)

data/lib/eco/api/session.rb

@@ -5,16 +5,24 @@ module Eco
     class Session < Common::Session::BaseSession
       #@param init [Eco::API::Session::Config, Eco::API::Common::Session::Environment] object to ini the session
       def initialize(init = {})
-        e = init
-        msg = "Expected object Eco::API::Session::Config or Eco::API::Common::Session::Environment. Given: #{init}"
-        raise msg  unless e.is_a?(Session::Config) || e.is_a?(Eco::API::Common::Session::Environment)
-        e = Eco::API::Common::Session::Environment.new(init, session: self) if !e.is_a?(Eco::API::Common::Session::Environment)
-        super(e)
+        env = init
+
+        msg  = "Expected object Eco::API::Session::Config or Eco::API::Common::Session::Environment. "
+        msg << " Given: #{init}"
+
+        correct_env = env.is_a?(Session::Config) || env.is_a?(Eco::API::Common::Session::Environment)
+        raise ArgumentError, msg unless correct_env
+
+        unless env.is_a?(Eco::API::Common::Session::Environment)
+          env = Eco::API::Common::Session::Environment.new(init, session: self)
+        end
+
+        super(env)
 
         @entry_factories  = {}
         @person_factories = {}
 
-        logger.debug("LINE COMMAND: #{$0} #{ARGV.join(" ")}")
+        logger.debug("LINE COMMAND: #{$0} #{ARGV.join(" ")}") # rubocop:disable Style/SpecialGlobalVars
       end
 
       # @retrun [String] the name of the current environment
@@ -24,7 +32,7 @@ module Eco
 
       # @return [Eco::API::Session::Batch] provides helper to launch batch operations.
       def batch
-        @batch  ||= Batch.new(enviro)
+        @batch ||= Batch.new(enviro)
       end
 
       # @!group Pure organization helpers
@@ -39,6 +47,12 @@ module Eco
         config.login_providers
       end
 
+      # The location node classifications of the organization
+      # @return [Eco::API::Organization::NodeClassifications]
+      def node_classifications(active: true)
+        config.node_classifications(active: active)
+      end
+
       # @param live [Boolean] states preference of `live` tree if available over file.
       # @param merge [Boolean] when in `live` mode, if mulitple trees, merge into one.
       # @see Eco::API::Session::Config#tagtree
@@ -79,11 +93,12 @@ module Eco
       end
 
       # Sets the current target `PersonSchema` of this session.
-      # @note observe that it is essential for the parsers/serialisers to identify target/present attributes.
-      # @param value [String, Ecoportal::API::V1::PersonSchema] where `String` can be the _name_ or the _id_ of the schema.
+      # @note observe that it is essential for the parsers/serialisers to identify
+      #   target/present attributes.
+      # @param value [String, Ecoportal::API::V1::PersonSchema] where `String`
+      #   can be the _name_ or the _id_ of the schema.
       def schema=(value)
         @schema = to_schema(value)
-        self
       end
 
       # Helper to state the abilities that a person should have with given their usergroups
@@ -95,7 +110,7 @@ module Eco
       def fields_mapper
         return @fields_mapper if instance_variable_defined?(:@fields_mapper)
         mappings = []
-        if map_file = config.people.fields_mapper
+        if (map_file = config.people.fields_mapper)
           mappings = map_file ? file_manager.load_json(map_file) : []
         end
         @fields_mapper = Eco::Data::Mapper.new(mappings)
@@ -140,7 +155,7 @@ module Eco
       # @param phase [Symbol] the phase when this parser should be active.
       # @return [Object] the parsed attribute.
       def parse_attribute(attr, source, phase = :internal, deps: {})
-        unless parsers = entry_factory.person_parser
+        unless (parsers = entry_factory.person_parser)
           raise "There are no parsers defined"
         end
         parsers.parse(attr, source, phase, deps: deps)
@@ -182,10 +197,10 @@ module Eco
       # @return [Eco::API::Common::People::Entries] collection of entries.
       def csv_entries(file, **kargs)
         kargs.merge!({
-          file: file,
+          file:   file,
           format: :csv
         })
-        return entries(**kargs)
+        entries(**kargs)
       end
 
       # Generates the collection of entries that should be discarded from an update.
@@ -193,8 +208,11 @@ module Eco
       # @return [Eco::API::Common::People::Entries] collection of entries.
       def discarded_entries
         return @discarded_entries if instance_variable_defined?(:@discarded_entries)
+
         file = config.people.discarded_file
-        fatal("You have not specified the 'discarded_people_file'") unless file = file_manager.dir.file(file)
+        file = file_manager.dir.file(file)
+        fatal("You have not specified the 'discarded_people_file'") unless file
+
         @discarded_entries = csv_entries(file)
       end
       # @!endgroup
@@ -234,7 +252,7 @@ module Eco
       # @see Eco::API::MicroCases
       # @return [Eco::API::MicroCases]
       def micro
-        @micro    ||= Eco::API::MicroCases.new(enviro)
+        @micro ||= Eco::API::MicroCases.new(enviro)
       end
 
       def post_launch
@@ -255,18 +273,23 @@ module Eco
       # It retrives the group of `Batch::Jobs` named `name`. It creates it if it doesn't exist.
       # @return [Eco::API::Session::Batch::Jobs]
       def job_group(name, order: :last)
-        case
-        when job_groups.exists?(name)
-          job_groups[name]
-        else
-          job_groups.new(name, order: order)
-        end
+        return job_groups[name] if job_groups.exists?(name)
+
+        job_groups.new(name, order: order)
       end
 
       # Shortcut to create a job of certain type within a group
       # @param [see @Eco::API::Session::Batch::Jobs#new]
       # @return [Eco::API::Session::Batch::Job]
-      def new_job(group, name, type, usecase, sets = [:core, :details, :account], accept_update_with_no_id = false, &block)
+      def new_job(
+        group,
+        name,
+        type,
+        usecase,
+        sets = %i[core details account],
+        accept_update_with_no_id = false, # rubocop:disable Style/OptionalBooleanParameter
+        &block
+      )
         job_group(group).new(name, usecase: usecase, type: type, sets: sets, accept_update_with_no_id: accept_update_with_no_id, &block)
       end
 
@@ -330,10 +353,10 @@ module Eco
       private
 
       # Comparer to state if 2 schemas are different
-      def same_schema? (schema1, schema2)
-        eq   = schema1&.id == schema2&.id
-        eq ||= schema1&.name&.downcase == schema2&.name&.downcase
-        schema1 && schema2 && eq
+      def same_schema?(schema_1, schema_2)
+        eq   = schema_1&.id == schema_2&.id
+        eq ||= schema_1&.name&.downcase == schema_2&.name&.downcase
+        schema_1 && schema_2 && eq
       end
 
       # from schema `id` or `name` to a PersonSchema object
@@ -342,7 +365,7 @@ module Eco
         sch = nil
         case value
         when String
-          unless sch = schemas.schema(value)
+          unless (sch = schemas.schema(value))
             fatal "The schema with id or name '#{value}' does not exist."
           end
         when Ecoportal::API::V1::PersonSchema
@@ -352,7 +375,6 @@ module Eco
         end
         sch
       end
-
     end
   end
 end

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

@@ -11,7 +11,7 @@ module Eco
         class MissingParameter < StandardError
           attr_reader :type, :required, :given
 
-          def initialize(msg = nil, type: nil, required:, given:)
+          def initialize(msg = nil, required:, given:, type: nil)
             @type     = type
             @required = required
             @given    = given
@@ -23,11 +23,11 @@ module Eco
 
         class << self
           def input_required?(type)
-            !valid_type?(type) || [:import, :sync].include?(type)
+            !valid_type?(type) || %i[import sync].include?(type)
           end
 
           def people_required?(type)
-            !valid_type?(type) || [:filter, :transform, :sync, :error_handler, :export].include?(type)
+            !valid_type?(type) || %i[filter transform sync error_handler export].include?(type)
           end
         end
 
@@ -40,10 +40,14 @@ module Eco
         # @param people [Eco::API::Organization::People] people object.
         # @param session [Eco::API:Session]
         # @param options [Hash] hash with symbol keys (i.e. behaviour modifiers, cli trackers, filters, etc.)
-        def initialize(type: nil, input: nil, people: nil, session:, options: {}, output: nil, validate: true)
-          self.type    = type if type
-
-          if self.type && validate
+        def initialize( # rubocop:disable Lint/MissingSuper
+          session:,
+          type:    nil, input:  nil, people: nil,
+          options: {},  output: nil, validate: true
+        )
+          self.type = type if type
+
+          if self.type && validate # rubocop:disable Style/IfUnlessModifier
             validate_args(input: input, people: people, session: session, options: options)
           end
 
@@ -64,8 +68,8 @@ module Eco
         # @return [Eco::API::UseCases::BaseIO]
         def base
           kargs = params(keyed: true).merge({
-            type:   self.type,
-            output: self.output,
+            type:   type,
+            output: output
           }).slice(:type, :input, :people, :session, :options, :output) # :validate <- ?
           Eco::API::UseCases::BaseIO.new(**kargs)
         end
@@ -74,12 +78,12 @@ module Eco
         # @return [Eco::API::UseCases::BaseIO]
         def new(**kargs)
           default = {
-            type:     self.type,
-            input:    self.input,
-            people:   self.people,
-            session:  self.session,
-            options:  self.options,
-            output:   self.output,
+            type:     type,
+            input:    input,
+            people:   people,
+            session:  session,
+            options:  options,
+            output:   output,
             validate: true
           }
           self.class.new(**default.merge(kargs))
@@ -88,7 +92,7 @@ module Eco
         # Helper to build a `Hash` of symbol keys or `Array` with params to do callbacks.
         def params(keyed: false, all: false)
           kargs = {}
-          kargs.merge!(input:    input)  if input_required?  || all
+          kargs.merge!(input:   input)   if input_required?  || all
           kargs.merge!(people:  people)  if people_required? || all
           kargs.merge!(session: session, options: options)
           keyed ? kargs : kargs.values
@@ -108,7 +112,7 @@ module Eco
         #   provided that it preserves the target parameter
         #   (otherise it would blank it)
         # @return [Eco::API::UseCases::BaseIO]
-        def chained(as: self.type)
+        def chained(as: type) # rubocop:disable Naming/MethodParameterName
           base.tap do |io_base|
             next unless io_base.output
             case as
@@ -116,7 +120,7 @@ module Eco
               io_base.output_be_input!
             when :filter
               io_base.output_be_people!
-            when :transform, :sync, :export, :error_handler, :other
+              # when :transform, :sync, :export, :error_handler, :other
             end
           end
         end
@@ -124,26 +128,25 @@ module Eco
         protected
 
         def output_be_input!
-          @input, @output = output, nil
+          @input, @output = output, nil # rubocop:disable Style/ParallelAssignment
           input
         end
 
         def output_be_people!
-          @people, @output = output, nil
+          @people, @output = output, nil # rubocop:disable Style/ParallelAssignment
           people
         end
 
         private
 
         def validate_args(input:, people:, session:, options:)
-          case
-          when !session.is_a?(Eco::API::Session)
+          if !session.is_a?(Eco::API::Session)
             raise MissingParameter.new("UseCase", required: :session, given: session.class)
-          when input_required? && !input
+          elsif input_required? && !input
             raise MissingParameter.new("UseCase", type: type, required: :input, given: input.class)
-          when people_required? && !people.is_a?(Eco::API::Organization::People)
+          elsif people_required? && !people.is_a?(Eco::API::Organization::People)
             raise MissingParameter.new("UseCase", type: type, required: :people, given: people.class)
-          when !options || (options && !options.is_a?(Hash))
+          elsif !options || (options && !options.is_a?(Hash))
             raise MissingParameter.new("Use Case options", required: :Hash, given: options.class)
           end
           true