isomorfeus-data 2.4.2 → 2.5.0

data/lib/isomorfeus_data/lucid_object/mixin.rb

@@ -1,18 +1,14 @@
 module LucidObject
   module Mixin
     def self.included(base)
-      base.include(Isomorfeus::Data::AttributeSupport)
+      base.include(Isomorfeus::Data::FieldSupport)
       base.extend(Isomorfeus::Data::GenericClassApi)
       base.include(Isomorfeus::Data::GenericInstanceApi)
       base.include(LucidI18n::Mixin)
 
       base.instance_exec do
-        def store_compressed(quality: 5)
-          @_store_compressed = quality
-        end
-
-        def _store_compressed
-          @_store_compressed
+        def escape_string(s)
+          s.gsub(/([\\\&\:\(\)\[\]\{\}\!\"\~\^\|\<\>\=\*\?\+\-\s])/, '\\\\\1')
         end
       end
 
@@ -29,220 +25,186 @@ module LucidObject
       end
 
       def to_transport
-        hash = { 'attributes' => _get_selected_attributes }
+        hash = { 'fields' => _get_selected_fields }
         hash['revision'] = revision if revision
         result = { @class_name => { @key => hash }}
-        result.deep_merge!(@class_name => { @previous_key => { new_key: @key}}) if @previous_key
+        result.deep_merge!(@class_name => { @previous_key => { new_key: @key }}) if @previous_key
         result
       end
 
+      def included_items_to_transport
+        f = fields
+        data_hash = {}
+        self.class.field_types.each do |field, type|
+          if type == :object
+            v = f[field]
+            if v
+              data_hash.deep_merge!(v.to_transport)
+              if v.respond_to?(:included_items_to_transport)
+                data_hash.deep_merge!(v.included_items_to_transport)
+              end
+            end
+          end
+        end
+        data_hash
+      end
+
       if RUBY_ENGINE == 'opal'
-        def initialize(key: nil, revision: nil, attributes: nil, _loading: false)
+        def initialize(key: nil, revision: nil, fields: nil, _loading: false, attributes: nil)
           @key = key.nil? ? SecureRandom.uuid : key.to_s
           @class_name = self.class.name
           @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
           _update_paths
           @_revision = revision ? revision : Redux.fetch_by_path(:data_state, :revision, @class_name, @key)
+          @_objects = {}
           @_changed = false
           loaded = loaded?
+          fields = attributes if attributes
           if loaded
-            raw_attributes = Redux.fetch_by_path(*@_store_path)
-            if `raw_attributes === null`
-              if attributes
-                _validate_attributes(attributes)
-                @_changed_attributes = attributes
+            raw_fields = Redux.fetch_by_path(*@_store_path)
+            if `raw_fields === null`
+              if fields
+                _validate_fields(fields)
+                @_changed_fields = fields
               else
-                @_changed_attributes = {}
+                @_changed_fields = {}
               end
-            elsif raw_attributes && attributes && ::Hash.new(raw_attributes) != attributes
-              _validate_attributes(attributes)
-              @_changed_attributes = attributes
+            elsif raw_fields && fields && ::Hash.new(raw_fields) != fields
+              _validate_fields(fields)
+              @_changed_fields = fields
             else
-              @_changed_attributes = {}
+              @_changed_fields = {}
             end
           else
-            attributes = {} unless attributes
-            _validate_attributes(attributes) unless _loading
-            @_changed_attributes = attributes
+            fields = {} unless fields
+            _validate_fields(fields) unless _loading
+            @_changed_fields = fields
           end
         end
 
         def _load_from_store!
-          @_changed_attributes = {}
+          @_changed_fields = {}
+          @_objects = {}
           @_changed = false
         end
 
         def _update_paths
-          @_store_path = [:data_state, @class_name, @key, :attributes]
+          @_store_path = [:data_state, @class_name, @key, :fields]
         end
 
         def each(&block)
-          attributes.each(&block)
+          fields.each(&block)
         end
       else # RUBY_ENGINE
         Isomorfeus.add_valid_data_class(base) unless base == LucidObject::Base
 
         base.instance_exec do
-          def instance_from_transport(instance_data, _included_items_data)
+          def instance_from_transport(instance_data, included_items_data, _already_loaded = {})
             key = instance_data[self.name].keys.first
+            ref_s = gen_ref_s(key)
+            return _already_loaded[ref_s] if _already_loaded.key?(ref_s)
             revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            attributes = instance_data[self.name][key].key?('attributes') ? instance_data[self.name][key]['attributes'].transform_keys!(&:to_sym) : nil
-            new(key: key, revision: revision, attributes: attributes)
+            data_obj = new(key: key, revision: revision)
+            _already_loaded[ref_s] = data_obj
+            fields = instance_data[self.name][key].key?('fields') ? instance_data[self.name][key]['fields'].transform_keys(&:to_sym) : nil
+            if fields
+              field_types.each do |field, type|
+                if type == :object
+                  sid = fields[field]
+                  if sid
+                    o_class_name = sid[0]
+                    raise "invalid data class #{type_class_name}" unless Isomorfeus.valid_data_class_name?(o_class_name)
+                    o_class = Isomorfeus.cached_data_class(o_class_name)
+                    o_data = { o_class_name => { sid[1] => included_items_data[o_class_name][sid[1]] }}
+                    if included_items_data && !included_items_data[self.name]&.key?(key)
+                      included_items_data.deep_merge!(instance_data)
+                    end
+                    fields[field] = o_class.instance_from_transport(o_data, included_items_data, _already_loaded)
+                  end
+                end
+              end
+            end
+            data_obj._validate_fields(fields)
+            data_obj.fields.merge!(fields)
+            data_obj
           end
 
           def props_from_data(instance_data)
             key = instance_data[self.name].keys.first
             revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
-            attributes = instance_data[self.name][key].key?('attributes') ? instance_data[self.name][key]['attributes'].transform_keys!(&:to_sym) : nil
-            LucidProps.new({ key: key, revision: revision }.merge!(attributes))
-          end
-
-          def setup_environment(&block)
-            @_setup_environment_block = block
-          end
-
-          def setup_index(&block)
-            @_setup_index_block = block
-          end
-
-          def object_expander
-            return @object_expander if @object_expander
-            compress = _store_compressed
-            compress = false if compress.nil?
-            @object_expander = if @_setup_environment_block
-                                 Isomorfeus::Data::ObjectExpander.new(class_name: self.to_s, compress: compress, &@_setup_index_block)
-                               else
-                                 Isomorfeus::Data::ObjectExpander.new(class_name: self.to_s, compress: compress)
-                               end
+            fields = instance_data[self.name][key].key?('fields') ? instance_data[self.name][key]['fields'].transform_keys!(&:to_sym) : nil
+            LucidProps.new({ key: key, revision: revision }.merge!(fields))
           end
 
           def object_accelerator
-            return @object_accelerator if @object_accelerator
-            @object_accelerator = if @_setup_index_block
-                                     Isomorfeus::Data::ObjectAccelerator.new(self.to_s, &@_setup_index_block)
-                                   else
-                                     Isomorfeus::Data::ObjectAccelerator.new(self.to_s)
-                                   end
+            @object_accelerator ||= Isomorfeus::Data::ObjectAccelerator.new(self)
           end
 
-          def each(readonly: true, &block)
-            self.object_expander.each(readonly: readonly) do |obj|
-              block.call(obj) if obj.class == self
+          def each(&block)
+            self.object_accelerator.each do |fields|
+              block.call self.new(key: fields.delete(:key), fields: fields)
             end
           end
 
-          def search(attr, val, options = {})
-            idx_type = self.indexed_attributes[attr]
-            raise "Can only search indexed attributes, but attribute :#{attr} is not indexed!" unless idx_type
+          def search(field = nil, val = nil, options = {}, query: nil)
+            if field && !self.field_options[field]&.fetch(:index) == :yes
+              raise "Can only search indexed #{self.field_types{field}}s, but #{self.field_types{field}} :#{field} is not indexed!"
+            end
             objs = []
-            if idx_type == :text
-              query = "+value:#{val} +class_name:#{self.name}"
-              query << " +attribute:#{attr}" if attr != '*'
-              self.object_accelerator.search_each(query, options) do |id|
-                doc = self.object_accelerator.index.doc(id)&.load
-                if doc
-                  sid_s = doc[:sid_s_attr].split(':|:')[0]
-                  obj = self.load(key: sid_s)
-                  objs << obj if obj
-                end
-              end
-            else
-              if val == '*'
-                self.object_expander.each do |obj|
-                  objs << obj if obj.class == self
-                end
-              else
-                attr_s = ":[#{attr}]"
-                accept_all_attr = attr_s == ":[*]" ? true : false
-                self.object_expander.search(":[#{self.name}]:|:[:#{val}:]:") do |sid_s_attr|
-                  if accept_all_attr || sid_s_attr.end_with?(attr_s)
-                    sid_s = sid_s_attr.split(':|:[')[0]
-                    obj = self.load(key: sid_s)
-                    objs << obj if obj
-                  end
-                end
-              end
+            query = query ? query : "#{field}:#{val}"
+            self.object_accelerator.search_each(query, options) do |id|
+              fields = self.object_accelerator.load_object(id: id)
+              objs << self.new(key: fields.delete(:key), fields: fields)
             end
             objs
           end
 
-          execute_create do
+          execute_create do |_already_saved: {}|
             self.key = SecureRandom.uuid unless self.key
-            self.class.object_expander.create_object(self.sid_s, self)
-            self.class.indexed_attributes.each do |attr, idx_type|
-              if idx_type == :text
-                self._create_text_indexed_attribute(attr)
-              else
-                self._store_value_indexed_attribute(attr)
-              end
+            unless _already_saved.key?(self.ref_s)
+              _already_saved[self.ref_s] = self
+              self.class.object_accelerator.create_object(self.key, fields, _already_saved)
             end
             self
           end
 
           execute_destroy do |key:|
-            key = key.to_s
-            sid_s = key.start_with?('[') ? key : gen_sid_s(key)
-            self.object_expander.destroy_object(sid_s)
-            self.indexed_attributes.each do |attr, idx_type|
-              if idx_type == :text
-                self.object_accelerator.destroy_doc("#{sid_s}:|:[#{attr}]")
-              else
-                old_val = self.object_expander.index_get("#{sid_s}:|:[#{attr}]")
-                self.object_expander.index_delete("#{sid_s}:|:[#{attr}]", old_val)
-                self.object_expander.index_delete(":[#{self.name}]:|:[:#{old_val}:]:", "#{sid_s}:|:[#{attr}]")
-              end
-            end
+            self.object_accelerator.destroy_object(key.to_s)
             true
           end
 
-          execute_load do |key:|
-            key = key.to_s
-            sid_s = key.start_with?('[') ? key : gen_sid_s(key)
-            self.object_expander.load_object(sid_s)
+          execute_load do |key:, _already_loaded: {}|
+            ref_s = self.gen_ref_s(@key)
+            if _already_loaded.key?(ref_s)
+              _already_loaded[ref_s]
+            else
+              _already_loaded[ref_s] = true
+              fields = self.object_accelerator.load_object(key: key.to_s, already_loaded: _already_loaded)
+              obj = fields ? self.new(key: fields.delete(:key), fields: fields) : nil
+              _already_loaded[ref_s] = obj
+            end
           end
 
-          execute_save do
+          execute_save do |_already_saved: {}|
             self.key = SecureRandom.uuid unless self.key
-            self.class.object_expander.save_object(self.sid_s, self)
-            self.class.indexed_attributes.each do |attr, val|
-              if val == :text
-                self._store_text_indexed_attribute(attr)
-              else
-                self._store_value_indexed_attribute(attr)
-              end
+            unless _already_saved.key?(self.ref_s)
+              _already_saved[self.ref_s] = true
+              self.class.object_accelerator.save_object(self.key, fields, _already_saved)
             end
             self
           end
         end
 
-        def initialize(key: nil, revision: nil, attributes: nil)
+        def initialize(key: nil, revision: nil, fields: nil, attributes: nil)
           @key = key.nil? ? SecureRandom.uuid : key.to_s
           @class_name = self.class.name
           @class_name = @class_name.split('>::').last if @class_name.start_with?('#<')
           @_revision = revision
           @_changed = false
-          attributes = {} unless attributes
-          _validate_attributes(attributes) if attributes
-          @_raw_attributes = attributes
-        end
-
-        def _create_text_indexed_attribute(attr)
-          doc = { sid_s_attr: "#{self.sid_s}:|:[#{attr}]", value: self.send(attr).to_s, attribute: attr.to_s, class_name: @class_name }
-          self.class.object_accelerator.create_doc(doc)
-        end
-
-        def _store_text_indexed_attribute(attr)
-          doc = { sid_s_attr: "#{self.sid_s}:|:[#{attr}]", value: self.send(attr).to_s, attribute: attr.to_s, class_name: @class_name }
-          self.class.object_accelerator.save_doc("#{self.sid_s}:|:[#{attr}]", doc)
-        end
-
-        def _store_value_indexed_attribute(attr)
-          old_val = self.class.object_expander.index_get("#{self.sid_s}:|:[#{attr}]")
-          self.class.object_expander.index_delete("#{self.sid_s}:|:[#{attr}]", old_val)
-          self.class.object_expander.index_delete(":[#{self.class.name}]:|:[:#{old_val}:]:", "#{self.sid_s}:|:[#{attr}]")
-          val = "#{self.send(attr)}"[0..300]
-          self.class.object_expander.index_put("#{self.sid_s}:|:[#{attr}]", val)
-          self.class.object_expander.index_put(":[#{self.class.name}]:|:[:#{val}:]:", "#{self.sid_s}:|:[#{attr}]")
+          fields = attributes if attributes
+          fields = {} unless fields
+          _validate_fields(fields) if fields
+          @_raw_fields = fields
         end
 
         def _unchange!
@@ -250,12 +212,12 @@ module LucidObject
         end
 
         def each(&block)
-          @_raw_attributes.each(&block)
+          @_raw_fields.each(&block)
         end
 
         def reload
           new_instance = self.class.load(key: @key)
-          @_raw_attributes = new_instance.attributes
+          @_raw_fields = new_instance.fields
           _unchange!
           self
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-data
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 2.5.0
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-28 00:00:00.000000000 Z
+date: 2022-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -94,48 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.14.0
-- !ruby/object:Gem::Dependency
-  name: isomorfeus-hamster
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.7
 - !ruby/object:Gem::Dependency
   name: isomorfeus-i18n
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.4.2
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.4.2
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: isomorfeus-policy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.4.2
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.4.2
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: isomorfeus-preact
   requirement: !ruby/object:Gem::Requirement
@@ -170,28 +156,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.4.2
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.4.2
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: isomorfeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.4.2
+        version: 2.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.4.2
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -232,19 +218,14 @@ files:
 - lib/data_uri/open_uri.rb
 - lib/data_uri/uri.rb
 - lib/isomorfeus-data.rb
-- lib/isomorfeus/data/attribute_support.rb
 - lib/isomorfeus/data/config.rb
-- lib/isomorfeus/data/document_accelerator.rb
 - lib/isomorfeus/data/field_support.rb
 - lib/isomorfeus/data/generic_class_api.rb
 - lib/isomorfeus/data/generic_instance_api.rb
 - lib/isomorfeus/data/handler/generic.rb
 - lib/isomorfeus/data/object_accelerator.rb
-- lib/isomorfeus/data/object_expander.rb
 - lib/isomorfeus/data/reducer.rb
 - lib/isomorfeus/data/version.rb
-- lib/isomorfeus_data/lucid_document/base.rb
-- lib/isomorfeus_data/lucid_document/mixin.rb
 - lib/isomorfeus_data/lucid_file/base.rb
 - lib/isomorfeus_data/lucid_file/mixin.rb
 - lib/isomorfeus_data/lucid_object/base.rb

data/lib/isomorfeus/data/attribute_support.rb

@@ -1,174 +0,0 @@
-module Isomorfeus
-  module Data
-    module AttributeSupport
-      def self.included(base)
-        base.instance_exec do
-          def attribute_conditions
-            @attribute_conditions ||= {}
-          end
-
-          def indexed_attributes
-            @indexed_attributes ||= {}
-          end
-
-          def valid_attribute?(attr_name, val)
-            Isomorfeus::Props::Validator.new(self.name, attr_name, val, attribute_conditions[attr_name]).validate!
-          rescue
-            false
-          end
-
-          def validate
-            Isomorfeus::Props::ValidateHashProxy.new
-          end
-
-          def _validate_attribute(attr_name, val)
-            Isomorfeus.raise_error(message: "#{self.name}: No such attribute declared: '#{attr_name}'!") unless attribute_conditions.key?(attr_name)
-            Isomorfeus::Props::Validator.new(self.name, attr_name, val, attribute_conditions[attr_name]).validated_value
-          end
-
-          def _validate_attributes(attrs)
-            attribute_conditions.each_key do |attr_name|
-              if attribute_conditions[attr_name].key?(:required) && attribute_conditions[attr_name][:required] && !attrs.key?(attr_name)
-                Isomorfeus.raise_error(message: "Required attribute #{attr_name} not given!")
-              end
-              attrs[attr_name] = _validate_attribute(attr_name, attrs[attr_name])
-            end
-          end
-        end
-
-        def _validate_attribute(attr_name, val)
-          self.class._validate_attribute(attr_name, val)
-        end
-
-        def _validate_attributes(attrs)
-          self.class._validate_attributes(attrs)
-        end
-
-        def exclude_attributes(*attrs)
-          @_excluded_attributes = attrs
-        end
-
-        def select_attributes(*attrs)
-          @_selected_attributes = attrs
-        end
-
-        if RUBY_ENGINE == 'opal'
-          base.instance_exec do
-            def attribute(name, options = {})
-              indexed_attributes[name] = options.delete(:index) if options.key?(:index)
-              attribute_conditions[name] = options
-
-              define_method(name) do
-                _get_attribute(name)
-              end
-
-              define_method("#{name}=") do |val|
-                val = _validate_attribute(name, val)
-                changed!
-                @_changed_attributes[name] = val
-              end
-            end
-          end
-
-          def validate_attributes_function
-            %x{
-              if (typeof self.validate_attributes_function === 'undefined') {
-                self.validate_attributes_function = function(attributes_object) {
-                  try { self.$_validate_attributes(Opal.Hash.$new(attributes_object)) }
-                  catch (e) { return e.message; }
-                }
-              }
-              return self.validate_attributes_function;
-            }
-          end
-
-          def validate_attribute_function(attr)
-            function_name = "validate_attribute_#{attr}_function"
-            %x{
-              if (typeof self[function_name] === 'undefined') {
-                self[function_name] = function(value) {
-                  try { self.$_validate_attribute(attribute, value); }
-                  catch (e) { return e.message; }
-                }
-              }
-              return self[function_name];
-            }
-          end
-
-          def _get_attribute(name)
-            return @_changed_attributes[name] if @_changed_attributes.key?(name)
-            path = @_store_path + [name]
-            result = Redux.fetch_by_path(*path)
-            %x{
-              if (result === null) { return nil; }
-              else if (result instanceof Object && !(result instanceof Array)) {
-                return Opal.Hash.$new(result);
-              } else { return result; }
-            }
-          end
-
-          def attributes
-            raw_attributes = Redux.fetch_by_path(*@_store_path)
-            hash = Hash.new(raw_attributes)
-            hash.merge!(@_changed_attributes) if @_changed_attributes
-            hash
-          end
-
-          def _get_selected_attributes
-            sel_attributes = attributes.dup
-            if @_selected_attributes && !@_selected_attributes.empty?
-              sel_attributes.each_key do |attr|
-                unless @_selected_attributes.include?(attr) || @_selected_attributes.include?(attr)
-                  sel_attributes.delete(attr)
-                end
-              end
-            end
-            if @_excluded_attributes && !@_excluded_attributes.empty?
-              @_excluded_attributes.each { |attr| sel_attributes.delete(attr) }
-            end
-            sel_attributes
-          end
-        else
-          base.instance_exec do
-            def attribute(name, options = {})
-              indexed_attributes[name] = options.delete(:index) if options.key?(:index)
-              attribute_conditions[name] = options
-
-              define_method(name) do
-                @_raw_attributes[name]
-              end
-
-              define_method("#{name}=") do |val|
-                val = _validate_attribute(name, val)
-                changed!
-                @_raw_attributes[name] = val
-              end
-            end
-          end
-
-          def attributes
-            @_raw_attributes
-          end
-
-          def _get_selected_attributes
-            sel_attributes = attributes.transform_keys(&:to_s)
-            self.class.attribute_conditions.each do |attr, options|
-              sel_attributes.delete(attr.to_s) if options[:server_only]
-            end
-            if @_selected_attributes && !@_selected_attributes.empty?
-              sel_attributes.each_key do |attr|
-                unless @_selected_attributes.include?(attr.to_sym) || @_selected_attributes.include?(attr)
-                  sel_attributes.delete(attr)
-                end
-              end
-            end
-            if @_excluded_attributes && !@_excluded_attributes.empty?
-              @_excluded_attributes.each { |attr| sel_attributes.delete(attr.to_s) }
-            end
-            sel_attributes
-          end
-        end
-      end
-    end
-  end
-end