lexster 0.0.1

data/lib/lexster/config.rb

@@ -0,0 +1,6 @@
+module Lexster
+  class Config
+    attr_accessor :enable_subrefs
+    attr_accessor :enable_per_model_indexes
+  end
+end

data/lib/lexster/database_cleaner.rb

@@ -0,0 +1,12 @@
+module Lexster
+  class NeoDatabaseCleaner
+    def self.clean_db(start_node = Lexster.db.get_root)
+      Lexster.db.execute_script <<-GREMLIN
+        g.V.toList().each { if (it.id != 0) g.removeVertex(it) }
+        g.indices.each { g.dropIndex(it.indexName); }
+      GREMLIN
+
+      true
+    end
+  end
+end

data/lib/lexster/middleware.rb

@@ -0,0 +1,16 @@
+module Ndoid
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      old_enabled, Thread.current[:lexster_enabled] = Thread.current[:lexster_enabled], true
+      old_batch, Thread.current[:lexster_current_batch] = Thread.current[:lexster_current_batch], nil
+      @app.call(env)
+    ensure
+      Thread.current[:lexster_enabled] = old_enabled
+      Thread.current[:lexster_current_batch] = old_batch
+    end
+  end
+end

data/lib/lexster/model_additions.rb

@@ -0,0 +1,121 @@
+module Lexster
+  module ModelAdditions
+    module ClassMethods
+      attr_reader :lexster_config
+      
+      def lexster_config
+        @lexster_config ||= Lexster::ModelConfig.new(self)
+      end
+      
+      def lexsterable(options = {})
+        # defaults
+        lexster_config.auto_index = true
+        lexster_config.enable_model_index = true # but the Lexster.enable_per_model_indexes is false by default. all models will be true only if the primary option is turned on.
+
+        yield(lexster_config) if block_given?
+
+        options.each do |key, value|
+          raise "Lexster #{self.name} model options: No such option #{key}" unless lexster_config.respond_to?("#{key}=")
+          lexster_config.send("#{key}=", value)
+        end
+      end
+
+      def neo_model_index_name
+        raise "Per Model index is not enabled. Nodes/Relationships are auto indexed with node_auto_index/relationship_auto_index" unless Lexster.config.enable_per_model_indexes || lexster_config.enable_model_index
+        @index_name ||= "#{self.name.tableize}_index"
+      end
+    end
+  
+    module InstanceMethods
+      def to_neo
+        if self.class.lexster_config.stored_fields
+          hash = self.class.lexster_config.stored_fields.inject({}) do |all, (field, block)|
+            all[field] = if block
+              instance_eval(&block)
+            else
+              self.send(field) rescue (raise "No field #{field} for #{self.class.name}")
+            end
+            
+            all
+          end
+
+          hash.reject { |k, v| v.nil? }
+        else
+          {}
+        end
+      end
+
+      def neo_save_after_model_save
+        return unless self.class.lexster_config.auto_index
+        neo_save
+        true
+      end
+
+      def neo_save
+        @_neo_destroyed = false
+        @_neo_representation = _neo_save
+      end
+
+      alias neo_create neo_save
+      alias neo_update neo_save
+
+      def neo_destroy
+        return if @_neo_destroyed
+        @_neo_destroyed = true
+
+        neo_representation = neo_find_by_id
+        return unless neo_representation
+
+        begin
+          neo_representation.del
+        rescue Neography::NodeNotFoundException => e
+          Lexster::logger.info "Lexster#neo_destroy entity not found #{self.class.name} #{self.id}"
+        end
+
+        # Not working yet because Neography can't delete a node and all of its realtionships in a batch, and deleting a node with relationships results an error
+        # if Lexster::Batch.current_batch
+        #   Lexster::Batch.current_batch << [self.class.delete_command, neo_representation.neo_id]
+        # else
+        #   begin
+        #     neo_representation.del
+        #   rescue Neography::NodeNotFoundException => e
+        #     Lexster::logger.info "Lexster#neo_destroy entity not found #{self.class.name} #{self.id}"
+        #   end
+        # end
+
+        _reset_neo_representation
+
+        true
+      end
+
+      def neo_unique_id
+        "#{self.class.name}:#{self.id}"
+      end
+
+      protected
+      def neo_properties_to_hash(*attribute_list)
+        attribute_list.flatten.inject({}) { |all, property|
+          all[property] = self.send(property)
+          all
+        }
+      end
+
+      private
+      def _neo_representation
+        @_neo_representation ||= neo_find_by_id || neo_save
+      end
+
+      def _reset_neo_representation
+        @_neo_representation = nil
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+
+      receiver.after_save :neo_save_after_model_save
+      receiver.after_destroy :neo_destroy
+    end
+  end
+end

