amico 1.0.0 → 1.1.0

data/.gitignore

@@ -2,3 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
+.yardoc
+doc

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create ruby-1.9.3-p0@amico_gem

data/CHANGELOG.md

@@ -1,3 +1,8 @@
-# 1.0.0
+# 1.1.0
+
+* Added blocking to relationships
+* Added reciprocated to relationships
+
+# 1.0.0 (2012-01-11)
 
 * Initial release

data/README.md

@@ -25,6 +25,8 @@ Amico.configure do |configuration|
   configuration.namespace = 'amico'
   configuration.following_key = 'following'
   configuration.followers_key = 'followers'
+  configuration.blocked_key = 'blocked'
+  configuration.reciprocated_key = 'reciprocated'
   configuration.page_size = 25
 end
 ```
@@ -40,6 +42,8 @@ Amico.configure do |configuration|
   configuration.namespace = 'amico'
   configuration.following_key = 'following'
   configuration.followers_key = 'followers'
+  configuration.blocked_key = 'blocked'
+  configuration.reciprocated_key = 'reciprocated'
   configuration.page_size = 25
 end
 
@@ -78,9 +82,39 @@ Amico.follower?(1, 11)
 
 Amico.following(1)
  => ["11"]
+
+Amico.block(1, 11)
+ => [1, 1, 1, 1, 1] 
+
+Amico.following?(11, 1)
+ => false 
+
+Amico.blocked?(1, 11)
+ => true 
+
+Amico.unblock(1, 11)
+ => true
+
+Amico.blocked?(1, 11)
+ => false
+
+Amico.follow(11, 1)
+ => nil
+
+Amico.follow(1, 11)
+ => [1, 1]
+
+Amico.reciprocated?(1, 11)
+ => true
+
+Amico.reciprocated(1)
+ => ["11"]
 ```
 
