eco-helpers 3.0.37 → 3.1.2

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

@@ -6,6 +6,16 @@ module Eco
           DEBUG = false
           include Eco::Language::AuxiliarLogger
 
+          BOOLEAN_ATTRS = %w[
+            freemium accept_eula archived
+          ].freeze
+          MULTI_ATTRS   = %w[
+            policy_group_ids filter_tags login_provider_ids starred_ids
+          ].freeze
+          NUMERIC_ATTRS = %w[
+            subordinates
+          ].freeze
+
           # This class is meant to provide a common interface to access entries of source data that come in
           # different formats.
           # @note
@@ -287,7 +297,9 @@ module Eco
             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|
+            @final_entry.slice(
+              *scoped_attrs
+            ).each do |attr, value|
               set_part(person.details, attr, value)
             end
           end
@@ -327,16 +339,22 @@ module Eco
           # @param mapped_entry [Hash] that with **internal** names but **external** values and types.
           # @return [Hash] with **external** names, values and types.
           def _external_serializing(mapped_entry)
-            target_attrs    = @emap.all_model_attrs | @emap.aliased_attrs
+            target_attrs    =
+              @emap.all_model_attrs |
+              @emap.aliased_attrs
             rest_keys       = mapped_entry.keys - target_attrs
             target_attrs   -= ['send_invites']
+
             external_entry  = target_attrs.each_with_object({}) do |attr, hash|
               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))
+            merge_missing_attrs(
+              external_entry,
+              mapped_entry.slice(*rest_keys)
+            )
           end
 
           # Parsing helper that aliases attribute names (from internal to external names)
@@ -348,7 +366,9 @@ module Eco
               hash[attr] = external_entry[@emap.to_external(attr)]
             end
 
-            external_entry.slice(*@emap.direct_attrs).merge(mapped_hash)
+            external_entry.slice(
+              *@emap.direct_attrs
+            ).merge(mapped_hash)
           end
 
           # Serializing helper that **serializes values** that have a parser/serializer defined.
@@ -364,7 +384,10 @@ module Eco
             model_attrs = @person_parser.all_model_attrs - ['send_invites']
             aux_hash    = mapped_hash.slice(*model_attrs)
 
-            merge_missing_attrs(aux_hash, mapped_hash)
+            merge_missing_attrs(
+              aux_hash,
+              mapped_hash
+            )
           end
 
           # Parsing helper that just **parses the values** that have a parser/serializer defined.
@@ -372,7 +395,9 @@ module Eco
           # @param mapped_entry [Hash] the entry with the _internal attribute_ names but the _external values_.
           # @return [Hash] the `internal entry` with the **internal** attributes names and values.
           def _internal_parsing(mapped_entry)
-            mapped_entry.merge(_parse_values(mapped_entry, :internal))
+            mapped_entry.merge(
+              _parse_values(mapped_entry, :internal)
+            )
           end
 
           # Serializing helper that just creates the _internal entry_ out of a _parsed entry_ (serializes the type).
@@ -382,18 +407,37 @@ module Eco
             final_entry        = final_entry.merge(
               _serialize_values(final_entry, :final)
             )
-            core_account       = @person_parser.target_attrs_account + @person_parser.target_attrs_core
+            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])))
+              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)))
+              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)
+              merge_missing_attrs(
+                internal_entry,
+                final_entry
+              )
             end
           end
 
@@ -403,19 +447,31 @@ module Eco
           #   but the **external** types.
           # @return [Hash] the `parsed entry` with the **internal** final attributes names, values and types.
           def _final_parsing(internal_entry)
-            core_account_attrs = @emap.account_attrs(internal_entry) + @emap.core_attrs(internal_entry)
-            core_account_hash  = internal_entry.slice(*core_account_attrs).each_with_object({}) do |(attr, value), hash|
+            core_account_attrs =
+              @emap.account_attrs(internal_entry) +
+              @emap.core_attrs(internal_entry)
+            core_account_hash  = internal_entry.slice(
+              *core_account_attrs
+            ).each_with_object({}) do |(attr, value), hash|
               hash[attr] = _parse_type(attr, value)
             end
 
             details_attrs     = @emap.details_attrs(internal_entry)
-            details_hash      = internal_entry.slice(*details_attrs).each_with_object({}) do |(attr, value), hash|
+            details_hash      = internal_entry.slice(
+              *details_attrs
+            ).each_with_object({}) do |(attr, value), hash|
               hash[attr] = _parse_type(attr, value, schema: @person_parser.schema)
             end
 
             merging(core_account_hash, details_hash) do |final_entry|
-              final_entry = merge_missing_attrs(final_entry, internal_entry)
-              final_entry.merge(_parse_values(final_entry, :final))
+              final_entry = merge_missing_attrs(
+                final_entry,
+                internal_entry
+              )
+
+              final_entry.merge(
+                _parse_values(final_entry, :final)
+              )
             end
           end
 
