RubyGems - neo4j - Versions diffs - 1.0.0.beta.9 → 1.0.0.beta.10 - Mend

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

Files changed (67) hide show

data/README.rdoc +5 -1971
data/lib/neo4j/mapping/class_methods/relationship.rb +2 -2
data/lib/neo4j/mapping/decl_relationship_dsl.rb +6 -1
data/lib/neo4j/mapping/has_n.rb +17 -1
data/lib/neo4j/node_traverser.rb +14 -1
data/lib/neo4j/rails/model.rb +127 -31
data/lib/neo4j/rails/tx_methods.rb +11 -0
data/lib/neo4j/rails/value.rb +44 -1
data/lib/neo4j/version.rb +1 -1
data/lib/neo4j.rb +1 -0
metadata +4 -59
data/lib/neo4j.old/batch_inserter.rb +0 -144
data/lib/neo4j.old/config.rb +0 -138
data/lib/neo4j.old/event_handler.rb +0 -73
data/lib/neo4j.old/extensions/activemodel.rb +0 -158
data/lib/neo4j.old/extensions/aggregate/aggregate_enum.rb +0 -40
data/lib/neo4j.old/extensions/aggregate/ext/node_mixin.rb +0 -69
data/lib/neo4j.old/extensions/aggregate/node_aggregate.rb +0 -8
data/lib/neo4j.old/extensions/aggregate/node_aggregate_mixin.rb +0 -331
data/lib/neo4j.old/extensions/aggregate/node_aggregator.rb +0 -216
data/lib/neo4j.old/extensions/aggregate/node_group.rb +0 -43
data/lib/neo4j.old/extensions/aggregate/prop_group.rb +0 -30
data/lib/neo4j.old/extensions/aggregate/property_enum.rb +0 -24
data/lib/neo4j.old/extensions/aggregate/props_aggregate.rb +0 -8
data/lib/neo4j.old/extensions/aggregate/props_aggregate_mixin.rb +0 -31
data/lib/neo4j.old/extensions/aggregate/props_aggregator.rb +0 -80
data/lib/neo4j.old/extensions/aggregate.rb +0 -12
data/lib/neo4j.old/extensions/find_path.rb +0 -117
data/lib/neo4j.old/extensions/graph_algo/all_simple_paths.rb +0 -133
data/lib/neo4j.old/extensions/graph_algo/neo4j-graph-algo-0.3.jar +0 -0
data/lib/neo4j.old/extensions/graph_algo.rb +0 -1
data/lib/neo4j.old/extensions/reindexer.rb +0 -104
data/lib/neo4j.old/extensions/rest/rest.rb +0 -336
data/lib/neo4j.old/extensions/rest/rest_mixin.rb +0 -193
data/lib/neo4j.old/extensions/rest/server.rb +0 -50
data/lib/neo4j.old/extensions/rest/stubs.rb +0 -141
data/lib/neo4j.old/extensions/rest.rb +0 -21
data/lib/neo4j.old/extensions/rest_master.rb +0 -34
data/lib/neo4j.old/extensions/rest_slave.rb +0 -31
data/lib/neo4j.old/extensions/tx_tracker.rb +0 -392
data/lib/neo4j.old/indexer.rb +0 -187
data/lib/neo4j.old/jars/geronimo-jta_1.1_spec-1.1.1.jar +0 -0
data/lib/neo4j.old/jars/neo4j-kernel-1.0.jar +0 -0
data/lib/neo4j.old/jars.rb +0 -6
data/lib/neo4j.old/mixins/java_list_mixin.rb +0 -139
data/lib/neo4j.old/mixins/java_node_mixin.rb +0 -205
data/lib/neo4j.old/mixins/java_property_mixin.rb +0 -169
data/lib/neo4j.old/mixins/java_relationship_mixin.rb +0 -60
data/lib/neo4j.old/mixins/migration_mixin.rb +0 -157
data/lib/neo4j.old/mixins/node_mixin.rb +0 -249
data/lib/neo4j.old/mixins/property_class_methods.rb +0 -265
data/lib/neo4j.old/mixins/rel_class_methods.rb +0 -167
data/lib/neo4j.old/mixins/relationship_mixin.rb +0 -103
data/lib/neo4j.old/neo.rb +0 -247
data/lib/neo4j.old/node.rb +0 -49
data/lib/neo4j.old/reference_node.rb +0 -15
data/lib/neo4j.old/relationship.rb +0 -85
data/lib/neo4j.old/relationships/decl_relationship_dsl.rb +0 -164
data/lib/neo4j.old/relationships/has_list.rb +0 -101
data/lib/neo4j.old/relationships/has_n.rb +0 -129
data/lib/neo4j.old/relationships/node_traverser.rb +0 -138
data/lib/neo4j.old/relationships/relationship_dsl.rb +0 -149
data/lib/neo4j.old/relationships/traversal_position.rb +0 -50
data/lib/neo4j.old/relationships/wrappers.rb +0 -51
data/lib/neo4j.old/search_result.rb +0 -72
data/lib/neo4j.old/transaction.rb +0 -254
data/lib/neo4j.old/version.rb +0 -3

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

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

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

@@ -1,193 +0,0 @@
-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 DELETED Viewed

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