isomorfeus-data 1.0.0.zeta25 → 2.0.0.rc1

data/lib/isomorfeus_data/lucid_document/mixin.rb

@@ -0,0 +1,148 @@
+module LucidDocument
+  module Mixin
+    def self.included(base)
+      base.include(Isomorfeus::Data::FieldSupport)
+      base.extend(Isomorfeus::Data::GenericClassApi)
+      base.include(Isomorfeus::Data::GenericInstanceApi)
+
+      def [](name)
+        send(name)
+      end
+
+      def []=(name, val)
+        send("#{name}=", val)
+      end
+
+      def changed!
+        @_changed = true
+      end
+
+      def to_transport
+        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
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def initialize(key: nil, revision: nil, fields: 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)
+          @_changed = false
+          loaded = loaded?
+          if fields
+            if loaded
+              raw_fields = Redux.fetch_by_path(*@_store_path)
+              if `raw_fields === null`
+                @_changed_fields = !fields ? {} : fields
+              elsif raw_fields && !fields.nil? && ::Hash.new(raw_fields) != fields
+                @_changed_fields = fields
+              end
+            else
+              @_changed_fields = fields
+            end
+          else
+            @_changed_fields = {}
+          end
+        end
+
+        def _load_from_store!
+          @_changed_fields = {}
+          @_changed = false
+        end
+
+        def _update_paths
+          @_store_path = [:data_state, @class_name, @key, :fields]
+        end
+
+        def each(&block)
+          fields.each(&block)
+        end
+      else # RUBY_ENGINE
+        Isomorfeus.add_valid_data_class(base) unless base == LucidDocument::Base
+
+        base.instance_exec do
+          def instance_from_transport(instance_data, _included_items_data)
+            key = instance_data[self.name].keys.first
+            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
+            fields = instance_data[self.name][key].key?('fields') ? instance_data[self.name][key]['fields'].transform_keys!(&:to_sym) : nil
+            new(key: key, revision: revision, fields: fields)
+          end
+
+          def setup_index(&block)
+            @_setup_index_block = block
+          end
+
+          def ferret_accelerator
+            return @ferret_accelerator if @ferret_accelerator
+            @ferret_accelerator = if @_setup_index_block
+                                    Isomorfeus::Data::FerretAccelerator.new(self, &@_setup_index_block)
+                                  else
+                                    Isomorfeus::Data::FerretAccelerator.new(self)
+                                  end
+          end
+
+          def search(query, options = {})
+            top_docs = []
+            self.ferret_accelerator.search_each(query, options) do |id|
+              doc = self.ferret_accelerator.load_doc(id)
+              top_docs << self.new(key: doc[:key], fields: doc) if doc
+            end
+            top_docs
+          end
+
+          execute_create do
+            doc = self.fields
+            doc[:key] = self.key.nil? ? SecureRandom.uuid : self.key
+            self.class.ferret_accelerator.create_doc(doc)
+            self
+          end
+
+          execute_destroy do |key:|
+            self.ferret_accelerator.destroy_doc(key)
+          end
+
+          execute_load do |key:|
+            doc = self.ferret_accelerator.load_doc(key)
+            doc.delete(:key)
+            self.new(key: key, fields: doc)
+          end
+
+          execute_save do
+            doc = self.fields
+            if self.key.nil?
+              doc[:key] = SecureRandom.uuid
+              self.class.ferret_accelerator.create_doc(doc)
+            else
+              doc[:key] = self.key
+              self.class.ferret_accelerator.save_doc(self.key, doc)
+            end
+            self
+          end
+        end
+
+        def initialize(key: nil, revision: nil, fields: 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
+          fields = {} unless fields
+          @_raw_fields = fields
+        end
+
+        def _unchange!
+          @_changed = false
+        end
+
+        def each(&block)
+          @_raw_fields.each(&block)
+        end
+      end # RUBY_ENGINE
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_file/base.rb

@@ -0,0 +1,10 @@
+module LucidFile
+  class Base
+    def self.inherited(base)
+      base.include LucidFile::Mixin
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_data_class(base)
+      end
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_file/mixin.rb

@@ -0,0 +1,217 @@
+module LucidFile
+  module Mixin
+    def self.included(base)
+      base.extend(Isomorfeus::Data::GenericClassApi)
+      base.include(Isomorfeus::Data::GenericInstanceApi)
+
+      def changed!
+        @_changed = true
+      end
+
+      def to_transport
+        hash = {}
+        hash['revision'] = revision if revision
+        hash['data_uri'] = data_uri
+        result = { @class_name => { @key => hash }}
+        result.deep_merge!(@class_name => { @previous_key => { new_key: @key }}) if @previous_key
+        result
+      end
+
+      def content_type
+        _reload
+        return @_data_uri_object.content_type if @_data_uri_object
+        nil
+      end
+
+      def content_type=(c)
+        changed!
+        _content_type(c)
+      end
+
+      def _content_type(c)
+        _reload
+        @_data_uri_string = _format_data_uri(c, @_data_uri_object.data)
+        @_data_uri_object = URI::Data.new(@_data_uri_string)
+        c
+      end
+
+      def data
+        _reload
+        @_data_uri_object.data
+      end
+
+      def data=(d)
+        changed!
+        _data(d)
+      end
+
+      def _data(d)
+        _reload
+        @_data_uri_string = _format_data_uri(self.content_type, d)
+        @_data_uri_object = URI::Data.new(@_data_uri_string)
+        d
+      end
+
+      def data_uri
+        _reload
+        @_data_uri_string
+      end
+
+      def data_uri=(d)
+        changed!
+        _data_uri(d)
+      end
+
+      def _data_uri(d)
+        _reload
+        if d.class == URI::Data
+          @_data_uri_string = _format_data_uri(d.content_type, d.data)
+          @_data_uri_object = d
+        else
+          @_data_uri_string = d
+          @_data_uri_object = URI::Data.new(d)
+        end
+        @_data_uri_string
+      end
+
+      def data_uri_object
+        _reload
+        @_data_uri_object
+      end
+
+      def _format_data_uri(c, d)
+        "data:#{c};base64,#{Base64.encode64(d).chop}"
+      end
+
+      if RUBY_ENGINE == 'opal'
+        base.instance_exec do
+          def files_path
+          end
+
+          def files_path=(_)
+          end
+        end
+
+        def initialize(key: nil, content_type: nil, data: nil, data_uri: nil, revision: 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)
+          @_changed = false
+          @_reload = false
+          loaded = loaded?
+          @_data_uri_object = nil
+          @_data_uri_string = nil
+          if data_uri
+            self.data_uri = data_uri
+          elsif data
+            self.data = data
+            self.content_type = content_type if content_type
+          else
+            self._data('')
+            self._content_type(content_type) if content_type
+          end
+        end
+
+        def _load_from_store!
+          @_changed = false
+          @_reload = true
+        end
+
+        def _reload
+          return unless @_reload
+          @_reload = false
+          d = Redux.fetch_by_path(*@_store_path)
+          self._data_uri(d) if d
+        end
+
+        def _update_paths
+          @_store_path = [:data_state, @class_name, @key, :data_uri]
+        end
+      else # RUBY_ENGINE
+        Isomorfeus.add_valid_file_class(base) unless base == LucidFile::Base
+
+        base.instance_exec do
+          def instance_from_transport(instance_data, _included_items_data)
+            key = instance_data[self.name].keys.first
+            revision = instance_data[self.name][key].key?('revision') ? instance_data[self.name][key]['revision'] : nil
+            data_uri = instance_data[self.name][key].key?('data_uri') ? instance_data[self.name][key]['data_uri'] : nil
+            new(key: key, revision: revision, data_uri: data_uri)
+          end
+
+          def files_path
+            @files_path ||= Isomorfeus.files_path
+          end
+
+          def files_path=(f)
+            @files_path = f
+          end
+
+          def check_and_prepare_path(key:)
+            Isomorfeus.raise_error(message: 'Invalid key (contains ".." or "\\")') if key.include?('..') || key.include?('\\')
+            elements = key.split('/')
+            Isomorfeus.raise_error(message: 'Invalid key (contains more than 2 slashes "/")') if elements.size > 3
+            file = elements.pop
+            if elements.size > 0
+              dir_path = ::File.expand_path(::File.join(files_path, *elements))
+              FileUtils.mkdir_p(path) unless Dir.exist?(dir_path)
+              ::File.join(dir_path, file)
+            else
+              FileUtils.mkdir_p(files_path) unless Dir.exist?(files_path)
+              ::File.join(files_path, file)
+            end
+          end
+
+          execute_create do
+            self.save
+          end
+
+          execute_destroy do |key:|
+            file = check_and_prepare_path(key: key)
+            ::FileUtils.rm_f(file)
+            true
+          end
+
+          execute_load do |key:|
+            file = check_and_prepare_path(key: key)
+            d = ::File.read(file)
+            instance = self.new(key: key)
+            instance.data = d
+            instance
+          end
+
+          execute_save do
+            file = self.class.check_and_prepare_path(key: self.key)
+            ::File.write(file, self.data)
+            self
+          end
+        end
+
+        def initialize(key: nil, content_type: nil, data: nil, data_uri: nil, revision: 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
+          @_data_uri_object = nil
+          @_data_uri_string = nil
+          if data_uri
+            self._data_uri(data_uri)
+          else
+            self._data(data ? data : '')
+            self._content_type(content_type) if content_type
+          end
+          @_changed = false
+        end
+
+        def _reload
+        end
+
+        def _unchange!
+          @_data_uri = @_changed_data_uri if @_changed
+          @_changed = false
+        end
+      end # RUBY_ENGINE
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_object/base.rb

@@ -0,0 +1,10 @@
+module LucidObject
+  class Base
+    def self.inherited(base)
+      base.include LucidObject::Mixin
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_data_class(base)
+      end
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_object/mixin.rb

@@ -0,0 +1,216 @@
+module LucidObject
+  module Mixin
+    def self.included(base)
+      base.include(Isomorfeus::Data::AttributeSupport)
+      base.extend(Isomorfeus::Data::GenericClassApi)
+      base.include(Isomorfeus::Data::GenericInstanceApi)
+
+      def changed!
+        @_changed = true
+      end
+
+      def [](name)
+        send(name)
+      end
+
+      def []=(name, val)
+        send("#{name}=".to_sym, val)
+      end
+
+      def to_transport
+        hash = { 'attributes' => _get_selected_attributes }
+        hash['revision'] = revision if revision
+        result = { @class_name => { @key => hash }}
+        result.deep_merge!(@class_name => { @previous_key => { new_key: @key}}) if @previous_key
+        result
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def initialize(key: nil, revision: 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?('#<')
+          _update_paths
+          @_revision = revision ? revision : Redux.fetch_by_path(:data_state, :revision, @class_name, @key)
+          @_changed = false
+          loaded = loaded?
+          if attributes
+            _validate_attributes(attributes)
+            if loaded
+              raw_attributes = Redux.fetch_by_path(*@_store_path)
+              if `raw_attributes === null`
+                @_changed_attributes = !attributes ? {} : attributes
+              elsif raw_attributes && !attributes.nil? && ::Hash.new(raw_attributes) != attributes
+                @_changed_attributes = attributes
+              end
+            else
+              @_changed_attributes = attributes
+            end
+          else
+            @_changed_attributes = {}
+          end
+        end
+
+        def _load_from_store!
+          @_changed_attributes = {}
+          @_changed = false
+        end
+
+        def _update_paths
+          @_store_path = [:data_state, @class_name, @key, :attributes]
+        end
+
+        def each(&block)
+          attributes.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)
+            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
+            new(key: key, revision: revision, attributes: attributes)
+          end
+
+          def setup_environment(&block)
+            @_setup_environment_block = block
+          end
+
+          def setup_index(&block)
+            @_setup_index_block = block
+          end
+
+          def hamster_storage_expander
+            return @hamster_storage_expander if @hamster_storage_expander
+            @hamster_storage_expander = if @_setup_environment_block
+                                          Isomorfeus::Data::HamsterStorageExpander.new(&@_setup_index_block)
+                                        else
+                                          Isomorfeus::Data::HamsterStorageExpander.new
+                                        end
+          end
+
+          def hamster_accelerator
+            return @hamster_accelerator if @hamster_accelerator
+            @hamster_accelerator = if @_setup_index_block
+                                     Isomorfeus::Data::HamsterAccelerator.new(&@_setup_index_block)
+                                   else
+                                     Isomorfeus::Data::HamsterAccelerator.new
+                                   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
+            objs = []
+            if idx_type == :text
+              query = "+value:#{val} +class_name:#{self.name}"
+              query << " +attribute:#{attr}" if attr != '*'
+              self.hamster_accelerator.search_each(query, options) do |id|
+                doc = self.hamster_accelerator.load_doc(id)
+                if doc
+                  sid_s = doc[:sid_s_attr].split(':|:')[0]
+                  obj = self.load(key: sid_s)
+                  objs << obj if obj
+                end
+              end
+            else
+              attr_s = ":[#{attr}]"
+              accept_all_attr = attr_s == ":[*]" ? true : false
+              self.hamster_storage_expander.search(":[:#{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
+            objs
+          end
+
+          execute_create do
+            self.key = SecureRandom.uuid unless self.key
+            self.class.hamster_storage_expander.create_object(self.sid_s, self)
+            self.class.indexed_attributes.each do |attr, idx_type|
+              if idx_type == :text
+                self._store_text_indexed_attribute(attr)
+              else
+                self._store_value_indexed_attribute(attr)
+              end
+            end
+            self
+          end
+
+          execute_destroy do |key:|
+            key = key.to_s
+            sid_s = key.start_with?('[') ? key : gen_sid_s(key)
+            self.hamster_storage_expander.destroy_object(sid_s)
+            self.indexed_attributes.each do |attr, idx_type|
+              if idx_type == :text
+                self.hamster_accelerator.destroy_doc("#{sid_s}:|:[#{attr}]")
+              else
+                old_val = self.hamster_storage_expander.index_get("#{sid_s}:|:[#{attr}]")
+                self.hamster_storage_expander.index_delete("#{sid_s}:|:[#{attr}]", old_val)
+                self.hamster_storage_expander.index_delete(":[:#{old_val}:]:", "#{sid_s}:|:[#{attr}]")
+              end
+            end
+            true
+          end
+
+          execute_load do |key:|
+            key = key.to_s
+            sid_s = key.start_with?('[') ? key : gen_sid_s(key)
+            self.hamster_storage_expander.load_object(sid_s)
+          end
+
+          execute_save do
+            self.key = SecureRandom.uuid unless self.key
+            self.class.hamster_storage_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
+            end
+            self
+          end
+        end
+
+        def initialize(key: nil, revision: 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 _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.hamster_accelerator.save_doc("#{self.sid_s}:|:[#{attr}]", doc)
+        end
+
+        def _store_value_indexed_attribute(attr)
+          old_val = self.class.hamster_storage_expander.index_get("#{self.sid_s}:|:[#{attr}]")
+          self.class.hamster_storage_expander.index_delete("#{self.sid_s}:|:[#{attr}]", old_val)
+          self.class.hamster_storage_expander.index_delete(":[:#{old_val}:]:", "#{self.sid_s}:|:[#{attr}]")
+          val = "#{self.send(attr)}"[0..300]
+          self.class.hamster_storage_expander.index_put("#{self.sid_s}:|:[#{attr}]", val)
+          self.class.hamster_storage_expander.index_put(":[:#{val}:]:", "#{self.sid_s}:|:[#{attr}]")
+        end
+
+        def _unchange!
+          @_changed = false
+        end
+
+        def each(&block)
+          @_raw_attributes.each(&block)
+        end
+      end # RUBY_ENGINE
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_query/base.rb

@@ -0,0 +1,10 @@
+module LucidQuery
+  class Base
+    def self.inherited(base)
+      base.include LucidQuery::Mixin
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_data_class(base)
+      end
+    end
+  end
+end

data/lib/isomorfeus_data/lucid_query/mixin.rb

@@ -0,0 +1,81 @@
+module LucidQuery
+  module Mixin
+    def self.included(base)
+      base.extend(LucidPropDeclaration::Mixin)
+
+      if RUBY_ENGINE == 'opal'
+        base.instance_exec do
+          def execute(**props)
+            props[:query_result_instance] = LucidQueryResult.new
+            promise_execute(props) unless props[:query_result_instance].loaded?
+            props[:query_result_instance]
+          end
+
+          def promise_execute(**props)
+            query_result_instance = props.delete(:query_result_instance)
+            query_result_instance = LucidQueryResult.new unless query_result_instance
+            props.each_key do |prop_name|
+              Isomorfeus.raise_error(message: "#{self.to_s} No such query prop declared: '#{prop_name}'!") unless declared_props.key?(prop_name)
+            end
+            props = validated_props(props)
+            props[:query_result_instance_key] = query_result_instance.key
+            Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :query, props).then do |agent|
+              if agent.processed
+                agent.result
+              else
+                agent.processed = true
+                if agent.response.key?(:error)
+                  Isomorfeus.raise_error(message: agent.response[:error])
+                end
+                query_result_instance._load_from_store!
+                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
+                agent.result = query_result_instance
+              end
+            end
+          end
+
+          def execute_query(_); end
+        end
+      else
+        unless base == LucidQuery::Base
+          Isomorfeus.add_valid_data_class(base)
+        end
+
+        base.instance_exec do
+          def promise_execute(**props)
+            instance = self.execute(**props)
+            result_promise = Promise.new
+            result_promise.resolve(instance)
+            result_promise
+          end
+
+          def execute(**props)
+            query_result_instance_key = props.delete(:query_result_instance_key)
+            query_result = LucidQueryResult.new(key: query_result_instance_key)
+            query_result.result_set = self.new(**props).instance_exec(&@_query_block)
+            query_result
+          end
+
+          def execute_query(&block)
+            @_query_block = block
+          end
+        end
+
+        attr_reader :props
+
+        def initialize(**props_hash)
+          props_hash = self.class.validated_props(props_hash)
+          @props = LucidProps.new(props_hash)
+        end
+
+        def current_user
+          Isomorfeus.current_user
+        end
+
+        def pub_sub_client
+          Isomorfeus.pub_sub_client
+        end
+      end
+    end
+  end
+end