isomorfeus-data 1.0.0.zeta25 → 2.0.0.rc1

data/lib/isomorfeus/data/generic_class_api.rb

@@ -1,116 +1,136 @@
-module Isomorfeus
-  module Data
-    module GenericClassApi
-      if RUBY_ENGINE == 'opal'
-        def destroy(key:)
-          promise_destroy(key: key)
-          true
-        end
-
-        def promise_destroy(key:)
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :destroy, key: key).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
-              Isomorfeus.store.dispatch(type: 'DATA_DESTROY', data: [self.name, key])
-              agent.result = true
-            end
-          end
-        end
-
-        def load(key:)
-          instance = self.new(key: key)
-          promise_load(key: key, instance: instance) unless instance.loaded?
-          instance
-        end
-
-        def promise_load(key:, instance: nil)
-          instance = self.new(key: key) unless instance
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :load, key: key).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
-              instance._load_from_store!
-              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
-              agent.result = instance
-            end
-          end
-        end
-
-        # execute
-        def execute_create(_); end
-        def execute_destroy(_); end
-        def execute_load(_); end
-        def execute_save(_); end
-      else
-        def destroy(key:)
-          !!instance_exec(key: key, &@_destroy_block)
-        end
-
-        def promise_load(key:)
-          instance = self.load(key: key)
-          result_promise = Promise.new
-          result_promise.resolve(instance)
-          result_promise
-        end
-
-        def load(key:)
-          data = instance_exec(key: key, &@_load_block)
-          return nil unless data
-          return data if data.class == self
-          Isomorfeus.raise_error(message: "#{self.to_s}: execute_load must return a instance of #{self.to_s} or nil. Returned was: #{data.class}.") if data.class != self
-          data
-        end
-
-        # execute
-        def execute_create(&block)
-          @_create_block = block
-        end
-
-        def execute_destroy(&block)
-          @_destroy_block = block
-        end
-
-        def execute_load(&block)
-          @_load_block = block
-        end
-
-        def execute_save(&block)
-          @_save_block = block
-        end
-      end
-
-      def create(key:, **things)
-        new(key: key, **things).create
-      end
-
-      def promise_create(key:, **things)
-        new(key: key, **things).promise_create
-      end
-
-      def save(instance:)
-        instance.save
-      end
-
-      def promise_save(instance:)
-        instance.promise_save
-      end
-
-      def current_user
-        Isomorfeus.current_user
-      end
-
-      def pub_sub_client
-        Isomorfeus.pub_sub_client
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Data
+    module GenericClassApi
+      if RUBY_ENGINE == 'opal'
+        def destroy(key:)
+          promise_destroy(key: key)
+          true
+        end
+
+        def promise_destroy(key:)
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :destroy, key: key).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
+              Isomorfeus.store.dispatch(type: 'DATA_DESTROY', data: [self.name, key])
+              agent.result = true
+            end
+          end
+        end
+
+        def load(key:)
+          instance = self.new(key: key)
+          promise_load(key: key, instance: instance) unless instance.loaded?
+          instance
+        end
+
+        def promise_load(key:, instance: nil)
+          instance = self.new(key: key) unless instance
+          if instance.loaded?
+            Promise.new.resolve(instance)
+          else
+            promise_load!(key: key, instance: instance)
+          end
+        end
+
+        def load!(key:)
+          instance = self.new(key: key)
+          promise_load!(key: key, instance: instance) unless instance.loaded?
+          instance
+        end
+
+        def promise_load!(key:, instance: nil)
+          instance = self.new(key: key) unless instance
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', self.name, :load, key: key).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
+              instance._load_from_store!
+              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.full_response[:data])
+              agent.result = instance
+            end
+          end
+        end
+
+        # execute
+        def execute_create(_); end
+        def execute_destroy(_); end
+        def execute_load(_); end
+        def execute_save(_); end
+      else # RUBY_ENGINE
+        def destroy(key:)
+          !!instance_exec(key: key, &@_destroy_block)
+        end
+
+        def promise_load(key:)
+          instance = self.load(key: key)
+          result_promise = Promise.new
+          result_promise.resolve(instance)
+          result_promise
+        end
+        alias promise_load! promise_load
+
+        def load(key:)
+          data = instance_exec(key: key, &@_load_block)
+          return nil unless data
+          return data if data.class == self
+          Isomorfeus.raise_error(message: "#{self.to_s}: execute_load must return a instance of #{self.to_s} or nil. Returned was: #{data.class}.") if data.class != self
+          data
+        end
+        alias load! load
+
+        def execute_create(&block)
+          @_create_block = block
+        end
+
+        def execute_destroy(&block)
+          @_destroy_block = block
+        end
+
+        def execute_load(&block)
+          @_load_block = block
+        end
+
+        def execute_save(&block)
+          @_save_block = block
+        end
+      end  # RUBY_ENGINE
+
+      def gen_sid_s(key)
+        "[#{self.name}|#{key}]"
+      end
+
+      def create(key: nil, **things)
+        new(key: key, **things).create
+      end
+
+      def promise_create(key: nil, **things)
+        new(key: key, **things).promise_create
+      end
+
+      def save(instance:)
+        instance.save
+      end
+
+      def promise_save(instance:)
+        instance.promise_save
+      end
+
+      def current_user
+        Isomorfeus.current_user
+      end
+
+      def pub_sub_client
+        Isomorfeus.pub_sub_client
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/generic_instance_api.rb

