ecoportal-api-v2 1.1.7 → 2.0.0

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,22 +60,24 @@ 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
 
           # If the class for `name` exists, it returns it. Otherwise it generates it.
           # @param name [String, Symbol] the name of the new class
           # @param inherits [Class] the parent class to _inherit_ from
-          # @param namespace [Class, String] an existing `constant` (class or module) the new class will be namespaced on
+          # @param namespace [Class, String] an existing `constant` (class or module)
+          #   the new class will be namespaced on
           # @yield [child_class] configure the new class
           # @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)
+            target_class = resolve_class("#{namespace}::#{class_name}", exception: false)
 
-            unless target_class = resolve_class("#{namespace}::#{class_name}", exception: false)
+            unless target_class
               target_class = Class.new(inherits)
               Kernel.const_get(namespace.to_s).const_set class_name, target_class
             end
@@ -92,19 +94,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
@@ -133,9 +133,11 @@ module Ecoportal
           # Builds the attr_reader and attr_writer of `attrs` and registers the associated instance variable as inheritable.
           def inheritable_attrs(*attrs)
             attrs.each do |attr|
-              class_eval %(
-                class << self; attr_accessor :#{attr} end
-              )
+              class_eval <<-DEF_CLSS_ATTR, __FILE__, __LINE__ + 1
+                class << self            # class << self
+                  attr_accessor :#{attr} #   attr_accessor :coolio
+                end                      # end
+              DEF_CLSS_ATTR
             end
             inheritable_class_vars(*attrs)
           end
@@ -147,6 +149,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

@@ -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,13 +136,13 @@ 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}}}"
               end
             else
-              show_str = \
+              show_str =
                 case value
                 when Hash
                   value.pretty_inspect
@@ -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
+            elem        = self[value]
+            current_pos = nil
+            current_pos = _doc_key(elem) if elem
 
             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 -= 1 unless pos <= current_pos
             end
 
-            pos = (pos && pos < _doc_items.length)? pos : _doc_items.length
-            pos.tap do |i|
+            pos = _doc_items.length unless pos && pos < _doc_items.length
+
+            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