neoid 0.0.2 → 0.0.5.alpha

data/lib/neoid/node.rb

@@ -11,50 +11,108 @@ module Neoid
       def neo_subref_node
         @_neo_subref_node ||= begin
           Neoid::logger.info "Node#neo_subref_node #{neo_subref_rel_type}"
-          
-          subref_node_query = Neoid.ref_node.outgoing(neo_subref_rel_type)
-
-          if subref_node_query.to_a.blank?
-            node = Neography::Node.create(type: self.name, name: neo_subref_rel_type)
-            Neography::Relationship.create(
-              neo_subref_rel_type,
-              Neoid.ref_node,
-              node
-            )
-          else
-            node = subref_node_query.first
-          end
-        
+
+          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);
+            }
+
+            g.createManualIndex(neo_index_name, Vertex.class);
+
+            subref
+          GREMLIN
+
+          Neoid.logger.info "subref query:\n#{gremlin_query}"
+
+          node = Neography::Node.load(Neoid.db.execute_script(gremlin_query, neo_subref_rel_type: neo_subref_rel_type, name: self.name, neo_index_name: self.neo_index_name))
+
           node
         end
       end
+
+      def neo_search(term, options = {})
+        Neoid.search(self, term, options)
+      end
     end
     
     module InstanceMethods
       def neo_find_by_id
         Neoid::logger.info "Node#neo_find_by_id #{self.class.neo_index_name} #{self.id}"
         Neoid.db.get_node_index(self.class.neo_index_name, :ar_id, self.id)
+      rescue Neography::NotFoundException
+        nil
       end
       
       def neo_create
+        return unless Neoid.enabled?
+        
         data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id)
         data.reject! { |k, v| v.nil? }
         
         node = Neography::Node.create(data)
         
-        Neography::Relationship.create(
-          self.class.neo_subref_node_rel_type,
-          self.class.neo_subref_node,
-          node
-        )
-        
+        retires = 2
+        begin
+          Neography::Relationship.create(
+            self.class.neo_subref_node_rel_type,
+            self.class.neo_subref_node,
+            node
+          )
+        rescue
+          # something must've happened to the cached subref node, reset and retry
+          @_neo_subref_node = nil
+          retires -= 1
+          retry if retires > 0
+        end
+
         Neoid.db.add_node_to_index(self.class.neo_index_name, :ar_id, self.id, node)
 
         Neoid::logger.info "Node#neo_create #{self.class.name} #{self.id}, index = #{self.class.neo_index_name}"
+        
+        neo_search_index
 
         node
       end
       
+      def neo_update
+        Neoid.db.set_node_properties(neo_node, self.to_neo)
+        neo_search_index
+      end
+      
+      def neo_search_index
+        return if self.class.neoid_config.search_options.blank? || (
+          self.class.neoid_config.search_options.index_fields.blank? &&
+          self.class.neoid_config.search_options.fulltext_fields.blank?
+        )
+
+        Neoid.ensure_default_fulltext_search_index
+
+        Neoid.db.add_node_to_index(DEFAULT_FULLTEXT_SEARCH_INDEX_NAME, 'ar_type', self.class.name, neo_node.neo_id)
+
+        self.class.neoid_config.search_options.fulltext_fields.each do |field, options|
+          Neoid.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.neoid_config.search_options.index_fields.each do |field, options|
+          Neoid.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(node)
         Neography::Node.load(node)
       end
@@ -65,21 +123,39 @@ module Neoid
     
       def neo_destroy
         return unless neo_node
+        Neoid.db.remove_node_from_index(DEFAULT_FULLTEXT_SEARCH_INDEX_NAME, neo_node)
+
         Neoid.db.remove_node_from_index(self.class.neo_index_name, neo_node)
         neo_node.del
+        _reset_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 = Neoid.config[: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.extend         Neoid::ModelAdditions::ClassMethods
-      receiver.send :include, Neoid::ModelAdditions::InstanceMethods
+      receiver.send :include, Neoid::ModelAdditions
       receiver.extend         ClassMethods
       receiver.send :include, InstanceMethods
-      
-      receiver.neo_subref_node # ensure
+      Neoid.node_models << receiver
       
       receiver.after_create :neo_create
+      receiver.after_update :neo_update
       receiver.after_destroy :neo_destroy
     end
   end
-end
+end

data/lib/neoid/railtie.rb

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

data/lib/neoid/relationship.rb

@@ -3,20 +3,29 @@ module Neoid
     module InstanceMethods
       def neo_find_by_id
         Neoid.db.get_relationship_index(self.class.neo_index_name, :ar_id, self.id)
+      rescue Neography::NotFoundException
+        nil
       end
       
       def neo_create
-        options = self.class.neoidable_options
+        return unless Neoid.enabled?
+        @_neo_destroyed = false
+        
+        options = self.class.neoid_config.relationship_options
         
         start_node = self.send(options[:start_node])
         end_node = self.send(options[:end_node])
         
         return unless start_node && end_node
+
+        data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id)
+        data.reject! { |k, v| v.nil? }
         
         relationship = Neography::Relationship.create(
-          options[:type],
+          options[:type].is_a?(Proc) ? options[:type].call(self) : options[:type],
           start_node.neo_node,
-          end_node.neo_node
+          end_node.neo_node,
+          data
         )
         
         Neoid.db.add_relationship_to_index(self.class.neo_index_name, :ar_id, self.id, relationship)