-You can pass `:page => 1` and `:page_size => 25` options into the `following` and `followers` methods. Set the values as appropriate.
+## Documentation 
+
+The source for the [relationships module](https://github.com/agoragames/amico/blob/master/lib/amico/relationships.rb) is well-documented. There are some 
+simple examples in the method documentation. You can also refer to the [online documentation](http://rubydoc.info/gems/amico/).
   
 ## Contributing to amico
  

data/lib/amico/configuration.rb

@@ -1,27 +1,82 @@
 module Amico
+  # Configuration settings for Amico.
   module Configuration
+    # Public: Redis instance.
     attr_accessor :redis
+
+    # Public: Amico namespace for Redis.
     attr_accessor :namespace
+
+    # Public: Key used in Redis for tracking who an individual is following.
     attr_accessor :following_key
+
+    # Public: Key used in Redis for tracking the followers of an individual.
     attr_accessor :followers_key
+
+    # Public: Key used in Redis for tracking who an individual blocks.
+    attr_accessor :blocked_key
+
+    # Public: Key used in Redis for tracking who has reciprocated a follow for an individual.
+    attr_accessor :reciprocated_key
+
+    # Public: Page size to be used when paging through the various types of relationships.
     attr_accessor :page_size
 
+    # Public: Yield self to be able to configure Amico with block-style configuration.
+    #
+    # Example:
+    #
+    #   Amico.configure do |configuration|
+    #     configuration.redis = Redis.new
+    #     configuration.namespace = 'amico'
+    #     configuration.following_key = 'following'
+    #     configuration.followers_key = 'followers'
+    #     configuration.blocked_key = 'blocked'
+    #     configuration.reciprocated_key = 'reciprocated'
+    #     configuration.page_size = 25
+    #   end
     def configure
       yield self
     end
 
+    # Public: Amico namespace for Redis.
+    #
+    # Returns the Amico namespace or the default of 'amico' if not set.
     def namespace
       @namespace ||= 'amico'
     end
 
+    # Public: Key used in Redis for tracking who an individual is following.
+    #
+    # Returns the key used in Redis for tracking who an individual is following or the default of 'following' if not set.
     def following_key
       @following_key ||= 'following'
     end
 
+    # Public: Key used in Redis for tracking the followers of an individual.
+    #
+    # Returns the key used in Redis for tracking the followers of an individual or the default of 'followers' if not set.
     def followers_key
       @followers_key ||= 'followers'
     end
 
+    # Public: Key used in Redis for tracking who an individual blocks.
+    # 
+    # Returns the key used in Redis for tracking who an individual blocks or the default of 'blocked' if not set.
+    def blocked_key
+      @blocked_key ||= 'blocked'
+    end
+
+    # Public: Key used in Redis for tracking who has reciprocated a follow for an individual.
+    #
+    # Returns the key used in Redis for tracking who has reciprocated a follow for an individual or the default of 'reciprocated' if not set.
+    def reciprocated_key
+      @reciprocated_key ||= 'reciprocated'
+    end
+
+    # Public: Page size to be used when paging through the various types of relationships.
+    #
+    # Returns the page size to be used when paging through the various types of relationships or the default of 25 if not set.
     def page_size
       @page_size ||= 25
     end

data/lib/amico/relationships.rb

@@ -1,63 +1,370 @@
 module Amico
   module Relationships
+    # Public: Establish a follow relationship between two IDs. After adding the follow 
+    #         relationship, it checks to see if the relationship is reciprocated and establishes that 
+    #         relationship if so.
+    # 
+    # from_id - The ID of the individual establishing the follow relationship.
+    # to_id   - The ID of the individual to be followed. 
+    #
+    # Examples
+    #
+    #   Amico.follow(1, 11)
     def follow(from_id, to_id)
       return if from_id == to_id
+      return if blocked?(to_id, from_id)
 
       Amico.redis.multi do
         Amico.redis.zadd("#{Amico.namespace}:#{Amico.following_key}:#{from_id}", Time.now.to_i, to_id)
         Amico.redis.zadd("#{Amico.namespace}:#{Amico.followers_key}:#{to_id}", Time.now.to_i, from_id)
       end
+
+      if reciprocated?(from_id, to_id)
+        Amico.redis.multi do
+          Amico.redis.zadd("#{Amico.namespace}:#{Amico.reciprocated_key}:#{from_id}", Time.now.to_i, to_id)
+          Amico.redis.zadd("#{Amico.namespace}:#{Amico.reciprocated_key}:#{to_id}", Time.now.to_i, from_id)
+        end
+      end
     end
 
+    # Public: Remove a follow relationship between two IDs. After removing the follow 
+    #         relationship, if a reciprocated relationship was established, it is 
+    #         also removed.
+    #
+    # from_id - The ID of the individual removing the follow relationship.
+    # to_id   - The ID of the individual to be unfollowed.
+    # 
+    # Examples
+    #
+    #   Amico.follow(1, 11)
+    #   Amico.unfollow(1, 11)
     def unfollow(from_id, to_id)
+      return if from_id == to_id
+
+      Amico.redis.multi do
+        Amico.redis.zrem("#{Amico.namespace}:#{Amico.following_key}:#{from_id}", to_id)
+        Amico.redis.zrem("#{Amico.namespace}:#{Amico.followers_key}:#{to_id}", from_id)
+        Amico.redis.zrem("#{Amico.namespace}:#{Amico.reciprocated_key}:#{from_id}", to_id)
+        Amico.redis.zrem("#{Amico.namespace}:#{Amico.reciprocated_key}:#{to_id}", from_id)
+      end
+    end
+
+    # Public: Block a relationship between two IDs. This method also has the side effect 
+    #         of removing any follower or following relationship between the two IDs. 
+    #
+    # from_id - The ID of the individual blocking the relationship.
+    # to_id   - The ID of the individual being blocked.
+    #
+    # Examples
+    #
+    #   Amico.block(1, 11)
+    def block(from_id, to_id)
+      return if from_id == to_id
+
       Amico.redis.multi do
         Amico.redis.zrem("#{Amico.namespace}:#{Amico.following_key}:#{from_id}", to_id)
+        Amico.redis.zrem("#{Amico.namespace}:#{Amico.following_key}:#{to_id}", from_id)
         Amico.redis.zrem("#{Amico.namespace}:#{Amico.followers_key}:#{to_id}", from_id)
+        Amico.redis.zrem("#{Amico.namespace}:#{Amico.followers_key}:#{from_id}", to_id)
+        Amico.redis.zrem("#{Amico.namespace}:#{Amico.reciprocated_key}:#{from_id}", to_id)
+        Amico.redis.zrem("#{Amico.namespace}:#{Amico.reciprocated_key}:#{to_id}", from_id)
+        Amico.redis.zadd("#{Amico.namespace}:#{Amico.blocked_key}:#{from_id}", Time.now.to_i, to_id)
       end
     end
 
+    # Public: Unblock a relationship between two IDs.
+    #
+    # from_id - The ID of the individual unblocking the relationship.
+    # to_id   - The ID of the blocked individual.
+    # 
+    # Examples
+    # 
+    #   Amico.block(1, 11)
+    #   Amico.unblock(1, 11)
+    def unblock(from_id, to_id)
+      return if from_id == to_id
+
+      Amico.redis.zrem("#{Amico.namespace}:#{Amico.blocked_key}:#{from_id}", to_id)
+    end
+
+    # Public: Count the number of individuals that someone is following.
+    #
+    # id - ID of the individual to retrieve following count for.
+    # 
+    # Examples
+    # 
+    #   Amico.follow(1, 11)
+    #   Amico.following_count(1)
+    #
+    # Returns the count of the number of individuals that someone is following.
     def following_count(id)
       Amico.redis.zcard("#{Amico.namespace}:#{Amico.following_key}:#{id}")
     end
 
+    # Public: Count the number of individuals that are following someone.
+    #
+    # id - ID of the individual to retrieve followers count for.
+    #
+    # Examples
+    #
+    #   Amico.follow(11, 1)
+    #   Amico.followers_count(1)
+    # 
+    # Returns the count of the number of individuals that are following someone.
     def followers_count(id)
       Amico.redis.zcard("#{Amico.namespace}:#{Amico.followers_key}:#{id}")
     end
 
+    # Public: Count the number of individuals that someone has blocked.
+    #
+    # id - ID of the individual to retrieve blocked count for.
+    # 
+    # Examples
+    #
+    #   Amico.block(1, 11)
+    #   Amico.blocked_count(1)
+    #
+    # Returns the count of the number of individuals that someone has blocked.
+    def blocked_count(id)
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.blocked_key}:#{id}")
+    end
+
+    # Public: Count the number of individuals that have reciprocated a following relationship.
+    #
+    # id - ID of the individual to retrieve reciprocated following count for.
+    # 
+    # Examples
+    # 
+    #   Amico.follow(1, 11)
+    #   Amico.follow(11, 1)
+    #   Amico.reciprocated_count(1)
+    #
+    # Returns the count of the number of individuals that have reciprocated a following relationship.
+    def reciprocated_count(id)
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.reciprocated_key}:#{id}")
+    end
+
+    # Public: Check to see if one individual is following another individual.
+    #
+    # id - ID of the individual checking the following status.
+    # following_id - ID of the individual to see if they are being followed by id.
+    #
+    # Examples
+    #
+    #   Amico.follow(1, 11)
+    #   Amico.following?(1, 11)
+    #
+    # Returns true if id is following following_id, false otherwise
     def following?(id, following_id)
       !Amico.redis.zscore("#{Amico.namespace}:#{Amico.following_key}:#{id}", following_id).nil?
     end
 
