ecoportal-api-v2 1.1.7 → 1.1.8

data/lib/ecoportal/api/common/content/collection_model.rb

@@ -32,15 +32,18 @@ module Ecoportal
             # @yield [doc] identifies the target `class` of the raw object
             # @yieldparam doc [Hash]
             # @yieldreturn [Klass] the target `class`
-            # @return [Klass] the target `class`
+            # @return [Class, Proc, Hash] the target `class`
+            #   - `Hash` tracks a symbol pending to be resovle from its referrer
+            #   - `Class` an already resolve class
+            #   - `Proc` a forker that pivots between multiple classes
             def klass(value = NOT_USED, &block)
               @klass = block if block_given?
 
-              if @klass && !@class.is_a?(Proc)
-                @klass = resolve_class(@klass, exception: false) unless @klass.is_a?(Class)
-                @klass
-              elsif @klass.is_a?(Proc) && used_param?(value)
+              if @klass.is_a?(Proc) && used_param?(value)
                 @klass.call(value)
+              elsif @klass && !@klass.is_a?(Proc) && !@klass.is_a?(Class)
+                @klass = resolve_class(@klass, exception: false)
+                @klass
               else
                 @klass
               end.tap do |result|
@@ -58,7 +61,7 @@ module Ecoportal
             # Optimization
             def new_item_class_based?
               return false if @new_item.is_a?(Proc)
-              return false if @klass.is_a?(Proc)
+              return false if klass.is_a?(Proc)
               return true  if klass.is_a?(Class)
               false
             end
@@ -78,7 +81,10 @@ module Ecoportal
             #   Meaning that there is actually no need to define this argument.
             # @return [Klass] instance object of the target `klass`
             def new_item(doc = NOT_USED, parent: nil, key: nil, read_only: false, &block)
-              return (@new_item = block; nil) if block_given
+              if block_given?
+                @new_item = block
+                return
+              end
 
               msg = "To define the 'new_item' callback (factory), you need to use a block"
               raise msg unless used_param?(doc)
@@ -86,18 +92,11 @@ module Ecoportal
               raise msg unless klass?
               return @new_item.call(doc, parent, key)    if @new_item.is_a?(Proc)
 
-              raise "Could not find a class for: #{doc}" unless target_class = klass(doc)
+              raise "Could not find a class for: #{doc}" unless (target_class = klass(doc))
               return doc if doc.is_a?(target_class)
 
               target_class.new(doc, parent: parent, key: key, read_only: read_only)
             end
-
-            def doc_class(name)
-              dim_class = new_class(name, inherits: Common::Content::ArrayModel) do |klass|
-                klass.order_matters = order_matters
-                klass.uniq          = uniq
-              end
-            end
           end
 
           include Enumerable
@@ -105,18 +104,18 @@ module Ecoportal
           inheritable_class_vars :klass, :order_matters, :order_key, :items_key, :new_item
 
           def initialize(ini_doc = [], parent: self, key: nil, read_only: false)
-            unless self.class.klass?
-              raise "Undefined base 'klass' or 'new_item' callback for #{self.class}"
-            end
-
-            ini_doc = case ini_doc
-                      when Array
-                        ini_doc
-                      when Enumerable
-                        ini_doc.to_a
-                      else
-                        []
-                      end
+            msg = "Undefined base 'klass' or 'new_item' callback for #{self.class}"
+            raise msg unless self.class.klass?
+
+            ini_doc =
+              case ini_doc
+              when Array
+                ini_doc
+              when Enumerable
+                ini_doc.to_a
+              else
+                []
+              end
 
             super(ini_doc, parent: parent, key: key, read_only: read_only)
           end
@@ -137,7 +136,7 @@ module Ecoportal
           def _doc_key(value)
             #print "*(#{value.class})"
             return super(value) unless value.is_a?(Hash) || value.is_a?(Content::DoubleModel)
