related 0.1

data/CHANGELOG

@@ -0,0 +1,4 @@
+
+*0.1*
+
+* First public release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010, 2011 Niklas Holmgren, Sutajio
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,92 @@
+Related
+=======
+
+Related is a Redis-backed high performance graph database.
+
+Setup
+-----
+
+Assuming you already have Redis installed:
+
+    $ gem install related
+
+Or add the gem to your Gemfile.
+
+    require 'related'
+    Related.redis = 'redis://.../'
+
+If you are using Rails, add the above to an initializer. If Redis is running
+on localhost and on the default port the second line is not needed.
+
+Example usage
+-------------
+
+    node = Related::Node.create(:name => 'Example', :popularity => 2.3)
+    node.new_record?
+    node.popularity = 100
+    node.save
+    node = Related::Node.find(node.id)
+    node.destroy
+
+    node1 = Related::Node.create
+    node2 = Related::Node.create
+    rel = Related::Relationship.create(:friends, node1, node2, :have_met => true)
+
+    n = Related::Node.find(node1.id)
+    nn = Related::Node.find(node1.id, node2.id)
+
+    n = Related::Node.find(node1.id, :fields => [:name])
+    nn = Related::Node.find(node1.id, node2.id, :fields => [:name])
+
+Nodes and relationships are both sub-classes of the same base class and both
+behave similar to an ActiveRecord object and can store attributes etc.
+
+To query the graph:
+
+    node.outgoing(:friends)
+    node.incoming(:friends)
+    node.outgoing(:friends).relationships
+    node.outgoing(:friends).nodes
+    node.outgoing(:friends).limit(5)
+    node1.path_to(node2).outgoing(:friends).depth(3)
+    node1.shortest_path_to(node2).outgoing(:friends).depth(3)
+
+To get the results from a query:
+
+    node.outgoing(:friends).to_a
+    node.outgoing(:friends).count (or .size, which is memoized)
+
+You can also do set operations, like union, diff and intersect (not implemented yet):
+
+    node1.outgoing(:friends).union(node2.outgoing(:friends))
+    node1.outgoing(:friends).diff(node2.outgoing(:friends))
+    node1.outgoing(:friends).intersect(node2.outgoing(:friends))
+
+Development
+-----------
+
+If you want to make your own changes to Related, first clone the repo and
+run the tests:
+
+    git clone git://github.com/sutajio/related.git
+    cd related
+    rake test
+
+Remember to install the Redis server on your local machine.
+
+Contributing
+------------
+
+Once you've made your great commits:
+
+1. Fork Related
+2. Create a topic branch - git checkout -b my_branch
+3. Push to your branch - git push origin my_branch
+4. Create a Pull Request from your branch
+5. That's it!
+
+Author
+------
+
+Related was created by Niklas Holmgren (niklas@sutajio.se) and released under
+the MIT license.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+
+$LOAD_PATH.unshift 'lib'
+
+task :default => [:test]
+
+task :test do
+  Dir.glob('test/**/*_test.rb').each do |file|
+    require File.expand_path(file)
+  end
+end

data/lib/related/entity.rb

