neo4j 3.0.0.rc.2 → 3.0.0.rc.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 489ffa77b2c5a647e44d217825a68af5fbeb13cf
-  data.tar.gz: 1ef50669eb2cbca0b88a1f7f1143ec5e56740527
+  metadata.gz: d2a5f927c44fc68a95721d7feca406c21a6f71d8
+  data.tar.gz: e53647f9c20b8d48040bcab9bc28ce300287f5a8
 SHA512:
-  metadata.gz: f275a297c3b4c2f93e2c655ad6cdaf3317f27ad9aa241959251558a1eb6202ec5e74b82e5c67684581df946b10be5209761dbd9d6826a0514d2afb6b235de015
-  data.tar.gz: b3e869867b335969ff6e4357e39f8796d894c6adedbafa426aa4fe0c30f67d261e4df8a31d00815b0fc8ba08888b32d39767b29ada56bb5ea3ed7f84fa5ba55e
+  metadata.gz: 542621a0655dbae24993c9a36c5e39a37930c08fc023acb16bb907622bcd953f0a02662a4750174f851e6144e4fef62b9c4abc4326f3a954b93c4811e13402d7
+  data.tar.gz: 0ebd9085b56e5a50a01f0d01994dff9f2219f1744f5e6e053717c12d787243c3d3e94a60dcd7b9623f24c08f3ba886acd454e8551518f22b083d19b387ef2738

data/CHANGELOG

@@ -1,3 +1,8 @@
+== 3.0.0.rc.3
+* thread safety improvements
+* scope and general refactoring
+* Added ability to create relationships on init (persisted on save)
+
 == 3.0.0.rc.2
 * Use newer neo4j-core release
 

data/Gemfile

@@ -6,7 +6,7 @@ gemspec
 #gem 'neo4j-core', :git => 'https://github.com/andreasronge/neo4j-core.git'
 #gem 'orm_adapter', :path => '../orm_adapter'
 
-gem 'coveralls', require: false
+#gem 'coveralls', require: false
 
 group 'development' do
   gem 'pry'
@@ -16,6 +16,7 @@ group 'development' do
 end
 
 group 'test' do
+  gem "codeclimate-test-reporter", require: nil
   gem "rspec", '~> 2.0'
   # gem 'rspec-its' instead of its in rspec 3
   gem "its"

data/README.md

@@ -1,15 +1,15 @@
-# Welcome to Neo4j.rb [![Build Status](https://secure.travis-ci.org/andreasronge/neo4j.png?branch=master)](http://travis-ci.org/andreasronge/neo4j) [![Coverage Status](https://coveralls.io/repos/andreasronge/neo4j/badge.png)](https://coveralls.io/r/andreasronge/neo4j) [![Code Climate](https://codeclimate.com/github/andreasronge/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) [![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)
 