-            if id = get_key(value)
+            if (id = get_key(value))
               #print "^"
               _doc_items.index {|item| get_key(item) == id}.tap do |p|
                 #print "{{#{p}}}"
@@ -157,9 +156,17 @@ module Ecoportal
             end
           end
 
-          def length;   count;      end
-          def empty?;   count == 0; end
-          def present?; count > 0;  end
+          def length
+            count
+          end
+
+          def empty?
+            count&.zero?
+          end
+
+          def present?
+            count&.positive?
+          end
 
           def each(&block)
             return to_enum(:each) unless block
@@ -206,7 +213,7 @@ module Ecoportal
             end
             item_doc = value.is_a?(Content::DoubleModel)? value.doc : value
             item_doc = JSON.parse(item_doc.to_json)
-            if item = self[value]
+            if (item = self[value])
               item.replace_doc(item_doc)
             else
               _doc_upsert(item_doc, pos: pos, before: before, after: after).tap do |pos_idx|
@@ -214,14 +221,14 @@ module Ecoportal
                 @indexed = false
               end
             end
-            (item || self[item_doc]).tap do |item|
-              yield(item) if block_given?
+            (item || self[item_doc]).tap do |itm|
+              yield(itm) if block_given?
             end
           end
 
           # Deletes all the elements of this `CollectionModel` instance
           def clear
-            self.to_a.each {|item| delete!(item)}
+            to_a.each {|item| delete!(item)}
           end
 
           # Deletes `value` from this `CollectionModel` instance
@@ -233,18 +240,25 @@ module Ecoportal
             unless value.is_a?(Hash) || value.is_a?(Content::DoubleModel) || value.is_a?(String)
               raise "'Content::DoubleModel' or 'Hash' doc required"
             end
-            if item = self[value]
-              _doc_delete(item.doc)
-              @indexed = false
-              _items.delete(item)
-            end
+            return unless (item = self[value])
+            _doc_delete(item.doc)
+            @indexed = false
+            _items.delete(item)
           end
 
           protected
 
-          def order_matters?; self.class.order_matters; end
-          def uniq?;          self.class.uniq;          end
-          def items_key;      self.class.items_key;     end
+          def order_matters?
+            self.class.order_matters
+          end
+
+          def uniq?
+            self.class.uniq
+          end
+
+          def items_key
+            self.class.items_key
+          end
 
           def on_change
             @indexed = false
@@ -261,7 +275,7 @@ module Ecoportal
             when String
               value
             when Numeric
-              get_key(self.to_a[value])
+              get_key(to_a[value])
             end
           end
 
@@ -284,9 +298,9 @@ module Ecoportal
 
           def new_item(value)
             if self.class.new_item_class_based?
-              self.class.klass.new(value, parent: self, read_only: self._read_only)
+              self.class.klass.new(value, parent: self, read_only: _read_only)
             else
-              self.class.new_item(value, parent: self, read_only: self._read_only)
+              self.class.new_item(value, parent: self, read_only: _read_only)
             end
           end
 
@@ -309,48 +323,46 @@ module Ecoportal
           # Deletes `value` from `doc` (here referred as `_doc_items`)
           # @return [Object] the element deleted from `doc`
           def _doc_delete(value)
-            if current_pos = _doc_key(value)
-              _doc_items.delete_at(current_pos)
-            end
+            return unless (current_pos = _doc_key(value))
+
+            _doc_items.delete_at(current_pos)
           end
 
           def _doc_upsert(value, pos: NOT_USED, before: NOT_USED, after: NOT_USED)
-            current_pos = if elem = self[value]
-              _doc_key(elem)
-            end
+            current_pos =
+              if (elem = self[value])
+                _doc_key(elem)
+              end
 
             pos   = scope_position(pos: pos, before: before, after: after)
             pos ||= current_pos
 
             if current_pos && pos
               _doc_items.delete_at(current_pos)
-              pos = (pos <= current_pos)? pos : pos - 1
+              pos = pos <= current_pos ? pos : pos - 1
             end
 
