eco-helpers 2.6.4 → 2.7.0

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

@@ -5,9 +5,9 @@ module Eco
         # @attr_reader direct_attrs [Array<String>] only those internal attributes present in the person entry that do **not** have an internal/external name mapping.
         class PersonEntryAttributeMapper
           DEBUG = false
-          @@cached_warnings = {}
+          @@cached_warnings = {} # rubocop:disable Style/ClassVars
 
-          attr_reader :aliased_attrs, :direct_attrs
+          attr_reader :direct_attrs
 
           # Helper class tied to `PersonEntry` that allows to track which attributes of a person entry are present
           # and how they should be mapped between internal and external names if applicable.
@@ -15,14 +15,21 @@ module Eco
           # @note
           #   - if `data` is a `Person` object, its behaviour is `serialise`.
           #   - if `data` is **not** a `Person` object, it does a `parse`.
-          #   - currently **in rework**, so there may be subtle differences that make it temporarily unstable (yet it is reliable).
-          # @param data [Hash, Ecoportal::API::V1::Person] `Person` object to be serialized or hashed entry to be parsed (note: `CSV::Row` is accepted).
-          # @param person_parser [Common::People::PersonParser]  parser/serializer of person attributes (it contains a set of attribute parsers).
-          # @param attr_map [Eco::Data::Mapper] mapper to translate attribute names from _external_ to _internal_ names and _vice versa_.
+          #   - currently **in rework**, so there may be subtle differences that make it
+          #     temporarily unstable (yet it is reliable).
+          # @param data [Hash, Ecoportal::API::V1::Person] `Person` object to
+          #   be serialized or hashed entry to be parsed (note: `CSV::Row` is accepted).
+          # @param person_parser [Common::People::PersonParser]  parser/serializer
+          #   of person attributes (it contains a set of attribute parsers).
+          # @param attr_map [Eco::Data::Mapper] mapper to translate attribute names
+          #   from _external_ to _internal_ names and _vice versa_.
           # @param logger [Common::Session::Logger, ::Logger] object to manage logs.
           def initialize(data, person_parser:, attr_map:, logger: ::Logger.new(IO::NULL))
-            raise "Constructor needs a PersonParser. Given: #{parser}" if !person_parser.is_a?(Eco::API::Common::People::PersonParser)
-            raise "Expecting Mapper object. Given: #{attr_map}" if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
+            msg = "Constructor needs a PersonParser. Given: #{person_parser.class}"
+            raise ArgumentError, msg unless person_parser.is_a?(Eco::API::Common::People::PersonParser)
+
+            msg = "Expecting Mapper object. Given: #{attr_map.class}"
+            raise ArgumentError, msg if attr_map && !attr_map.is_a?(Eco::Data::Mapper)
 
             @source         = data
             @person_parser  = person_parser
@@ -30,15 +37,17 @@ module Eco
             @logger         = logger
 
             if parsing?
-              @external_entry   = data
+              @external_entry = data
             else  # SERIALIZING
-              @person          = data
+              @person = data
             end
           end
 
-          # @return [Array<String>] only those internal attributes present in the person entry that have an internal/external name mapping.
+          # @return [Array<String>] only those internal attributes
+          #   present in the person entry that have an internal/external
+          #   name mapping.
           def aliased_attrs
-            return @aliased_attrs unless !@aliased_attrs
+            return @aliased_attrs if @aliased_attrs
             if parsing?
               init_attr_trackers
             else
@@ -52,16 +61,14 @@ module Eco
             return @internal_attrs unless data || !@internal_attrs
             if parsing?
               init_attr_trackers unless @internal_attrs
-              if data
-                return data.keys & @person_parser.all_model_attrs
-              end
+
+              return data.keys & @person_parser.all_model_attrs if data
             else
               @internal_attrs = @person_parser.all_model_attrs
             end
             @internal_attrs
           end
 
-
           # @return [Array<String>] all the attrs that are present in the person entry.
           def all_model_attrs(data = nil)
             core_attrs(data) | account_attrs(data) | details_attrs(data)
@@ -115,7 +122,7 @@ module Eco
           def to_internal(value)
             # TODO: check PersonEntry#to_internal and #to_external in init_attr_trackers
             # => when attr_map is avoided, it doesn't work as it should
-            return value if !@attr_map
+            return value unless @attr_map
             attr = value
             case value
             when Array
@@ -123,17 +130,20 @@ module Eco
                 to_internal(v)
               end.compact
             when String
-              case
-              when @attr_map.external?(value)
+              if @attr_map.external?(value)
                 attr = @attr_map.to_internal(value)
