neo4j 3.0.0.rc.3 → 3.0.0.rc.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2a5f927c44fc68a95721d7feca406c21a6f71d8
-  data.tar.gz: e53647f9c20b8d48040bcab9bc28ce300287f5a8
+  metadata.gz: dd39f8916d1896f18ed9ce37f44137e383415b30
+  data.tar.gz: bbed25635d7e160853156a666b25589a35986b92
 SHA512:
-  metadata.gz: 542621a0655dbae24993c9a36c5e39a37930c08fc023acb16bb907622bcd953f0a02662a4750174f851e6144e4fef62b9c4abc4326f3a954b93c4811e13402d7
-  data.tar.gz: 0ebd9085b56e5a50a01f0d01994dff9f2219f1744f5e6e053717c12d787243c3d3e94a60dcd7b9623f24c08f3ba886acd454e8551518f22b083d19b387ef2738
+  metadata.gz: b3e192aadf5611e0bfd472eb7253d2863298536bd595a9934e7c08ff3495c6685aa699335a0492f5df57d8d63bd2d84a85b1dc586237c97bf4d60cc353e894b0
+  data.tar.gz: 9dfd058c39bcf5ba5d5476d103b5449070609bc2c998250df343d3334477ef2f034d962abfad2301f7589c61af45e3ae2434d49830897c872716351e152b4829

data/CHANGELOG

@@ -1,3 +1,13 @@
+== 3.0.0.rc.4
+* UUIDs are now automatically specified on models as neo IDs won't be reliable
+in future versions of neo4j
+* Migrations now supported (including built-in migrations to migrate UUIDs and
+insert the _classname property which is used for performance)
+* Association reflection
+* Model.find supports ids/node objects as well as arrays of id/node objects
+* rake tasks now get automatically included into rails app
+
+
 == 3.0.0.rc.3
 * thread safety improvements
 * scope and general refactoring

data/Gemfile

@@ -3,10 +3,11 @@ source 'http://rubygems.org'
 gemspec
 
 #gem 'neo4j-core', path: '../neo4j-core'
-#gem 'neo4j-core', :git => 'https://github.com/andreasronge/neo4j-core.git'
+gem 'neo4j-core', git: 'https://github.com/neo4jrb/neo4j-core'
 #gem 'orm_adapter', :path => '../orm_adapter'
 
-#gem 'coveralls', require: false
+gem 'coveralls', require: false
+
 
 group 'development' do
   gem 'pry'
@@ -16,9 +17,9 @@ group 'development' do
 end
 
 group 'test' do
-  gem "codeclimate-test-reporter", require: nil
+  gem 'simplecov', require: false
+  gem 'simplecov-html', require: false
   gem "rspec", '~> 2.0'
-  # gem 'rspec-its' instead of its in rspec 3
   gem "its"
   gem "test-unit"
 end

data/README.md

