eco-helpers 2.7.20 → 2.7.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3980da36d6d236bdd2ff26448cd639af2bc415717d0c1cdabfc9cc13b6ca9996
-  data.tar.gz: d9d1b60a3ff632a244974c6109416ccfa7feee6fd7ce81327596d11367bd3edb
+  metadata.gz: 7cc77a4ee2eb9f30b13efc22f5eaedff1b564f9831c3b7f4d9430b80185ffb83
+  data.tar.gz: fbe4135c3c9c08d46c1ee39b1b3de0c28fd2be547243d2137e49517997052d96
 SHA512:
-  metadata.gz: ff36802a7a6c40dd68bce5389d33b3b525d3233f45e2be91bceac1cbf7678aa70bd89bffd7fa936489c5a57f141c19b7f2f45e0a116c85d2d37a5b03f8830786
-  data.tar.gz: 94a5170171d53c8ca580d8baf85dc370ce7d8e37eb06e1ee79f7bb6947417ca7f6438e2530da5f8ead77c80a52fb27ed086232895a26b089bf0cd285e1f38489
+  metadata.gz: 3f9d81d2a91bf458dadd99e60b15c2e4063e902fa4e9663383367f91a0ad39fdbf4bd4f367a11fa5aef6f9aacfe82ee22161adc4f36ec46781e2d23ef9798168
+  data.tar.gz: 823605e14716575990fcc13db6e538bc7642164b77b889d10fb0b3037bd8a9304751e012ba1fe3229895e0ec1d3585ea69318496a4226df5af18a7c288a42f81

data/CHANGELOG.md

@@ -2,20 +2,32 @@
 
 All notable changes to this project will be documented in this file.
 
-## [2.7.21] - 2024-07-xx
+## [2.7.22] - 2024-07-xx
 
 ### Added
 
 ### Changed
 
+- Patch on exception: to show cause
+- `Eco::Common::Session::FileManager`
+  - `load_json` prevent avoidable memory leaks
+  - `save_json` prevent avoidable memory leaks
+
 ### Fixed
 
-## [2.7.20] - 2024-07-11
+## [2.7.21] - 2024-07-13
 
 ### Added
 
+- Ability to skip GraphQL schema fetch (`GRAPHQL_FETCH_SCHEMA`)
+
 ### Changed
 
+- `-clean-unknown-tags` case
+  - option for `clean-archived-nodes` by default it won't clean them
+
+## [2.7.20] - 2024-07-11
+
 ### Fixed
 
 - Patch on exception

data/lib/eco/api/common/session/file_manager.rb

@@ -3,7 +3,6 @@ module Eco
     module Common
       module Session
         class FileManager
-
           include Eco::Data::Files
 
           attr_reader :dir, :dir_path
@@ -11,18 +10,17 @@ module Eco
 
           def initialize(init = {}, enviro: nil)
             @enviro = enviro
-            init = @enviro.config if @enviro && init.empty?
+            init    = @enviro.config if @enviro && init.empty?
+
             @timestamp_pattern = init.files.timestamp_pattern || DEFAULT_TIMESTAMP_PATTERN
-            self.dir_path = init.working_directory || Dir.pwd
+            self.dir_path      = init.working_directory || Dir.pwd
           end
 
           def dir_path=(value)
-            begin
-              @dir = Eco::Data::Files::Directory.new(value)
-              @dir_path = @dir.create
-            rescue Exception => e
-              logger.error("could not create or make any sense of directory '#{value}': #{e.to_s}")
-            end
+            @dir =      Eco::Data::Files::Directory.new(value)
+            @dir_path = @dir.create
+          rescue StandardError => e
+            logger.error("could not create or make any sense of directory '#{value}': #{e.to_s}")
           end
 
           def logger
@@ -40,53 +38,92 @@ module Eco
 
           def file_content(filename, mode: nil)
             file = dir.file(filename, should_exist: true)
-            if !file
+
+            unless file
               logger.error("Can't read from file '#{filename}' because it does not exist.")
               return nil
             end
