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

data/lib/neo4j/mapping/rule_node.rb

@@ -1,176 +0,0 @@
-module Neo4j::Mapping
-
-
-  class RuleNode
-    attr_reader :rules
-
-    def initialize(clazz)
-      @clazz = clazz
-      @rules = []
-    end
-
-    def to_s
-      "RuleNode #{@clazz}, node #{rule_node} #rules: #{@rules.size}"
-    end
-    
-    def node_exist?
-      !Neo4j.ref_node.rel?(@clazz)
-    end
-
-    def create_node
-      Neo4j::Transaction.run do
-        node = Neo4j::Node.new
-        Neo4j.ref_node.outgoing(@clazz) << node
-        node
-      end
-    end
-
-    def inherit(subclass)
-      @rules.each do |rule|
-        subclass.rule rule.rule_name, rule.props, &rule.filter
-      end
-    end
-
-    def delete_node
-      if Neo4j.ref_node.rel?(@clazz)
-        Neo4j.ref_node.outgoing(@clazz).each { |n| n.del }
-      end
-      clear_rule_node
-    end
-
-    def find_node
-      Neo4j.ref_node.rel?(@clazz.to_s) && Neo4j.ref_node._rel(:outgoing, @clazz.to_s)._end_node
-    end
-
-    def on_neo4j_started
-      # initialize the rule node when neo4j starts
-      @rule_node = find_node || create_node
-    end
-
-    def rule_node
-      @rule_node ||= find_node || create_node
-    end
-
-    def rule_node?(node)
-      @rule_node == node
-    end
-
-    def clear_rule_node
-      @rule_node = nil
-    end
-
-    def rule_names
-      @rules.map { |r| r.rule_name }
-    end
-
-    def find_rule(rule_name)
-      @rules.find { |rule| rule.rule_name == rule_name }
-    end
-
-    def add_rule(rule_name, props, &block)
-      @rules << (rule = Rule.new(rule_name, props, &block))
-      rule
-    end
-
-    def remove_rule(rule_name)
-      r = find_rule(rule_name)
-      r && @rules.delete(r)
-    end
-
-    # Return a traversal object with methods for each rule and function.
-    # E.g. Person.all.old or Person.all.sum(:age)
-    def traversal(rule_name)
-      # define method on the traversal
-      traversal = rule_node.outgoing(rule_name)
-      @rules.each do |rule|
-        traversal.filter_method(rule.rule_name) do |path|
-          path.end_node.rel?(rule.rule_name, :incoming)
-        end
-        rule.functions && rule.functions.each do |func|
-          traversal.functions_method(func, self, rule_name)
-        end
-      end
-      traversal
-    end
-
-    def find_function(rule_name, function_name, function_id)
-      rule = find_rule(rule_name)
-      rule.find_function(function_name, function_id)
-    end
-
-    def execute_rules(node, *changes)
-      @rules.each do |rule|
-        execute_rule(rule, node, *changes)
-        execute_other_rules(rule, node)
-      end
-    end
-
-    def execute_other_rules(rule, node)
-      rule.triggers && rule.triggers.each do |rel_type|
-        node.incoming(rel_type).each { |n| n.trigger_rules }
-      end
-    end
-
-    def execute_rule(rule, node, *changes)
-      if rule.execute_filter(node)
-        if connected?(rule.rule_name, node)
-          # it was already connected - the node is in the same rule group but a property has changed
-          execute_update_functions(rule, *changes)
-        else
-          # the node has changed or is in a new rule group
-          connect(rule.rule_name, node)
-          execute_add_functions(rule, *changes)
-        end
-      else
-        if break_connection(rule.rule_name, node)
-          # the node has been removed from a rule group
-          execute_delete_functions(rule, *changes)
-        end
-      end
-    end
-
-    def execute_update_functions(rule, *changes)
-      if functions = find_functions_for_changes(rule, *changes)
-        functions && functions.each { |f| f.update(rule.rule_name, rule_node, changes[1], changes[2]) }
-      end
-    end
-
-    def execute_add_functions(rule, *changes)
-      if functions = find_functions_for_changes(rule, *changes)
-        functions && functions.each { |f| f.add(rule.rule_name, rule_node, changes[2]) }
-      end
-    end
-
-    def execute_delete_functions(rule, *changes)
-      if functions = find_functions_for_changes(rule, *changes)
-        functions.each { |f| f.delete(rule.rule_name, rule_node, changes[1]) }
-      end
-    end
-
-    def find_functions_for_changes(rule, *changes)
-      !changes.empty? && rule.functions_for(changes[0])
-    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?(rule_name, end_node)
-      end_node.incoming(rule_name).find { |n| n == rule_node }
-    end
-
-    def connect(rule_name, end_node)
-      rule_node.outgoing(rule_name) << end_node
-    end
-
-    # sever a direct one-to-one relationship if it exists
-    def break_connection(rule_name, end_node)
-      rel = end_node._rels(:incoming, rule_name).find { |r| r._start_node == rule_node }
-      rel && rel.del
-      !rel.nil?
-    end
-
-  end
-
-
-end
-

