neo4j 1.0.0.beta.21-java

data/lib/neo4j/mapping/decl_relationship_dsl.rb

@@ -0,0 +1,214 @@
+module Neo4j::Mapping
+
+
+  # A DSL for declared relationships has_n and has_one
+  # This DSL will be used to create accessor methods for relationships.
+  # Instead of using the 'raw' Neo4j::NodeMixin#rels method where one needs to know
+  # the name of relationship and direction one can use the generated accessor methods.
+  #
+  # The DSL can also be used to specify a mapping to a Ruby class for a relationship, see Neo4j::Relationships::DeclRelationshipDsl#relationship
+  #
+  # ==== Example
+  #
+  #   class Folder
+  #      include Neo4j::NodeMixin
+  #      property :name
+  #      # Declaring a Many relationship to any other node
+  #      has_n(:files)
+  #    end
+  #
+  #   class File
+  #     include Neo4j::NodeMixin
+  #     # declaring a incoming relationship from Folder's relationship files
+  #     has_one(:folder).from(Folder, :files)
+  #   end
+  #
+  # The following methods will be generated:
+  # <b>Folder#files</b> ::      returns an Enumerable of outgoing nodes for relationship 'files'
+  # <b>Folder#files_rels</b> :: returns an Enumerable of outgoing relationships for relationship 'files'
+  # <b>File#folder</b> ::       for adding one node for the relationship 'files' from the outgoing Folder node
+  # <b>File#folder_rel</b> ::   for accessing relationship 'files' from the outgoing Folder node
+  # <b>File#folder</b> ::       for accessing nodes from relationship 'files' from the outgoing Folder node
+  #
+  class DeclRelationshipDsl
+    include Neo4j::ToJava
+
+    attr_reader :target_class, :direction, :rel_type
+
+    def initialize(method_id, has_one, target_class, params)
+      @direction    = :outgoing
+      @method_id    = method_id
+      @has_one      = has_one
+      @rel_type     = method_id
+      @target_class = target_class
+    end
+
+    def to_s
+      "DeclRelationshipDsl #{object_id} dir: #{@direction} rel_id: #{@method_id}, rel_type: #{@rel_type}, target_class:#{@target_class} rel_class:#{@relationship}"
+    end
+
+    def has_one?
+      @has_one
+    end
+
+    def each_node(node, direction, &block) #:nodoc:
+      type = type_to_java(rel_type)
+      dir  = dir_to_java(direction)
+      node._java_node.getRelationships(type, dir).each do |rel|
+        other = rel.getOtherNode(node).wrapper
+        block.call other
+      end
+    end
+
+    def incoming? #:nodoc:
+      @direction == :incoming
+    end
+
+    def single_node(node) #:nodoc:
+      rel = single_relationship(node)
+      rel && rel.other_node(node).wrapper
+    end
+
+    def single_relationship(node) #:nodoc:
+      node._java_node.rel(direction, rel_type)
+    end
+
+    def _all_relationships(node) #:nodoc:
+      type = type_to_java(rel_type)
+      dir  = dir_to_java(direction)
+      node._java_node.getRelationships(type, dir)
+    end
+
+    def all_relationships(node) #:nodoc:
+      Neo4j::RelationshipTraverser.new(node._java_node, [rel_type], direction)
+    end
+
+    def create_relationship_to(node, other) # :nodoc: 
+      from, to = incoming? ? [other, node] : [node, other]
+      java_type = type_to_java(rel_type)
+
+      rel       = from._java_node.create_relationship_to(to._java_node, java_type)
+      rel[:_classname] = relationship_class.to_s if relationship_class
+      rel.wrapper
+    end
+
+    # Specifies an outgoing relationship.
+    # The name of the outgoing class will be used as a prefix for the relationship used.
+    #
+    # ==== Arguments
+    # clazz:: to which class this relationship goes
+    # relationship:: optional, the relationship to use
+    #
+    # ==== Example
+    #   class FolderNode
+    #     include Neo4j::NodeMixin
+    #     has_n(:files).to(FileNode)
+    #   end
+    #
+    #  folder = FolderNode.new
+    #  # generate a relationship between folder and file of type 'FileNode#files'
+    #  folder.files << FileNode.new
+    #
+    def to(*args)
+      @direction = :outgoing
+
+      if (args.size > 1)
+        raise "only one argument expected - the class of the node this relationship points to, got #{args.inspect}"
+      elsif (Class === args[0])
+        # handle e.g. has_n(:friends).to(class)
+        @target_class = args[0]
+        @rel_type     = "#{@target_class}##{@method_id}"
+      else
+        raise "Expected a class for, got #{args[0]}"
+      end
+      self
+    end
+
+    # Specifies an incoming relationship.
+    # Will use the outgoing relationship given by the from class.
+    #
+    # ==== Example, with prefix FileNode
+    #   class FolderNode
+    #     include Neo4j::NodeMixin
+    #     has_n(:files).to(FileNode)
+    #   end
+    #
+    #   class FileNode
+    #     include Neo4j::NodeMixin
+    #     # will only traverse any incoming relationship of type files from node FileNode
+    #     has_one(:folder).from(FileNode, :files)
+    #   end
+    #
+    #   file = FileNode.new
+    #   # create an outgoing relationship of type 'FileNode#files' from folder node to file (FileNode is the prefix).
+    #   file.folder = FolderNode.new
+    #
+    # ==== Example, without prefix
+    #
+    #   class FolderNode
+    #     include Neo4j::NodeMixin
+    #     has_n(:files)
+    #   end
+    #
+    #   class FileNode
+    #     include Neo4j::NodeMixin
+    #     has_one(:folder).from(:files)  # will traverse any incoming relationship of type files
+    #   end
+    #
+    #   file = FileNode.new
+    #   # create an outgoing relationship of type 'FileNode#files' from folder node to file
+    #   file.folder = FolderNode.new
+    #
+    #
+    def from(*args)
+      @direction = :incoming
+
+      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
+          puts "WARNING: Unknown outgoing relationship #{args[1]} on #{@target_class}"
+        end
+      elsif (Symbol === args[0])
+        # handle unspecified (unprefixed) relationship, e.g. has_n(:known_by).from(:type)
+        @rel_type = args[0]
+      else
+        raise "Expected a symbol for, got #{args[0]}"
+      end
+      self
+    end
+
+    # Specifies which relationship ruby class to use for the relationship
+    #
+    # ==== Example
+    #
+    #   class OrderLine
+    #     include Neo4j::RelationshipMixin
+    #     property :units
+    #     property :unit_price
+    #   end
+    #
+    #   class Order
+    #     property :total_cost
+    #     property :dispatched
+    #     has_n(:products).to(Product).relationship(OrderLine)
+    #   end
+    #
+    #  order = Order.new
+    #  order.products << Product.new
+    #  order.products_rels.first # => OrderLine
+    #
+    def relationship(rel_class)
+      @relationship = rel_class
+      self
+    end
+
+    def relationship_class # :nodoc:
+      @relationship
+    end
+  end
+end