data/lib/lexster/model_config.rb

@@ -0,0 +1,57 @@
+module Lexster
+  class ModelConfig
+    attr_reader :properties
+    attr_reader :search_options
+    attr_reader :relationship_options
+    attr_accessor :enable_model_index
+    attr_accessor :auto_index
+    
+    def initialize(klass)
+      @klass = klass
+    end
+    
+    def stored_fields
+      @stored_fields ||= {}
+    end
+    
+    def field(name, &block)
+      self.stored_fields[name] = block
+    end
+    
+    def relationship(options)
+      @relationship_options = options
+    end
+    
+    def search(&block)
+      raise "search needs a block" unless block_given?
+      @search_options = SearchConfig.new
+      block.(@search_options)
+    end
+    
+    def inspect
+      "#<Lexster::ModelConfig @properties=#{properties.inspect} @search_options=#{@search_options.inspect}>"
+    end
+  end
+  
+  class SearchConfig
+    def index_fields
+      @index_fields ||= {}
+    end
+
+    def fulltext_fields
+      @fulltext_fields ||= {}
+    end
+    
+    def index(field, options = {}, &block)
+      index_fields[field] = options.merge(block: block)
+    end
+    
+    def fulltext(field, options = {}, &block)
+      fulltext_fields[field] = options.merge(block: block)
+    end
+    
+    def inspect
+      "#<Lexster::SearchConfig @index_fields=#{index_fields.inspect} @fulltext_fields=#{fulltext_fields.inspect}>"
+    end
+  end
+end

data/lib/lexster/node.rb

