eco-helpers 3.0.29 → 3.0.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48e3cb15eee9eccde5ed9781dbff0ebcf811d26b1a7f23f503e3de733b60c19b
-  data.tar.gz: b4a84a5c1b4496706292044964256d80728f7dadabc975937306fa2f08ae29d8
+  metadata.gz: cc3166aa570a24f55a90822a79ad103419cbbd176677a5f17fe3ef8a27553cf6
+  data.tar.gz: f3418aa7bd4e8c645b60eeb839038a03da00fb4328a6acd63bb1500dfe18cfb8
 SHA512:
-  metadata.gz: bd7335d81867d2d954a692e071ed3ca42b9c1510d8ef166a3eff0ec317e9254d4bf42a319dadb0a894c8689808ac55769dcdb6687124457e575c38c134fc70ba
-  data.tar.gz: 4364f5451f67f91228e27ad40daf10af8c2db1b99d907be9cdb84b983bb5e9f274dfddc13be174a1bed2ca4dd7c8ee42b4ffec23eaeba3ae05bae761ed5fe223
+  metadata.gz: 3ca74dcfcb34cc4b252c5613fcf3bf786eb85435920fae73b3ef24e293a6ce11f96698ff0ea7f16cd57e023ce9feee613eb2f8cb44e2352b501150098a6fc0cb
+  data.tar.gz: ad2f68c81259897a21267bbc914b6c79dda294191ce6eb9d293c080685be0bf829883b6a98c670e167602379a9af178bde80ec82f9fc0c390d48e801b7e96758

data/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 All notable changes to this project will be documented in this file.
 
-## [3.0.30] - 2025-03-xx
+## [3.0.32] - 2025-04-xx
 
 ### Added
 
@@ -10,6 +10,41 @@ All notable changes to this project will be documented in this file.
 
 ### Fixed
 
+## [3.0.31] - 2025-04-xx
+
+### Added
+
+### Changed
+
+- upgraded `ecoportal-api-gem`
+
+### Fixed
+
+- `Eco::API::Common::People::PersonEntry#_parse_type`
+  - During a refactor the line that parses schema details fields that are `multiple` got removed. **Added** this parsing back in.
+- `Eco::Data::Files#folder_files`
+  - prevent `nil` error
+- Message of `Sftp` moving file to.
+
+## [3.0.30] - 2025-04-03
+
+### Added
+
+- `Eco::API::Session::Config#locations_mapper`
+  - Added named argument `insensitive`
+- `Eco::API::Common::People::PersonEntry#entry` shortcut, to obtain the data as is at a certain stage of the parsing process.
+- `Eco::API::Common::People::Entries#export` **added** `parsing_phase` named argument to specify the data of what parsing stage should be used to generated the CSV.
+- `-entries-to-csv` case
+  - added `-phase` option
+
+### Changed
+
+- **Moved** `EntriesToCsv` to `Default::Utils` space
+
+### Fixed
+
+- `SCR.get_file` check specified file existence, if `filename` provided, rather than if `required`.
+
 ## [3.0.29] - 2025-03-31
 
 ### Added

data/eco-helpers.gemspec

@@ -41,7 +41,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'bcrypt_pbkdf',  '~> 1.0'
   spec.add_dependency 'docx',          '>= 0.8.0', '< 0.9'
   spec.add_dependency 'dotenv',        '~> 3'
-  spec.add_dependency 'ecoportal-api',         '~> 0.10', '>= 0.10.9'
+  spec.add_dependency 'ecoportal-api',         '~> 0.10', '>= 0.10.10'
   spec.add_dependency 'ecoportal-api-graphql', '~> 0.4',  '>= 0.4.5'
   spec.add_dependency 'ecoportal-api-v2',      '~> 2.0',  '>= 2.0.16'
   spec.add_dependency 'ed25519',       '~> 1.2'

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

@@ -153,17 +153,19 @@ module Eco
             newFrom to_a - discarded
           end
 
-          # TODO: it should rather use the the people-to-csv case somehow
+          # @todo could it somehow rather use the people-to-csv case?
           # Helper to dump the entries into a CSV
           # @param filename [String] the destination file
-          def export(filename)
+          # @param parsing_phase [Symbol] data as per specific parsing stage.
+          def export(filename, parsing_phase: :internal)
             header = each_with_object([]) do |entry, hds|
-              hds.push(*entry.internal_entry.keys).uniq!
+              hds.push(*entry.entry(parsing_phase).keys).uniq!
             end