data/lib/neo4j/mapping/has_list.rb

@@ -0,0 +1,134 @@
+module Neo4j
+  module Mapping
+
+    # Enables creating and traversal of nodes in a list.
+    #
+    # It uses the TimeLine http://api.neo4j.org/current/org/neo4j/index/timeline/Timeline.html,
+    #
+    # Includes the Enumerable Mixin.
+    # The Neo4j::Mapping::ClassMethods::List#has_list  methods returns an object of this type.
+    #
+    # === Example, index same as size of list
+    #
+    #  class Person
+    #     include Neo4j::NodeMixin
+    #     has_list :feeds
+    #  end
+    #
+    #  person = Person.new
+    #  person.feeds << Neo4j::Node:new << Neo4j::Node.new
+    #
+    # === Example, using a custom index
+    #
+    #  class Person
+    #     include Neo4j::NodeMixin
+    #     has_list :feeds
+    #  end
+    #
+    #  person = Person.new
+    #  person.feeds[42] = (a = Neo4j::Node:new)
+    #  person.feeds[1251] = Neo4j::Node.new
+    #
+    #  person.feeds[42] # => a
+    #
+    class HasList
+      include Enumerable
+      include ToJava
+
+      def initialize(node, name)
+        @time_line = org.neo4j.index.timeline.Timeline.new(name, node._java_node, true, Neo4j.started_db.graph)
+        @node      = node
+        @name      = name
+        self.size = 0 unless size
+      end
+
+      # returns the size of this list
+      # notice in order to get correct result you must call the #remove method when an item is removed from the list
+      def size
+        @node["_list_size_#{@name}"]
+      end
+
+      # same as #size == 0
+      def empty?
+        size == 0
+      end
+
+      # returns the first node with index n
+      def [](n)
+        @time_line.getAllNodesBetween(n-1, n+1).first
+      end
+
+      # returns all nodes with the given index n
+      def all(n)
+        @time_line.getAllNodesBetween(n-1, n+1)
+      end
+
+      # returns the first node in the list or nil
+      def first
+        @time_line.first_node
+      end
+
+      # returns the last node in the list or nil
+      def last
+        @time_line.last_node
+      end
+
+      # adds a node to the list with the given index n
+      def []=(n, other_node)
+        @time_line.add_node(other_node, n)
+        self.size = self.size + 1
+      end
+
+      # returns all the nodes between the given Range
+      def between(range)
+        @time_line.getAllNodesBetween(range.first-1, range.end+1)
+      end
+
+      # removes one node from the list and decrases the size of the list,
+      def remove(node)
+        @time_line.remove_node(node)
+        self.size = self.size - 1
+      end
+
+      # Required by the Enumerable mixin so that we can
+      #
+      # ==== Example
+      #
+      #  class Person
+      #     include Neo4j::NodeMixin
+      #     has_list :feeds
+      #  end
+      #
+      #  person.feeds.each {|node| node}
+      #
+      def each
+        @time_line.all_nodes.iterator.each { |node|
+          if @raw then
+            yield node
+          else
+            yield node.wrapper
+          end }
+      end
+
+      # If called then it will only return the raw java nodes and not the Ruby wrappers using the Neo4j::NodeMixin
+      def raw
+        @raw = true
+      end
+
+      def <<(other)
+        @time_line.add_node(other, size)
+        self.size = self.size + 1
+        self
+      end
+
+
+      private
+      def size=(size)
+        @node["_list_size_#{@name}"] = size
+      end
+
+
+    end
+
+  end
+end