data/lib/neo4j/migrations.rb

@@ -1,12 +0,0 @@
-require 'neo4j/migrations/extensions'
-require 'neo4j/migrations/lazy_migration_mixin'
-require 'neo4j/migrations/migration'
-require 'neo4j/migrations/migration_mixin'
-require 'neo4j/migrations/migrations'
-require 'neo4j/migrations/global_migration'
-
-module Neo4j
-  module Migrations
-
-  end
-end

data/lib/neo4j/migrations/global_migration.rb

@@ -1,29 +0,0 @@
-module Neo4j
-
-  # This node stores the migrations for Neo4j.migrations
-  # Uses the Neo4j.ref_node for keeping the current version of the db.
-  # When the database starts it will check if it needs to run a migration.
-  class GlobalMigration
-    extend Neo4j::Migrations
-
-    class << self
-      def migrate!(version=nil)
-        _migrate!(self, Neo4j.ref_node, version)
-      end
-
-      def db_version
-        Neo4j.ref_node[:_db_version] || 0
-      end
-
-      # Remote all migration and set migrate_to = nil and set the current version to nil
-      def reset_migrations!
-        @migrations = nil
-        @migrate_to = nil
-        Neo4j::Transaction.run do
-          Neo4j.ref_node[:_db_version] = nil
-        end
-      end
-    end
-  end
-
-end

data/lib/neo4j/migrations/lazy_migration_mixin.rb

@@ -1,47 +0,0 @@
-module Neo4j
-
-  # Overrides the init_on_load method so that it will check if any migration is needed.
-  # The init_on_create method is also overriden so that it sets the version to the latest migration number
-  # when a new node is created.
-  #
-  # Migration will take place if needed when the node is loaded.
-  #
-  module LazyMigrationMixin
-    extend ActiveSupport::Concern
-
-    included do
-      extend Neo4j::Migrations
-    end
-
-    module ClassMethods
-      # Remote all migration and set migrate_to = nil
-      # Does not change the version of nodes.
-      def reset_migrations!
-        @migrations = nil
-        @migrate_to = nil
-      end
-    end
-
-    def migrate!
-      self.class._migrate!(self._java_node, self)
-    end
-
-    def init_on_create(*)
-      super
-      # set the db version to the current
-      self[:_db_version] = self.class.migrate_to
-    end
-
-    def init_on_load(*) # :nodoc:
-      super
-      migrate!
-      # this if for Neo4j::Rails::Model which keeps the properties in this variable
-      @properties.clear if instance_variable_defined? :@properties
-    end
-
-    def db_version
-      self[:_db_version]
-    end
-  end
-
-end

data/lib/neo4j/migrations/migration_mixin.rb

@@ -1,78 +0,0 @@
-module Neo4j
-
-
-  # By including this mixing on a node class one can add migrations to it.
-  # Each class has a unique db version.
-  #
-  # ==== Example
-  #
-  #  class Person
-  #    include Neo4j::NodeMixin
-  #    include MigrationMixin
-  #    rule :all  # adding the method all to make it possible to find all nodes of this class
-  #  end
-  #
-  #  Person.migration 1, :split_property do
-  #    up do
-  #      all.each_raw do |node|
-  #          node[:given_name] = node[:name].split[0]
-  #          node[:surname]    = node[:name].split[1]
-  #          node[:name]       = nil
-  #        end
-  #    end
-  #
-  #    down do
-  #      all.each_raw do |node|
-  #       node[:name]       = "#{node[:given_name]} #{node[:surname]}"
-  #       node[:surename]   = nil
-  #       node[:given_name] = nil
-  #      end
-  #    end
-  #  end
-  #
-  # Notice that the up and down methods are evaluated in the context of the class (where the all method is defined
-  # if using the rule :all).
-  #
-  module MigrationMixin
-    extend ActiveSupport::Concern
-
-    included do
-      extend Neo4j::Migrations
-    end
-
-    module ClassMethods
-      def migrate!(version=nil)
-        _migrate!(self, migration_meta_node, version)
-      end
-
-      # The node that holds the db version property
-      def migration_meta_node
-        Neo4j::Mapping::Rule.rule_node_for(self).rule_node
-      end
-
-      # Remote all migration and set migrate_to = nil and set the current version to nil
-      def reset_migrations!
-        @migrations = nil
-        @migrate_to = nil
-        Neo4j::Transaction.run do
-          migration_meta_node[:_db_version] = nil
-        end
-      end
-
-      # sets the migration db version for this class on a 'meta' node.
-      def db_version=(version)
-        Neo4j::Transaction.run do
-          migration_meta_node[:_db_version] = version
-        end
-      end
-
-      # returns the current version of the database for this class.
-      def db_version
-        migration_meta_node[:_db_version]
-      end
-    end
-
-  end
-
-
-end