-              when @attr_map.external?(value.strip)
+              elsif @attr_map.external?(value.strip)
                 unless cached_warning("external", "spaces", value)
-                  logger.warn("The external person field name '#{value}' contains additional spaces in the reference file")
+                  msg  = "The external person field name '#{value}' contains "
+                  msg << "additional spaces in the reference file"
+                  logger.warn(msg)
                 end
                 attr = @attr_map.to_internal(value.strip)
-              when @attr_map.internal?(value) || @attr_map.internal?(value.strip) || @attr_map.internal?(value.strip.downcase)
+              elsif [value, value.strip, value.strip.downcase].any? {|val| @attr_map.internal?(val)}
                 unless cached_warning("external", "reversed", value)
-                  logger.info("The mapper [external, internal] attribute names may be declared reversedly for EXTERNAL attribute: '#{value}'")
+                  msg  = "The mapper [external, internal] attribute names "
+                  msg << "may be declared reversedly for EXTERNAL attribute: '#{value}'"
+                  logger.info(msg)
                 end
               end
             end
@@ -154,7 +164,7 @@ module Eco
           # @param value [String, Array<String>] value(s) to be translated or aliased into external ones.
           # @return [String, nil, Array<String] the external name(s) of `value`.
           def to_external(value)
-            return value if !@attr_map
+            return value unless @attr_map
             attr = value
             case value
             when Array
@@ -162,17 +172,21 @@ module Eco
                 to_external(v)
               end.compact
             when String
-              case
-              when @attr_map.internal?(value)
+              if @attr_map.internal?(value)
                 attr = @attr_map.to_external(value)
-              when @attr_map.internal?(value.strip)
+              elsif @attr_map.internal?(value.strip)
                 unless cached_warning("internal", "spaces", value)
-                  logger.warn("The internal person field name '#{value}' contains additional spaces in the reference file")
+                  msg  = "The internal person field name '#{value}' contains "
+                  msg << "additional spaces in the reference file"
+                  logger.warn(msg)
                 end
                 attr = @attr_map.to_external(value.strip)
-              when @attr_map.external?(value) || @attr_map.external?(value.strip) || @attr_map.external?(value.strip.downcase)
+              elsif [value, value.strip, value.strip.downcase].any? {|val| @attr_map.external?(val)}
                 unless cached_warning("internal", "reversed", value)
-                  logger.info("The mapper [external, internal] attribute names may be declared reversedly for INTERNAL attribute: '#{value}'")
+                  msg  = "The mapper [external, internal] attribute names "
+                  msg << "may be declared reversedly for "
+                  msg << "INTERNAL attribute: '#{value}'"
+                  logger.info(msg)
                 end
               end
             end
@@ -185,22 +199,24 @@ module Eco
 
           # Whether the maps include this `attr` as mapped to itself
           def self_mapped_attr?(attr)
-            return false if !@attr_map
+            return false unless @attr_map
             @attr_map.self_mapped?(attr)
           end
 
           # Whether the maps include this `attr` as mapped from to some other or itself
           def external_attr?(attr)
-            return false if !@attr_map
+            return false unless @attr_map
             @attr_map.external?(attr)
           end
 
           # when parsing:
-          def init_attr_trackers
+          def init_attr_trackers # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
             # (def) all internal attributes we can expect
             def_all_attrs     = @person_parser.all_model_attrs
             # (def) internal attrs with no aliasing nor parser definition (expected to be direct)
-            def_unlinked      = @person_parser.undefined_model_attrs.select { |attr| !to_external(attr) }
+            def_unlinked      = @person_parser.undefined_model_attrs.reject do |attr|
+              to_external(attr)
+            end
 
             debug(
               def_unlinked,
@@ -208,7 +224,7 @@ module Eco
             )
 
             # (data) data attributes (actual attributes of the entry)
-            data_attrs        = attributes(@external_entry)
+            data_attrs              = attributes(@external_entry)
             # (data) attributes of the data that COULD come directly as internal attribute names
             # => WARNING: this includes ext direct attrs that may be aliased to other int attrs
             data_direct_attrs_raw   = data_attrs & def_all_attrs
@@ -223,7 +239,7 @@ module Eco
 
             debug(
               data_direct_attrs,
-              "(data_direct_attrs) attributes of the data that come directly as internal attribute names (data_direct_attrs_raw - data_direct_renamed)"
+              "(data_direct_attrs) attributes of the data that come directly as internal attribute names (data_direct_attrs_raw - data_direct_renamed)" # rubocop:disable Layout/LineLength
             )
 
             # (def) configured as alised (int <-> ext attrs) + accept/include int attrs as ext attrs