@@ -429,15 +485,30 @@ module Eco
           # @return [Hash] the `parsed entry` with the **internal** attributes names and internal typed values.
           def _final_serializing(person)
             core_hash = @person_parser.target_attrs_core.reduce({}) do |hash, attr|
-              hash.merge(hash_attr(attr, get_part(person, 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)))
+              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)))
+              hash.merge(
+                hash_attr(
+                  attr,
+                  get_part(person.details, attr)
+                )
+              )
             end
 
             merging(core_hash, account_hash, details_hash) do |final_entry|
@@ -458,7 +529,9 @@ module Eco
             ).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))
+              hash.merge!(
+                hash_attr(attr, serial_attr)
+              )
             end
           end
 
@@ -468,7 +541,9 @@ module Eco
               phase
             ).each_with_object({}) do |attr, hash|
               parsed_attr = @person_parser.parse(attr, entry.merge(hash), phase)
-              hash.merge!(hash_attr(attr, parsed_attr))
+              hash.merge!(
+                hash_attr(attr, parsed_attr)
+              )
             end
           end
 
@@ -489,11 +564,11 @@ module Eco
               end
 
               value
-            elsif %w[policy_group_ids filter_tags login_provider_ids starred_ids].include?(attr)
+            elsif MULTI_ATTRS.include?(attr)
               @person_parser.serialize(:multiple, value)
-            elsif %w[freemium accept_eula archived].include?(attr)
+            elsif BOOLEAN_ATTRS.include?(attr)
               @person_parser.serialize(:boolean, value)
-            elsif ['subordinates'].include?(attr)
+            elsif NUMERIC_ATTRS.include?(attr)
               @person_parser.serialize(:number, value)
             else
               value
@@ -523,13 +598,13 @@ module Eco
             elsif attr == 'email'
               value = value.strip.downcase if value
               value
-            elsif %w[policy_group_ids filter_tags login_provider_ids starred_ids].include?(attr)
+            elsif MULTI_ATTRS.include?(attr)
               value = @person_parser.parse(:multiple, value)
               value = value.compact.map(&:upcase) if attr == 'filter_tags'
               value
-            elsif %w[freemium accept_eula archived].include?(attr)
+            elsif BOOLEAN_ATTRS.include?(attr)
               @person_parser.parse(:boolean, value)
-            elsif ['subordinates'].include?(attr)
+            elsif NUMERIC_ATTRS.include?(attr)
               @person_parser.parse(:number, value)
             else
               value
@@ -552,7 +627,9 @@ module Eco
           # Adds to `dest_entry` the `keys` it misses from `source_entry`
           def merge_missing_attrs(dest_entry, source_entry)
             keys_rest = source_entry.keys - dest_entry.keys
-            dest_entry.merge(source_entry.slice(*keys_rest))
+            dest_entry.merge(
+              source_entry.slice(*keys_rest)
+            )
           end
 
           def into_a(value)

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

@@ -11,7 +11,7 @@ module Eco
         # @attr_reader all_model_attrs [Array<String>] all the internal
         #   name attributes, including _core_, _account_ and _details_.
         class PersonParser
-          extend Eco::API::Common::ClassAutoLoader
+          extend Eco::Language::Klass::AutoLoader
           autoloads_children_of     'Eco::API::Common::Loaders::Parser'
           autoload_namespace_ignore 'Eco::API'
 
@@ -61,12 +61,14 @@ module Eco
             @patch_version = 0
 
             if schema
-              @schema = Ecoportal::API::Internal::PersonSchema.new(JSON.parse(schema.doc.to_json))
+              @schema = Ecoportal::API::Internal::PersonSchema.new(
+                JSON.parse(schema.doc.to_json)
+              )
               @details_attrs = @schema&.fields&.map(&:alt_id)
             end
 
             @all_model_attrs = CORE_ATTRS + ACCOUNT_ATTRS + @details_attrs
-            self.class.autoload_children(self)
+            self.class.autoload_children!(self)
           end
 
           def patched!
@@ -74,7 +76,9 @@ module Eco
           end
 
           def new(schema: nil)
-            self.class.new(schema: schema || self.schema).merge(self)
+            self.class.new(
+              schema: schema || self.schema
+            ).merge(self)
           end
 
           # @!group selection options of all select attributes
@@ -90,6 +94,7 @@ module Eco
               raise msg unless fld.options&.any?
 
               options_hash = fld.options.to_h { |v| [v.downcase.strip, v] }
+
               [fld.alt_id, options_hash]
             end
           end
@@ -100,7 +105,9 @@ module Eco
 
           # @return [Array<Eco::API::Common::Loaders::Parser::RequiredAttrs>]
           def required_attrs