+
             logger.debug("Reading from file '#{file}'")
             mode ? File.read(file, mode: mode) : File.read(file)
           end
 
           def load_json(filename)
-            content = file_content(filename)
-            begin
-              parsed = content && JSON.parse(content)
-            rescue JSON::ParserError => e
-              pp "Parsing error on file #{filename}"
-              raise e
+            file = dir.file(filename, should_exist: true)
+
+            unless file
+              logger.error("Can't read from file '#{filename}' because it does not exist.")
+              return nil
             end
-            return parsed
+
+            fd = File.open(file)
+            JSON.load fd # rubocop:disable Security/JSONLoad
+          rescue JSON::ParserError => e
+            pp "Parsing error on file #{file}"
+            raise e
+          ensure
+            fd&.close
           end
 
           def touch(filename, modifier = :no_stamp, mode: :string)
             save("", filename, modifier, mode: mode)
           end
 
-          def save(content, filename, modifier = :no_stamp, mode: :string)
-            file = dir.file(filename)
-            file = FileManager.timestamp_file(file) if modifier == :timestamp
-            mode = (mode == :binary) ? 'wb' : 'w'
+          def save_json(data, filename, modifier = :no_stamp)
+            return save(data.to_json, filename, modifier) unless data.is_a?(Array)
 
-            FileManager.create_directory(FileManager.file_fullpath(file))
+            file = filename_for(filename, modifier)
+            FileManager.create_directory(
+              FileManager.file_fullpath(file)
+            )
 
             logger.debug("Writting to file '#{file}'")
-            File.open(file, mode) { |fd| fd << content }
-            return file
+
+            mode = mode == :binary ? 'wb' : 'w'
+
+            File.open(file, mode) do |fd|
+              first = true
+
+              fd << '['
+              data.each do |elem|
+                fd << "," unless first
+                first = false
+
+                fd << elem.to_json
+              end
+              fd << ']'
+            end
+
+            file
           end
 
-          def save_json(data, filename, modifier = :no_stamp)
-            return save(data.to_json, filename, modifier)
+          def save(content, filename, modifier = :no_stamp, mode: :string)
+            file = filename_for(filename, modifier)
+            FileManager.create_directory(
+              FileManager.file_fullpath(file)
+            )
+
+            logger.debug("Writting to file '#{file}'")
+
+            mode = mode == :binary ? 'wb' : 'w'
+            File.open(file, mode) { |fd| fd << content }
+            file
           end
 
           # if the file does not exist, it creates it
           def append(content, filename, mode: :string)
             file = dir.file(filename)
-            mode = (mode == :binary) ? 'ab' : 'a'
 
             logger.debug("Appending to file '#{file}'")
-            File.open(file, mode) { |fd| fd << content + "\n" } # '\n' won't add line
-            return file
+
+            mode = mode == :binary ? 'ab' : 'a'
+            File.open(file, mode) { |fd| fd << "#{content}\n" }
+            file
+          end
+
+          def filename_for(filename, modifier = :no_stamp)
+            file = dir.file(filename)
+            FileManager.timestamp_file(file) if modifier == :timestamp
           end
         end
       end

data/lib/eco/api/common/version_patches/exception.rb

@@ -12,6 +12,11 @@ class ::Exception
       msg << "#{" " * 8}#{i + 1}: from #{bt}"
     end
 
+    unless cause.nil?
+      msg << "\nCAUSE:"
+      msg << cause.patch_full_message(trace_count: trace_count)
+    end
+
     msg.join("\n")
   rescue StandardError => e
     puts "Something is wrong with 'patch_full_message': #{e}"

data/lib/eco/api/microcases/fix_filter_tags.rb

@@ -11,16 +11,20 @@ module Eco
       #   * `:preserve_custom` (Boolean) [true] indicates if original tags that are not in the tree should be added/preserved.
       #   * `:add_custom` (Boolean) [true] indicates if target tags that are not in the tree should be really added.
       def fix_filter_tags(person, options)