@@ -0,0 +1,126 @@
+module Related
+  class Entity
+
+      attr_reader :id
+      attr_reader :attributes
+      attr_reader :destroyed
+
+      def initialize(*attributes)
+        if attributes.first.is_a?(String)
+          @id = attributes.first
+          @attributes = attributes.last
+        else
+          @attributes = attributes.first
+        end
+      end
+
+      def to_s
+        self.id
+      end
+
+      def method_missing(sym, *args, &block)
+        @attributes[sym] || @attributes[sym.to_s]
+      end
+
+      def ==(other)
+        @id == other.id
+      end
+
+      def new_record?
+        @id.nil? ? true : false
+      end
+
+      def save
+        create_or_update
+      end
+
+      def destroy
+        delete
+      end
+
+      def self.create(attributes = {})
+        self.new(attributes).save
+      end
+
+      def self.find(*args)
+        options = args.size > 1 && args.last.is_a?(Hash) ? args.pop : {}
+        args.size == 1 && args.first.is_a?(String) ?
+          find_one(args.first, options) :
+          find_many(args.flatten, options)
+      end
+
+    private
+
+      def create_or_update
+        new_record? ? create : update
+      end
+
+      def create
+        @id = Related.generate_id
+        @attributes.merge!(:created_at => Time.now.utc)
+        Related.redis.hmset(@id, *@attributes.to_a.flatten)
+        self
+      end
+
+      def update
+        @attributes.merge!(:updated_at => Time.now.utc)
+        Related.redis.hmset(@id, *@attributes.to_a.flatten)
+        self
+      end
+
+      def delete
+        Related.redis.del(id)
+        @destroyed = true
+        self
+      end
+
+      def self.find_fields(id, fields)
+        res = Related.redis.hmget(id.to_s, *fields)
+        if res
+          attributes = {}
+          res.each_with_index do |value, i|
+            attributes[fields[i]] = value
+          end
+          attributes
+        end
+      end
+
+      def self.find_one(id, options = {})
+        attributes = options[:fields] ?
+          find_fields(id, options[:fields]) :
+          Related.redis.hgetall(id.to_s)
+        if attributes.empty?
+          if Related.redis.exists(id) == false
+            raise Related::NotFound, id
+          end
+        end
+        self.new(id, attributes)
+      end
+
+      def self.find_many(ids, options = {})
+        res = Related.redis.pipelined do
+          ids.each {|id|
+            if options[:fields]
+              Related.redis.hmget(id.to_s, *options[:fields])
+            else
+              Related.redis.hgetall(id.to_s)
+            end
+          }
+        end
+        objects = []
+        ids.each_with_index do |id,i|
+          if options[:fields]
+            attributes = {}
+            res[i].each_with_index do |value, i|
+              attributes[options[:fields][i]] = value
+            end
+            objects << self.new(id, attributes)
+          else
+            objects << self.new(id, Hash[*res[i]])
+          end
+        end
+        objects
+      end
+
+  end
+end

data/lib/related/exceptions.rb

@@ -0,0 +1,4 @@
+module Related
+  class RelatedException < RuntimeError; end
+  class NotFound < RelatedException; end
+end

data/lib/related/helpers.rb

@@ -0,0 +1,15 @@
+require 'base64'
+require 'digest/sha2'
+
+module Related
+  module Helpers
+
+    # Generate a unique id
+    def generate_id
+      Base64.encode64(
+        Digest::SHA256.digest("#{Time.now}-#{rand}")
+      ).gsub('/','x').gsub('+','y').gsub('=','').strip[0..21]
+    end
+
+  end
+end

data/lib/related/node.rb

@@ -0,0 +1,174 @@
+module Related
+  class Node < Entity
+    module QueryMethods
+      def relationships
+        query = self.query
+        query.entity_type = :relationships
+        query
+      end
+
+      def nodes
+        query = self.query
+        query.entity_type = :nodes
+        query
+      end
+
+      def outgoing(type)
+        query = self.query
+        query.relationship_type = type
+        query.direction = :out
+        query
+      end
+
+      def incoming(type)
+        query = self.query
+        query.relationship_type = type
+        query.direction = :in
+        query
+      end
+
+      def limit(count)
+        query = self.query
+        query.limit = count
+        query
+      end
+
+      def depth(depth)
+        query = self.query
+        query.depth = depth
+        query
+      end
+
+      def include_start_node
+        query = self.query
+        query.include_start_node = true
+        query
+      end
+
+      def path_to(node)
+        query = self.query
+        query.destination = node
+        query.search_algorithm = :depth_first
+        query
+      end
+
+      def shortest_path_to(node)
+        query = self.query
+        query.destination = node
+        query.search_algorithm = :dijkstra
+        query
+      end
+    end
+
+    include QueryMethods
+
+    class Query
+      include QueryMethods
+
+      attr_writer :entity_type
+      attr_writer :relationship_type
+      attr_writer :direction
+      attr_writer :limit
+      attr_writer :depth
+      attr_writer :include_start_node
+      attr_writer :destination
+      attr_writer :search_algorithm
+
+      def initialize(node)
+        @node = node
+        @entity_type = :nodes
+        @depth = 4
+      end
+
+      def each(&block)
+        self.to_a.each(&block)
+      end
+
+      def map(&block)
+        self.to_a.map(&block)
+      end
+
+      def to_a
+        res = []
+        if @destination
+          res = self.send(@search_algorithm, [@node.id])
+          res.shift unless @include_start_node
+          return Related::Node.find(res)
+        else
+          if @limit
+            res = (1..@limit.to_i).map { Related.redis.srandmember(key) }
+          else
+            res = Related.redis.smembers(key)
+          end
+        end
+        res = Relationship.find(res)
+        if @entity_type == :nodes
+          res = Related::Node.find(res.map {|rel| @direction == :in ? rel.start_node_id : rel.end_node_id })
+          res.unshift(@node) if @include_start_node
+        end
+        res
+      end
+
+      def count
+        @count = Related.redis.scard(key)
+        @limit && @count > @limit ? @limit : @count
+      end
+
+      def size
+        @count || count
+      end
+
+    protected
+
+      def key
+        "#{@node.id}:rel:#{@relationship_type}:#{@direction}"
+      end
+
+      def query
+        self
+      end
+
+      def depth_first(nodes, depth = 0)
+        return [] if depth > @depth
+        nodes.each do |node|
+          key = "#{node}:nodes:#{@relationship_type}:#{@direction}"
+          if Related.redis.sismember(key, @destination.id)
+            return [node, @destination.id]
+          else
+            res = depth_first(Related.redis.smembers(key), depth+1)
+            return [node] + res unless res.empty?
+          end
+        end
+        return []
+      end
+
+      def dijkstra(nodes, depth = 0)
+        return [] if depth > @depth
+        shortest_path = []
+        nodes.each do |node|
+          key = "#{node}:nodes:#{@relationship_type}:#{@direction}"
+          if Related.redis.sismember(key, @destination.id)
+            return [node, @destination.id]
+          else
+            res = dijkstra(Related.redis.smembers(key), depth+1)
+            if res.size > 0
+              res = [node] + res
+              if res.size < shortest_path.size || shortest_path.size == 0
+                shortest_path = res
+              end
+            end
+          end
+        end
+        return shortest_path
+      end
+
+    end
+
+  protected
+
+    def query
+      Query.new(self)
+    end
+
+  end
+end