+    # Public: Check to see if one individual is a follower of another individual.
+    #
+    # id - ID of the individual checking the follower status.
+    # following_id - ID of the individual to see if they are following id.
+    #
+    # Examples
+    #
+    #   Amico.follow(11, 1)
+    #   Amico.follower?(1, 11)
+    # Returns true if follower_id is following id, false otherwise
     def follower?(id, follower_id)
       !Amico.redis.zscore("#{Amico.namespace}:#{Amico.followers_key}:#{id}", follower_id).nil?
     end
 
+    # Public: Check to see if one individual has blocked another individual.
+    #
+    # id - ID of the individual checking the blocked status.
+    # blocked_id - ID of the individual to see if they are blocked by id.
+    #
+    # Examples
+    # 
+    #   Amico.block(1, 11)
+    #   Amico.blocked?(1, 11)
+    #
+    # Returns true if id has blocked blocked_id, false otherwise
+    def blocked?(id, blocked_id)
+      !Amico.redis.zscore("#{Amico.namespace}:#{Amico.blocked_key}:#{id}", blocked_id).nil?
+    end
+
+    # Public: Check to see if one individual has reciprocated in following another individual.
+    #
+    # from_id - ID of the individual checking the reciprocated relationship.
+    # to_id - ID of the individual to see if they are following from_id.
+    #
+    # Examples
+    #
+    #   Amico.follow(1, 11)
+    #   Amico.follow(11, 1)
+    #   Amico.reciprocated?(1, 11)
+    #
+    # Returns true if both individuals are following each other, false otherwise
+    def reciprocated?(from_id, to_id)
+      following?(from_id, to_id) && following?(to_id, from_id)
+    end
+
+    # Public: Retrieve a page of followed individuals for a given ID.
+    #
+    # id - ID of the individual.
+    # options - Options to be passed for retrieving a page of followed individuals.
+    #           default({:page_size => Amico.page_size, :page => 1})
+    #
+    # Examples
+    #
+    #   Amico.follow(1, 11)
+    #   Amico.follow(1, 12)
+    #   Amico.following(1, :page => 1)
+    #
+    # Returns a page of followed individuals for a given ID.
     def following(id, options = default_options)
       members("#{Amico.namespace}:#{Amico.following_key}:#{id}", options)
     end
 