@@ -1,4 +1,4 @@
-# Welcome to Neo4j.rb [![Build Status](https://secure.travis-ci.org/neo4jrb/neo4j.png?branch=master)](http://travis-ci.org/neo4jrb/neo4j) [![Test Coverage](https://codeclimate.com/github/neo4jrb/neo4j/badges/coverage.svg)](https://codeclimate.com/github/neo4jrb/neo4j) [![Code Climate](https://codeclimate.com/github/neo4jrb/neo4j.png)](https://codeclimate.com/github/andreasronge/neo4j)
+# Welcome to Neo4j.rb [![Build Status](https://secure.travis-ci.org/neo4jrb/neo4j.png?branch=master)](http://travis-ci.org/neo4jrb/neo4j) [![Coverage Status](https://coveralls.io/repos/neo4jrb/neo4j/badge.png?branch=master)](https://coveralls.io/r/neo4jrb/neo4j?branch=master) [![Code Climate](https://codeclimate.com/github/neo4jrb/neo4j.png)](https://codeclimate.com/github/andreasronge/neo4j)
 
 Neo4j.rb is an Active Model compliant Ruby/JRuby wrapper for [the Neo4j graph database](http://www.neo4j.org/). It uses the [neo4j-core](https://github.com/neo4jrb/neo4j-core) and [active_attr](https://github.com/cgriego/active_attr) gems.
 

data/config/neo4j/add_classnames.yml

@@ -0,0 +1 @@
+# This file is used as the source for adding _classname properties to nodes and relationships.

data/lib/neo4j.rb

@@ -40,6 +40,7 @@ require 'neo4j/active_rel'
 
 require 'neo4j/active_node/query_methods'
 require 'neo4j/active_node/query/query_proxy_methods'
+require 'neo4j/active_node/query/query_proxy_find_in_batches'
 require 'neo4j/active_node/labels'
 require 'neo4j/active_node/id_property'
 require 'neo4j/active_node/callbacks'
@@ -48,6 +49,7 @@ require 'neo4j/active_node/property'
 require 'neo4j/active_node/persistence'
 require 'neo4j/active_node/validations'
 require 'neo4j/active_node/rels'
+require 'neo4j/active_node/reflection'
 require 'neo4j/active_node/has_n'
 require 'neo4j/active_node/has_n/association'
 require 'neo4j/active_node/query/query_proxy'

data/lib/neo4j/active_node.rb

@@ -30,6 +30,7 @@ module Neo4j
     include Neo4j::ActiveNode::IdProperty
     include Neo4j::ActiveNode::SerializedProperties
     include Neo4j::ActiveNode::Property
+    include Neo4j::ActiveNode::Reflection
     include Neo4j::ActiveNode::Persistence
     include Neo4j::ActiveNode::Validations
     include Neo4j::ActiveNode::Callbacks
@@ -45,7 +46,7 @@ module Neo4j
 
     included do
       def self.inherited(other)
-        inherit_id_property(other) if self.id_property_info
+        inherit_id_property(other) if self.has_id_property?
         inherited_indexes(other) if self.respond_to?(:indexed_properties)
         attributes.each_pair do |k,v|
           other.attributes[k] = v
@@ -66,6 +67,8 @@ module Neo4j
       end
 
       Neo4j::Session.on_session_available do |_|
+        id_property :uuid, auto: :uuid
+
         name = Neo4j::Config[:id_property]
         type = Neo4j::Config[:id_property_type]
         value = Neo4j::Config[:id_property_type_value]

data/lib/neo4j/active_node/has_n.rb

@@ -4,8 +4,65 @@ module HasN
 
   class NonPersistedNodeError < StandardError; end
 
-  module ClassMethods
+  # Clears out the association cache.
+  def clear_association_cache #:nodoc:
+    association_cache.clear if persisted?
+  end
+
+  # Returns the current association cache. It is in the format
+  # { :association_name => { :hash_of_cypher_string => [collection] }}
+  def association_cache
+    @association_cache ||= {}
+  end
+
+  # Returns the specified association instance if it responds to :loaded?, nil otherwise.
+  # @param [String] cypher_string the cypher, with params, used for lookup
+  # @param [Enumerable] association_obj the HasN::Association object used to perform this query
+  def association_instance_get(cypher_string, association_obj)
+    return if association_cache.nil? || association_cache.empty?
+    lookup_obj = cypher_hash(cypher_string)
+    reflection = association_reflection(association_obj)
+    return if reflection.nil?
+    association_cache[reflection.name] ? association_cache[reflection.name][lookup_obj] : nil
+  end
 
+  # @return [Hash] A hash of all queries in @association_cache created from the association owning this reflection
+  def association_instance_get_by_reflection(reflection_name)
+    association_cache[reflection_name]
+  end
+
+  # Caches an association result. Unlike ActiveRecord, which stores results in @association_cache using { :association_name => [collection_result] },
+  # ActiveNode stores it using { :association_name => { :hash_string_of_cypher => [collection_result] }}.
+  # This is necessary because an association name by itself does not take into account :where, :limit, :order, etc,... so it's prone to error.
+  # @param [Neo4j::ActiveNode::Query::QueryProxy] query_proxy The QueryProxy object that resulted in this result
+  # @param [Enumerable] collection_result The result of the query after calling :each
+  # @param [Neo4j::ActiveNode::HasN::Association] association_obj The association traversed to create the result
+  def association_instance_set(cypher_string, collection_result, association_obj)
+    return collection_result if Neo4j::Transaction.current
+    cache_key = cypher_hash(cypher_string)
+    reflection = association_reflection(association_obj)
+    return if reflection.nil?
+    if @association_cache[reflection.name]
+      @association_cache[reflection.name][cache_key] = collection_result
+    else
+      @association_cache[reflection.name] = { cache_key => collection_result }
+    end
+    collection_result
+  end
+
+  def association_reflection(association_obj)
+    self.class.reflect_on_association(association_obj.name)
+  end
+
+  # Uses the cypher generated by a QueryProxy object, complete with params, to generate a basic non-cryptographic hash
+  # for use in @association_cache.
+  # @param [String] the cypher used in the query
+  # @return [String] A basic hash of the query
+  def cypher_hash(cypher_string)
+    cypher_string.hash.abs
+  end
+
+  module ClassMethods
     def has_association?(name)
       !!associations[name.to_sym]
     end
@@ -25,11 +82,11 @@ module HasN
       name = name.to_sym
 
       association = Neo4j::ActiveNode::HasN::Association.new(:has_many, direction, name, options)
-
       @associations ||= {}
       @associations[name] = association
 
       target_class_name = association.target_class_name || 'nil'
+      create_reflection(:has_many, name, association)
 
       # TODO: Make assignment more efficient? (don't delete nodes when they are being assigned)
       module_eval(%Q{
@@ -42,13 +99,15 @@ module HasN
                                                      start_object: self,
                                                      node: node,
                                                      rel: rel,
-                                                     context: '#{self.name}##{name}'
+                                                     context: '#{self.name}##{name}',
+                                                     caller: self
                                                    })
+
           end
 
           def #{name}=(other_nodes)
             #{name}(nil, :r).query_as(:n).delete(:r).exec
-
+            clear_association_cache
             other_nodes.each do |node|
               #{name} << node
             end
@@ -71,7 +130,8 @@ module HasN
                                                        query_proxy: query_proxy,
                                                        node: node,
                                                        rel: rel,
-                                                       context: context
+                                                       context: context,
+                                                       caller: query_proxy.caller
                                                      })
           end}, __FILE__, __LINE__)
       end