-            pos = (pos && pos < _doc_items.length)? pos : _doc_items.length
-            pos.tap do |i|
+            pos = (pos && pos < _doc_items.length)? pos : _doc_items.length # rubocop:disable Style/TernaryParentheses
+            pos.tap do |_i|
               _doc_items.insert(pos, value)
             end
-
           end
 
           def scope_position(pos: NOT_USED, before: NOT_USED, after: NOT_USED)
-            case
-            when used_param?(pos)
-              if elem = self[pos]
+            if used_param?(pos)
+              if (elem = self[pos])
                 _doc_key(elem) - 1
               end
-            when used_param?(before)
-              if elem = self[before]
+            elsif used_param?(before)
+              if (elem = self[before])
                 _doc_key(elem) - 1
               end
-            when used_param?(after)
-              if elem = self[after]
+            elsif used_param?(after)
+              if (elem = self[after])
                 _doc_key(elem)
               end
             end
           end
-
         end
       end
     end

data/lib/ecoportal/api/common/content/double_model.rb

@@ -6,12 +6,8 @@ module Ecoportal
         # which differs of `attr_*` ruby native class methods because `pass*`
         # completelly **links** the methods **to a subjacent `Hash` model**
         class DoubleModel < Common::BaseModel
-          NOT_USED = Common::Content::ClassHelpers::NOT_USED
-          extend Common::Content::ClassHelpers
-          include Common::Content::ModelHelpers
-
           class UnlinkedModel < StandardError
-            def initialize (msg = "Something went wrong when linking the document.", from: nil, key: nil)
+            def initialize(msg = "Something went wrong when linking the document.", from: nil, key: nil)
               msg += " From: #{from}." if from
               msg += " key: #{key}."   if key
               super(msg)
@@ -21,6 +17,10 @@ module Ecoportal
           class NoKeyMethod < StandardError
           end
 
+          NOT_USED = Common::Content::ClassHelpers::NOT_USED
+          extend Common::Content::ClassHelpers
+          include Common::Content::ModelHelpers
+
           class << self
             attr_reader :key
 
@@ -118,7 +118,7 @@ module Ecoportal
             #   as well as its `key` in the underlying `Hash` model.
             # @param default [Value] the default value that
             #   this `key` will be written in the model when it doesn't exixt
-            def passforced(method, default: , read_only: false)
+            def passforced(method, default:, read_only: false)
               model_forced_keys[method.to_s.freeze] = default
               passthrough(method, read_only: read_only)
             end
@@ -126,8 +126,9 @@ module Ecoportal
             # Ensures `doc` has the `model_forced_keys`. If it doesn't, it adds those missing
             #   with the defined `default` values
             def enforce!(doc)
-              return unless doc && doc.is_a?(Hash)
-              return if model_forced_keys.empty?
+              return unless doc.is_a?(Hash)
+              return if     model_forced_keys.empty?
+
               model_forced_keys.each do |key, default|
                 doc[key] = default unless doc.key?(key)
               end
@@ -139,8 +140,8 @@ module Ecoportal
             #   as well as its `key` in the underlying `Hash` model.
             # @param read_only [Boolean] should it only define the reader?
             def passthrough(*methods, read_only: false)
-              pass_reader *methods
-              pass_writer *methods unless read_only
+              pass_reader(*methods)
+              pass_writer(*methods) unless read_only
               self
             end
 
@@ -151,9 +152,7 @@ module Ecoportal
             # @param read_only [Boolean] should it only define the reader?
             def passdate(*methods, read_only: false)
               pass_reader(*methods) {|value| to_time(value)}
-              unless read_only
-                pass_writer(*methods) {|value| to_time(value)&.iso8601}
-              end
+              pass_writer(*methods) {|value| to_time(value)&.iso8601} unless read_only
               self
             end
 
@@ -163,9 +162,7 @@ module Ecoportal
             # @param read_only [Boolean] should it only define the reader?
             def passboolean(*methods, read_only: false)
               pass_reader(*methods) {|value| value}