+
             CSV.open(filename, 'w') do |csv|
               csv << header
               each do |entry|
-                csv << entry.internal_entry.values_at(*header)
+                csv << entry.entry(parsing_phase).values_at(*header)
               end
             end
           end

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

@@ -2,13 +2,13 @@ module Eco
   module API
     module Common
       module People
-        # TODO: EntryFactory should suppport multiple schemas itself
+        # @todo EntryFactory should suppport multiple schemas itself
         #   (rather that being done on `Session`)
         # => currently, it's through session.entry_factory(schema: id),
         #   but this is wrong
         # => This way, Entries and PersonEntry will be able to refer to attr_map
         #   and person_parser linked to schema_id
-        # => "schema_id" should be an optional column in the input file,
+        # => 'schema_id' should be an optional column in the input file,
         #   or parsable via a custom parser to scope the schema
         # Helper factory class to generate entries (input entries).
         # @attr_reader schema [Ecoportal::API::V1::PersonSchema] person schema to
@@ -26,7 +26,7 @@ module Eco
           #   set of attribute, type and format parsers/serializers.
           # @param attr_map [nil, Eco::Data::Mapper] attribute names mapper
           #   to translate external names into internal ones and _vice versa_.
-          def initialize(e, schema:, person_parser: nil, default_parser: nil, attr_map: nil)
+          def initialize(e, schema:, person_parser: nil, default_parser: nil, attr_map: nil) # rubocop:disable Naming/MethodParameterName
             super(e)
 
             msg = "Constructor needs a PersonSchema. Given: #{schema.class}"
@@ -42,12 +42,18 @@ module Eco
             @source_person_parser = person_parser
 
             # load default parser + custom parsers
-            @default_parser = default_parser&.new(schema: @schema) || Eco::API::Common::People::DefaultParsers.new(schema: @schema)
+            @default_parser =
+              default_parser&.new(schema: @schema) ||
+              Eco::API::Common::People::DefaultParsers.new(schema: @schema)
+
             base_parser = @default_parser.merge(@source_person_parser)
+
             # new parser with linked schema
-            @person_parser = @source_person_parser.new(schema: @schema).merge(base_parser)
+            @person_parser = @source_person_parser.
+              new(schema: @schema).
+              merge(base_parser)
             @person_parser_patch_version = @source_person_parser.patch_version
-            @attr_map = attr_map
+            @attr_map                    = attr_map
           end
 
           def newFactory(schema: nil) # rubocop:disable Naming/MethodName
@@ -60,18 +66,22 @@ module Eco
             )
           end
 
-          # provides with a Eco::API::Common::People::PersonParser object (collection of attribute parsers)
-          # @note if the custom person parser has changed, it updates the copy of this EntryFactory instance
-          # @return [Eco::API::Common::People::PersonParser] set of attribute, type and format parsers/serializers.
+          # Provides with a Eco::API::Common::People::PersonParser object
+          # (collection of attribute parsers)
+          # @note if the custom person parser has changed, it updates the copy of
+          #   this EntryFactory instance
+          # @return [Eco::API::Common::People::PersonParser] set of attribute,
+          #   type and format parsers/serializers.
           def person_parser
             if @person_parser_patch_version < @source_person_parser.patch_version
               @person_parser.merge(@source_person_parser)
               @person_parser_patch_version = @source_person_parser.patch_version
             end
+
             @person_parser
           end
 
-          # key method to generate objects of `PersonEntry` that share dependencies
+          # Key method to generate objects of `PersonEntry` that share dependencies
           # via this `EntryFactory` environment.
           # @note this method is necessary to make the factory object work
           #   as a if it was a class `PersonEntry` you can call `new` on.
@@ -97,17 +107,26 @@ module Eco
           #   - if the `format:` you provide is not a `Symbol`.
           #   - if there is no _parser/serializer_ defined for `format:`.
           # @param data [Array<Hash>] data to be parsed. It cannot be used alongside with `file:`
-          # @param file [String] absolute or relative path to the input file. It cannot be used alongside with `data:`.
-          # @param format [Symbol] it must be used when you use the option `file:` (i.e. `:xml`, `:csv`), as it specifies the format of the input `file:`.
+          # @param file [String] absolute or relative path to the input file. It
+          #   cannot be used alongside with `data:`.
+          # @param format [Symbol] it must be used when you use the option `file:`
+          #   (i.e. `:xml`, `:csv`), as it specifies the format of the input `file:`.
           # @param options [Hash] further options.
