ecoportal-api-v2 1.1.7 → 2.0.0

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

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

@@ -7,25 +7,26 @@ module Ecoportal
 
           attr_reader :response, :result
 
-          def initialize(response, klass, key: nil)
+          def initialize(response, klass, key: nil) # rubocop:disable Lint/MissingSuper
             @response = response
             @klass    = klass
             @key      = key
 
-            if @response.success?
-              @result =
-                if data.is_a?(Array)
-                  data.map do |doc|
-                    @klass.new(doc)
-                  end
-                else
-                  @klass.new(data)
+            return unless @response.success?
+
+            @result =
+              if data.is_a?(Array)
+                data.map do |doc|
+                  @klass.new(doc)
                 end
-            end
+              else
+                @klass.new(data)
+              end
           end
 
           def data
             return @data if instance_variable_defined?(:@data)
+
             @data = (response.body || {})["data"]
             @data = @data[@key] if @key && @data
             @data
@@ -34,7 +35,6 @@ module Ecoportal
           def body
             data.to_s
           end
-
         end
       end
     end

data/lib/ecoportal/api/v2/page/component/reference_field.rb

@@ -25,8 +25,8 @@ module Ecoportal
                 ref_ids.each do |ref_id|
                   next if reference_ids.include?(ref_id)
                   refs.push({
-                    "id" => ref_id,
-                    "weight" => 0,
+                    "id"        => ref_id,
+                    "weight"    => 0,
                     "patch_ver" => 0
                   })
                 end
@@ -39,9 +39,13 @@ module Ecoportal
 
             def delete(*ref_ids)
               ref_ids.each do |ref_id|
-                if doc_ref = doc["references"].find {|doc_ref| doc_ref["id"] == ref_id}
-                  doc["references"].delete(doc_ref)
+                doc_ref = doc["references"].find do |df|
+                  df["id"] == ref_id
                 end
+
+                next unless doc_ref
+
+                doc["references"].delete(doc_ref)
               end
             end
 
@@ -62,21 +66,21 @@ module Ecoportal
                   self.display_fields = true
                   self.display_fields_in_lookup = true
                 when Hash
-                  supported = [:create, :attach, :metadata]
-                  unless (rest = hash_except(cnf.dup, *supported)).empty?
-                    unused.push(rest)
-                  end
-                  if cnf.key?(:create)   then self.hide_create = !cnf[:create] end
-                  if cnf.key?(:attach)   then self.hide_attach = !cnf[:attach] end
-                  if cnf.key?(:metadata) then self.hide_metadata = !cnf[:metadata] end
+                  supported = %i[create attach metadata]
+                  rest      = hash_except(cnf.dup, *supported)
+
+                  unused.push(rest) unless rest.empty?
+
+                  self.hide_create   = !cnf[:create]   if cnf.key?(:create)
+                  self.hide_attach   = !cnf[:attach]   if cnf.key?(:attach)
+                  self.hide_metadata = !cnf[:metadata] if cnf.key?(:metadata)
                 else
                   unused.push(cnf)
                 end
-              end.yield_self do |unused|
+              end.then do |unused|
                 super(*unused)
               end
             end
-
           end
         end
       end