neo4j 1.0.0.beta.1

data/lib/neo4j.old/extensions/graph_algo.rb

@@ -0,0 +1 @@
+require 'neo4j/extensions/graph_algo/all_simple_paths'

data/lib/neo4j.old/extensions/graph_algo/all_simple_paths.rb

@@ -0,0 +1,133 @@
+module Neo4j::GraphAlgo
+  require 'neo4j/extensions/graph_algo/neo4j-graph-algo-0.3.jar'
+
+                                                   
+  class ListOfAlternatingNodesAndRelationships #:nodoc:
+    include Enumerable
+
+    def initialize(list)
+      @list = list
+    end
+
+    def each
+      iter = @list.iterator
+      node = true
+      while (iter.hasNext)
+        id = iter.next.getId
+        if (node)
+          yield Neo4j.load_node(id)
+        else
+          yield Neo4j.load_rel(id)
+        end
+        node = !node
+      end
+    end
+  end
+
+  class ListOfNodes #:nodoc:
+    include Enumerable
+
+    def initialize(list)
+      @list = list
+    end
+
+    def size
+      @list.size
+    end
+
+    def each
+      iter = @list.iterator
+      while (iter.hasNext)
+        n = iter.next
+        yield Neo4j.load_node(n.getId)
+      end
+    end
+  end
+
+  # A Wrapper for some of the neo4j graphdb algorithms
+  #
+  # Currently only the AllSimplePaths is wrapped in Ruby.
+  #
+  # === Usage
+  #
+  #   found_nodes = GraphAlgo.all_simple_paths.from(node1).both(:knows).to(node7).depth(4).as_nodes
+  #
+  # === See also
+  # * JavaDoc: http://components.neo4j.org/graph-algo/apidocs/org/neo4j/graphalgo/AllSimplePaths.html
+  # * A complete example: http://github.com/andreasronge/neo4j/tree/master/examples/you_might_know/ 
+  #
+  class AllSimplePaths
+    include Enumerable
+
+    def initialize
+      @types = []
+      @direction = org.neo4j.graphdb.Direction::OUTGOING
+    end
+
+    def each
+      if @as_nodes
+        iter = paths.get_paths_as_nodes.iterator
+        while (iter.has_next) do yield ListOfNodes.new(iter.next) end
+      else
+        iter = paths.get_paths.iterator
+        while (iter.has_next) do yield ListOfAlternatingNodesAndRelationships.new(iter.next) end
+      end
+    end
+
+    def as_nodes
+      @as_nodes = true
+      self
+    end
+
+    def size
+      paths.get_paths_as_nodes.size
+    end
+
+    def paths
+      @paths ||= org.neo4j.graphalgo.AllSimplePaths.new(@from._java_node, @to._java_node, @depth, @direction, @types.to_java(:"org.neo4j.graphdb.RelationshipType"))
+    end
+
+    def from(f)
+      @from = f
+      self
+    end
+
+    def to(t)
+      @to = t
+      self
+    end
+
+    def depth(d)
+      @depth = d
+      self
+    end
+
+    def both(*types)
+      types.each { |type| @types << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s) }
+      @direction = org.neo4j.graphdb.Direction::BOTH
+      self
+    end
+
+    def outgoing(*types)
+      types.each { |type| @types << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s) }
+      @direction = org.neo4j.graphdb.Direction::OUTGOING
+      self
+    end
+
+    def incoming(*types)
+      types.each { |type| @types << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s) }
+      @direction = org.neo4j.graphdb.Direction::INCOMING
+      self
+    end
+
+  end
+
+  def self.all_simple_paths
+    # org.neo4j.graphdb.Node node1, org.neo4j.graphdb.Node node2, int maximumTotalDepth, org.neo4j.graphdb.Direction relationshipDirection, org.neo4j.graphdb.RelationshipType... relationshipTypes)
+    AllSimplePaths.new
+  end
+
+
+end
+
+

data/lib/neo4j.old/extensions/reindexer.rb

