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

data/lib/neo4j/functions/count.rb

@@ -1,33 +0,0 @@
-module Neo4j
-  module Functions
-    class Count < Function
-      def initialize
-        @property = '_classname'
-      end
-
-      def calculate?(changed_property)
-        true
-      end
-
-      def delete(rule_name, rule_node, old_value)
-        key            = rule_node_property(rule_name)
-        rule_node[key] ||= 0
-        rule_node[key] -= 1
-      end
-
-      def add(rule_name, rule_node, new_value)
-        key            = rule_node_property(rule_name)
-        rule_node[key] ||= 0
-        rule_node[key] += 1
-      end
-
-      def update(*)
-        # we are only counting, not interested in property changes
-      end
-
-      def self.function_name
-        :count
-      end
-    end
-  end
-end

data/lib/neo4j/functions/function.rb

@@ -1,72 +0,0 @@
-module Neo4j
-  module Functions
-
-    # The base class of rule functions.
-    #
-    # You are expected to at least implement two methods:
-    # * update :: update the rule node value of this function
-    # * function_name :: the name of this function, the name of the generated method - A class method !
-    #
-    class Function
-
-      # Initialize the the function with a property which is usually the same as the function identity.
-      # See the #calculate? method how this property is used.
-      #
-      def initialize(property)
-        @property = property.to_s
-      end
-
-      def to_s
-        "Function #{self.class.function_name} function_id: #{function_id}"
-      end
-
-      # Decides if the function should be called are not
-      #
-      def calculate?(changed_property)
-        @property == changed_property
-      end
-
-
-      # The identity of the function.
-      # Used to identify function.
-      #
-      # ==== Example
-      #   Person.sum(:young, :age)
-      #
-      # In the example above the property :age is the used to identify which function will be called
-      # since there could be several sum method. In the example we want use the sum method that uses the :age property.
-      #
-      def function_id
-        @property
-      end
-
-      # The value of the rule
-      def value(rule_node, rule_name)
-        key = rule_node_property(rule_name)
-        rule_node[key] || 0
-      end
-
-      # Called when a node is removed from a rule group
-      # Default is calling update method which is expected to be implemented in a subclass
-      def delete(rule_name, rule_node, old_value)
-        update(rule_name, rule_node, old_value, nil)
-      end
-
-      # Called when a node is added to a rule group
-      # Default is calling update method which is expected to be implemented in a subclass
-      def add(rule_name, rule_node, new_value)
-        update(rule_name, rule_node, nil, new_value)
-      end
-
-      # the name of the property that holds the value of the function
-      def rule_node_property(rule_name)
-        self.class.rule_node_property(self.class.function_name, rule_name, @property)
-      end
-
-      def self.rule_node_property(function_name, rule_name, prop)
-        "_#{function_name}_#{rule_name}_#{prop}"
-      end
-
-    end
-  end
-end

data/lib/neo4j/functions/sum.rb

@@ -1,27 +0,0 @@
-module Neo4j
-  module Functions
-
-    class Sum < Function
-      # Updates the function's value.
-      # Called after the transactions commits and a property has been changed on a node.
-      #
-      # ==== Arguments
-      # * rule_name :: the name of the rule group
-      # * rule_node :: the node which contains the value of this function
-      # * old_value new value :: the changed value of the property (when the transaction commits)
-      def update(rule_name, rule_node, old_value, new_value)
-        key            = rule_node_property(rule_name)
-        rule_node[key] ||= 0
-        old_value      ||= 0
-        new_value      ||= 0
-        rule_node[key] += new_value - old_value
-      end
-
-      def self.function_name
-        :sum
-      end
-    end
-
-
-  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, raw = false, &block) #:nodoc:
-      type = type_to_java(rel_type)
-      dir  = dir_to_java(direction)
-      node._java_node.getRelationships(type, dir).each do |rel|
-        other = raw ? rel.getOtherNode(node) : 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
-          Neo4j.logger.warn "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/rule.rb

