isomorfeus-data 2.4.0 → 2.5.0

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

data/lib/isomorfeus/data/document_accelerator.rb

@@ -1,80 +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
-
-      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,199 +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 ferret_accelerator
-            return @ferret_accelerator if @ferret_accelerator
-            @ferret_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.ferret_accelerator.each do |id|
-              doc = self.ferret_accelerator.index.doc(id)&.load
-              if doc
-                key = doc.delete(:key)
-                block.call(self.new(key: key, fields: doc))
-              end
-            end
-          end
-
-          def search(query, options = {})
-            top_docs = []
-            self.ferret_accelerator.search_each(query, options) do |id|
-              doc = self.ferret_accelerator.index.doc(id)&.load
-              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.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)
-            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.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
-          _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