neo4j 1.2.6-java → 2.0.0.alpha.3-java

data/lib/neo4j/has_n/decl_relationship_dsl.rb

@@ -34,7 +34,7 @@ module Neo4j
     class DeclRelationshipDsl
       include Neo4j::ToJava
 
-      attr_reader :target_class, :dir, :rel_type
+      attr_reader :target_class, :source_class, :dir, :rel_type
 
       def initialize(method_id, has_one, target_class)
         @dir = :outgoing
@@ -42,6 +42,7 @@ module Neo4j
         @has_one = has_one
         @rel_type = method_id
         @target_class = target_class
+        @source_class = target_class
       end
 
       def to_s
@@ -63,7 +64,7 @@ module Neo4j
       def java_dir
         dir_to_java(@dir)
       end
-      
+
       def each_node(node, &block) #:nodoc:
         node._java_node.getRelationships(java_rel_type, java_dir).each do |rel|
           block.call(rel.getOtherNode(node).wrapper)
@@ -141,7 +142,7 @@ module Neo4j
         if (Class === target)
           # handle e.g. has_n(:friends).to(class)
           @target_class = target
-          @rel_type = "#{@target_class}##{@method_id}"
+          @rel_type = "#{@source_class}##{@method_id}"
         elsif (Symbol === target)
           # handle e.g. has_n(:friends).to(:knows)
           @rel_type = target.to_s
@@ -163,7 +164,7 @@ module Neo4j
       #   class FileNode
       #     include Neo4j::NodeMixin
       #     # will only traverse any incoming relationship of type files from node FileNode
-      #     has_one(:folder).from(FileNode, :files)
+      #     has_one(:folder).from(FolderNode, :files)
       #   end
       #
       #   file = FileNode.new
@@ -183,7 +184,7 @@ module Neo4j
       #   end
       #
       #   file = FileNode.new
-      #   # create an outgoing relationship of type 'FileNode#files' from folder node to file
+      #   # create an outgoing relationship of type 'files' from folder node to file
       #   file.folder = FolderNode.new
       #
       #
@@ -192,14 +193,9 @@ module Neo4j
 
         if (args.size > 1)
           # handle specified (prefixed) relationship, e.g. has_n(:known_by).from(clazz, :type)
-          @rel_type = "#{@target_class}##{args[1]}"
           @target_class = args[0]
-          other_class_dsl = @target_class._decl_rels[args[1]]
-          if other_class_dsl
-            @relationship = other_class_dsl.relationship_class
-          else
-            Neo4j.logger.warn "Unknown outgoing relationship #{args[1]} on #{@target_class}"
-          end
+          @rel_type = "#{@target_class}##{args[1]}"
+          @relationship_name = args[1]
         elsif (Symbol === args[0])
           # handle unspecified (unprefixed) relationship, e.g. has_n(:known_by).from(:type)
           @rel_type = args[0]
@@ -235,7 +231,15 @@ module Neo4j
       end
 
       def relationship_class # :nodoc:
-        @relationship 
+        if !@relationship_name.nil? && @relationship.nil?
+          other_class_dsl = @target_class._decl_rels[@relationship_name]
+          if other_class_dsl
+            @relationship = other_class_dsl.relationship_class
+          else
+            Neo4j.logger.warn "Unknown outgoing relationship #{@relationship_name} on #{@target_class}"
+          end
+        end
+        @relationship
       end
     end
   end

data/lib/neo4j/has_n/mapping.rb

@@ -7,7 +7,7 @@ module Neo4j
 
     # The object created by a has_n or has_one Neo4j::NodeMixin class method which enables creating and traversal of nodes.
     #
-    # Includes the Enumerable and WillPaginate mixins.
+    # Includes the Enumerable mixin.
     # The Neo4j::Mapping::ClassMethods::Relationship#has_n and Neo4j::Mapping::ClassMethods::Relationship#one
     # methods returns an object of this type.
     #
@@ -16,8 +16,6 @@ module Neo4j
     #
     class Mapping
       include Enumerable
