eco-helpers 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3aec55ff6424177729ff863f6652dfe53fecd2df84111036d336e216f9df441
-  data.tar.gz: 86faa0568a8d3bc393cbbe4db62bb367230035de12230739c68891d551ae16b7
+  metadata.gz: c71b81aaf2b40c4f9388fc87176a3ca7b5cd4c274a760546aaae8e98b00abea5
+  data.tar.gz: cfefc68eed3bfbfd1767ca222bf3c7dfca2d7ce77d94fa6cf5b0b406754ae0aa
 SHA512:
-  metadata.gz: 49f68f024a1e129502ec505b79b945feec5f40a99dfa8c7ebb45ea9699c889efffaad23b1e0c08302032a92cc117a0fb9ecf404cb68cdf6d576deb283d63118e
-  data.tar.gz: 64777d1d3c04e878538f70b41fd0fc67ec4a951c1d59ade2300a96174c006ff68d1a2c12c9c661b57bc75af5e71e8d690c1e8239664373b426328d4e247a674d
+  metadata.gz: 14234f90a41da5093e8f1af208edc9aea7f454c8f15b8a19dcbbfce63559d3e82b47de850160d3f843d30ab0fac0fc9c44bd3f60a56e056c7b8922f64624da29
+  data.tar.gz: 6c8d9cf5e0311591601be6e1f211c23667b5ea7902e8704edaa53eeb1d3e1123780b0bc7fee44b85d39792e2bbe7cf23c43b5a8dc815db69fc16e5e3daa9fe88

data/lib/eco/api.rb

@@ -8,6 +8,7 @@ end
 require_relative 'api/common'
 require_relative 'api/usecases'
 require_relative 'api/policies'
+require_relative 'api/error'
 require_relative 'api/organization'
 require_relative 'api/session'
 require_relative 'api/eco_faker'

data/lib/eco/api/common.rb

@@ -6,5 +6,6 @@ module Eco
 end
 
 require_relative 'common/version_patches'
+require_relative 'common/class_helpers'
 require_relative 'common/people'
 require_relative 'common/session'

data/lib/eco/api/common/class_helpers.rb

@@ -0,0 +1,33 @@
+module Eco
+  module API
+    module Common
+      module ClassHelpers
+
+        def class_resolver(name, klass)
+          define_singleton_method(name) { resolve_class(klass) }
+          define_method(name) { self.class.resolve_class(klass) }
+        end
+
+        def resolve_class(klass, exception: true)
+          @resolved ||= {}
+          @resolved[klass] ||=
+            case klass
+              when Class
+                klass
+              when String
+                begin
+                  Kernel.const_get(klass)
+                rescue NameError => e
+                  raise e if exception
+                end
+              when Symbol
+                resolve_class(self.send(klass))
+              else
+                raise "Unknown class: #{klass}" if exception
+            end
+        end
+        
+      end
+    end
+  end
+end

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

@@ -10,6 +10,7 @@ end
 require_relative 'people/person_modifier'
 require_relative 'people/person_factory'
 require_relative 'people/base_parser'
+require_relative 'people/person_attribute_parser'
 require_relative 'people/person_parser'
 require_relative 'people/default_parsers'
 require_relative 'people/person_entry_attribute_mapper'

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

@@ -0,0 +1,52 @@
+module Eco
+  module API
+    module Common
+      module People
+
+        # Class to define a parser/serializer.
+        class PersonAttributeParser < Eco::Language::Models::ParserSerializer
+
+          # @see Eco::Language::Models::ParserSerializer#def_parser
+          # @note
+          #  - additionally, you can declare a callback `active:` to determine if when the
+          # parser will be active/used.
+          #  - this is important to help avoiding to set values that are not present in the input entry.
+          #  - if you have doubts about using it or not, do not use it.
+          # @param active_when [Proc] that expects a list of internal attributes or the internal entry itself
+          # By default, an attribute paraser is active if in the entry to parse the internal attribute is present.
+          def def_parser(active_when: nil, &block)
+            @active_when = attribute_present(active_when)
+            super(&block)
+          end
+
+          # Determines if for a given source data to parse, this parser should be active or not
+          # @return [Boolean] `true` if there's no callback defined or there is and evaluates `true`
+          # when for the current data to parse. It returns `false` otherwise.
+          def parser_active?(source_data)
+            @active_when.call(source_data)
+          end
+
+          private
+
+          # by default, an attribute paraser is active if in the entry to parse
+          # the internal attribute is present
+          def attribute_present(active_when)
+            Proc.new do |source_data|
+              case source_data
+              when Array
+                keys = source_data
+              when Hash
+                keys = source_data.keys
+              else
+                keys = []
+              end
+
+              (source_data && keys.include?(self.attr)) ||
+              (active_when && active_when.call(source_data))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Eco
         # @attr_reader core_attrs [Array<String>] core attributes that are present in the person entry.
         # @attr_reader details_attrs [Array<String>] schema details attributes that are present in the person entry.
         # @attr_reader account_attrs [Array<String>] account attributes that are present in the person entry.