data/lib/neo4j/node_mixin.rb

@@ -1,4 +0,0 @@
-module Neo4j
-  # make an alias so that we don't have to write the long name Neo4j::Mapping::NodeMixin
-  NodeMixin = Neo4j::Mapping::NodeMixin
-end

data/lib/neo4j/node_relationship.rb

@@ -1,161 +0,0 @@
-module Neo4j
-
-
-  module NodeRelationship
-    include ToJava
-
-
-    # A more powerful alternative of #outgoing, #incoming and #both method.
-    # You can use this method for example to only traverse nodes based on properties on the relationships
-    #
-    # ==== Example
-    #
-    #   some_node.expand { |n| n._rels.find_all { |r| r[:age] > 5 } }.depth(:all).to_a
-    #
-    # The above traverse all relationships with a property of age > 5
-    #
-    def expand(&expander)
-      NodeTraverser.new(self).expander(&expander)
-    end
-
-
-    # Returns the outgoing nodes for this node.
-    #
-    # ==== Returns
-    # a Neo4j::NodeTraverser which can be used to further specify which nodes should be included
-    # in traversal by using the <tt>depth</tt>, <tt>filter</tt> and <tt>prune</tt> methods.
-    #
-    # ==== Examples
-    #   # Find all my friends (nodes of depth 1 of type <tt>friends</tt>)
-    #   me.outgoing(:friends).each {|friend| puts friend[:name]}
-    #
-    #   # Find all my friends and their friends (nodes of depth 1 of type <tt>friends</tt>)
-    #   # me.outgoing(:friends).depth(2).each {|friend| puts friend[:name]}
-    #
-    #   # Find all my friends and include my self in the result
-    #   me.outgoing(:friends).depth(4).include_start_node.each {...}
-    #
-    #   # Find all my friends friends friends, etc. at any depth
-    #   me.outgoing(:friends).depth(:all).each {...}
-    #
-    #   # Find all my friends friends but do not include my friends (only depth == 2)
-    #   me.outgoing(:friends).depth(2).filter{|path| path.length == 2}
-    #
-    #   # Find all my friends but 'cut off' some parts of the traversal path
-    #   me.outgoing(:friends).depth(42).prune(|path| an_expression_using_path_returning_true_false }
-    #
-    #   # Find all my friends and work colleges
-    #   me.outgoing(:friends).outgoing(:work).each {...}
-    #
-    # Of course all the methods <tt>outgoing</tt>, <tt>incoming</tt>, <tt>both</tt>, <tt>depth</tt>, <tt>include_start_node</tt>, <tt>filter</tt>, and <tt>prune</tt> can be combined.
-    #
-    def outgoing(type)
-      if type
-        NodeTraverser.new(self).outgoing(type)
-      else
-        raise "Not implemented getting all types of outgoing relationship. Specify a relationship type"
-      end
-    end
-
-
-    # Returns the incoming nodes of given type(s).
-    #
-    # See #outgoing
-    #
-    def incoming(type)
-      if type
-        NodeTraverser.new(self).incoming(type)
-      else
-        raise "Not implemented getting all types of incoming relationship. Specify a relationship type"
-      end
-    end
-
-    # Returns both incoming and outgoing nodes of given types(s)
-    #
-    # If a type is not given then it will return all types of relationships.
-    #
-    # See #outgoing
-    #
-    def both(type=nil)
-      if type
-        NodeTraverser.new(self).both(type)
-      else
-        NodeTraverser.new(self) # default is both
-      end
-    end
-
-
-    # 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)
-      RelationshipTraverser.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