-        if session.tagtree
-          unless !person.new? && (options.dig(:exclude, :core) || options.dig(:exclude, :filter_tags))
-            person.filter_tags = session.tagtree.user_tags(
-              initial:          person.original_doc["filter_tags"] || [],
-              final:            person.filter_tags,
-              preserve_custom:  _fix_filter_tags_preserve_custom?(options),
-              add_custom:       _fix_filter_tags_add_custom?(options)
-            )
-          end
-        end
+        return unless session.tagtree
+
+        filter_tags_excluded =
+          options.dig(:exclude, :core) ||
+          options.dig(:exclude, :filter_tags)
+
+        return if !person.new? && filter_tags_excluded
+
+        person.filter_tags = session.tagtree.user_tags(
+          initial:         person.original_doc["filter_tags"] || [],
+          final:           person.filter_tags,
+          preserve_custom: _fix_filter_tags_preserve_custom?(options),
+          add_custom:      _fix_filter_tags_add_custom?(options)
+        )
       end
 
       private
@@ -28,15 +32,18 @@ module Eco
       # default `true`
       def _fix_filter_tags_preserve_custom?(options)
         key_defined = options.key?(:filter_tags) && options[:filter_tags].key?(:preserve_custom)
-        !key_defined || options.dig(:filter_tags, :preserve_custom)
+        return true unless key_defined
+
+        options.dig(:filter_tags, :preserve_custom)
       end
 
       # default `true`
       def _fix_filter_tags_add_custom?(options)
         key_defined = options.key?(:filter_tags) && options[:filter_tags].key?(:add_custom)
-        !key_defined || options.dig(:filter_tags, :add_custom)
-      end
+        return true unless key_defined
 
+        options.dig(:filter_tags, :add_custom)
+      end
     end
   end
 end

data/lib/eco/api/microcases/preserve_filter_tags.rb

@@ -8,21 +8,21 @@ module Eco
       # @param options [Hash] the options.
       # @param keep_new [Boolean] tells if it should keep the new tags or get rid of them.
       # @return [Array<String>] the final value of `filter_tags`.
-      def preserve_filter_tags(person, options, keep_new: false)
-        if person.as_update.key?("filter_tags")
-          if original  = person.original_doc["filter_tags"]
-            unless original.empty?
-              if keep_new
-                person.filter_tags += original
-              else
-                person.filter_tags  = original
-              end
-            end
+      def preserve_filter_tags(person, _options, keep_new: false)
+        person.filter_tags.tap do
+          next unless person.as_update.key?('filter_tags')
+          next unless (original = person.original_doc['filter_tags'])
+          next if original.empty?
+
+          if keep_new
+            person.filter_tags += original
+          else
+            person.filter_tags  = original
           end
+
+          return person.filter_tags
         end
-        person.filter_tags
       end
-
     end
   end
 end

data/lib/eco/api/microcases/set_core.rb

@@ -7,12 +7,11 @@ module Eco
       # @param person [Ecoportal::API::V1::Person] the person we want to update, carrying the changes to be done.
       # @param options [Hash] the options
       def set_core(entry, person, options)
-        unless options.dig(:exclude, :core) && !person.new?
-          entry.set_core(person, exclude: micro.core_excluded(person, options))
-          micro.fix_filter_tags(person, options)
-        end
-      end
+        return if options.dig(:exclude, :core) && !person.new?
 
+        entry.set_core(person, exclude: micro.core_excluded(person, options))
+        micro.fix_filter_tags(person, options)
+      end
     end
   end
 end

data/lib/eco/api/microcases/set_core_with_supervisor.rb

@@ -9,19 +9,24 @@ module Eco
       # @param supers_job [Eco::API::Session::Batch::Job] the job that will run the supers .
       # @param options [Hash] the options.
       def set_core_with_supervisor(entry, person, people, supers_job, options)