-            @parsers.values_at(*all_attrs(include_defined_parsers: true)).compact.map(&:required_attrs).compact
+            @parsers.values_at(*all_attrs(
+              include_defined_parsers: true
+            )).compact.map(&:required_attrs).compact
           end
 
           # All the internal name attributes, including _core_, _account_ and _details_.
@@ -165,8 +172,9 @@ module Eco
           #  - the list is sorted according `CORE_ATTRS` + `ACCOUNT_ATTRS` + schema attrs
           # @return [Array<String>] list of all attribute defined parsers in the model.
           def defined_model_attrs
-            defined     = @parsers.keys
-            defined     = (all_model_attrs | defined) & defined
+            defined = @parsers.keys
+            defined = (all_model_attrs | defined) & defined
+
             defined - symbol_keys
           end
 
@@ -247,7 +255,10 @@ module Eco
               raise msg
             end
 
-            Eco::API::Common::People::PersonAttributeParser.new(attr, dependencies: dependencies).tap do |parser|
+            Eco::API::Common::People::PersonAttributeParser.new(
+              attr,
+              dependencies: dependencies
+            ).tap do |parser|
               @parsers[attr] = parser
               definition.call(parser)
             end
@@ -277,8 +288,13 @@ module Eco
             msg = "There is no parser for attribute '#{attr}'"
             raise msg unless self.defined?(attr)
 
-            @parsers[attr].parse(source, phase, dependencies: deps) do |_dkey, dval|
+            @parsers[attr].parse(
+              source,
+              phase,
+              dependencies: deps
+            ) do |_dkey, dval|
               next dval unless dval.is_a?(Proc)
+
               dval.call(self)
             end
           end
@@ -297,8 +313,13 @@ module Eco
             msg = "There is no parser for attribute '#{attr}'"
             raise msg unless self.defined?(attr)
 
-            @parsers[attr].serialize(object, phase, dependencies: deps) do |_dkey, dval|
+            @parsers[attr].serialize(
+              object,
+              phase,
+              dependencies: deps
+            ) do |_dkey, dval|
               next dval unless dval.is_a?(Proc)
+
               dval.call(self)
             end
           end
@@ -308,7 +329,7 @@ module Eco
 
           # @return [Hash] attr-parser pairs with all the defined type and attribute parsers/serializers.
           def to_h
-            self.class.autoload_children(self)
+            self.class.autoload_children!(self)
             @parsers
           end
 
@@ -323,23 +344,36 @@ module Eco
           end
 
           def attr_to_str(attr)
-            attr.is_a?(Symbol)? ":#{attr}" : attr.to_s
+            return attr.to_s unless attr.is_a?(Symbol)
+
+            ":#{attr}"
           end
 
           def valid?(attr)
-            valid_attr?(attr) || valid_type?(attr) || valid_format?(attr)
+            return true if valid_attr?(attr)
+            return true if valid_type?(attr)
+            return true if valid_format?(attr)
+
+            false
           end
 
           def valid_attr?(attr)
-            attr.is_a?(String) && (!@schema || @all_model_attrs.include?(attr))
+            return false unless attr.is_a?(String)
+            return true  unless @schema
+
+            @all_model_attrs.include?(attr)
           end
 
           def valid_type?(attr)
-            attr.is_a?(Symbol) && TYPE.include?(attr)
+            return false unless attr.is_a?(Symbol)
+
+            TYPE.include?(attr)
           end
 
           def valid_format?(attr)
-            attr.is_a?(Symbol) && FORMAT.include?(attr)
+            return false unless attr.is_a?(Symbol)
+
+            FORMAT.include?(attr)
           end
         end
       end

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

@@ -23,8 +23,6 @@ module Eco
               return [] unless values.is_a?(Enumerable)
               roam = proc do |tree|
                 [].tap do |out|
-                  sub_outs = tree.empty?? [] : tree.map {|sup, subtree| roam.call(subtree)}
-
                   tree.each do |sup, subtree|
                     sout = subtree.empty?? [] : roam.call(subtree)
                     supervisors_first ? sout.unshift(sup) : sout.push(sup)
@@ -46,12 +44,15 @@ module Eco
 
               identify  = proc do |top_sup, offspring, chain = [top_sup]|
                 next [] if offspring.empty?
+
                 offspring.each_with_object([]) do |(sup, subordinates), set|
                   break set unless set.empty?
+
                   if top_sup.supervisor_id == sup.id
                     set.concat(chain, [sup])
                   else
-                    set = identify.call(top_sup, subordinates, chain | [sup])
+                    set.clear
+                    set.push identify.call(top_sup, subordinates, chain | [sup])
                   end
                 end
               end
@@ -74,7 +75,7 @@ module Eco
             end
 
             def print_tree(tree, lev: 0)
-              puts tree_to_str(tree)
+              puts tree_to_str(tree, lev: lev)
             end
 
             # Generates a `Hash` tree structure, where:
@@ -86,13 +87,16 @@ module Eco
             # @return [Hash] the tree structure
             def supervisors_tree(values) # rubocop:disable Metrics/AbcSize
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
+
               return {} unless values.is_a?(Enumerable)
+
               idx = get_super_indexes(values)
 
               processed = []
               subtree = proc do |entry, level, toptree|
                 if processed.include?(entry)
                   next {} unless toptree.key?(entry) && level.positive?
+
                   # needs to be moved as a child
                   subnodes = toptree.delete(entry)
                   processed.delete(entry)
@@ -101,7 +105,8 @@ module Eco
                 subnodes ||= {}.tap do |tree|
                   subs = idx[:subordinates].call(entry)
                   processed.push(entry)
-                  next nil unless subs && !subs.empty?
+                  next unless subs && !subs.empty?
+
                   subs.each do |sub|
                     sub_tree = subtree.call(sub, level + 1, toptree)
                     tree.merge!(sub_tree)
@@ -112,7 +117,7 @@ module Eco
               end
 
               {}.tap do |tree|
-                idx[:by_sup].keys.each do |sup_id|
+                idx[:by_sup].each_key do |sup_id|
                   if (sup = idx[:supers][sup_id])
                     tree.merge!(subtree.call(sup, 0, tree))
                   else
@@ -128,6 +133,7 @@ module Eco
 
             def get_super_indexes(values) # rubocop:disable Metrics/AbcSize
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
+
               {}.tap do |indexes|
                 indexes[:by_id]  = values.map do |e|
                   e.id && [e.id, e]

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

@@ -1,84 +1,78 @@
-module Eco
-  module API
-    module Common
-      module Session
-        class BaseSession
-          attr_writer :session, :config
-          attr_reader :environment
-          alias_method :enviro, :environment
-
-          include Session::Helpers
-          include Eco::Language::AuxiliarLogger
-
-          def initialize(env)
-            msg = "Expected object Eco::API::Common::Session::Environment. Given: #{env.class}"
-            raise msg unless env.is_a?(Environment)
-
-            self.environment = env
-          end
-
-          def session
-            enviro.session
-          end
-
-          def environment=(value)
-            @environment = nil
-            @environment = value if value.is_a?(Environment)
-          end
-          alias_method :enviro=, :environment=
-
-          def config
-            enviro.config
-          end
-
-          def api(version: nil)
-            enviro.api(version: version)
-          end
-
-          def api?(version: nil)
-            enviro.api?(version: version)
-          end
-
-          def file_manager
-            enviro.file_manager
-          end
-          alias_method :fm, :file_manager
-
-          def mailer
-            enviro.mailer
-          end
-
-          def mailer?
-            enviro.mailer?
-          end
-
-          def sftp
-            enviro.sftp
-          end
-
-          def sftp?
-            enviro.sftp?
-          end
-
-          def s3uploader
-            enviro.s3uploader
-          end
-
-          def s3uploader?
-            enviro.s3uploader?
-          end
-
-          def logger
-            enviro.logger
-          end
-
-          # TODO: paremeter for the exception
-          def fatal(msg)
-            log(:fatal) { msg }
-            raise msg
-          end
-        end
-      end
+module Eco::API::Common::Session
+  class BaseSession
+    attr_writer :session, :config
+    attr_reader :environment
+    alias_method :enviro, :environment
+
+    include Eco::API::Common::Session::Helpers
+    include Eco::Language::AuxiliarLogger
+
+    def initialize(env)
+      msg = "Expected object Eco::API::Common::Session::Environment. Given: #{env.class}"
+      raise msg unless env.is_a?(Environment)
+
+      self.environment = env
+    end
+
+    def session
+      enviro.session
+    end
+
+    def environment=(value)
+      @environment = nil
+      @environment = value if value.is_a?(Environment)
+    end
+    alias_method :enviro=, :environment=
+
+    def config
+      enviro.config
+    end
+
+    def api(version: nil)
+      enviro.api(version: version)
+    end
+
+    def api?(version: nil)
+      enviro.api?(version: version)
+    end
+
+    def file_manager
+      enviro.file_manager
+    end
+    alias_method :fm, :file_manager
+
+    def mailer
+      enviro.mailer
+    end
+
+    def mailer?
+      enviro.mailer?
+    end
+
+    def sftp
+      enviro.sftp
+    end
+
+    def sftp?
+      enviro.sftp?
+    end
+
+    def s3uploader
+      enviro.s3uploader
+    end
+
+    def s3uploader?
+      enviro.s3uploader?
+    end
+
+    def logger
+      enviro.logger
+    end
+
+    # TODO: paremeter for the exception
+    def fatal(msg)
+      log(:fatal) { msg }
+      raise msg
     end
   end
 end