+    # Public: Retrieve a page of followers for a given ID.
+    #
+    # id - ID of the individual.
+    # options - Options to be passed for retrieving a page of followers.
+    #           default({:page_size => Amico.page_size, :page => 1})
+    #
+    # Examples
+    # 
+    #   Amico.follow(11, 1)
+    #   Amico.follow(12, 1)
+    #   Amico.followers(1, :page => 1)
+    #
+    # Returns a page of followers for a given ID.
     def followers(id, options = default_options)
       members("#{Amico.namespace}:#{Amico.followers_key}:#{id}", options)
     end
 
+    # Public: Retrieve a page of blocked individuals for a given ID.
+    #
+    # id - ID of the individual.
+    # options - Options to be passed for retrieving a page of blocked individuals.
+    #           default({:page_size => Amico.page_size, :page => 1})
+    #
+    # Examples
+    #
+    #   Amico.block(1, 11)
+    #   Amico.block(1, 12)
+    #   Amico.blocked(1, :page => 1)
+    #
+    # Returns a page of blocked individuals for a given ID.
+    def blocked(id, options = default_options)
+      members("#{Amico.namespace}:#{Amico.blocked_key}:#{id}", options)
+    end
+
+    # Public: Retrieve a page of individuals that have reciprocated a follow for a given ID.
+    #
+    # id - ID of the individual.
+    # options - Options to be passed for retrieving a page of individuals that have reciprocated a follow.
+    #           default({:page_size => Amico.page_size, :page => 1})
+    #
+    # Examples
+    #
+    #   Amico.follow(1, 11)
+    #   Amico.follow(1, 12)
+    #   Amico.follow(11, 1)
+    #   Amico.follow(12, 1)
+    #   Amico.reciprocated(1, :page => 1)
+    #
+    # Returns a page of individuals that have reciprocated a follow for a given ID.
+    def reciprocated(id, options = default_options)
+      members("#{Amico.namespace}:#{Amico.reciprocated_key}:#{id}", options)
+    end
+
+    # Public: Count the number of pages of following relationships for an individual.
+    #
+    # id - ID of the individual.
+    # page_size - Page size (default: Amico.page_size).
+    #
+    # Examples
+    #
+    #   Amico.follow(1, 11)
+    #   Amico.follow(1, 12)
+    #   Amico.following_page_count(1)
+    #
+    # Returns the number of pages of following relationships for an individual.
     def following_page_count(id, page_size = Amico.page_size)
       total_pages("#{Amico.namespace}:#{Amico.following_key}:#{id}", page_size)
     end
 