-        unless options.dig(:exclude, :core) && !person.new?
-          micro.set_core(entry, person, options)
-          if entry.supervisor_id?
-            micro.set_supervisor(person, entry.supervisor_id, people, options) do |unknown_id|
-              # delay setting supervisor if does not exit
-              supers_job.add(person) do |person|
-                micro.set_supervisor(person, unknown_id, people, options)
-              end
-            end
+        return if options.dig(:exclude, :core) && !person.new?
+
+        micro.set_core(entry, person, options)
+
+        return unless entry.supervisor_id?
+
+        micro.set_supervisor(
+          person,
+          entry.supervisor_id,
+          people,
+          options
+        ) do |unknown_id|
+          # delay setting supervisor if does not exit
+          supers_job.add(person) do |pers|
+            micro.set_supervisor(pers, unknown_id, people, options)
           end
         end
       end
-
     end
   end
 end

data/lib/eco/api/microcases/set_supervisor.rb

@@ -43,6 +43,7 @@ module Eco
         return true  if person.id == new_super.id
         return true  if new_super.supervisor_id == person.id
         return true  if new_super.supervisor_id == person.external_id
+
         false
       end
 

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

@@ -30,6 +30,7 @@ module Eco
                 require 'ecoportal/api-graphql'
                 Ecoportal::API::GraphQL
               else
+                puts "Unknown api version '#{version}'"
               end
             end
           end
@@ -104,7 +105,7 @@ module Eco
           end
 
           def external_key
-            self["external_key"] || ([:v1, :v2].include?(version) && key)
+            self["external_key"] || (%i[v1 v2].include?(version) && key)
           end
 
           def internal_key
@@ -129,7 +130,7 @@ module Eco
 
           # @param mode [Symbol] to define if running on `:remote` or `:local`
           def mode=(mode)
-            self["mode"] = (mode == :remote)? :remote : :local
+            self["mode"] = mode == :remote ? :remote : :local
           end
 
           # @return [Symbol] if running on `:remote` or `:local`
@@ -163,7 +164,7 @@ module Eco
           private
 
           # Generates a **new** `API` object of version `version`.
-          def new_api(version)
+          def new_api(version) # rubocop:disable Metrics/AbcSize
             klass = self.class.api_class(version)
             case self.version(version)
             when :v0
@@ -173,6 +174,8 @@ module Eco
             when :v2
               klass.new(user_key: user_key, org_key: external_key, host: host, logger: logger)
             when :graphql
+              kargs = {host: host, org_id: org_id, email: email, pass: pass}
+              kargs.merge!({no_schema: true}) if ENV['GRAPHQL_FETCH_SCHEMA'] == "false"
               klass.new(host: host, org_id: org_id, email: email, pass: pass)
             end.tap do |api|
               unless !api || log_connection?

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

@@ -153,6 +153,7 @@ module Eco
 
           def graphql_api
             return nil unless apis.active_api.version_available?(:graphql)
+
             apis.api(version: :graphql)
           end
 

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

@@ -5,15 +5,23 @@ module Eco
       class BaseCase
         class InvalidType < StandardError
           def initialize(msg = nil, type:, types:)
-            msg ||= "Invalid type."
-            msg = "Given type '#{type}'. Valid types: #{types}"
+            msg ||= "Invalid type. "
+            msg  << "Given type '#{type}'. Valid types: #{types}"
             super(msg)
           end
         end
 
         extend Eco::API::Common::ClassHelpers
 
-        @types = [:import, :filter, :transform, :sync, :error_handler, :export, :other]
+        @types = %i[
+          import
+          filter
+          transform
+          sync
+          error_handler
+          export
+          other
+        ]
 
         class << self
           attr_reader :types

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

@@ -71,6 +71,7 @@ module Eco
             type:   type,
             output: output
           }).slice(:type, :input, :people, :session, :options, :output) # :validate <- ?
+
           Eco::API::UseCases::BaseIO.new(**kargs)
         end
 
@@ -95,6 +96,7 @@ module Eco
           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
         end
 
