neo4j 1.0.0.beta.20 → 3.0.0.alpha.2

data/lib/neo4j/mapping/class_methods/relationship.rb

@@ -1,90 +0,0 @@
-module Neo4j::Mapping
-  module ClassMethods
-
-    module Relationship
-      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::Mapping::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 {...}
-      #
-      # ==== Returns
-      #
-      # Neo4j::Mapping::DeclRelationshipDsl
-      #
-      def has_n(rel_type, params = {})
-        clazz = self
-        module_eval(%Q{
-                def #{rel_type}
-                    dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                    Neo4j::Mapping::HasN.new(self, dsl)
-                end}, __FILE__, __LINE__)
-
-        module_eval(%Q{
-                def #{rel_type}_rels
-                    dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                    dsl.all_relationships(self)
-                end}, __FILE__, __LINE__)
-
-        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, false, clazz, params)
-      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::Mapping::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::Mapping::DeclRelationshipDsl
-      #
-      def has_one(rel_type, params = {})
-        clazz = self
-        module_eval(%Q{def #{rel_type}=(value)
-                  dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                  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 = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                  dsl.single_node(self)
-              end}, __FILE__, __LINE__)
-
-        module_eval(%Q{
-              def #{rel_type}_rel
-                  dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
-                  dsl.single_relationship(self)
-    end}, __FILE__, __LINE__)
-
-        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, true, clazz, params)
-      end
-
-    end
-  end
-end

data/lib/neo4j/mapping/class_methods/root.rb

@@ -1,31 +0,0 @@
-module Neo4j::Mapping
-  module ClassMethods
-    # Used to hold information about which relationships and properties has been declared.
-    module Root
-      #attr_reader :_decl_rels, :_decl_props
-
-      def root_class(clazz)
-        @@_all_decl_rels  ||= {}
-        @@_all_decl_props ||= {}
-        @@_all_decl_rels[clazz] ||= {}
-        @@_all_decl_props[clazz] ||= {}
-        @_decl_rels  = @@_all_decl_rels[clazz]
-        @_decl_props = @@_all_decl_props[clazz]
-      end
-
-
-      # a hash of all relationships which has been declared with a has_n or has_one using Neo4j::Mapping::ClassMethods::Relationship
-      def _decl_rels
-        @@_all_decl_rels[self] ||= {}
-        @_decl_props = @@_all_decl_rels[self]
-      end
-
-      # a hash of all properties which has been declared with <tt>property</tt> using the Neo4j::Mapping::ClassMethods::Property
-      def _decl_props
-        @@_all_decl_props[self] ||= {}
-        @_decl_props = @@_all_decl_props[self]
-      end
-
-    end
-  end
-end

data/lib/neo4j/mapping/class_methods/rule.rb

