related 0.2.1 → 0.3.0

data/CHANGELOG

@@ -1,4 +1,10 @@
 
+*0.3*
+
+* ActiveModel support
+* Properties
+* Dynamic sub-class loading
+
 *0.2*
 
 * Implemented set operations.

data/README.md

@@ -11,7 +11,9 @@ use. The intention is not to compete with industrial grade graph databases
 like Neo4j, but rather to be a replacement for a relational database when your
 data is better described as a graph. For example when building social
 software. Related is meant to be web scale, but ultimately relies on the
-ability of Redis to scale (using Redis cluster for example).
+ability of Redis to scale (using Redis cluster for example). Read more about
+the philosophy behind Related in the
+[Wiki](http://github.com/sutajio/related/wiki).
 
 Setup
 -----
@@ -22,8 +24,10 @@ Assuming you already have Redis installed:
 
 Or add the gem to your Gemfile.
 
-    require 'related'
-    Related.redis = 'redis://.../'
+```ruby
+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.
@@ -31,52 +35,69 @@ 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])
+```ruby
+node = Related::Node.create(:name => 'Example', :popularity => 2.3)
+node.new?
+node.popularity = 100
+node.attributes
+node.has_attribute?(:popularity)
+node.read_attribute(:popularity)
+node.write_attribute(:popularity, 50)
+node.save
+node.persisted?
+node = Related::Node.find(node.id)
+node.destroy
+node.destroyed?
+
+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)
+```ruby
+node.outgoing(:friends)
+node.incoming(:friends)
+node.outgoing(:friends).relationships
+node.outgoing(:friends).nodes
+node.outgoing(:friends).limit(5)
+node.outgoing(:friends).options(:fields => ..., :model => ...)
+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)
+```ruby
+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:
 
-    node1.outgoing(:friends).union(node2.outgoing(:friends))
-    node1.outgoing(:friends).diff(node2.outgoing(:friends))
-    node1.outgoing(:friends).intersect(node2.outgoing(:friends))
+```ruby
+node1.outgoing(:friends).union(node2.outgoing(:friends))
+node1.outgoing(:friends).diff(node2.outgoing(:friends))
+node1.outgoing(:friends).intersect(node2.outgoing(:friends))
+```
 
 Relationships are sorted based on when they were created, which means you can
 paginate them:
 
-    node.outgoing(:friends).relationship.per_page(100).page(1)
-    node.outgoing(:friends).relationship.per_page(100).page(rel)
+```ruby
+node.outgoing(:friends).relationships.per_page(100).page(1)
+node.outgoing(:friends).relationships.per_page(100).page(rel)
+```
 
 The second form paginates based on the id of the last relationship on the
 previous page. Useful for cases where explicit page numbers are not
@@ -87,7 +108,79 @@ without going through the extra step of iterating through the relationship
 objects you will only get random nodes. Thus you can use .limit (or .per_page)
 like this to get a random selection of nodes:
 
-    node.outgoing(:friends).nodes.limit(5)
+```ruby
+node.outgoing(:friends).nodes.limit(5)
+```
+
+Properties
+----------
+
+All Node and Relationship attributes are stored as strings in Redis, but you
+can easily create your own subclass and define your own custom serialization
+behavior. You can either just override the getter and setter methods for the
+attribute you need to convert or you can use the `property` method to define
+the semantics and let Related do the conversion for you.
+
+```ruby
+class Event < Related::Node
+  property :title, String
+  property :attending_count, Integer
+  property :popularity, Float
+  property :start_date, DateTime
+  property :location do |value|
+    "http://maps.google.com/maps?q=#{value}"
+  end
+end
+```
+
+An additional benefit of defining properties like this is that they get
+included when you serialize the object to JSON or XML even when the attribute
+hasn't been set.
+
+```ruby
+event = Event.create(:title => 'Party!', :location => 'Stockholm')
+event.as_json # => {"title"=>"Party!","attending_count"=>nil,"popularity"=>nil,"start_date"=>nil,"location"=>"http://maps.google.com/maps?q=Stockholm"}
+```
+
+When querying the graph you may want the query to return the results as your
+custom model class instead of as a Related::Node or Related::Relationship.
+Related allows you to specify what model a specific node or relationship
+should be instantiated as based on its attributes.
+
+```ruby
+Related::Node.find(...,
+  :model => lambda {|attributes|
+    attributes['start_date'] ? Event : Related::Node
+  }
+)
+
+node.outgoing(:attending).options(
+  :model => lambda {|attributes|
+    attributes['start_date'] ? Event : Related::Node
+  }
+)
+```
+
+ActiveModel
+-----------
+
+Related supports ActiveModel and includes some basic functionality in both
+nodes and relationships like validations, callbacks, JSON and XML
+serialization and translation support. You can easily extend your own sub
+classes with the custom ActiveModel functionality that you need.
+
+```ruby
+class Like < Related::Relationship
+  validates_presence_of :how_much
+  validates_numericality_of :how_much
+
+  after_save :invalidate_cache
+
+  def invalidate_cache
+    ...
+  end
+end
+```
 
 Follower
 --------