@@ -0,0 +1,210 @@
+module Lexster
+  module Node
+    def self.from_hash(hash)
+      node = Neography::Node.new(hash)
+      node.neo_server = Lexster.db
+      node
+    end
+
+    module ClassMethods
+      attr_accessor :neo_subref_node
+
+      def neo_subref_rel_type
+        @_neo_subref_rel_type ||= "#{self.name.tableize}_subref"
+      end
+
+      def neo_subref_node_rel_type
+        @_neo_subref_node_rel_type ||= self.name.tableize
+      end
+
+      def delete_command
+        :delete_node
+      end
+
+      def neo_model_index
+        return nil unless Lexster.config.enable_per_model_indexes
+
+        Lexster::logger.info "Node#neo_model_index #{neo_subref_rel_type}"
+
+        gremlin_query = <<-GREMLIN
+          g.createManualIndex(neo_model_index_name, Vertex.class);
+        GREMLIN
+
+        # Lexster.logger.info "subref query:\n#{gremlin_query}"
+
+        script_vars = { neo_model_index_name: neo_model_index_name }
+
+        Lexster.execute_script_or_add_to_batch gremlin_query, script_vars
+      end
+
+      def neo_subref_node
+        return nil unless Lexster.config.enable_subrefs
+
+        @neo_subref_node ||= begin
+          Lexster::logger.info "Node#neo_subref_node #{neo_subref_rel_type}"
+
+          gremlin_query = <<-GREMLIN
+            q = g.v(0).out(neo_subref_rel_type);
+
+            subref = q.hasNext() ? q.next() : null;
+
+            if (!subref) {
+              subref = g.addVertex([name: neo_subref_rel_type, type: name]);
+              g.addEdge(g.v(0), subref, neo_subref_rel_type);
+            }
+
+            subref
+          GREMLIN
+
+          # Lexster.logger.info "subref query:\n#{gremlin_query}"
+
+          script_vars = {
+            neo_subref_rel_type: neo_subref_rel_type,
+            name: self.name
+          }
+
+          Lexster.execute_script_or_add_to_batch gremlin_query, script_vars do |value|
+            Lexster::Node.from_hash(value)
+          end
+        end
+      end
+
+      def reset_neo_subref_node
+        @neo_subref_node = nil
+      end
+
+      def neo_search(term, options = {})
+        Lexster.search(self, term, options)
+      end
+    end
+    
+    module InstanceMethods
+      def neo_find_by_id
+        # Lexster::logger.info "Node#neo_find_by_id #{self.class.neo_index_name} #{self.id}"
+        node = Lexster.db.get_node_auto_index(Lexster::UNIQUE_ID_KEY, self.neo_unique_id)
+        node.present? ? Lexster::Node.from_hash(node[0]) : nil
+      end
+      
+      def _neo_save
+        return unless Lexster.enabled?
+
+        data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id, Lexster::UNIQUE_ID_KEY => self.neo_unique_id)
+        data.reject! { |k, v| v.nil? }
+
+        gremlin_query = <<-GREMLIN
+          idx = g.idx('node_auto_index');
+          q = null;
+          if (idx) q = idx.get(unique_id_key, unique_id);
+
+          node = null;
+          if (q && q.hasNext()) {
+            node = q.next();
+            node_data.each {
+              if (node.getProperty(it.key) != it.value) {
+                node.setProperty(it.key, it.value);
+              }
+            }
+          } else {
+            node = g.addVertex(node_data);
+            if (enable_subrefs) g.addEdge(g.v(subref_id), node, neo_subref_node_rel_type);
+
+            if (enable_model_index) g.idx(neo_model_index_name).put('ar_id', node.ar_id, node);
+          }
+
+          node
+        GREMLIN
+
+         script_vars = {
+          unique_id_key: Lexster::UNIQUE_ID_KEY,
+          node_data: data,
+          unique_id: self.neo_unique_id,
+          enable_subrefs: Lexster.config.enable_subrefs,
+          enable_model_index: Lexster.config.enable_per_model_indexes && self.class.lexster_config.enable_model_index
+        }
+
+        if Lexster.config.enable_subrefs
+          script_vars.update(
+            subref_id: self.class.neo_subref_node.neo_id,
+            neo_subref_node_rel_type: self.class.neo_subref_node_rel_type
+          )
+        end
+
+        if Lexster.config.enable_per_model_indexes && self.class.lexster_config.enable_model_index
+          script_vars.update(
+            neo_model_index_name: self.class.neo_model_index_name
+          )
+        end
+
+        Lexster::logger.info "Node#neo_save #{self.class.name} #{self.id}"
+
+        node = Lexster.execute_script_or_add_to_batch(gremlin_query, script_vars) do |value|
+          @_neo_representation = Lexster::Node.from_hash(value)
+        end.then do |result|
+          neo_search_index
+        end
+
+        node
+      end
+
+      def neo_search_index
+        return if self.class.lexster_config.search_options.blank? || (
+          self.class.lexster_config.search_options.index_fields.blank? &&
+          self.class.lexster_config.search_options.fulltext_fields.blank?
+        )
+
+        Lexster.ensure_default_fulltext_search_index
+
+        Lexster.db.add_node_to_index(DEFAULT_FULLTEXT_SEARCH_INDEX_NAME, 'ar_type', self.class.name, neo_node.neo_id)
+
+        self.class.lexster_config.search_options.fulltext_fields.each do |field, options|
+          Lexster.db.add_node_to_index(DEFAULT_FULLTEXT_SEARCH_INDEX_NAME, "#{field}_fulltext", neo_helper_get_field_value(field, options), neo_node.neo_id)
+        end
+
+        self.class.lexster_config.search_options.index_fields.each do |field, options|
+          Lexster.db.add_node_to_index(DEFAULT_FULLTEXT_SEARCH_INDEX_NAME, field, neo_helper_get_field_value(field, options), neo_node.neo_id)
+        end
+
+        neo_node
+      end
+
+      def neo_helper_get_field_value(field, options = {})
+        if options[:block]
+          options[:block].call
+        else
+          self.send(field) rescue (raise "No field #{field} for #{self.class.name}")
+        end
+      end
+      
+      def neo_load(hash)
+        Lexster::Node.from_hash(hash)
+      end
+      
+      def neo_node
+        _neo_representation
+      end
+
+      def neo_after_relationship_remove(relationship)
+        relationship.neo_destroy
+      end
+
+      def neo_before_relationship_through_remove(record)
+        rel_model, foreign_key_of_owner, foreign_key_of_record = Lexster::Relationship.meta_data[self.class.name.to_s][record.class.name.to_s]
+        rel_model = rel_model.to_s.constantize
+        @__neo_temp_rels ||= {}
+        @__neo_temp_rels[record] = rel_model.where(foreign_key_of_owner => self.id, foreign_key_of_record => record.id).first
+      end
+
+      def neo_after_relationship_through_remove(record)
+        @__neo_temp_rels.each { |record, relationship| relationship.neo_destroy }
+        @__neo_temp_rels.delete(record)
+      end
+    end
+      
+    def self.included(receiver)
+      receiver.send :include, Lexster::ModelAdditions
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+      Lexster.node_models << receiver
+    end
+  end
+end