+    # Public: Count the number of pages of follower relationships for an individual.
+    #
+    # id - ID of the individual.
+    # page_size - Page size (default: Amico.page_size).
+    #
+    # Examples
+    #
+    #   Amico.follow(11, 1)
+    #   Amico.follow(12, 1)
+    #   Amico.followers_page_count(1)
+    #
+    # Returns the number of pages of follower relationships for an individual.
     def followers_page_count(id, page_size = Amico.page_size)
       total_pages("#{Amico.namespace}:#{Amico.followers_key}:#{id}", page_size)
     end
 
+    # Public: Count the number of pages of blocked relationships for an individual.
+    #
+    # id - ID of the individual.
+    # page_size - Page size (default: Amico.page_size).
+    #
+    # Examples
+    #
+    #   Amico.block(1, 11)
+    #   Amico.block(1, 12)
+    #   Amico.blocked_page_count(1)
+    #    
+    # Returns the number of pages of blocked relationships for an individual.
+    def blocked_page_count(id, page_size = Amico.page_size)
+      total_pages("#{Amico.namespace}:#{Amico.blocked_key}:#{id}", page_size)
+    end
+
+    # Public: Count the number of pages of reciprocated relationships for an individual.
+    #
+    # id - ID of the individual.
+    # page_size - Page size (default: Amico.page_size).
+    #
+    # Examples
+    #
+    #   Amico.follow(1, 11)
+    #   Amico.follow(1, 12)
+    #   Amico.follow(11, 1)
+    #   Amico.follow(12, 1)
+    #   Amico.reciprocated_page_count(1)
+    #    
+    # Returns the number of pages of reciprocated relationships for an individual.
+    def reciprocated_page_count(id, page_size = Amico.page_size)
+      total_pages("#{Amico.namespace}:#{Amico.reciprocated_key}:#{id}", page_size)
+    end
+
     private
 
+    # Internal: Default options for doing, for example, paging.
+    #
+    # Returns a hash of the default options.
     def default_options
       {:page_size => Amico.page_size, :page => 1}
     end
 
+    # Internal: Count the total number of pages for a given key in a Redis sorted set.
+    #
+    # key - Redis key.
+    # page_size - Page size from which to calculate total pages.
+    #
+    # Returns total number of pages for a given key in a Redis sorted set.
     def total_pages(key, page_size)
       (Amico.redis.zcard(key) / page_size.to_f).ceil
     end
 
+    # Internal: Retrieve a page of items from a Redis sorted set without scores.
+    #
+    # key - Redis key.
+    # options - Default options for paging (default: {:page_size => Amico.page_size, :page => 1})
+    #
+    # Returns a page of items from a Redis sorted set without scores.
     def members(key, options = default_options)
       options = default_options.dup.merge!(options)
       if options[:page] < 1

data/lib/amico/version.rb

@@ -1,3 +1,3 @@
 module Amico
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/spec/amico/configuration_spec.rb

@@ -7,6 +7,8 @@ describe Amico::Configuration do
         configuration.namespace.should eql('amico')
         configuration.following_key.should eql('following')
         configuration.followers_key.should eql('followers')
+        configuration.blocked_key.should eql('blocked')
+        configuration.reciprocated_key.should eql('reciprocated')
         configuration.page_size.should be(25)
       end
     end

data/spec/amico/relationships_spec.rb

@@ -15,10 +15,18 @@ describe Amico::Relationships do
       Amico.redis.zcard("#{Amico.namespace}:#{Amico.following_key}:1").should be(0)
       Amico.redis.zcard("#{Amico.namespace}:#{Amico.followers_key}:1").should be(0)
     end
