neoid 0.1.2 → 0.2.0

data/lib/neoid/database_cleaner.rb

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

data/lib/neoid/middleware.rb

@@ -1,4 +1,4 @@
-module Ndoid
+module Neoid
   class Middleware
     def initialize(app)
       @app = app

data/lib/neoid/model_additions.rb

@@ -2,11 +2,11 @@ module Neoid
   module ModelAdditions
     module ClassMethods
       attr_reader :neoid_config
-      
+
       def neoid_config
         @neoid_config ||= Neoid::ModelConfig.new(self)
       end
-      
+
       def neoidable(options = {})
         # defaults
         neoid_config.auto_index = true
@@ -15,17 +15,17 @@ module Neoid
         yield(neoid_config) if block_given?
 
         options.each do |key, value|
-          raise "Neoid #{self.name} model options: No such option #{key}" unless neoid_config.respond_to?("#{key}=")
+          raise "Neoid #{name} model options: No such option #{key}" unless neoid_config.respond_to?("#{key}=")
           neoid_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 Neoid.config.enable_per_model_indexes || neoid_config.enable_model_index
-        @index_name ||= "#{self.name.tableize}_index"
+        raise 'Per Model index is not enabled. Nodes/Relationships are auto indexed with node_auto_index/relationship_auto_index' unless Neoid.config.enable_per_model_indexes || neoid_config.enable_model_index
+        @index_name ||= "#{name.tableize}_index"
       end
     end
-  
+
     module InstanceMethods
       def to_neo
         if self.class.neoid_config.stored_fields
@@ -33,9 +33,9 @@ module Neoid
             all[field] = if block
               instance_eval(&block)
             else
-              self.send(field) rescue (raise "No field #{field} for #{self.class.name}")
+              send(field) rescue (raise "No field #{field} for #{self.class.name}")
             end
-            
+
             all
           end
 
@@ -69,7 +69,7 @@ module Neoid
         begin
           neo_representation.del
         rescue Neography::NodeNotFoundException => e
-          Neoid::logger.info "Neoid#neo_destroy entity not found #{self.class.name} #{self.id}"
+          Neoid::logger.info "Neoid#neo_destroy entity not found #{self.class.name} #{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
@@ -89,18 +89,20 @@ module Neoid
       end
 
       def neo_unique_id
-        "#{self.class.name}:#{self.id}"
+        "#{self.class.name}:#{id}"
       end
 
       protected
+
       def neo_properties_to_hash(*attribute_list)
         attribute_list.flatten.inject({}) { |all, property|
-          all[property] = self.send(property)
+          all[property] = send(property)
           all
         }
       end
 
       private
+
       def _neo_representation
         @_neo_representation ||= neo_find_by_id || neo_save
       end

data/lib/neoid/model_config.rb

@@ -5,34 +5,34 @@ module Neoid
     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
+      stored_fields[name] = block
     end
-    
+
     def relationship(options)
       @relationship_options = options
     end
-    
+
     def search(&block)
-      raise "search needs a block" unless block_given?
+      raise 'search needs a block' unless block_given?
       @search_options = SearchConfig.new
-      block.(@search_options)
+      block.call(@search_options)
     end
-    
+
     def inspect
       "#<Neoid::ModelConfig @properties=#{properties.inspect} @search_options=#{@search_options.inspect}>"
     end
   end
-  
+
   class SearchConfig
     def index_fields
       @index_fields ||= {}
@@ -41,15 +41,15 @@ module Neoid
     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
       "#<Neoid::SearchConfig @index_fields=#{index_fields.inspect} @fulltext_fields=#{fulltext_fields.inspect}>"
     end

data/lib/neoid/node.rb

@@ -6,15 +6,22 @@ module Neoid
       node
     end
 
+    def self.included(receiver)
+      receiver.send :include, Neoid::ModelAdditions
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+      Neoid.node_models << receiver
+    end
+    
     module ClassMethods
       attr_accessor :neo_subref_node
 
       def neo_subref_rel_type
-        @_neo_subref_rel_type ||= "#{self.name.tableize}_subref"
+        @_neo_subref_rel_type ||= "#{name.tableize}_subref"
       end
 
       def neo_subref_node_rel_type
-        @_neo_subref_node_rel_type ||= self.name.tableize
+        @_neo_subref_node_rel_type ||= name.tableize
       end
 
       def delete_command
@@ -60,7 +67,7 @@ module Neoid
 
           script_vars = {
             neo_subref_rel_type: neo_subref_rel_type,
-            name: self.name
+            name: name
           }
 
           Neoid.execute_script_or_add_to_batch gremlin_query, script_vars do |value|
@@ -77,18 +84,18 @@ module Neoid
         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}"
-        node = Neoid.db.get_node_auto_index(Neoid::UNIQUE_ID_KEY, self.neo_unique_id)
+        node = Neoid.db.get_node_auto_index(Neoid::UNIQUE_ID_KEY, neo_unique_id)
         node.present? ? Neoid::Node.from_hash(node[0]) : nil
       end
-      
+
       def _neo_save
         return unless Neoid.enabled?
 
-        data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id, Neoid::UNIQUE_ID_KEY => self.neo_unique_id)
+        data = to_neo.merge(ar_type: self.class.name, ar_id: id, Neoid::UNIQUE_ID_KEY => neo_unique_id)
         data.reject! { |k, v| v.nil? }
 
         gremlin_query = <<-GREMLIN
@@ -114,10 +121,10 @@ module Neoid
           node
         GREMLIN
 