data/lib/neo4j/mapping/has_n.rb

@@ -0,0 +1,83 @@
+module Neo4j
+  module Mapping
+
+    # Enables creating and traversal of nodes.
+    #
+    # Includes the Enumerable Mixin.
+    # The Neo4j::Mapping::ClassMethods::Relationship#has_n and Neo4j::Mapping::ClassMethods::Relationship#one
+    # methods returns an object of this type.
+    #
+    # ==== See Also
+    # Neo4j::Mapping::ClassMethods::Relationship
+    #
+    class HasN
+      include Enumerable
+      include ToJava
+
+      def initialize(node, dsl) # :nodoc:
+        @node = node
+        @direction = dsl.direction
+        @dsl = dsl
+      end
+
+      def to_s
+        "HasN [#@direction, id: #{@node.neo_id} type: #{@dsl && @dsl.rel_type} dsl:#{@dsl}]"
+      end
+
+      def size
+        [*self].size
+      end
+
+      alias_method :length, :size
+
+      def [](index)
+        each_with_index {|node,i| break node if index == i}
+      end
+
+      # Pretend we are an array - this is neccessarly for Rails actionpack/actionview/formhelper to work with this
+      def is_a?(type)
+        # ActionView requires this for nested attributes to work
+        return true if Array == type
+        super
+      end
+
+      # Required by the Enumerable mixin.
+      def each(&block)
+        @dsl.each_node(@node, @direction, &block)
+      end
+
+
+      # Returns true if there are no node in this type of relationship
+      def empty?
+        first == nil
+      end
+
+
+      # Creates a relationship instance between this and the other node.
+      # Returns the relationship object
+      def new(other)
+        @dsl.create_relationship_to(@node, other)
+      end
+
+
+      # Creates a relationship between this and the other node.
+      #
+      # ==== Example
+      # 
+      #   n1 = Node.new # Node has declared having a friend type of relationship
+      #   n2 = Node.new
+      #   n3 = Node.new
+      #
+      #   n1 << n2 << n3
+      #
+      # ==== Returns
+      # self
+      #
+      def <<(other)
+        @dsl.create_relationship_to(@node, other)
+        self
+      end
+    end
+
+  end
+end