data/lib/related/relationship.rb

@@ -0,0 +1,54 @@
+module Related
+  class Relationship < Entity
+
+    def initialize(*attributes)
+      if attributes.first.is_a?(String)
+        @id = attributes.first
+      end
+      @attributes = attributes.last
+    end
+
+    def start_node
+      @start_node ||= Related::Node.find(start_node_id)
+    end
+
+    def end_node
+      @end_node ||= Related::Node.find(end_node_id)
+    end
+
+    def self.create(type, node1, node2, attributes = {})
+      self.new(attributes.merge(
+        :type => type,
+        :start_node_id => node1.to_s,
+        :end_node_id => node2.to_s
+      )).save
+    end
+
+  private
+
+    def create
+      Related.redis.multi do
+        super
+        Related.redis.sadd("#{self.start_node_id}:rel:#{type}:out", self.id)
+        Related.redis.sadd("#{self.end_node_id}:rel:#{type}:in", self.id)
+
+        Related.redis.sadd("#{self.start_node_id}:nodes:#{type}:out", self.end_node_id)
+        Related.redis.sadd("#{self.end_node_id}:nodes:#{type}:in", self.start_node_id)
+      end
+      self
+    end
+
+    def delete
+      Related.redis.multi do
+        Related.redis.srem("#{self.start_node_id}:rel:#{type}:out", self.id)
+        Related.redis.srem("#{self.end_node_id}:rel:#{type}:in", self.id)
+
+        Related.redis.srem("#{self.start_node_id}:nodes:#{type}:out", self.end_node_id)
+        Related.redis.srem("#{self.end_node_id}:nodes:#{type}:in", self.start_node_id)
+        super
+      end
+      self
+    end
+
+  end
+end

data/lib/related/version.rb

@@ -0,0 +1,3 @@
+module Related
+  Version = VERSION = '0.1'
+end

data/lib/related.rb

@@ -0,0 +1,49 @@
+require 'redis'
+require 'redis/namespace'
+
+require 'related/version'
+require 'related/helpers'
+require 'related/exceptions'
+require 'related/entity'
+require 'related/node'
+require 'related/relationship'
+
+module Related
+  include Helpers
+  extend self
+
+  # Accepts:
+  #   1. A 'hostname:port' string
+  #   2. A 'hostname:port:db' string (to select the Redis db)
+  #   3. A 'hostname:port/namespace' string (to set the Redis namespace)
+  #   4. A redis URL string 'redis://host:port'
+  #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+  #      or `Redis::Namespace`.
+  def redis=(server)
+    if server.respond_to? :split
+      if server =~ /redis\:\/\//
+        redis = Redis.connect(:url => server)
+      else
+        server, namespace = server.split('/', 2)
+        host, port, db = server.split(':')
+        redis = Redis.new(:host => host, :port => port,
+          :thread_safe => true, :db => db)
+      end
+      namespace ||= :related
+      @redis = Redis::Namespace.new(namespace, :redis => redis)
+    elsif server.respond_to? :namespace=
+      @redis = server
+    else
+      @redis = Redis::Namespace.new(:related, :redis => server)
+    end
+  end
+
+  # Returns the current Redis connection. If none has been created, will
+  # create a new one.
+  def redis
+    return @redis if @redis
+    self.redis = 'localhost:6379'
+    self.redis
+  end
+
+end

