ecoportal-api-v2 1.1.6 → 1.1.8

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

@@ -5,7 +5,7 @@ module Ecoportal
       module Content
         module ClassHelpers
           include Common::BaseClass
-          NOT_USED = "no_used!"
+          NOT_USED = "no_used!".freeze
 
           # Class resolver
           # @note it caches the resolved `klass`es
@@ -18,21 +18,21 @@ module Ecoportal
             @resolved ||= {}
             @resolved[klass] ||=
               case klass
-                when Class
-                  klass
-                when String
-                  begin
-                    Kernel.const_get(klass)
-                  rescue NameError => e
-                    raise if exception
-                  end
-                when Symbol
-                  source_class.resolve_class(source_class.send(klass))
-                when Hash
-                  referrer, referred = klass.first
-                  resolve_class(referred, source_class: referrer, exception: exception)
-                else
-                  raise "Unknown class: #{klass}" if exception
+              when Class
+                klass
+              when String
+                begin
+                  Kernel.const_get(klass)
+                rescue NameError
+                  raise if exception
+                end
+              when Symbol
+                source_class.resolve_class(source_class.send(klass))
+              when Hash
+                referrer, referred = klass.first
+                resolve_class(referred, source_class: referrer, exception: exception)
+              else
+                raise "Unknown class: #{klass}" if exception
               end
           end
 
@@ -41,11 +41,11 @@ module Ecoportal
           # @param key [String, Symbol] to be normalized
           # @return [String] a correct constant name
           def to_constant(key)
-            str_name = key.to_s.strip.split(/::/).compact.map do |str|
+            key.to_s.strip.split(/::/).compact.map do |str|
               str.slice(0).upcase + str.slice(1..-1)
-            end.join("").split(/[\-\_ :]+/i).compact.map do |str|
+            end.join.split(/[\-\_ :]+/i).compact.map do |str|
               str.slice(0).upcase + str.slice(1..-1)
-            end.join("")
+            end.join
           end
 
           # Helper to create an instance variable `name`
@@ -60,7 +60,7 @@ module Ecoportal
           # Generates random ids in hexadecimal to use in class name generation.
           # @param len [Integeter] length of the `uid`
           # @return [String] a random unique id of length `len`
-          def uid(len = 8);
+          def uid(len = 8)
             SecureRandom.hex(len/2)
           end
 
@@ -72,8 +72,8 @@ module Ecoportal
           # @yieldparam child_class [Class] the new class
           # @return [Class] the new generated class
           def new_class(name = "Child#{uid}", inherits: self, namespace: inherits)
-            name            = name.to_s.to_sym.freeze
-            class_name      = to_constant(name)
+            name       = name.to_s.to_sym.freeze
+            class_name = to_constant(name)
 
             unless target_class = resolve_class("#{namespace}::#{class_name}", exception: false)
               target_class = Class.new(inherits)
@@ -92,19 +92,17 @@ module Ecoportal
           # @return
           def to_time(value, exception: true)
             case value
-            when NilClass
+            when Time, NilClass
               value
             when String
               begin
                 Time.parse(value)
-              rescue ArgumentArgument => e
+              rescue ArgumentArgument
                 raise if exception
                 nil
               end
             when Date
               Time.parse(value.to_s)
-            when Time
-              value
             else
               to_time(value.to_s) if value.respond_to?(:to_s)
             end
@@ -147,6 +145,7 @@ module Ecoportal
           #   - mutating methods would reflect the changes on other classes as well
           #   - therefore, `freeze` will be called on the values that are inherited.
           def inherited(subclass)
+            super
             inheritable_class_vars.each do |var|
               instance_var = instance_variable_name(var)
               value        = instance_variable_get(instance_var)

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

@@ -6,7 +6,6 @@ module Ecoportal
         # @note to be able to refer to the correct element of the Collection,
         #   it is required that those elements have a unique `key` that allows to identify them
         class CollectionModel < Content::DoubleModel
-
           class << self
             attr_writer   :klass
             attr_accessor :order_matters, :order_key
