neo4j 1.0.0.beta.1

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

@@ -0,0 +1,193 @@
+module Neo4j
+
+  org.neo4j.kernel.impl.core.NodeProxy.class_eval do
+    # See Neo4j::RestMixin#read
+    def read
+    end
+  end
+
+  # Creates a number of resources for the class using this mixin.
+  #
+  # The following resources are created:
+  #
+  # <b>add new class</b>::      <code>POST /neo</code> post ruby code of a neo4j node class
+  # <b>node classes</b>::       <code>GET /neo</code> - returns hyperlinks to /nodes/classname
+  # <b>search nodes</b>::       <code>GET /nodes/classname?name=p</code>
+  # <b>view all nodes</b>::     <code>GET /nodes/classname</code>
+  # <b>update property</b>::    <code>PUT nodes/classname/id/property_name</code>
+  # <b>view property</b>::      <code>GET nodes/classname/id/property_name</code>
+  # <b>delete node</b>::        <code>DELETE nodes/classname/node_id</code>
+  # <b>update properties</b>::  <code>PUT nodes/classname/node_id</code>
+  # <b>view node</b>::          <code>GET /nodes/classname/id</code>
+  # <b>create node</b>::        <code>POST /nodes/classname</code>
+  # <b>view relationship</b>::  <code>GET /rels/id</code>
+  # <b>list rels</b>:: <code>GET /nodes/classname/id/relationship-type</code>
+  # <b>add relationship</b>::   <code>POST /nodes/classname/id/relationship-type</code>
+  # <b>traversal</b>::          <code>GET nodes/classname/id/traverse?relationship=relationship-type&depth=depth</code>
+  #
+  # Also provides lucene queries
+  # <b>Lucene query string</b>::      <code>/nodes/classname?search=name:hello~</code>
+  # <b>Exact match on property</b>::  <code>/nodes/classname?name=hello</code>
+  # <b>Specify sorting order</b>::    <code>/nodes/classname?sort=name,desc</code>
+  # <b>Pagination (offset,num)</b>::  <code>/nodes/classname?limit=100,20</code>#
+  #
+  # When create a new node  by posting to <code>/nodes/classname</code> a 201 will be return with the 'Location' header set to the
+  # URI of the newly created node.
+  #
+  # The JSON representation of a node looks like this
+  #
+  #   {"rels" : {"type1":"http://0.0.0.0:4567/rels/0","type2":"http://0.0.0.0:4567/rels/1"},
+  #    "properties" : {"_neo_id":1,"_classname":"MyNode"}}
+  #
+  module RestMixin
+
+    def _uri
+      "#{Neo4j::Rest.base_uri}#{_uri_rel}"
+    end
+
+    def _uri_rel
+      clazz = self.class.root_class.to_s #.gsub(/::/, '-') TODO urlencoding
+      "/nodes/#{clazz}/#{neo_id}"
+    end
+
+    # Called by the REST API if this node is accessed directly by ID. Any query parameters
+    # in the request are passed in a hash. For example if <code>GET /nodes/MyClass/1?foo=bar</code>
+    # is requested, <code>MyClass#accessed</code> is called with <code>{'foo' => 'bar'}</code>.
+    # By default this method does nothing, but model classes may override it to achieve specific
+    # behaviour.
+    def read(options={})
+    end
+
+    # Called by the REST API if this node is deleted. Any query parameters in the request are passed
+    # in a hash.
+    def del(options={})
+      super()
+    end
+
+
+    def self.included(c)
+      c.extend ClassMethods
+      uri_rel = c._uri_rel
+      # just for debugging and logging purpose so we know which classes uses this mixin, TODO - probablly not needed
+      Neo4j::Rest::REST_NODE_CLASSES[uri_rel] = c
+    end
+
+
+    module ClassMethods
+
+      # todo remove
+      def _uri_rel  # :nodoc:
+        clazz = root_class.to_s #.gsub(/::/, '-') TODO urlencoding
+        "/nodes/#{clazz}"
+      end
+
+
+      # Overrides 'find' so that we can simply pass a query parameters object to it, and
+      # search resources accordingly.
+      def find(query=nil, &block)
+        return super(query, &block) if query.nil? || query.kind_of?(String)
+
+        query = symbolize_keys(query)
+
+        if query[:search]
+          # Use Lucene
+          results = super(query[:search])
+          results = [*apply_lucene_sort(query[:sort], results)] rescue [*super(query[:search])]
+
+        else
+          # Use traverser
+          results = apply_ruby_sort(query[:sort], apply_traverser_conditions(query))
+        end
+
+        apply_limits(query[:limit], results)
+      end
+
+      # :nodoc:
+      def symbolize_keys(hash)
+        # Borrowed from ActiveSupport
+        hash.inject({}) do |options, (key, value)|
+          options[(key.to_sym rescue key) || key] = value
+          options
+        end
+      end
+
+      protected
+
+      # Searches for nodes matching conditions by using a traverser.
+      def apply_traverser_conditions(query)
+        query = query.reject{|key, value| [:sort, :limit, :classname].include? key }
+
+        index_node = Neo4j::IndexNode.instance
+        raise 'Index node is nil. Make sure you have called Neo4j.load_reindexer' if index_node.nil?
+        traverser = index_node.traverse.outgoing(root_class)
+
+        traverser.filter do |position|
+          node = position.current_node
+          position.depth == 1 and
+            query.inject(true) do |meets_condition, (key, value)|
+              meets_condition && (node.send(key) == value)
+            end
+        end
+      end
+
+      # Sorts a list of results according to a string of comma-separated fieldnames (optionally
+      # with 'asc' or 'desc' thrown in). For use in cases where we don't go via Lucene.
+      def apply_ruby_sort(sort_string, results)
+        if sort_string
+          sort_fields = sort_string.to_s.split(/,/)
+          [*results].sort do |x,y|
+            catch(:item_order) do
+              sort_fields.each_index do |index|
+                field = sort_fields[index]
+                unless %w(asc desc).include?(field)
+                  item_order = if sort_fields[index + 1] == 'desc'
+                    (y.send(field) || '') <=> (x.send(field) || '')
+                  else
+                    (x.send(field) || '') <=> (y.send(field) || '')
+                  end
+                  throw :item_order, item_order unless item_order == 0
+                end
+              end
+              0
+            end
+          end
+        else
+          [*results]
+        end
+      end
+
+      # Applies Lucene sort instructions to a Neo4j::SearchResult object.
+      def apply_lucene_sort(sort_string, results)
+        return results if sort_string.nil?
+        last_field = nil
+
+        sort_string.to_s.split(/,/).each do |field|
+          if %w(asc desc).include? field
+            results = results.sort_by(field == 'asc' ? Lucene::Asc[last_field] : Lucene::Desc[last_field])
+            last_field = nil
+          else
+            results = results.sort_by(Lucene::Asc[last_field]) unless last_field.nil?
+            last_field = field
+          end
+        end
+        results.sort_by(Lucene::Asc[last_field]) unless last_field.nil?
+        results
+      end
+
+      # Return only the requested subset of results for pagination
+      # (TODO: can this be done more efficiently within Lucene?)
+      def apply_limits(limit_string, results)
+        if limit_string
+          limit = limit_string.to_s.split(/,/).map{|i| i.to_i}
+          limit.unshift(0) if limit.size == 1
+
+          (limit[0]...(limit[0]+limit[1])).map{|n| results[n] }
+        else
+          results
+        end
+      end
+
+    end
+  end
+
+end

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