-          # @option options [String] :encoding optional parameter to read `file:` by expecting certain encoding.
-          # @option options [Boolean] :check_headers signals if the `csv` file headers should be expected.
+          # @option options [String] :encoding optional parameter to read `file:` by
+          #   expecting certain encoding.
+          # @option options [Boolean] :check_headers signals if the `csv` file headers
+          #   should be expected.
           # @return [Eco::API::Common::People::Entries] collection of `Eco::API::Common::People::PersonEntry`.
-          def entries(data: (no_data = true; nil), file: (no_file = true; nil), format: (no_format = true; nil), **options) # rubocop:disable Style/Semicolon
-            msg = "You should at least use data: or file:, but not both"
+          def entries(
+            data:   (no_data = true; nil),   # rubocop:disable Style/Semicolon
+            file:   (no_file = true; nil),   # rubocop:disable Style/Semicolon
+            format: (no_format = true; nil), # rubocop:disable Style/Semicolon
+            **options
+          )
+            msg = 'You should at least use data: or file:, but not both'
             fatal msg if no_data == no_file
 
-            msg = "You must specify a valid format: (symbol) when you use file."
+            msg = 'You must specify a valid format: (symbol) when you use file.'
             fatal msg if file && no_format
 
             msg = "Format should be a Symbol. Given '#{format}'"
@@ -120,25 +139,40 @@ module Eco
             options.merge!(file:     file)     unless no_file
             options.merge!(format:   format)   unless no_format
 
-            Entries.new(to_array_of_hashes(**options), klass: PersonEntry, factory: self)
+            Entries.new(
+              to_array_of_hashes(**options),
+              klass:   PersonEntry,
+              factory: self
+            )
           end
 
-          def to_array_of_hashes(**kargs) # rubocop:disable Metrics/AbcSize
-            content, file, encoding, format = kargs.values_at(:content, :file, :encoding, :format)
+          # Input file format parsing to obtain the final processing model.
+          # @note This only takes care of the file format parsing alone (i.e. csv, json).
+          # @note
+          #   1. The **parsing** of the file happens here.
+          #   2. It also adds a row index (idx column).
+          # @return [Array<Hash>] the parsed content.
+          def to_array_of_hashes(**kargs) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+            content, file, encoding, format = kargs.values_at(
+              :content, :file, :encoding, :format
+            )
 
-            # Support for multiple file
+            # Support for multiple file (iterated self call)
             if file.is_a?(Array)
               return file.each_with_object([]) do |f, out|
                 log(:info) { "Parsing file '#{f}'" }
-                curr = to_array_of_hashes(**kargs.merge(file: f))
+                curr = to_array_of_hashes(**kargs, file: f)
                 out.concat(curr)
               end
             end
 
-            # Get content only when it's not :xls, nor :json
-            # note: even if content was provided, file takes precedence
-            if get_content?(format) && file # rubocop:disable Style/IfUnlessModifier
-              content = get_file_content(file, encoding: encoding)
+            # Get content only when it's not :xls, nor :json (so when is :csv).
+            # @note: even if content was provided, file takes precedence
+            if file && get_content?(format)
+              content = get_file_content(
+                file,
+                encoding: encoding
+              )
             end
 
             case content
@@ -148,15 +182,24 @@ module Eco
               }
               exit(1)
             when String
-              deps = {check_headers: true} if kargs[:check_headers]
-              to_array_of_hashes(content: person_parser.parse(format, content, deps: deps || {}))
+              deps ||= {}
+              deps   = deps.merge(**kargs.slice(:check_headers))
+
+              to_array_of_hashes(
+                content: person_parser.parse(
+                  format,
+                  content,
+                  deps: deps
+                )
+              )
             when Enumerable
               sample = content.to_a.first
+
               case sample
               when Hash, Array, ::CSV::Row
                 Eco::CSV::Table.new(content).to_array_of_hashes
               when NilClass
-                abort("There is NO input data")
+                abort('There is NO input data')
               else
                 abort("Input content 'Array' of '#{sample.class}' is not supported.")
               end
@@ -170,9 +213,10 @@ module Eco
               start_from_two = (format == :csv) || format == :xls
               first_idx      = start_from_two ? 2 : 1
 
+              # add row index column
               out_array.each.with_index(first_idx) do |entry_hash, idx|
-                entry_hash["idx"]         = idx
-                entry_hash["source_file"] = file
+                entry_hash['idx']         = idx
+                entry_hash['source_file'] = file
               end
             end
           end