-              unless read_only
-                pass_writer(*methods) {|value| !!value}
-              end
+              pass_writer(*methods) {|value| !!value} unless read_only
               self
             end
 
@@ -186,7 +183,7 @@ module Ecoportal
 
                 define_method method do
                   return instance_variable_get(var) if instance_variable_defined?(var)
-                  new_obj = dim_class.new(parent: self, key: method, read_only: self.read_only?)
+                  new_obj = dim_class.new(parent: self, key: method, read_only: read_only?)
                   variable_set(var, new_obj)
                 end
               end
@@ -197,7 +194,7 @@ module Ecoportal
             # @param key [Symbol] the `key` that embeds it to the underlying `Hash` model
             # @nullable [Boolean] to specify if this object can be `nil`
             # @param klass [Class, String] the class of the embedded object
-            def embeds_one(method, key: method, nullable: false, klass:)
+            def embeds_one(method, klass:, key: method, nullable: false)
               embed(method, key: key, nullable: nullable, multiple: false, klass: klass)
             end
 
@@ -212,12 +209,13 @@ module Ecoportal
             # @param read_only [Boolean] whether or not should try to **work around** items `klass` missing a `key`
             #   - If set to `true` this is meant only for read purposes (won't be able to successufully insert)
             def embeds_many(method, key: method, klass: nil, enum_class: nil,
-              order_matters: false, order_key: nil, read_only: self.read_only?)
+              order_matters: false, order_key: nil, read_only: read_only?)
               if enum_class
                 eclass = enum_class
               elsif klass
                 eclass = new_class("#{method}::#{klass}", inherits: Common::Content::CollectionModel) do |dim_class|
-                  dim_class.klass         = klass
+                  # NOTE: new_class may resolve the namespace of the class to an already existing class
+                  dim_class.klass       ||= klass
                   dim_class.order_matters = order_matters
                   dim_class.order_key     = order_key
                   dim_class.read_only! if read_only
@@ -225,61 +223,69 @@ module Ecoportal
               else
                 raise "You should either specify the 'klass' of the elements or the 'enum_class'"
               end
-              embed(method, key: key, multiple: true, klass: eclass, read_only: read_only) do |instance_with_called_method|
+
+              embed(
+                method,              key:   key,
+                multiple:  true,     klass: eclass,
+                read_only: read_only
+              ) do |instance_with_called_method|
                 # keep reference to the original class to resolve the `klass` dependency
                 # See stackoverflow: https://stackoverflow.com/a/73709529/4352306
                 referrer_class = instance_with_called_method.class
-                eclass.klass = {referrer_class => klass} if klass
+                eclass.klass   = {referrer_class => klass} if klass
+                # This helps `resolve_class` to correctly resolve a symbol
+                # by using referrer_class as a base module to resolve it
               end
             end
 
             private
 
-            def embed(method, key: method, nullable: false, multiple: false, klass:, read_only: self.read_only?, &block)
+            def embed(
+              method,          klass:,          key: method,
+              nullable: false, multiple: false, read_only: read_only?,
+              &embed_block
+            )
               method = method.to_s.freeze
               var    = instance_variable_name(method).freeze
-              k      = key.to_s.freeze
+              obj_k  = key.to_s.freeze
 
               # retrieving method (getter)
               define_method(method) do
-                yield(self) if block_given?
+                # set item klass as referrer to klass (to allow resolve symbol)
+                embed_block&.call(self)
                 return instance_variable_get(var) if instance_variable_defined?(var)
-                unless nullable
-                  doc[k] ||= multiple ? [] : {}
-                end
-                return variable_set(var, nil) unless doc[k]
 
