isomorfeus-data 2.4.2 → 2.5.0

data/lib/isomorfeus/data/document_accelerator.rb

@@ -1,84 +0,0 @@
-module Isomorfeus
-  module Data
-    class DocumentAccelerator
-      def self.finalize(fer_acc)
-        proc { fer_acc.close_index }
-      end
-
-      attr_reader :doc_class, :doc_class_name
-      attr_accessor :index
-
-      def initialize(doc_class, &block)
-        @doc_class = doc_class
-        @doc_class_name = doc_class.name
-        if block_given?
-          res = block.call(self)
-          @index = res unless @index
-        else
-          @index_path = File.expand_path(File.join(Isomorfeus.data_documents_path, @doc_class_name.underscore))
-          open_index
-        end
-        ObjectSpace.define_finalizer(self, self.class.finalize(self))
-      end
-
-      def destroy_index
-        close_index
-        FileUtils.rm_rf(@index_path)
-      end
-
-      def close_index
-        @index.close
-      end
-
-      def create_doc(document)
-        @index.add_document(document)
-      end
-
-      def destroy_doc(key)
-        id = get_doc_id(key)
-        @index.delete(id) if id
-        true
-      end
-
-      def load_doc(key)
-        id = get_doc_id(key)
-        @index.doc(id)&.load&.to_h if id
-      end
-
-      def save_doc(key, document)
-        id = get_doc_id(key)
-        if id
-          @index.update(id, document)
-          true
-        end
-      end
-
-      def search_each(query, options, &block)
-        @index.search_each(query, options, &block)
-      end
-
-      def each(&block)
-        @index.each(&block)
-      end
-
-      private
-
-      def get_doc_id(key)
-        # special characters must be escaped, characters taken from the ferret query parser documentation
-        escaped_key = key.gsub(/([\\\&\:\(\)\[\]\{\}\!\"\~\^\|\<\>\=\*\?\+\-\s])/, '\\\\\1')
-        top_docs = @index.search("key:\"#{escaped_key}\"", limit: 1)
-        id = top_docs.hits[0].doc if top_docs.total_hits == 1
-      end
-
-      def open_index
-        FileUtils.mkdir_p(Isomorfeus.data_documents_path) unless Dir.exist?(Isomorfeus.data_documents_path)
-        field_infos = Isomorfeus::Ferret::Index::FieldInfos.new(store: :yes, index: :yes, term_vector: :with_positions_offsets)
-        @index = Isomorfeus::Ferret::Index::Index.new(path: @index_path, key: :key, auto_flush: true, lock_retry_time: 5, field_infos: field_infos)
-        @index.field_infos.add_field(:key, store: :yes, index: :yes, term_vector: :no) unless @index.field_infos[:key]
-        @doc_class.field_options.each do |field, options|
-          @index.field_infos.add_field(field, options) unless @index.field_infos[field]
-        end
-      end
-    end
-  end
-end

data/lib/isomorfeus/data/object_expander.rb

@@ -1,79 +0,0 @@
-module Isomorfeus
-  module Data
-    class ObjectExpander
-      class << self
-        def finalize(ins)
-          proc { ins.environment.close rescue nil }
-        end
-      end
-
-      attr_accessor :environment
-
-      def initialize(class_name:, compress: false, &block)
-        if block_given?
-          res = block.call(self)
-          self.environment = res unless self.environment
-        else
-          @env_path = File.expand_path(File.join(Isomorfeus.data_object_envs_path, class_name.underscore))
-          open_environment
-        end
-        @db = self.environment.database('objects', create: true)
-        @index_db = self.environment.database('index', create: true, dupsort: true)
-        @compress = compress
-        @use_class_cache = !Isomorfeus.development?
-        ObjectSpace.define_finalizer(self, self.class.finalize(self))
-      end
-
-      def create_object(sid_s, obj)
-        Isomorfeus::Hamster::Marshal.dump(@db, sid_s, obj, class_cache: @use_class_cache, compress: @compress)
-      end
-
-      def destroy_object(sid_s)
-        @db.delete(sid_s) rescue nil
-        true
-      end
-
-      def load_object(sid_s)
-        Isomorfeus::Hamster::Marshal.load(@db, sid_s, class_cache: @use_class_cache)
-      end
-
-      def save_object(sid_s, obj)
-        Isomorfeus::Hamster::Marshal.dump(@db, sid_s, obj, class_cache: @use_class_cache, compress: @compress)
-      end
-
-      def index_delete(key, val)
-        @index_db.delete(key, val) rescue nil
-      end
-
-      def index_get(key)
-        @index_db.get(key)
-      end
-
-      def index_put(key, val)
-        environment.transaction { @index_db.put(key, val) }
-      end
-
-      def each(readonly: true, &block)
-        @db.each(readonly: readonly) do |key, obj|
-          block.call(Isomorfeus::Hamster::Marshal.unserialize(obj, class_cache: @use_class_cache))
-        end
-      end
-
-      def search(val_key, &block)
-        @index_db.each_value(val_key, &block)
-      end
-
-      private
-
-      def open_environment
-        FileUtils.mkdir_p(@env_path) unless Dir.exist?(@env_path)
-        begin
-          self.environment = Isomorfeus::Hamster.new(@env_path, mapsize: Isomorfeus.hamster_mapsize)
-        rescue RangeError
-          self.environment = Isomorfeus::Hamster.new(@env_path, mapsize: 2_147_483_647)
-          STDERR.puts "Isomorfeus::Data Warning: Hamster Object Store limited to 2Gb because of platform restrictions."
-        end
-      end
-    end
-  end
-end

data/lib/isomorfeus_data/lucid_document/base.rb

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

data/lib/isomorfeus_data/lucid_document/mixin.rb

@@ -1,197 +0,0 @@
-module LucidDocument
-  module Mixin
-    def self.included(base)
-      base.include(Isomorfeus::Data::FieldSupport)
-      base.extend(Isomorfeus::Data::GenericClassApi)
-      base.include(Isomorfeus::Data::GenericInstanceApi)
-      base.include(LucidI18n::Mixin)
-
-      base.instance_exec do
-        def escape_string(s)
-          s.gsub(/([\\\&\:\(\)\[\]\{\}\!\"\~\^\|\<\>\=\*\?\+\-\s])/, '\\\\\1')
-        end
-      end
-
-      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, _loading: false)
-          @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 loaded
-            raw_fields = Redux.fetch_by_path(*@_store_path)
-            if `raw_fields === null`
-              if fields
-                _validate_fields(fields)
-                @_changed_fields = fields
-              else
-                @_changed_fields = {}
-              end
-            elsif raw_fields && fields && ::Hash.new(raw_fields) != fields
-              _validate_fields(fields)
-              @_changed_fields = fields
-            else
-              @_changed_fields = {}
-            end
-          else
-            fields = {} unless fields
-            _validate_fields(fields) unless _loading
-            @_changed_fields = 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 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
-            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 setup_index(&block)
-            @_setup_index_block = block
-          end
-
-          def document_accelerator
-            return @document_accelerator if @document_accelerator
-            @document_accelerator = if @_setup_index_block
-                                    Isomorfeus::Data::DocumentAccelerator.new(self, &@_setup_index_block)
-                                  else
-                                    Isomorfeus::Data::DocumentAccelerator.new(self)
-                                  end
-          end
-
-          def each(&block)
-            self.document_accelerator.each do |doc|
-              doc = doc.to_h
-              key = doc.delete(:key)
-              block.call(self.new(key: key, fields: doc))
-            end
-          end
-
-          def search(query, options = {})
-            top_docs = []
-            self.document_accelerator.search_each(query, options) do |id|
-              doc = self.document_accelerator.index.doc(id)&.to_h
-              if doc
-                key = doc.delete(:key)
-                top_docs << self.new(key: key, fields: doc)
-              end
-            end
-            top_docs
-          end
-
-          execute_create do
-            doc = self.fields.dup
-            if self.key.nil?
-              u = SecureRandom.uuid
-              doc[:key] = u
-              self.key = u
-            else
-              doc[:key] = self.key
-            end
-            self.class.document_accelerator.create_doc(doc)
-            self
-          end
-
-          execute_destroy do |key:|
-            self.document_accelerator.destroy_doc(key)
-          end
-
-          execute_load do |key:|
-            doc = self.document_accelerator.load_doc(key)
-            if doc
-              doc.delete(:key)
-              self.new(key: key, fields: doc)
-            end
-          end
-
-          execute_save do
-            doc = self.fields.dup
-            if self.key.nil?
-              u = SecureRandom.uuid
-              doc[:key] = u
-              self.key = u
-              self.class.document_accelerator.create_doc(doc)
-            else
-              doc[:key] = self.key
-              self.class.document_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
-          _validate_fields(fields)
-          @_raw_fields = fields
-        end
-
-        def _unchange!
-          @_changed = false
-        end
-
-        def each(&block)
-          @_raw_fields.each(&block)
-        end
-
-        def reload
-          new_instance = self.class.load(key: @key)
-          @_raw_fields = new_instance.fields
-          _unchange!
-          self
-        end
-      end # RUBY_ENGINE
-    end
-  end
-end