@@ -95,22 +188,26 @@ Follower
 Related includes a helper module called Related::Follower that you can include
 in your node sub-class to get basic Twitter-like follow functionality:
 
-    class User < Related::Node
-      include Related::Follower
-    end
-
-    user1 = User.create
-    user2 = User.create
-
-    user1.follow!(user2)
-    user1.unfollow!(user2)
-    user2.followers
-    user1.following
-    user1.friends
-    user2.followed_by?(user1)
-    user1.following?(user2)
-    user2.followers_count
-    user1.following_count
+```ruby
+require 'related/follower'
+
+class User < Related::Node
+  include Related::Follower
+end
+
+user1 = User.create
+user2 = User.create
+
+user1.follow!(user2)
+user1.unfollow!(user2)
+user2.followers
+user1.following
+user1.friends
+user2.followed_by?(user1)
+user1.following?(user2)
+user2.followers_count
+user1.following_count
+```
 
 The two nodes does not need to be of the same type. You can for example have
 a User following a Page or whatever makes sense in your app.

data/lib/related/entity.rb

@@ -1,134 +1,252 @@
 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
-
-      def as_json(options = {})
-        (attributes || {}).merge(:id => self.id)
-      end
-
-      def to_json(options = {})
-        as_json.to_json(options)
-      end
-
-    private
-
-      def create_or_update
-        new_record? ? create : update
-      end
-
-      def create
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include ActiveModel::Translation
+
+    self.include_root_in_json = false
+
+    define_model_callbacks :create, :update, :destroy, :save
+
+    attr_reader :id
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = {}
+      attributes.each do |key,value|
+        serializer = self.class.property_serializer(key)
+        @attributes[key.to_s] = serializer ?
+          serializer.to_string(value) : value
+      end
+    end
+
+    def to_s
+      self.id
+    end
+
+    def attributes
+      @attributes ||= {}
+      self.class.properties.inject({}) { |memo,key|
+        memo[key.to_s] = nil
+        memo
+      }.merge(@attributes.inject({}) { |memo,(k,v)|
+        memo[k.to_s] = v
+        memo
+      }.merge('id' => self.id))
+    end
+
+    def read_attribute(name)
+      @attributes ||= {}
+      @attributes[name.to_s] || @attributes[name]
+    end
+
+    def write_attribute(name, value)
+      @attributes ||= {}
+      @attributes[name.to_s] = value
+    end
+
+    def has_attribute?(name)
+      @attributes ||= {}
+      @attributes.has_key?(name.to_s) ||
+        @attributes.has_key?(name) ||
+        @properties.has_key?(name.to_sym)
+    end
+
+    def method_missing(sym, *args, &block)
+      if sym.to_s =~ /=$/
+        name = sym.to_s[0..-2]
+        serializer = self.class.property_serializer(name)
+        write_attribute(name,
+          serializer ? serializer.to_string(args.first) :
+                       args.first)
+      else
+        serializer = self.class.property_serializer(sym)
+        serializer ? serializer.from_string(read_attribute(sym)) :
+                     read_attribute(sym)
+      end
+    end
+
+    def ==(other)
+      other.is_a?(Related::Entity) && self.to_key == other.to_key
+    end
+
+    def new?
+      @id.nil? ? true : false
+    end
+
+    alias new_record? new?
+
+    def persisted?
+      !new?
+    end
+
+    def destroyed?
+      @destroyed
+    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
+
+    def self.property(name, klass=nil, &block)
+      @properties ||= {}
+      @properties[name.to_sym] = Serializer.new(klass, block)
+    end
+
+    def self.properties
+      @properties ? @properties.keys : []
+    end
+
+  private
+
+    def load_attributes(id, attributes)
+      @id = id
+      @attributes = attributes
+      self
+    end
+
+    def create_or_update
+      run_callbacks :save do
+        new? ? create : update
+      end
+    end
+
+    def create
+      run_callbacks :create do
+        raise Related::ValidationsFailed, self unless valid?
         @id = Related.generate_id
