neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/has_list/class_methods.rb

@@ -1,11 +0,0 @@
-module Neo4j::HasList
-  module ClassMethods
-      def has_list(name, params = {})
-        module_eval(%Q{
-                def #{name}
-                  Neo4j::HasList::Mapping.new(self.class, self, '#{name}')
-                end}, __FILE__, __LINE__)
-      end
-  end
-end
-

data/lib/neo4j/has_list/has_list.rb

@@ -1,3 +0,0 @@
-require 'neo4j/has_list/class_methods'
-require 'neo4j/has_list/mapping'
-

data/lib/neo4j/has_list/mapping.rb

@@ -1,133 +0,0 @@
-module Neo4j
-  module HasList
-
-    # 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 Mapping
-      include Enumerable
-      include ToJava
-
-
-      def initialize(indexer_for, node, name)
-        @index = Neo4j.started_db.lucene.for_nodes("#{indexer_for.to_s.gsub('::', '_')}_#{name}-timeline", Neo4j::Config[:lucene][:exact])
-        @time_line = org.neo4j.index.lucene.LuceneTimeline.new(Neo4j.started_db.graph, @index)
-        @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.getBetween(n, n).first
-      end
-
-      # returns all nodes with the given index n
-      def all(n)
-        @time_line.getBetween(n, n)
-      end
-
-      # returns the first node in the list or nil
-      def first
-        @time_line.getFirst()
-      end
-
-      # returns the last node in the list or nil
-      def last
-        @time_line.getLast
-      end
-
-      # adds a node to the list with the given index n
-      def []=(n, other_node)
-        @time_line.add(other_node, n)
-        self.size = self.size + 1
-      end
-
-      # returns all the nodes between the given Range
-      def between(range)
-        @time_line.getBetween(range.first, range.end)
-      end
-
-      # removes one node from the list and decrases the size of the list,
-      def remove(node)
-        @index.remove(node, "timestamp")
-        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.getBetween(java.lang.Long::MIN_VALUE,java.lang.Long::MAX_VALUE).iterator.each do |node|
-          if @raw then
-            yield node
-          else
-            yield node.wrapper
-          end
-        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(other._java_node, size)
-        self.size = self.size + 1
-        self
-      end
-
-      private
-      def size=(size)
-        @node["_list_size_#{@name}"] = size
-      end
-    end
-  end
-end

data/lib/neo4j/has_n/class_methods.rb

