neo4j 1.0.0.beta.9 → 1.0.0.beta.10

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

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

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

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