ecoportal-api-v2 2.0.12 → 2.0.14

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

@@ -0,0 +1,40 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Model
+            module NumericKey
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+
+                  # to be able to call super:
+                  include_missing(base, CollectionModel::Modifiers::ItemsKey)
+                  include_missing(base, Model::Iterable)
+                  base.send(:include, InstanceMethods)
+                end
+              end
+
+              # INSTANCE METHODS
+              module InstanceMethods
+                # Gets the `key` value of the object `value`.
+                # @note its name could be `fetch_key`.
+                # @return [String] the **value** of the `key`
+                #   on the object `value`.
+                def get_key(value)
+                  return super unless value.is_a?(Numeric)
+
+                  # get_key(_items[value])
+                  get_key(to_a[value])
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Model
+            module VarTracking
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+
+                  # to support call to super:
+                  include_missing(base, DoubleModel::VarTracking)
+                  include_missing(base, Model::Items)
+                  include_missing(base, Model::NumericKey)
+                  include_missing(base, Model::Cache)
+                  base.send(:include, InstanceMethods)
+                end
+              end
+
+              module InstanceMethods
+                # protected
+
+                private # moved to private
+
+                # Helper to remove tracked down instance variables
+                def variable_remove!(key)
+                  if @items_by_key && (k = get_key(key)) && (item = @items_by_key[k])
+                    _items.delete(item) if _items.include?(item)
+                    @items_by_key.delete(k)
+                  else
+                    super
+                  end
+                end
+
+                # Removes all the persistent variables
+                def variables_remove!
+                  @indexed = false
+                  super
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'ecoportal/api/common/content/collection_model/model/items'
+require 'ecoportal/api/common/content/collection_model/model/iterable'
+require 'ecoportal/api/common/content/collection_model/model/numeric_key'
+require 'ecoportal/api/common/content/collection_model/model/cache'
+require 'ecoportal/api/common/content/collection_model/model/var_tracking'
+require 'ecoportal/api/common/content/collection_model/model/lookup'
+
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Model
+            class << self
+              include Content::Includer
+
+              def included(base)
+                super
+
+                include_missing(base, Items)
+                include_missing(base, Iterable)
+                include_missing(base, NumericKey)
+                include_missing(base, Cache)
+                include_missing(base, VarTracking)
+                include_missing(base, Lookup)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Modifiers
+            module ItemsKey
+              class << self
+                def included(base)
+                  super
+                  base.extend Content::ClassHelpers
+                  base.extend ClassMethods
+                  base.inheritable_class_vars :items_key
+                end
+              end
+
+              module ClassMethods
+                # The attr that has been defined as `passkey`
+                # in the item class
+                def items_key
+                  @items_key ||= 'id'
+                end
+
+                def items_key=(value)
+                  @items_key = value && value.to_s.freeze
+                end
+              end
+
+              # INSTANCE METHODS
+
+              protected
+
+              def items_key
+                self.class.items_key
+              end
+
+              # Gets the `key` value of the object `value`.
+              # @note its name could be `fetch_key`.
+              # @return [String] the **value** of the `key`
+              #   on the object `value`.
+              def get_key(value)
+                case value
+                when Content::DoubleModel
+                  value.key
+                when Hash
+                  value[items_key]
+                when String
+                  value
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Modifiers
+            module ItemsKlass
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+                  base.extend Content::ClassHelpers
+
+                  include_missing(base, Modifiers::ItemsKey)
+
+                  base.extend ClassMethods
+                  base.inheritable_class_vars :klass, :new_item
+                end
+              end
+
+              module ClassMethods
+                NOT_USED = Content::ClassHelpers::NOT_USED
+
+                attr_writer :klass
+
+                # 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
+
+                # @return [Boolean] are there the factory logics to build item objects defined?
+                def klass?
+                  @klass || @new_item
+                end
+
+                # Resolves to the nuclear `Class` of the elements
+                # @note
+                #   - 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 [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.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|
+                    next unless result.is_a?(Class)
+                    next unless result < Ecoportal::API::Common::Content::DoubleModel
+
+                    self.items_key = result.key
+                  end
+                end
+
+                # Generates a new object of the target class
+                # @note
+                #   - use block to define `new_item` callback, which will prevail over `klass`
+                #   - if `new_item` callback was **not** defined, it is required to defnie `klass`
+                # @param doc [Hash] doc to parse
+                # @note if block is given, it ignores `doc`
+                # @yield [doc, parent, key] creates an object instance of the target `klass`
+                # @yieldparam doc [Hash]
+                # @yieldreturn [Klass] instance object of the target `klass`
+                # @param parent [CollectionModel] the parent of the new item
+                # @param 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.
+                # @param read_only [Boolean] whether or not this new element should be
+                #   created as read-only.
+                # @return [Klass] instance object of the target `klass`
+                def new_item(doc = NOT_USED, parent: nil, key: nil, read_only: false, &block)
+                  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)
+
+                  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)
+
+                  target_class = klass(doc)
+                  raise "Could not find a class for: #{doc}" unless target_class
+
+                  return doc if doc.is_a?(target_class)
+
+                  target_class.new(doc, parent: parent, key: key, read_only: read_only)
+                end
+              end
+
+              # INSTANCE METHODS
+
+              # @return [Class] the class of the elements of the Collection
+              def items_class
+                self.class.klass
+              end
+
+              private
+
+              def new_item(value)
+                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
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Modifiers
+            module ItemsOrder
+              class << self
+                def included(base)
+                  super
+                  base.extend Content::ClassHelpers
+                  base.extend ClassMethods
+                  base.inheritable_class_vars :order_matters, :order_key
+                end
+              end
+
+              module ClassMethods
+                attr_accessor :order_matters, :order_key
+              end
+
+              # INSTANCE METHODS
+
+              protected
+
+              def order_matters?
+                self.class.order_matters
+              end
+
+              def uniq?
+                self.class.uniq
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'ecoportal/api/common/content/collection_model/modifiers/items_key'
+require 'ecoportal/api/common/content/collection_model/modifiers/items_klass'
+require 'ecoportal/api/common/content/collection_model/modifiers/items_order'
+
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Modifiers
+            class << self
+              include Content::Includer
+
+              def included(base)
+                super
+
+                include_missing(base, ItemsKey)
+                include_missing(base, ItemsKlass)
+                include_missing(base, ItemsOrder)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Mutation
+            module Clear
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+                  include_missing(base, CollectionModel::Model::Iterable)
+                  include_missing(base, Mutation::Delete)
+                end
+              end
+
+              # INSTANCE METHODS
+
+              # Deletes all the elements of this `CollectionModel` instance
+              def clear
+                to_a.each {|item| delete!(item)}
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Mutation
+            module Delete
+              class << self
+                def included(base)
+                  super
+                  base.send(:include, CollectionModel::Doc::Items)
+                  base.send(:include, CollectionModel::Model::Lookup)
+                  base.send(:include, CollectionModel::DocMutation::Delete)
+                end
+              end
+
+              # INSTANCE METHODS
+
+              # Deletes `value` from this `CollectionModel` instance.
+              # @param value [String, Hash, Ecoportal::API::Common::Content::DoubleModel]
+              #   - When used as `String`, the `key` value (i.e. `id` value) is expected.
+              #   - When used as `Hash`, it should be the `doc` of the target element.
+              #   - When used as `DoubleModel`, it should be the specific object to be deleted.
+              def delete!(value)
+                unless value.is_a?(Hash) || value.is_a?(Content::DoubleModel) || value.is_a?(String)
+                  msg = 'Content::DoubleModel or Hash doc required'
+                  raise ArgumentError, msg
+                end
+
+                return unless (item = self[value])
+
+                _doc_delete(item.doc)
+                @indexed = false
+                _items.delete(item)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Mutation
+            module Upsert
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+                  base.extend Content::ClassHelpers
+
+                  include_missing(base, CollectionModel::Modifiers::ItemsKlass)
+                  include_missing(base, CollectionModel::Model::Items)
+                  include_missing(base, CollectionModel::Model::Lookup)
+                  include_missing(base, CollectionModel::DocMutation::Upsert)
+                end
+              end
+
+              # INSTANCE METHODS
+
+              # Tries to find the element `value`, if it exists, it updates it
+              #   Otherwise it pushes it to the end
+              # @value [Hash, Ecoportal::API::Common::Content::DoubleModel] the eleement to be added
+              # @return [Object] the `items_class` element object
+              def upsert!(value, pos: NOT_USED, before: NOT_USED, after: NOT_USED)
+                unless value.is_a?(Hash) || value.is_a?(Content::DoubleModel)
+                  msg = "'Content::DoubleModel' or 'Hash' doc required. Given #{value.class}"
+                  raise ArgumentError, msg
+                end
+
+                item_doc = value.is_a?(Content::DoubleModel)? value.doc : value
+                item_doc = JSON.parse(item_doc.to_json)
+
+                if (item = self[value])
+                  item.replace_doc(item_doc)
+                else
+                  _doc_upsert(item_doc, pos: pos, before: before, after: after).tap do |pos_idx|
+                    _items.insert(pos_idx, new_item(item_doc))
+                    @indexed = false
+                  end
+                end
+
+                (item || self[item_doc]).tap do |itm|
+                  yield(itm) if block_given?
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'ecoportal/api/common/content/collection_model/mutation/delete'
+require 'ecoportal/api/common/content/collection_model/mutation/upsert'
+require 'ecoportal/api/common/content/collection_model/mutation/clear'
+
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class CollectionModel
+          module Mutation
+            class << self
+              include Content::Includer
+
+              def included(base)
+                super
+
+                include_missing(base, Upsert)
+                include_missing(base, Delete)
+                include_missing(base, Clear)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end