-      include WillPaginate::Finders::Base
-      
       include ToJava
 
       def initialize(node, dsl) # :nodoc:
@@ -30,7 +28,7 @@ module Neo4j
       end
 
       def size
-        self.to_a.size
+        self.to_a.size # TODO: Optimise this
       end
 
       alias_method :length, :size
@@ -50,13 +48,13 @@ module Neo4j
       end
 
       # Required by the Enumerable mixin.
-      def each(&block)
-        @dsl.each_node(@node, &block)
+      def each
+        @dsl.each_node(@node) {|n| yield n} # Should use yield here as passing &block through doesn't always work (why?)
       end
 
       # returns none wrapped nodes, you may get better performance using this method
-      def _each(&block)
-        @dsl._each_node(@node, &block)
+      def _each
+        @dsl._each_node(@node) {|n| yield n}
       end
 
       # Returns an real ruby array.
@@ -64,21 +62,6 @@ module Neo4j
         self.to_a
       end
 
-      def wp_query(options, pager, args, &block) #:nodoc:
-         page     = pager.current_page || 1
-         to       = pager.per_page * page
-         from     = to - pager.per_page
-         i        = 0
-         res      = []
-         _each do |node|
-           res << node.wrapper if i >= from
-           i += 1
-           break if i >= to
-         end
-         pager.replace res
-         pager.total_entries ||= self.size  # TODO, this could be very slow to do
-       end
-
       # Returns true if there are no node in this type of relationship
       def empty?
         first == nil

data/lib/neo4j/identity_map.rb

@@ -1,6 +1,3 @@
-# https://github.com/rails/rails/blob/master/activerecord/lib/active_record/identity_map.rb
-# https://github.com/rails/rails/pull/76
-
 module Neo4j
 
   # = Neo4j Identity Map

data/lib/neo4j/index/class_methods.rb

@@ -53,13 +53,19 @@ module Neo4j
       #
       #  Person.index_names[:fulltext] => 'my_location'
       #  Person.index_names[:exact] => 'Foo_Person-exact' # default Location
-      #  Notice in versions <= 1.0.0.beta.29 the default location was 'Foo::Person-exact'
-      #  which does not work on Windows [lighthouse ticket #147]
+      #
+      # The index can be prefixed, see Neo4j#threadlocal_ref_node= and multi dendency.
       #
       # :singleton-method: index_names
 
 
-      def_delegators :@_indexer, :index, :find, :index?, :index_type?, :delete_index_type, :rm_field_type, :add_index, :rm_index, :index_type_for, :index_names
+      ##
+      # Returns a hash of which indexes has been defined and the type of index (:exact or :fulltext)
+      #
+      # :singleton-method: index_types
+
+
+      def_delegators :@_indexer, :index, :find, :index?, :index_type?, :delete_index_type, :rm_field_type, :add_index, :rm_index, :index_type_for, :index_names, :index_types
 
       # Sets which indexer should be used for the given node class.
       # You can share an indexer between several different classes.

data/lib/neo4j/index/index.rb

@@ -19,7 +19,8 @@ module Neo4j
     # Neo4j::Index::ClassMethods::index
     #
     def add_index(field, value=self[field])
-      self.class.add_index(wrapped_entity, field.to_s, value)
+      converted_value = Neo4j::TypeConverters.convert(value, field, self.class)
+      self.class.add_index(wrapped_entity, field.to_s, converted_value)
     end
 
     # Removes an index on the given property.

data/lib/neo4j/index/indexer.rb

@@ -2,6 +2,7 @@ module Neo4j
   module Index
     class Indexer
       attr_reader :indexer_for, :field_types, :via_relationships, :entity_type, :parent_indexers, :via_relationships
+      alias_method :index_types, :field_types  # public method accessible from node.index_types
 
       def initialize(clazz, type) #:nodoc:
         # part of the unique name of the index
@@ -155,7 +156,7 @@ module Neo4j
       end
 
       def update_single_index_on(node, field, old_val, new_val) #:nodoc:
-        if @field_types.include?(field)
+        if @field_types.has_key?(field)
           rm_index(node, field, old_val) if old_val
           add_index(node, field, new_val) if new_val
         end
@@ -322,7 +323,7 @@ module Neo4j
       def index_names
         @index_names ||= Hash.new do |hash, index_type|
           default_filename = index_prefix + @indexer_for.to_s.gsub('::', '_')
-          hash.fetch(index_type) {"#{default_filename}-#{index_type}"}
+          hash.fetch(index_type) {"#{default_filename}_#{index_type}"}
         end
       end
 

data/lib/neo4j/index/indexer_registry.rb

@@ -10,7 +10,7 @@ module Neo4j
         def create_for(this_clazz, using_other_clazz, type)
           @@indexers                  ||= {}
           index                       = Indexer.new(this_clazz, type)
-          index.inherit_fields_from(@@indexers[using_other_clazz.to_s])
+          index.inherit_fields_from(@@indexers[using_other_clazz.to_s]) if @@indexers[using_other_clazz.to_s]
           @@indexers[this_clazz.to_s] = index
         end
 

data/lib/neo4j/index/lucene_query.rb

@@ -37,8 +37,7 @@ module Neo4j
     #
     class LuceneQuery
       include Enumerable
-      include WillPaginate::Finders::Base
-      attr_accessor :left_and_query, :left_or_query
+      attr_accessor :left_and_query, :left_or_query, :right_not_query
 
       def initialize(index, decl_props, query, params={})
         @index      = index
@@ -52,30 +51,9 @@ module Neo4j
         end
       end
 
-      def wp_query(options, pager, args, &block) #:nodoc:
-        @params[:page]     = pager.current_page
-        @params[:per_page] = pager.per_page
-        pager.replace [*self]
-        pager.total_entries = size
-      end
-
-      # Since we include the Ruby Enumerable mixin we need this method.
+      # Implements the Ruby +Enumerable+ interface
       def each
-        if @params.include?(:per_page)
-          # paginate the result, used by the will_paginate gem
-          page     = @params[:page] || 1
-          per_page = @params[:per_page]
-          to       = per_page * page
-          from     = to - per_page
-          i        = 0
-          hits.each do |node|
-            yield node.wrapper if i >= from
-            i += 1
-            break if i >= to
-          end
-        else
-          hits.each { |n| yield n.wrapper }
-        end
+        hits.each { |x| yield x.wrapper }
       end
 
       # Close hits
@@ -156,9 +134,33 @@ module Neo4j
       #  Person.find(:name=>'kalle').and(:age => 3)
       #
       def and(query2)
-        new_query                = LuceneQuery.new(@index, @decl_props, query2)
-        new_query.left_and_query = self
-        new_query
+        LuceneQuery.new(@index, @decl_props, query2).tap { |new_query| new_query.left_and_query = self }
+      end
+
+      # Create an OR lucene query.
+      #
+      # ==== Parameters
+      # query2 :: the query that should be OR together
+      #
+      # ==== Example
+      #
+      #  Person.find(:name=>'kalle').or(:age => 3)
+      #
+      def or(query2)
+        LuceneQuery.new(@index, @decl_props, query2).tap { |new_query| new_query.left_or_query = self }
+      end
+
+      # Create a NOT lucene query.
+      #
+      # ==== Parameters
+      # query2 :: the query that should exclude matching results
+      #
+      # ==== Example
+      #
+      #  Person.find(:age => 3).not(:name=>'kalle')
+      #
+      def not(query2)
+        LuceneQuery.new(@index, @decl_props, query2).tap { |new_query| new_query.right_not_query = self }
       end
 
 
@@ -175,11 +177,26 @@ module Neo4j
       end
 
       def build_and_query(query) #:nodoc:
-        left_query = @left_and_query.build_query
-        and_query  = org.apache.lucene.search.BooleanQuery.new
-        and_query.add(left_query, org.apache.lucene.search.BooleanClause::Occur::MUST)
-        and_query.add(query, org.apache.lucene.search.BooleanClause::Occur::MUST)
-        and_query
+        build_composite_query(@left_and_query.build_query, query, org.apache.lucene.search.BooleanClause::Occur::MUST)
+      end
+
+      def build_or_query(query) #:nodoc:
+        build_composite_query(@left_or_query.build_query, query, org.apache.lucene.search.BooleanClause::Occur::SHOULD)
+      end
+
+      def build_not_query(query) #:nodoc:
+        right_query = @right_not_query.build_query
+        composite_query  = org.apache.lucene.search.BooleanQuery.new
+        composite_query.add(query, org.apache.lucene.search.BooleanClause::Occur::MUST_NOT)
+        composite_query.add(right_query, org.apache.lucene.search.BooleanClause::Occur::MUST)
+        composite_query
+      end
+
+      def build_composite_query(left_query, right_query, opeartor) #:nodoc:
+        composite_query  = org.apache.lucene.search.BooleanQuery.new
+        composite_query.add(left_query, opeartor)
+        composite_query.add(right_query, opeartor)
+        composite_query
       end
 
       def build_sort_query(query) #:nodoc:
@@ -224,6 +241,8 @@ module Neo4j
         query = @query
         query = build_hash_query(query) if Hash === query
         query = build_and_query(query) if @left_and_query
+        query = build_or_query(query) if @left_or_query
+        query = build_not_query(query) if @right_not_query
         query = build_sort_query(query) if @order
         query
       end

data/lib/neo4j/neo4j.rb

@@ -13,6 +13,9 @@ require 'neo4j/database'
 #
 module Neo4j
 
+  # The version of the Neo4j jar files
+  NEO_VERSION = Neo4j::Community::VERSION
+
   class << self
     # Start Neo4j using the default database.
     # This is usally not required since the database will be started automatically when it is used.
@@ -71,6 +74,22 @@ module Neo4j
       Neo4j::Config
     end
 
+    # Executes a Cypher Query
+    # Check the neo4j http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html
+    # Returns an enumerable of hash values.
+    #
+    # === Usage
+    #
+    #  q = Neo4j.query("START n=node({node}) RETURN n", 'node' => @node.neo_id)
+    #  q.first['n'] #=> the @node
+    #  q.columns.first => 'n'
+    #
+    def query(query, params = {})
+      engine = org.neo4j.cypher.javacompat.ExecutionEngine.new(db)
+      engine.execute(query, params)
+    end
+
+
     # Returns the logger used by neo4j.
     # If not specified (with Neo4j.logger=) it will use the standard Ruby logger.
     # You can change standard logger threshold by configuration :logger_level.

data/lib/neo4j/node.rb

@@ -7,42 +7,6 @@ require 'neo4j/equal'
 require 'neo4j/load'
 
 module Neo4j
-
-  org.neo4j.kernel.impl.core.NodeProxy.class_eval do
-    include Neo4j::Property
-    include Neo4j::Rels
-    include Neo4j::Traversal
-    include Neo4j::Equal
-    include Neo4j::Index
-
-    def del #:nodoc:
-      rels.each {|r| r.del}
-      delete
-      nil
-    end
-
-    def exist?  #:nodoc:
-      Neo4j::Node.exist?(self)
-    end
-
-    def wrapped_entity  #:nodoc:
-      self
-    end
-
-    def wrapper  #:nodoc:
-      self.class.wrapper(self)
-    end
-
-    def _java_node  #:nodoc:
-      self
-    end
-
-    def class  #:nodoc:
-      Neo4j::Node
-    end
-  end
-
-
   # A node in the graph with properties and relationships to other entities.
   # Along with relationships, nodes are the core building blocks of the Neo4j data representation model.
   # Node has three major groups of operations: operations that deal with relationships, operations that deal with properties and operations that traverse the node space.
@@ -259,6 +223,48 @@ module Neo4j
         nil
       end
 