@@ -80,15 +140,16 @@ module HasN
         name = name.to_sym
 
         association = Neo4j::ActiveNode::HasN::Association.new(:has_one, direction, name, options)
-
         @associations ||= {}
         @associations[name] = association
 
         target_class_name = association.target_class_name || 'nil'
+        create_reflection(:has_one, name, association)
 
         module_eval(%Q{
           def #{name}=(other_node)
             raise(Neo4j::ActiveNode::HasN::NonPersistedNodeError, 'Unable to create relationship with non-persisted nodes') unless self.persisted?
+            clear_association_cache
             #{name}_query_proxy(rel: :r).query_as(:n).delete(:r).exec
             #{name}_query_proxy << other_node
           end
@@ -103,7 +164,14 @@ module HasN
 
           def #{name}(node = nil, rel = nil)
             return nil unless self.persisted?
-            #{name}_query_proxy(node: node, rel: rel, context: '#{self.name}##{name}').first
+            result = #{name}_query_proxy(node: node, rel: rel, context: '#{self.name}##{name}')
+            association = self.class.reflect_on_association(__method__)
+            query_return = association_instance_get(result.to_cypher_with_params, association)
+            if query_return.nil?
+              association_instance_set(result.to_cypher_with_params, result.first, association)
+            else
+              query_return
+            end
           end}, __FILE__, __LINE__)
 
         instance_eval(%Q{
@@ -118,8 +186,6 @@ module HasN
             #{name}_query_proxy(query_proxy: query_proxy, node: node, rel: rel, context: context)
           end}, __FILE__, __LINE__)
       end
-
-
     end
   end
 

data/lib/neo4j/active_node/has_n/association.rb

@@ -12,6 +12,7 @@ module Neo4j
           @name = name
           @direction = direction.to_sym
           @target_class_name_from_name = name.to_s.classify
+
           set_vars_from_options(options)
         end
 
@@ -64,6 +65,10 @@ module Neo4j
           end
         end
 
+        def relationship_class
+          @relationship_class
+        end
+
         private
 
         def get_direction(relationship_cypher, create)
@@ -94,10 +99,6 @@ module Neo4j
           target_class.associations[@origin].relationship_type
         end
 
-        def relationship_class
-          @relationship_class
-        end
-
         private
 
         def set_vars_from_options(options)

data/lib/neo4j/active_node/id_property.rb

@@ -51,18 +51,24 @@ module Neo4j::ActiveNode
       end
 
       def define_property_method(clazz, name)
+        clear_methods(clazz, name)
+
         clazz.module_eval(%Q{
           def id
             persisted? ? #{name} : nil
           end
 
-          property :#{name}
           validates_uniqueness_of :#{name}
+
+          property :#{name}
         }, __FILE__, __LINE__)
+
       end
 
 
       def define_uuid_method(clazz, name)