@@ -189,11 +233,17 @@ module Eco
           #   There must be a parser/serializer defined for it.
           # @param encoding [String] optional parameter to geneate `file:` content by unsing certain encoding.
           # @return [Void].
-          def export(data:, file: "export", format: :csv, encoding: "utf-8", internal_names: false)
+          def export(
+            data:,
+            file:           'export',
+            format:         :csv,
+            encoding:       'utf-8',
+            internal_names: false
+          )
             msg = "data: Expected Eco::API::Organization::People object. Given: #{data.class}"
             fatal msg unless data.is_a?(Eco::API::Organization::People)
 
-            fatal "A file should be specified."                   if file.to_s.strip.empty?
+            fatal 'A file should be specified.'                   if file.to_s.strip.empty?
             fatal "Format should be a Symbol. Given '#{format}'"  if format && !format.is_a?(Symbol)
 
             msg = "There is no parser/serializer for format ':#{format}'"
@@ -202,25 +252,30 @@ module Eco
             run = true
             if self.class.file_exists?(file)
               prompt_user(
-                "Do you want to overwrite it? (Y/n):",
+                'Do you want to overwrite it? (Y/n):',
                 explanation: "The file '#{file}' already exists.",
-                default:     "Y"
+                default:     'Y'
               ) do |response|
-                run = (response == "") || response.upcase.start_with?("Y")
+                run = (response == '') || response.upcase.start_with?('Y')
               end
             end
 
             return unless run
 
-            deps         = {"supervisor_id" => {people: data}}
+            deps         = {'supervisor_id' => {people: data}}
             data_entries = data.map do |person|
               new(person, dependencies: deps).then do |entry|
                 internal_names ? entry.mapped_entry : entry.external_entry
               end
             end
 
-            File.open(file, "w", enconding: encoding) do |fd|
-              fd.write(person_parser.serialize(format, data_entries))
+            File.open(file, 'w', enconding: encoding) do |fd|
+              fd.write(
+                person_parser.serialize(
+                  format,
+                  data_entries
+                )
+              )
             end
           end
 

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

@@ -70,6 +70,24 @@ module Eco
             )
           end
 
+          # @return [Hash] the data as of at that parsing stage.
+          def entry(phase = :external)
+            phase = phase.to_sym
+
+            case phase
+            when :external
+              external_entry
+            when :mapped
+              mapped_entry
+            when :internal
+              internal_entry
+            when :final
+              final_entry
+            else
+              raise ArgumentError, "Unknown phase '#{phase}'"
+            end
+          end
+
           # @note completely serialized entry.
           # @return [Hash] entry `Hash` with **external** attribute names, and values and types thereof.
           def external_entry # rubocop:disable Style/TrivialAccessors
@@ -77,12 +95,15 @@ module Eco
           end
 
           # @note just one step away from being completely parsed (only types parsing pending).
-          # @return [Hash] entry `Hash` with **internal** attribute names and values, but **external** types.
+          # @return [Hash] entry `Hash` with **internal** attribute names and values,
+          #   but **external** types.
           def internal_entry # rubocop:disable Style/TrivialAccessors
             @internal_entry
           end
 
-          # @return [Hash] entry `Hash` with **internal** attribute names, but **external** types and values.
+          # @note at this stage, only the header names have been converted/transformed.
+          # @return [Hash] entry `Hash` with **internal** attribute names,
+          #   but **external** types and values.
           def mapped_entry # rubocop:disable Style/TrivialAccessors
             @mapped_entry
           end
@@ -204,20 +225,21 @@ module Eco
           # @return [String] string summary of this person identity.
           def identify
             str_id = id ? "id: '#{id}'; " : ''
-            "(row: #{idx}) '#{name}' (#{str_id}ext_id: '#{external_id}'; email: '#{email}')"
+            str  = "(row: #{idx}) '#{name}' "
+            str << "(#{str_id}ext_id: '#{external_id}'; "
+            str << "email: '#{email}')"
+            str
           end
 
           # Provides a reference of this person entry.
           # @return [String] string summary of this person identity.
           def to_s(options)
             options = into_a(options)
-            if options.include?(:identify)
-              identify
-            else
-              final_entry.each.map do |k, v|
-                "'#{k}': '#{v.to_json}'"
-              end.join(' | ')
-            end
+            return identify if options.include?(:identify)
+
+            final_entry.each.map do |k, v|
+              "'#{k}': '#{v.to_json}'"
+            end.join(' | ')
           end
 
           # Setter to fill in all the `core` properties of the `Person` that are present in the `Entry`.
