ecoportal-api-v2 1.1.6 → 1.1.8

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
 
@@ -38,6 +38,16 @@ module Ecoportal
               uid(length)
             end
 
+            def read_only?
+              @read_only = false if @read_only.nil?
+              @read_only
+            end
+
+            # Be able to define if a class should be read-only
+            def read_only!
+              @read_only = true
+            end
+
             # Same as `attr_reader` but links to a subjacent `Hash` model property
             # @note it does **not** create an _instance variable_
             # @param methods [Array<Symbol>] the method that exposes the value
@@ -108,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
@@ -116,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
@@ -129,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
 
@@ -141,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
 
@@ -153,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
 
@@ -176,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
@@ -187,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
 
@@ -202,73 +209,83 @@ 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: false)
+              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
                 end
               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: false, &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)
+                doc[obj_k] ||= (multiple ? [] : {}) unless nullable
+                return variable_set(var, nil) unless doc[obj_k]
 
-                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
-
-                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
+          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: false)
+          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
@@ -281,10 +298,16 @@ 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
+          #   in instance variables, for optimization purposes
+          def read_only?
+            @_read_only
           end
 
           def root
@@ -294,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,
@@ -320,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
@@ -359,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`
@@ -379,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))
@@ -393,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
@@ -408,6 +431,9 @@ module Ecoportal
             !!defined?(@doc)
           end
 
+          # Both requisites
+          # @note that for optimization purposes, `@doc` var may be used when
+          #   the object is `read_only?`
           def is_root?
             _parent == self && doc_var?
           end
@@ -418,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
@@ -435,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
@@ -482,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.v2.rb

@@ -5,4 +5,5 @@ module Ecoportal
   end
 end
 
+require 'ecoportal/api/common/concerns'
 require 'ecoportal/api/common/content'

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

@@ -30,65 +30,64 @@ module Ecoportal
           class << self
             def new_doc(type: nil)
               {
-                "id"         => new_uuid
+                "id" => new_uuid
               }.tap do |base_doc|
                 if type
                   base_doc.merge!({"type" => type})
-                  if klass = get_class(base_doc)
+                  if (klass = get_class(base_doc))
                     base_doc.merge!(klass.new_doc || {})
                   end
                 end
               end
             end
 
-            def get_class(doc)
-              if doc.is_a?(Hash)
-                case doc["type"]
-                when "tag_field"
-                  tag_field_class
-                when "geo"
-                  geo_field_class
-                when "select"
-                  selection_field_class
-                when "date"
-                  date_field_class
-                when "number"
-                  number_field_class
-                when "gauge"
-                  gauge_field_class
-                when "plain_text"
-                  plain_text_field_class
-                when "rich_text"
-                  rich_text_field_class
-                when "people"
-                  people_field_class
-                when "contractor_entities"
-                  contractor_entities_field_class
-                when "checklist"
-                  checklist_field_class
-                when "page_action","checklist_task"
-                  action_field_class
-                when "actions_list"
-                  actions_field_class
-                when "file"
-                  files_field_class
-                when "image_gallery"
-                  images_field_class
-                when "signature"
-                  signature_field_class
-                when "cross_reference"
-                  reference_field_class
-                when "law"
-                  law_field_class
-                when "mailbox"
-                  mailbox_field_class
-                when "chart"
-                  chart_field_class
-                when "frequency_rate_chart"
-                  chart_fr_field_class
-                else
-                  self
-                end
+            def get_class(doc) # rubocop:disable Metrics/AbcSize
+              return nil unless doc.is_a?(Hash)
+              case doc["type"]
+              when "tag_field"
+                tag_field_class
+              when "geo"
+                geo_field_class
+              when "select"
+                selection_field_class
+              when "date"
+                date_field_class
+              when "number"
+                number_field_class
+              when "gauge"
+                gauge_field_class
+              when "plain_text"
+                plain_text_field_class
+              when "rich_text"
+                rich_text_field_class
+              when "people"
+                people_field_class
+              when "contractor_entities"
+                contractor_entities_field_class
+              when "checklist"
+                checklist_field_class
+              when "page_action", "checklist_task"
+                action_field_class
+              when "actions_list"
+                actions_field_class
+              when "file"
+                files_field_class
+              when "image_gallery"
+                images_field_class
+              when "signature"
+                signature_field_class
+              when "cross_reference"
+                reference_field_class
+              when "law"
+                law_field_class
+              when "mailbox"
+                mailbox_field_class
+              when "chart"
+                chart_field_class
+              when "frequency_rate_chart"
+                chart_fr_field_class
+              else
+                self
               end
             end
           end
@@ -103,7 +102,7 @@ module Ecoportal
           passarray   :refs
 
           def ooze
-            self._parent.ooze
+            _parent.ooze
           end
 
           def ref_backend
@@ -111,9 +110,9 @@ module Ecoportal
           end
 
           def ref(any_length: false)
-            if digest = self.class.hash_label(label, any_length: any_length)
-              [type, digest].join(".")
-            end
+            digest = self.class.hash_label(label, any_length: any_length)
+            return unless digest
+            [type, digest].join(".")
           end
 
           # Looks up the section that this component belongs to.
@@ -159,7 +158,7 @@ module Ecoportal
 
           # @return [Boolean] `true` if the component is bound to any force, `false` otherwise
           def bindings?
-            forces.count > 0
+            forces.count&.positive?
           end
 
           # If the field has bindings they are replaced by this new field
@@ -168,10 +167,10 @@ module Ecoportal
             if fld.section
               fld.move(section: self.section, before: self)
             else
-              self.section.add(fld, before: self)
+              section.add(fld, before: self)
             end
             replace_bindings(fld)
-            self.delete!
+            delete!
           end
 
           def replace_bindings(fld)
@@ -180,12 +179,12 @@ module Ecoportal
 
           def delete!
             bindings.each {|b| b.delete!}
-            self.unattach!
-            self._parent.delete!(self)
+            unattach!
+            _parent.delete!(self)
           end
 
           def move(section:, before: nil, after: nil, side: nil)
-            self.unattach!
+            unattach!
             section.add_component(self, before: before, after: after, side: side)
           end
 
@@ -212,9 +211,7 @@ module Ecoportal
               when :hide_reports
                 self.hidden_on_reports = true
               when Hash
-                if cnf.key?(:global)
-                  self.global_binding = cnf[:global]
-                end
+                self.global_binding = cnf[:global] if cnf.key?(:global)
               else
                 unused.push(cnf)
               end
@@ -222,7 +219,6 @@ module Ecoportal
               raise "Unsupported configuration options '#{unused}' for #{self.class}" unless unused.empty?
             end
           end
-
         end
       end
     end

data/lib/ecoportal/api/v2/page/components.rb

@@ -5,28 +5,28 @@ module Ecoportal
         class Components < Common::Content::CollectionModel
           class_resolver :component_class, "Ecoportal::API::V2::Page::Component"
 
-          self.klass do |doc|
+          klass do |doc|
             component_class.get_class(doc).tap do |klass|
               klass.key = :id
             end
           end
 
-          order_matters = true
+          #self.order_matters = true
 
           def ooze
-            self._parent.ooze
+            _parent.ooze
           end
 
           # @return [Ecoportal::API::V2::Page::Component] the field with `id`
           def get_by_id(id)
-            self.find do |comp|
+            find do |comp|
               comp.id == id
             end
           end
 
           # @return [Array<Ecoportal::API::V2::Page::Component>] the fields of that `type`
           def get_by_type(type)
-            self.select do |comp|
+            select do |comp|
               comp.type.downcase == type.to_s.strip.downcase
             end
           end
@@ -53,19 +53,19 @@ module Ecoportal
           def add(doc: nil, label: doc && doc["label"], type: doc && doc["type"])
             fld_doc = doc ? JSON.parse(doc.to_json) : component_class.new_doc(type: type)
             upsert!(fld_doc) do |fld|
-              fld.label  = label if !doc
-              yield(fld) if block_given?
+              fld.label = label unless doc
+              yield(fld)        if block_given?
             end
           end
 
           # @return [Array<Ecoportal::API::V2::Page::Component>] **orphaned** fields (with no section).
           def unattached
-            select {|comp| !comp.attached?}
+            reject(&:attached?)
           end
 
           # @return [Array<Ecoportal::API::V2::Page::Component>] fields belonging to more than one section.
           def multi_section
-            select {|comp| comp.multi_section?}
+            select(&:multi_section?)
           end
         end
       end