-                embedded_class = self.class.resolve_class(klass)
-
-                if multiple && read_only
-                  if doc[k].is_a?(Array) && embedded_class < Common::Content::CollectionModel
-                    if (item_class = embedded_class.klass) && !item_class.key?
-                      item_class.passkey :id
-                      doc[k].each_with_index do |item_doc, i|
-                        item_doc["id"] = "#{i}" unless item_doc.key?("id")
-                      end
-                    end
-                  end
-                end
+                doc[obj_k] ||= (multiple ? [] : {}) unless nullable
+                return variable_set(var, nil) unless doc[obj_k]
 
-                embedded_class.new(doc[k], parent: self, key: k, read_only: self.read_only? || read_only).tap do |obj|
-                  variable_set(var, obj)
+                embedded_class = self.class.resolve_class(klass)
+                setup_items_key(embedded_class, doc[obj_k]) if multiple && read_only
+
+                embedded_class.new(
+                  doc[obj_k],
+                  parent:    self,
+                  key:       obj_k,
+                  read_only: read_only? || read_only
+                ).tap do |collection|
+                  variable_set(var, collection)
                 end
               end
             end
 
             # The list of keys that will be forced in the model
             def model_forced_keys
-              @forced_model_keys ||= {}
+              @model_forced_keys ||= {}
             end
           end
 
-          inheritable_class_vars :forced_model_keys, :key, :read_only
+          inheritable_class_vars :model_forced_keys, :key, :read_only
 
-          # `_key` refers to the parent's property that links to this model
+          # `_key` refers to the `_parent`'s property that links to this model
+          # @note while `key` refers to the value of theproperty of this model
+          #   that is key (identifies an item in a set of elements)
           attr_reader :_parent, :_key, :_read_only
 
-          def initialize(doc = {}, parent: self, key: nil, read_only: self.class.read_only?)
+          def initialize(doc = {}, parent: self, key: nil, read_only: self.class.read_only?) # rubocop:disable Lint/MissingSuper
             @_dim_vars  = []
             @_parent    = parent || self
             @_key       = key    || self
@@ -292,10 +298,10 @@ module Ecoportal
               @original_doc = JSON.parse(@doc.to_json)
             end
 
-            if key_method? && doc && doc.is_a?(Hash)
-              self.key = doc[key_method]
-              #puts "\n$(#{self.key}<=>#{self.class})"
-            end
+            return unless key_method? && doc && doc.is_a?(Hash)
+
+            self.key = doc[key_method]
+            #puts "\n$(#{self.key}<=>#{self.class})"
           end
 
           # @note `read_only` allows for some optimizations, such as storing values
@@ -311,15 +317,20 @@ module Ecoportal
 
           # @return [String] the `value` of the `key` method (i.e. `id` value)
           def key
-            raise NoKeyMethod.new "No key_method defined for #{self.class}" unless key_method?
-            self.method(key_method).call
+            raise NoKeyMethod, "No key_method defined for #{self.class}" unless key_method?
+
+            method(key_method).call
           end
 
           # @param [String] the `value` of the `key` method (i.e. `id` value)
           def key=(value)
-            raise NoKeyMethod.new "No key_method defined for #{self.class}" unless key_method?
-            method = "#{key_method}="
-            self.method(method).call(value)
+            raise NoKeyMethod, "No key_method defined for #{self.class}" unless key_method?
+
+            method("#{key_method}=").call(value)
+          end
+
+          def resolved_doc_key
+            [_doc_key(_key)]
           end
 
           # Offers a method for child classes to transform the key,
@@ -337,25 +348,22 @@ module Ecoportal
           # @return [nil, Hash] the underlying `Hash` model as is (carrying current changes)
           def doc
             return @doc if doc_var?
+
             raise UnlinkedModel.new(from: "#{self.class}#doc", key: _key) unless linked?
-            if is_root?
-              @doc
-            else
-              # transform parent's `_key` to this object into a
-              # path key that can rerieve from the parents's doc
-              _parent.doc.dig(*[_doc_key(_key)].flatten)
-            end
+            return @doc if is_root?
+
+            # transform parent's `_key` to this object into a
+            # path key that can rerieve from the parents's doc
+            _parent.doc.dig(*resolved_doc_key.flatten)
           end
 
           # The `original_doc` holds the model as is now on server-side.
           # @return [nil, Hash] the underlying `Hash` model as after last `consolidate!` changes
           def original_doc
             raise UnlinkedModel.new(from: "#{self.class}#original_doc", key: _key) unless linked?