@@ -0,0 +1,104 @@
+module Neo4j
+
+  module PropertyClassMethods
+      # Traverse all nodes and update the lucene index.
+      # Can be used for example if it's' necessary to change the index on a class
+      #
+      def update_index
+        all.nodes.each do |n|
+          n.update_index
+        end
+      end
+
+      # Returns node instances of this class.
+      #
+      def all
+        index_node = IndexNode.instance
+        index_node.rels.outgoing(self)
+      end
+  end
+  
+  module NodeMixin
+    alias_method :ignore_incoming_cascade_delete_orig?, :ignore_incoming_cascade_delete?
+    def ignore_incoming_cascade_delete? (relationship)
+      # if it's an index node relationship then it should be allowed to cascade delete the node
+      ignore_incoming_cascade_delete_orig?(relationship) || relationship.other_node(self) == IndexNode.instance
+    end
+
+  end
+
+
+  class IndexNode
+    include NodeMixin
+
+    # Connects the given node with the reference node.
+    # The type of the relationship will be the same as the class name of the
+    # specified node unless the optional parameter type is specified.
+    # This method is used internally to keep a reference to all node instances in the node space
+    # (useful for example for reindexing all nodes by traversing the node space).
+    #
+    # ==== Parameters
+    # node<Neo4j::NodeMixin>:: Connect the reference node with this node
+    # type<String>:: Optional, the type of the relationship we want to create
+    #
+    # ==== Returns
+    # nil
+    #
+    # :api: private
+    def connect(node, type = node.class.root_class)
+      rtype = org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
+      @_java_node.createRelationshipTo(node._java_node, rtype)
+      nil
+    end
+
+    def on_node_created(node)
+      # we have to avoid connecting to our self
+      unless self == node
+        node.class.ancestors.grep(Class).each{|p| connect(node, p) if p.respond_to?(:all)}
+      end
+    end
+
+    def self.on_neo_started(neo_instance)
+      if neo_instance.ref_node.rel?(:index_node)
+        # we already have it, put it in instance variable so we do not have to look again
+        @index_node = neo_instance.ref_node.rels.outgoing(:index_node).nodes.first
+      else
+        @index_node = IndexNode.new # cache this so we do not have to look it up always
+        neo_instance.ref_node.rels.outgoing(:index_node) << @index_node
+      end
+      Neo4j.event_handler.add(@index_node)
+    end
+
+    def self.on_neo_stopped(neo_instance)
+      # unregister the instance
+      Neo4j.event_handler.remove(@index_node)
+      @index_node = nil
+    end
+
+    def self.instance
+      Neo4j.start if @index_node.nil?
+      @index_node
+    end
+
+    def self.instance?
+      !@index_node.nil?
+    end
+
+  end
+
+
+  # Add this so it can add it self as listener
+  def self.load_reindexer
+    Neo4j.event_handler.add(IndexNode)
+    # in case we already have started
+    Neo4j::Transaction.run { IndexNode.on_neo_started(Neo4j) } if Neo4j.running?
+  end
+
+  def self.unload_reindexer
+    Neo4j.event_handler.remove(IndexNode)
+    Neo4j.event_handler.remove(IndexNode.instance) if IndexNode.instance?
+  end
+
+
+  load_reindexer
+end

data/lib/neo4j.old/extensions/rest.rb

@@ -0,0 +1,21 @@
+require 'net/http'
+require 'thread'
+require 'json'
+require 'sinatra/base'
+
+require 'neo4j/extensions/rest/rest'
+require 'neo4j/extensions/rest/rest_mixin'
+require 'neo4j/extensions/rest/stubs'
+require 'neo4j/extensions/rest/server'
+
+# Provides Neo4j::NodeMixin::ClassMethods#all
+require 'neo4j/extensions/reindexer'
+
+
+module Neo4j
+  # Make the ReferenceNode available as a REST resource
+  # not possible to do much without that node being exposed ...
+  class ReferenceNode
+    include Neo4j::RestMixin
+  end
+end

data/lib/neo4j.old/extensions/rest/rest.rb