+
+    it 'should add each individual to the reciprocated set if you both follow each other' do
+      Amico.follow(1, 11)
+      Amico.follow(11, 1)
+
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.reciprocated_key}:1").should be(1)
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.reciprocated_key}:11").should be(1)
+    end
   end
 
   describe '#unfollow' do
-    it 'should allow you to follow' do
+    it 'should allow you to unfollow' do
       Amico.follow(1, 11)
 
       Amico.redis.zcard("#{Amico.namespace}:#{Amico.following_key}:1").should be(1)
@@ -28,20 +36,53 @@ describe Amico::Relationships do
 
       Amico.redis.zcard("#{Amico.namespace}:#{Amico.following_key}:1").should be(0)
       Amico.redis.zcard("#{Amico.namespace}:#{Amico.followers_key}:11").should be(0)
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.reciprocated_key}:1").should be(0)
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.reciprocated_key}:11").should be(0)
     end
   end
 
-  describe '#following_count' do
-    it 'should return the correct count' do
-      Amico.follow(1, 11)
-      Amico.following_count(1).should be(1)
+  describe '#block' do
+    it 'should allow you to block someone following you' do
+      Amico.follow(11, 1)
+      Amico.block(1, 11)
+
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.following_key}:11").should be(0) 
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.blocked_key}:1").should be(1) 
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.reciprocated_key}:1").should be(0)
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.reciprocated_key}:11").should be(0)
+    end
+
+    it 'should allow you to block someone who is not following you' do
+      Amico.block(1, 11)
+
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.following_key}:11").should be(0) 
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.blocked_key}:1").should be(1) 
+    end
+
+    it 'should not allow someone you have blocked to follow you' do
+      Amico.block(1, 11)
+
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.following_key}:11").should be(0) 
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.blocked_key}:1").should be(1) 
+
+      Amico.follow(11, 1)
+
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.following_key}:11").should be(0) 
+      Amico.redis.zcard("#{Amico.namespace}:#{Amico.blocked_key}:1").should be(1) 
+    end
+
+    it 'should not allow you to block yourself' do
+      Amico.block(1, 1)
+      Amico.blocked?(1, 1).should be_false
     end
   end
 
-  describe '#followers_count' do
-    it 'should return the correct count' do
-      Amico.follow(1, 11)
-      Amico.followers_count(11).should be(1)
+  describe '#unblock' do
+    it 'should allow you to unblock someone you have blocked' do
+      Amico.block(1, 11)
+      Amico.blocked?(1, 11).should be_true
+      Amico.unblock(1, 11)
+      Amico.blocked?(1, 11).should be_false      
     end
   end
 
@@ -67,6 +108,27 @@ describe Amico::Relationships do
     end
   end
 
+  describe '#blocked?' do
+    it 'should return that someone is being blocked' do
+      Amico.block(1, 11)
+      Amico.blocked?(1, 11).should be_true
+      Amico.following?(11, 1).should be_false
+    end
+  end
+
+  describe '#reciprocated?' do
+    it 'should return true if both individuals are following each other' do
+      Amico.follow(1, 11)
+      Amico.follow(11, 1)
+      Amico.reciprocated?(1, 11).should be_true
+    end
+
+    it 'should return false if both individuals are not following each other' do
+      Amico.follow(1, 11)
+      Amico.reciprocated?(1, 11).should be_false
+    end
+  end
+
   describe '#following' do
     it 'should return the correct list' do
       Amico.follow(1, 11)
@@ -101,6 +163,72 @@ describe Amico::Relationships do
     end
   end
 