@@ -104,7 +106,12 @@ module Eco
         #   2. does this, **before** the target `case_name` launch and **after
         # @return [Eco::API::UseCases::BaseIO]
         def process_case(case_name, case_type, **params)
-          session.process_case(case_name, io: chained, type: case_type, **params).chained
+          session.process_case(
+            case_name,
+            io:   chained,
+            type: case_type,
+            **params
+          ).chained
         end
 
         # Does the switch from output to result in a new IO object.
@@ -115,6 +122,7 @@ module Eco
         def chained(as: type) # rubocop:disable Naming/MethodParameterName
           base.tap do |io_base|
             next unless io_base.output
+
             case as
             when :import
               io_base.output_be_input!

data/lib/eco/api/usecases/default/people/amend/clean_unknown_tags_case.rb

@@ -1,7 +1,9 @@
 class Eco::API::UseCases::Default::People::Amend::CleanUnknownTags < Eco::API::Common::Loaders::UseCase
-  name "clean-unknown-tags"
+  name 'clean-unknown-tags'
   type :transform
 
+  require_relative 'cli/clean_unknown_tags_cli'
+
   REGISTER_TAGS = %w[
     EVENT INJURY RISK CONTRACTOR PERMIT
     AUDIT JSEA
@@ -11,58 +13,162 @@ class Eco::API::UseCases::Default::People::Amend::CleanUnknownTags < Eco::API::C
     POLICY IDEA REPORTS
   ].freeze
 
-  def main(people, session, options, usecase)
-    update = session.new_job("main", "update", :update, usecase)
+  def main(*_args)
+    tune_options!
+
     people.each do |person|
-      unknown_tags = person.filter_tags.reject { |tag| tag?(tag) }
-      person.filter_tags -= unknown_tags
-      removed_tag!(*unknown_tags)
-      if (tag = default_tag(person)) && !tag?(tag)
-        removed_tag!(tag)
-        micro.refresh_default_tag(person.entry, person, options)
-      end
-      update.add(person)
+      update_job.add(person)
+
+      update_filter_tags!(person)
+      update_default_tag!(person)
+
+      clean_unkown_tags!(person)
+      clean_archived_nodes!(person) if clean_archived?
     end
+  end
 
-    log(:info) {
-      msg  = "Here list of the #{removed_tags.count} removed locations..."
-      msg << "\n  • "
-      msg << removed_tags.sort.join("\n  • ")
-      msg
-    }
+  def update_job
+    @update_job ||= session.new_job('main', 'update', :update, usecase) do |_job, _job_status|
+      report_archived_cleaned
+      report_unknown_cleaned
+    end
   end
 
   private
 
+  def known_tag?(value)
+    return false if clean_register_tags? && register_tag?(tag)
+
+    tag?(value)
+  end
+
+  def archived_tag?(value)
+    return false if register_tag?(value)
+
+    archived_node?(value)
+  end
+
+  def clean_unkown_tags!(person)
+    person.filter_tags = person.filter_tags.select do |tag|
+      known_tag?(tag).tap do |known|
+        cleaned_unknown_tag!(tag) unless known
+      end
+    end
+  end
+
+  # @note it only targets archived nodes
+  def clean_archived_nodes!(person)
+    person.filter_tags = person.filter_tags.reject do |tag|
+      archived_tag?(tag).tap do |known|
+        cleaned_archived_node!(tag) unless known
+      end
+    end
+  end
+
+  def report_unknown_cleaned
+    report_cleaned(
+      cleaned_unknown_tags,
+      msg: 'Cleaned up the following non existing tags:'
+    )
+  end
+
+  def report_archived_cleaned
+    report_cleaned(
+      cleaned_archived_nodes,
+      msg: 'Cleaned up the following archived nodes:'
+    )
+  end
+
+  def clean_register_tags?
+    options.dig(:usecase, :clean_register_tags) || false
+  end
+
+  def clean_archived?
+    options.dig(:usecase, :clean_archived) || false
+  end
+
+  def report_cleaned(data, msg:)
+    return if data.empty?
+
+    cleaned_sorted = data.sort_by {|tag, count| [count * -1, tag]}
+
+    msg << "\n  • "
+    msg += cleaned_sorted.map do |tag, count|
+      "'#{tag}' (#{count})"
+    end.join("\n  • ")
+
+    log(:info) { msg }
+    data.clear
+  end
+
+  def cleaned_unknown_tag!(tag)
+    cleaned_unknown_tags[tag] ||= 0
+    cleaned_unknown_tags[tag]  += 1
+  end
+
+  def cleaned_unknown_tags
+    @cleaned_unknown_tags ||= {}
+  end
+
+  def cleaned_archived_node!(tag)
+    cleaned_archived_nodes[tag] ||= 0
+    cleaned_archived_nodes[tag]  += 1
+  end
+
+  def cleaned_archived_nodes
+    @cleaned_archived_nodes ||= {}
+  end
+
   def default_tag(person)
     return unless (account = person.account)