@@ -1,119 +0,0 @@
-module Neo4j
-  module HasN
-    module ClassMethods
-      include Neo4j::ToJava
-
-      # Specifies a relationship between two node classes.
-      # Generates assignment and accessor methods for the given relationship.
-      # Both incoming and outgoing relationships can be declared, see Neo4j::HasN::DeclRelationshipDsl
-      #
-      # ==== Example
-      #
-      #   class FolderNode
-      #      include Ne4j::NodeMixin
-      #      has_n(:files)
-      #   end
-      #
-      #   folder = FolderNode.new
-      #   folder.files << Neo4j::Node.new << Neo4j::Node.new
-      #   folder.files.inject {...}
-      #
-      #   FolderNode.files #=> 'files' the name of the relationship
-      #
-      # ==== Example has_n(x).to(...)
-      #
-      # You can declare which class it has relationship to.
-      # The generated relationships will be prefixed with the name of that class.
-      #
-      #   class FolderNode
-      #      include Ne4j::NodeMixin
-      #      has_n(:files).to(File)
-      #   end
-      #
-      #   FolderNode.files #=> 'File#files' the name of the relationship
-      #
-      # ==== Example has_n(x).from(class, has_n_name)
-      #
-      # Neo4j.rb can also generate accessor method for traversing and adding relationship on incoming nodes.
-      #
-      #   class FileNode
-      #      include Ne4j::NodeMixin
-      #      has_one(:folder).from(FolderNode, :files)
-      #   end
-      #
-      #
-      # ==== Returns
-      #
-      # * This method returns Neo4j::HasN::DeclRelationshipDsl
-      # * The generated has_n method returns a Neo4j::HasN::Mapping object
-      #
-      def has_n(rel_type)
-        clazz = self
-        module_eval(%Q{
-                def #{rel_type}
-                    dsl = _decl_rels_for('#{rel_type}'.to_sym)
-                    Neo4j::HasN::Mapping.new(self, dsl)
-                end}, __FILE__, __LINE__)
-
-        
-        module_eval(%Q{
-                def #{rel_type}_rels
-                    dsl = _decl_rels_for('#{rel_type}'.to_sym)
-                    dsl.all_relationships(self)
-                end}, __FILE__, __LINE__)
-
-        instance_eval(%Q{
-          def #{rel_type}
-            _decl_rels[:#{rel_type}].rel_type.to_s
-          end}, __FILE__, __LINE__)
-
-        _decl_rels[rel_type.to_sym] = DeclRelationshipDsl.new(rel_type, false, clazz)
-      end
-
-
-      # Specifies a relationship between two node classes.
-      # Generates assignment and accessor methods for the given relationship
-      # Old relationship is deleted when a new relationship is assigned.
-      # Both incoming and outgoing relationships can be declared, see Neo4j::HasN::DeclRelationshipDsl
-      #
-      # ==== Example
-      #
-      #   class FileNode
-      #      include Ne4j::NodeMixin
-      #      has_one(:folder)
-      #   end
-      #
-      #   file = FileNode.new
-      #   file.folder = Neo4j::Node.new
-      #   file.folder # => the node above
-      #   file.folder_rel # => the relationship object between those nodes
-      #
-      # ==== Returns
-      #
-      # Neo4j::HasN::DeclRelationshipDsl
-      #
-      def has_one(rel_type)
-        clazz = self
-        module_eval(%Q{def #{rel_type}=(value)
-                  dsl = _decl_rels_for(:#{rel_type})
-                  rel = dsl.single_relationship(self)
-                  rel.del unless rel.nil?
-                  dsl.create_relationship_to(self, value) if value
-              end}, __FILE__, __LINE__)
-
-        module_eval(%Q{def #{rel_type}
-                  dsl = _decl_rels_for(:#{rel_type})
-                  dsl.single_node(self)
-              end}, __FILE__, __LINE__)
-
-        module_eval(%Q{def #{rel_type}_rel
-                  dsl = _decl_rels_for(:#{rel_type})
-                  dsl.single_relationship(self)
-               end}, __FILE__, __LINE__)
-
-        _decl_rels[rel_type.to_sym] = DeclRelationshipDsl.new(rel_type, true, clazz)
-      end
-
-    end
-  end
-end

data/lib/neo4j/has_n/decl_relationship_dsl.rb

@@ -1,246 +0,0 @@
-module Neo4j
-  module HasN
-
-
-    # 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::HasN::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, :source_class, :dir, :rel_type
-
-      def initialize(method_id, has_one, target_class)
-        @dir = :outgoing
-        @method_id = method_id
-        @has_one = has_one
-        @rel_type = method_id
-        @target_class = target_class
-        @source_class = target_class
-      end
-
-      def to_s
-        "DeclRelationshipDsl #{object_id} dir: #{@dir} rel_id: #{@method_id}, rel_type: #{@rel_type}, target_class:#{@target_class} rel_class:#{@relationship}"
-      end
-
-      def has_one?
-        @has_one
-      end
-
-      def has_n?
-        !@has_one
-      end
-
-      def java_rel_type
-        type_to_java(@rel_type)
-      end
-
-      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)
-        end
-      end
-
-      def _each_node(node, &block) #:nodoc:
-        node._java_node.getRelationships(java_rel_type, java_dir).each do |rel|
-          block.call rel.getOtherNode(node)
-        end
-      end
-
-      def incoming? #:nodoc:
-        @dir == :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(dir, rel_type)
-      end
-
-      def _all_relationships(node) #:nodoc:
-        node._java_node.getRelationships(java_rel_type, java_dir)
-      end
-
-      def all_relationships(node) #:nodoc:
-        Neo4j::Rels::Traverser.new(node._java_node, [rel_type], dir)
-      end
-
-      def create_relationship_to(node, other) # :nodoc:
-        from, to = incoming? ? [other, node] : [node, other]
-
-        if relationship_class
-          relationship_class.new(@rel_type, from._java_node, to._java_node)
-        else
-          from._java_node.create_relationship_to(to._java_node, java_rel_type)
-        end
-      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
-      #
-      # ==== Example, without prefix
-      #
-      #   class FolderNode
-      #     include Neo4j::NodeMixin
-      #     has_n(:files).to(:contains)
-      #   end
-      #
-      #   file = FileNode.new
-      #   # create an outgoing relationship of type 'contains' from folder node to file
-      #   folder.files << FolderNode.new
-      #
-      def to(target)
-        @dir = :outgoing
-
-        if (Class === target)
-          # handle e.g. has_n(:friends).to(class)
-          @target_class = target
-          @rel_type = "#{@source_class}##{@method_id}"
-        elsif (Symbol === target)
-          # handle e.g. has_n(:friends).to(:knows)
-          @rel_type = target.to_s
-        else
-          raise "Expected a class or a symbol for, got #{target}/#{target.class}"
-        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(FolderNode, :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 'files' from folder node to file
-      #   file.folder = FolderNode.new
-      #
-      #
-      def from(*args)
-        @dir = :incoming
-
-        if (args.size > 1)
-          # handle specified (prefixed) relationship, e.g. has_n(:known_by).from(clazz, :type)
-          @target_class = args[0]
-          @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]
-        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:
-        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
-end