neo4j 1.0.0.beta.27-java → 1.0.0.beta.28-java

data/lib/neo4j/{mapping/class_methods/property.rb → property/class_methods.rb}

@@ -1,6 +1,7 @@
-module Neo4j::Mapping
-  module ClassMethods
-    module Property
+module Neo4j
+  module Property
+
+    module ClassMethods
 
       # Generates accessor method and sets configuration for Neo4j node properties.
       # The generated accessor is a simple wrapper around the #[] and
@@ -80,4 +81,4 @@ module Neo4j::Mapping
       end
     end
   end
-end
+end

data/lib/neo4j/{property.rb → property/property.rb}

@@ -1,3 +1,5 @@
+require 'neo4j/property/class_methods'
+
 module Neo4j
   module Property
 

data/lib/neo4j/rails/finders.rb

@@ -4,7 +4,7 @@ module Neo4j
       extend ActiveSupport::Concern
 
       included do
-        rule(:_all, :functions => Neo4j::Functions::Count.new)
+        rule(:_all, :functions => Neo4j::Rule::Functions::Count.new)
       end
 
       module ClassMethods
@@ -59,8 +59,14 @@ module Neo4j
             when :all, :first
               kind = args.shift
               send(kind, *args)
+            when "0", 0
+              nil
             else
-              find_with_ids(*args) or first(*args)
+              if ((args.first.is_a?(Integer) || args.first.is_a?(String)) && args.first.to_i > 0)
+                find_with_ids(*args)
+              else
+                first(*args)
+              end
           end
         end
 
@@ -116,16 +122,24 @@ module Neo4j
 
           # does it contain an empty conditions param ?
           hash = args.find { |a| a.is_a?(Hash) }
-          return false if hash.include?(:conditions) && hash[:conditions].empty?
+          if hash
+            return false if hash.include?(:conditions) && hash[:conditions].empty?
 
-          # does it contain only paging or sorting params ?
-          !hash.except(:sort, :page, :per_page).empty?
+            # does it contain only paging or sorting params ?
+            !hash.except(:sort, :page, :per_page).empty?
+          else
+            return false
+          end
         end
 
         def find_with_ids(*args)
-          if ((args.first.is_a?(String) || args.first.is_a?(Integer)) && args.first.to_i > 0)
-            load(*args.map { |p| p.to_i })
+          result = load(*args.map { |p| p.to_i })
+          if result.is_a?(Array)
+            result = result.select { |r| r.is_a? self }
+          else
+            result = nil unless result.is_a? self
           end
+          result
         end
 
         def find_with_indexer(*args)

data/lib/neo4j/rails/rails.rb

@@ -0,0 +1,19 @@
+# rails
+require 'neo4j/rails/tx_methods'
+require 'neo4j/rails/transaction'
+require 'neo4j/rails/railtie'
+require 'neo4j/rails/validations/uniqueness'
+require 'neo4j/rails/validations/non_nil'
+require 'neo4j/rails/finders'
+require 'neo4j/rails/mapping/property'
+require 'neo4j/rails/validations'
+require 'neo4j/rails/callbacks'
+require 'neo4j/rails/timestamps'
+require 'neo4j/rails/serialization'
+require 'neo4j/rails/attributes'
+require 'neo4j/rails/persistence'
+require 'neo4j/rails/relationships/mapper'
+require 'neo4j/rails/relationships/relationship'
+require 'neo4j/rails/relationships/relationships'
+require 'neo4j/rails/model'
+require 'neo4j/rails/lucene_connection_closer'

data/lib/neo4j/rails/timestamps.rb

@@ -1,6 +1,6 @@
-# Handle all the created_at, updated_at, created_on, updated_on type stuff.
 module Neo4j
 	module Rails
+    # Handle all the created_at, updated_at, created_on, updated_on type stuff.
 		module Timestamps
 			extend ActiveSupport::Concern
 			

data/lib/neo4j/relationship.rb

@@ -1,3 +1,10 @@
+# external neo4j dependencies
+require 'neo4j/property/property'
+require 'neo4j/index/index'
+require 'neo4j/equal'
+require 'neo4j/load'
+require 'neo4j/to_java'
+
 module Neo4j
 
   org.neo4j.kernel.impl.core.RelationshipProxy.class_eval do

data/lib/neo4j/{mapping/class_methods/init_rel.rb → relationship_mixin/class_methods.rb}

@@ -1,6 +1,6 @@
-module Neo4j::Mapping
-  module ClassMethods
-    module InitRel
+module Neo4j
+  module RelationshipMixin
+    module ClassMethods
       def load_wrapper(rel)
         wrapped_rel = self.orig_new
         wrapped_rel.init_on_load(rel)
@@ -21,7 +21,7 @@ module Neo4j::Mapping
       # props:: optional hash of properties to initialize the create relationship with
       #
       def new(*args)
-        type, from_node, to_node, props = args
+        type, from_node, to_node = args
         rel = Neo4j::Relationship.create(type, from_node, to_node)
         wrapped_rel = super()
         wrapped_rel.init_on_load(rel)