data/test/performance_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path('test/test_helper')
+require 'benchmark'
+
+class PerformanceTest < Test::Unit::TestCase
+
+  def setup
+    Related.redis.flushall
+  end
+
+  def test_simple
+    puts "Simple:"
+    node = Related::Node.create
+    time = Benchmark.measure do
+      1000.times do
+        n = Related::Node.create
+        rel = Related::Relationship.create(:friends, node, n)
+      end
+    end
+    puts time
+    time = Benchmark.measure do
+      node.outgoing(:friends).to_a
+    end
+    puts time
+  end
+
+  def test_with_attributes
+    puts "With attributes:"
+    node = Related::Node.create
+    time = Benchmark.measure do
+      1000.times do
+        n = Related::Node.create(
+          :title => 'Example title',
+          :description => 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.',
+          :status => 'archived',
+          :length => 42.3,
+          :enabled => true)
+        rel = Related::Relationship.create(:friends, node, n, :weight => 2.5, :list => 'Co-workers')
+      end
+    end
+    puts time
+    time = Benchmark.measure do
+      node.outgoing(:friends).to_a
+    end
+    puts time
+  end
+
+  def test_search
+    puts "Search:"
+    node = Related::Node.create
+    time = Benchmark.measure do
+      10.times do
+        n = Related::Node.create
+        rel = Related::Relationship.create(:friends, node, n)
+        10.times do
+          n2 = Related::Node.create
+          rel2 = Related::Relationship.create(:friends, n, n2)
+          10.times do
+            n3 = Related::Node.create
+            rel3 = Related::Relationship.create(:friends, n2, n3)
+            10.times do
+              n4 = Related::Node.create
+              rel4 = Related::Relationship.create(:friends, n3, n4)
+            end
+          end
+        end
+      end
+    end
+    puts time
+    time = Benchmark.measure do
+      node.outgoing(:friends).path_to(Related::Node.create)
+    end
+    puts time
+  end
+
+end

data/test/redis-test.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./test/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9736
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/test/related_test.rb

