ecoportal-api-v2 2.0.11 → 2.0.14

data/lib/ecoportal/api/common/content/double_model/double_doc/replaceable_doc.rb

@@ -0,0 +1,61 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module DoubleDoc
+            module ReplaceableDoc
+              include DoubleModel::VarTracking
+
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+
+                  include_missing(base, DoubleModel::HashHelpers)
+                  include_missing(base, DoubleDoc::Base)
+                  include_missing(base, DoubleDoc::RootedKey)
+                  include_missing(base, DoubleDoc::LinkableDoc)
+                end
+              end
+
+              # INSTANCE METHODS
+
+              def replace_doc(new_doc)
+                return (@doc = new_doc) if root?
+
+                unless linked?
+                  raise UnlinkedModel.new(
+                    from: "#{self.class}##{__method__}",
+                    key:  _parent_key
+                  )
+                end
+
+                dig_set(_parent.doc, resolved_rooted_doc_key, new_doc)
+
+                _parent.variable_remove!(_parent_key) unless new_doc
+                #variables_remove!
+              end
+
+              protected
+
+              def replace_original_doc(new_doc)
+                return (@original_doc = new_doc) if root?
+
+                unless linked?
+                  raise UnlinkedModel.new(
+                    from: "#{self.class}##{__method__}",
+                    key:  _parent_key
+                  )
+                end
+
+                dig_set(_parent.original_doc, resolved_rooted_doc_key, new_doc)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/content/double_model/double_doc/reset_consolidate.rb

@@ -0,0 +1,54 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module DoubleDoc
+            module ResetConsolidate
+              include DoubleModel::VarTracking
+
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+
+                  include_missing(base, DoubleDoc::Base)
+                  include_missing(base, DoubleDoc::RootedKey)
+                  include_missing(base, DoubleDoc::LinkableDoc)
+                  include_missing(base, DoubleDoc::ReplaceableDoc)
+                end
+              end
+
+              # INSTANCE METHODS
+
+              # It makes `original_doc` to be like `doc`
+              # @note
+              #   - after executing it, there will be no pending changes
+              #   - you should technically run this command, after a successful update request to the server
+              def consolidate!
+                replace_original_doc(JSON.parse(doc.to_json))
+              end
+
+              # It makes `doc` to be like `original`
+              # @note
+              #   - after executing it, changes in `doc` will be lost
+              #   - you should technically run this command only if you want to remove certain changes
+              # @key [Symbol] the specific part of the model you want to `reset`
+              def reset!(key = nil)
+                if key
+                  keys    = [key].flatten.compact
+                  odoc    = original_doc.dig(*keys)
+                  odoc  &&= JSON.parse(odoc.to_json)
+                  dig_set(doc, keys, odoc)
+                else
+                  replace_doc(JSON.parse(original_doc.to_json))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/content/double_model/double_doc/rooted_key.rb

@@ -0,0 +1,49 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module DoubleDoc
+            module RootedKey
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+
+                  include_missing(base, DoubleDoc::Base)
+                end
+              end
+
+              # INSTANCE METHODS
+
+              # Offers a method for child classes to transform the key,
+              # provided that the child's `doc` can be accessed.
+              # @note this method can't be protected. It might be accessed by cousing classes.
+              #   See last line of this method.
+              #   parent class to a child class.
+              def _rooted_doc_key(value)
+                #print "!(#{value}<=#{self.class})" if value.is_a?(Content::DoubleModel) && !value.root?
+                return value unless value.is_a?(Content::DoubleModel)
+                return value if value.root?
+
+                #print "?(#{value.class}<=#{value._parent.class})"
+                value._parent._rooted_doc_key(value)
+              end
+              # alias_method :_doc_key, :_rooted_doc_key
+
+              protected
+
+              # @note this method can be protected... not accessed from
+              #   parent class to child class.
+              def resolved_rooted_doc_key
+                [_rooted_doc_key(_parent_key)].flatten
+              end
+              # alias_method :resolved_doc_key, :resolved_rooted_doc_key
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/content/double_model/double_doc.rb

@@ -0,0 +1,31 @@
+require 'ecoportal/api/common/content/double_model/double_doc/base'
+require 'ecoportal/api/common/content/double_model/double_doc/rooted_key'
+require 'ecoportal/api/common/content/double_model/double_doc/linkable_doc'
+require 'ecoportal/api/common/content/double_model/double_doc/replaceable_doc'
+require 'ecoportal/api/common/content/double_model/double_doc/reset_consolidate'
+
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module DoubleDoc
+            class << self
+              include Content::Includer
+
+              def included(base)
+                super
+
+                include_missing(base, Base)
+                include_missing(base, RootedKey)
+                include_missing(base, LinkableDoc)
+                include_missing(base, ReplaceableDoc)
+                include_missing(base, ResetConsolidate)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/content/double_model/hash_helpers.rb

