neo4j 1.0.0.beta.21-java

data/lib/neo4j/load.rb

@@ -0,0 +1,21 @@
+module Neo4j
+
+  # === Mixin responsible for loading Ruby wrappers for Neo4j Nodes and Relationship.
+  #
+  module Load
+    def wrapper(node) # :nodoc:
+      return node unless node.property?(:_classname)
+      to_class(node[:_classname]).load_wrapper(node)
+    end
+
+    def to_class(class_name) # :nodoc:
+      class_name.split("::").inject(Kernel) {|container, name| container.const_get(name.to_s) }
+    end
+
+    # Checks if the given entity (node/relationship) or entity id (#neo_id) exists in the database.
+    def exist?(node_or_node_id, db = Neo4j.started_db)
+      id = node_or_node_id.kind_of?(Fixnum) ?  node_or_node_id : node_or_node_id.id
+      _load(id, db) != nil
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Neo4j::Mapping
+  module ClassMethods
+    module InitNode
+
+      def load_wrapper(node)
+        wrapped_node = self.orig_new
+        wrapped_node.init_on_load(node)
+        wrapped_node
+      end
+
+
+      # Creates a new node or loads an already existing Neo4j node.
+      #
+      # You can use two callback method to initialize the node
+      # init_on_load:: this method is called when the node is loaded from the database
+      # init_on_create:: called when the node is created, will be provided with the same argument as the new method
+      #
+      #
+      # Does
+      # * sets the neo4j property '_classname' to self.class.to_s
+      # * creates a neo4j node java object (in @_java_node)
+      #
+      # If you want to provide your own initialize method you should instead implement the
+      # method init_on_create method.
+      #
+      # === Example
+      #
+      #   class MyNode
+      #     include Neo4j::NodeMixin
+      #
+      #     def init_on_create(name, age)
+      #        self[:name] = name
+      #        self[:age] = age
+      #     end
+      #   end
+      #
+      #   node = MyNode.new('jimmy', 23)
+      #
+      def new(*args)
+        node = Neo4j::Node.create
+        wrapped_node = super()
+        wrapped_node.init_on_load(node)
+        wrapped_node.init_on_create(*args)
+        wrapped_node
+      end
+
+      alias_method :create, :new
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Neo4j::Mapping
+  module ClassMethods
+    module InitRel
+      def load_wrapper(rel)
+        wrapped_rel = self.orig_new
+        wrapped_rel.init_on_load(rel)
+        wrapped_rel
+      end
+
+
+      # Creates a relationship between given nodes.
+      #
+      # You can use two callback method to initialize the relationship
+      # init_on_load:: this method is called when the relationship is loaded from the database
+      # init_on_create:: called when the relationship is created, will be provided with the same argument as the new method
+      #
+      # ==== Parameters (when creating a new relationship in db)
+      # type:: the key and value to be set
+      # from_node:: create relationship from this node
+      # to_node:: create relationship to this node
+      # props:: optional hash of properties to initialize the create relationship with
+      #
+      def new(*args)
+        type, from_node, to_node, props = args
+        rel = Neo4j::Relationship.create(type, from_node, to_node)
+        wrapped_rel = super()
+        wrapped_rel.init_on_load(rel)
+        wrapped_rel.init_on_create(*args)
+        wrapped_rel
+      end
+
+      alias_method :create, :new
+    end
+  end
+end

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

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

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

@@ -0,0 +1,82 @@
+module Neo4j::Mapping
+  module ClassMethods
+    module Property
+
+      # Generates accessor method and sets configuration for Neo4j node properties.
+      # The generated accessor is a simple wrapper around the #[] and
+      # #[]= operators.
+      #
+      # ==== Types
+      # If a property is set to nil the property will be removed.
+      # A property can be of any primitive type (Boolean, String, Fixnum, Float) and does not
+      # even have to be the same. Arrays of primitive types is also supported. Array values must
+      # be of the same type and are mutable, e.g. you have to create a new array if you want to change one value.
+      #
+      # Example:
+      #   class Foo
+      #     include Neo4j::NodeMixin
+      #     property :age
+      #   end
+      #
+      # Example:
+      #   foo = Foo.new
+      #   foo.age = "hej" # first set it to string
+      #   foo.age = 42  # change it to a Fixnum
+      #
+      # However, you can specify an type for the index, see Neo4j::Index::Indexer#index
+      #
+      # ==== Conversions
+      #
+      # It is possible to do conversions between types in order to support none primitive types
+      # Example:
+      #
+      #   class Foo
+      #     include Neo4j::NodeMixin
+      #     property :since, :type => DateTime  # will be converted into a fixnum
+      #   end
+      #
+      # You can write your own converter and register it in the Neo4j::Config.
+      #
+      def property(*props)
+        if props.size == 2 and props[1].kind_of?(Hash)
+          props[1].each_pair do |key, value|
+            pname = props[0].to_sym
+            _decl_props[pname] ||= {}
+            _decl_props[pname][key] = value
+          end
+          props = props[0..0]
+        end
+
+        props.each do |prop|
+          pname = prop.to_sym
+          _decl_props[pname] ||= {}
+          _decl_props[pname][:defined] = true
+
+          define_method(pname) do
+            Neo4j::TypeConverters.to_ruby(self.class, pname, self[pname])
+          end
+
+          name = (pname.to_s() +"=").to_sym
+          define_method(name) do |value|
+            self[pname] = Neo4j::TypeConverters.to_java(self.class, pname, value)
+          end
+        end
+      end
+
+
+      # Returns true if the given property name has been defined with the class
+      # method property or properties.
+      #
+      # Notice that the node may have properties that has not been declared.
+      # It is always possible to set an undeclared property on a node.
+      #
+      # ==== Returns
+      # true or false
+      #
+      def property?(prop_name)
+        return false if _decl_props[prop_name.to_sym].nil?
+        _decl_props[prop_name.to_sym][:defined] == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+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 = _decl_rels_for('#{rel_type}'.to_sym)
+                    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 = _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 = #{clazz}._decl_rels[:#{rel_type}]
+                  dsl = _decl_rels_for(:#{rel_type})
+                  dsl.single_node(self)
+              end}, __FILE__, __LINE__)
+
+        module_eval(%Q{def #{rel_type}_rel
+                  dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
+#                  dsl = _decl_rels_for(:#{rel_type})
+                  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/rule.rb

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