data/lib/neo4j/mapping/node_mixin.rb

@@ -0,0 +1,112 @@
+require "active_support/core_ext/module/delegation"
+
+module Neo4j::Mapping
+
+  # This Mixin is used to wrap Neo4j Java Nodes in Ruby objects.
+  #
+  # It includes a number of mixins and forwards some methods to the raw Java node which in term includes a number of mixins, see below.
+  #
+  # === Instance Methods
+  #
+  # Mixins:
+  # * Neo4j::Index
+  # * Neo4j::Property
+  # * Neo4j::NodeRelationship
+  # * Neo4j::Equal
+  # * Neo4j::Index
+  #
+  # === Class Methods
+  #
+  # Mixins:
+  # * Neo4j::Mapping::ClassMethods::Root
+  # * Neo4j::Mapping::ClassMethods::Property
+  # * Neo4j::Mapping::ClassMethods::InitNode
+  # * Neo4j::Mapping::ClassMethods::Relationship
+  # * Neo4j::Mapping::ClassMethods::Rule
+  # * Neo4j::Mapping::ClassMethods::List
+  # * Neo4j::Index::ClassMethods
+  #
+  module NodeMixin
+    include Neo4j::Index
+
+    delegate :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :rels, :rel?, :to_param, :getId,
+             :rel, :del, :list?, :print, :print_sub, :outgoing, :incoming, :both,
+             :equal?, :eql?, :==, :exist?, :getRelationships, :getSingleRelationship, :_rels, :rel, 
+             :to => :@_java_node, :allow_nil => true 
+
+
+    # --------------------------------------------------------------------------
+    # Initialization methods
+    #
+
+
+    # Init this node with the specified java neo node
+    #
+    def init_on_load(java_node) # :nodoc:
+      @_java_node = java_node
+    end
+
+
+    # Creates a new node and initialize with given properties.
+    # You can override this to provide your own initialization.
+    #
+    def init_on_create(*args) # :nodoc:
+      self[:_classname] = self.class.to_s
+      if args[0].respond_to?(:each_pair)
+        args[0].each_pair { |k, v| respond_to?("#{k}=")? self.send("#{k}=", v) : @_java_node[k] = v }
+      end
+    end
+
+    # Returns the org.neo4j.graphdb.Node wrapped object
+    def _java_node
+      @_java_node
+    end
+
+    def trigger_rules
+      self.class.trigger_rules(self)
+    end
+
+
+    def _decl_rels_for(rel_type)
+      self.class._decl_rels[rel_type]
+    end
+    
+    def wrapper
+      self
+    end
+
+
+    def self.included(c) # :nodoc:
+      c.instance_eval do
+        class << self
+          alias_method :orig_new, :new
+        end
+      end unless c.respond_to?(:orig_new)
+
+      c.class_inheritable_hash :_decl_props
+      c._decl_props ||= {}
+
+      c.class_inheritable_hash :_decl_rels
+      c._decl_rels ||= {}
+
+      c.extend ClassMethods::Property
+      c.extend ClassMethods::InitNode
+      c.extend ClassMethods::Relationship
+      c.extend ClassMethods::Rule
+      c.extend ClassMethods::List
+      c.extend Neo4j::Index::ClassMethods
+
+      def c.inherited(subclass)
+        # inherit the index properties
+        subclass.node_indexer self
+
+        # inherit the rules too
+        subclass.inherit_rules_from self
+
+        super
+      end
+
+      c.node_indexer c
+    end
+  end
+end