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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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