eco-helpers 2.6.4 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ecd2c2f2849623bb76d4eb53883c5d7564cb1bf1a3c6365b4d96d3de8c9c68e
-  data.tar.gz: 8e4ef9ddee2ca1d9750b9df3aabda5200d93e4a30216306dbe44d68b175883be
+  metadata.gz: 763e0c31825790c4529dca3c90c5b673fc948605f4fb0fad3c73ad5caabe1473
+  data.tar.gz: edabe853c610dfe4b003600e953c1a2c6e16ebf69881073d08c69af7dd08fecb
 SHA512:
-  metadata.gz: 68001b392d5eba8ee710bc315b88adc5c0111ff9b7b6e862e1037b31c10a4269e9453c0514eabb8768c46bf9e9e0128187d072e9eec5ed017b38920cde9fc3c0
-  data.tar.gz: 71904f2040ab00bf8cc4fd31b07fef8a80259de806ca63cff717c559c953ade2d99f76a4b336e9dbfc0c48a07ce94616fe49b9daf285cc488fcd3a8c8373281c
+  metadata.gz: 1e4bb559627452bddeb611a25234c02f7d9d0406af0c9c3fa585d467f4c49118d65a7462566d9e41ac737b11c52d2e344aa4242f45bc671142c3cca6e1fc8cfa
+  data.tar.gz: c47d33d0c37a32b3dd26a280000f91a77860cdb99ca64a15387cf5d1038de1b0fe757b4c57aef80ccd76be7576d3835408d3b58007f39a9d6cddbcbfa36996a2

data/.gitignore

@@ -4,6 +4,7 @@ Gemfile.lock
 # build artifacts
 *.gem
 /.bundle
+/.vscode
 /vendor/bundle
 /spec/reports/
 /tmp/

data/.rubocop.yml

@@ -0,0 +1,95 @@
+AllCops:
+  TargetRubyVersion: 2.7.8
+  Exclude:
+    - 'config/routes.rb'
+  NewCops: enable
+
+Metrics/ClassLength:
+  Max: 500
+Metrics/ModuleLength:
+  Max: 300
+Metrics/MethodLength:
+  Max: 50
+Metrics/AbcSize:
+  Max: 30
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: false
+Metrics/BlockLength:
+  CountAsOne: ['array', 'heredoc', 'method_call']
+  Max: 50
+Metrics/CyclomaticComplexity:
+  Max: 30
+Metrics/PerceivedComplexity:
+  Max: 30
+
+Style/AccessorGrouping:
+  Enabled: false
+Style/ConditionalAssignment:
+  Enabled: false
+Style/BlockDelimiters:
+  BracesRequiredMethods: ['log']
+  AllowedPatterns: ['proc', 'new']
+Style/ClassAndModuleChildren:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/StringLiterals:
+  Enabled: false
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/CommentedKeyword:
+  Enabled: false
+Style/MultilineBlockChain:
+  Enabled: false
+Style/AndOr:
+  Enabled: false
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+Style/FetchEnvVar:
+  Enabled: false
+Style/RegexpLiteral:
+  EnforcedStyle: mixed
+  AllowInnerSlashes: true
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+Layout/LeadingCommentSpace:
+  Enabled: false
+  AllowGemfileRubyComment: true
+Layout/ParameterAlignment:
+  Enabled: false
+Layout/MultilineMethodDefinitionBraceLayout:
+  EnforcedStyle: symmetrical
+Layout/LineLength:
+  Enabled: true
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: false
+Layout/SpaceInsideBlockBraces:
+  Enabled: false
+Layout/SpaceAroundOperators:
+  Enabled: false
+Layout/ExtraSpacing:
+  AllowForAlignment: true
+  AllowBeforeTrailingComments: true
+Layout/AccessModifierIndentation:
+  EnforcedStyle: indent
+Layout/DotPosition:
+  EnforcedStyle: trailing
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+Layout/FirstHashElementIndentation:
+  Enabled: false
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
+
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+  CheckSymbols: false
+Naming/MethodParameterName:
+  AllowedNames: ['x', 'y', 'i', 'j', 'id', 'io', 'to']
+Naming/RescuedExceptionsVariableName:
+  Enabled: false