@@ -0,0 +1,40 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module HashHelpers
+            private
+
+            # It sets `value` on the last object that you would get
+            # via `obj.dig(*keys[0..-1])`
+            # @note equivalent to `obj.dig(*keys[0..-1])&[keys.last] = value`
+            def dig_set(obj, keys, value)
+              if keys.length == 1
+                obj[keys.first] = value
+              else
+                dig_set(obj[keys.first], keys.slice(1..-1), value)
+              end
+            end
+
+            # It sets `value` on the last object that you would get
+            # via `obj.dig(*keys[0..-1])`
+            # @note equivalent to
+            #   1. `parent = obj.dig(*keys[0..-1])`
+            #   2. `parent.delete(keys.last) if parent.is_a?(Hash)`
+            # @return [Variant] the value of that key
+            def dig_delete(obj, keys)
+              if keys.length == 1
+                return unless obj.respond_to?(:delete)
+
+                obj.delete(keys.first)
+              else
+                dig_delete(obj[keys.first], keys.slice(1..-1))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/content/double_model/modifiers/read_only_able.rb

@@ -0,0 +1,73 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module Modifiers
+            module ReadOnlyAble
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+                  base.extend Content::ClassHelpers
+
+                  include_missing(base, DoubleModel::Parented)
+                  include_missing(base, Modifiers::Rootable)
+
+                  base.extend ClassMethods
+                  base.inheritable_class_vars :read_only
+                end
+              end
+
+              module ClassMethods
+                # @note when defined as root of the model, it isn't read-only
+                def read_only?
+                  @read_only = false if @read_only.nil?
+                  return false if root?
+
+                  @read_only
+                end
+
+                # Be able to define if a class should be read-only
+                # @note this propagates to all the nested models thereof.
+                def read_only!
+                  @read_only = true
+                end
+              end
+
+              # INSTANCE METHODS
+
+              # @note `read_only` allows for some optimizations, such as storing values
+              #   in instance variables, for optimization purposes
+              def read_only?
+                _read_only || false
+              end
+
+              protected
+
+              def _read_only
+                @_read_only = self.class.read_only? if @_read_only.nil?
+                @_read_only
+              end
+
+              # @return [Boolean] whether this should be the root of the model
+              def to_be_root?
+                return true if _parent == self
+                return true if read_only?
+
+                self.class.root?
+              end
+
+              private
+
+              def read_only!
+                @_read_only = true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/content/double_model/modifiers/rootable.rb

@@ -0,0 +1,64 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module Modifiers
+            module Rootable
+              class << self
+                include Content::Includer
+
+                def included(base)
+                  super
+
+                  include_missing(base, DoubleModel::Parented)
+
+                  base.extend ClassMethods
+                end
+              end
+
+              module ClassMethods
+                # @return [Boolean] whether this is the top of the doc model
+                #   and should not make its nested models read-only (rooted on their own)
+                def root?
+                  @start_root
+                end
+
+                # @note that this method stops the propagation of read_only!
+                # @note that this method only affects the current model.
+                def root!
+                  @start_root = false if @start_root.nil?
+                  @start_root = true
+                end
+              end
+
+              # INSTANCE METHODS
+
+              def root
+                return self if root?
+
+                _parent.root
+              end
+
+              protected
+
+              def doc_var?
+                !!defined?(@doc)
+              end
+
+              # Both requisites
+              # @note that for optimization purposes, `@doc` var may be used when
+              #   the object is `read_only?`
+              # @note we check on @doc instance variable defined, to ensure what
+              #   we have already rooted this object's subjacent model (doc)
+              #   within itself.
+              def root?
+                _parent == self && doc_var?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'ecoportal/api/common/content/double_model/modifiers/rootable'
+require 'ecoportal/api/common/content/double_model/modifiers/read_only_able'
+
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module Modifiers
+            class << self
+              include Content::Includer
+
+              def included(base)
+                super
+                include_missing(base, ReadOnlyAble)
+                include_missing(base, Rootable)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/content/double_model/parented.rb

@@ -0,0 +1,22 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module Parented
+            attr_reader :_parent, :_parent_key
+
+            # `_key` refers to the `_parent`'s property that links to this model.
+            # @note on the other hand, `key` rather refers to the **value**
+            #   of the key property (identifies an item in a set of elements)
+            alias_method :_key, :_parent_key
+
+            protected
+
+            attr_writer :_parent, :_parent_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/common/content/double_model/var_tracking.rb

@@ -0,0 +1,45 @@
+module Ecoportal
+  module API
+    module Common
+      module Content
+        class DoubleModel
+          module VarTracking
+            protected
+
+            # Helper to track down persistent variables
+            def variable_set(key, value)
+              var = instance_variable_name(key)
+              _dim_vars.push(var).uniq!
+              instance_variable_set(var, value)
+            end
+
+            # Helper to remove tracked down instance variables
+            def variable_remove!(key)
+              var = instance_variable_name(key)
+              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 {|var| variable_remove!(var)}
+            end
+
+            private
+
+            def _dim_vars
+              @_dim_vars ||= []
+            end
+
+            def instance_variable_name(key)
+              self.class.instance_variable_name(key)
+            end
+          end
+        end
+      end
+    end
+  end
+end