+
     account.default_tag
   end
 
-  def register_tags
-    @register_tags ||= self.class::REGISTER_TAGS.compact.map(&:upcase)
+  def unknown_tag?(value)
+    !known_tag?(value)
   end
 
-  def removed_tag!(*tags)
-    @removed_tags = removed_tags | tags
+  def active_node?(value)
+    return false if value.nil?
+    return false unless tagtree.tag?(value)
+
+    !archived_node?(value)
   end
 
-  def removed_tags
-    @removed_tags ||= []
+  def archived_node?(value)
+    return false unless (node = tagtree.node(value))
+
+    node.archived
   end
 
   def tag?(value)
     return false if value.nil?
     return true  if tagtree.tag?(value)
-    return false if clean_register_tags?
+
     register_tags.any? { |reg| value.upcase == reg }
   end
 
+  def register_tag?(value)
+    register_tags.include?(value)
+  end
+
+  def register_tags
+    @register_tags ||= self.class::REGISTER_TAGS.compact.map(&:upcase)
+  end
+
+  # Get all the location structures merged into a single one
   def tagtree
-    @tagtree ||= session.tagtree(live: true, merge: true)
+    @tagtree ||= session.tagtree(
+      live:             true,
+      include_archived: true,
+      merge:            true
+    )
   end
 
-  def clean_register_tags?
-    options.dig(:usecase, :clear_register_tags)
+  def tune_options!
+    # options.deep_merge!(include: {excluded:     true})
+    options.deep_merge!(skip: {api_policies: true})
+    options.deep_merge!(skip: {batch_policy: true})
   end
 end

data/lib/eco/api/usecases/default/people/amend/cli/clean_unknown_tags_cli.rb

@@ -0,0 +1,16 @@
+class Eco::API::UseCases::Default::People::Amend::CleanUnknownTags
+  class Cli < Eco::API::UseCases::Cli
+    str  = 'Cleans from filter_tags those tags that are not present in the tagtree '
+    str << '(as per tagtree.json file). '
+    str << 'It will preserve standard register tags of most common registers (i.e. EVENT, RISK).'
+    desc str
+
+    add_option("-clean-register-tags", "Will also try to remove register tags") do |options|
+      options.deep_merge!(usecase: {clean_register_tags: true})
+    end
+
+    add_option("-clean-archived", "Will also try to remove archived tags") do |options|
+      options.deep_merge!(usecase: {clean_archived: true})
+    end
+  end
+end

data/lib/eco/api/usecases/default/people/migrate/remap_tags_case.rb

@@ -152,7 +152,7 @@ class Eco::API::UseCases::Default::People::Migrate::RemapTags < Eco::API::Common
 
   def cleared_unknown_tag!(tag)
     cleared_unknown_tags[tag] ||= 0
-    cleared_unknown_tags[tag] += 1
+    cleared_unknown_tags[tag]  += 1
   end
 
   def cleared_unknown_tags