data/lib/neo4j/{mapping → relationship_mixin}/relationship_mixin.rb

@@ -1,5 +1,23 @@
-module Neo4j::Mapping
-
+# external neo4j dependencies
+require 'neo4j/index/index'
+require 'neo4j/property/property'
+
+# internal dependencies
+require 'neo4j/relationship_mixin/class_methods'
+
+
+module Neo4j
+
+  # Use this mixin to wrap Neo4j Relationship Java object.
+  # This mixin is similar to Neo4j::NodeMixin which wraps Neo4j::Node Java objects.
+  #
+  # ==== Instance Methods, Mixins
+  # * Neo4j::Index :: relationships can also be indexed just like nodes
+  # *
+  # ==== Class Methods, Mixins
+  # * Neo4j::Index::ClassMethods :: for declaration for keeping lucene index and neo4j property in sync
+  # * Neo4j::Property::ClassMethods :: for declaration of convenience accessors of property
+  #
   module RelationshipMixin
     extend Forwardable
     include Neo4j::Index
@@ -103,9 +121,9 @@ module Neo4j::Mapping
         
         c.class_inheritable_hash :_decl_props
         c._decl_props ||= {}
-        
-        c.extend ClassMethods::Property
-        c.extend ClassMethods::InitRel
+
+        c.extend ClassMethods
+        c.extend Neo4j::Property::ClassMethods
         c.extend Neo4j::Index::ClassMethods
 
         def c.inherited(subclass)

data/lib/neo4j/rels/rels.rb

@@ -0,0 +1,85 @@
+require 'neo4j/rels/traverser'
+
+
+module Neo4j
+
+  # Contains methods for traversing relationship object of depth one from one node.
+  module Rels
+    include ToJava
+
+    # Returns an enumeration of relationship objects.
+    # It always returns relationship of depth one.
+    #
+    # See Neo4j::Relationship
+    #
+    # ==== Examples
+    #   # Return both incoming and outgoing relationships
+    #   me.rels(:friends, :work).each {|relationship|...}
+    #
+    #   # Only return outgoing relationship of given type
+    #   me.rels(:friends).outgoing.first.end_node # => my friend node
+    #
+    def rels(*type)
+      Traverser.new(self, type, :both)
+    end
+
+
+    # Returns the only relationship of a given type and direction that is attached to this node, or null.
+    # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or
+    # one relationships of a given type and direction to another node.
+    # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships
+    # exist, it is a fatal error that should generate an unchecked exception. This method reflects that semantics and
+    # returns either:
+    #
+    # * nil if there are zero relationships of the given type and direction,
+    # * the relationship if there's exactly one, or
+    # * raise an exception in all other cases.
+    def rel(dir, type)
+      result = _rel(dir, type)
+      result && result.wrapper
+    end
+
+    # Same as rel but does not return a ruby wrapped object but instead returns the Java object.
+    def _rel(dir, type)
+      get_single_relationship(type_to_java(type), dir_to_java(dir))
+    end
+
+    # Returns the raw java neo4j relationship object.
+    def _rels(dir=:both, *types)
+      if types.size > 1
+        java_types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
+        get_relationships(java_types)
+      elsif types.size == 1
+        get_relationships(type_to_java(types[0]), dir_to_java(dir))
+      elsif dir == :both
+        get_relationships(dir_to_java(dir))
+      else
+        raise "illegal argument, does not accept #{dir} #{types.join(',')} - only dir=:both for any relationship types"
+      end
+    end
+
+    # Check if the given relationship exists
+    # Returns true if there are one or more relationships from this node to other nodes
+    # with the given relationship.
+    #
+    # ==== Parameters
+    # type:: the key and value to be set, default any type
+    # dir:: optional default :both (either, :outgoing, :incoming, :both)
+    #
+    # ==== Returns
+    # true if one or more relationships exists for the given type and dir
+    # otherwise false
+    #
+    def rel? (type=nil, dir=:both)
+      if type
+        hasRelationship(type_to_java(type), dir_to_java(dir))
+      else
+        hasRelationship
+      end
+    end
+
+  end
+
+end
+
+

data/lib/neo4j/rels/traverser.rb