data/lib/lexster/railtie.rb

@@ -0,0 +1,15 @@
+require 'lexster/middleware'
+
+module Lexster
+  class Railtie < Rails::Railtie
+    initializer "lexster.configure_rails_initialization" do
+      config.after_initialize do
+        Lexster.initialize_all
+      end
+    end
+
+    initializer 'lexster.inject_middleware' do |app|
+      app.middleware.use Ndoid::Middleware
+    end
+  end
+end

data/lib/lexster/relationship.rb

@@ -0,0 +1,163 @@
+module Lexster
+  module Relationship
+    # this is a proxy that delays loading of start_node and end_node from Neo4j until accessed.
+    # the original Neography Relatioship loaded them on initialization
+    class RelationshipLazyProxy < ::Neography::Relationship
+      def start_node
+        @start_node_from_db ||= @start_node = Neography::Node.load(@start_node, Lexster.db)
+      end
+
+      def end_node
+        @end_node_from_db ||= @end_node = Neography::Node.load(@end_node, Lexster.db)
+      end
+    end
+
+    def self.from_hash(hash)
+      relationship = RelationshipLazyProxy.new(hash)
+
+      relationship
+    end
+
+
+    module ClassMethods
+      def delete_command
+        :delete_relationship
+      end
+    end
+
+    module InstanceMethods
+      def neo_find_by_id
+        results = Lexster.db.get_relationship_auto_index(Lexster::UNIQUE_ID_KEY, self.neo_unique_id)
+        relationship = results.present? ? Lexster::Relationship.from_hash(results[0]) : nil
+        relationship
+      end
+      
+      def _neo_save
+        return unless Lexster.enabled?
+        
+        options = self.class.lexster_config.relationship_options
+        
+        start_item = self.send(options[:start_node])
+        end_item = self.send(options[:end_node])
+        
+        return unless start_item && end_item
+
+        # initialize nodes
+        start_item.neo_node
+        end_item.neo_node
+
+        data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id, Lexster::UNIQUE_ID_KEY => self.neo_unique_id)
+        data.reject! { |k, v| v.nil? }
+
+        rel_type = options[:type].is_a?(Proc) ? options[:type].call(self) : options[:type]
+
+        gremlin_query = <<-GREMLIN
+          idx = g.idx('relationship_auto_index');
+          q = null;
+          if (idx) q = idx.get(unique_id_key, unique_id);
+
+          relationship = null;
+          if (q && q.hasNext()) {
+            relationship = q.next();
+            relationship_data.each {
+              if (relationship.getProperty(it.key) != it.value) {
+                relationship.setProperty(it.key, it.value);
+              }
+            }
+          } else {
+            node_index = g.idx('node_auto_index');
+            start_node = node_index.get(unique_id_key, start_node_unique_id).next();
+            end_node = node_index.get(unique_id_key, end_node_unique_id).next();
+
+            relationship = g.addEdge(start_node, end_node, rel_type, relationship_data);
+          }
+
+          relationship
+        GREMLIN
+
+         script_vars = {
+          unique_id_key: Lexster::UNIQUE_ID_KEY,
+          relationship_data: data,
+          unique_id: self.neo_unique_id,
+          start_node_unique_id: start_item.neo_unique_id,
+          end_node_unique_id: end_item.neo_unique_id,
+          rel_type: rel_type
+        }
+
+        Lexster::logger.info "Relationship#neo_save #{self.class.name} #{self.id}"
+        
+        relationship = Lexster.execute_script_or_add_to_batch gremlin_query, script_vars do |value|
+          Lexster::Relationship.from_hash(value)
+        end
+
+        relationship
+      end
+      
+      def neo_load(hash)
+        Lexster::Relationship.from_hash(hash)
+      end
+
+      def neo_relationship
+        _neo_representation
+      end
+    end
+
+    def self.included(receiver)
+      receiver.send :include, Lexster::ModelAdditions
+      receiver.send :include, InstanceMethods
+      receiver.extend         ClassMethods
+      
+      initialize_relationship receiver if Lexster.env_loaded
+
+      Lexster.relationship_models << receiver
+    end
+
+    def self.meta_data
+      @meta_data ||= {}
+    end
+
+    def self.initialize_relationship(rel_model)
+      rel_model.reflect_on_all_associations(:belongs_to).each do |belongs_to|
+        return if belongs_to.options[:polymorphic]
+
+        # e.g. all has_many on User class
+        all_has_many = belongs_to.klass.reflect_on_all_associations(:has_many)
+
+        # has_many (without through) on the side of the relationship that removes a relationship. e.g. User has_many :likes
+        this_has_many = all_has_many.find { |o| o.klass == rel_model }
+        next unless this_has_many
+
+        # e.g. User has_many :likes, after_remove: ...
+        full_callback_name = "after_remove_for_#{this_has_many.name}"
+        belongs_to.klass.send(full_callback_name) << :neo_after_relationship_remove if belongs_to.klass.method_defined?(full_callback_name)
+
+        # has_many (with through) on the side of the relationship that removes a relationship. e.g. User has_many :movies, through :likes
+        many_to_many = all_has_many.find { |o| o.options[:through] == this_has_many.name }
+        next unless many_to_many
+
+        return if many_to_many.options[:as] # polymorphic are not supported here yet
+
+        # user_id
+        foreign_key_of_owner = many_to_many.through_reflection.foreign_key
+
+        # movie_id
+        foreign_key_of_record = many_to_many.source_reflection.foreign_key
+
+        (Lexster::Relationship.meta_data ||= {}).tap do |data|
+          (data[belongs_to.klass.name.to_s] ||= {}).tap do |model_data|
+            model_data[many_to_many.klass.name.to_s] = [rel_model.name.to_s, foreign_key_of_owner, foreign_key_of_record]
+          end
+        end
+
+        # e.g. User has_many :movies, through: :likes, before_remove: ...
+        full_callback_name = "before_remove_for_#{many_to_many.name}"
+        belongs_to.klass.send(full_callback_name) << :neo_before_relationship_through_remove if belongs_to.klass.method_defined?(full_callback_name)
+
+
+        # e.g. User has_many :movies, through: :likes, after_remove: ...
+        full_callback_name = "after_remove_for_#{many_to_many.name}"
+        belongs_to.klass.send(full_callback_name) << :neo_after_relationship_through_remove if belongs_to.klass.method_defined?(full_callback_name)
+      end
+    end
+  end
+end