-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/andreasronge/neo4j-core) and [active_attr](https://github.com/cgriego/active_attr) gems.
+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.
 
 ## Documentation version 3.0.0.rc
 
-* [Wiki](https://github.com/andreasronge/neo4j/wiki/Neo4j.rb-v3-Introduction)
+* [Wiki](https://github.com/neo4jrb/neo4j/wiki/Neo4j.rb-v3-Introduction)
 
 ## Documentation Old stable version 2.x
 
-* [README](https://github.com/andreasronge/neo4j/tree/2.x)
-* [Wiki](https://github.com/andreasronge/neo4j/wiki/Neo4j%3A%3ARails-Introduction)
+* [README](https://github.com/neo4jrb/neo4j/tree/2.x)
+* [Wiki](https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3ARails-Introduction)
 
 ## Support
 
@@ -31,7 +31,6 @@ Pull request with high test coverage and good [code climate](https://codeclimate
 ## License
 
 * Neo4j.rb - MIT, see the [LICENSE](http://github.com/andreasronge/neo4j/tree/master/LICENSE).
-* Lucene -  Apache, see the [Lucene Documentation](http://lucene.apache.org/java/docs/features.html).
 * Neo4j - Dual free software/commercial license, see [Licensing Guide](http://www.neo4j.org/learn/licensing).
 
 **Notice:** There are different licenses for the `neo4j-community`, `neo4j-advanced`, and `neo4j-enterprise` jar gems. Only the `neo4j-community` gem is required by default.

data/lib/neo4j.rb

@@ -38,6 +38,8 @@ require 'neo4j/active_rel/query'
 require 'neo4j/active_rel/related_node'
 require 'neo4j/active_rel'
 
+require 'neo4j/active_node/query_methods'
+require 'neo4j/active_node/query/query_proxy_methods'
 require 'neo4j/active_node/labels'
 require 'neo4j/active_node/id_property'
 require 'neo4j/active_node/callbacks'
@@ -51,6 +53,7 @@ require 'neo4j/active_node/has_n/association'
 require 'neo4j/active_node/query/query_proxy'
 require 'neo4j/active_node/query'
 require 'neo4j/active_node/serialized_properties'
+require 'neo4j/active_node/scope'
 require 'neo4j/active_node'
 
 require 'neo4j/active_node/orm_adapter'

data/lib/neo4j/active_node.rb

@@ -37,6 +37,7 @@ module Neo4j
     include Neo4j::ActiveNode::Labels
     include Neo4j::ActiveNode::Rels
     include Neo4j::ActiveNode::HasN
+    include Neo4j::ActiveNode::Scope
 
     def neo4j_obj
       _persisted_obj || raise("Tried to access native neo4j object on a non persisted object")

data/lib/neo4j/active_node/has_n.rb

@@ -59,13 +59,16 @@ module HasN
           end}, __FILE__, __LINE__)
 
         instance_eval(%Q{
-          def #{name}(node = nil, rel = nil)
-            context = (self.query_proxy && self.query_proxy.context ? self.query_proxy.context : '#{self.name}') + '##{name}'
+          def #{name}(node = nil, rel = nil, proxy_obj = nil)
+            query_proxy = proxy_obj || Neo4j::ActiveNode::Query::QueryProxy.new(#{self.name}, nil, { 
+                  session: self.neo4j_session, query_proxy: nil, context: '#{self.name}' + '##{name}'
+                })
+            context = (query_proxy && query_proxy.context ? query_proxy.context : '#{self.name}') + '##{name}'
             Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name},
                                                      @associations[#{name.inspect}],
                                                      {
                                                        session: self.neo4j_session,
-                                                       query_proxy: self.query_proxy,
+                                                       query_proxy: query_proxy,
                                                        node: node,
                                                        rel: rel,
                                                        context: context
@@ -110,9 +113,9 @@ module HasN
                                                      {session: self.neo4j_session}.merge(options))
           end
 
-          def #{name}(node = nil, rel = nil)
-            context = (self.query_proxy && self.query_proxy.context ? self.query_proxy.context : '#{self.name}') + '##{name}'
-            #{name}_query_proxy(query_proxy: self.query_proxy, node: node, rel: rel, context: context)
+          def #{name}(node = nil, rel = nil, query_proxy = nil)
+            context = (query_proxy && query_proxy.context ? query_proxy.context : '#{self.name}') + '##{name}'
+            #{name}_query_proxy(query_proxy: query_proxy, node: node, rel: rel, context: context)
           end}, __FILE__, __LINE__)
       end
 

data/lib/neo4j/active_node/initialize.rb

@@ -2,12 +2,11 @@ module Neo4j::ActiveNode::Initialize
   extend ActiveSupport::Concern
   include Neo4j::TypeConverters
 
-  attr_reader :_persisted_obj
-
   # called when loading the node from the database
   # @param [Neo4j::Node] persisted_node the node this class wraps
   # @param [Hash] properties of the persisted node.
   def init_on_load(persisted_node, properties)
+    @_association_attributes = self.class.extract_association_attributes!(properties)
     @_persisted_obj = persisted_node
     changed_attributes && changed_attributes.clear
     @attributes = attributes.merge(properties.stringify_keys)

data/lib/neo4j/active_node/labels.rb

@@ -9,7 +9,6 @@ module Neo4j
       WRAPPED_CLASSES = []
       class InvalidQueryError < StandardError; end
       class RecordNotFound < StandardError; end
-      class InvalidParameterError < StandardError; end
 
       # @return the labels
       # @see Neo4j-core
@@ -60,46 +59,14 @@ module Neo4j
       end
 
       module ClassMethods
+        include Neo4j::ActiveNode::QueryMethods
+
         # Find all nodes/objects of this class
         def all
           self.query_as(:n).pluck(:n)
         end
 
-        # Returns the first node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
-        def first
-          self.query_as(:n).limit(1).order('ID(n)').pluck(:n).first
-        end
-
-        # Returns the last node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
-        def last
-          self.query_as(:n).limit(1).order('ID(n) DESC').pluck(:n).first
-        end
-
-        # @return [Fixnum] number of nodes of this class
-        def count(distinct = nil)
-          raise(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
-          q = distinct.nil? ? "n" : "DISTINCT n"
-          self.query_as(:n).return("count(#{q}) AS count").first.count
-        end
-        alias_method :size,   :count
-        alias_method :length, :count
 
-        def empty?
-          !self.exists?
-        end
-        alias_method :blank?, :empty?
-
-        def include?(other)
-          raise(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
-          self.query_as(:n).where("ID(n) = #{other.neo_id}").return("count(n) AS count").first.count > 0
-        end
-
-        def exists?(node_id=nil)
-          raise(InvalidParameterError, ':exists? only accepts neo_ids') unless node_id.is_a?(Integer) || node_id.nil?
-          start_q = self.query_as(:n)
-          end_q = node_id.nil? ? start_q : start_q.where("ID(n) = #{node_id}")
-          end_q.return("COUNT(n) AS count").first.count > 0
-        end
 
         # Returns the object with the specified neo4j id.
         # @param [String,Fixnum] id of node to find

data/lib/neo4j/active_node/persistence.rb

@@ -13,6 +13,8 @@ module Neo4j::ActiveNode
       properties = convert_properties_to :db, props
       node = _create_node(properties)
       init_on_load(node, node.props)
+      send_props(@relationship_props) if @relationship_props
+      @relationship_props = nil
       # Neo4j::IdentityMap.add(node, self)
       # write_changed_relationships
       true

data/lib/neo4j/active_node/property.rb

@@ -3,15 +3,19 @@ module Neo4j::ActiveNode
     extend ActiveSupport::Concern
     include Neo4j::Shared::Property
 
+    def initialize(attributes={}, options={})
+      super(attributes, options)
+
+      send_props(@relationship_props) if persisted? and not @relationship_props.nil?
+    end
+
     module ClassMethods
 
       # Extracts keys from attributes hash which are relationships of the model
       # TODO: Validate separately that relationships are getting the right values?  Perhaps also store the values and persist relationships on save?
       def extract_association_attributes!(attributes)
-        attributes.keys.inject({}) do |association_props, key|
+        attributes.keys.each_with_object({}) do |key, association_props|
           association_props[key] = attributes.delete(key) if self.has_association?(key)
-
-          association_props
         end
       end
     end

data/lib/neo4j/active_node/query.rb

@@ -23,7 +23,7 @@ module Neo4j
       module ClassMethods
         include Enumerable
 
-        attr_writer :query_proxy
+        #attr_writer :query_proxy
 
         def each
           self.query_as(:n).pluck(:n).each {|o| yield o }
@@ -49,7 +49,7 @@ module Neo4j
         end
 
         def query_proxy(options = {})
-          @query_proxy || Neo4j::ActiveNode::Query::QueryProxy.new(self, nil, options)
+          Neo4j::ActiveNode::Query::QueryProxy.new(self, nil, options)
         end
 
         def as(node_var)

data/lib/neo4j/active_node/query/query_proxy.rb

@@ -1,10 +1,10 @@
 module Neo4j
   module ActiveNode
     module Query
-      class InvalidParameterError < StandardError; end
       class QueryProxy
 
         include Enumerable
+        include Neo4j::ActiveNode::Query::QueryProxyMethods
 
         def initialize(model, association = nil, options = {})
           @model = model
@@ -18,13 +18,17 @@ module Neo4j
           @params = options[:query_proxy] ? options[:query_proxy].instance_variable_get('@params') : {}
         end
 
+        def identity
+          @node_var || :result
+        end
+
         def each(node = true, rel = nil, &block)
           if node && rel
-            self.pluck((@node_var || :result), @rel_var).each do |obj, rel|
+            self.pluck(identity, @rel_var).each do |obj, rel|
               yield obj, rel
             end
           else
-            pluck_this = !rel ? (@node_var || :result) : @rel_var
+            pluck_this = !rel ? identity : @rel_var
             self.pluck(pluck_this).each do |obj|
               yield obj
             end
@@ -68,13 +72,12 @@ module Neo4j
 
         # Like calling #query_as, but for when you don't care about the variable name
         def query
-          query_as(@node_var || :result)
+          query_as(identity)
         end
 
         # Build a Neo4j::Core::Query object for the QueryProxy
         def query_as(var)
           var = @node_var if @node_var
-
           query = if @association
             chain_var = _association_chain_var
             label_string = @model && ":`#{@model.mapped_label_name}`"
@@ -111,14 +114,14 @@ module Neo4j
           raise "Can only create associations on associations" unless @association
           other_nodes = [other_nodes].flatten
 
-          other_nodes.map! do |other_node|
+          other_nodes = other_nodes.map do |other_node|
             case other_node
             when Integer, String
               @model.find(other_node)
             else
               other_node
             end
-          end
+          end.compact
 
           raise ArgumentError, "Node must be of the association's class when model is specified" if @model && other_nodes.any? {|other_node| other_node.class != @model }
           other_nodes.each do |other_node|
@@ -137,41 +140,6 @@ module Neo4j
           end
         end
 
-        #TODO: Get these out of here
-        def first
-          self.query_as(:n).limit(1).order('ID(n)').pluck(:n).first
-        end
-
-        def last
-          self.query_as(:n).limit(1).order('ID(n) DESC').pluck(:n).first
-        end
-
-        # @return [Fixnum] number of nodes of this class
-        def count(distinct = nil)
-          raise(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
-          q = distinct.nil? ? "n" : "DISTINCT n"
-          self.query_as(:n).return("count(#{q}) AS count").first.count
-        end
-        alias_method :size,   :count
-        alias_method :length, :count
-
-        def empty?
-          !self.exists?
-        end
-        alias_method :blank?, :empty?
-
-        def include?(other)
-          raise(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
-          self.query_as(:n).where("ID(n) = #{other.neo_id}").return("count(n) AS count").first.count > 0
-        end
-
-        def exists?(node_id=nil)
-          raise(InvalidParameterError, ':exists? only accepts neo_ids') unless node_id.is_a?(Integer) || node_id.nil?
-          start_q = self.query_as(:n)
-          end_q = node_id.nil? ? start_q : start_q.where("ID(n) = #{node_id}")
-          end_q.return("COUNT(n) AS count").first.count > 0
-        end
-
         # QueryProxy objects act as a representation of a model at the class level so we pass through calls
         # This allows us to define class functions for reusable query chaining or for end-of-query aggregation/summarizing
         def method_missing(method_name, *args)
@@ -254,9 +222,8 @@ module Neo4j
         private
 
         def call_class_method(method_name, *args)
-          @model.query_proxy = self
+          args[2] = self
           result = @model.send(method_name, *args)
-          @model.query_proxy = nil
           result
         end
 

data/lib/neo4j/active_node/query/query_proxy_methods.rb

@@ -0,0 +1,60 @@
+module Neo4j
+  module ActiveNode
+    module Query
+      module QueryProxyMethods
+        class InvalidParameterError < StandardError; end
+
+        def query_with_target(target, &block)
+          target = target.nil? ? identity : target
+          block.yield(target)
+        end
+
+        def first(target=nil)
+          query_with_target(target) { |target| first_and_last("ID(#{target})", target) }
+        end
+
+        def last(target=nil)
+          query_with_target(target) { |target| first_and_last("ID(#{target}) DESC", target) }
+        end
+
+        def first_and_last(order, target)
+          self.order(order).limit(1).pluck(target).first
+        end
+
+        # @return [Fixnum] number of nodes of this class
+        def count(distinct=nil, target=nil)
+          raise(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
+          query_with_target(target) do |target|
+            q = distinct.nil? ? target : "DISTINCT #{target}"
+            self.query.return("count(#{q}) AS count").first.count
+          end
+        end
+
+        alias_method :size,   :count
+        alias_method :length, :count
+
+        def empty?(target=nil)
+          query_with_target(target) { |target| !self.exists?(nil, target) }
+        end
+
+        alias_method :blank?, :empty?
+
+        def include?(other, target=nil)
+          raise(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
+          query_with_target(target) do |target|
+            self.where("ID(#{target}) = {other_node_id}").params(other_node_id: other.neo_id).query.return("count(#{target}) AS count").first.count > 0
+          end
+        end
+
+        def exists?(node_id=nil, target=nil)
+          raise(InvalidParameterError, ':exists? only accepts neo_ids') unless node_id.is_a?(Integer) || node_id.nil?
+          query_with_target(target) do |target|
+            start_q = self.query
+            end_q = node_id.nil? ? start_q : start_q.where("ID(#{target}) = #{node_id}")
+            end_q.return("COUNT(#{target}) AS count").first.count > 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/query_methods.rb

@@ -0,0 +1,47 @@
+module Neo4j
+  module ActiveNode
+    module QueryMethods
+      class InvalidParameterError < StandardError; end
+
+      def exists?(node_id=nil)
+        raise(InvalidParameterError, ':exists? only accepts neo_ids') unless node_id.is_a?(Integer) || node_id.nil?
+        start_q = self.query_as(:n)
+        end_q = node_id.nil? ? start_q : start_q.where("ID(n) = #{node_id}")
+        end_q.return("COUNT(n) AS count").first.count > 0
+      end
+
+      # Returns the first node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
+      def first
+        self.query_as(:n).limit(1).order('ID(n)').pluck(:n).first
+      end
+
+      # Returns the last node of this class, sorted by ID. Note that this may not be the first node created since Neo4j recycles IDs.
+      def last
+        self.query_as(:n).limit(1).order('ID(n) DESC').pluck(:n).first
+      end
+
+      # @return [Fixnum] number of nodes of this class
+      def count(distinct = nil)
+        raise(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
+        q = distinct.nil? ? "n" : "DISTINCT n"
+        self.query_as(:n).return("count(#{q}) AS count").first.count
+      end
+
+      alias_method :size, :count
+      alias_method :length, :count
+
+      def empty?
+        !self.exists?
+      end
+
+      alias_method :blank?, :empty?
+
+      def include?(other)
+        raise(InvalidParameterError, ':include? only accepts nodes') unless other.respond_to?(:neo_id)
+        self.query_as(:n).where("ID(n) = #{other.neo_id}").return("count(n) AS count").first.count > 0
+      end
+
+
+    end
+  end
+end

data/lib/neo4j/active_node/scope.rb

@@ -0,0 +1,87 @@
+module Neo4j::ActiveNode
+  module Scope
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Similar to ActiveRecord scope
+      #
+      # @example without argument
+      #   class Person
+      #     include Neo4j::ActiveNode
+      #     property :name
+      #     property :score
+      #     has_many :out, :friends, model_class: self
+      #     scope :top_students, -> { where(score: 42)}") }
+      #   end
+      #   Person.top_students.to_a
+      #   a_person.friends.top_students.to_a
+      #   a_person.friends.friends.top_students.to_a
+      #   a_person.friends.top_students.friends.to_a
+      #
+      # @example Argument for scopes
+      #   Person.scope :level, ->(num) { where(level_num: num)}
+      #
+      # @example Argument as a cypher identifier
+      #   class Person
+      #     include Neo4j::ActiveNode
+      #     property :name
+      #     property :score
+      #     has_many :out, :friends, model_class: self
+      #     scope :great_students, ->(identifier) { where("#{identifier}.score > 41") }
+      #   end
+      #   Person.as(:all_people).great_students(:all_people).to_a
+      #
+      # @see http://guides.rubyonrails.org/active_record_querying.html#scopes
+      def scope(name, proc)
+        _scope[name.to_sym] = proc
+
+        module_eval(%Q{
+          def #{name}(query_params=nil, _=nil, query_proxy=nil)
+            eval_context = ScopeEvalContext.new(self, query_proxy || self.class.query_proxy)
+            proc = self.class._scope[:"#{name}"]
+            self.class._call_scope_context(eval_context, query_params, proc)
+          end
+        }, __FILE__, __LINE__)
+
+        instance_eval(%Q{
+          def #{name}(query_params=nil, _=nil, query_proxy=nil)
+            eval_context = ScopeEvalContext.new(self, query_proxy || self.query_proxy)
+            proc = _scope[:"#{name}"]
+            _call_scope_context(eval_context, query_params, proc)
+          end
+        }, __FILE__, __LINE__)
+      end
+
+
+
+      def _scope
+        @_scope ||= {}
+      end
+
+      def _call_scope_context(eval_context, query_params, proc)
+        if proc.arity == 1
+          eval_context.instance_exec(query_params,&proc)
+        else
+          eval_context.instance_exec(&proc)
+        end
+      end
+
+
+    end
+
+    class ScopeEvalContext
+      def initialize(target, query_proxy)
+        @query_proxy = query_proxy
+        @target = target
+      end
+
+      Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
+        module_eval(%Q{
+            def #{method}(params={})
+              (@query_proxy || @target).#{method}(params)
+            end}, __FILE__, __LINE__)
+      end
+    end
+  end
+end

data/lib/neo4j/active_rel/initialize.rb

@@ -27,4 +27,4 @@ module Neo4j::ActiveRel
       self
     end
   end
-end
+end

data/lib/neo4j/active_rel/persistence.rb

@@ -30,7 +30,7 @@ module Neo4j::ActiveRel
       create_magic_properties
       set_timestamps
       properties = convert_properties_to :db, props
-      rel = _create_rel(properties)
+      rel = _create_rel(from_node, to_node, properties)
       init_on_load(rel, to_node, from_node, @rel_type)
       true
     end
@@ -69,8 +69,7 @@ module Neo4j::ActiveRel
       end
     end
 
-    def _create_rel(*args)
-      session = self.class.neo4j_session
+    def _create_rel(from_node, to_node, *args)
       props = self.class.default_property_values(self)
       props.merge!(args[0]) if args[0].is_a?(Hash)
       set_classname(props)

data/lib/neo4j/active_rel/property.rb

@@ -19,15 +19,19 @@ module Neo4j::ActiveRel
       self.class._type
     end
 
+    def initialize(attributes={}, options={})
+      super(attributes, options)
+
+      send_props(@relationship_props) unless @relationship_props.nil?
+    end
+
     module ClassMethods
 
       # Extracts keys from attributes hash which are relationships of the model
       # TODO: Validate separately that relationships are getting the right values?  Perhaps also store the values and persist relationships on save?
       def extract_association_attributes!(attributes)
-        attributes.keys.inject({}) do |relationship_props, key|
-          relationship_props[key] = attributes.delete(key) if key == :from_node || key == :to_node
-
-          relationship_props
+        attributes.keys.each_with_object({}) do |key, relationship_props|
+          relationship_props[key] = attributes.delete(key) if [:from_node, :to_node].include?(key)
         end
       end
 

data/lib/neo4j/shared/property.rb

@@ -15,13 +15,16 @@ module Neo4j::Shared
 
     ILLEGAL_PROPS = %w[from_node to_node start_node end_node]
 
+    attr_reader :_persisted_obj
+
     def initialize(attributes={}, options={})
       attributes = process_attributes(attributes)
-      relationship_props = self.class.extract_association_attributes!(attributes)
+      @relationship_props = self.class.extract_association_attributes!(attributes)
       writer_method_props = extract_writer_methods!(attributes)
       validate_attributes!(attributes)
       send_props(writer_method_props) unless writer_method_props.nil?
-      send_props(relationship_props) unless relationship_props.nil?
+
+      @_persisted_obj = nil
 
       super(attributes, options)
     end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "3.0.0.rc.2"
+  VERSION = "3.0.0.rc.3"
 end

data/neo4j.gemspec

@@ -11,15 +11,12 @@ Gem::Specification.new do |s|
 
   s.authors  = "Andreas Ronge"
   s.email    = 'andreas.ronge@gmail.com'
-  s.homepage = "http://github.com/andreasronge/neo4j/tree"
+  s.homepage = "https://github.com/andreasronge/neo4j/"
   s.rubyforge_project = 'neo4j'
   s.summary = "A graph database for Ruby"
   s.license = 'MIT'
   s.description = <<-EOF
-You can think of Neo4j as a high-performance graph engine with all the features of a mature and robust database.
-The programmer works with an object-oriented, flexible network structure rather than with strict and static tables 
-yet enjoys all the benefits of a fully transactional, enterprise-strength database.
-It comes included with the Apache Lucene document database.
+A Neo4j OGM for use in Ruby on Rails and Rack frameworks, intended as a complete replacement for ActiveRecord.
   EOF
 
   s.require_path = 'lib'
@@ -34,7 +31,7 @@ It comes included with the Apache Lucene document database.
   s.add_dependency("activesupport", "~> 4")
   s.add_dependency("railties", "~> 4")
   s.add_dependency('active_attr', "~> 0.8")
-  s.add_dependency("neo4j-core", "~> 3.0.0.rc.4")
+  s.add_dependency("neo4j-core", "= 3.0.0.rc.4")
 
   if RUBY_PLATFORM =~ /java/
     s.add_dependency("neo4j-community", '~> 2.0')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc.2
+  version: 3.0.0.rc.3
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-27 00:00:00.000000000 Z
+date: 2014-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -84,21 +84,18 @@ dependencies:
   name: neo4j-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
         version: 3.0.0.rc.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
         version: 3.0.0.rc.4
-description: "You can think of Neo4j as a high-performance graph engine with all the
-  features of a mature and robust database.\nThe programmer works with an object-oriented,
-  flexible network structure rather than with strict and static tables \nyet enjoys
-  all the benefits of a fully transactional, enterprise-strength database.\nIt comes
-  included with the Apache Lucene document database.\n"
+description: |
+  A Neo4j OGM for use in Ruby on Rails and Rack frameworks, intended as a complete replacement for ActiveRecord.
 email: andreas.ronge@gmail.com
 executables:
 - neo4j-jars
@@ -127,7 +124,10 @@ files:
 - lib/neo4j/active_node/property.rb
 - lib/neo4j/active_node/query.rb
 - lib/neo4j/active_node/query/query_proxy.rb
+- lib/neo4j/active_node/query/query_proxy_methods.rb
+- lib/neo4j/active_node/query_methods.rb
 - lib/neo4j/active_node/rels.rb
+- lib/neo4j/active_node/scope.rb
 - lib/neo4j/active_node/serialized_properties.rb
 - lib/neo4j/active_node/validations.rb
 - lib/neo4j/active_rel.rb
@@ -155,7 +155,7 @@ files:
 - lib/rails/generators/neo4j/model/templates/model.erb
 - lib/rails/generators/neo4j_generator.rb
 - neo4j.gemspec
-homepage: http://github.com/andreasronge/neo4j/tree
+homepage: https://github.com/andreasronge/neo4j/
 licenses:
 - MIT
 metadata: {}