@@ -1,145 +1,150 @@
-module Isomorfeus
-  module Data
-    module GenericInstanceApi
-      def key
-        @key
-      end
-
-      def key=(k)
-        @key = k.to_s
-      end
-
-      def revision
-        @_revision
-      end
-
-      def to_sid
-        [@class_name, @key]
-      end
-
-      if RUBY_ENGINE == 'opal'
-        def loaded?
-          Redux.fetch_by_path(*@_store_path) ? true : false
-        end
-
-        def create
-          promise_create
-          self
-        end
-
-        def promise_create
-          data_hash = { instance: to_transport }
-          data_hash.deep_merge!(included_items: included_items_to_transport) if respond_to?(:included_items_to_transport)
-          class_name = self.class.name
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', class_name, :create, data_hash).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
-              data = agent.full_response[:data]
-              if data.key?(class_name) && data[class_name].key?(@key) && data[class_name][@key].key?('new_key')
-                @key = data[class_name][@key]['new_key']
-                @revision = data[class_name][@key]['revision'] if data[class_name][@key].key?('revision')
-                _update_paths
-              end
-              _load_from_store!
-              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: data)
-              agent.result = self
-            end
-          end
-        end
-
-        def destroy
-          promise_destroy
-          nil
-        end
-
-        def promise_destroy
-          self.class.promise_destroy(@key)
-        end
-
-        def reload
-          self.class.promise_load(@key, self)
-          self
-        end
-
-        def promise_reload
-          self.class.promise_load(@key, self)
-        end
-
-        def promise_save
-          data_hash = { instance: to_transport }
-          data_hash.deep_merge!(included_items: included_items_to_transport) if respond_to?(:included_items_to_transport)
-          class_name = self.class.name
-          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', class_name, :save, data_hash).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
-              data = agent.full_response[:data]
-              if data.key?(class_name) && data[class_name].key?(@key) && data[class_name][@key].key?('new_key')
-                @key = data[class_name][@key]['new_key']
-                @revision = data[class_name][@key]['revision'] if data[class_name][@key].key?('revision')
-                _update_paths
-              end
-              _load_from_store!
-              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: data)
-              agent.result = self
-            end
-          end
-        end
-
-        # TODO update -> only send partial change
-        # included_changed_items
-      else # RUBY_ENGINE
-        def loaded?
-          true
-        end
-
-        def create
-          previous_key = self.key
-          instance = instance_exec(&self.class.instance_variable_get(:@_create_block))
-          return nil unless instance
-          Isomorfeus.raise_error(message: "#{self.to_s}: execute_create must return self or nil. Returned was: #{instance.class}.") if instance != self
-          instance_variable_set(:@previous_key, previous_key) if key != previous_key
-          _unchange!
-          self
-        end
-
-        def promise_create
-          promise = Promise.new
-          promise.resolve(create)
-        end
-
-        def save
-          previous_key = self.key
-          instance = instance_exec(&self.class.instance_variable_get(:@_save_block))
-          return nil unless instance
-          Isomorfeus.raise_error(message: "#{self.to_s}: execute_save must return self or nil. Returned was: #{instance.class}.") if instance != self
-          instance_variable_set(:@previous_key, previous_key) if key != previous_key
-          _unchange!
-          self
-        end
-
-        def promise_save
-          promise = Promise.new
-          promise.resolve(save)
-        end
-      end # RUBY_ENGINE
-
-      def current_user
-        Isomorfeus.current_user
-      end
-
-      def pub_sub_client
-        Isomorfeus.pub_sub_client
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Data
+    module GenericInstanceApi
+      def key
+        @key
+      end
+
+      def key=(k)
+        @key = k.to_s
+      end
+
+      def changed?
+        @_changed
+      end
+
+      def revision
+        @_revision
+      end
+
+      def sid
+        [@class_name, @key]
+      end
+
+      def sid_s
+        "[#{@class_name}|#{@key}]"
+      end
+
+      if RUBY_ENGINE == 'opal'
+        def loaded?
+          Redux.fetch_by_path(*@_store_path) ? true : false
+        end
+
+        def create
+          promise_create
+          self
+        end
+
+        def promise_create
+          data_hash = { instance: to_transport }
+          data_hash.deep_merge!(included_items: included_items_to_transport) if respond_to?(:included_items_to_transport)
+          class_name = self.class.name
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', class_name, :create, data_hash).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
+              data = agent.full_response[:data]
+              if data.key?(class_name) && data[class_name].key?(@key) && data[class_name][@key].key?('new_key')
+                @key = data[class_name][@key]['new_key']
+                @revision = data[class_name][@key]['revision'] if data[class_name][@key].key?('revision')
+                _update_paths
+              end
+              _load_from_store!
+              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: data)
+              agent.result = self
+            end
+          end
+        end
+
+        def destroy
+          promise_destroy
+          nil
+        end
+
+        def promise_destroy
+          self.class.promise_destroy(@key)
+        end
+
+        def reload
+          self.class.promise_load!(@key, self)
+          self
+        end
+
+        def promise_reload
+          self.class.promise_load!(@key, self)
+        end
+
+        def promise_save
+          data_hash = { instance: to_transport }
+          data_hash.deep_merge!(included_items: included_items_to_transport) if respond_to?(:included_items_to_transport)
+          class_name = self.class.name
+          Isomorfeus::Transport.promise_send_path( 'Isomorfeus::Data::Handler::Generic', class_name, :save, data_hash).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
+              data = agent.full_response[:data]
+              if data.key?(class_name) && data[class_name].key?(@key) && data[class_name][@key].key?('new_key')
+                @key = data[class_name][@key]['new_key']
+                @revision = data[class_name][@key]['revision'] if data[class_name][@key].key?('revision')
+                _update_paths
+              end
+              _load_from_store!
+              Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: data)
+              agent.result = self
+            end
+          end
+        end
+      else # RUBY_ENGINE
+        def loaded?
+          true
+        end
+
+        def create
+          previous_key = self.key
+          instance = instance_exec(&self.class.instance_variable_get(:@_create_block))
+          return nil unless instance
+          Isomorfeus.raise_error(message: "#{self.to_s}: execute_create must return self or nil. Returned was: #{instance.class}.") if instance != self
+          instance_variable_set(:@previous_key, previous_key) if key != previous_key
+          _unchange!
+          self
+        end
+
+        def promise_create
+          promise = Promise.new
+          promise.resolve(create)
+        end
+
+        def save
+          previous_key = self.key
+          instance = instance_exec(&self.class.instance_variable_get(:@_save_block))
+          return nil unless instance
+          Isomorfeus.raise_error(message: "#{self.to_s}: execute_save must return self or nil. Returned was: #{instance.class}.") if instance != self
+          instance_variable_set(:@previous_key, previous_key) if key != previous_key
+          _unchange!
+          self
+        end
+
+        def promise_save
+          promise = Promise.new
+          promise.resolve(save)
+        end
+      end # RUBY_ENGINE
+
+      def current_user
+        Isomorfeus.current_user
+      end
+
+      def pub_sub_client
+        Isomorfeus.pub_sub_client
+      end
+    end
+  end
+end