@@ -1,295 +0,0 @@
-module Neo4j::Mapping
-  module ClassMethods
-    # Holds all defined rules and trigger them when an event is received.
-    #
-    # See Rule
-    # 
-    class Rules
-      class << self
-        def add(clazz, field, props, &block)
-          clazz                   = clazz.to_s
-          @rules                  ||= {}
-          # was there no ruls for this class AND is neo4j running ?
-          if !@rules.include?(clazz) && Neo4j.running?
-            # maybe Neo4j was started first and the rules was added later. Create rule nodes now
-            create_rule_node_for(clazz)
-          end
-          @rules[clazz]           ||= {}
-          filter                  = block.nil? ? Proc.new { |*| true } : block
-          @rules[clazz][field]    = filter
-          @triggers               ||= {}
-          @triggers[clazz]        ||= {}
-          trigger                 = props[:trigger].nil? ? [] : props[:trigger]
-          @triggers[clazz][field] = trigger.respond_to?(:each) ? trigger : [trigger]
-        end
-
-        def inherit(parent_class, subclass)
-          # copy all the rules
-          @rules[parent_class.to_s].each_pair do |field, filter|
-            subclass.rule field, &filter
-          end if @rules[parent_class.to_s]
-        end
-
-        def trigger_other_rules(node)
-          clazz = node[:_classname]
-          @rules[clazz].keys.each do |field|
-            rel_types = @triggers[clazz][field]
-            rel_types.each do |rel_type|
-              node.incoming(rel_type).each { |n| n.trigger_rules }
-            end
-          end
-        end
-
-        def fields_for(clazz)
-          clazz = clazz.to_s
-          return [] if @rules.nil? || @rules[clazz].nil?
-          @rules[clazz].keys
-        end
-
-        def delete(clazz)
-          clazz = clazz.to_s
-          # delete the rule node if found
-          if Neo4j.ref_node.rel?(clazz)
-            Neo4j.ref_node.outgoing(clazz).each { |n| n.del }
-          end
-          @rules.delete(clazz) if @rules
-        end
-
-        def on_neo4j_started(*)
-          @rules.each_key { |clazz| create_rule_node_for(clazz) } if @rules
-        end
-
-        def create_rule_node_for(clazz)
-          if !Neo4j.ref_node.rel?(clazz)
-            Neo4j::Transaction.run do
-              node = Neo4j::Node.new
-              Neo4j.ref_node.outgoing(clazz) << node
-              node
-            end
-          end
-        end
-
-        def trigger?(node)
-          @rules && node.property?(:_classname) && @rules.include?(node[:_classname])
-        end
-
-        def rule_for(clazz)
-          if Neo4j.ref_node.rel?(clazz)
-            Neo4j.ref_node._rel(:outgoing, clazz)._end_node
-          else
-            # this should be called if the rule node gets deleted
-            create_rule_node_for(clazz)
-          end
-        end
-
-
-        def on_relationship_created(rel, *)
-          trigger_start_node = trigger?(rel._start_node)
-          trigger_end_node   = trigger?(rel._end_node)
-          # end or start node must be triggered by this event
-          return unless trigger_start_node || trigger_end_node
-          on_property_changed(trigger_start_node ? rel._start_node : rel._end_node)
-        end
-
-
-        def on_property_changed(node, *)
-          trigger_rules(node) if trigger?(node)
-        end
-
-        def trigger_rules(node)
-          trigger_rules_for_class(node, node[:_classname])
-          trigger_other_rules(node)
-        end
-
-        def trigger_rules_for_class(node, clazz)
-          return if @rules[clazz].nil?
-
-          agg_node = rule_for(clazz)
-          @rules[clazz].each_pair do |field, rule|
-            if run_rule(rule, node)
-              # is this node already included ?
-              unless connected?(field, agg_node, node)
-                agg_node.outgoing(field) << node
-              end
-            else
-              # remove old ?
-              break_connection(field, agg_node, node)
-            end
-          end
-
-          # recursively add relationships for all the parent classes with rules that also pass for this node
-          if clazz = eval("#{clazz}.superclass")
-            trigger_rules_for_class(node, clazz.to_s)
-          end
-        end
-
-        # work out if two nodes are connected by a particular relationship
-        # uses the end_node to start with because it's more likely to have less relationships to go through
-        # (just the number of superclasses it has really)
-        def connected?(relationship, start_node, end_node)
-          end_node.incoming(relationship).each do |n|
-            return true if n == start_node
-          end
-          false
-        end
-
-        # sever a direct one-to-one relationship if it exists
-        def break_connection(relationship, start_node, end_node)
-          end_node.rels(relationship).incoming.each do |r|
-            return r.del if r.start_node == start_node
-          end
-        end
-
-        def run_rule(rule, node)
-          if rule.arity != 1
-            node.wrapper.instance_eval(&rule)
-          else
-            rule.call(node)
-          end
-        end
-      end
-    end
-
-
-    # Allows you to group nodes by providing a rule.
-    #
-    # === Example, finding all nodes of a certain class
-    # Just add a rule without a code block, then all nodes of that class will be grouped under the given key (<tt>all</tt>
-    # for the example below).
-    #
-    #   class Person
-    #     include Neo4j::NodeMixin
-    #     rule :all
-    #   end
-    #
-    # Then you can get all the nodes of type Person (and siblings) by
-    #   Person.all.each {|x| ...}
-    #
-    # === Example, finding all nodes with a given condition on a property
-    #
-    #   class Person
-    #     include Neo4j::NodeMixin
-    #     property :age
-    #     rule(:old) { age > 10 }
-    #   end
-    #
-    #  Now we can find all nodes with a property <tt>age</tt> above 10.
-    #
-    # === Chain Rules
-    #
-    #   class NewsStory
-    #     include Neo4j::NodeMixin
-    #     has_n :readers
-    #     rule(:featured) { |node| node[:featured] == true }
-    #     rule(:young_readers) { !readers.find{|user| !user.young?}}
-    #   end
-    #
-    # You can combine two rules. Let say you want to find all stories which are featured and has young readers:
-    #   NewsStory.featured.young_readers.each {...}
-    #
-    # === Trigger Other Rules
-    # You can let one rule trigger another rule.
-    # Let say you have readers of some magazine and want to know if the magazine has old or young readers.
-    # So when a reader change from young to old you want to trigger all the magazine that he reads (a but stupid example)
-    #
-    # Example
-    #   class Reader
-    #     include Neo4j::NodeMixin
-    #     property :age
-    #     rule(:young, :trigger => :readers) { age < 15 }
-    #   end
-    #
-    #   class NewsStory
-    #     include Neo4j::NodeMixin
-    #     has_n :readers
-    #     rule(:young_readers) { !readers.find{|user| !user.young?}}
-    #   end
-    #
-    # === Performance Considerations
-    # If you have many rules and many updates this can be a bit slow.
-    # In order to speed it up somewhat you can use the raw java node object instead by providing an argument in your block.
-    #
-    # Example:
-    #
-    #   class Person
-    #     include Neo4j::NodeMixin
-    #     property :age
-    #     rule(:old) {|node| node[:age] > 10 }
-    #   end
-    #
-    # === Thread Safe ?
-    # Not sure...
-    #
-    module Rule
-
-      # Creates an rule node attached to the Neo4j.ref_node
-      # Can be used to rule all instances of a specific Ruby class.
-      #
-      # Example of usage:
-      #   class Person
-      #     include Neo4j
-      #     rule :all
-      #     rule :young { self[:age] < 10 }
-      #   end
-      #
-      #   p1 = Person.new :age => 5
-      #   p2 = Person.new :age => 7
-      #   p3 = Person.new :age => 12
-      #   Neo4j::Transaction.finish
-      #   Person.all    # =>  [p1,p2,p3]
-      #   Person.young  # =>  [p1,p2]
-      #   p1.young?    # => true
-      #
-      def rule(name, props = {}, &block)
-        singelton = class << self;
-          self;
-        end
-
-        # define class methods
-        singelton.send(:define_method, name) do
-          agg_node  = Rules.rule_for(self)
-          raise "no rule node for #{name}  on #{self}" if agg_node.nil?
-          traversal = agg_node.outgoing(name) # TODO possible to cache this object
-          Rules.fields_for(self).each do |filter_name|
-            traversal.filter_method(filter_name) do |path|
-              path.end_node.rel?(filter_name, :incoming)
-            end
-          end
-          traversal
-        end unless respond_to?(name)
-
-        # define instance methods
-        self.send(:define_method, "#{name}?") do
-          instance_eval &block
-        end
-
-        Rules.add(self, name, props, &block)
-      end
-
-      def inherit_rules_from(clazz)
-        Rules.inherit(clazz, self)
-      end
-
-      # This is typically used for RSpecs to clean up rule nodes created by the #rule method.
-      # It also remove the given class method.
-      def delete_rules
-        singelton = class << self;
-          self;
-        end
-        Rules.fields_for(self).each do |name|
-          singelton.send(:remove_method, name)
-        end
-        Rules.delete(self)
-      end
-
-      # Force to trigger the rules.
-      # You don't normally need that since it will be done automatically.
-      def trigger_rules(node)
-        Rules.trigger_rules(node)
-      end
-
-    end
-
-    Neo4j.unstarted_db.event_handler.add(Rules)
-  end
-end

data/lib/neo4j/mapping/decl_relationship_dsl.rb

@@ -1,214 +0,0 @@
-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