@@ -230,6 +252,7 @@ module Eco
           def set_core(person, exclude: nil)
             scoped_attrs  = @emap.core_attrs(@final_entry) - into_a(exclude)
             scoped_attrs -= ['id']
+
             @final_entry.slice(*scoped_attrs).each do |attr, value|
               set_part(person, attr, value)
             rescue StandardError => e
@@ -248,6 +271,7 @@ module Eco
           def set_account(person, exclude: nil)
             person.account = {} unless person.account
             scoped_attrs = @emap.account_attrs(@final_entry) - into_a(exclude)
+
             @final_entry.slice(*scoped_attrs).each do |attr, value|
               set_part(person.account, attr, value)
             end
@@ -262,6 +286,7 @@ module Eco
           def set_details(person, exclude: nil)
             person.add_details(@person_parser.schema) if !person.details || !person.details.schema_id
             scoped_attrs = @emap.details_attrs(@final_entry) - into_a(exclude)
+
             @final_entry.slice(*scoped_attrs).each do |attr, value|
               set_part(person.details, attr, value)
             end
@@ -272,24 +297,28 @@ module Eco
           # @return [Hash] entry in raw: that with **external** names, values and types.
           def __external_entry(data)
             return data if parsing?
+
             _external_serializing(data)
           end
 
           # @return [Hash] that with **internal** names but **external** values and types.
           def __mapped_entry(data)
             return _mapped_parsing(data) if parsing?
+
             _mapped_serializing(data)
           end
 
           # @return [Hash] that with **internal** names and values, but **external** values and types.
           def __internal_entry(data)
             return _internal_parsing(data) if parsing?
+
             _internal_serializing(data)
           end
 
           # @return [Hash] that with **internal** names, values and types.
           def __final_entry(data)
             return _final_parsing(data) if parsing?
+
             _final_serializing(data)
           end
 
@@ -302,10 +331,11 @@ module Eco
             rest_keys       = mapped_entry.keys - target_attrs
             target_attrs   -= ['send_invites']
             external_entry  = target_attrs.each_with_object({}) do |attr, hash|
-              unless hash.key?(ext_attr = @emap.to_external(attr))
-                hash[ext_attr] = mapped_entry[attr]
-              end
+              next if hash.key?(ext_attr = @emap.to_external(attr))
+
+              hash[ext_attr] = mapped_entry[attr]
             end
+
             merge_missing_attrs(external_entry, mapped_entry.slice(*rest_keys))
           end
 
@@ -317,6 +347,7 @@ module Eco
             mapped_hash = @emap.aliased_attrs.each_with_object({}) do |attr, hash|
               hash[attr] = external_entry[@emap.to_external(attr)]
             end
+
             external_entry.slice(*@emap.direct_attrs).merge(mapped_hash)
           end
 
@@ -327,9 +358,12 @@ module Eco
           # @param internal_entry [Hash] entry with **internal** names and values, but **external** types.
           # @return [Hash] entry with **internal** names and **external** values and types.
           def _mapped_serializing(internal_entry)
-            mapped_hash = internal_entry.merge(_serialize_values(internal_entry, :internal))
+            mapped_hash = internal_entry.merge(
+              _serialize_values(internal_entry, :internal)
+            )
             model_attrs = @person_parser.all_model_attrs - ['send_invites']
             aux_hash    = mapped_hash.slice(*model_attrs)
+
             merge_missing_attrs(aux_hash, mapped_hash)
           end
 
@@ -345,14 +379,19 @@ module Eco
           # @param final_entry [Hash] the entry with all _internal_ (attributes, values and types)
           # @return [Hash] the `internal entry` with the **internal** attributes names and values, but external types.
           def _internal_serializing(final_entry)
-            final_entry        = final_entry.merge(_serialize_values(final_entry, :final))
+            final_entry        = final_entry.merge(
+              _serialize_values(final_entry, :final)
+            )
             core_account       = @person_parser.target_attrs_account + @person_parser.target_attrs_core
+
             core_account_hash  = core_account.reduce({}) do |hash, attr|
               hash.merge(hash_attr(attr, _serialize_type(attr, final_entry[attr])))
             end
+
             details_hash = @person_parser.target_attrs_details.reduce({}) do |hash, attr|
               hash.merge(hash_attr(attr, _serialize_type(attr, final_entry[attr], schema: @person_parser.schema)))
             end
+
             merging(core_account_hash, details_hash) do |internal_entry|
               merge_missing_attrs(internal_entry, final_entry)
             end