+        clear_methods(clazz, name)
+
         clazz.module_eval(%Q{
           default_property :#{name} do
              ::SecureRandom.uuid
@@ -77,6 +83,8 @@ module Neo4j::ActiveNode
       end
 
       def define_custom_method(clazz, name, on)
+        clear_methods(clazz, name)
+
         clazz.module_eval(%Q{
           default_property :#{name} do |instance|
              raise "Specifying custom id_property #{name} on none existing method #{on}" unless instance.respond_to?(:#{on})
@@ -91,17 +99,44 @@ module Neo4j::ActiveNode
         }, __FILE__, __LINE__)
       end
 
+      def clear_methods(clazz, name)
+        if clazz.method_defined?(name)
+          clazz.module_eval(%Q{
+            undef_method :#{name}
+          }, __FILE__, __LINE__)
+        end
+
+        if clazz.attribute_names.include?(name.to_s)
+          clazz.module_eval(%Q{
+            undef_property :#{name}
+          }, __FILE__, __LINE__)
+        end
+      end
+
       extend self
     end
 
 
     module ClassMethods
 
-      def find_by_id(key)
-        Neo4j::Node.load(key.to_i)
+      def find_by_id(id)
+        self.where(id_property_name => id).first
+      end
+
+      def find_by_ids(ids)
+        self.where(id_property_name => ids).to_a
       end
 
       def id_property(name, conf = {})
+        begin
+          if has_id_property?
+            unless mapped_label.uniqueness_constraints[:property_keys].include?([name])
+              drop_constraint(id_property_name, type: :unique)
+            end
+          end
+        rescue Neo4j::Server::CypherResponse::ResponseError
+        end
+
         @id_property_info = {name: name, type: conf}
         TypeMethods.define_id_methods(self, name, conf)
         constraint name, type: :unique
@@ -111,11 +146,21 @@ module Neo4j::ActiveNode
         end
       end
 
+      def has_id_property?
+        id_property_info && !id_property_info.empty?
+      end
+
       def id_property_info
-        @id_property_info ||= false
+        @id_property_info ||= {}
       end
 
+      def id_property_name
+        id_property_info[:name]
+      end
+
+      alias_method :primary_key, :id_property_name
+
     end
   end
 
-end
+end

data/lib/neo4j/active_node/initialize.rb

@@ -8,6 +8,7 @@ module Neo4j::ActiveNode::Initialize
   def init_on_load(persisted_node, properties)
     @_association_attributes = self.class.extract_association_attributes!(properties)
     @_persisted_obj = persisted_node
+    @association_cache = {}
     changed_attributes && changed_attributes.clear
     @attributes = attributes.merge(properties.stringify_keys)
     self.default_properties=properties

data/lib/neo4j/active_node/labels.rb

@@ -71,8 +71,13 @@ module Neo4j
         # Returns the object with the specified neo4j id.
         # @param [String,Fixnum] id of node to find
         def find(id)
-          raise "Unknown argument #{id.class} in find method (expected String or Fixnum)" if not [String, Fixnum].include?(id.class)
-          find_by_id(id)
+          map_id = Proc.new {|object| object.respond_to?(:id) ? object.send(:id) : object }
+
+          if id.is_a?(Array)
+            find_by_ids(id.map {|o| map_id.call(o) })
+          else
+            find_by_id(map_id.call(id))
+          end
         end
 
         # Finds the first record matching the specified conditions. There is no implied ordering so if order matters, you should specify it yourself.
@@ -129,12 +134,19 @@ module Neo4j
         #   Person.constraint :name, type: :unique
         #
         def constraint(property, constraints, session = Neo4j::Session.current)
-          Neo4j::Session.on_session_available do |_|
+          Neo4j::Session.on_session_available do |session|
             label = Neo4j::Label.create(mapped_label_name)
             label.create_constraint(property, constraints, session)
           end
         end
 
+        def drop_constraint(property, constraint, session = Neo4j::Session.current)
+          Neo4j::Session.on_session_available do |session|
+            label = Neo4j::Label.create(mapped_label_name)
+            label.drop_constraint(property, constraint, session)
+          end
+        end
+
         def index?(index_def)
           mapped_label.indexes[:property_keys].include?([index_def])
         end

data/lib/neo4j/active_node/orm_adapter.rb

@@ -73,7 +73,7 @@ module Neo4j
 
       def extract_id!(conditions)
         if id = conditions.delete(:id)
-          conditions[:neo_id] = id.to_i
+          conditions[klass.id_property_name.to_sym] = id
         end
       end