neo4j 1.0.0.beta.1

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

@@ -0,0 +1,21 @@
+module Neo4j::Mapping
+  module ClassMethods
+    module Index
+      def index(field, config = {})
+        Neo4j::Node.index(field, config, index_name)
+      end
+
+      def find(field, query, config = {})
+        Neo4j::Node.find(field, query, config, index_name)
+      end
+
+      def rm_index(field, config = {})
+        Neo4j::Node.rm_index(field, config, index_name)
+      end
+
+      def index_name
+        root_class
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+module Neo4j::Mapping
+  module ClassMethods
+    module Property
+
+      #
+      # Access to class constants.
+      # These properties are shared by the class and its siblings.
+      # For example that means that we can specify properties for a parent
+      # class and the child classes will 'inherit' those properties.
+      #
+
+      def root_class # :nodoc:
+        self::ROOT_CLASS
+      end
+
+      def properties_info # :nodoc:
+        self::PROPERTIES_INFO
+      end
+
+
+      # ------------------------------------------------------------------------
+
+
+      # Generates accessor method and sets configuration for Neo4j node properties.
+      # The generated accessor is a simple wrapper around the #[] and
+      # #[]= operators.
+      #
+      # If a property is set to nil the property will be removed.
+      #
+      # ==== Example
+      #   class Baaz; end
+      #
+      #   class Foo
+      #     include Neo4j::NodeMixin
+      #     property :name, :city # can set several properties in one go
+      #     property :bar
+      #   end
+      #
+      #   f = Foo.new
+      #   f.bar = Baaz.new
+      #
+      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
+            properties_info[pname] ||= {}
+            properties_info[pname][key] = value
+          end
+          props = props[0..0]
+        end
+
+        props.each do |prop|
+          pname = prop.to_sym
+          properties_info[pname] ||= {}
+          properties_info[pname][:defined] = true
+
+          define_method(pname) do
+            self[pname]
+          end
+
+          name = (pname.to_s() +"=").to_sym
+          define_method(name) do |value|
+            self[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 properties_info[prop_name.to_sym].nil?
+        properties_info[prop_name.to_sym][:defined] == true
+      end
+
+
+      def load
+        # TODO
+        node = db.graph.get_node_by_id(node_id.to_i)
+        clazz = Neo4j::Node.to_class(node[:_classname])
+        raise "Expected classname #{self} got #{clazz}" if clazz != self
+      end
+
+      def load_wrapper(node, db = Neo4j.started_db)
+        wrapped_node = self.orig_new # avoid creating a new node, only a Ruby Object
+        wrapped_node.init_on_load(node)
+        wrapped_node
+      end
+
+
+      # Creates a new node or loads an already existing Neo4j node.
+      #
+      # Does
+      # * sets the neo4j property '_classname' to self.class.to_s
+      # * creates a neo4j node java object (in @_java_node)
+      # * calls init_node if that is defined in the current class.
+      #
+      # If you want to provide your own initialize method you should instead implement the
+      # method init_node method.
+      #
+      # === Example
+      #
+      #   class MyNode
+      #     include Neo4j::NodeMixin
+      #
+      #     def init_node(name, age)
+      #        self[:name] = name
+      #        self[:age] = age
+      #     end
+      #   end
+      #
+      #   node = MyNode.new('jimmy', 23)
+      #   # notice the following is still possible:
+      #   node = MyNode :name => 'jimmy', :age => 12
+      #
+      # The init_node is only called when the node is created in the database.
+      # The initialize method is used both for to purposes:
+      # loading an already existing node from the Neo4j database and creating a new node in the database.
+      #
+      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/relationship.rb

@@ -0,0 +1,96 @@
+module Neo4j::Mapping
+  module ClassMethods
+
+    module Relationship
+      def decl_relationships
+        # :nodoc:
+        self::DECL_RELATIONSHIPS
+      end
+
+      # Specifies a relationship between two node classes.
+      # Generates assignment and accessor methods for the given relationship.
+      #
+      # ==== 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}(&block)
+                    dsl = #{clazz}.decl_relationships[:'#{rel_type.to_s}']
+                    Neo4j::Mapping::HasN.new(self, dsl, &block)
+                end}, __FILE__, __LINE__)
+
+        module_eval(%Q{
+                def #{rel_type}_rels
+                    dsl = #{clazz}.decl_relationships[:'#{rel_type.to_s}']
+                    Neo4j::Mapping::HasN.new(self, dsl).rels
+      end}, __FILE__, __LINE__)
+
+        decl_relationships[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, 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.
+      #
+      # ==== 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::Relationships::DeclRelationshipDsl
+      #
+      def has_one(rel_type, params = {})
+        clazz = self
+
+
+        module_eval(%Q{def #{rel_type}=(value)
+                    dsl = #{clazz}.decl_relationships[:'#{rel_type.to_s}']
+                    r = Neo4j::Mapping::HasN.new(self, dsl)
+                    r.rels.each {|n| n.del} # delete previous relationships, only one can exist
+                    r << value
+                    r
+                end}, __FILE__, __LINE__)
+
+        module_eval(%Q{def #{rel_type}
+                    dsl = #{clazz}.decl_relationships[:'#{rel_type.to_s}']
+                    r = Neo4j::Mapping::HasN.new(self, dsl)
+                    [*r][0]
+                end}, __FILE__, __LINE__)
+
+        module_eval(%Q{
+                def #{rel_type}_rel
+                    dsl = #{clazz}.decl_relationships[:'#{rel_type.to_s}']
+                    r = Neo4j::Mapping::HasN.new(self, dsl).rels
+                    [*r][0]
+      end}, __FILE__, __LINE__)
+
+        decl_relationships[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, params)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+module Neo4j::Mapping
+  module ClassMethods
+    class Rules
+      class << self
+        def add(clazz, field, &block)
+          clazz = clazz.to_s
+          @rules ||= {}
+          @rules[clazz] ||= {}
+          filter = block.nil? ? Proc.new{|*| true} : block
+          @rules[clazz][field] = filter
+        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(*)
+          create_rules if @rules
+        end
+
+        def create_rules
+          @rules.each_key do |clazz|
+            # check if rule nodes exist, if note create them
+            if !Neo4j.ref_node.rel?(clazz)
+              Neo4j::Transaction.run do
+                node = Neo4j::Node.new
+                Neo4j.ref_node.outgoing(clazz) << node
+                node
+              end
+            end
+          end
+        end
+
+
+        def trigger?(node)
+          @rules && node.property?(:_classname) && @rules.include?(node[:_classname])
+        end
+
+        def rule_for(clazz)
+          Neo4j.ref_node.outgoing(clazz).first
+        end
+
+
+        def on_property_changed(node, key, old_value, new_value)
+          return unless trigger?(node)
+          clazz = node[:_classname]
+          return if @rules[clazz].nil?
+          agg_node = rule_for(node[:_classname])
+          @rules[clazz].each_pair do |field, filter|
+            if filter.call(node)
+              # is this node already included ?
+              if !node.rel?(field)
+                agg_node.outgoing(field) << node
+              end
+            else
+              # remove old ?
+              node.rels(field).incoming.each { |x| x.del }
+            end
+          end
+        end
+      end
+    end
+
+
+    module Aggregate
+
+      # 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, &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
+
+        # define instance methods
+        self.send(:define_method, "#{name}?") do
+          instance_eval &block
+        end
+
+        Rules.add(self, name, &block)
+      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
+    end
+
+    Neo4j.unstarted_db.event_handler.add(Rules)
+  end
+end

data/lib/neo4j/mapping/decl_relationship_dsl.rb

@@ -0,0 +1,151 @@
+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
+
+    attr_reader :to_type, :to_class, :cascade_delete_prop_name, :counter, :rel_id, :direction
+    CASCADE_DELETE_PROP_NAMES = {:outgoing => :_cascade_delete_outgoing, :incoming => :_cascade_delete_incoming}
+
+    def initialize(rel_id, params)
+      @direction = :outgoing
+      @rel_id = rel_id
+      @to_type = rel_id
+      @namespace_type = rel_id
+      @cascade_delete_prop_name = CASCADE_DELETE_PROP_NAMES[params[:cascade_delete]]
+      @counter = params[:counter] == true
+    end
+
+    # If a counter was specified in the dsl for counting number of nodes in this relationship.
+    #
+    def counter?
+      @counter
+    end
+
+    # If cascade delete was specified for this relationship
+    #
+    def cascade_delete?
+      !@cascade_delete_prop_name.nil?
+    end
+
+    def class_and_type_from_args(args) # :nodoc:
+      if (args.size > 1)
+        return args[0], args[1]
+      else
+        return args[0], @rel_id
+      end
+    end
+
+
+    # The actual relationship type that this DSL will use
+    def namespace_type
+      @to_class.nil? ? @to_type.to_s : "#{@to_class.to_s}##{@to_type.to_s}"
+    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
+      @to_class, @to_type = class_and_type_from_args(args)
+      self
+    end
+
+    # Specifies an incoming relationship.
+    # Will use the outgoing relationship given by the from class.
+    #
+    # ==== Example
+    #   class FolderNode
+    #     include Neo4j::NodeMixin
+    #     has_n(:files).to(FileNode)
+    #   end
+    #
+    #  class FileNode
+    #    include Neo4j::NodeMixin
+    #    has_one(:folder).from(FileNode, :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)
+      #(clazz, type)
+      @direction = :incoming
+      @to_class, @to_type = class_and_type_from_args(args)
+      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