@@ -0,0 +1,336 @@
+module Neo4j
+
+  module Rest #:nodoc: all
+    # contains a list of rest node class resources
+    REST_NODE_CLASSES = {}
+
+    class RestException < StandardError
+      def code;
+        500;
+      end
+    end
+
+    class NotAllowed < RestException
+      def code;
+        403;
+      end
+    end
+
+    class Conflict < RestException
+      def code;
+        409;
+      end
+    end
+
+    def self.base_uri
+      host = Sinatra::Application.host
+      port = Sinatra::Application.port
+      "http://#{host}:#{port}"
+    end
+
+    def self.load_class(clazz)
+      clazz.split("::").inject(Kernel) do |container, name|
+        container.const_get(name.to_s)
+      end
+    rescue NameError
+      raise Sinatra::NotFound
+    end
+
+
+    # Extracts query parameters from a URL; e.g. if <code>/resource?foo=bar</code> was requested,
+    # <code>{'foo' => 'bar'}</code> is returned.
+    def self.query_from_params(params)
+      query = nil
+      unless (params.nil?)
+        query = params.clone
+        query.delete('neo_id')
+        query.delete('class')
+        query.delete('prop')
+        query.delete('rel')
+      end
+      query
+    end
+
+    # -------------------------------------------------------------------------
+    # /neo
+    # -------------------------------------------------------------------------
+
+    Sinatra::Application.post("/neo") do
+      body = request.body.read
+      Object.class_eval body
+      200
+    end
+
+
+    Sinatra::Application.get("/neo") do
+      if request.accept.include?("text/html")
+        html = "<html><body><h2>Neo4j.rb v #{Neo4j::VERSION} is alive !</h2><p/><h3>Defined REST classes</h3>"
+        REST_NODE_CLASSES.keys.each {|clazz| html << "Class '" + clazz + "' <br/>"}
+        html << "</body></html>"
+        html
+      else
+        content_type :json
+        # make it look like it was a node - todo maybe it should be a real Neo4j::Node ...
+        properties = {:classes => REST_NODE_CLASSES.keys, :ref_node => Neo4j.ref_node._uri}
+        {:properties => properties}.to_json
+      end
+    end
+
+
+    # -------------------------------------------------------------------------
+    # /rels/<id>
+    # -------------------------------------------------------------------------
+
+    Sinatra::Application.get("/rels/:id") do
+      content_type :json
+      begin
+        Neo4j::Transaction.run do
+          rel = Neo4j.load_rel(params[:id].to_i)
+          return 404, "Can't find relationship with id #{params[:id]}" if rel.nil?
+          # include hyperlink to end_node if that has an _uri method
+          end_node_hash = {:uri => rel.end_node._uri}
+
+          # include hyperlink to start_node if that has an _uri method
+          start_node_hash = {:uri => rel.start_node._uri}
+
+          {:properties => rel.props, :start_node => start_node_hash, :end_node => end_node_hash}.to_json
+        end
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+
+    # -------------------------------------------------------------------------
+    # /nodes/<classname>
+    # -------------------------------------------------------------------------
+
+    # Allows searching for nodes (provided that they are indexed). Supports the following:
+    # <code>/nodes/classname?search=name:hello~</code>:: Lucene query string
+    # <code>/nodes/classname?name=hello</code>:: Exact match on property
+    # <code>/nodes/classname?sort=name,desc</code>:: Specify sorting order
+    # <code>/nodes/classname?limit=100,20</code>:: Specify offset and number of nodes (for pagination)
+    Sinatra::Application.get("/nodes/:class") do
+      content_type :json
+      clazz = Neo4j::Rest.load_class(params[:class])
+      return 404, "Can't find class '#{classname}'" if clazz.nil?
+
+      begin
+        Neo4j::Transaction.run do
+          resources = clazz.find(Neo4j::Rest.query_from_params(params)) # uses overridden find method -- see below
+          resources.map{|res| res.props}.to_json
+        end
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+    Sinatra::Application.post("/nodes/:class") do
+      content_type :json
+
+      clazz = Neo4j::Rest.load_class(params[:class])
+      return 404, "Can't find class '#{classname}'" if clazz.nil?
+
+      begin
+        uri = Neo4j::Transaction.run do
+          node = clazz.new
+          data = JSON.parse(request.body.read)
+          properties = data['properties']
+          node.update(properties, Neo4j::Rest.query_from_params(params))
+          node._uri
+        end
+        redirect "#{uri}", 201 # created
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+
+    # -------------------------------------------------------------------------
+    # /nodes/<classname>/<id>
+    # -------------------------------------------------------------------------
+
+    Sinatra::Application.get("/nodes/:class/:id") do
+      content_type :json
+
+      begin
+        Neo4j::Transaction.run do
+          node = Neo4j.load_node(params[:id])
+          return 404, "Can't find node with id #{params[:id]}" if node.nil?
+          node.read(Neo4j::Rest.query_from_params(params))
+          relationships = node.rels.outgoing.inject({}) do |hash, v|
+            type = v.relationship_type.to_s
+            hash[type] ||= []
+            hash[type] << "#{Neo4j::Rest.base_uri}/rels/#{v.neo_id}"
+            hash
+          end
+          {:rels => relationships, :properties => node.props}.to_json
+        end
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+    Sinatra::Application.put("/nodes/:class/:id") do
+      content_type :json
+      begin
+        Neo4j::Transaction.run do
+          body = request.body.read
+          data = JSON.parse(body)
+          properties = data['properties'] || {}
+          node = Neo4j.load_node(params[:id])
+          node.update(properties, Neo4j::Rest.query_from_params(params).merge({:strict => true}))
+          node.props.to_json
+        end
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+    Sinatra::Application.delete("/nodes/:class/:id") do
+      content_type :json
+      begin
+        Neo4j::Transaction.run do
+          node = Neo4j.load_node(params[:id])
+          return 404, "Can't find node with id #{params[:id]}" if node.nil?
+          node.del(Neo4j::Rest.query_from_params(params))
+          ""
+        end
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+
+    # -------------------------------------------------------------------------
+    # /nodes/<classname>/<id>/<property>
+    # -------------------------------------------------------------------------
+
+    Sinatra::Application.get("/nodes/:class/:id/traverse") do
+      content_type :json
+      begin
+        Neo4j::Transaction.run do
+          node = Neo4j.load_node(params[:id])
+          return 404, {'error' => "Can't find node with id #{params[:id]}"}.to_json if node.nil?
+
+          relationship = params['relationship']
+          depth = case params['depth']
+            when nil then
+              1
+            when 'all' then
+              :all
+            else
+              params['depth'].to_i
+          end
+          return 400, {'error' => "invalid depth parameter - must be an integer"}.to_json if depth == 0
+
+          uris = node.traverse.outgoing(relationship.to_sym).depth(depth).collect{|node| node._uri}
+          {'uri_list' => uris}.to_json
+        end
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+
+    Sinatra::Application.get("/nodes/:class/:id/:prop") do
+      content_type :json
+
+      begin
+        Neo4j::Transaction.run do
+          node = Neo4j.load_node(params[:id])
+          return 404, "Can't find node with id #{params[:id]}" if node.nil?
+          prop = params[:prop].to_sym
+          # check if prop is a relationship defined by has_n or has_one
+          if node.class.decl_relationships.keys.include?(prop)
+            # instead of returning properties return the relationship properties
+            rels = node.send(prop) || []
+            # is it a has_n or has_one relationship ?
+            # if it is a has_n then return an array of properties of that relationship (can be a large json struct)
+            (rels.respond_to?(:props) ? rels.props : rels.map{|rel| rel.props}).to_json
+          else
+            {prop => node[prop]}.to_json
+          end
+        end
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+
+    Sinatra::Application.put("/nodes/:class/:id/:prop") do
+      content_type :json
+      begin
+        Neo4j::Transaction.run do
+          node = Neo4j.load_node(params[:id])
+          property = params[:prop]
+          body = request.body.read
+          data = JSON.parse(body)
+          value = data[property]
+          return 409, "Can't set property #{property} with JSON data '#{body}'" if value.nil?
+          node[property] = value
+          200
+        end
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+
+    URL_REGEXP = Regexp.new '((http[s]?|ftp):\/)?\/?([^:\/\s]+)((\/\w+)*\/)([\w\-\.]+\/[\w\-\.]+)$' #:nodoc:
+
+    Sinatra::Application.post("/nodes/:class/:id/:rel") do
+      content_type :json
+      begin
+        new_id = Neo4j::Transaction.run do
+          node = Neo4j.load_node(params[:id])
+          return 404, "Can't find node with id #{params[:id]}" if node.nil?
+          rel = params[:rel]
+
+          body = request.body.read
+          data = JSON.parse(body)
+          uri = data['uri']
+          match = URL_REGEXP.match(uri)
+          return 400, "Bad node uri '#{uri}'" if match.nil?
+          to_clazz, to_node_id = match[6].split('/')
+
+          other_node = Neo4j.load_node(to_node_id.to_i)
+          return 400, "Unknown other node with id '#{to_node_id}'" if other_node.nil?
+
+          if to_clazz != other_node.class.to_s
+            return 400, "Wrong type id '#{to_node_id}' expected '#{to_clazz}' got '#{other_node.class.to_s}'"
+          end
+
+          rel_obj = node.add_rel(rel, other_node)
+
+          return 400, "Can't create relationship to #{to_clazz}" if rel_obj.nil?
+
+          rel_obj.neo_id
+        end
+        redirect "/rels/#{new_id}", 201 # created
+      rescue RestException => exception
+        return exception.code, {'error' => $!}.to_json
+      rescue Exception => e
+        return 500, {'error' => $!, 'backtrace' => e.backtrace}.to_json
+      end
+    end
+  end
+
+end