neo4j 3.0.0.alpha.11 → 3.0.0.rc.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d3b8eeb614c23ddb1a08578e3096eb8d2afc410
-  data.tar.gz: a33b7bd296a1b43e5c2c0a5216981fa3ed48813d
+  metadata.gz: 489ffa77b2c5a647e44d217825a68af5fbeb13cf
+  data.tar.gz: 1ef50669eb2cbca0b88a1f7f1143ec5e56740527
 SHA512:
-  metadata.gz: c67c87f76ecf5ab6fe234b8d19661fe31dec925077f8c9b06c4e9af3622c798c22f13b1a02a5bf55260f7e346cf03a474f1d0e8c7a9bce1847fbf9c1330ffb3e
-  data.tar.gz: 8548e9d857fb400dcda682d903f437cf8f1727ed885276b30e24b673df72acddbda1ec1a5859519aac7948bb167291cdfaf8acd30e9cdafd51a53a7a92327fd7
+  metadata.gz: f275a297c3b4c2f93e2c655ad6cdaf3317f27ad9aa241959251558a1eb6202ec5e74b82e5c67684581df946b10be5209761dbd9d6826a0514d2afb6b235de015
+  data.tar.gz: b3e869867b335969ff6e4357e39f8796d894c6adedbafa426aa4fe0c30f67d261e4df8a31d00815b0fc8ba08888b32d39767b29ada56bb5ea3ed7f84fa5ba55e

data/CHANGELOG