-        # @attr_reader all_attrs [Array<String>] all the attrs that are present in the person entry.        
+        # @attr_reader all_attrs [Array<String>] all the attrs that are present in the person entry.
         # @attr_reader internal_attrs [Array<String>] all the internally named attributes that the person entry has.
         # @attr_reader aliased_attrs [Array<String>] only those internal attributes present in the person entry that have an internal/external name mapping.
         # @attr_reader direct_attrs [Array<String>] only those internal attributes present in the person entry that do **not** have an internal/external name mapping.
@@ -23,7 +23,7 @@ module Eco
           #   - 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, Person] `Person` object to be serialized or hashed entry (`CSV::Row` is accepted).
+          # @param data [Hash, Person] `Person` object to be serialized or hashed entry (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.

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

@@ -43,12 +43,6 @@ module Eco
             @all_attrs = CORE_ATTRS + ACCOUNT_ATTRS + @details_attrs
           end
 
-          # Lists all defined attributes, types and formats.
-          # @return [Array<String>] the list of defined parsers/serializers.
-          def list_defined
-            @parsers.keys
-          end
-
           # Scopes `source_attrs` using the _**core** attributes_.
           # @note use this helper to know which among your attributes are **core** ones.
           # @param source_attrs [Array<String>]
@@ -76,14 +70,26 @@ module Eco
             scoped_attrs(source_attrs, ACCOUNT_ATTRS)
           end
 
+          # Lists all defined attributes, types and formats.
+          # @return [Array<String>] the list of defined parsers/serializers.
+          #def list_defined
+          #  @parsers.keys
+          #end
+
           # Returns a list of all the internal attributes of the model that have a parser defined.
-          # @note it excludes any parser that is not in the model, such as type parsers (i.e. ``:boolean`, ``:multiple`)
+          # @note it excludes any parser that is not in the model, such as type parsers (i.e. `:boolean`, `:multiple`)
           # @return [Array<String>] list of all attribute defined parsers.
           def defined_attrs
             defined = @parsers.keys
             defined - (defined - all_attrs)
           end
 
+          # Returns a list of all the internal attributes of the model that have a parser defined & that should be active.
+          # @return [Array<String>] list of all attribute defined parsers that should be active.
+          def active_attrs(source_data)
+            defined_attrs.select {|attr| @parsers[attr].parser_active?(source_data)}
+          end
+
           # Returns a list of all the internal attributes of the model that do **not** have a parser defined.
           # @note it excludes any parser that is **not** in the model, such as type parsers (i.e. :boolean, :multiple)
           # @return [Array<String>] list of all attributes without a defined parser.
@@ -123,8 +129,8 @@ module Eco
               msg = "The attribute '#{attr_to_str(attr)}' is not part of core, account or target schema, or does not match any type: #{@details_attrs}"
               raise msg
             end
-
-            Eco::Language::Models::ParserSerializer.new(attr, dependencies: dependencies).tap do |parser|
+            # Eco::Language::Models::ParserSerializer
+            Eco::API::Common::People::PersonAttributeParser.new(attr, dependencies: dependencies).tap do |parser|
               @parsers[attr] = parser
               definition.call(parser)
             end
@@ -169,7 +175,7 @@ module Eco
 
           def scoped_attrs(source_attrs, section_attrs)
             direct_attrs = source_attrs & section_attrs
-            parsed_attrs = @parsers.keys & section_attrs
+            parsed_attrs = active_attrs(source_attrs) & section_attrs
             (source_attrs + parsed_attrs) & (direct_attrs + parsed_attrs)
           end
 

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

@@ -7,6 +7,5 @@ module Eco
   end
 end
 
-require_relative 'version_patches/base_model.rb'
-require_relative 'version_patches/external_person.rb'
-require_relative 'version_patches/internal_person.rb'
+require_relative 'version_patches/hash'
+require_relative 'version_patches/ecoportal_api'

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

@@ -0,0 +1,4 @@
+require 'ecoportal/api'
+require_relative 'ecoportal_api/base_model'
+require_relative 'ecoportal_api/external_person'
+require_relative 'ecoportal_api/internal_person'

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

@@ -0,0 +1,2 @@
+
+require_relative 'hash/deep_merge'

data/lib/eco/api/common/version_patches/hash/deep_merge.rb