@@ -31,23 +40,89 @@ module Neoid
       end
       
       def neo_destroy
+        return if @_neo_destroyed
+        @_neo_destroyed = true
         return unless neo_relationship
         Neoid.db.remove_relationship_from_index(self.class.neo_index_name, neo_relationship)
         neo_relationship.del
+        _reset_neo_representation
+
+        Neoid::logger.info "Relationship#neo_destroy #{self.class.name} #{self.id}, index = #{self.class.neo_index_name}"
+
+        true
       end
       
+      def neo_update
+        Neoid.db.set_relationship_properties(neo_relationship, self.to_neo) if neo_relationship
+      end
+
       def neo_relationship
         _neo_representation
       end
     end
 
     def self.included(receiver)
-      receiver.extend         Neoid::ModelAdditions::ClassMethods
-      receiver.send :include, Neoid::ModelAdditions::InstanceMethods
+      receiver.send :include, Neoid::ModelAdditions
       receiver.send :include, InstanceMethods
       
       receiver.after_create :neo_create
       receiver.after_destroy :neo_destroy
+      receiver.after_update :neo_update
+
+      if Neoid.env_loaded
+        initialize_relationship receiver
+      else
+        Neoid.relationship_models << receiver
+      end
+    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)
+        # belongs_to.klass.send(:has_many, this_has_many.name, this_has_many.options.merge(after_remove: :neo_after_relationship_remove))
+
+        # 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
+
+        (Neoid.config[: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
+
+        # puts Neoid.config[:relationship_meta_data].inspect
+
+        # 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)
+        # belongs_to.klass.send(:has_many, many_to_many.name, many_to_many.options.merge(before_remove: :neo_after_relationship_remove))
+
+
+        # 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)
+        # belongs_to.klass.send(:has_many, many_to_many.name, many_to_many.options.merge(after_remove: :neo_after_relationship_remove))
+      end
     end
   end
-end
+end

data/lib/neoid/search_session.rb

@@ -0,0 +1,28 @@
+module Neoid
+  class SearchSession
+    def initialize(response, *models)
+      @response = response || []
+      @models = models
+    end
+    
+    def hits
+      @response.map { |x| Neography::Node.new(x) }
+    end
+
+    def ids
+      @response.collect { |x| x['data']['ar_id'] }
+    end
+    
+    def results
+      models_by_name = @models.inject({}) { |all, curr| all[curr.name] = curr; all }
+
+      ids_by_klass = @response.inject({}) do |all, curr|
+        klass_name = curr['data']['ar_type']
+        (all[models_by_name[klass_name]] ||= []) << curr['data']['ar_id']
+        all
+      end
+
+      ids_by_klass.map { |klass, ids| klass.where(id: ids) }.flatten
+    end
+  end
+end

data/lib/neoid/version.rb

@@ -1,3 +1,3 @@
 module Neoid
-  VERSION = "0.0.2"
+  VERSION = "0.0.5.alpha"
 end

data/lib/neoid.rb

@@ -1,14 +1,43 @@
-require "neoid/version"
-require "neoid/model_config"
-require "neoid/model_additions"
-require "neoid/node"
-require "neoid/relationship"
+require 'neoid/version'
+require 'neoid/model_config'
+require 'neoid/model_additions'
+require 'neoid/search_session'
+require 'neoid/node'
+require 'neoid/relationship'
+require 'neoid/database_cleaner'
+require 'neoid/railtie' if defined?(Rails)
 
 module Neoid
+  DEFAULT_FULLTEXT_SEARCH_INDEX_NAME = 'neoid_default_search_index'
+
   class << self
     attr_accessor :db
     attr_accessor :logger
     attr_accessor :ref_node
+    attr_accessor :env_loaded
+    
+    def models
+      @models ||= []
+    end
+    
+    def node_models
+      @node_models ||= []
+    end
+    
+    def relationship_models
+      @relationship_models ||= []
+    end
+
+    def config
+      @config ||= {}
+    end
+
+    def initialize_all
+      @env_loaded = true
+      relationship_models.each do |rel_model|
+        Relationship.initialize_relationship(rel_model)
+      end
+    end
     
     def db
       raise "Must set Neoid.db with a Neography::Rest instance" unless @db
@@ -16,11 +45,115 @@ module Neoid
     end
     
     def logger
-      @logger ||= Logger.new(ENV['NEOID_LOG'] ? $stdout : '/dev/null')
+      @logger ||= Logger.new(ENV['NEOID_LOG'] ? ENV['NEOID_LOG_FILE'] || $stdout : '/dev/null')
     end
     
     def ref_node
       @ref_node ||= Neography::Node.load(Neoid.db.get_root['self'])
     end
+    
+    def reset_cached_variables
+      Neoid.models.each do |klass|
+        klass.instance_variable_set(:@_neo_subref_node, nil)
+      end
+      $neo_ref_node = nil
+    end
+    
+    def clean_db(confirm)
+      puts "must call with confirm: Neoid.clean_db(:yes_i_am_sure)" and return unless confirm == :yes_i_am_sure
+      Neoid::NeoDatabaseCleaner.clean_db
+    end
+    
+
+    def enabled=(flag)
+      Thread.current[:neoid_enabled] = flag
+    end
+
+    def enabled
+      flag = Thread.current[:neoid_enabled]
+      # flag should be set by the middleware. in case it wasn't (non-rails app or console), default it to true
+      flag.nil? ? true : flag
+    end
+    alias enabled? enabled
+
+    def use(flag=true)
+      old, self.enabled = enabled?, flag
+      yield if block_given?
+    ensure
+      self.enabled = old
+    end
+
+    # create a fulltext index if not exists
+    def ensure_default_fulltext_search_index
+      Neoid.db.create_node_index(DEFAULT_FULLTEXT_SEARCH_INDEX_NAME, 'fulltext', 'lucene') unless (indexes = Neoid.db.list_node_indexes) && indexes[DEFAULT_FULLTEXT_SEARCH_INDEX_NAME]
+    end
+
+    def search(types, term, options = {})
+      options = options.reverse_merge(limit: 15)
+
+      types = [*types]
+
+      query = []
+
+      types.each do |type|
+        query_for_type = []
+
+        query_for_type << "ar_type:#{type.name}"
+
+        case term
+        when String
+          search_in_fields = type.neoid_config.search_options.fulltext_fields.keys
+          next if search_in_fields.empty?
+          query_for_type << search_in_fields.map{ |field| generate_field_query(field, term, true) }.join(" OR ")
+        when Hash
+          term.each do |field, value|
+            query_for_type << generate_field_query(field, value, false)
+          end
+        end
+
+        query << "(#{query_for_type.join(") AND (")})"
+      end
+
+      query = "(#{query.join(") OR (")})"
+
+      logger.info "Neoid query #{query}"
+
+      gremlin_query = <<-GREMLIN
+        #{options[:before_query]}
+
+        idx = g.getRawGraph().index().forNodes('#{DEFAULT_FULLTEXT_SEARCH_INDEX_NAME}')
+        hits = idx.query('#{sanitize_query_for_gremlin(query)}')
+
+        hits = #{options[:limit] ? "hits.take(#{options[:limit]})" : "hits"}
+
+        #{options[:after_query]}
+      GREMLIN
+
+      logger.info "[NEOID] search:\n#{gremlin_query}"
+
+      results = Neoid.db.execute_script(gremlin_query)
+
+      SearchSession.new(results, *types)
+    end
+
+    private
+      def sanitize_term(term)
+        # TODO - case sensitive?
+        term.downcase
+      end
+
+      def sanitize_query_for_gremlin(query)
+        # TODO - case sensitive?
+        query.gsub("'", "\\\\'")
+      end
+
+      def generate_field_query(field, term, fulltext = false)
+        term = term.to_s if term
+        return "" if term.nil? || term.empty?
+
+        fulltext = fulltext ? "_fulltext" : nil
+
+        "(" + term.split(/\s+/).reject(&:empty?).map{ |t| "#{field}#{fulltext}:#{sanitize_term(t)}" }.join(" AND ") + ")"
+      end
   end
 end

data/neoid.gemspec

@@ -18,9 +18,11 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "rest-client"
-  s.add_development_dependency "supermodel"
-  s.add_runtime_dependency "neography"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rest-client'
+  s.add_development_dependency 'activerecord'
+  s.add_development_dependency 'sqlite3'
+
+  s.add_runtime_dependency 'neography'
 end