@@ -392,21 +431,31 @@ module Eco
             core_hash = @person_parser.target_attrs_core.reduce({}) do |hash, attr|
               hash.merge(hash_attr(attr, get_part(person, attr)))
             end
+
             account_hash = @person_parser.target_attrs_account.reduce({}) do |hash, attr|
               hash.merge(hash_attr(attr, get_part(person.account, attr)))
             end
+
             details_hash = @person_parser.target_attrs_details.reduce({}) do |hash, attr|
               hash.merge(hash_attr(attr, get_part(person.details, attr)))
             end
+
             merging(core_hash, account_hash, details_hash) do |final_entry|
               final_entry['Has account?'] = !person.account.nil?
-              final_entry.merge(_serialize_values(person, :person))
+              final_entry.merge(
+                _serialize_values(person, :person)
+              )
             end
           end
 
           # HELPERS
+
           def _serialize_values(entry, phase = :person)
-            @person_parser.active_attrs(entry, phase, process: :serialize).each_with_object({}) do |attr, hash|
+            @person_parser.active_attrs(
+              entry,
+              phase,
+              process: :serialize
+            ).each_with_object({}) do |attr, hash|
               data        = entry.is_a?(Hash)? entry.merge(hash) : entry
               serial_attr = @person_parser.serialize(attr, data, phase, deps: @deps[attr] || {})
               hash.merge!(hash_attr(attr, serial_attr))
@@ -414,7 +463,10 @@ module Eco
           end
 
           def _parse_values(entry, phase = :internal)
-            @person_parser.active_attrs(entry, phase).each_with_object({}) do |attr, hash|
+            @person_parser.active_attrs(
+              entry,
+              phase
+            ).each_with_object({}) do |attr, hash|
               parsed_attr = @person_parser.parse(attr, entry.merge(hash), phase)
               hash.merge!(hash_attr(attr, parsed_attr))
             end
@@ -423,13 +475,19 @@ module Eco
           # Transforms each **typed** value into its `String` version
           def _serialize_type(attr, value, schema: nil)
             if !!schema
-              unless (field = schema[attr])
-                fatal("Field '#{attr}' does not exist in details of schema: '#{schema.name}'")
-              end
+              msg = "Field '#{attr}' does not exist in details of schema: '#{schema.name}'"
+              fatal(msg) unless (field = schema[attr])
+
               value = @person_parser.serialize(:multiple, value) if field.multiple
+
               if @person_parser.defined?(field.type.to_sym)
-                value = @person_parser.serialize(field.type.to_sym, value, deps: {'attr' => attr})
+                value = @person_parser.serialize(
+                  field.type.to_sym,
+                  value,
+                  deps: {'attr' => attr}
+                )
               end
+
               value
             elsif %w[policy_group_ids filter_tags login_provider_ids starred_ids].include?(attr)
               @person_parser.serialize(:multiple, value)
@@ -446,15 +504,21 @@ module Eco
           def _parse_type(attr, value, schema: nil) # rubocop:disable Metrics/AbcSize
             value = value.strip if value.is_a?(String)
             value = nil         if value.to_s.strip.empty?
+
             if !!schema
-              unless (field = schema[attr])
-                fatal("Field '#{attr}' does not exist in details of schema: '#{schema.name}'")
-              end
+              msg = "Field '#{attr}' does not exist in details of schema: '#{schema.name}'"
+              fatal(msg) unless (field = schema[attr])
+
               value = @person_parser.parse(:multiple, value) if field.multiple
 
               if @person_parser.defined?(field.type.to_sym)
-                value = @person_parser.parse(field.type.to_sym, value, deps: {'attr' => attr})
+                value = @person_parser.parse(
+                  field.type.to_sym,
+                  value,
+                  deps: {'attr' => attr}
+                )
               end
+
               value
             elsif attr == 'email'
               value = value.strip.downcase if value
@@ -480,6 +544,7 @@ module Eco
             merged      = sorted_keys.each_with_object({}) do |k, h|
               h[k] = rev_hash[k]
             end
+
             merged = yield(merged) if block_given?
             merged
           end
@@ -498,6 +563,7 @@ module Eco
 
           def get_part(obj, attr)
             return unless obj
+
             case obj
             when Ecoportal::API::V1::PersonDetails
               #unless field = obj.get_field(attr)
@@ -529,6 +595,7 @@ module Eco
           # @return [Hash] `value` if it was a `Hash`, and `{ attr => value}` otherwise
           def hash_attr(attr, value)
             return value if value.is_a?(Hash)
+
             { attr => value }
           end