friendable 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=d

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-p194@friendable --create

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  add_filter "spec/"
+end

data/.travis.yml

@@ -0,0 +1,12 @@
+script: "bundle exec rspec spec/"
+
+rvm:
+  - ree
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+
+matrix:
+  allow_failures:
+    - rvm: ree
+    - rvm: 1.8.7

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in friendable.gemspec
+gemspec
+
+gem 'pry'
+gem 'simplecov'

data/LICENSE.md

@@ -0,0 +1,22 @@
+# Copyright (c) 2012 Yuki Nishijima
+
+## MIT License
+
+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,118 @@
+# Friendable
+
+You don't want to implement friendship functionality with RDB any more? But you think it's still too early to use graphDB? Use Redis!
+
+[![Build Status](https://secure.travis-ci.org/yuki24/friendable.png)](http://travis-ci.org/yuki24/friendable) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/yuki24/friendable)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'friendable'
+
+And then execute:
+
+    $ bundle
+
+Next, include `Friendable::UserMethods` inside User class or something like that you use in your application:
+
+```ruby
+class User < ActiveRecord::Base
+  include Friendable::UserMethods
+
+  ...
+end
+```
+
+Create a config file like below to set up Redis connection and save it as `config/initializers/friendable.rb`:
+
+```ruby
+Friendable.redis = Redis.new(host: "localhost", port: 6379)
+```
+
+## Usage
+
+### Being a friend
+
+```ruby
+user         = User.first
+another_user = User.last
+
+user.friends                # => empty ActiveRecord::Relation
+user.friend?(another_user)  # => false
+
+ # they are now friends!
+current_user.friend!(another_user)
+
+user.friend?(another_user)           # => true
+user.friends.include?(another_user)  # => true
+another_user.friend?(user)           # => true
+another_user.friends.include?(user)  # => true
+```
+
+You can also pass properties about their relationship. For example, if you want to store where they meet, you can do something like this:
+
+```ruby
+friendship = user.friend!(another_user, :meeting_place => "Red Rock")
+
+friendship.meeting_place  # => "Red Rock"
+friendship.created_at     # => "2012-09-23 14:24:03"
+friendship.updated_at     # => "2012-09-23 14:24:03"
+```
+
+If you want to find the specific friendship with somebody and edit/save the friendship, you can do it by using `#write_attribute` and `#save`:
+
+```ruby
+friendship = user.friendship_with(another_user)
+friendship.write_attribute(:close_friend, true)
+friendship.save
+
+friendship.close_friend   # => true
+friendship.meeting_place  # => "Red Rock"
+friendship.created_at     # => "2012-09-23 14:24:03"
+friendship.updated_at     # => "2012-09-23 14:25:21"
+```
+
+**Note:** properties are not saved on the opposite direction of the friendship.
+
+```ruby
+user.friend!(another_user, :meeting_place => "Red Rock")
+
+friendship = user.friendship_with(another_user)
+friendship.meeting_place  # => "Red Rock"
+
+friendship = another_user.friendship_with(user)  # opposite
+friendship.meeting_place  # => NoMethodError
+```
+
+### Removing a friend
+
+You can remove a user from the friend list of a user like this:
+
+```ruby
+user.unfriend!(another_user)
+
+user.friend?(another_user)                 # => false
+user.friends.include?(another_user)        # => false
+user.friend_ids.include?(another_user.id)  # => false
+```
+
+For more details, have a look at the documentation.
+
+## Support
+
+ * Ruby version: 1.9.3, 1.9.2, 1.8.7 and REE
+ * ORM: ActiveRecord
+
+You also(and of course) need to install Redis.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+Copyright (c) 2012 Yuki Nishijima. See LICENSE.md for further details.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/friendable.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/friendable/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Yuki Nishijima"]
+  gem.email         = ["mail@yukinishijima.net"]
+  gem.description   = %q{Redis backed friendship engine for your Ruby models}
+  gem.summary       = %q{Redis backed friendship engine for your Ruby models}
+  gem.homepage      = "https://github.com/yuki24/friendable"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "friendable"
+  gem.require_paths = ["lib"]
+  gem.version       = Friendable::VERSION
+
+  gem.add_dependency 'msgpack'
+  gem.add_dependency 'activesupport', '>= 3.0.0'
+  gem.add_dependency 'redis-namespace'
+  gem.add_dependency 'keytar'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'activerecord'
+  gem.add_development_dependency 'sqlite3'
+end

data/lib/friendable.rb

@@ -0,0 +1,41 @@
+require "friendable/version"
+require "friendable/user_methods"
+require "friendable/friendship"
+require "friendable/exceptions"
+require "redis-namespace"
+
+module Friendable
+  extend self
+  attr_accessor :resource_class
+
+  def redis
+    @redis ||= Redis::Namespace.new(:friendable, :redis => Redis.new)
+  end
+
+  # 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)
+    case server
+    when String
+      if server =~ /redis\:\/\//
+        redis = Redis.connect(:url => server, :thread_safe => true)
+      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 ||= :friendable
+
+      @redis = Redis::Namespace.new(namespace, :redis => redis)
+    when Redis::Namespace
+      @redis = server
+    else
+      @redis = Redis::Namespace.new(:friendable, :redis => server)
+    end
+  end
+end

data/lib/friendable/exceptions.rb

@@ -0,0 +1,6 @@
+module Friendable
+  # A general Friendable exception
+  class Error < StandardError; end
+
+  class FriendshipNotFound < Error; end
+end

data/lib/friendable/friendship.rb

@@ -0,0 +1,70 @@
+require 'msgpack'
+
+module Friendable
+  class Friendship
+    attr_accessor :target_resource, :source_resource
+    alias :friend :target_resource
+
+    def initialize(source_resource, target_resource, attrs = {})
+      # options = attrs.delete(:options) if attrs[:options]
+      @source_resource = source_resource
+      @target_resource = target_resource
+      @attributes = attrs.reverse_merge!(:created_at => nil, :updated_at => nil).symbolize_keys
+    end
+
+    def write_attribute(attr_name, value)
+      @attributes[attr_name.to_sym] = value
+    end
+
+    def save
+      write_attribute(:created_at, Time.zone.now) unless @attributes[:created_at]
+      write_attribute(:updated_at, Time.zone.now)
+
+      Friendable.redis.hset(redis_key, target_resource.id, self.to_msgpack)
+    end
+
+    def to_msgpack
+      serializable.to_msgpack
+    end
+
+    # Get a pretty string representation of the friendship, including the
+    # user who is a friend with and attributes for inspection.
+    #
+    def inspect
+      "#<Friendable::Friendship with: #{@target_resource.class}(id: #{@target_resource.id}), " <<
+      "attributes: " <<
+      @attributes.to_a.map{|ary| ary.join(": ") }.join(", ") << ">"
+    end
+
+    def self.deserialize!(source_resource, target_resource, options)
+      attrs = MessagePack.unpack(options).symbolize_keys
+      attrs[:created_at] = Time.zone.at(attrs[:created_at])
+      attrs[:updated_at] = Time.zone.at(attrs[:updated_at])
+
+      Friendship.new(source_resource, target_resource, attrs)
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      if method.to_s.last == "=" && @attributes.has_key?(method.to_s[0..-2].to_sym)
+        write_attribute(method.to_s[0..-2], args.first)
+      elsif @attributes.has_key?(method)
+        return @attributes[method]
+      else
+        super(method, args, block)
+      end
+    end
+
+    def redis_key
+      source_resource.friend_list_key
+    end
+
+    def serializable
+      @attributes.clone.tap do |serializable_object|
+        serializable_object[:created_at] = serializable_object[:created_at].try(:utc).try(:to_i)
+        serializable_object[:updated_at] = serializable_object[:updated_at].try(:utc).try(:to_i)
+      end
+    end
+  end
+end

data/lib/friendable/user_methods.rb

@@ -0,0 +1,153 @@
+require 'active_support/concern'
+require 'keytar'
+
+module Friendable
+  module UserMethods
+    extend ActiveSupport::Concern
+
+    included do
+      Friendable.resource_class = self
+      include Keytar
+      define_key :friend_list, :key_case => nil
+    end
+
+    # Returns an array object of the friend ids of your friends.
+    #
+    # ==== Examples
+    #   current_user.friend!(target_user)
+    #
+    #   current_user.friend_ids.include?(target_user.id) # => true
+    #
+    def friend_ids
+      @_friend_ids ||= (@_raw_friend_hashes ? @_raw_friend_hashes.keys : raw_friend_ids).map(&:to_i)
+    end
+
+    # Returns an collection of user ressources(ActiveRecord::Relation).
+    #
+    # ==== Examples
+    #   current_user.friends       # => [#<User id: 1, ...>, #<User id: 2, ...>, ...]
+    #   current_user.friends.first # => #<User id: 1, ...>
+    #   current_user.friends.class # => ActiveRecord::Relation
+    #
+    def friends
+      @_friends ||= Friendable.resource_class.where(:id => friend_ids)
+    end
+
+    # Returns an array of friendship objects. Currently this method does not support
+    # pagination.
+    #
+    # ==== Examples
+    #   current_user.friendships       # => [#<Friendable::Friendship>, ...]
+    #   current_user.friendships.first # => #<Friendable::Friendship>
+    #   current_user.friendships.class # => Array
+    #
+    def friendships
+      @_friendships ||= Friendable.resource_class.find(raw_friend_hashes.keys).map do |resource|
+        Friendship.deserialize!(self, resource, raw_friend_hashes[resource.id.to_s])
+      end
+    end
+
+    # Returns a friendship object that indicates the relation from a user to another user.
+    #
+    # ==== Examples
+    #   current_user.friend!(target_user, :foo => "bar")
+    #
+    #   friendship = current_user.friendship_with(target_user)
+    #   friendship.friend == target_user # => true
+    #   friendship.foo                   # => "bar"
+    #   friendship.bar                   # => NoMethodError
+    #
+    def friendship_with(target_resource)
+      raw_friendship = @_raw_friend_hashes.try(:[], target_resource.id.to_s) || redis.hget(friend_list_key, target_resource.id)
+
+      if raw_friendship
+        Friendship.deserialize!(self, target_resource, raw_friendship)
+      else
+        raise Friendable::FriendshipNotFound, "user:#{self.id} is not a friend of the user:#{target_resource.id}"
+      end
+    end
+
+    # Returns the number of the user's friends.
+    #
+    # ==== Examples
+    #   current_user.friends_count        # => 0
+    #
+    #   current_user.friend!(target_user)
+    #   current_user.friends_count        # => 1
+    #
+    def friends_count
+      @_raw_friend_ids.try(:count) || @_raw_friend_hashes.try(:count) || redis.hlen(friend_list_key)
+    end
+
+    # Returns if the given user is friend of you or not.
+    #
+    # ==== Examlpes
+    #   current_user.friend?(target_user) # => false
+    #
+    #   current_user.friend!(target_user)
+    #
+    #   current_user.friend?(target_user) # => true
+    #
+    def friend?(resource)
+       @_raw_friend_ids.try(:include?, resource.id.to_s) || @_raw_friend_hashes.try(:has_key?, resource.id.to_s) || redis.hexists(friend_list_key, resource.id)
+    end
+
+    # Adds the given user to your friend list. If the given user is already
+    # a friend of you and different options are given, the existing options
+    # will be replaced with the new options. It returns an object of
+    # Friendable::Friendship.
+    #
+    # ==== Examples
+    #   current_user.friends.include?(target_user) # => false
+    #   current_user.friend!(target_user)          # => #<Friendable::Friendship>
+    #   current_user.friends.include?(target_user) # => true
+    #
+    #   friendship = current_user.friend!(target_user, :foo => "bar")
+    #   friendship.foo # => "bar"
+    #   friendship.bar # => NoMethodError
+    #
+    def friend!(resource, options = {})
+      # TODO: in the near future, I want to change to something like this:
+      #   redis.multi do
+      #     Friendship.new(self, resource, options).save(inverse: true)
+      #   end
+      Friendship.new(self, resource, options).tap do |friendship|
+        redis.multi do
+          friendship.save
+          Friendship.new(resource, self).save
+        end
+      end
+    end
+
+    # Removes the given user from your friend list. If the given user is not
+    # a friend of you, it doesn't affect anything.
+    #
+    # ==== Examples
+    #   current_user.friend!(target_user)
+    #   current_user.friends.include?(target_user) # => true
+    #
+    #   current_user.unfriend!(target_user)
+    #   current_user.friends.include?(target_user) # => false
+    #
+    def unfriend!(resource)
+      redis.multi do
+        redis.hdel(friend_list_key, resource.id)
+        redis.hdel(resource.friend_list_key, self.id)
+      end
+    end
+
+    private
+
+    def raw_friend_hashes
+      @_raw_friend_hashes ||= redis.hgetall(friend_list_key)
+    end
+
+    def raw_friend_ids
+      @_raw_friend_ids ||= redis.hkeys(friend_list_key)
+    end
+
+    def redis
+      @_redis ||= Friendable.redis
+    end
+  end
+end

data/lib/friendable/version.rb

@@ -0,0 +1,3 @@
+module Friendable
+  VERSION = "0.1.0"
+end

data/spec/friendable/friendship_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+# Suppose the following class exists:
+#
+#   class User < ActiveRecord::Base
+#     include Friendable::UserMethods
+#   end
+
+describe Friendable::Friendship do
+  def redis; Friendable.redis; end
+  before(:each) { redis.flushdb }
+  let(:current_user) { User.first }
+  let(:target_user) { User.last }
+
+  describe "initialization" do
+    context "without options" do
+      subject { Friendable::Friendship.new(current_user, target_user) }
+      its(:created_at) { should be_nil }
+      its(:updated_at) { should be_nil }
+    end
+  end
+
+  describe "dynamic accessors" do
+    let(:friendship) { Friendable::Friendship.new(current_user, target_user, :foo => "bar", :hoge => "fuga") }
+    subject { friendship }
+    its(:foo) { should == "bar" }
+    its(:hoge) { should == "fuga" }
+
+    it "should not allow to dynamically set a new value" do
+      expect { friendship.new_attr = "new value" }.to raise_exception(NoMethodError)
+    end
+
+    describe "#write_attribute" do
+      specify { friendship.write_attribute(:another_attr, "another value").should == "another value" }
+
+      context "after the definition" do
+        before { friendship.write_attribute(:another_attr, "another value") }
+        its(:another_attr) { should == "another value" }
+        specify do
+          friendship.another_attr = "new value"
+          friendship.another_attr.should == "new value"
+        end
+      end
+    end
+=begin
+    describe "#remove_attribute" do
+      specify { friendship.remove_attribute(:foo).should == "bar" }
+
+      context "after the removal" do
+        before { friendship.remove_attribute(:foo) }
+
+        it "can no longer get a new value from foo" do
+          expect { friendship.foo }.to raise_exception(NoMethodError)
+        end
+
+        it "can no longer set a new value to foo" do
+          expect { friendship.foo = "bar" }.to raise_exception(NoMethodError)
+        end
+      end
+    end
+=end
+  end
+
+  describe "serialization" do
+    context "with options" do
+      let(:friendship) { Friendable::Friendship.new(current_user, target_user, :foo => "bar", :hoge => "fuga") }
+      specify do
+        MessagePack.unpack(friendship.to_msgpack).should == {
+          "foo" => "bar",
+          "hoge" => "fuga",
+          "created_at" => nil,
+          "updated_at" => nil
+        }
+      end
+    end
+  end
+
+  describe "deserialization" do
+    let(:current_timestamp) { Time.now.to_i }
+    let(:msgpacked_data) { {:created_at => current_timestamp, :updated_at => current_timestamp}.to_msgpack }
+
+    context "with options" do
+      subject { Friendable::Friendship.deserialize!(current_user, target_user, msgpacked_data) }
+      it { should be_a(Friendable::Friendship) }
+      its(:source_resource) { should == current_user }
+      its(:target_resource) { should == target_user }
+      its(:created_at) { should == Time.zone.at(current_timestamp) }
+      its(:updated_at) { should == Time.zone.at(current_timestamp) }
+    end
+  end
+
+  describe "#save" do
+    before { current_user.friend!(target_user) }
+    let(:friendship) { current_user.friendship_with(target_user) }
+
+    it "should persist the newly assigned value" do
+      created_at = friendship.created_at
+      updated_at = friendship.updated_at
+      sleep 1
+      friendship.save
+
+      friendship = current_user.friendship_with(target_user)
+      friendship.created_at.to_i.should == created_at.to_i
+      friendship.updated_at.to_i.should_not == updated_at.to_i
+    end
+  end
+
+  describe "#inspect" do
+    subject { Friendable::Friendship.new(current_user, target_user, :foo => "bar", :hoge => "fuga") }
+    its(:inspect) { should ==
+      "#<Friendable::Friendship with: User(id: #{target_user.id}), attributes: foo: bar, hoge: fuga, created_at: , updated_at: >"
+    }
+  end
+end

data/spec/friendable/user_methods_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+# Suppose the following class exists:
+#
+#   class User < ActiveRecord::Base
+#     include Friendable::UserMethods
+#   end
+
+describe Friendable::UserMethods do
+  def redis; Friendable.redis; end
+  before(:each) { redis.flushdb }
+  let(:current_user) { User.first }
+  let(:target_user) { User.last }
+
+  subject { current_user }
+  its(:friend_list_key) { should == "Users:friend_list:1" }
+
+  describe "#friend!" do
+    context "to add a friend" do
+      before { current_user.friend!(target_user) }
+      specify { current_user.friend?(target_user).should be_true }
+      specify { redis.hkeys(current_user.friend_list_key).should include(target_user.id.to_s) }
+      specify { redis.hkeys(target_user.friend_list_key).should include(current_user.id.to_s) }
+    end
+
+    context "to add a friend with several options" do
+      let(:friendship) { current_user.friend!(target_user, :foo => "bar", :hoge => "fuga") }
+      subject { friendship }
+      it { should be_a(Friendable::Friendship) }
+      its(:friend){ should == target_user }
+      its(:foo){ should == "bar" }
+      its(:hoge){ should == "fuga" }
+    end
+
+    context "to add a friend without options" do
+      let(:friendship) { current_user.friend!(target_user) }
+      subject { friendship }
+      it { should be_a(Friendable::Friendship) }
+      its(:friend){ should == target_user }
+    end
+  end
+
+  describe "#unfriend!" do
+    context "to remove a friendship" do
+      before do
+        current_user.friend!(target_user)
+        current_user.unfriend!(target_user)
+      end
+
+      specify { current_user.friend?(target_user).should be_false }
+      specify { redis.hexists(current_user.friend_list_key, target_user.id.to_s).should be_false }
+      specify { redis.hexists(target_user.friend_list_key, current_user.id.to_s).should be_false }
+    end
+  end
+
+  describe "#friends" do
+    subject { current_user.friends }
+
+    context "without friends" do
+      it { should be_an(ActiveRecord::Relation) }
+      its(:count){ should == 0 }
+    end
+
+    context "with one friend" do
+      before { current_user.friend!(target_user) }
+      it { should include(target_user) }
+    end
+  end
+
+  describe "#friendships" do
+    subject { current_user.friendships }
+
+    context "without friends to return an empty erray" do
+      it { should be_an(Array) }
+      its(:count) { should == 0 }
+    end
+
+    context "with one friend to return an array of friendship objects" do
+      before { current_user.friend!(target_user, :foo => "bar", :hoge => "fuga") }
+      subject { current_user.friendships.first }
+      it { should be_a(Friendable::Friendship) }
+      its(:source_resource) { should == current_user }
+      its(:target_resource) { should == target_user }
+      its(:created_at) { should be_a(ActiveSupport::TimeWithZone) }
+      its(:updated_at) { should be_a(ActiveSupport::TimeWithZone) }
+      its(:foo) { should == "bar" }
+      its(:hoge) { should == "fuga" }
+    end
+  end
+
+  describe "#friendship_with" do
+    context "without friends" do
+      specify do
+        expect {
+          current_user.friendship_with(target_user)
+        }.to raise_exception(Friendable::FriendshipNotFound)
+      end
+    end
+
+    context "with one friend" do
+      before { current_user.friend!(target_user, :foo => "bar", :hoge => "fuga") }
+      subject { current_user.friendship_with(target_user) }
+      it { should be_a(Friendable::Friendship) }
+      its(:foo) { should == "bar" }
+      its(:hoge) { should == "fuga" }
+    end
+  end
+
+  describe "#friend_ids" do
+    subject { current_user.friend_ids }
+
+    context "without friends" do
+      it { should be_an(Array) }
+      its(:count) { should == 0 }
+    end
+
+    context "with one friend" do
+      before { current_user.friend!(target_user) }
+      it { should include(target_user.id) }
+    end
+
+    context "without friends after unfriend" do
+      before do
+        current_user.friend!(target_user)
+        current_user.unfriend!(target_user)
+      end
+
+      it { should_not include(target_user.id) }
+    end
+  end
+
+  describe "#friends_count" do
+    subject { current_user.friends_count }
+
+    context "without friends" do
+      it { should == 0 }
+    end
+
+    context "with one friend" do
+      before { current_user.friend!(target_user) }
+      it { should == 1 }
+    end
+
+    context "without friends after unfriend" do
+      before do
+        current_user.friend!(target_user)
+        current_user.unfriend!(target_user)
+      end
+
+      it { should == 0 }
+    end
+  end
+end

data/spec/friendable_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Friendable do
+  it { should respond_to :redis }
+  it { should respond_to :resource_class }
+  it { should respond_to :resource_class= }
+  its(:redis) { should be_a(Redis::Namespace) }
+
+  describe "confgiruration" do
+    context "with the default redis" do
+      subject { Friendable.redis.client }
+      it { should be_a(Redis::Client) }
+      its(:host) { should == "127.0.0.1" }
+      its(:port) { should == 6379 }
+    end
+
+    context "with a string" do
+      before { Friendable.redis = "10.0.0.1:6379:1" }
+      subject { Friendable.redis.client }
+      it { should be_a(Redis::Client) }
+      its(:host) { should == "10.0.0.1" }
+      its(:port) { should == 6379 }
+      its(:db) { should == 1 }
+    end
+
+    context "with an object of Redis class" do
+      before { Friendable.redis = Redis.new(:host => "127.0.0.1", :port => 6379) }
+      subject { Friendable.redis.client }
+      it { should be_a(Redis::Client) }
+      its(:host) { should == "127.0.0.1" }
+      its(:port) { should == 6379 }
+    end
+
+    context "with an object of Redis::Namespace class" do
+      before { Friendable.redis = Redis::Namespace.new(:friendable, :host => "127.0.0.1", :port => 6379) }
+      subject { Friendable.redis.client }
+      it { should be_a(Redis::Client) }
+      its(:host) { should == "127.0.0.1" }
+      its(:port) { should == 6379 }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'simplecov'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'bundler/setup'
+Bundler.require
+
+# database
+require 'active_record'
+ActiveRecord::Base.configurations = {'test' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('test')
+
+# migrations
+class CreateAllTables < ActiveRecord::Migration
+  def self.up
+    create_table(:users) {|t| t.string :name; t.integer :age}
+  end
+end
+ActiveRecord::Migration.verbose = false
+CreateAllTables.up
+
+# models
+class User < ActiveRecord::Base
+  include Friendable::UserMethods
+end
+User.create!(:name => "Some User")
+User.create!(:name => "Another User")
+
+# default time sone
+Time.zone = "UTC"
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f }
+
+RSpec.configure do |config|
+
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: friendable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Yuki Nishijima
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: keytar
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Redis backed friendship engine for your Ruby models
+email:
+- mail@yukinishijima.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- .simplecov
+- .travis.yml
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- friendable.gemspec
+- lib/friendable.rb
+- lib/friendable/exceptions.rb
+- lib/friendable/friendship.rb
+- lib/friendable/user_methods.rb
+- lib/friendable/version.rb
+- spec/friendable/friendship_spec.rb
+- spec/friendable/user_methods_spec.rb
+- spec/friendable_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/yuki24/friendable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Redis backed friendship engine for your Ruby models
+test_files:
+- spec/friendable/friendship_spec.rb
+- spec/friendable/user_methods_spec.rb
+- spec/friendable_spec.rb
+- spec/spec_helper.rb