@@ -1,3 +1,15 @@
+== 3.0.0.rc.2
+* Use newer neo4j-core release
+
+== 3.0.0.rc.1
+* Support for count, size, length, empty, blank? for has_many relationship
+* Support for rails logger of cypher queries in development
+* Support for distinct count
+* Optimized methods: https://github.com/andreasronge/neo4j/wiki/Optimized-Methods
+* Queries should respect mapped label names (#421)
+* Warn if no session is available
+* Fix broken == and equality (#424)
+
 == 3.0.0.alpha.11
 * Bug fixes
 

data/README.md

@@ -2,22 +2,31 @@
 
 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.
 
-## Version 3.0.0.alpha.X
+## Documentation version 3.0.0.rc
 
-Unstable !
+* [Wiki](https://github.com/andreasronge/neo4j/wiki/Neo4j.rb-v3-Introduction)
 
-* [Wiki](https://github.com/andreasronge/neo4j/wiki/Neo4j-v3)
-* [Basic Rails 4 Example](https://github.com/andreasronge/neo4j/blob/master/example/blog/README.md)
+## Documentation Old stable version 2.x
 
-## Version 2.x
+* [README](https://github.com/andreasronge/neo4j/tree/2.x)
+* [Wiki](https://github.com/andreasronge/neo4j/wiki/Neo4j%3A%3ARails-Introduction)
+
+## Support
+
+* [Neo4j.rb mailing list](https://groups.google.com/forum/#!forum/neo4jrb)
+* Consulting support ? ask any of the developers
+
+## Developers
+
+* [Andreas Ronge](https://github.com/andreasronge)
+* [Brian Underwood](https://github.com/cheerfulstoic)
+* [Chris Grigg](https://github.com/subvertallchris)
 
-For the stable 2.x version, see [here](https://github.com/andreasronge/neo4j/tree/2.x)
 
 ## Contributing
 
-* Have you found a bug, need help, or have a patch ?
-* Just clone neo4j.rb and send me a pull request or email me.
-* Do you need help - send me an email (andreas.ronge at gmail dot com).
+Pull request with high test coverage and good [code climate](https://codeclimate.com/github/andreasronge/neo4j) values will be accepted faster.
+
 
 ## License
 

data/lib/neo4j/active_node.rb

@@ -25,6 +25,7 @@ module Neo4j
     extend ActiveSupport::Concern
 
     include Neo4j::Shared
+    include Neo4j::Shared::Identity
     include Neo4j::ActiveNode::Initialize
     include Neo4j::ActiveNode::IdProperty
     include Neo4j::ActiveNode::SerializedProperties
@@ -43,6 +44,7 @@ module Neo4j
 
     included do
       def self.inherited(other)
+        inherit_id_property(other) if self.id_property_info
         inherited_indexes(other) if self.respond_to?(:indexed_properties)
         attributes.each_pair do |k,v|
           other.attributes[k] = v
@@ -56,6 +58,12 @@ module Neo4j
        self.indexed_properties.each {|property| other.index property }
       end
 
+      def self.inherit_id_property(other)
+        id_prop = self.id_property_info
+        conf = id_prop[:type].empty? ? {auto: :uuid} : id_prop[:type]
+        other.id_property id_prop[:name], conf
+      end
+
       Neo4j::Session.on_session_available do |_|
         name = Neo4j::Config[:id_property]
         type = Neo4j::Config[:id_property_type]

data/lib/neo4j/active_node/has_n.rb

@@ -1,39 +1,49 @@
 module Neo4j::ActiveNode
-  module HasN
-    extend ActiveSupport::Concern
+module HasN
+  extend ActiveSupport::Concern
 
-    module ClassMethods
+  class NonPersistedNodeError < StandardError; end
 
-      def has_association?(name)
-        !!associations[name]
-      end
-
-      def associations
-        @associations || {}
-      end
+  module ClassMethods
 
-      # make sure the inherited classes inherit the <tt>_decl_rels</tt> hash
-      def inherited(klass)
-        klass.instance_variable_set(:@associations, associations.clone)
-
-        super
-      end
-
-      def has_many(direction, name, options = {})
-        name = name.to_sym
+    def has_association?(name)
+      !!associations[name.to_sym]
+    end
 
-        association = Neo4j::ActiveNode::HasN::Association.new(:has_many, direction, name, options)
-        name = name.to_sym
+    def associations
+      @associations || {}
+    end
 
-        @associations ||= {}
-        @associations[name] = association
+    # make sure the inherited classes inherit the <tt>_decl_rels</tt> hash
+    def inherited(klass)
+      klass.instance_variable_set(:@associations, associations.clone)
 
-        target_class_name = association.target_class_name || 'nil'
+      super
+    end
 
-        # TODO: Make assignment more efficient? (don't delete nodes when they are being assigned)
-        module_eval(%Q{
-          def #{name}(node = nil, rel = nil)
-            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name}, self.class.associations[#{name.inspect}], session: self.class.neo4j_session, start_object: self, node: node, rel: rel)
+    def has_many(direction, name, options = {})
+      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'
+
+      # TODO: Make assignment more efficient? (don't delete nodes when they are being assigned)
+      module_eval(%Q{
+        def #{name}(node = nil, rel = nil)
+          return [].freeze unless self.persisted?
+          Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name},
+                                                   self.class.associations[#{name.inspect}],
+                                                   {
+                                                     session: self.class.neo4j_session,
+                                                     start_object: self,
+                                                     node: node,
+                                                     rel: rel,
+                                                     context: '#{self.name}##{name}'
+                                                   })
           end
 
           def #{name}=(other_nodes)
@@ -50,7 +60,16 @@ module Neo4j::ActiveNode
 
         instance_eval(%Q{
           def #{name}(node = nil, rel = nil)
-            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name}, @associations[#{name.inspect}], session: self.neo4j_session, query_proxy: self.query_proxy, node: node, rel: rel)
+            context = (self.query_proxy && self.query_proxy.context ? self.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,
+                                                       node: node,
+                                                       rel: rel,
+                                                       context: context
+                                                     })
           end}, __FILE__, __LINE__)
       end
 
@@ -58,7 +77,6 @@ module Neo4j::ActiveNode
         name = name.to_sym
 
         association = Neo4j::ActiveNode::HasN::Association.new(:has_one, direction, name, options)
-        name = name.to_sym
 
         @associations ||= {}
         @associations[name] = association
@@ -67,6 +85,7 @@ module Neo4j::ActiveNode
 
         module_eval(%Q{
           def #{name}=(other_node)
+            raise(Neo4j::ActiveNode::HasN::NonPersistedNodeError, 'Unable to create relationship with non-persisted nodes') unless self.persisted?
             #{name}_query_proxy(rel: :r).query_as(:n).delete(:r).exec
             #{name}_query_proxy << other_node
           end
@@ -80,16 +99,20 @@ module Neo4j::ActiveNode
           end
 
           def #{name}(node = nil, rel = nil)
-            #{name}_query_proxy(node: node, rel: rel).first
+            return nil unless self.persisted?
+            #{name}_query_proxy(node: node, rel: rel, context: '#{self.name}##{name}').first
           end}, __FILE__, __LINE__)
 
         instance_eval(%Q{
           def #{name}_query_proxy(options = {})
-            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name}, @associations[#{name.inspect}], {session: self.neo4j_session}.merge(options))
+            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name},
+                                                     @associations[#{name.inspect}],
+                                                     {session: self.neo4j_session}.merge(options))
           end
 
           def #{name}(node = nil, rel = nil)
-            #{name}_query_proxy(query_proxy: self.query_proxy, node: node, rel: rel)
+            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)
           end}, __FILE__, __LINE__)
       end
 

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

@@ -117,8 +117,8 @@ module Neo4j
         end
 
         def check_valid_type_and_dir(type, direction)
-          raise ArgumentError, "Invalid association type: #{type.inspect}" if not [:has_many, :has_one].include?(type.to_sym)
-          raise ArgumentError, "Invalid direction: #{direction.inspect}" if not [:out, :in, :both].include?(direction.to_sym)
+          raise ArgumentError, "Invalid association type: #{type.inspect} (valid value: :has_many and :has_one)" if not [:has_many, :has_one].include?(type.to_sym)
+          raise ArgumentError, "Invalid direction: #{direction.inspect} (valid value: :out, :in, and :both)" if not [:out, :in, :both].include?(direction.to_sym)
         end
 
         def validate_option_combinations(options)

data/lib/neo4j/active_node/id_property.rb

@@ -101,10 +101,9 @@ module Neo4j::ActiveNode
         Neo4j::Node.load(key.to_i)
       end
 
-
       def id_property(name, conf = {})
+        @id_property_info = {name: name, type: conf}
         TypeMethods.define_id_methods(self, name, conf)
-
         constraint name, type: :unique
 
         self.define_singleton_method(:find_by_id) do |key|
@@ -112,8 +111,11 @@ module Neo4j::ActiveNode
         end
       end
 
-    end
+      def id_property_info
+        @id_property_info ||= false
+      end
 
+    end
   end
 
 end

data/lib/neo4j/active_node/labels.rb

@@ -9,6 +9,7 @@ module Neo4j
       WRAPPED_CLASSES = []
       class InvalidQueryError < StandardError; end
       class RecordNotFound < StandardError; end
+      class InvalidParameterError < StandardError; end
 
       # @return the labels
       # @see Neo4j-core
@@ -71,12 +72,33 @@ module Neo4j
 
         # 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).order('ID(n) DESC').limit(1).pluck(:n).first
+          self.query_as(:n).limit(1).order('ID(n) DESC').pluck(:n).first
         end
 
         # @return [Fixnum] number of nodes of this class
-        def count
-          self.query_as(:n).return("count(n) AS count").first.count
+        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.
@@ -147,7 +169,7 @@ module Neo4j
         end
 
         def index?(index_def)
-          mapped_label.indexes[:property_keys].include?(index_def)
+          mapped_label.indexes[:property_keys].include?([index_def])
         end
 
         # @return [Array{Symbol}] all the labels that this class has
@@ -157,7 +179,7 @@ module Neo4j
 
         # @return [Symbol] the label that this class has which corresponds to a Ruby class
         def mapped_label_name
-          @_label_name || self.to_s.to_sym
+          @_label_name || (self.name.nil? ? object_id.to_s.to_sym : self.name.to_sym)
         end
 
         # @return [Neo4j::Label] the label for this class

data/lib/neo4j/active_node/node_wrapper.rb

@@ -4,6 +4,7 @@ class Neo4j::Node
     # this is a plugin in the neo4j-core so that the Ruby wrapper will be wrapped around the Neo4j::Node objects
     def wrapper
       most_concrete_class = sorted_wrapper_classes
+      return self unless most_concrete_class
       wrapped_node = most_concrete_class.new
       wrapped_node.init_on_load(self, self.props)
       wrapped_node

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

@@ -1,19 +1,21 @@
 module Neo4j
   module ActiveNode
     module Query
-
+      class InvalidParameterError < StandardError; end
       class QueryProxy
+
         include Enumerable
 
         def initialize(model, association = nil, options = {})
           @model = model
           @association = association
+          @context = options.delete(:context)
           @options = options
           @node_var = options[:node]
           @rel_var = options[:rel] || _rel_chain_var
           @session = options[:session]
           @chain = []
-          @params = {}
+          @params = options[:query_proxy] ? options[:query_proxy].instance_variable_get('@params') : {}
         end
 
         def each(node = true, rel = nil, &block)
@@ -75,7 +77,7 @@ module Neo4j
 
           query = if @association
             chain_var = _association_chain_var
-            label_string = @model && ":`#{@model.name}`"
+            label_string = @model && ":`#{@model.mapped_label_name}`"
             (_association_query_start(chain_var) & _query_model_as(var)).match("#{chain_var}#{_association_arrow}(#{var}#{label_string})")
           else
             _query_model_as(var)
@@ -109,6 +111,15 @@ module Neo4j
           raise "Can only create associations on associations" unless @association
           other_nodes = [other_nodes].flatten
 
+          other_nodes.map! do |other_node|
+            case other_node
+            when Integer, String
+              @model.find(other_node)
+            else
+              other_node
+            end
+          end
+
           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|
             #Neo4j::Transaction.run do
@@ -116,9 +127,9 @@ module Neo4j
 
               return false if @association.perform_callback(@options[:start_object], other_node, :before) == false
 
-              _association_query_start(:start)
-                .match(end: other_node.class)
-                .where(end: {neo_id: other_node.neo_id})
+              start_object = @options[:start_object]
+              _session.query(context: @options[:context])
+                .start(start: "node(#{start_object.neo_id})", end: "node(#{other_node.neo_id})")
                 .create("start#{_association_arrow(properties, true)}end").exec
 
               @association.perform_callback(@options[:start_object], other_node, :after)
@@ -126,19 +137,53 @@ 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)
           if @model && @model.respond_to?(method_name)
-            @model.query_proxy = self
-            result = @model.send(method_name, *args)
-            @model.query_proxy = nil
-            result
+            call_class_method(method_name, *args)
           else
             super
           end
         end
 
+        attr_reader :context
+
         protected
         # Methods are underscored to prevent conflict with user class methods
 
@@ -153,12 +198,13 @@ module Neo4j
         end
 
         def _query_model_as(var)
-          if @model
+          match_arg = if @model
             label = @model.respond_to?(:mapped_label_name) ? @model.mapped_label_name : @model
-            _session.query.match(var => label)
+            {var => label}
           else
-            _session.query.match(var)
+            var
           end
+          _session.query(context: @context).match(match_arg)
         end
 
         def _session
@@ -203,8 +249,17 @@ module Neo4j
           :"rel#{_chain_level - 1}"
         end
 
+        attr_writer :context
+
         private
 
+        def call_class_method(method_name, *args)
+          @model.query_proxy = self
+          result = @model.send(method_name, *args)
+          @model.query_proxy = nil
+          result
+        end
+
         def build_deeper_query_proxy(method, args)
           self.dup.tap do |new_query|
             args.each do |arg|
@@ -251,7 +306,7 @@ module Neo4j
         end
 
         def links_for_order_arg(arg)
-          [[:order, ->(v) { {v => arg} }]]
+          [[:order, ->(v) { arg.is_a?(String) ? arg : {v => arg} }]]
         end
 
 

data/lib/neo4j/active_rel.rb

@@ -6,6 +6,7 @@ module Neo4j
 
     include Neo4j::Shared
     include Neo4j::ActiveRel::Initialize
+    include Neo4j::Shared::Identity
     include Neo4j::ActiveRel::Property
     include Neo4j::ActiveRel::Persistence
     include Neo4j::ActiveRel::Validations

data/lib/neo4j/paginated.rb

@@ -10,7 +10,7 @@ module Neo4j
     def self.create_from(source, page, per_page)
       #partial = source.drop((page-1) * per_page).first(per_page)
       partial = source.skip(page-1).limit(per_page)
-      Paginated.new(partial, source.count, page)
+      Paginated.new(partial, source.instance_variable_get(:@model).count, page)
     end
 
     delegate :each, :to => :items

data/lib/neo4j/railtie.rb

@@ -1,3 +1,5 @@
+require 'active_support/notifications'
+
 module Neo4j
     class Railtie < ::Rails::Railtie
     config.neo4j = ActiveSupport::OrderedOptions.new
@@ -66,6 +68,16 @@ module Neo4j
         Neo4j::Railtie.open_neo4j_session(session_opts)
       end
       Neo4j::Config.setup.merge!(cfg.to_hash)
+
+      clear = "\e[0m"
+      red = "\e[31m"
+      yellow = "\e[33m"
+      cyan = "\e[36m"
+
+      ActiveSupport::Notifications.subscribe('neo4j.cypher_query') do |name, start, finish, id, payload|
+        ms = (finish - start) * 1000
+        Rails.logger.info " #{cyan}#{payload[:context]}#{clear} #{yellow}#{ms.round}ms#{clear} #{payload[:cypher]}" + (payload[:params].size > 0 ? ' | ' + payload[:params].inspect : '')
+      end
     end
   end
 end

data/lib/neo4j/shared.rb

@@ -7,8 +7,6 @@ module Neo4j
     include ActiveModel::Serializers::Xml
     include ActiveModel::Serializers::JSON
 
-    include Neo4j::Shared::Identity
-
     module ClassMethods
       def neo4j_session_name (name)
         @neo4j_session_name = name
@@ -18,7 +16,7 @@ module Neo4j
         if @neo4j_session_name
           Neo4j::Session.named(@neo4j_session_name) || raise("#{self.name} is configured to use a neo4j session named #{@neo4j_session_name}, but no such session is registered with Neo4j::Session")
         else
-          Neo4j::Session.current
+          Neo4j::Session.current!
         end
       end
     end

data/lib/neo4j/version.rb

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

data/lib/rails/generators/neo4j/model/model_generator.rb

@@ -9,7 +9,7 @@ class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base #:nodoc:
   class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
   class_option :indices,    :type => :array,  :desc => "The properties which should be indexed"
   class_option :has_one,    :type => :array,  :desc => "A list of has_one relationships"
-  class_option :has_n,      :type => :array,  :desc => "A list of has_n relationships"
+  class_option :has_many,   :type => :array,  :desc => "A list of has_many relationships"
 
   def create_model_file
     template "model.erb", File.join('app/models', "#{singular_name}.rb")
@@ -24,14 +24,14 @@ class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base #:nodoc:
     options[:timestamps]
   end
 
-  def has_n?
-    options[:has_n]
+  def has_many?
+    options[:has_many]
   end
 
-  def has_n_statements
+  def has_many_statements
     txt = ""
-    options[:has_n].each do |key|
-      txt << has_x('has_n', key)
+    options[:has_many].each do |key|
+      txt << has_x('has_many', key)
     end
     txt
   end
@@ -79,4 +79,4 @@ class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base #:nodoc:
   end
 
   hook_for :test_framework
-end
+end

data/lib/rails/generators/neo4j/model/templates/model.erb

@@ -1,11 +1,10 @@
 class <%= class_name %> <%= parent? ? "#{options[:parent].classify}" : "" %>
-    include Neo4j::ActiveNode
+  include Neo4j::ActiveNode
 <% attributes.each do |attribute| -%>
-    property :<%= attribute.name %><%= ", type: #{attribute.type_class}" unless attribute.type_class == 'any' %>
-    <%= index_fragment(attribute.name) %>
+  property :<%= attribute.name %><%= ", type: #{attribute.type_class}" unless attribute.type_class == 'any' %><%= "\n  " + index_fragment if index_fragment = index_fragment(attribute.name) %>
 <% end -%>
-<%= has_n_statements if has_n? -%>
+<%= has_many_statements if has_many? -%>
 <%= has_one_statements if has_one? -%>
 
 <%= timestamp_statements if timestamps? -%>
-end
+end

data/neo4j.gemspec

@@ -34,7 +34,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.alpha.19")
+  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.alpha.11
+  version: 3.0.0.rc.2
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-18 00:00:00.000000000 Z
+date: 2014-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -84,16 +84,16 @@ dependencies:
   name: neo4j-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0.alpha.19
+        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.alpha.19
+        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