@@ -0,0 +1,102 @@
+# external neo4j dependencies
+require 'neo4j/to_java'
+
+
+module Neo4j
+  module Rels
+
+    # Traverse relationships of depth one from one node.
+    # This object is returned when using the Neo4j::Rels which is included in the Neo4j::Node class.
+    #
+    class Traverser
+      include Enumerable
+      include ToJava
+
+      def initialize(node, types, direction)
+        @node = node
+        if types.size > 1
+          @types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
+        elsif types.size == 1
+          @type = type_to_java(types[0])
+        end
+        @direction = direction
+      end
+
+      def to_s
+        if @type
+          "#{self.class} [type: #{@type} dir:#{@direction}]"
+        elsif @types
+          "#{self.class} [types: #{@types.join(',')} dir:#{@direction}]"
+        else
+          "#{self.class} [types: ANY dir:#{@direction}]"
+        end
+      end
+
+      def each
+        iter = iterator
+        while (iter.hasNext())
+          rel = iter.next
+          yield rel.wrapper if match_to_other?(rel)
+        end
+      end
+
+      def empty?
+        first == nil
+      end
+
+      def iterator
+        if @types
+          @node.get_relationships(@types).iterator
+        elsif @type
+          @node.get_relationships(@type, dir_to_java(@direction))
+        else
+          @node.get_relationships(dir_to_java(@direction))
+        end
+      end
+
+      def match_to_other?(rel)
+        if @to_other.nil?
+          true
+        elsif @direction == :outgoing
+          rel._end_node == @to_other
+        elsif @direction == :incoming
+          rel._start_node == @to_other
+        else
+          rel._start_node == @to_other || rel._end_node == @to_other
+        end
+      end
+
+      def to_other(to_other)
+        @to_other = to_other
+        self
+      end
+
+      def del
+        each { |rel| rel.del }
+      end
+
+      def size
+        [*self].size
+      end
+
+      def both
+        @direction = :both
+        self
+      end
+
+      def incoming
+        raise "Not allowed calling incoming when finding several relationships types" if @types
+        @direction = :incoming
+        self
+      end
+
+      def outgoing
+        raise "Not allowed calling outgoing when finding several relationships types" if @types
+        @direction = :outgoing
+        self
+      end
+
+    end
+
+  end
+end

data/lib/neo4j/{mapping/class_methods/rule.rb → rule/class_methods.rb}

@@ -1,5 +1,5 @@
-module Neo4j::Mapping
-  module ClassMethods
+module Neo4j
+  module Rule
 
 
     # Allows you to group nodes by providing a rule.
@@ -72,7 +72,7 @@ module Neo4j::Mapping
     # Yes, since operations are performed in an transaction. However you may get a deadlock exception:
     # http://docs.neo4j.org/html/snapshot/#_deadlocks
     #
-    module Rule
+    module ClassMethods
 
       # Creates an rule node attached to the Neo4j.ref_node
       # Can be used to rule all instances of a specific Ruby class.
@@ -102,7 +102,7 @@ module Neo4j::Mapping
 
         # define class methods
         singleton.send(:define_method, rule_name) do
-          rule_node = Neo4j::Mapping::Rule.rule_node_for(self)
+          rule_node = RuleEventListener.rule_node_for(self)
           rule_node.traversal(rule_name)
         end unless respond_to?(rule_name)
 
@@ -111,11 +111,11 @@ module Neo4j::Mapping
           instance_eval &block
         end
 
-        rule = Neo4j::Mapping::Rule.add(self, rule_name, props, &block)
+        rule = RuleEventListener.add(self, rule_name, props, &block)
 
         rule.functions && rule.functions.each do |func|
           singleton.send(:define_method, func.class.function_name) do |r_name, *args|
-            rule_node = Neo4j::Mapping::Rule.rule_node_for(self)
+            rule_node = RuleEventListener.rule_node_for(self)
             function_id = args.empty? ? "_classname" : args[0]
             function = rule_node.find_function(r_name, func.class.function_name, function_id)
             function.value(rule_node.rule_node, r_name)
@@ -124,7 +124,7 @@ module Neo4j::Mapping
       end
 
       def inherit_rules_from(clazz)
-        Neo4j::Mapping::Rule.inherit(clazz, self)
+        RuleEventListener.inherit(clazz, self)
       end
 
       # This is typically used for RSpecs to clean up rule nodes created by the #rule method.
@@ -133,7 +133,7 @@ module Neo4j::Mapping
         singelton = class << self;
           self;
         end
-        rule_node = Neo4j::Mapping::Rule.rule_node_for(self)
+        rule_node = RuleEventListener.rule_node_for(self)
 
         rule_node.rule_names.each {|rule_name| singelton.send(:remove_method, rule_name)}
         rule_node.rules.clear
@@ -145,7 +145,7 @@ module Neo4j::Mapping
       # Can also be called from an migration.
       #
       def trigger_rules(node, *changes)
-        Neo4j::Mapping::Rule.trigger_rules(node, *changes)
+        RuleEventListener.trigger_rules(node, *changes)
       end
 
       # Returns a proc that will call add method on the given function
@@ -167,7 +167,7 @@ module Neo4j::Mapping
       # Returns a proc that calls the given method on the given function.
       def function_for(method, rule_name, function_name_or_class, function_id = '_classname')
         function_name = function_name_or_class.is_a?(Symbol)? function_name_or_class : function_name_or_class.function_name
-        rule_node = Neo4j::Mapping::Rule.rule_node_for(self)
+        rule_node = RuleEventListener.rule_node_for(self)
         rule = rule_node.find_rule(rule_name)
         rule_node_raw = rule_node.rule_node
 
@@ -179,6 +179,6 @@ module Neo4j::Mapping
       end
     end
 
-    Neo4j.unstarted_db.event_handler.add(Neo4j::Mapping::Rule) unless Neo4j.read_only?
+    Neo4j.unstarted_db.event_handler.add(RuleEventListener) unless Neo4j.read_only?
   end
 end