@@ -26,24 +25,27 @@ module Ecoportal
             #   - use block to define `klass` callback
             # @note When `klass` is resolved, if the items are of type
             #   `DoubleModel`, it sets on the collection class the `items_key`
+            # @note when `klass` is directly resolved (not via doc) only once
+            #    it will set @klass as resolved and will use this class from now on.
+            #    This is an optimization to cut class lookups
             # @param value [Hash] base `doc` (raw object) to create the object with
             # @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)
-              if block
-                @klass = block
-                block.call(value) if value != NOT_USED
+              @klass = block if block_given?
+
+              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
-              elsif used_param?(value)
-                if @klass.is_a?(Proc)
-                  @klass.call(value)
-                else
-                  resolve_class(@klass, exception: false)
-                end
               else
-                resolve_class(@klass, exception: false)
+                @klass
               end.tap do |result|
                 next unless result.is_a?(Class)
                 next unless result < Ecoportal::API::Common::Content::DoubleModel
@@ -51,6 +53,19 @@ module Ecoportal
               end
             end
 
+            # @return [Boolean] are there the factory logics to build item objects defined?
+            def klass?
+              @klass || @new_item
+            end
+
+            # Optimization
+            def new_item_class_based?
+              return false if @new_item.is_a?(Proc)
+              return false if klass.is_a?(Proc)
+              return true  if klass.is_a?(Class)
+              false
+            end
+
             # Generates a new object of the target class
             # @note
             #   - use block to define `new_item` callback, which will prevail over `klass`
@@ -60,36 +75,27 @@ module Ecoportal
             # @yield [doc, parent, key] creates an object instance of the target `klass`
             # @yieldparam doc [Hash]
             # @yieldreturn [Klass] instance object of the target `klass`
+            # @parent [CollectionModel] the parent of the new item
+            # @key [Symbol, String] the key value to access the item within collection
+            #   Please observe that items in a CollectionModel are identified via their key attr.
+            #   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)
-              if block
+              if block_given?
                 @new_item = block
-              elsif used_param?(doc)
-                raise "You should define either a 'klass' or a 'new_item' callback first" unless klass?
-                if @new_item
-                  @new_item.call(doc, parent, key)
-                else
-                  if target_class = self.klass(doc)
-                    doc.is_a?(target_class) ? doc : target_class.new(doc, parent: parent, key: key, read_only: read_only)
-                  else
-                    raise "Could not find a class for: #{doc}"
-                  end
-                end
-              else
-                raise "To define the 'new_item' callback (factory), you need to use a block"
+                return
               end
-            end
 
-            # @return [Boolean] are there the factory logics to build item objects defined?
-            def klass?
-              @klass || @new_item
-            end
+              msg = "To define the 'new_item' callback (factory), you need to use a block"
+              raise msg unless used_param?(doc)
+              msg = "You should define either a 'klass' or a 'new_item' callback first"
+              raise msg unless klass?
+              return @new_item.call(doc, parent, key)    if @new_item.is_a?(Proc)
 
-            def doc_class(name)
-              dim_class = new_class(name, inherits: Common::Content::ArrayModel) do |klass|
-                klass.order_matters = order_matters
-                klass.uniq          = uniq
-              end
+              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
           end
 
@@ -98,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
@@ -130,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}}}"
@@ -150,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
@@ -166,6 +180,7 @@ module Ecoportal
               _doc_items.each do |item_doc|
                 elements << new_item(item_doc)
               end
+              @_items = elements if read_only?
             end
           end
 
@@ -198,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|
@@ -206,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
@@ -225,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
@@ -253,7 +275,7 @@ module Ecoportal
             when String
               value
             when Numeric
-              get_key(self.to_a[value])
+              get_key(to_a[value])
             end
           end
 
@@ -275,7 +297,11 @@ module Ecoportal
           private
 
           def new_item(value)
-            self.class.new_item(value, parent: self, read_only: self._read_only)
+            if self.class.new_item_class_based?
+              self.class.klass.new(value, parent: self, read_only: _read_only)
+            else
+              self.class.new_item(value, parent: self, read_only: _read_only)
+            end
           end
 
           # Helper to remove tracked down instance variables
@@ -297,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