neo4j 1.0.0.beta.1

data/lib/neo4j.old/mixins/property_class_methods.rb

@@ -0,0 +1,265 @@
+module Neo4j::PropertyClassMethods
+
+  #
+  # 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 #set_property and
+  # #get_property methods.
+  #
+  # If a property is set to nil the property will be removed.
+  #
+  # ==== Configuration
+  # By setting the :type configuration parameter to 'Object' makes
+  # it possible to marshal any ruby object.
+  #
+  # If no type is provided the only the native Neo4j property types are allowed:
+  # * TrueClass, FalseClass
+  # * String
+  # * Fixnum
+  # * Float
+  # * Boolean
+  #
+  # ==== Parameters
+  # props<Array,Hash>:: a variable length arguments or a hash, see example below
+  #
+  # ==== Example
+  #   class Baaz; end
+  #
+  #   class Foo
+  #     include Neo4j::NodeMixin
+  #     property :name, :city # can set several properties in one go
+  #     property :bar, :type => Object # allow serialization of any ruby object
+  #   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 should be marshalled.
+  # All properties that has a type will be marshalled.
+  #
+  # ===== Example
+  #   class Foo
+  #     include Neo4j::NodeMixin
+  #     property :name
+  #     property :since, :type => Date
+  #   end
+  #   Foo.marshal?(:since) => true
+  #   Foo.marshal?(:name) => false
+  #
+  # ==== Returns
+  # true if the property will be marshalled, false otherwise
+  #
+  def marshal?(prop_name)
+    return false if properties_info[prop_name.to_sym].nil?
+    return false if properties_info[prop_name.to_sym][:type].nil?
+    return true
+  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
+
+
+  # Creates a struct class containig all properties of this class.
+  #
+  # ==== Example
+  #
+  # h = Person.value_object.new
+  # h.name    # => nil
+  # h.name='kalle'
+  # h[:name]   # => 'kalle'
+  #
+  # ==== Returns
+  # Struct
+  #
+  def value_object
+    @value_class ||= create_value_class
+  end
+
+  # Index a property or a relationship.
+  # If the rel_prop arg contains a '.' then it will index the relationship.
+  # For example "friends.name" will index each node with property name in the relationship friends.
+  # For example "name" will index the name property of this NodeMixin class.
+  #
+  # ==== Example
+  #   class Person
+  #     include Neo4j::NodeMixin
+  #     property :name
+  #     index :name
+  #   end
+  #
+  def index(*rel_type_props)
+    if rel_type_props.size == 2 and rel_type_props[1].kind_of?(Hash)
+      rel_type_props[1].each_pair do |key, value|
+        idx = rel_type_props[0]
+        indexer.field_infos[idx.to_sym][key] = value
+      end
+      rel_type_props = rel_type_props[0..0]
+    end
+    rel_type_props.each do |rel_type_prop|
+      rel_name, prop = rel_type_prop.to_s.split('.')
+      index_property(rel_name) if prop.nil?
+      index_relationship(rel_name, prop) unless prop.nil?
+    end
+  end
+
+
+  # Remove one or more specified indexes.
+  # Those indexes will not be updated anymore, old indexes will still exist
+  # until the update_index method is called.
+  #
+  def remove_index(*keys)
+    keys.each do |key|
+      raise "Not implemented remove index on a relationship index" if key.to_s.include?('.')
+      indexer.remove_index_on_property(key)
+    end
+  end
+
+
+  def index_property(prop) # :nodoc:
+    indexer.add_index_on_property(prop)
+  end
+
+
+  def index_relationship(rel_name, prop) # :nodoc:
+    # find the trigger and updater classes and the rel_type of the given rel_name
+    trigger_clazz = decl_relationships[rel_name.to_sym].to_class
+    trigger_clazz ||= self # if not defined in a has_n
+
+    updater_clazz = self
+
+    dsl = decl_relationships[rel_name.to_sym]
+    rel_type = dsl.to_type # this or the other node we index ?
+    rel_type ||= rel_name # if not defined (in a has_n) use the same name as the rel_name
+
+    if dsl.outgoing?
+      namespace_type = dsl.namespace_type
+    else
+      clazz = dsl.to_class || node.class
+      namespace_type = clazz.decl_relationships[dsl.to_type].namespace_type
+    end
+
+    # add index on the trigger class and connect it to the updater_clazz
+    # (a trigger may cause an update of the index using the Indexer specified on the updater class)
+    trigger_clazz.indexer.add_index_in_relationship_on_property(updater_clazz, rel_name, rel_type, prop, namespace_type.to_sym)
+  end
+
+
+  # Finds all nodes or relationship of this type (and ancestors of this type) having
+  # the specified property values.
+  # See the lucene module for more information how to do a query.
+  #
+  # ==== Example
+  #   MyNode.find(:name => 'foo', :company => 'bar')
+  #
+  # Or using a DSL query (experimental)
+  #   MyNode.find{(name == 'foo') & (company == 'bar')}
+  #
+  # ==== Returns
+  # Neo4j::SearchResult
+  #
+  def find(query=nil, &block)
+    self.indexer.find(query, block)
+  end
+  
+
+  # Creates a new value object class (a Struct) representing this class.
+  #
+  # The struct will have the Ruby on Rails method: model_name and
+  # new_record? so that it can be used for restful routing.
+  #
+  def create_value_class # :nodoc:
+    # the name of the class we want to create
+    name = "#{self.to_s}ValueObject".gsub("::", '_')
+
+    # remove previous class if exists
+    Neo4j.instance_eval do
+      remove_const name
+    end if Neo4j.const_defined?(name)
+
+    # get the properties we want in the new class
+    props = self.properties_info.keys.map{|k| ":#{k}"}.join(',')
+    Neo4j.module_eval %Q[class #{name} < Struct.new(#{props}); end]
+
+    # get reference to the new class
+    clazz = Neo4j.const_get(name)
+
+    # make it more Ruby on Rails friendly - try adding model_name method
+    if self.respond_to?(:model_name)
+      model = self.model_name.clone
+      (
+      class << clazz;
+        self;
+      end).instance_eval do
+        define_method(:model_name) {model}
+      end
+    end
+
+    # by calling the _update method we change the state of the struct
+    # so that new_record returns false - Ruby on Rails
+    clazz.instance_eval do
+      define_method(:_update) do |hash|
+        @_updated = true
+        hash.each_pair {|key, value| self[key.to_sym] = value if members.include?(key.to_s) }
+      end
+      define_method(:new_record?) { ! defined?(@_updated) }
+    end
+
+    clazz
+  end
+  
+end

data/lib/neo4j.old/mixins/rel_class_methods.rb

@@ -0,0 +1,167 @@
+module Neo4j::RelClassMethods
+
+
+  # Contains information of all relationships, name, type, and multiplicity
+  #
+  # :api: private
+  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 FileNode
+  #      include Ne4j::NodeMixin
+  #      has_one(:folder)
+  #   end
+  #
+  #   file = FileNode.new
+  #   file.folder = Neo4j::Node.new
+  #   file.folder # => the node above
+  #
+  # ==== 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::Relationships::HasN.new(self, dsl)
+                    r.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::Relationships::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::Relationships::HasN.new(self, dsl).rels
+                    [*r][0]
+      end}, __FILE__, __LINE__)
+
+    decl_relationships[rel_type.to_sym] = Neo4j::Relationships::DeclRelationshipDsl.new(rel_type, params)
+  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::Relationships::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::Relationships::HasN.new(self, dsl, &block)
+                end},  __FILE__, __LINE__)
+
+    module_eval(%Q{
+                def #{rel_type}_rels
+                    dsl = #{clazz}.decl_relationships[:'#{rel_type.to_s}']
+                    Neo4j::Relationships::HasN.new(self, dsl).rels
+      end}, __FILE__, __LINE__)
+
+    decl_relationships[rel_type.to_sym] = Neo4j::Relationships::DeclRelationshipDsl.new(rel_type, params)
+  end
+
+
+  # Specifies a relationship to a linked list of nodes.
+  # Each list item class may (but not necessarily  use the belongs_to_list
+  # in order to specify which ruby class should be loaded when a list item is loaded.
+  #
+  # ==== Example
+  #
+  #  class Company
+  #    include Neo4j::NodeMixin
+  #    has_list :employees
+  #  end
+  #
+  #  company = Company.new
+  #  company.employees << employee1 << employee2
+  #
+  #  # prints first employee2 and then employee1
+  #  company.employees.each {|employee| puts employee.name}
+  #
+  # ===== Size Counter
+  # If the optional parameter :size is given then the list will contain a size counter.
+  #
+  # Example
+  #
+  #  class Company
+  #    include Neo4j::NodeMixin
+  #    has_list :employees, :counter => true
+  #  end
+  #
+  #  company = Company.new
+  #  company.employees << employee1 << employee2
+  #  company.employees.size # => 2
+  #
+  # ==== Deleted List Items
+  #
+  # The list will be updated if an item is deleted in a list.
+  # Example:
+  #
+  #  company = Company.new
+  #  company.employees << employee1 << employee2 << employee3
+  #  company.employees.size # => 3
+  #
+  #  employee2.del
+  #
+  #  [*company.employees] # => [employee1, employee3]
+  #  company.employees.size # => 2
+  #
+  # ===== List Items Memberships
+  #
+  #  For deciding which lists a node belongs to see the Neo4j::NodeMixin#list method
+  #
+  # :api: public
+  def has_list(rel_type, params = {})
+    clazz = self
+    #(self.kind_of?(Module))? self : self.class
+    module_eval(%Q{
+                def #{rel_type}(&block)
+                    dsl = #{clazz}.decl_relationships[:'#{rel_type.to_s}']
+                    Neo4j::Relationships::HasList.new(self, dsl, &block)
+                end},  __FILE__, __LINE__)
+    Neo4j.event_handler.add Neo4j::Relationships::HasList
+    decl_relationships[rel_type.to_sym] = Neo4j::Relationships::DeclRelationshipDsl.new(rel_type, params)
+  end
+
+
+  # Can be used together with the has_list to specify the ruby class of a list item.
+  #
+  # :api: public
+  def belongs_to_list(rel_type, params = {})
+    decl_relationships[rel_type] = Neo4j::Relationships::DeclRelationshipDsl.new(rel_type, params)
+  end
+
+  def indexer # :nodoc:
+    Neo4j::Indexer.instance(root_class) # create an indexer that search for nodes (and not relationships)
+  end
+
+end

data/lib/neo4j.old/mixins/relationship_mixin.rb

@@ -0,0 +1,103 @@
+module Neo4j
+
+
+  # A module that can be mixed in like a Neo4j::NodeMixin
+  # It wraps the Neo4j Relationship class.
+  # It includes the Neo4j::PropertyClassMethods class methods.
+  #
+  module RelationshipMixin
+    extend Forwardable
+
+    attr_reader :_java_node
+
+    def_delegators :@_java_node, :[]=, :[], :property?, :props, :update, :neo_id, :del, :start_node, :end_node, :other_node, :relationship_type, :wrapper
+
+    # Initialize the Relationship object with specified java org.neo4j.graphdb.Relationship object
+    # Expects at least one parameter.
+    #
+    # This method is used both when neo4j.rb loads relationships from the database as well as when
+    # a relationship is first created.  If you are only interested in when the relationship is created in the database
+    # see the #init_with_args (which you may want to override and call super on).
+    #
+    # ==== Parameters (when loading from DB)
+    # param1:: the internal java relationship object (org.neo4j.graphdb.Relationship)
+    #
+    # ==== Parameters (when creating a new relationship in db)
+    # type:: the key and value to be set
+    # from_node:: create relationship from this node
+    # to:: create relationship to this node
+    #
+    def initialize(*args)
+      if (args[0].kind_of?(Java::org.neo4j.graphdb.Relationship))
+        init_with_rel(args[0])
+      else
+        init_with_args(*args)
+      end
+
+      # must call super with no arguments so that chaining of initialize method will work
+      super()
+    end
+
+
+    # Initialize this relationship with the given arguments.
+    # This method is only called when the relationship is created in the database
+    # (and not when it is loaded from the database).
+    #
+    # ==== Parameters
+    # type:: the key and value to be set
+    # from_node:: create relationship from this node
+    # to_node:: create relationship to this node
+    def init_with_args(type, from_node, to_node)
+      @_java_node = Neo4j.create_rel(type, from_node, to_node)
+      @_java_node._wrapper = self
+      @_java_node[:_classname] = self.class.to_s
+      Neo4j.event_handler.relationship_created(self)
+      self.class.indexer.on_relationship_created(@_wrapper, type) 
+    end
+
+    # Inits this node with the specified java neo relationship
+    #
+    # :api: private
+    def init_with_rel(rel)
+      @_java_node = rel # TODO hmm, should really name _java_node to something else
+      rel._wrapper=self
+      rel[:_classname] = self.class.to_s unless rel.property?(:_classname)
+    end
+
+
+    def eql?(o)
+      o.kind_of?(RelationshipMixin) && o.internal_r == internal_r
+    end
+
+    def ==(o)
+      eql?(o)
+    end
+
+    def hash
+      _java_node.hashCode
+    end
+
+    # Adds class methods from
+    #
+    # * Neo4j::RelClassMethods
+    # * Neo4j::PropertyClassMethods
+    #
+    def self.included(c) # :nodoc:
+      c.instance_eval do
+        # these constants are used in the Neo4j::RelClassMethods and Neo4j::PropertyClassMethods
+        # they are defined here since they should only be defined once -
+        # all subclasses share the same index, declared properties and index_updaters
+        const_set(:ROOT_CLASS, self)
+        const_set(:PROPERTIES_INFO, {})
+      end unless c.const_defined?(:ROOT_CLASS)
+      c.extend Neo4j::PropertyClassMethods
+      c.extend ClassMethods
+    end
+
+    module ClassMethods
+      def indexer # :nodoc:
+        Neo4j::Indexer.instance(root_class, false) # create an indexer that search for relationships (and not nodes)
+      end
+    end
+  end
+end