party_boy 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+spec/database.yml
+*.log

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Mike Nelson
+
+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.rdoc

@@ -0,0 +1,89 @@
+= party_boy
+
+Models relationships between AR models. Allows you to follow, friend, and block other AR's. Consists of two mixins: acts_as_followable and acts_as_friend. These options allow an AR to inherit either a twitter-like follower system or a facebook-like friend system.
+
+== Installation
+
+Install the gem
+ gem install party_boy
+	
+Run the generator
+ script/generate party_boy
+	
+This will generate a migration file as well as the necessary Relationship class in your models folder.
+
+== Usage
+
+=== Setup
+
+Add the appropriate mixin to your models:
+ class Waterboy < ActiveRecord::Base
+  ...
+  acts_as_followable
+  ...
+ end
+
+ class Quarterback < ActiveRecord::Base
+  ...
+  acts_as_friend
+  ...
+ end
+
+---
+
+=== acts_as_follower
+
+To allow a model (A) to follow another (B), add acts_as_follow to at least model A. Now, you can follow any other model in your project:
+ a = Waterboy.find 1
+ b = Quarterback.find 2
+ a.follow(b)
+
+To stop following, simply just:
+ a.unfollow(b)
+
+Or to block the relationship:
+ b.block(a)
+
+To find out if there is a relationship between two models, use the methods:
+ a.following?(b)
+ b.followed_by?(a)
+
+To retrieve a set of models based on the relationships, use:
+ a.following
+ b.followers
+
+==== STI
+
+STI is also handled by party_boy. The relationship is always stored using the super-most class. However, relationships to inheriting classes can also be retrieved. Do so by passing in the type(s):
+
+ class Quarterback < User; end
+ class Cheerleader < User; end
+ class Waterboy < User; end
+
+In string form
+ a.followers('users')
+ a.following(%w(users quarterbacks))
+
+Or in class form
+ a.followers(User)
+ b.following([User, Quarterback, Cheerleader])
+
+==== STI - part deux
+
+On top of accessing relationships through followers / following methods, party_boy will dynamically filter the results based on the combined class name:
+
+ a.quarterback_followers		# returns all followers of type quarterback
+ b.cheerleader_followers		# returns all followers of type cheerleader
+ a.following_quarterbacks		# returns all the quarterbacks 'a' is following
+ b.following_cheerleaders		# returns all the cheerleaders 'b' is following
+
+---
+
+=== acts_as_friend
+
+Docs coming soon. I don't need it, do you?
+
+
+== Copyright
+
+Copyright (c) 2010 Mike Nelson. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "party_boy"
+    gem.summary = "Models relationships between AR models. Allows you to follow, friend, and block other AR's."
+    gem.description = "Models relationships between AR models. Allows you to follow, friend, and block other AR's. Consists of two acts_as: acts_as_followable and acts_as_friend. These options allow an AR to inherit either a twitter-like follower system or a facebook-like friend system."
+    gem.email = "mdnelson30@gmail.com"
+    gem.homepage = "http://github.com/mnelson/party_boy"
+    gem.authors = ["Mike Nelson"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "party_boy #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/generators/party_boy/party_boy_generator.rb

@@ -0,0 +1,14 @@
+class PartyBoyGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.directory "app/models"
+      m.template "model.rb", "app/models/relationship.rb"
+      
+      m.migration_template 'migration.rb', 'db/migrate'
+    end
+  end
+  
+  def file_name
+    "party_boy_migration"
+  end
+end

data/generators/party_boy/templates/migration.rb

@@ -0,0 +1,14 @@
+class PartyBoyMigration < ActiveRecord::Migration
+  def self.up
+    create_table :relationships do |t|
+			t.references :requestor, :polymorphic => true, :null => false
+			t.references :requestee, :polymorphic => true, :null => false
+			t.boolean :restricted, :default => true
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :relationships
+  end
+end

data/generators/party_boy/templates/model.rb

@@ -0,0 +1,30 @@
+class Relationship < ActiveRecord::Base
+
+	named_scope :restricted, :conditions => ['relationships.restricted = ?', true]
+	named_scope :unrestricted, :conditions => ['relationships.restricted = ?', false]
+	
+	named_scope :to_type, lambda {|rtype| rtype = [rtype].flatten.compact; rtype.size > 0 && {:conditions => ['relationships.requestee_type IN (?)', [rtype].flatten]} || {}}
+	named_scope :from_type, lambda {|rtype| rtype = [rtype].flatten.compact; rtype.size > 0 && {:conditions => ['relationships.requestor_type IN (?)', [rtype].flatten]} || {}}
+	
+	default_scope :order => 'created_at DESC'
+	
+	with_options :polymorphic => true do |klazz|
+		klazz.belongs_to :requestor
+		klazz.belongs_to :requestee
+	end
+	
+	validates_presence_of :requestor, :requestee
+	
+	alias_attribute :blocked, :restricted
+	def accepted?
+		!self.restricted
+	end
+	
+	class << self
+		alias_attribute :blocked, :restricted
+		alias_attribute :unblocked, :unrestricted
+	
+		alias_attribute :unaccepted, :restricted
+		alias_attribute :accepted, :unrestricted
+	end
+end

data/lib/party_boy.rb

@@ -0,0 +1,225 @@
+module Party
+	module Boy
+		
+		class IdentityTheftError < StandardError; end
+		class StalkerError < StandardError; end
+		
+		def self.included(klazz)
+			klazz.extend(Party::Boy::ClassMethods)
+			klazz.class_eval do 
+				include Party::Boy::RelateableInstanceMethods
+			end
+		end
+		
+		module ClassMethods
+			
+			def acts_as_followable
+				with_options :class_name => 'Relationship', :dependent => :destroy do |klazz|
+				 klazz.has_many :followings, :as => :requestee
+				 klazz.has_many :follows, :as => :requestor
+				end
+				
+				include Party::Boy::FollowableInstanceMethods
+			end
+			
+			def acts_as_friend
+				with_options :class_name => 'Relationship', :dependent => :destroy do |klazz|
+					klazz.has_many :outgoing_friendships, :as => :requestor, :include => :requestee
+					klazz.has_many :incoming_friendships, :as => :requestee, :include => :requestor
+				end
+				
+				include Party::Boy::RelateableInstanceMethods
+				include Party::Boy::FriendlyInstanceMethods
+			end
+			
+		end
+		
+		
+		module RelateableInstanceMethods
+		
+		private
+			
+			# should be able to pass a class, string, or object and get back the super-most class (before activerecord)
+			def super_class_name(obj = self)
+				obj = (obj.class == Class && obj || obj.class == String && obj.constantize || obj.class)
+				if obj.superclass != ActiveRecord::Base
+					super_class_name(obj.superclass)
+				else
+					obj.name
+				end
+			end
+			
+			def super_class_names(obj = self)
+				if obj.nil?
+					return nil
+				end
+				obj = (obj.class == Class && obj || obj.class == String && obj.constantize || obj.class)
+				if obj.superclass != ActiveRecord::Base
+					[obj.name, super_class_names(obj.superclass)].flatten
+				else
+					[obj.name]
+				end
+			end
+			
+			def get_relationship_to(requestee)
+				requestee && Relationship.unblocked.find(:first, :conditions => ['requestor_id = ? and requestor_type = ? and requestee_id = ? and requestee_type = ?', self.id, super_class_name, requestee.id, super_class_name(requestee)]) || nil
+			end
+			
+			def get_relationship_from(requestor)
+				requestor && Relationship.unblocked.find(:first, :conditions => ['requestor_id = ? and requestor_type = ? and requestee_id = ? and requestee_type = ?', requestor.id, super_class_name(requestor), self.id, super_class_name]) || nil
+			end
+			
+		end
+		
+		module FollowableInstanceMethods
+		
+			def following?(something)
+				!!(something && Relationship.unblocked.count(:conditions => ['requestor_id = ? and requestor_type = ? and requestee_id = ? and requestee_type = ?', self.id, super_class_name, something.id, super_class_name(something)]) > 0)
+			end
+			
+			def followed_by?(something)
+				!!(something && Relationship.unblocked.count(:conditions => ['requestor_id = ? and requestor_type = ? and requestee_id = ? and requestee_type = ?', something.id, super_class_name(something), self.id, super_class_name]) > 0)
+			end
+			
+			def follow(something)
+				if blocked_by?(something)
+					raise(Party::Boy::StalkerError, "#{super_class_name} #{self.id} has been blocked by #{super_class_name(something)} #{something.id} but is trying to follow them")
+				else
+					Relationship.create(:requestor => self, :requestee => something, :restricted => false) if !(blocked_by?(something) || following?(something))
+				end
+			end
+			
+			def blocked_by?(something)
+				!!(something && Relationship.blocked.count(:conditions => ['requestor_id = ? and requestor_type = ? and requestee_id = ? and requestee_type = ?', self.id, super_class_name, something.id, super_class_name(something)]) > 0)
+			end
+			
+			def unfollow(something)
+				(rel = get_relationship_to(something)) && rel.destroy
+			end
+			
+			def block(something)
+				(rel = (get_relationship_from(something) || get_relationship_to(something))) && rel.update_attribute(:restricted, true)
+			end
+			
+			def follower_count(type = nil)
+				followings.unblocked.from_type(type).size
+			end
+			
+			def following_count(type = nil)
+				follows.unblocked.to_type(type).size
+			end
+			
+			def followers(type = nil)
+				type = [type].flatten.compact.uniq
+				super_class = type.last
+				exact_class = type.first
+				results = relationships_from(super_class)
+				if super_class != exact_class
+					results.collect{|r| r.requestor.class.name == exact_class && r.requestor || nil}.compact
+				else
+					results.collect{|r| r.requestor}
+				end
+					
+			end
+			
+			def following(type = nil)
+				type = [type].flatten.compact.uniq
+				super_class = type.last
+				exact_class = type.first
+				results = relationships_to(super_class)
+				if super_class != exact_class
+					results.collect{|r| r.requestee.class.name == exact_class && r.requestee || nil}.compact
+				else
+					results.collect{|r| r.requestee}
+				end
+			end
+			
+			def extended_network(type = nil)
+				following.collect{|f| f.methods.include?('following') && f.following(type) || []}.flatten.uniq
+			end
+			
+			def method_missing(method, *args)
+				case method.id2name
+				when /^(.+)ss_followers$/
+					# this is for the rare case of a class name ending in ss, like 'business'; 'business'.classify => 'Busines'
+					followers(super_class_names("#{$1.classify}ss"))
+				when /^(.+)s_followers$/, /^(.+)_followers$/
+					followers(super_class_names($1.classify))
+				when /^following_(.+)$/
+					following(super_class_names($1.classify))
+				else
+					super
+				end
+			end
+			
+		private
+			
+			def relationships_to(type)
+				self.follows.unblocked.to_type(type).all(:include => [:requestee])
+			end
+			
+			def relationships_from(type)
+				self.followings.unblocked.from_type(type).all(:include => [:requestor])
+			end
+			
+		end
+		
+		module FriendlyInstanceMethods
+			
+			def friends
+				(outgoing_friendships.accepted + incoming_friendships.accepted).collect{|r| [r.requestor, r.requestee]}.flatten.uniq - [self]
+			end
+			
+			def extended_network
+				friends.collect{|f| f.methods.include?('friends') && f.friends || []}.flatten.uniq - [self]
+			end
+			
+			def outgoing_friend_requests
+				self.outgoing_friendships.unaccepted.all
+			end
+			
+			def incoming_friend_requests
+				self.incoming_friendships.unaccepted.all
+			end
+			
+			def is_friends_with?(something)
+				arr = something && [self.id, super_class_name, super_class_name(something), something.id]
+				arr && Relationship.accepted.count(:conditions => [(['(requestor_id = ? AND requestor_type = ? AND requestee_type = ? AND requestee_id = ?)']*2).join(' OR '), arr, arr.reverse].flatten) > 0
+			end
+			
+			def pending?(something)
+				arr = something && [self.id, super_class_name, super_class_name(something), something.id]
+				arr && Relationship.unaccepted.count(:conditions => [(['(requestor_id = ? AND requestor_type = ? AND requestee_type = ? AND requestee_id = ?)']*2).join(' OR '), arr, arr.reverse].flatten) > 0
+			end
+			
+			def friend_count
+				arr = [self.id, super_class_name]
+				Relationship.accepted.count(:conditions => ['(requestor_id = ? AND requestor_type = ?) OR (requestee_id = ? and requestee_type = ?)', arr, arr].flatten)
+			end
+			
+			def request_friendship(friendship_or_something)
+				rel = relationship_from(friendship_or_something)
+				rel.nil? && Relationship.create(:requestor => self, :requestee => friendship_or_something, :restricted => true) || rel.update_attributes(:restricted => false)
+			end
+			
+			def deny_friendship(friendship_or_something)
+				(rel = relationship_from(friendship_or_something)) && rel.destroy
+			end
+			
+			alias_method :reject_friendship, :deny_friendship
+			alias_method :accept_friendship, :request_friendship
+			
+		private
+		
+			def relationship_from(friendship_or_something)
+				if friendship_or_something && friendship_or_something.class == Relationship
+					raise(Party::Boy::IdentityTheftError, "#{self.class.name} with id of #{self.id} tried to access Relationship #{friendship_or_something.id}") if 	!(friendship_or_something.requestor == self || friendship_or_something.requestee == self)
+					friendship_or_something
+				else
+					arr = friendship_or_something && [self.id, super_class_name, super_class_name(friendship_or_something), friendship_or_something.id]
+					arr && Relationship.find(:first, :conditions => [(['(requestor_id = ? AND requestor_type = ? AND requestee_type = ? AND requestee_id = ?)']*2).join(' OR '), arr, arr.reverse].flatten) || nil
+				end
+			end	
+		end
+	end
+end

data/social_lite.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{social_lite}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mike Nelson"]
+  s.date = %q{2010-01-28}
+  s.description = %q{Models relationships between AR models. Allows you to follow, friend, and block other AR's. Consists of two acts_as: acts_as_followable and acts_as_friend. These options allow an AR to inherit either a twitter-like follower system or a facebook-like friend system.}
+  s.email = %q{mdnelson30@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "generators/party_boy/party_boy_generator.rb",
+     "generators/party_boy/templates/migration.rb",
+     "generators/party_boy/templates/model.rb",
+     "lib/party_boy.rb",
+     "spec/models/follower_class.rb",
+     "spec/models/friend_class.rb",
+     "spec/party_boy_spec.rb",
+     "spec/schema.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mnelson/social_lite}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Models relationships between AR models. Allows you to follow, friend, and block other AR's.}
+  s.test_files = [
+    "spec/models/follower_class.rb",
+     "spec/models/friend_class.rb",
+     "spec/party_boy_spec.rb",
+     "spec/schema.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/spec/models/follower_class.rb

@@ -0,0 +1,5 @@
+class FollowerClass < ActiveRecord::Base
+	include Party::Boy
+	
+	acts_as_followable
+end

data/spec/models/friend_class.rb

@@ -0,0 +1,5 @@
+class FriendClass < ActiveRecord::Base
+	include Party::Boy
+	
+	acts_as_friend
+end

data/spec/party_boy_spec.rb

@@ -0,0 +1,160 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+
+describe "PartyBoy" do
+	
+	it "should integrate follower methods properly" do
+		%w(followers following following? followed_by?).each do |method|
+	   	FollowerClass.new.methods.include?(method).should be_true
+		end
+	end
+	
+	it "should integrate friend methods properly" do
+		%w(friends outgoing_friend_requests incoming_friend_requests extended_network).each do |method|
+	   	FriendClass.new.methods.include?(method).should be_true
+		end
+	end
+	
+	
+	it "should validate relationships properly" do
+		a = FollowerClass.create
+		b = FollowerClass.create
+		
+		r = Relationship.new(:requestor => a, :requestee => b, :restricted => false)
+		r.should be_valid
+		
+		r2 = Relationship.new(:requestor => a, :restricted => false)
+		r2.should_not be_valid
+	
+		r3 = Relationship.new(:requestee => b, :restricted => true)
+		r3.should_not be_valid
+	end
+	
+end
+
+describe "PartyBoy -- Follower" do
+	it "should generate relationships and return proper counts" do
+		a = FollowerClass.create
+		b = FollowerClass.create
+
+		a.follow(b)
+		
+		r = Relationship.last
+
+		r.requestor.should eql(a)
+		r.requestee.should eql(b)
+		r.blocked.should be_false
+		
+		a.following_count.should eql(1)
+		a.follower_count.should eql(0)
+		
+		b.following_count.should eql(0)
+		b.follower_count.should eql(1)
+	end
+	
+	it "should generate and destroy relationships from party_boy models" do
+		a = FollowerClass.create
+		b = FollowerClass.create
+		
+		a.follow(b)
+		
+		a.following_count.should eql(1)
+		
+		a.unfollow(b)
+		a.following_count.should eql(0)
+		
+	end
+		
+	it "should restrict relationships properly" do
+		a = FollowerClass.create
+		b = FollowerClass.create
+
+		r = a.follow(b)
+		
+		b.block(a)
+		
+		a.following_count.should eql(0)
+		b.follower_count.should eql(0)
+		
+		r.reload
+		r.blocked.should be_true
+		
+		lambda { a.follow(b) }.should raise_error(Party::Boy::StalkerError)
+		
+		a.following_count.should eql(0)
+		b.follower_count.should eql(0)
+	
+		b.follow(a)
+		
+		a.follower_count.should eql(1)
+		b.following_count.should eql(1)
+		
+	end
+	
+	
+	it "should collect relationship personnel properly" do
+		a = FollowerClass.create
+		b = FollowerClass.create
+		c = FollowerClass.create
+		d = FollowerClass.create
+		e = FollowerClass.create
+		
+		a.follow(b)
+		b.follow(c)
+		a.follow(c)
+		c.follow(d)
+		e.follow(c)
+		
+		a.followers.empty?.should be_true
+		a.following.size.should eql(2)
+		a.following.sort{|m,n| m.id <=> n.id}.should eql([b,c])
+		
+		c.followers.size.should eql(3)
+		c.followers.sort{|m,n| m.id <=> n.id}.should eql([a,b,e])
+
+		a.extended_network.include?(d).should be_true
+		a.extended_network.include?(e).should be_false
+	end
+	
+	
+	class User < FollowerClass; end
+	class Business < FollowerClass; end
+	
+	
+	it "should handle STI properly" do 
+		u = User.create
+		b = Business.create
+		
+		u.follow(b)
+		
+		b.followers.first.class.name.should eql('User')
+		u.following.first.class.name.should eql('Business')
+	end
+	
+	it "should handle method_missing properly" do
+		u = User.create
+		b = Business.create
+		u2 = User.create
+		b2 = Business.create
+		
+		u.follow(u2)
+		u.follow(b)
+		u.follow(b2)
+
+		u.following.size.should eql(3)
+		u.following_businesses.size.should eql(2)
+		u.following_users.size.should eql(1)
+		
+		b.follow(u)
+		b.follow(u2)
+		b.follow(b2)
+		
+		b2.followers.size.should eql(2)
+		b2.user_followers.size.should eql(1)
+		b2.business_followers.size.should eql(1)
+		b2.follower_class_followers.size.should eql(2)
+		
+	end
+	
+end
+

data/spec/schema.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Schema.define :version => 0 do
+  
+	create_table :relationships, :force => true do |t|
+		t.references :requestor, :polymorphic => true, :null => false
+		t.references :requestee, :polymorphic => true, :null => false
+		t.boolean :restricted, :default => true
+		t.timestamps
+	end
+  
+	create_table :friend_classes, :force => true do |t|
+		t.timestamps
+	end
+  
+	create_table :follower_classes, :force => true do |t|
+		t.string :type
+		t.timestamps
+	end
+	
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--format specdoc
+--loadby mtime

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'party_boy'
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+require 'active_record'
+require "#{File.dirname(__FILE__)}/../generators/party_boy/templates/model"
+require 'models/follower_class'
+require 'models/friend_class'
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'mysql')
+ 
+load(File.dirname(__FILE__) + '/schema.rb')
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: party_boy
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mike Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-28 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: "Models relationships between AR models. Allows you to follow, friend, and block other AR's. Consists of two acts_as: acts_as_followable and acts_as_friend. These options allow an AR to inherit either a twitter-like follower system or a facebook-like friend system."
+email: mdnelson30@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- generators/party_boy/party_boy_generator.rb
+- generators/party_boy/templates/migration.rb
+- generators/party_boy/templates/model.rb
+- lib/party_boy.rb
+- social_lite.gemspec
+- spec/models/follower_class.rb
+- spec/models/friend_class.rb
+- spec/party_boy_spec.rb
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mnelson/party_boy
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Models relationships between AR models. Allows you to follow, friend, and block other AR's.
+test_files: 
+- spec/models/follower_class.rb
+- spec/models/friend_class.rb
+- spec/party_boy_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb