neo4j 1.0.0.beta.20 → 3.0.0.alpha.2

data/lib/neo4j/mapping/has_n.rb

@@ -1,83 +0,0 @@
-module Neo4j
-  module Mapping
-
-    # Enables creating and traversal of nodes.
-    #
-    # Includes the Enumerable Mixin.
-    # The Neo4j::Mapping::ClassMethods::Relationship#has_n and Neo4j::Mapping::ClassMethods::Relationship#one
-    # methods returns an object of this type.
-    #
-    # ==== See Also
-    # Neo4j::Mapping::ClassMethods::Relationship
-    #
-    class HasN
-      include Enumerable
-      include ToJava
-
-      def initialize(node, dsl) # :nodoc:
-        @node = node
-        @direction = dsl.direction
-        @dsl = dsl
-      end
-
-      def to_s
-        "HasN [#@direction, id: #{@node.neo_id} type: #{@dsl.rel_type} dsl:#{@dsl}]"
-      end
-
-      def size
-        [*self].size
-      end
-
-      alias_method :length, :size
-
-      def [](index)
-        each_with_index {|node,i| break node if index == i}
-      end
-
-      # Pretend we are an array - this is neccessarly for Rails actionpack/actionview/formhelper to work with this
-      def is_a?(type)
-        # ActionView requires this for nested attributes to work
-        return true if Array == type
-        super
-      end
-
-      # Required by the Enumerable mixin.
-      def each(&block)
-        @dsl.each_node(@node, @direction, &block)
-      end
-
-
-      # Returns true if there are no node in this type of relationship
-      def empty?
-        first == nil
-      end
-
-
-      # Creates a relationship instance between this and the other node.
-      # Returns the relationship object
-      def new(other)
-        @dsl.create_relationship_to(@node, other)
-      end
-
-
-      # Creates a relationship between this and the other node.
-      #
-      # ==== Example
-      # 
-      #   n1 = Node.new # Node has declared having a friend type of relationship
-      #   n2 = Node.new
-      #   n3 = Node.new
-      #
-      #   n1 << n2 << n3
-      #
-      # ==== Returns
-      # self
-      #
-      def <<(other)
-        @dsl.create_relationship_to(@node, other)
-        self
-      end
-    end
-
-  end
-end

data/lib/neo4j/mapping/node_mixin.rb

@@ -1,97 +0,0 @@
-module Neo4j::Mapping
-
-  # This Mixin is used to wrap Neo4j Java Nodes in Ruby objects.
-  # It includes the Neo4j::Index module and forwards a number of method to the raw Java node which
-  # intern includes a number of mixins, see below.
-  #
-  # === Instance Mixins
-  # * Neo4j::Index
-  # * Neo4j::Property
-  # * Neo4j::NodeRelationship
-  # * Neo4j::Equal
-  # * Neo4j::Index
-  #
-  # === Class Mixins
-  # * Neo4j::Mapping::ClassMethods::Root
-  # * Neo4j::Mapping::ClassMethods::Property
-  # * Neo4j::Mapping::ClassMethods::InitNode
-  # * Neo4j::Mapping::ClassMethods::Relationship
-  # * Neo4j::Mapping::ClassMethods::Rule
-  # * Neo4j::Index::ClassMethods
-  #
-  module NodeMixin
-    extend Forwardable
-    include Neo4j::Index
-
-    def_delegators :@_java_node, :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :rels, :rel?, :to_param, :getId,
-                   :rel, :del, :list?, :print, :print_sub, :outgoing, :incoming, :both,
-                   :equal?, :eql?, :==, :exist?, :getRelationships, :getSingleRelationship, :_rels, :rel
-
-
-    # --------------------------------------------------------------------------
-    # Initialization methods
-    #
-
-
-    # Init this node with the specified java neo node
-    #
-    def init_on_load(java_node) # :nodoc:
-      @_java_node = java_node
-    end
-
-
-    # Creates a new node and initialize with given properties.
-    # You can override this to provide your own initialization.
-    #
-    def init_on_create(*args) # :nodoc:
-      self[:_classname] = self.class.to_s
-      if args[0].respond_to?(:each_pair)
-        args[0].each_pair { |k, v| respond_to?("#{k}=")? self.send("#{k}=", v) : @_java_node[k] = v }
-      end
-    end
-
-    # Returns the org.neo4j.graphdb.Node wrapped object
-    def _java_node
-      @_java_node
-    end
-
-    def trigger_rules
-      self.class.trigger_rules(self)
-    end
-
-
-    def wrapper
-      self
-    end
-
-    def self.included(c) # :nodoc:
-      c.instance_eval do
-        class << self
-          alias_method :orig_new, :new
-        end
-      end unless c.respond_to?(:orig_new)
-
-      c.extend ClassMethods::Root
-      c.extend ClassMethods::Property
-      c.extend ClassMethods::InitNode
-      c.extend ClassMethods::Relationship
-      c.extend ClassMethods::Rule
-      c.extend Neo4j::Index::ClassMethods
-
-      def c.inherited(subclass)
-        subclass.root_class subclass
-
-        # inherit the index properties
-        subclass.node_indexer self
-
-        # inherit the rules too
-        subclass.inherit_rules_from self
-
-        super
-      end
-
-      c.node_indexer c
-      c.root_class c
-    end
-  end
-end

data/lib/neo4j/mapping/relationship_mixin.rb

@@ -1,117 +0,0 @@
-module Neo4j::Mapping
-
-  module RelationshipMixin
-    extend Forwardable
-    include Neo4j::Index
-
-    def_delegators :@_java_rel, :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :to_param, :getId,
-                   :equal?, :eql?, :==, :delete, :getStartNode, :getEndNode, :getOtherNode, :exist?
-
-
-
-    # --------------------------------------------------------------------------
-    # Initialization methods
-    #
-
-
-    # Init this node with the specified java neo4j relationship.
-    #
-    def init_on_load(java_rel) # :nodoc:
-      @_java_rel = java_rel
-    end
-
-
-    # Creates a new node and initialize with given properties.
-    #
-    def init_on_create(*args) # :nodoc:
-      type, from_node, to_node, props = args
-      self[:_classname] = self.class.to_s
-      if props.respond_to?(:each_pair)
-        props.each_pair { |k, v| @_java_rel.set_property(k.to_s, v) }
-      end
-    end
-
-
-    # --------------------------------------------------------------------------
-    # Instance Methods
-    #
-
-    # Returns the org.neo4j.graphdb.Relationship wrapped object
-    def _java_rel
-      @_java_rel
-    end
-
-    # Returns the end node of this relationship
-    def end_node
-      id = getEndNode.getId
-      Neo4j::Node.load(id)
-    end
-
-    # Returns the start node of this relationship
-    def start_node
-      id = getStartNode.getId
-      Neo4j::Node.load(id)
-    end
-
-    # Deletes this relationship
-    def del
-      delete
-    end
-
-    def exist?
-      Neo4j::Relationship.exist?(self)
-    end
-
-    # A convenience operation that, given a node that is attached to this relationship, returns the other node.
-    # For example if node is a start node, the end node will be returned, and vice versa.
-    # This is a very convenient operation when you're manually traversing the node space by invoking one of the #rels operations on node.
-    #
-    # This operation will throw a runtime exception if node is neither this relationship's start node nor its end node.
-    #
-    # ==== Example
-    # For example, to get the node "at the other end" of a relationship, use the following:
-    #   Node endNode = node.rel(:some_rel_type).other_node(node)
-    #
-    def other_node(node)
-      neo_node = node.respond_to?(:_java_node)? node._java_node : node
-      id = getOtherNode(neo_node).getId
-      Neo4j::Node.load(id)
-    end
-
-
-    # Returns the neo relationship type that this relationship is used in.
-    # (see java API org.neo4j.graphdb.Relationship#getType  and org.neo4j.graphdb.RelationshipType)
-    #
-    # ==== Returns
-    # the relationship type (of type Symbol)
-    #
-    def relationship_type
-      get_type.name.to_sym
-    end
-
-    # --------------------------------------------------------------------------
-    # Class Methods
-    #
-
-    class << self
-      def included(c) # :nodoc:
-        c.instance_eval do
-          class << self
-            alias_method :orig_new, :new
-          end
-        end
-        c.extend ClassMethods::Root
-        c.extend ClassMethods::Property
-        c.extend ClassMethods::InitRel
-        c.extend Neo4j::Index::ClassMethods
-
-        def c.inherited(subclass)
-          subclass.rel_indexer subclass
-          super
-        end
-
-        c.rel_indexer c
-      end
-    end
-  end
-end

data/lib/neo4j/model.rb

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

data/lib/neo4j/neo4j.rb

@@ -1,95 +0,0 @@
-# = Neo4j
-#
-# The Neo4j modules is used to interact with an Neo4j Database instance.
-# You can for example start and stop an instance and list all the nodes that exist in the database.
-#
-# === Starting and Stopping Neo4j
-# You don't normally need to start the Neo4j database since it will be automatically started when needed.
-# Before the database is started you should configure where the database is stored, see Neo4j::Config.
-#
-module Neo4j
-
-  class << self
-    
-    # Start Neo4j using the default database.
-    # This is usally not required since the database will be started automatically when it is used.
-    #
-    def start
-      db = default_db
-      db.start unless db.running?
-    end
-
-
-    # sets the default database to use
-    def default_db=(my_db)
-      @db = my_db
-    end
-
-    # Returns default database. Creates a new one if it does not exist, but does not start it.
-    def default_db
-      @db ||= Database.new
-    end
-
-    # Returns a started db instance. Starts it if's not running.
-    def started_db
-      db = default_db
-      db.start unless db.running?
-      db
-    end
-
-
-    # Returns an unstarted db instance
-    #
-    # This is typically used for configuring the database, which must sometimes
-    # be done before the database is started
-    # if the database was already started an exception will be raised
-    def unstarted_db
-      @db ||= Database.new
-      raise "database was already started" if @db.running?
-      @db
-    end
-
-    # returns true if the database is running
-    def running?
-      @db && @db.running?
-    end
-
-
-    # Stops this database
-    # There are Ruby hooks that will do this automatically for you.
-    #
-    def shutdown(this_db = @db)
-      this_db.shutdown if this_db
-    end
-
-    # Returns the reference node, which is a "starting point" in the node space.
-    #
-    # Usually, a client attaches relationships to this node that leads into various parts of the node space.
-    # For more information about common node space organizational patterns, see the design guide at http://wiki.neo4j.org/content/Design_Guide
-    #
-    def ref_node(this_db = self.started_db)
-      this_db.graph.reference_node
-    end
-
-    # Returns an Enumerable object for all nodes in the database
-    def all_nodes(this_db = self.started_db)
-      Enumerator.new(this_db, :each_node)
-    end
-
-    # Same as #all_nodes but does not return wrapped nodes but instead raw java node objects.
-    def _all_nodes(this_db = self.started_db)
-      Enumerator.new(this_db, :_each_node)
-    end
-
-    # Returns the Neo4j::EventHandler
-    #
-    def event_handler(this_db = default_db)
-      this_db.event_handler
-    end
-    
-    # Ruby to Java type converters
-    def converters
-    	Neo4j::Config[:converters] || {}
-    end
-  end
-end

data/lib/neo4j/node.rb

@@ -1,131 +0,0 @@
-module Neo4j
-
-
-
-  org.neo4j.kernel.impl.core.NodeProxy.class_eval do
-    include Neo4j::Property
-    include Neo4j::NodeRelationship
-    include Neo4j::Equal
-    include Neo4j::Index
-
-    # Delete the node and all its relationship
-    def del
-      rels.each {|r| r.del}
-      delete
-    end
-
-    # returns true if the node exists in the database
-    def exist?
-      Neo4j::Node.exist?(self)
-    end
-
-    # same as _java_node
-    # Used so that we have same method for both relationship and nodes
-    def wrapped_entity
-      self
-    end
-    
-    # Loads the Ruby wrapper for this node 
-    # If there is no _classname property for this node then it will simply return itself.
-    # Same as Neo4j::Node.wrapper(node)
-    def wrapper
-      self.class.wrapper(self)
-    end
-
-    def _java_node
-      self
-    end
-
-    def class
-      Neo4j::Node
-    end
-  end
-
-
-  # A node in the graph with properties and relationships to other entities.
-  # Along with relationships, nodes are the core building blocks of the Neo4j data representation model.
-  # Node has three major groups of operations: operations that deal with relationships, operations that deal with properties and operations that traverse the node space.
-  # The property operations give access to the key-value property pairs.
-  # Property keys are always strings. Valid property value types are the primitives(<tt>String</tt>, <tt>Fixnum</tt>, <tt>Float</tt>, <tt>Boolean</tt>), and arrays of those primitives.
-  #
-  # === Instance Methods form Included Mixins
-  # * Neo4j::Property - methods that deal with properties
-  # * Neo4j::NodeRelationship methods for relationship
-  # * Neo4j::Equal equality operators: <tt>eql?</tt>, <tt>equal</tt>, <tt>==</tt>
-  # * Neo4j::Index lucene index methods, like indexing a node
-  #
-  # === Class Methods from Included Mixins
-  # * Neo4j::Index::ClassMethods lucene index class methods, like find
-  # * Neo4j::Load - methods for loading a node
-  #
-  # See also the Neo4j::NodeMixin (Neo4j::Mapping::NodeMixin) if you want to wrap a node with your own Ruby class.
-  #
-  class Node
-    extend Neo4j::Index::ClassMethods
-    extend Neo4j::Load
-
-    self.node_indexer self
-
-    class << self
-
-      # Returns a new neo4j Node.
-      # The return node is actually an Java obejct of type org.neo4j.graphdb.Node java object
-      # which has been extended (see the included mixins for Neo4j::Node).
-      #
-      # The created node will have a unique id - Neo4j::Property#neo_id
-      #
-      # ==== Parameters
-      # *args :: a hash of properties to initialize the node with or nil
-      #
-      # ==== Returns
-      # org.neo4j.graphdb.Node java object
-      #
-      # ==== Examples
-      #
-      #  Neo4j::Transaction.run do
-      #    Neo4j::Node.new
-      #    Neo4j::Node.new :name => 'foo', :age => 100
-      #  end
-      #
-      #
-      def new(*args)
-        # the first argument can be an hash of properties to set
-        props = args[0].respond_to?(:each_pair) && args[0]
-
-        # a db instance can be given, is the first argument if that was not a hash, or otherwise the second
-        db = (!props && args[0]) || args[1] || Neo4j.started_db
-
-        node = db.graph.create_node
-        props.each_pair { |k, v| node[k]= v } if props
-        node
-      end
-
-      # create is the same as new
-      alias_method :create, :new
-
-      # Loads a node or wrapped node given a native java node or an id.
-      # If there is a Ruby wrapper for the node then it will create a Ruby object that will
-      # wrap the java node (see Neo4j::NodeMixin).
-      #
-      # If the node does not exist it will return nil
-      #
-      def load(node_id, db = Neo4j.started_db)
-        node = _load(node_id, db)
-        return nil if node.nil?
-        node.wrapper
-      end
-
-      # Same as load but does not return the node as a wrapped Ruby object.
-      #
-      def _load(node_id, db)
-	return nil if node_id.nil?
-        db.graph.get_node_by_id(node_id.to_i)
-      rescue java.lang.IllegalStateException
-        nil # the node has been deleted
-      rescue org.neo4j.graphdb.NotFoundException
-        nil
-      end
-
-    end
-  end
-end