data/CHANGELOG.md

@@ -1,9 +1,146 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.6.4] - 2024-03-xx
+## [2.7.2] - 2024-04-xx
+
+### Added
+### Changed
+### Fixed
+
+## [2.7.1] - 2024-04-23
+
+### Fixed
+  - `Eco::Language::AuxiliaLogger` prioritize `session.logger` in the object scoping process.
+
+## [2.7.0] - 2024-04-23
+
+### Added
+  - **support** for node **classifications** on
+    - `Eco::Data::Locations::NodePlain`
+    - `Eco::API::Organization::TagTree`
+      - It `downcase` the classification values
+    - added class `Eco::API::Organization::NodeClassifications`
+      - `#node_classifications` method in `session`, `session.config` and in `config.tagtree`
+    - **validation** helpers via locations base case (`Eco::API::UseCases::GraphQL::Helpers::Location::Base::ClassificationsParser`)
+  - Use case (**made native**)
+    - `-tagtree-upload`  => `Eco::API::UseCases::Default::Locations::TagtreeUpload`
+      - it can target specific tree via `-structure-id` cli argument
+    - it has some **optimizations** such as:
+      1. Only backing up the tree once (before)
+      2. Not graphql querying the tree as a response of each batch commands request
+  - Parameter `-file-as-source` for `-tagtree-extract` provided that the case can **convert** input tree csv files into a list of nodes (`Eco::API::UseCases::Default::Locations::TagtreeExtract`)
+  - **Tagtree UPDATE** case helpers. Added three service modules for quickly building **custom tagtree update cases**. See:
+    1. `Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeToList`
+    2. `Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeDiff`
+    3. `Eco::API::UseCases::GraphQL::Samples::Location::Command::Service::TreeUpdate`
+  - `snake_case` helper (at `Eco::Data::Strings::SnakeCase`)
+  - `camel_case` helper (at `Eco::Data::Strings::CamelCase`)
+  - `camel_case` helper (at `Eco::Data::Strings::CamelCase`)
+  - snake vs camel indifferent access helper (at `Eco::Data::Hashes::SnakeCamelIndifferentAccess`)
+  - **Optimization** helper classes to cluster node diffs:
+    - `Eco::Data::Locations::NodeDiff::NodesDiff::ClusteredTreeify`: key helper
+    - `Eco::Data::Locations::NodeDiff::NodesDiff::DiffsTree`: supporting class.
+  - **consistency** (snake vs camel case) on `parentd` for `Eco::Data::Locations::NodeLevel`
+  - `Eco::API::UseCases::GraphQL::Utils::Sftp`
+    - Configurable `remote_folder`
+  - Made **native** location diffs staged command builders
+    - These helpers target ONLY location nodes where the `id` are **codes**
+      - Please notice that composed `id` (i.e. `name - code`) is NOT supported (as there isn't a clean way to update => no batch remap location ids operation available)
+    - **Added** class and namespaces under `Eco::API::UseCases::GraphQL::Helpers::Location::Command`
+      - `Diff`
+      - `Diffs`
+  - **SFTP Helpers** review
+    - `Eco::API::Common::Session::SFTP#upload` added method
+    - `Eco::API::UseCases::GraphQL::Utils::SFTP`
+      - `#sftp_download_files` added method
+      - `#local_folder` for downloading the files
+      - added parameters to the existing methods
+
+### Changed
+  - **Parsers**
+    - Native **date parser**, added _warning_ when date cannot be parsed
+    - Migrated **select parser** (`Eco::API::Common::People::DefaultParsers::SelectParser`). This change entailed to introduce several changes:
+      - Added _warning_ when select option is unknown.
+      - `Eco::API::Common::People::PersonParser`:
+        1. methods `#parse` and `#serialize` call to the parser/serializer method by using a block to resolve `Proc` call dependencies.
+        2. **added** method `#select_tables` (this has been moved from the _default parsers_ class to the _person parser_ itself)
+      - `Eco::Language::Models::ParserSerializer`
+        - methods `#parse` and `#serialize` can be called with a `block` to resolve dependencies.
+  - `Eco::CSV::Table` the internal method `to_rows_array` was not spliting `Array` values with pipe operator `|`. Made so it does so.
+    - **Note** that `to_array_of_hashes` (the opposite method) does NOT convert them back to `Array` (but it wasn't converting back the array string to its Array version anyway)
+  - **renamed** use case `-export-tree` to `-tagtree-extract`
+    - `Eco::API::UseCases::Default::Locations::TagtreeExtract`
+  - **Improved** `Eco::Data::Locations::NodeLevel` by adding support for `classifications` and `classification_names`
+    - It just catches the **original header** names, and uses them
+    - **Note** that these headers may NOT be actual classifications, but just conventional header names. For this reason, it is **required** that there is a **parse** function that **validates** that they are **actual classifications**
+  - `Eco::API::Organization::TagTree`
+    - **changed** `as_json` serialization on **classifications** (it serializes to a `dup` of the `Array` now) - ceased to ~~`join('|')`~~
+    - **changed** `as_json`. It now includes `level` (`depth + 1`)
+  - **Optimized** life cycle of applying commands to _locations structures_
+    - This optimization is based on **NOT retrieving** the full locations structure on each request (_apply commands payload block_ on **graphql**). This also entails that the number of **backups** per run is drastically minimized.
+    - `Eco::API::UseCases::GraphQL::Helpers::Location::Command::DSL`
+      - **Added** `#batch_tree_track_mode` to define what tracking mode would be used at each commands stage.
+        - The only stage that tracks/backes-up the tree on each request is now `:id` (or `:id_name`) -> remap location ids _integrity check_ purposes (which is actually somehow redundant; just an additional measure in place).
+    - `Eco::API::UseCases::GraphQL::Helpers::Location::Command`
+      - `#sliced_batches`
+        - **added** parameter `track_tree_mode:`
+        - **before** final call to `apply_commands`, it scopes the payload `block` of the request (using the new custom method `scope_commands_block`, see below)
+      - Decoupled re-configurable (**overridable**) methods into `Optimizations` sub-space: `Eco::API::UseCases::GraphQL::Helpers::Location::Command::Optimizations`
+        - `#default_tree_tracking_mode` the fallback tracking mode (besides `#batch_tree_track_mode` on `DLS`)
+        - `#scope_commands_block` based on the current tree tracking mode, it scopes what the block for the apply commands payload will be
+        - `#commands_payload_without_structure_block`: sample graphql payload block that does NOT retrieve the locations structure (**optimization lies here**)
+  - `Eco::API::UseCases::GraphQL::Samples::Location::Command::Results`
+    - **Decoupled** tracking of changed ids into `Eco::API::UseCases::GraphQL::Samples::Location::Command::TrackChangedIds`
+      - `#update_tags_remap_table` -> remove `:move` stage tracking
+      - As content only has the lowest level location node, moving does **NOT** entail remapping locations any longer (there isn't full path on content at this stage; after `RS P3` release)
+  - `Eco::Data::Locations::NodeDiff`
+    - `archived?` added parameter for **validation** (default `true`)
+    - `attr_expose`
+      - It adds `_prev` as a postfix (**removed** as a prefix ~~`prev_`~~)
+      - It uses the question mark `?` alone (**removed** ~~`diff_`~~ prefix)
+      - **added** all these methods support now `snake_case`
+    - **BREAKING** change to move onto **RS P3 post-release**
+      - A change of `name?` **WON'T** trigger a change of `id` (`nodeId`) any more
+      - For this reason, identification on changes on the `id` will be besides changes of the `name`
+  - `Eco::Data::Locations::NodeDiff::NodesDiff`- **Important change** on `#diffs` (core property)
+    - It now discards diffs that `insert?` and `archive?` as well, provided that they do not generate updates
+    - **Note** that this limiation may be a drawback when we aim to import historical location nodes that should be in the org (for import purposes) but that are not active locations. The way **around it** is to just use an input where the `archived` property is `false` (later on launch those again with `archived` true, but lets do a good input data integrity check here)
+  - `Eco::Data::Hashes::DiffResult`
+    - moved `Meta` under its namespace
+    - created _private_ unique points to access source hashes. This will allows to extend the behaviour from child classes
+    - **Moved** hash accessors (**DSL**) to `Eco::Data::Hashes::DiffResult::Meta`
+      - also **added** method `key_present?`
+      - **improved** `slice_attrs` to return `nil` if `src` isn't present.
+      - **added** `Array` comparizon via `eq?` method.
+    - (Class) **Added** named arg `when_present` to `compare` class method.
+    - (Instance) **Removed** unused method `compared_attrs`
+      - **Replaced by** `all_compared_attrs`
+    - (Class) **Added** `compared_attrs_when_present`
+      - (Instance) **Added** `comparable_attr?`, which based on `all_compared_attrs` (instance method) checks if `attr` is required for presence on both source hashes (`src_1` and `src_2`)
+        - This is supported by the **new** method `key_present_in_both?`
+      - (Instance) **Modified** behaviour on `diff_attrs` provided that takes into consideration if an `attr` is **comparable** (`comparable_attr?`)
+  - upgrade **gems** `ecoportal-api-v2` and `ecoportal-api-graphql`
+    - this brings some optimizations when treeifying locations structures
+  - `Eco::Data::Hashes::ArrayDiff`
+    - **Removed** unused method `compared_attrs`
+
+### Fixed
+  - upgrade `ecoportal-api-v2` **gem**
+  - A bunch of small things on the `Eco::Data::Locations` namespace
+  - `Eco::API::Session::Config#live_trees` to choose a tree when only one
+  - `Eco::API::UseCases::GraphQL::Helpers::Location::Base`
+    - `tagtree_id` method should `map` values rather than `select` keys on `options`
+  - `Eco::Data::Locations::NodeDiff::NodesDiff`
+    - fix `diffs_summary` lining
+  - `Eco::Language::Methods::DslAble`
+    - explicit behaviour for `respond_to_missing?` (dsl doesn't need to allow method capturing via `method` call)
+    - add `__FILE__` and `__LINE__` to error backtrace on `eval`
+  - Parsing `archived` value in
+    - `Eco::API::Organization::TagTree`
+    - `Eco::Data::Locations::NodePlain`
+
+## [2.6.4] - 2024-03-06
 
-### Added
 ### Changed
   - updated core **gem** `ecoportal-api`
   - The `subordinates` core people property has been removed from the back-end

data/Rakefile

@@ -1,7 +1,8 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "yard"
-require "redcarpet"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'yard'
+require 'redcarpet'
 
 desc "run the specs"
 RSpec::Core::RakeTask.new(:spec)
@@ -10,11 +11,13 @@ desc "run rspec showing backtrace"
 RSpec::Core::RakeTask.new(:spec_trace) do |task|
   task.rspec_opts = ['--backtrace']
 end
+task(rspec_trace: :spec_trace)
 
 desc "run rspec stopping on first fail, and show backtrace"
 RSpec::Core::RakeTask.new(:spec_fast) do |task|
   task.rspec_opts = ['--fail-fast', '--backtrace']
 end
+task(rspec_fast: :spec_fast)
 
 # default task name is yard
 desc "Yard: generate all the documentation"
@@ -22,6 +25,9 @@ YARD::Rake::YardocTask.new(:doc) do |t|
   #t.files = ['lib/**/*.rb']
 end
 
-task :default     => [:spec]
-task :rspec_trace => :spec_trace
-task :rspec_fast  => :spec_fast
+desc "default task: runs rubocop and rspec"
+task :default do
+  Rake::Task[:rubocop].invoke
+ensure
+  Rake::Task[:spec].invoke
+end

data/eco-helpers.gemspec

@@ -31,8 +31,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "redcarpet", ">= 3.6.0",  "< 4"
 
   spec.add_dependency 'ecoportal-api',         '>= 0.9.7', '< 0.10'
-  spec.add_dependency 'ecoportal-api-v2',      '>= 1.1.6', '< 1.2'
-  spec.add_dependency 'ecoportal-api-graphql', '>= 0.3.13', '< 0.4'
+  spec.add_dependency 'ecoportal-api-v2',      '>= 1.1.8', '< 1.2'
+  spec.add_dependency 'ecoportal-api-graphql', '>= 0.3.15', '< 0.4'
   spec.add_dependency 'aws-sdk-s3',    '>= 1.142.0', '< 2'
   spec.add_dependency 'aws-sdk-ses',   '>= 1.58.0', '< 2'
   spec.add_dependency 'dotenv',        '>= 2.8.1',  '< 3'

data/lib/eco/api/common/loaders/base.rb

@@ -14,7 +14,7 @@ module Eco
 
             # If still not set, it sets the `created_at` class timestamp.
             def set_created_at!
-              @created_at = Time.now unless @created_at
+              @created_at ||= Time.now unless @created_at # rubocop:disable Naming/MemoizedInstanceVariableName
             end
 
             # Class creation timestamp, to be able to load them in the order they were declared.
@@ -33,7 +33,7 @@ module Eco
           private
 
           def simulate?
-            options.dig(:simulate) || options.dig(:dry_run)
+            options[:simulate] || options[:dry_run]
           end
           alias_method :dry_run?, :simulate?
 

data/lib/eco/api/common/loaders/case_base.rb

@@ -10,7 +10,7 @@ module Eco
             def name(value = nil)
               name_only_once! if value
               set_created_at!
-              return @name ||= self.to_s unless value
+              return @name ||= to_s unless value
               @name = value
             end
 

data/lib/eco/api/common/loaders/config/workflow/mailer.rb

@@ -5,7 +5,7 @@ class Eco::API::Common::Loaders::Workflow::Mailer < Eco::API::Common::Loaders::W
   inheritable_class_vars :config_block
 
   config_block do
-    puts "running from class #{self}"
+    #puts "running from class #{self}"
     exception do |err, io|
       self.error = err
       log(:debug) { err.patch_full_message }
@@ -13,9 +13,9 @@ class Eco::API::Common::Loaders::Workflow::Mailer < Eco::API::Common::Loaders::W
     end
 
     after(:close) do |_wf, io|
-      next if options.dig(:workflow, :no_email)
+      next if     options.dig(:workflow, :no_email)
       next unless session.mailer?
-      next if session.config.dry_run?
+      next if     session.config.dry_run?
       next unless session.config.run_mode_remote?
       next unless some_update?(io) || error?
 
@@ -49,7 +49,7 @@ class Eco::API::Common::Loaders::Workflow::Mailer < Eco::API::Common::Loaders::W
 
     def some_update?(io)
       cli.config.usecases.active(io: io).any? do |usecase, data|
-        [:transform, :sync].any? { |type| usecase.type == type }
+        %i[transform sync].any? { |type| usecase.type == type }
       end
     end
 
@@ -62,7 +62,7 @@ class Eco::API::Common::Loaders::Workflow::Mailer < Eco::API::Common::Loaders::W
     end
 
     def log_err_n_warn(io)
-      warn_errors = io.logger.cache.logs(level: [:error, :warn])
+      warn_errors = io.logger.cache.logs(level: %i[error warn])
       return if warn_errors.empty?
       "WARNINGS & ERRORS:\n#{warn_errors.join('')}\n"
     end

data/lib/eco/api/common/loaders/error_handler.rb

@@ -9,7 +9,8 @@ module Eco
             # @return [Eco::API::Error] the error class, child of `Eco::API::Error`.
             def error(value = nil)
               unless value
-                return @error || raise("You should specify an error type for #{self.class}")
+                msg = "You should specify an error type for #{self.class}"
+                return @error || (raise msg)
               end
               @error = value
             end
@@ -17,9 +18,11 @@ module Eco
 
           inheritable_class_vars :error
 
-          def initialize(handlers)
-            raise "Expected Eco::API::Policies. Given #{handlers.class}" unless handlers.is_a?(Eco::API::Error::Handlers)
-            handlers.on(self.error, &self.method(:main))
+          def initialize(handlers) # rubocop:disable Lint/MissingSuper
+            msg = "Expected Eco::API::Policies. Given #{handlers.class}"
+            raise msg unless handlers.is_a?(Eco::API::Error::Handlers)
+
+            handlers.on(error, &method(:main))
           end
 
           # @param people [Eco::API::Organization::People] the people in the queue of the current `job`
@@ -27,7 +30,7 @@ module Eco
           # @param options [Hash] the options that modify the case behaviour or bring some dependencies.
           # @param handler [Eco::API::Error::Hanlder] the `error handler` instance object.
           # @param job [Eco::API::Session::Batch::Job] the `Batch::Job` made on purpose for this handler.
-          def main(people, session, options, handler, job)
+          def main(people, session, options, handler, job) # rubocop:disable Lint/UnusedMethodArgument
             raise "You should implement this method"
           end
 

data/lib/eco/api/common/loaders/parser.rb

@@ -4,7 +4,7 @@ module Eco
       module Loaders
         class Parser < Eco::API::Common::Loaders::CaseBase
           # Helper class to scope what required attributes it depends on
-          class RequiredAttrs < Struct.new(:attr, :type, :attrs)
+          RequiredAttrs = Struct.new(:attr, :type, :attrs) do
             def active?(*input_attrs)
               missing(*input_attrs).empty?
             end
@@ -33,7 +33,9 @@ module Eco
             # @return [String] the `type` of usecase (i.e. `:sync`, `:transform`, `:import`, `:other`)
             def attribute(value = nil)
               unless value
-                return @attribute || raise("You should specify the 'attribute' this parser/serializer, #{self.class}, is linked to")
+                msg  = "You should specify the 'attribute' this parser/serializer, "
+                msg << "#{self.class}, is linked to"
+                return @attribute || (raise msg)
               end
               name value
               @attribute = value
@@ -42,9 +44,13 @@ module Eco
             # Some parsers require dependencies to do their job.
             def dependencies(**value)
               @dependencies ||= {}
-              return @dependencies.merge({
-                required_attrs: @active_when_attrs
-              }) unless !value.empty?
+
+              if value.empty?
+                return @dependencies.merge({
+                  required_attrs: @active_when_attrs
+                })
+              end
+
               raise "Expected Hash. Given: '#{value.class}'" unless value.is_a?(Hash)
               @dependencies.merge!(value)
             end
@@ -70,7 +76,7 @@ module Eco
             # Helper to build the `active_when` condition.
             def active_when_any(*attrs)
               @active_when_attrs = RequiredAttrs.new(attribute, :any, attrs)
-              @active_when = Proc.new do |source_data|
+              @active_when = proc do |source_data|
                 keys = data_keys(source_data)
                 attrs.any? {|key| keys.include?(key)}
               end
@@ -79,7 +85,7 @@ module Eco
             # Helper to build the `active_when` condition.
             def active_when_all(*attrs)
               @active_when_attrs = RequiredAttrs.new(attribute, :all, attrs)
-              @active_when = Proc.new do |source_data|
+              @active_when = proc do |source_data|
                 keys = data_keys(source_data)
                 attrs.all? {|key| keys.include?(key)}
               end
@@ -88,40 +94,46 @@ module Eco
             private
 
             # Helper to obtain the current internal named attributes of the data
-            # @param source_data [Array<String>, Hash] if `Array` those are already the `keys`, if `Hash` it gets the `keys`
+            # @param source_data [Array<String>, Hash] if `Array` those
+            #   are already the `keys`, if `Hash` it gets the `keys`
             # @return [Array<String>] `keys` of `source_data`
             def data_keys(source_data)
               case source_data
               when Array
-                keys = source_data
+                source_data
               when Hash
-                keys = source_data.keys
+                source_data.keys
               else
-                keys = []
+                []
               end
             end
           end
 
           inheritable_class_vars :attribute, :parsing_phase, :serializing_phase
 
-          def initialize(person_parser)
-            raise "Expected Eco::API::Common::People::PersonParser. Given #{policies.class}" unless person_parser.is_a?(Eco::API::Common::People::PersonParser)
-            person_parser.define_attribute(self.attribute, dependencies: self.class.dependencies) do |attr_parser|
+          def initialize(person_parser) # rubocop:disable Lint/MissingSuper
+            msg = "Expected Eco::API::Common::People::PersonParser. Given #{person_parser.class}"
+            raise msg unless person_parser.is_a?(Eco::API::Common::People::PersonParser)
+
+            person_parser.define_attribute(attribute, dependencies: self.class.dependencies) do |attr_parser|
               _define_parser(attr_parser)
               _define_serializer(attr_parser)
             end
           end
 
           # @param data [Hash] all the person data at the specified `parsing_phase`:
-          #   - when `:internal`: the parser will receive external types (i.e. String with '|' delimiters instead of an Array).
-          #   - when `:final`: the parser will receive the typed values (i.e. Array instread of String with '|' delimiters).
+          #   - when `:internal`: the parser will receive external types
+          #     (i.e. String with '|' delimiters instead of an Array).
+          #   - when `:final`: the parser will receive the typed values
+          #     (i.e. Array instread of String with '|' delimiters).
           # @param deps [Hash] the merged dependencies (default to the class object and when calling the parser).
-          def parser(data, deps)
+          def parser(_data, _deps)
             raise "You should implement this method"
           end
 
           # @param data [Hash, Ecoportal::API::V1::Person] all the person data at the specified `serializing_phase`:
-          #   - when `:internal`: it will receive a `Hash` with the **internal values** but the types already serialized to `String`.
+          #   - when `:internal`: it will receive a `Hash` with the **internal values** but the types already serialized
+          #     to `String`.
           #   - when `:final`: it will receive a `Hash` with the **internal values** and **types**.
           #   - when `:person`: it will receive the `person` object.
           # @param deps [Hash] the merged dependencies (default to the class object and when calling the parser).
@@ -137,16 +149,26 @@ module Eco
           private
 
           def _define_parser(attr_parser)
-            if active_when = self.class.active_when
-              attr_parser.def_parser(self.class.parsing_phase, active_when: active_when, &self.method(:parser))
+            if (active_when = self.class.active_when)
+              attr_parser.def_parser(
+                self.class.parsing_phase,
+                active_when: active_when,
+                &method(:parser)
+              )
             else
-              attr_parser.def_parser(self.class.parsing_phase, &self.method(:parser))
+              attr_parser.def_parser(
+                self.class.parsing_phase,
+                &method(:parser)
+              )
             end
           end
 
           def _define_serializer(attr_parser)
             return unless respond_to?(:serializer, true)
-            attr_parser.def_serializer(self.class.serializing_phase, &self.method(:serializer))
+            attr_parser.def_serializer(
+              self.class.serializing_phase,
+              &method(:serializer)
+            )
           end
         end
       end

data/lib/eco/api/common/loaders/policy.rb

@@ -3,9 +3,11 @@ module Eco
     module Common
       module Loaders
         class Policy < Eco::API::Common::Loaders::CaseBase
-          def initialize(policies)
-            raise "Expected Eco::API::Policies. Given #{policies.class}" unless policies.is_a?(Eco::API::Policies)
-            policies.define(self.name, &self.method(:main))
+          def initialize(policies) # rubocop:disable Lint/MissingSuper
+            msg = "Expected Eco::API::Policies. Given #{policies.class}"
+            raise msg unless policies.is_a?(Eco::API::Policies)
+
+            policies.define(name, &method(:main))
           end
 
           # @param people [Eco::API::Organization::People] the people in the queue of the current `job`
@@ -13,7 +15,7 @@ module Eco
           # @param options [Hash] the options that modify the case behaviour or bring some dependencies.
           # @param policy [Eco::API::Policies::Policy] the `policy` instance object.
           # @param job [Eco::API::Session::Batch::Job] the `Batch::Job` that these `people` belong to the queue thereof.
-          def main(people, session, options, policy, job)
+          def main(people, session, options, policy, job) # rubocop:disable Lint/UnusedMethodArgument
             raise "You should implement this method"
           end
         end

data/lib/eco/api/common/loaders/use_case.rb

@@ -7,7 +7,9 @@ module Eco
             # @return [Symbol] the `type` of usecase (i.e. `:sync`, `:transform`, `:import`, `:other`)
             def type(value = nil)
               unless value
-                return @type || raise("You should specify a type of case [:sync, :transform, :import, :other] for #{self}")
+                msg  = "You should specify a type of case "
+                msg << "[:sync, :transform, :import, :other] for #{self}"
+                return @type || (raise msg)
               end
               @type = value
             end
@@ -18,13 +20,15 @@ module Eco
 
             def cli(cli_class = nil)
               if cli_class.is_a?(Class)
-                raise ArgumentError, "cli_class should inherit from Eco::API::UseCases::Cli" unless cli_class < Eco::API::UseCases::Cli
+                msg = "cli_class should inherit from Eco::API::UseCases::Cli"
+                raise ArgumentError, msg unless cli_class < Eco::API::UseCases::Cli
+
                 @cli = cli_class
               elsif cli_class.nil?
                 return @cli if instance_variable_defined?(:@cli) && !@cli.nil?
                 # try to see if it's namespaced after the use case it provisions cli integration
                 begin
-                  try_class = [self.to_s, 'Cli'].join('::')
+                  try_class = [to_s, 'Cli'].join('::')
                   @cli = Kernel.const_get(try_class)
                 rescue NameError
                   nil
@@ -37,9 +41,11 @@ module Eco
 
           inheritable_class_vars :type, :cli
 
-          def initialize(usecases)
-            raise "Expected Eco::API::UseCases. Given #{usecases.class}" unless usecases.is_a?(Eco::API::UseCases)
-            usecases.define(self.name, type: self.type, &self.method(:main))
+          def initialize(usecases) # rubocop:disable Lint/MissingSuper
+            msg = "Expected Eco::API::UseCases. Given #{usecases.class}"
+            raise msg unless usecases.is_a?(Eco::API::UseCases)
+
+            usecases.define(name, type: type, &method(:main))
           end
 
           # The parameters of this method will depend on the `type` of usecase.
@@ -48,7 +54,7 @@ module Eco
           # @param session [Eco::API::Session] the current session where the usecase kicks in.
           # @param options [Hash] the options that modify the case behaviour or bring some dependencies.
           # @param usecase [Eco::API::Policies::Policy] the `usecase` instance object.
-          def main(entries, people, session, options, usecase)
+          def main(entries, people, session, options, usecase) # rubocop:disable Lint/UnusedMethodArgument
             raise "You should implement this method"
           end
 

data/lib/eco/api/common/people/base_parser.rb

@@ -2,7 +2,6 @@ module Eco
   module API
     module Common
       module People
-
         # @example Example of usage:
         #  class ExampleParser < Eco::API::Common::People::BaseParser
         #    def process
@@ -26,7 +25,6 @@ module Eco
         # Helper class to inherit from to ease the definition of attribute parsers in a `PersonParser` object,
         # mostly used in for configuration loading.
         class BaseParser
-
           # @param parsers [Eco::API::Common::People::PersonParser] set of attribute parsers/serialisers.
           # @param options [Hash] keyword arguments to be used in the `process` method of the child class.
           def initialize(parsers, **options)