data/lib/isomorfeus/data/hamster_accelerator.rb

@@ -0,0 +1,87 @@
+module Isomorfeus
+  module Data
+    class HamsterAccelerator
+      class << self
+        def index
+          @index
+        end
+
+        def index=(idx)
+          @index = idx
+        end
+
+        def ref
+          @ref ||= 0
+        end
+
+        def ref=(val)
+          @ref = val
+        end
+
+        def refa
+          self.ref += 1
+        end
+
+        def refs
+          self.ref -= 1 if self.ref > 0
+        end
+
+        def finalize(cls)
+          proc do
+            cls.refs
+            cls.index.close if cls.ref == 0
+          end
+        end
+      end
+
+      def initialize(&block)
+        if block_given?
+          res = block.call(self)
+          self.class.index = res unless self.class.index
+        else
+          open_index
+        end
+        ObjectSpace.define_finalizer(self, self.class.finalize(self.class))
+      end
+
+      def destroy_index
+        close_index
+        FileUtils.rm_rf(Isomorfeus.data_object_idx_path)
+      end
+
+      def destroy_doc(id)
+        self.class.index.delete(id)
+        true
+      end
+
+      def load_doc(id)
+        self.class.index.doc(id)&.load
+      end
+
+      def save_doc(id, document)
+        self.class.index.update(id, document)
+      end
+
+      def search_each(query, options, &block)
+        self.class.index.search_each(query, options, &block)
+      end
+
+      private
+
+      def open_index
+        return self.class.refa if self.class.index
+        unless Dir.exist?(Isomorfeus.data_object_idx_path)
+          FileUtils.mkdir_p(Isomorfeus.data_object_idx_path)
+          fis = Isomorfeus::Ferret::Index::FieldInfos.new
+          fis.add_field(:attribute, store: :no)
+          fis.add_field(:class_name, store: :no)
+          fis.add_field(:value, store: :no)
+          fis.add_field(:sid_s_attr, store: :yes)
+          fis.create_index(Isomorfeus.data_object_idx_path)
+        end
+        self.class.index = Isomorfeus::Ferret::Index::Index.new(path: Isomorfeus.data_object_idx_path, id_field: :sid_s_attr)
+        self.class.refa
+      end
+    end
+  end
+end