+      def extend_java_class(java_clazz) #:nodoc:
+        java_clazz.class_eval do
+          include Neo4j::Property
+          include Neo4j::Rels
+          include Neo4j::Traversal
+          include Neo4j::Equal
+          include Neo4j::Index
+
+          def del #:nodoc:
+            rels.each { |r| r.del }
+            delete
+            nil
+          end
+
+          def exist? #:nodoc:
+            Neo4j::Node.exist?(self)
+          end
+
+          def wrapped_entity #:nodoc:
+            self
+          end
+
+          def wrapper #:nodoc:
+            self.class.wrapper(self)
+          end
+
+          def _java_node #:nodoc:
+            self
+          end
+
+          def class #:nodoc:
+            Neo4j::Node
+          end
+        end
+      end
     end
   end
+
+  # org.neo4j.kernel.HighlyAvailableGraphDatabase$LookupNode
+  #
+  Neo4j::Node.extend_java_class(org.neo4j.kernel.impl.core.NodeProxy)
+
+
+
 end

data/lib/neo4j/node_mixin/node_mixin.rb

@@ -36,8 +36,6 @@ module Neo4j
   # * Neo4j::Index::ClassMethods
   # * Neo4j::HasList::ClassMethods
   #
-  # This class also includes the class mixin WillPaginate::Finders::Base, see http://github.com/mislav/will_paginate/wiki
-  #
   module NodeMixin
     include Neo4j::Index
 
@@ -80,7 +78,7 @@ module Neo4j
     def _java_entity
       @_java_node
     end
-    
+
     # Trigger rules.
     # You don't normally need to call this method (except in Migration) since
     # it will be triggered automatically by the Neo4j::Rule::Rule
@@ -99,6 +97,13 @@ module Neo4j
       self
     end
 
+    def pagination_source(*a)
+      binding.pry
+    end
+
+    def self.pagination_source(*a)
+      binding.pry
+    end
 
     def self.included(c) # :nodoc:
       c.instance_eval do
@@ -119,7 +124,6 @@ module Neo4j
       c.extend Neo4j::Rule::ClassMethods
       c.extend Neo4j::HasList::ClassMethods
       c.extend Neo4j::Index::ClassMethods
-      c.extend WillPaginate::Finders::Base
 
       def c.inherited(subclass)
         # inherit the index properties
@@ -131,7 +135,7 @@ module Neo4j
         super
       end
 
-      c.node_indexer c
+      c.node_indexer c unless c == Neo4j::Rails::Model
     end
   end
 end

data/lib/neo4j/paginated.rb

@@ -0,0 +1,23 @@
+module Neo4j
+
+  # The class provides the pagination based on the given source.
+  # The source must be an Enumerable implementing methods drop, first and count (or size).
+  # This can be used to paginage any Enumerable collection and
+  # provides the integration point for other gems, like will_paginate and kaminari.
+  class Paginated
+    include Enumerable
+    attr_reader :items, :total, :current_page
+
+    def initialize(items, total, current_page)
+      @items, @total, @current_page = items, total, current_page
+    end
+
+    def self.create_from(source, page, per_page)
+      partial = source.drop((page-1) * per_page).first(per_page)
+      Paginated.new(partial, source.count, page)
+    end
+
+    delegate :each, :to => :items
+    delegate :size, :[], :to => :items
+  end
+end

data/lib/neo4j/rails/accept_id.rb