+  describe '#blocked' do
+    it 'should return the correct list' do
+      Amico.block(1, 11)
+      Amico.block(1, 12)
+      Amico.blocked(1).should eql(["12", "11"])
+      Amico.blocked(1, :page => 5).should eql(["12", "11"])
+    end
+
+    it 'should page correctly' do
+      add_reciprocal_followers(26, true)
+
+      Amico.blocked(1, :page => 1, :page_size => 5).size.should be(5)
+      Amico.blocked(1, :page => 1, :page_size => 10).size.should be(10)
+      Amico.blocked(1, :page => 1, :page_size => 26).size.should be(25)
+    end
+  end
+
+  describe '#reciprocated' do
+    it 'should return the correct list' do
+      Amico.follow(1, 11)
+      Amico.follow(11, 1)
+      Amico.reciprocated(1).should eql(["11"])
+      Amico.reciprocated(11).should eql(["1"])
+    end
+
+    it 'should page correctly' do
+      add_reciprocal_followers
+
+      Amico.reciprocated(1, :page => 1, :page_size => 5).size.should be(5)
+      Amico.reciprocated(1, :page => 1, :page_size => 10).size.should be(10)
+      Amico.reciprocated(1, :page => 1, :page_size => 26).size.should be(25)
+    end
+  end
+
+  describe '#following_count' do
+    it 'should return the correct count' do
+      Amico.follow(1, 11)
+      Amico.following_count(1).should be(1)
+    end
+  end
+
+  describe '#followers_count' do
+    it 'should return the correct count' do
+      Amico.follow(1, 11)
+      Amico.followers_count(11).should be(1)
+    end
+  end
+
+  describe '#blocked_count' do
+    it 'should return the correct count' do
+      Amico.block(1, 11)
+      Amico.blocked_count(1).should be(1)
+    end
+  end
+
+  describe '#reciprocated_count' do
+    it 'should return the correct count' do
+      Amico.follow(1, 11)
+      Amico.follow(11, 1)
+      Amico.follow(1, 12)
+      Amico.follow(12, 1)
+      Amico.follow(1, 13)
+      Amico.reciprocated_count(1).should be(2)
+    end
+  end
+
   describe '#following_page_count' do
     it 'should return the correct count' do
       add_reciprocal_followers
@@ -121,14 +249,38 @@ describe Amico::Relationships do
     end
   end
 
+  describe '#blocked_page_count' do
+    it 'should return the correct count' do
+      add_reciprocal_followers(26, true)
+
+      Amico.blocked_page_count(1).should be(1)
+      Amico.blocked_page_count(1, 10).should be(3)
+      Amico.blocked_page_count(1, 5).should be(5)
+    end
+  end
+
+  describe '#reciprocated_page_count' do
+    it 'should return the correct count' do
+      add_reciprocal_followers
+
+      Amico.reciprocated_page_count(1).should be(1)
+      Amico.reciprocated_page_count(1, 10).should be(3)
+      Amico.reciprocated_page_count(1, 5).should be(5)
+    end
+  end
+
   private
 
-  def add_reciprocal_followers(count = 26)
+  def add_reciprocal_followers(count = 26, block_relationship = false)
     1.upto(count) do |outer_index|
       1.upto(count) do |inner_index|
         if outer_index != inner_index
           Amico.follow(outer_index, inner_index + 1000)
           Amico.follow(inner_index + 1000, outer_index)
+          if block_relationship
+            Amico.block(outer_index, inner_index + 1000)
+            Amico.block(inner_index + 1000, outer_index)
+          end
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: amico
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-11 00:00:00.000000000 Z
+date: 2012-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &2160263060 !ruby/object:Gem::Requirement
+  requirement: &2164475940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2160263060
+  version_requirements: *2164475940
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2160261920 !ruby/object:Gem::Requirement
+  requirement: &2164475520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160261920
+  version_requirements: *2164475520
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2160260960 !ruby/object:Gem::Requirement
+  requirement: &2164475100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2160260960
+  version_requirements: *2164475100
 description: Relationships (e.g. friendships) backed by Redis
 email:
 - dczarnecki@agoragames.com
@@ -53,6 +53,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .rvmrc
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -80,7 +81,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2423888867059560591
+      hash: 2967547926380313375
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -89,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2423888867059560591
+      hash: 2967547926380313375
 requirements: []
 rubyforge_project: amico
 rubygems_version: 1.8.10