-        @attributes.merge!(:created_at => Time.now.utc.iso8601)
+        @attributes ||= {}
+        @attributes.merge!('created_at' => Time.now.utc.iso8601)
         Related.redis.hmset(@id, *@attributes.to_a.flatten)
-        self
       end
+      self
+    end
 
-      def update
-        @attributes.merge!(:updated_at => Time.now.utc.iso8601)
+    def update
+      run_callbacks :update do
+        raise Related::ValidationsFailed, self unless valid?
+        @attributes ||= {}
+        @attributes.merge!('updated_at' => Time.now.utc.iso8601)
         Related.redis.hmset(@id, *@attributes.to_a.flatten)
-        self
       end
+      self
+    end
 
-      def delete
+    def delete
+      run_callbacks :destroy do
         Related.redis.del(id)
         @destroyed = true
-        self
       end
+      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
+    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
+    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
-        self.new(id, attributes)
       end
+      klass = options[:model] ? options[:model].call(attributes) : self
+      klass.new.send(:load_attributes, 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|
+    def self.find_many(ids, options = {})
+      res = Related.redis.pipelined do
+        ids.each {|id|
           if options[:fields]
-            attributes = {}
-            res[i].each_with_index do |value, i|
-              attributes[options[:fields][i]] = value
-            end
-            objects << self.new(id, attributes)
+            Related.redis.hmget(id.to_s, *options[:fields])
           else
-            objects << self.new(id, Hash[*res[i]])
+            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
+          klass = options[:model] ? options[:model].call(attributes) : self
+          objects << klass.new.send(:load_attributes, id, attributes)
+        else
+          attributes = Hash[*res[i]]
+          klass = options[:model] ? options[:model].call(attributes) : self
+          objects << klass.new.send(:load_attributes, id, attributes)
         end
-        objects
       end
+      objects
+    end
+
+    def self.property_serializer(property)
+      @properties ||= {}
+      @properties[property.to_sym]
+    end
+
+    class Serializer
+      def initialize(klass, block = nil)
+        @klass = klass
+        @block = block
+      end
+
+      def to_string(value)
+        case @klass.to_s
+        when 'DateTime', 'Time'
+          value.iso8601
+        else
+          value.to_s
+        end
+      end
+
+      def from_string(value)
+        value = case @klass.to_s
+        when 'String'
+          value.to_s
+        when 'Integer'
+          value.to_i
+        when 'Float'
+          value.to_f
+        when 'DateTime', 'Time'
+          Time.parse(value)
+        else
+          value
+        end unless value.nil?
+        @block ? @block.call(value) : value
+      end
+    end
 
   end
 end

data/lib/related/exceptions.rb

@@ -2,4 +2,5 @@ module Related
   class RelatedException < RuntimeError; end
   class NotFound < RelatedException; end
   class InvalidQuery < RelatedException; end
+  class ValidationsFailed < RelatedException; end
 end

data/lib/related/follower.rb

@@ -1,12 +1,12 @@
 module Related
   module Follower
-    def follow!(user)
-      Related::Relationship.create(:follow, self, user)
+    def follow!(other)
+      Related::Relationship.create(:follow, self, other)
     end
 
-    def unfollow!(user)
+    def unfollow!(other)
       self.following.relationships.each do |rel|
-        if rel.end_node_id == user.id
+        if rel.end_node_id == other.id
           rel.destroy
         end
       end
@@ -24,12 +24,12 @@ module Related
       self.followers.intersect(self.following)
     end
 
-    def followed_by?(user)
-      self.followers.include?(user)
+    def followed_by?(other)
+      self.followers.include?(other)
     end
 
-    def following?(user)
-      self.following.include?(user)
+    def following?(other)
+      self.following.include?(other)
     end
 
     def followers_count

data/lib/related/helpers.rb

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

data/lib/related/node.rb

@@ -13,6 +13,12 @@ module Related
         query
       end
 
+      def options(opt)
+        query = self.query
+        query.options = opt
+        query
+      end
+
       def outgoing(type)
         query = self.query
         query.relationship_type = type
@@ -86,11 +92,13 @@ module Related
       attr_writer :include_start_node
       attr_writer :destination
       attr_writer :search_algorithm
+      attr_writer :options
 
       def initialize(node)
         @node = node
         @result_type = :nodes
         @depth = 4
+        @options = {}
       end
 
       def each(&block)
@@ -104,9 +112,9 @@ module Related
       def to_a
         perform_query unless @result
         if @result_type == :nodes
-          Related::Node.find(@result)
+          Related::Node.find(@result, @options)
         else
-          Related::Relationship.find(@result)
+          Related::Relationship.find(@result, @options)
         end
       end
 
@@ -153,6 +161,14 @@ module Related
         self
       end
 
+      def as_json(options = {})
+        self.to_a
+      end
+
+      def to_json(options = {})
+        self.as_json.to_json(options)
+      end
+
     protected
 
       def page_start

data/lib/related/version.rb

@@ -1,3 +1,3 @@
 module Related
-  Version = VERSION = '0.2.1'
+  Version = VERSION = '0.3.0'
 end

data/lib/related.rb

@@ -1,6 +1,6 @@
 require 'redis'
 require 'redis/namespace'
-require 'json'
+require 'active_model'
 
 require 'related/version'
 require 'related/helpers'

data/test/active_model_test.rb

@@ -0,0 +1,132 @@
+require File.expand_path('test/test_helper')
+
+class ActiveModelTest < ActiveModel::TestCase
+  include ActiveModel::Lint::Tests
+
+  class Like < Related::Relationship
+    validates_numericality_of :how_much, :allow_nil => true
+
+    before_save :before_save_callback
+    after_save :after_save_callback
+    before_create :before_create_callback
+    after_create :after_create_callback
+    before_update :before_update_callback
+    after_update :after_update_callback
+    before_destroy :before_destroy_callback
+    after_destroy :after_destroy_callback
+
+    attr_reader :before_save_was_called
+    attr_reader :after_save_was_called
+    attr_reader :before_create_was_called
+    attr_reader :after_create_was_called
+    attr_reader :before_update_was_called
+    attr_reader :after_update_was_called
+    attr_reader :before_destroy_was_called
+    attr_reader :after_destroy_was_called
+
+    def before_save_callback
+      @before_save_was_called = true
+    end
+    def after_save_callback
+      @after_save_was_called = true
+    end
+    def before_create_callback
+      @before_create_was_called = true
+    end
+    def after_create_callback
+      @after_create_was_called = true
+    end
+    def before_update_callback
+      @before_update_was_called = true
+    end
+    def after_update_callback
+      @after_update_was_called = true
+    end
+    def before_destroy_callback
+      @before_destroy_was_called = true
+    end
+    def after_destroy_callback
+      @after_destroy_was_called = true
+    end
+  end
+
+  def setup
+    Related.redis.flushall
+    @model = Related::Entity.new
+  end
+
+  def test_attributes_has_id
+    node = Related::Entity.create
+    assert_equal node.id, node.attributes['id']
+  end
+
+  def test_can_return_json
+    node = Related::Entity.create(:name => 'test')
+    json = { :node => node }.to_json
+    json = JSON.parse(json)
+    assert_equal node.id, json['node']['id']
+    assert_equal node.name, json['node']['name']
+  end
+
+  def test_query_can_return_json
+    node1 = Related::Node.create(:name => 'node1')
+    node2 = Related::Node.create(:name => 'node2')
+    Related::Relationship.create(:friends, node1, node2)
+    json = { :nodes => node1.outgoing(:friends) }.to_json
+    json = JSON.parse(json)
+    assert_equal node2.id, json['nodes'][0]['id']
+    assert_equal node2.name, json['nodes'][0]['name']
+  end
+
+  def test_validations
+    like = Like.new(:how_much => 'not much')
+    assert_equal false, like.valid?
+    assert_equal [:how_much], like.errors.messages.keys
+    assert_raises Related::ValidationsFailed do
+      like.save
+    end
+    like.how_much = 1.0
+    assert_equal true, like.valid?
+    assert_nothing_raised do
+      like.save
+    end
+  end
+
+  def test_save_callbacks
+    like = Like.new
+    assert_equal nil, like.before_save_was_called
+    assert_equal nil, like.after_save_was_called
+    like.save
+    assert_equal true, like.before_save_was_called
+    assert_equal true, like.after_save_was_called
+  end
+
+  def test_create_callbacks
+    like = Like.new
+    assert_equal nil, like.before_create_was_called
+    assert_equal nil, like.after_create_was_called
+    like.save
+    assert_equal true, like.before_create_was_called
+    assert_equal true, like.after_create_was_called
+  end
+
+  def test_update_callbacks
+    like = Like.new
+    like.save
+    assert_equal nil, like.before_update_was_called
+    assert_equal nil, like.after_update_was_called
+    like.save
+    assert_equal true, like.before_update_was_called
+    assert_equal true, like.after_update_was_called
+  end
+
+  def test_create_callbacks
+    like = Like.new
+    assert_equal nil, like.before_destroy_was_called
+    assert_equal nil, like.after_destroy_was_called
+    like.destroy
+    assert_equal true, like.before_destroy_was_called
+    assert_equal true, like.after_destroy_was_called
+  end
+
+end

data/test/model_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path('test/test_helper')
+
+class ModelTest < ActiveModel::TestCase
+
+  class Event < Related::Node
+    property :attending_count, Integer
+    property :popularity, Float
+    property :start_date, DateTime
+    property :end_date, DateTime
+    property :location do |value|
+      "http://maps.google.com/maps?q=#{value}"
+    end
+  end
+
+  def setup
+    Related.redis.flushall
+  end
+
+  def test_property_conversion
+    event = Event.create(
+      :attending_count => 42,
+      :popularity => 0.9,
+      :start_date => Time.parse('2011-01-01'),
+      :location => 'Stockholm')
+    event = Event.find(event.id)
+    assert_equal 42, event.attending_count
+    assert_equal 0.9, event.popularity
+    assert_equal Time.parse('2011-01-01'), event.start_date
+    assert_equal Time.parse('2011-01-01').iso8601, event.read_attribute(:start_date)
+    assert_equal nil, event.end_date
+    assert_equal "http://maps.google.com/maps?q=Stockholm", event.location
+    assert event.as_json.has_key?('end_date')
+  end
+
+  def test_model_factory
+    e1 = Event.create(:popularity => 0.0)
+    e2 = Event.create(:popularity => 1.0)
+    e1, e2 = Related::Node.find(e1.id, e2.id, :model =>
+      lambda {|attributes| attributes['popularity'].to_f > 0.5 ? Event : Related::Node })
+    assert_equal Related::Node, e1.class
+    assert_equal Event, e2.class
+
+    Related::Relationship.create(:test, e1, e2)
+    nodes = e1.outgoing(:test).nodes.options(:model =>
+      lambda {|attributes| attributes['popularity'].to_f > 0.5 ? Event : Related::Node }).to_a
+    assert_equal Event, nodes.first.class
+  end
+
+end

data/test/related_test.rb

@@ -56,7 +56,7 @@ class RelatedTest < Test::Unit::TestCase
   end
 
   def test_two_nodes_with_the_same_id_should_be_equal
-    assert_equal Related::Node.new('test', {}), Related::Node.new('test', {})
+    assert_equal Related::Node.new.send(:load_attributes, 'test', {}), Related::Node.new.send(:load_attributes, 'test', {})
   end
 
   def test_can_find_a_node_and_only_load_specific_attributes
@@ -265,14 +265,6 @@ class RelatedTest < Test::Unit::TestCase
     assert_equal [node1], node2.incoming(:friends).intersect(node3.incoming(:friends)).to_a
   end
 
-  def test_can_return_json
-    node = Related::Node.create(:name => 'test')
-    json = { :node => node }.to_json
-    json = JSON.parse(json)
-    assert_equal node.id, json['node']['id']
-    assert_equal node.name, json['node']['name']
-  end
-
   def test_timestamps
     node = Related::Node.create.save
     node = Related::Node.find(node.id)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: related
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Niklas Holmgren
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-23 00:00:00 +02:00
+date: 2011-10-07 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,19 +51,17 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: activemodel
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 3
         segments: 
-        - 1
-        - 0
         - 0
-        version: 1.0.0
+        version: "0"
   type: :runtime
   version_requirements: *id003
 description: Related is a Redis-backed high performance graph database.
@@ -88,7 +86,9 @@ files:
 - lib/related/relationship.rb
 - lib/related/version.rb
 - lib/related.rb
+- test/active_model_test.rb
 - test/follower_test.rb
+- test/model_test.rb
 - test/performance_test.rb
 - test/redis-test.conf
 - test/related_test.rb