@@ -0,0 +1,66 @@
+module Neo4j::Rails
+  # Allows accepting id for association objects. For example
+  # class Book < Neo4j::Model
+  #   has_one(:author).to(Author)
+  #   accepts_id_for :author
+  # end
+  #
+  # This would add a author_id getter and setter on Book. You could use
+  # book = Book.new(:name => 'Graph DBs', :author_id => 11)
+  # book.author_id # 11
+  # book.author_id = 13
+  # TODO: Support for has_n associations
+  module AcceptId
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Adds association_id getter and setter for one or more has_one associations
+      #
+      # @example
+      # class Book < Neo4j::Model
+      #   has_one(:author).to(Author)
+      #   has_one(:publisher).to(Publisher)
+      #   accepts_id_for :author, :publisher
+      # end
+      def accepts_id_for(*association_names)
+        association_names.each do |association_name|
+          define_association_id_getter(association_name)
+          define_association_id_setter(association_name)
+          accepts_id_associations << association_name
+        end
+      end
+
+      # Check if model accepsts id for its association
+      # @example
+      # Book.accepts_id_for?(:author) => true
+      # Book.accepts_id_for?(:genre) => false
+      def accepts_id_for?(association_name)
+        accepts_id_associations.include?(association_name)
+      end
+
+      def accepts_id_associations #nodoc
+        @accepts_id_associations ||= []
+      end
+
+      protected
+      def define_association_id_getter(association_name)
+        class_eval %Q{
+          def #{association_name}_id
+            association_object = self.#{association_name}
+            association_object.present? ? association_object.id : nil
+          end
+        }, __FILE__, __LINE__
+      end
+
+      def define_association_id_setter(association_name)
+        class_eval %Q{
+          def #{association_name}_id=(id)
+            relation_target_class = self.class._decl_rels[:#{association_name}].target_class
+            association_class =  relation_target_class <= self.class ?  Neo4j::Model : relation_target_class
+            self.#{association_name} = id.present? ? association_class.find(id) : nil
+          end
+        }, __FILE__, __LINE__
+      end
+    end
+  end
+end

data/lib/neo4j/rails/attributes.rb

@@ -38,7 +38,7 @@ module Neo4j
         key_s = key.to_s
         if !@properties.has_key?(key_s) || @properties[key_s] != value
           attribute_will_change!(key_s)
-          @properties[key_s] = value
+          @properties[key_s] = value.nil? ? attribute_defaults[key_s] : value
         end
         value
       end
@@ -98,16 +98,17 @@ module Neo4j
               send(name + "=", nil)
             else
 
-              value = if :time == decl_type
+              #TODO: Consider extracting hardcoded assignments into "Binders"
+              value = if Neo4j::TypeConverters::TimeConverter.convert?(decl_type)
                 instantiate_time_object(name, values)
-              elsif :date == decl_type
+              elsif Neo4j::TypeConverters::DateConverter.convert?(decl_type)
                 begin
                   values = values_with_empty_parameters.collect do |v| v.nil? ? 1 : v end
                   Date.new(*values)
                 rescue ArgumentError => ex # if Date.new raises an exception on an invalid date
                   instantiate_time_object(name, values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
                 end
-              elsif :datetime == decl_type
+              elsif Neo4j::TypeConverters::DateTimeConverter.convert?(decl_type)
                 DateTime.new(*values)
               else
                 raise "Unknown type #{decl_type}"
@@ -201,8 +202,8 @@ module Neo4j
       # Known properties are either in the @properties, the declared
       # properties or the property keys for the persisted node
       def property?(name)
-        @properties.keys.include?(name) ||
-            self.class._decl_props.map { |k| k.to_s }.include?(name) ||
+        @properties.has_key?(name) ||
+            self.class._decl_props.has_key?(name) ||
             begin
               persisted? && super
             rescue org.neo4j.graphdb.NotFoundException
@@ -216,9 +217,13 @@ module Neo4j
       def attribute?(name)
         name[0] != ?_ && property?(name)
       end
-      
+
       def _classname
-        self[:_classname]
+        self.class.to_s
+      end
+
+      def _classname=(value)
+        write_local_property_without_type_conversion("_classname",value)
       end
 
       # To get ActiveModel::Dirty to work, we need to be able to call undeclared
@@ -248,7 +253,7 @@ module Neo4j
 
       # Wrap the setter in a conversion from Ruby to Java
       def write_local_property_with_type_conversion(property, value)
-        self.send("#{property}_before_type_cast=", value) if respond_to?("#{property}_before_type_cast=")
+        @properties_before_type_cast[property.to_sym]=value if self.class._decl_props.has_key? property.to_sym
         write_local_property_without_type_conversion(property, Neo4j::TypeConverters.to_java(self.class, property, value))
       end
     end