@@ -161,7 +161,7 @@ class Eco::API::UseCases::Default::People::Migrate::RemapTags < Eco::API::Common
 
   def cleared_archived_node!(tag)
     cleared_archived_nodes[tag] ||= 0
-    cleared_archived_nodes[tag] += 1
+    cleared_archived_nodes[tag]  += 1
   end
 
   def cleared_archived_nodes
@@ -210,6 +210,7 @@ class Eco::API::UseCases::Default::People::Migrate::RemapTags < Eco::API::Common
 
   def default_tag(person)
     return unless (account = person.account)
+
     account.default_tag
   end
 
@@ -228,23 +229,27 @@ class Eco::API::UseCases::Default::People::Migrate::RemapTags < Eco::API::Common
   def archived_tag?(value)
     return false if register_tag?(value)
     return false unless (node = tagtree.node(value))
+
     node.archived
   end
 
   def tag?(value)
     return false if value.nil?
     return true  if tagtree.tag?(value)
+
     register_tags.any? { |reg| value.upcase == reg }
   end
 
   def active_node?(value)
     return false if value.nil?
     return false unless tagtree.tag?(value)
+
     !archived_node?(value)
   end
 
   def archived_node?(value)
     return false unless (node = tagtree.node(value))
+
     node.archived
   end
 
@@ -263,7 +268,7 @@ class Eco::API::UseCases::Default::People::Migrate::RemapTags < Eco::API::Common
 
   def tune_options!
     # options.deep_merge!(include: {excluded:     true})
-    options.deep_merge!(skip:    {api_policies: true})
-    options.deep_merge!(skip:    {batch_policy: true})
+    options.deep_merge!(skip: {api_policies: true})
+    options.deep_merge!(skip: {batch_policy: true})
   end
 end

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

@@ -8,35 +8,46 @@ module Eco
         attr_reader :options
 
         def initialize(name, type:, root:, &block)
-          raise InvalidType.new("Invalid type for '#{name}'.", type: type, types: self.class.types) unless self.class.valid_type?(type)
-
-          self.root = root
-          @callback = block
-          @name     = name
-          @type     = type
+          invalid_type_err = InvalidType.new(
+            "Invalid type for '#{name}'.",
+            type:  type,
+            types: self.class.types
+          )
+          raise invalid_type_err unless self.class.valid_type?(type)
+
+          super()
+
+          self.root       = root
+          @callback       = block
+          @name           = name
+          @type           = type
           @times_launched = 0
         end
 
         def source_object
           return nil unless callback_from_loader?
+
           callback_self
         end
 
         def chainer
-          # TODO: root is a Eco::API::UseCases that will not point to this new case.
+          # @todo: root is a Eco::API::UseCases that will not point to this new case.
           # => Moreover, the name and type will be the same as self
           Eco::API::UseCases::UseCaseChain.new(usecase: self, root: @root)
         end
 
         def root=(value)
-          raise "Root should be a Eco::API::UseCases. Given: #{value.class}" if !value.is_a?(Eco::API::UseCases)
+          msg = "Root should be a Eco::API::UseCases. Given: #{value.class}"
+          raise ArgumentError, msg unless value.is_a?(Eco::API::UseCases)
+
           @root = value
         end
 
         # Actual launch of the usecase
         # @param io [Eco::API::UseCases::BaseIO] an input/output helper with the necessary parameters.
         # @param kargs [Hash] hash with symbol keys.
-        # @option kargs [Eco::API::Common::People::Entries, Eco::API::Organization::People] :input the input data of reference.
+        # @option kargs [Eco::API::Common::People::Entries, Eco::API::Organization::People] :input
+        #   the input data of reference.
         # @option kargs [Eco::API::Organization::People] :people object.
         # @option kargs [Eco::API:Session] :session
         # @option kargs [Hash] :options hash with symbol keys (i.e. behaviour modifiers, cli trackers, filters, etc.)