@@ -0,0 +1,203 @@
+require File.expand_path('test/test_helper')
+
+class RelatedTest < Test::Unit::TestCase
+
+  def setup
+    Related.redis.flushall
+  end
+
+  def test_can_set_a_namespace_through_a_url_like_string
+    assert Related.redis
+    assert_equal :related, Related.redis.namespace
+    Related.redis = 'localhost:9736/namespace'
+    assert_equal 'namespace', Related.redis.namespace
+  end
+
+  def test_can_create_node
+    assert Related::Node.create
+  end
+
+  def test_can_create_node_with_attributes
+    node = Related::Node.create(:name => 'Example', :popularity => 12.3)
+    assert node
+    assert_equal 'Example', node.name
+    assert_equal 12.3, node.popularity
+  end
+
+  def test_can_create_node_and_then_find_it_again_using_its_id
+    node1 = Related::Node.create(:name => 'Example', :popularity => 12.3)
+    node2 = Related::Node.find(node1.id)
+    assert node2
+    assert_equal node1.id, node2.id
+    assert_equal 'Example', node2.name
+    assert_equal '12.3', node2.popularity
+  end
+
+  def test_can_find_many_nodes_at_the_same_time
+    node1 = Related::Node.create(:name => 'One')
+    node2 = Related::Node.create(:name => 'Two')
+    one, two = Related::Node.find(node1.id, node2.id)
+    assert one
+    assert two
+  end
+
+  def test_will_raise_exception_when_a_node_is_not_found
+    assert_raises Related::NotFound do
+      Related::Node.find('foo')
+    end
+  end
+
+  def test_can_update_node_with_new_attributes
+    node1 = Related::Node.create(:name => 'Example', :popularity => 12.3)
+    node1.description = 'Example description.'
+    node1.save
+    node2 = Related::Node.find(node1.id)
+    assert_equal node1.description, node2.description
+  end
+
+  def test_two_nodes_with_the_same_id_should_be_equal
+    assert_equal Related::Node.new('test', {}), Related::Node.new('test', {})
+  end
+
+  def test_can_find_a_node_and_only_load_specific_attributes
+    node1 = Related::Node.create(:name => 'Example', :popularity => 12.3)
+    node2 = Related::Node.find(node1.id, :fields => [:does_not_exist, :name])
+    assert_equal node1.name, node2.name
+    assert_nil node2.does_not_exist
+    assert_nil node2.popularity
+  end
+
+  def test_can_find_multiple_nodes_and_only_load_specific_attributes
+    node1 = Related::Node.create(:name => 'Example 1', :popularity => 12.3)
+    node2 = Related::Node.create(:name => 'Example 2', :popularity => 42.5)
+    n = Related::Node.find(node1.id, node2.id, :fields => [:does_not_exist, :name])
+    assert_equal 2, n.size
+    assert_equal 'Example 1', n.first.name
+    assert_nil n.first.does_not_exist
+    assert_nil n.first.popularity
+    assert_equal 'Example 2', n.last.name
+    assert_nil n.last.does_not_exist
+    assert_nil n.last.popularity
+  end
+
+  def test_can_destroy_node
+    node = Related::Node.create
+    node.destroy
+    assert_raises Related::NotFound do
+      Related::Node.find(node.id)
+    end
+  end
+
+  def test_can_create_a_relationship_between_two_nodes
+    node1 = Related::Node.create(:name => 'One')
+    node2 = Related::Node.create(:name => 'Two')
+    rel = Related::Relationship.create(:friends, node1, node2)
+    assert_equal [rel], node1.outgoing(:friends).relationships.to_a
+    assert_equal [node2], node1.outgoing(:friends).to_a
+    assert_equal [], node1.incoming(:friends).to_a
+    assert_equal [node1], node2.incoming(:friends).to_a
+    assert_equal [], node2.outgoing(:friends).to_a
+  end
+
+  def test_can_create_a_relationship_with_attributes
+    node1 = Related::Node.create(:name => 'One')
+    node2 = Related::Node.create(:name => 'Two')
+    rel = Related::Relationship.create(:friends, node1, node2, :weight => 2.5)
+    rel = Related::Relationship.find(rel.id)
+    assert_equal '2.5', rel.weight
+  end
+
+  def test_can_delete_a_relationship
+    node1 = Related::Node.create(:name => 'One')
+    node2 = Related::Node.create(:name => 'Two')
+    rel = Related::Relationship.create(:friends, node1, node2)
+    rel.destroy
+    assert_equal [], node1.outgoing(:friends).to_a
+    assert_equal [], node1.incoming(:friends).to_a
+    assert_equal [], node2.incoming(:friends).to_a
+    assert_equal [], node2.outgoing(:friends).to_a
+    assert_raises Related::NotFound do
+      Related::Relationship.find(rel.id)
+    end
+  end
+
+  def test_can_limit_the_number_of_nodes_returned_from_a_query
+    node1 = Related::Node.create
+    node2 = Related::Node.create
+    node3 = Related::Node.create
+    node4 = Related::Node.create
+    node5 = Related::Node.create
+    Related::Relationship.create(:friends, node1, node2)
+    Related::Relationship.create(:friends, node1, node3)
+    Related::Relationship.create(:friends, node1, node4)
+    Related::Relationship.create(:friends, node1, node5)
+    assert_equal 3, node1.outgoing(:friends).limit(3).to_a.size
+  end
+
+  def test_can_count_the_number_of_related_nodes
+    node1 = Related::Node.create
+    node2 = Related::Node.create
+    node3 = Related::Node.create
+    node4 = Related::Node.create
+    node5 = Related::Node.create
+    rel1 = Related::Relationship.create(:friends, node1, node2)
+    rel1 = Related::Relationship.create(:friends, node1, node3)
+    rel1 = Related::Relationship.create(:friends, node1, node4)
+    rel1 = Related::Relationship.create(:friends, node1, node5)
+    assert_equal 4, node1.outgoing(:friends).count
+    assert_equal 4, node1.outgoing(:friends).size
+    assert_equal 3, node1.outgoing(:friends).limit(3).count
+    assert_equal 4, node1.outgoing(:friends).limit(5).count
+  end
+
+  def test_can_find_path_between_two_nodes
+    node1 = Related::Node.create
+    node2 = Related::Node.create
+    node3 = Related::Node.create
+    node4 = Related::Node.create
+    node5 = Related::Node.create
+    node6 = Related::Node.create
+    node7 = Related::Node.create
+    node8 = Related::Node.create
+    rel1 = Related::Relationship.create(:friends, node1, node2)
+    rel1 = Related::Relationship.create(:friends, node2, node3)
+    rel1 = Related::Relationship.create(:friends, node3, node2)
+    rel1 = Related::Relationship.create(:friends, node3, node4)
+    rel1 = Related::Relationship.create(:friends, node4, node5)
+    rel1 = Related::Relationship.create(:friends, node5, node3)
+    rel1 = Related::Relationship.create(:friends, node5, node8)
+    rel1 = Related::Relationship.create(:friends, node2, node5)
+    rel1 = Related::Relationship.create(:friends, node2, node6)
+    rel1 = Related::Relationship.create(:friends, node6, node7)
+    rel1 = Related::Relationship.create(:friends, node7, node8)
+    assert_equal node8, node1.path_to(node8).outgoing(:friends).depth(5).to_a.last
+    assert_equal node1, node1.path_to(node8).outgoing(:friends).depth(5).include_start_node.to_a.first
+    assert_equal node1, node8.path_to(node1).incoming(:friends).depth(5).to_a.last
+    assert_equal node8, node8.path_to(node1).incoming(:friends).depth(5).include_start_node.to_a.first
+  end
+
+  def test_can_find_shortest_path_between_two_nodes
+    node1 = Related::Node.create
+    node2 = Related::Node.create
+    node3 = Related::Node.create
+    node4 = Related::Node.create
+    node5 = Related::Node.create
+    node6 = Related::Node.create
+    node7 = Related::Node.create
+    node8 = Related::Node.create
+    rel1 = Related::Relationship.create(:friends, node1, node2)
+    rel1 = Related::Relationship.create(:friends, node2, node3)
+    rel1 = Related::Relationship.create(:friends, node3, node2)
+    rel1 = Related::Relationship.create(:friends, node3, node4)
+    rel1 = Related::Relationship.create(:friends, node4, node5)
+    rel1 = Related::Relationship.create(:friends, node5, node3)
+    rel1 = Related::Relationship.create(:friends, node5, node8)
+    rel1 = Related::Relationship.create(:friends, node2, node5)
+    rel1 = Related::Relationship.create(:friends, node2, node6)
+    rel1 = Related::Relationship.create(:friends, node6, node7)
+    rel1 = Related::Relationship.create(:friends, node7, node8)
+    assert_equal [node2,node5,node8], node1.shortest_path_to(node8).outgoing(:friends).depth(5).to_a
+    assert_equal [node1,node2,node5,node8], node1.shortest_path_to(node8).outgoing(:friends).depth(5).include_start_node.to_a
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,42 @@
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'test/unit'
+require 'related'
+
+#
+# make sure we can run redis
+#
+
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  puts "** try running `sudo rake install`"
+  abort ''
+end
+
+
+#
+# start our own redis when the tests start,
+# kill it when they end
+#
+
+at_exit do
+  next if $!
+
+  if defined?(MiniTest)
+    exit_code = MiniTest::Unit.new.run(ARGV)
+  else
+    exit_code = Test::Unit::AutoRunner.run
+  end
+
+  pid = `ps -A -o pid,command | grep [r]edis-test`.split(" ")[0]
+  puts "Killing test redis server..."
+  `rm -f #{dir}/dump.rdb`
+  Process.kill("KILL", pid.to_i)
+  exit exit_code
+end
+
+puts "Starting redis for testing at localhost:9736..."
+`redis-server #{dir}/redis-test.conf`
+Related.redis = 'localhost:9736'

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: related
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Niklas Holmgren
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-09 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: redis-namespace
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
+  type: :runtime
+  version_requirements: *id002
+description: Related is a Redis-backed high performance graph database.
+email: niklas@sutajio.se
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- README.md
+- Rakefile
+- LICENSE
+- CHANGELOG
+- lib/related/entity.rb
+- lib/related/exceptions.rb
+- lib/related/helpers.rb
+- lib/related/node.rb
+- lib/related/relationship.rb
+- lib/related/version.rb
+- lib/related.rb
+- test/performance_test.rb
+- test/redis-test.conf
+- test/related_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/sutajio/related/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Related is a Redis-backed high performance graph database.
+test_files: []
+