@@ -0,0 +1,34 @@
+class Hash
+  # Source: `ActiveSupport`
+  #   - https://github.com/rails/rails/blob/b2eb1d1c55a59fee1e6c4cba7030d8ceb524267c/activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = { a: true, b: { c: [1, 2, 3] } }
+  #   h2 = { a: false, b: { x: [3, 4, 5] } }
+  #
+  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  #
+  # Like with Hash#merge in the standard library, a block can be provided
+  # to merge values:
+  #
+  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+  #   h2 = { b: 250, c: { c1: 200 } }
+  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+  #   # => { a: 100, b: 450, c: { c1: 300 } }
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block_given?
+        block.call(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+end

data/lib/eco/api/error.rb

@@ -0,0 +1,133 @@
+module Eco
+  module API
+    class Error < Exception
+      class UnknownErrorClass < Exception
+        def initialize(msg = nil, klass:)
+          msg ||= "Unkown api error class #{klass}"
+          super(msg)
+        end
+      end
+
+      @str_err = "api error on the server reply"
+      @match  = /.*/
+      #RxValidId = /[a-f0-9]{24}/
+
+      class Unclassified < Eco::API::Error
+        @str_error = "Unclassified error message"
+        @match     = /.*/
+      end
+
+      class UnknownPersonId < Eco::API::Error
+        @str_err = "Unknown person id"
+        @match   = /Cannot find person with id (.*)/
+      end
+      class EmailMissing < Eco::API::Error
+        @str_err = "missing email for account creation"
+        @match   = /#{@str_err}/
+      end
+      class EmailInvalid < Eco::API::Error
+        @str_err = "Email is invalid"
+        @match   = /#{@str_err}/
+      end
+      class EmailTaken < Eco::API::Error
+        @str_err = "user email already taken"
+        @match   = /#{@str_err}/
+      end
+      class SupervisorNotFound < Eco::API::Error
+        @str_err = "Supervisor not found"
+        @match   = /Supervisor (.*?) not found/
+      end
+      class CyclicSupervisor < Eco::API::Error
+        @str_err = "Supervisor is cyclic!"
+        @match   = /#{@str_err}/
+      end
+      class SchemaNotFound < Eco::API::Error
+        @str_err = "Schema not found"
+        @match   = /Schema (.*?) not found/
+      end
+      class InvalidObjectId < Eco::API::Error
+        @str_err = "Invalid ObjectId."
+        @match   = /'(.*?)' is an invalid ObjectId./
+      end
+      class UnkownField < Eco::API::Error
+        @str_err = "Unknown field."
+        @match   = /(.+?) is an unknown field/
+
+        class UnkownCoreField < UnkownField
+          @str_err = "Unknown core field."
+          @match   = /(.+?) is an unknown field/
+        end
+        class UnkownAccountField < UnkownField
+          @str_err = "Unknown account field."
+          @match   = /account \> (.+?) is an unknown field/
+        end
+        class UnkownDetailsField < UnkownField
+          @str_err = "Unknown details field."
+          @match   = /details \> (.+?) is an unknown field/
+        end
+
+      end
+
+      class << self
+        def descendants(direct: false)
+          ObjectSpace.each_object(::Class).select do |klass|
+            klass < self
+          end.tap do |siblings|
+            if direct
+              siblings.reject! do |si|
+                siblings.any? {|s| si < s}
+              end
+            end
+          end
+        end
+
+        def descendants?(direct: false)
+          descendants(direct: direct).length > 0
+        end
+
+        def err_match?(err_msg)
+          err_msg =~ @match
+        end
+
+        def get_type(err_msg)
+          type = nil
+          descendants(direct: true).reverse.each do |klass|
+            if klass.err_match?(err_msg)
+              type = klass
+              if klass.descendants?(direct: true)
+                type = klass.get_type(err_msg) || type
+              end
+            end
+          end
+          type
+        end
+
+        def known_err_class?(klass)
+          descendants.push(self).include?(klass)
+        end
+
+        def validate_err_class(klass)
+          raise UnknownErrorClass.new(klass: klass) unless known_err_class?(klass)
+        end
+      end
+
+      attr_reader :msg, :err_msg, :session, :entry
+
+      def initialize(msg = nil, err_msg:, session: nil, entry: nil)
+        @msg     = msg
+        @err_msg = err_msg
+        @session = session
+        @entry   = entry
+
+        super(built_error)
+      end
+
+      def built_error
+        str ||= msg
+      end
+    end
+  end
+end
+
+require_relative 'error/handler'
+require_relative 'error/handlers'

data/lib/eco/api/error/handler.rb

@@ -0,0 +1,19 @@
+module Eco
+  module API
+    class Error
+      class Handler < Eco::API::UseCases::UseCase
+        @types = [:transform]
+
+        def initialize(name, type: :transform, root:, &block)
+          super(name, type: type, root: root, &block)
+        end
+
+        def root=(value)
+          raise "Root should be a Eco::API::Error::Handlers object. Given: #{value}" if !value.is_a?(Eco::API::Error::Handlers)
+          @root = value
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/error/handlers.rb

@@ -0,0 +1,22 @@
+module Eco
+  module API
+    class Error
+      class Handlers < Eco::API::UseCases
+
+        def add(handler)
+          raise "Expected Eco::API::Error::Handler object. Given: #{policy}" unless handler.is_a?(Eco::API::Error::Handler)
+          super(handler)
+        end
+
+        def on(klass_err, type: :transform, retry: true, &block)
+          Eco::API::Error.validate_err_class(klass_err)
+          raise "Expected block but not given" unless block
+          Eco::API::Error::Handler.new(klass_err, type: type, root: self, &block).tap do |handler|
+            add(handler)
+          end
+        end
+
+      end
+    end
+  end
+end