-            if is_root?
-              @original_doc
-            else
-              _parent.original_doc.dig(*[_doc_key(_key)].flatten)
-            end
+            return @original_doc if is_root?
+
+            _parent.original_doc.dig(*resolved_doc_key.flatten)
           end
 
           def as_json
@@ -376,7 +384,7 @@ module Ecoportal
           # @return [Boolean] stating if there are changes
           def dirty?
             au = as_update
-            !((au == {}) || (au == nil))
+            !((au == {}) || au.nil?)
           end
 
           # It makes `original_doc` to be like `doc`
@@ -396,7 +404,7 @@ module Ecoportal
             if key
               keys    = [key].flatten.compact
               odoc    = original_doc.dig(*keys)
-              odoc    = odoc && JSON.parse(odoc.to_json)
+              odoc  &&= JSON.parse(odoc.to_json)
               dig_set(doc, keys, odoc)
             else
               replace_doc(JSON.parse(original_doc.to_json))
@@ -410,13 +418,11 @@ module Ecoportal
 
           def replace_doc(new_doc)
             raise UnlinkedModel.new(from: "#{self.class}#replace_doc", key: _key) unless linked?
-            if is_root?
-              @doc = new_doc
-            else
-              dig_set(_parent.doc, [_doc_key(_key)].flatten, new_doc)
-              _parent.variable_remove!(_key) unless new_doc
-              #variables_remove!
-            end
+            return (@doc = new_doc) if is_root?
+
+            dig_set(_parent.doc, resolved_doc_key.flatten, new_doc)
+            _parent.variable_remove!(_key) unless new_doc
+            #variables_remove!
           end
 
           protected
@@ -438,11 +444,9 @@ module Ecoportal
 
           def replace_original_doc(new_doc)
             raise UnlinkedModel.new(from: "#{self.class}#replace_original_doc", key: _key) unless linked?
-            if is_root?
-              @original_doc = new_doc
-            else
-              dig_set(_parent.original_doc, [_doc_key(_key)].flatten, new_doc)
-            end
+            return (@original_doc = new_doc) if is_root?
+
+            dig_set(_parent.original_doc, resolved_doc_key.flatten, new_doc)
           end
 
           # Helper to track down persistent variables
@@ -455,16 +459,16 @@ module Ecoportal
           # Helper to remove tracked down instance variables
           def variable_remove!(key)
             var = instance_variable_name(key)
-            unless !@_dim_vars.include?(var)
-              @_dim_vars.delete(var)
-              remove_instance_variable(var)
-            end
+            return unless @_dim_vars.include?(var)
+
+            @_dim_vars.delete(var)
+            remove_instance_variable(var)
           end
 
           # Removes all the persistent variables
           def variables_remove!
             #puts "going to remove vars: #{@_dim_vars} on #{self.class} (parent: #{identify_parent(self._parent)})"
-            @_dim_vars.dup.map {|k| variable_remove!(k)}
+            @_dim_vars.dup.map {|var| variable_remove!(var)}
           end
 
           private
@@ -502,6 +506,20 @@ module Ecoportal
             self.class.key
           end
 
+          # It allows to work-around missing item_key
+          def setup_items_key(embedded_class, obj_doc)
+            # only if is going to be a collection
+            return unless obj_doc.is_a?(Array) && embedded_class < Common::Content::CollectionModel
+            return unless (item_class = embedded_class.klass)
+            # if already has key don't need to work around
+            return if     item_class&.key
+
+            # apply work around
+            item_class.passkey :id
+            obj_doc.each_with_index do |item_doc, idx|
+              item_doc["id"] = idx.to_s unless item_doc.key?("id")
+            end
+          end
         end
       end
     end