@@ -0,0 +1,50 @@
+module Neo4j
+
+  module Rest
+    # todo move inside namepace Rest
+
+    class RestServer #:nodoc:
+      class << self
+        attr_accessor :thread
+
+        def on_neo_started(neo_instance)
+          start
+        end
+
+        def on_neo_stopped(neo_instance)
+          stop
+        end
+
+
+        def start
+          puts "RESTful already started" if @thread
+          return if @thread
+
+          @thread = Thread.new do
+            puts "Start Restful server at port #{Neo4j::Config[:rest_port]}"
+            Sinatra::Application.run! :port => Neo4j::Config[:rest_port]
+          end
+        end
+
+        def stop
+          if @thread
+            # TODO must be a nicer way to do this - to shutdown sinatra
+            @thread.kill
+            @thread = nil
+          end
+        end
+      end
+    end
+
+
+    def self.load_rest #:nodoc:
+      Neo4j::Config.defaults[:rest_port] = 9123
+      Neo4j.event_handler.add(RestServer)
+    end
+
+    load_rest
+
+  end
+
+
+end

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

@@ -0,0 +1,141 @@
+module Neo4j
+  module Rest
+    # A stub class that talk to a neo4j rest server.
+    # It behaves like a Neo4j::Node, but instead of actually performing operation
+    # it talks to the server over HTTP/JSON
+    #
+    module RestStubMixin
+      attr_accessor :json
+
+      def initialize(uri_or_json_hash)
+        if uri_or_json_hash.kind_of?(Hash)
+          @json = uri_or_json_hash
+        else
+          @json = RestHttpMethods.get_request(uri_or_json_hash)
+        end
+      end
+
+      def [](key)
+        @json['properties'][key.to_s]
+      end
+
+      def relationships
+        RelationshipTraverserStub.new(@json['rels'])
+      end
+
+
+      def relationship?(type, dir=:outgoing)
+        rels.rel?(type, dir)
+      end
+
+      def props
+        @json['properties']
+      end
+    end
+
+    module RestHttpMethods # :nodoc:
+      class << self
+        def get_request(resource, args = {})
+          body = _get_request(resource, args)
+          JSON.parse(body)
+        end
+
+        def _get_request(resource, args)
+          _request(resource, :get, args)
+        end
+
+        def _request(resource, method = :get, args = {})
+          url = URI.parse(resource)
+          host = url.host
+          host.sub!(/0\.0\.0\.0/, 'localhost')
+
+          #if args
+          #  url.query = args.map { |k, v| "%s=%s" % [URI.encode(k), URI.encode(v)] }.join("&")
+          #end
+
+          req =
+                  case method
+                    when :put
+                      Net::HTTP::Put.new(url.path)
+                    when :get
+                      Net::HTTP::Get.new(url.path)
+                    when :post
+                      Net::HTTP::Post.new(url.path)
+                  end
+
+          http = Net::HTTP.new(host, url.port)
+          res = http.start() { |conn| conn.request(req) }
+          res.body
+        end
+      end
+    end
+
+
+    class RelationshipStub # :nodoc:
+      include RestStubMixin
+
+      def start_node
+        uri = @json['start_node']['uri']
+        NodeStub.new(uri)
+      end
+
+      def end_node
+        uri = @json['end_node']['uri']
+        NodeStub.new(uri)
+      end
+
+    end
+
+    class RelationshipTraverserStub
+      include Enumerable
+
+      def initialize(json)
+        @json = json
+      end
+
+      def outgoing(rel_type)
+        @rel_type = rel_type
+        self
+      end
+
+      def relationship?(type, dir=:outgoing)
+        !@json[type.to_s].nil?
+      end
+
+      def nodes
+        @return_nodes = true
+        self
+      end
+
+      def first
+        each do |x|
+          return x if !block_given? || yield(x)
+        end
+      end
+
+      def each
+        keys =
+                if @rel_type.nil?
+                  @json.keys # take all keys
+                else
+                  [@rel_type.to_s]
+                end
+
+        keys.each do |rel_type|
+          next unless rel?(rel_type)
+          if @return_nodes
+            @json[rel_type.to_s].each {|uri| yield RelationshipStub.new(uri).end_node}
+          else
+            @json[rel_type.to_s].each {|uri| yield RelationshipStub.new(uri)}
+          end
+        end
+      end
+    end
+
+    # A class that simply includes the RestStubMixin
+    class NodeStub
+      include RestStubMixin
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'neo4j'
+require 'neo4j/extensions/rest'
+require 'neo4j/extensions/tx_tracker'
+
+module Neo4j
+  class TxNode
+    include Neo4j::RestMixin
+  end
+
+  class TxRelationshipCreatedNode
+    include Neo4j::RestMixin
+  end
+
+  class TxNodeCreated
+    include Neo4j::RestMixin
+  end
+
+  class TxNodeList
+    include Neo4j::RestMixin
+  end
+
+  class ReferenceNode
+    include Neo4j::RestMixin
+  end
+
+
+  # FOR TESTING PURPOSE ----
+  
+  class Node
+    include Neo4j::RestMixin # for making it easier to test    
+  end
+
+  Neo4j::Config[:storage_path] = 'tmp/master'
+end

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

@@ -0,0 +1,31 @@
+require 'net/http'
+require 'thread'
+require 'json'
+#require 'sinatra/base'
+require 'neo4j/extensions/rest/stubs'
+
+
+require 'neo4j/extensions/tx_tracker'
+
+module Neo4j
+
+  module Rest #:nodoc: all
+    def self.base_uri
+      Neo4j::Config[:master_neo4j_uri]
+    end
+  end
+  
+
+  # TODO This is not working yet !
+  def self.replicate
+    neo_master = Neo4j::Rest::NodeStub.new(Config[:master_neo4j_uri] + "/neo")
+    neo_ref_node = Neo4j::Rest::NodeStub.new(neo_master[:ref_node])
+    tx_node_list = neo_ref_node.rels.outgoing(:tx_node_list).nodes.first
+    tx_node = tx_node_list.rels.outgoing(:tx_nodes).nodes.first
+    Neo4j::Transaction.run do
+      Neo4j::TxNodeList.instance.redo_tx(tx_node)
+    end
+  end
+
+  Config[:master_neo4j_uri] = 'http://localhost:9123'
+end