@@ -48,8 +59,10 @@ module Eco
           UseCaseIO.new(**kargs).tap do |uio|
             @options = uio.options
             uio.session.logger.debug("#{self.class}: going to process '#{name}'")
+
             set_session_n_options(uio) if callback_from_loader?
-            uio.output = callback.call(*uio.params)
+
+            uio.output       = callback.call(*uio.params)
             @times_launched += 1
           end
         end
@@ -62,12 +75,10 @@ module Eco
 
         protected
 
-        def callback
-          @callback
-        end
+        attr_reader :callback
 
         def callback_self
-          eval("self", callback.binding)
+          eval("self", callback.binding, __FILE__, __LINE__)
         end
 
         def callback_from_loader?
@@ -78,33 +89,40 @@ module Eco
         # in the use case definition
         # @note this only works when the use case was defined
         #   via an children class of `Eco::API::Common::Loaders::Base`
-        def set_session_n_options(uio)
+        def set_session_n_options(uio) # rubocop:disable Naming/AccessorMethodName
           return false unless callback_from_loader?
-          opts = uio.options || @options
-          sess = uio.session
-          peo  = uio.people
-          ent  = uio.input
+
+          opts          = uio.options || @options
+          sess          = uio.session
+          peo           = uio.people
+          ent           = uio.input
           use_case_self = self
 
           callback_self.instance_eval do
             @session = sess
             @options = opts
+
             if peo
               @people = peo
-              self.singleton_class.attr_reader(:people) unless respond_to?(:people)
+              singleton_class.attr_reader(:people) unless respond_to?(:people)
             end
 
             if ent # entries/input
               @input = ent
-              self.singleton_class.attr_reader(:input) unless respond_to?(:input)
+              singleton_class.attr_reader(:input) unless respond_to?(:input)
+
+              # Below problematic code... usage has cases where entries = (gets assigned)
+              # @entries = ent
+              # singleton_class.attr_reader(:entries) unless respond_to?(:entries)
             end
 
             # `self` is the use case itself (when used the Loader)
-            next unless self.is_a?(Eco::API::Common::Loaders::CaseBase)
+            next unless is_a?(Eco::API::Common::Loaders::CaseBase)
 
             @usecase = use_case_self
-            self.singleton_class.attr_reader(:usecase) unless respond_to?(:usecase)
+            singleton_class.attr_reader(:usecase) unless respond_to?(:usecase)
           end
+
           true
         end
       end

data/lib/eco/cli_default/usecases.rb

@@ -88,13 +88,6 @@ ASSETS.cli.config do |cnf|
       options.deep_merge!(source: {file: file})
     end
 
-    desc  = "Cleans from filter_tags those tags that are not present in the tagtree (as per tagtree.json file)."
-    desc += " It will preserve standard register tags of most common registers (i.e. EVENT, RISK)."
-    cases.add("-clean-unknown-tags", :transform, desc, case_name: "clean-unknown-tags")
-    .add_option("-clear-register-tags", "Will also try to remove register tags") do |options|
-      options.deep_merge!(usecase: {clear_register_tags: true})
-    end
-
     desc = "Forces a change of email in the same org. It won't succeed if email taken by an org member user"
     cases.add("-change-email-from", :sync, desc, case_name: "change-email")
 

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = '2.7.20'.freeze
+  VERSION = '2.7.22'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.7.20
+  version: 2.7.22
 platform: ruby
 authors:
 - Oscar Segura
@@ -705,6 +705,7 @@ files:
 - lib/eco/api/usecases/default/people/amend.rb
 - lib/eco/api/usecases/default/people/amend/clean_unknown_tags_case.rb
 - lib/eco/api/usecases/default/people/amend/clear_abilities_case.rb
+- lib/eco/api/usecases/default/people/amend/cli/clean_unknown_tags_cli.rb
 - lib/eco/api/usecases/default/people/amend/refresh_case.rb
 - lib/eco/api/usecases/default/people/amend/reinvite_sync_case.rb
 - lib/eco/api/usecases/default/people/amend/reinvite_trans_case.rb