@@ -1,158 +0,0 @@
-module Neo4j::Mapping
-
-
-  # Holds all defined rules and trigger them when an event is received.
-  #
-  # See Neo4j::Mapping::ClassMethods::Rule
-  #
-  class Rule #:nodoc:
-
-    attr_reader :rule_name, :filter, :triggers, :functions
-
-    def initialize(rule_name, props, &block)
-      @rule_name = rule_name
-      @triggers  = props[:triggers]
-      @functions = props[:functions]
-      @triggers  = [@triggers] if @triggers && !@triggers.respond_to?(:each)
-      @functions = [@functions] if @functions && !@functions.respond_to?(:each)
-      @filter    = block
-    end
-
-    def to_s
-      "Rule #{rule_name} props=#{props.inspect}"
-    end
-
-    def find_function(function_name, function_id)
-      function_id = function_id.to_s
-      @functions && @functions.find{|f| f.function_id == function_id && f.class.function_name == function_name}
-    end
-
-    # Reconstruct the properties given when created this rule
-    # Needed when inheriting a rule and we want to duplicate a rule
-    def props
-      props = {}
-      props[:triggers] = @triggers if @triggers
-      props[:functions] = @functions if @functions
-      props
-    end
-
-    def functions_for(property)
-      @functions && @functions.find_all { |f| f.calculate?(property) }
-    end
-
-    def execute_filter(node)
-      if @filter.nil?
-        true
-      elsif @filter.arity != 1
-        node.wrapper.instance_eval(&@filter)
-      else
-        @filter.call(node)
-      end
-    end
-
-    # ------------------------------------------------------------------------------------------------------------------
-    # Class Methods
-    # ------------------------------------------------------------------------------------------------------------------
-
-    class << self
-      def add(clazz, rule_name, props, &block)
-        rule_node = rule_node_for(clazz.to_s)
-        rule_node.remove_rule(rule_name) # remove any previously inherited rules
-        rule_node.add_rule(rule_name, props, &block)
-      end
-
-      def rule_names_for(clazz)
-        rule_node = rule_node_for(clazz)
-        rule_node.rules.map { |rule| rule.rule_name }
-      end
-
-      def rule_node_for(clazz)
-        return nil if clazz.nil?
-        @rule_nodes             ||= {}
-        @rule_nodes[clazz.to_s] ||= RuleNode.new(clazz)
-      end
-
-      def inherit(parent_class, subclass)
-        # copy all the rules
-        if rule_node = rule_node_for(parent_class)
-          rule_node.inherit(subclass)
-        end
-      end
-
-      def delete(clazz)
-        if rule_node = rule_node_for(clazz)
-          rule_node.delete_node
-        end
-      end
-
-      def trigger?(node)
-        classname = node[:_classname]
-        @rule_nodes && classname && rule_node_for(classname)
-      end
-
-      def trigger_rules(node, *changes)
-        classname = node[:_classname]
-        return unless classname # there are no rules if there is not a :_classname property
-        rule_node = rule_node_for(classname)
-        rule_node.execute_rules(node, *changes)
-
-        # recursively add relationships for all the parent classes with rules that also pass for this node
-        if (clazz = eval("#{classname}.superclass")) && clazz.include?(Neo4j::NodeMixin)
-          rule_node = rule_node_for(clazz)
-          rule_node && rule_node.execute_rules(node, *changes)
-        end
-      end
-
-
-      # ----------------------------------------------------------------------------------------------------------------
-      # Event handling methods
-      # ----------------------------------------------------------------------------------------------------------------
-
-      def on_relationship_created(rel, *)
-        trigger_start_node = trigger?(rel._start_node)
-        trigger_end_node   = trigger?(rel._end_node)
-        trigger_rules(rel._start_node) if trigger_start_node
-        trigger_rules(rel._end_node) if trigger_end_node
-      end
-
-      def on_property_changed(node, *changes)
-        trigger_rules(node, *changes) if trigger?(node)
-      end
-
-      def on_node_deleted(node, old_properties, data)
-        # have we deleted a rule node ?
-        del_rule_node = @rule_nodes && @rule_nodes.values.find{|rn| rn.rule_node?(node)}
-        del_rule_node && del_rule_node.clear_rule_node
-        return if del_rule_node
-
-        # do we have prop_aggregations for this
-        clazz     = old_properties['_classname']
-        rule_node = rule_node_for(clazz)
-        return if rule_node.nil?
-
-        id = node.getId
-        rule_node.rules.each do |rule|
-          next if rule.functions.nil?
-          rule_name = rule.rule_name.to_s
-
-          # is the rule node deleted ?
-          deleted_rule_node = data.deletedNodes.find{|n| n == rule_node.rule_node}
-          next if deleted_rule_node
-          
-          rule.functions.each do |function|
-            next unless data.deletedRelationships.find do |r|
-              r.getEndNode().getId() == id && r.rel_type == rule_name
-            end
-            previous_value = old_properties[function.function_id]
-            function.delete(rule_name, rule_node.rule_node, previous_value) if previous_value
-          end if rule.functions
-        end
-      end
-
-      def on_neo4j_started(*)
-        @rule_nodes.each_value { |rule_node| rule_node.on_neo4j_started } if @rule_nodes
-      end
-
-    end
-  end
-end