@@ -233,7 +249,7 @@ module Eco
             # (def) ext attrs of the data's aliasable int attrs (def_int_aliased)
             def_ext_alias       = def_int_aliased.map   { |attr| to_external(attr) }
             # (def) those ext attrs that map to multiple int attrs
-            def_ext_multi_alias = def_ext_alias.detect  { |attr| def_ext_alias.count(attr) > 1 }
+            # def_ext_multi_alias = def_ext_alias.detect  { |attr| def_ext_alias.count(attr) > 1 }
             # (def) those ext attrs that are direct, mapt to themselves and some other
 
 
@@ -267,7 +283,7 @@ module Eco
 
             debug(
               def_int_aliased,
-              "(def_int_aliased) aliasable int attrs of the input data (excludes int attrs direct as ext attrs that got renamed)"
+              "(def_int_aliased) aliasable int attrs of the input data (excludes int attrs direct as ext attrs that got renamed)" # rubocop:disable Layout/LineLength
             )
 
             debug(
@@ -277,7 +293,7 @@ module Eco
 
             debug(
               data_def_int_aliased,
-              "(data_def_int_aliased) int attrs that come aliased in the current data ((def_int_aliased - data_direct_attrs) | data_direct_self_mapped)"
+              "(data_def_int_aliased) int attrs that come aliased in the current data ((def_int_aliased - data_direct_attrs) | data_direct_self_mapped)" # rubocop:disable Layout/LineLength
             )
 
             debug(
@@ -287,16 +303,16 @@ module Eco
 
             debug(
               aliased_attrs,
-              "(aliased_attrs) all internal attributes that come aliased, with given the entry (data_def_int_aliased | data_vi_int_aliased)"
+              "(aliased_attrs) all internal attributes that come aliased, with given the entry (data_def_int_aliased | data_vi_int_aliased)" # rubocop:disable Layout/LineLength
             )
 
             # (data) all those ext attrs present that will require aliasing
-            #data_ext_alias_all   = data_def_ext_alias   + data_vi_ext_alias
-            data_ext_alias_all   = data_ext_alias | data_vi_ext_alias
+            #data_ext_alias_all = data_def_ext_alias   + data_vi_ext_alias
+            data_ext_alias_all = data_ext_alias | data_vi_ext_alias
 
             debug(
               data_ext_alias_all,
-              "(data_ext_alias_all) all those ext attrs present that will require aliasing (data_ext_alias | data_vi_ext_alias)"
+              "(data_ext_alias_all) all those ext attrs present that will require aliasing (data_ext_alias | data_vi_ext_alias)" # rubocop:disable Layout/LineLength
             )
 
             # those that are direct external to internal:
@@ -343,7 +359,7 @@ module Eco
           def cached_warning(*args)
             unless exists = !!@@cached_warnings.dig(*args)
               args.reduce(@@cached_warnings) do |cache, level|
-                cache[level] = {} if !cache.key?(level)
+                cache[level] = {} unless cache.key?(level)
                 cache[level]
               end
             end

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

@@ -2,33 +2,44 @@ module Eco
   module API
     module Common
       module People
-
         # Helper factory to build `Ecoportal::API::V1::Person` or `Ecoportal::API::Internal::Person` objects
         # @attr_reader schema [Ecoportal::API::V1::PersonSchema] person schema to be used in this person factory
         # @attr_reader schema_attrs [Array<String>] _inernal names_ of the schema fields/attributes
         class PersonFactory
-
           attr_reader :schema, :schema_attrs
 
           def initialize(person: nil, schema: {}, account: {}, modifier: Common::People::PersonModifier.new)
-            @modifier = Common::People::PersonModifier.new(modifier)
-            @person  = person
-            @account = account
-            @schema  = schema
-            @schema_attrs = @schema&.fields&.map { |fld| fld.alt_id }
+            @modifier     = Common::People::PersonModifier.new(modifier)
+            @person       = person
+            @account      = account
+            @schema       = schema
+            @schema_attrs = @schema&.fields&.map(&:alt_id)
           end
 
           def new(person: nil)
             in_raw_modifier = Common::People::PersonModifier.new.no_details
-            return PersonFactory.new(person: person, schema: @schema, modifier: in_raw_modifier).new unless !person
+
+            if person
+              return PersonFactory.new(
+                person:   person,
+                schema:   @schema,
+                modifier: in_raw_modifier
+              ).new
+            end
+
             person = klass.new(person_hash(@person))
             person.account = account_hash(@account) if @modifier.add_account? && @modifier.internal?
             person.add_details(@schema) unless @modifier.no_details?
             person
           end
 
-          def new_contact(schema)
-            factory = self.class.new(@modifier.reset_account, person: @person, schema: @schema, account: @account)
+          def new_contact(schema = @schema)
+            factory = self.class.new(
+              @modifier.reset_account,
+              person:  @person,
+              schema:  schema,
+              account: @account
+            )
             factory.new
           end
 
@@ -37,7 +48,7 @@ module Eco
           end
 
           def schema_id
-            nil if !@schema
+            nil unless @schema
             @schema['schema_id'] || @schema['id']
           end
 
@@ -53,19 +64,20 @@ module Eco
 
           def new_hash(modifier)
             modifier = Common::People::PersonModifier.new(modifier)
-            doc = person_hash(@person)
+            doc      = person_hash(@person)
             doc = add_account(doc, @account) if modifier.add_account? && modifier.internal?
-            doc = add_details(doc, @schema) unless modifier.no_details?
+            doc = add_details(doc, @schema)  unless modifier.no_details?
+            doc
           end
 
           def add_details(doc, details)
-            return nil if !doc
+            return nil unless doc
             doc_det = details_hash(details)
             doc.merge({ "details" => doc_det })
           end
 
           def add_account(doc, account)
-            return nil if !doc
+            return nil unless doc
             doc_acc = account_hash(account)
             doc.merge({ "account" => doc_acc })
           end
@@ -85,10 +97,8 @@ module Eco
 
           def details_hash(details)
             case details
-            when Ecoportal::API::V1::PersonDetails
+            when Ecoportal::API::V1::PersonDetails, Ecoportal::API::V1::PersonSchema
               doc = JSON.parse(details.doc.to_json)
-            when Ecoportal::API::V1::PersonSchema
-              doc =JSON.parse(details.doc.to_json)
             when Hash
               doc = JSON.parse(details.to_json)
               doc = doc["details"] if doc.key?("details")
@@ -100,17 +110,15 @@ module Eco
           end
 
           def account_hash(account)
-            case
-            when account.is_a?(Ecoportal::API::Internal::Account)
+            if account.is_a?(Ecoportal::API::Internal::Account)
               JSON.parse(account.doc.to_json)
-            when account.is_a?(Hash)
+            elsif account.is_a?(Hash)
               doc = JSON.parse(account.to_json)
               doc["account"] if doc.key?("account")
             else
               {}
             end
           end
-
         end
       end
     end

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

@@ -3,24 +3,23 @@ module Eco
     module Common
       module People
         class PersonModifier < Eco::Language::Models::Modifier
+          WITH_DETAILS = %i[contact details with_details schema with_schema].freeze
+          NO_DETAILS   = %i[no_details only_account].freeze
 
-          WITH_DETAILS = [:contact, :details, :with_details, :schema, :with_schema]
-          NO_DETAILS   = [:no_details, :only_account]
+          WITH_ACCOUNT = %i[user account with_account].freeze
+          NO_ACCOUNT   = %i[no_account only_details].freeze
 
-          WITH_ACCOUNT = [:user, :account, :with_account]
-          NO_ACCOUNT   = [:no_account, :only_details]
-
-          INTERNAL_PERSON = [:internal, :v0]
-          EXTERNAL_PERSON = [:external, :v1]
+          INTERNAL_PERSON = %i[internal v0].freeze
+          EXTERNAL_PERSON = %i[external v1].freeze
 
           def reset_add_account
-            self < self.mode - (WITH_ACCOUNT | NO_ACCOUNT)
+            self < mode - (WITH_ACCOUNT | NO_ACCOUNT)
           end
 
           def no_details
-            self.push(:no_details)
+            push(:no_details)
           end
-          
+
           def add_account?
             mode.any? { |m| WITH_ACCOUNT.include?(m) }
           end
@@ -49,11 +48,10 @@ module Eco
           protected
 
           def resolve_mode
-            modifiers = self.to_a
+            modifiers = to_a
             modifiers = resolve(modifiers, WITH_DETAILS | NO_DETAILS)
             modifiers = resolve(modifiers, WITH_ACCOUNT | NO_ACCOUNT)
-            modifiers = resolve(modifiers, INTERNAL_PERSON | EXTERNAL_PERSON)
-            modifiers
+            resolve(modifiers, INTERNAL_PERSON | EXTERNAL_PERSON)
           end
         end
       end