-         script_vars = {
+        script_vars = {
           unique_id_key: Neoid::UNIQUE_ID_KEY,
           node_data: data,
-          unique_id: self.neo_unique_id,
+          unique_id: neo_unique_id,
           enable_subrefs: Neoid.config.enable_subrefs,
           enable_model_index: Neoid.config.enable_per_model_indexes && self.class.neoid_config.enable_model_index
         }
@@ -135,7 +142,7 @@ module Neoid
           )
         end
 
-        Neoid::logger.info "Node#neo_save #{self.class.name} #{self.id}"
+        Neoid::logger.info "Node#neo_save #{self.class.name} #{id}"
 
         node = Neoid.execute_script_or_add_to_batch(gremlin_query, script_vars) do |value|
           @_neo_representation = Neoid::Node.from_hash(value)
@@ -171,14 +178,14 @@ module Neoid
         if options[:block]
           options[:block].call
         else
-          self.send(field) rescue (raise "No field #{field} for #{self.class.name}")
+          send(field) rescue (raise "No field #{field} for #{self.class.name}")
         end
       end
-      
+
       def neo_load(hash)
         Neoid::Node.from_hash(hash)
       end
-      
+
       def neo_node
         _neo_representation
       end
@@ -191,7 +198,7 @@ module Neoid
         rel_model, foreign_key_of_owner, foreign_key_of_record = Neoid::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
+        @__neo_temp_rels[record] = rel_model.where(foreign_key_of_owner => id, foreign_key_of_record => record.id).first
       end
 
       def neo_after_relationship_through_remove(record)
@@ -199,12 +206,5 @@ module Neoid
         @__neo_temp_rels.delete(record)
       end
     end
-      
-    def self.included(receiver)
-      receiver.send :include, Neoid::ModelAdditions
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
-      Neoid.node_models << receiver
-    end
   end
 end

data/lib/neoid/railtie.rb

@@ -2,7 +2,7 @@ require 'neoid/middleware'
 
 module Neoid
   class Railtie < Rails::Railtie
-    initializer "neoid.configure_rails_initialization" do
+    initializer 'neoid.configure_rails_initialization' do
       config.after_initialize do
         Neoid.initialize_all
       end

data/lib/neoid/relationship.rb

@@ -1,5 +1,70 @@
 module Neoid
   module Relationship
+    class << self
+      def from_hash(hash)
+        relationship = RelationshipLazyProxy.new(hash)
+
+        relationship
+      end
+
+      def included(receiver)
+        receiver.send :include, Neoid::ModelAdditions
+        receiver.send :include, InstanceMethods
+        receiver.extend         ClassMethods
+
+        initialize_relationship receiver if Neoid.env_loaded
+
+        Neoid.relationship_models << receiver
+      end
+
+      def meta_data
+        @meta_data ||= {}
+      end
+
+      def 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
+
+          (Neoid::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
+
     # 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
@@ -12,13 +77,6 @@ module Neoid
       end
     end
 
-    def self.from_hash(hash)
-      relationship = RelationshipLazyProxy.new(hash)
-
-      relationship
-    end
-
-
     module ClassMethods
       def delete_command
         :delete_relationship
@@ -27,26 +85,26 @@ module Neoid
 
     module InstanceMethods
       def neo_find_by_id
-        results = Neoid.db.get_relationship_auto_index(Neoid::UNIQUE_ID_KEY, self.neo_unique_id)
+        results = Neoid.db.get_relationship_auto_index(Neoid::UNIQUE_ID_KEY, neo_unique_id)
         relationship = results.present? ? Neoid::Relationship.from_hash(results[0]) : nil
         relationship
       end
-      
+
       def _neo_save
         return unless Neoid.enabled?
-        
+
         options = self.class.neoid_config.relationship_options
-        
-        start_item = self.send(options[:start_node])
-        end_item = self.send(options[:end_node])
-        
+
+        start_item = send(options[:start_node])
+        end_item = 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, Neoid::UNIQUE_ID_KEY => self.neo_unique_id)
+        data = to_neo.merge(ar_type: self.class.name, ar_id: id, Neoid::UNIQUE_ID_KEY => neo_unique_id)
         data.reject! { |k, v| v.nil? }
 
         rel_type = options[:type].is_a?(Proc) ? options[:type].call(self) : options[:type]
@@ -75,24 +133,24 @@ module Neoid
           relationship
         GREMLIN
 
-         script_vars = {
+        script_vars = {
           unique_id_key: Neoid::UNIQUE_ID_KEY,
           relationship_data: data,
-          unique_id: self.neo_unique_id,
+          unique_id: 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
         }
 
-        Neoid::logger.info "Relationship#neo_save #{self.class.name} #{self.id}"
-        
+        Neoid::logger.info "Relationship#neo_save #{self.class.name} #{id}"
+
         relationship = Neoid.execute_script_or_add_to_batch gremlin_query, script_vars do |value|
           Neoid::Relationship.from_hash(value)
         end
 
         relationship
       end
-      
+
       def neo_load(hash)
         Neoid::Relationship.from_hash(hash)
       end
@@ -101,63 +159,5 @@ module Neoid
         _neo_representation
       end
     end
-
-    def self.included(receiver)
-      receiver.send :include, Neoid::ModelAdditions
-      receiver.send :include, InstanceMethods
-      receiver.extend         ClassMethods
-      
-      initialize_relationship receiver if Neoid.env_loaded
-
-      Neoid.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
-
-        (Neoid::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