dm-is-friendly 0.10.2 → 0.10.25

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Kabari Hendrick
+Copyright (c) 2010 Kabari Hendrick
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -1,63 +1,75 @@
-# dm-is-friendly #
+dm-is-friendly
+==============
 
 DataMapper plugin that adds self-referential friendship functionality to your models.
 
-**Note: This is NOT officially part of the DataMapper (dm-core, dm-more) project, it just works with DataMapper.
-
 ## Why is this plugin useful? ##
 
-If you're building a social app, it will probably save you 12 minutes, tops.
+If you're building an app that require this type of relation then it will probably save some time to use this instead of rolling our own :)
 
 ## Installation ##
 
-Probably make sure you can use github gems first.
-
-$ sudo gem install kabari-dm-is-friendly.
+    $ [sudo] gem install dm-is-friendly.
 
-Create a file for the friendship (or whatever you want to call it) class. An example is below.
+Create a file for the friendship (or whatever you want to call it) class.
 
-## Example DataMapper resource (i.e. model) ##
+## Example DataMapper model ##
 
-    # /app/models/friendship.rb
     class Friendship
       include DataMapper::Resource
-      
-      # you need all of this
       property :person_id, Integer, :key => true
       property :friend_id, Integer, :key => true
-      property :accepted_at, DateTime, :nullable => true
-
-      belongs_to :person, :child_key => [:person_id]
-      belongs_to :friend, :class_name => "Person", :child_key => [:friend_id]
-
+      property :accepted_at, DateTime
+  
+      belongs_to :person
+      belongs_to :friend, :model => "Person", :child_key => [:friend_id]
+  
     end
-    
-    # /app/models/person.rb
+
     class Person
       include DataMapper::Resource
-      property :id, Integer, :serial => true
+      property :id, Serial
       property :name, String
-      
-      # you need this part
-      is :friendly
+  
+      is :friendly #, :friendship_class => "Friendship", :require_acceptance => true
     end
+
+## Use It ##
+
+    @quentin = Person.create(:name => "quentin")
+    @joe     = Person.create(:name => "joe")
     
-### There are options ###
-  
-    # /some/folder/homie.rb
-    class Homie
-      property :gangster_id, Integer, :key => true
-      property :friend_id, Integer, :key => true
-      property :accepted_at, DateTime, :nullable => true
+    # request friendship
+    @joe.request_friendship(@quentin)
+    
+    # Find friend requests sent
+    @joe.friendship_requests              # => [#<Person @id=1 @name="quentin">]
+    @joe.friendship_requested?(@quentin)  # => true
+    
+    # Find recieve friend requests
+    @quentin.friendships_to_accept       # => [#<Person @id=2 @name="joe">]
+    @quentin.friendship_to_accept?(@joe) # => true
+    
+    # Check friendships
+    @quentin.is_friends_with?(@joe) # => false
+    
+    # Accept friendships
+    @quentin.confirm_friendship_with(@joe)
+    @quentin.is_friends_with?(@joe) # => true
+    
+    # End friendships :(
+    @quentin.end_friendship_with(@joe) # => true
+    
+### Options ###
+
+**:require_acceptance**
+Set this if friendships should be accepted before showing up in the query of friends.
+Default: true
+**Must provide the :accepted_at Property*
+
+**:friendship_class**
+Set this to something other than "Friendship" if you want.
+Default: "Friendship"
 
-      belongs_to :gangster
-      belongs_to :homie, :child_key => [:friend_id]
-    end
 
-    # /some/folder/gangster.rb
-    class Gangster
-      is :friendly, :friendship_class => "Homie", :require_acceptance => false
-    end
-  
-This would change the friendship class to Homie, and make it not require friendships to be accepted. I admit, it was kind of dumb to do it that way, but I just made this into a gem so that it wasn't lying around my code base. I'll make it more useful in the next run.
 

data/Rakefile

@@ -1,20 +1,17 @@
 require 'rubygems'
 require 'rake'
-require File.join(File.dirname(__FILE__), *%w[lib is version])
-
-version = DataMapper::Is::Friendly::VERSION
 
 begin
   require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "dm-is-friendly"
-    gem.summary = %Q{DataMapper plugin that adds self-referential friendship functionality to your models.}
-    gem.email = "kabari@gmail.com"
-    gem.homepage = "http://github.com/kabari/dm-is-friendly"
-    gem.authors = ["Kabari Hendrick"]
-    gem.add_dependency("extlib", "~> 0.9.14")
-    gem.add_dependency("dm-core", "~> #{version}")
-    gem.add_dependency("dm-aggregates", "~> #{version}")
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "dm-is-friendly"
+    gemspec.summary = %Q{DataMapper plugin that adds self-referential friendship functionality to your models.}
+    gemspec.email = "kabari@gmail.com"
+    gemspec.homepage = "http://github.com/kabari/dm-is-friendly"
+    gemspec.authors = ["Kabari Hendrick"]
+    gemspec.add_dependency("extlib", "~> 0.9.14")
+    gemspec.add_dependency("dm-core", "~> 0.10.2")
+    gemspec.add_dependency("dm-aggregates", "~> 0.10.2")
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -40,8 +37,18 @@ require 'rake/rdoctask'
 
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "dm-is-friendly #{version}"
+  rdoc.title = "dm-is-friendly 0.10.21"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |t|
+    t.files   = ['lib/**/*.rb', 'README.markdown', 'LICENSE']
+  end
+rescue LoadError
+  task :yard do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -1 +1 @@
-0.10.2
+0.10.25

data/dm-is-friendly.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dm-is-friendly}
-  s.version = "0.10.2"
+  s.version = "0.10.25"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kabari Hendrick"]
-  s.date = %q{2010-01-11}
+  s.date = %q{2010-03-14}
   s.email = %q{kabari@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -25,7 +25,6 @@ Gem::Specification.new do |s|
      "dm-is-friendly.gemspec",
      "lib/dm-is-friendly.rb",
      "lib/is/friendly.rb",
-     "lib/is/version.rb",
      "spec/dm-is-friendly_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"
@@ -33,7 +32,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/kabari/dm-is-friendly}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{DataMapper plugin that adds self-referential friendship functionality to your models.}
   s.test_files = [
     "spec/dm-is-friendly_spec.rb",

data/lib/dm-is-friendly.rb

@@ -1,17 +1,5 @@
-# Needed to import datamapper and other gems
-require 'rubygems'
 require 'pathname'
 
-# Add all external dependencies for the plugin here
-gem 'extlib', '~>0.9.14'
-require "extlib"
-
-gem 'dm-core', '~>0.10.2'
-require 'dm-core'
-
-gem 'dm-aggregates', '~>0.10.2'
-require "dm-aggregates"
-
 # Require plugin-files
 require Pathname(__FILE__).dirname.expand_path / 'is' / 'friendly'
 

data/lib/is/friendly.rb

@@ -43,39 +43,47 @@ module DataMapper
       module InstanceMethods
         
         # returns all of the friends this person has that are accepted
+        # @return [DataMapper::Collection] All the person's friends
         def friends
           friendship_requests(nil,true).union(friendships_to_accept(nil,true))
         end
                 
         # returns all the people I have requested frienship from
+        # @param friend (nil)
+        # @param include_accepted (false)
+        # @return [DataMapper::Collection] All the people that the person has sent friendship requests to
         def friendship_requests(friend = nil, include_accepted = false)
           conditions = {}
           friend_acceptance_condition(conditions, include_accepted)
           friend_scope_condition(conditions, friend)
           
           conditions[friendly_options.friendship_foreign_key] = self.id
-          ids = friendly_options.friendship_class.all(conditions).collect(&:friend_id)
-          self.class.all( :id => ids)
+          friendly_options.friendship_class.all(conditions).friend
         end
                 
         # returns all the people that have requested my friendship
+        # @param friend (nil)
+        # @param include_accepted (false)
+        # @return [DataMapper::Collection] All the people that have requested friendship
         def friendships_to_accept(friend = nil, include_accepted = false)
           conditions = {}
           friend_acceptance_condition(conditions, include_accepted)
           friend_scope_condition(conditions, friend, true)
           
-          conditions[:friend_id] = self.id
-          ids = friendly_options.friendship_class.all(conditions).collect(&friendly_options.friendship_foreign_key)
-          self.class.all(:id => ids)
+          conditions[:friend_id] = self.id                      
+          friendly_options.friendship_class.all(conditions).send(friendly_options.friend_class.name.downcase)
         end
         
         # see if there is a pending friendship request from this person to another
+        # @param friend
+        # @return [true, false]
         def friendship_requested?(friend)
-          # return false unless friendly_options.require_acceptance?
           !friendship_requests(friend).empty?
         end
         
         # see if user has a friend request to accept from this person
+        # @param friend
+        # @return [true, false]
         def friendship_to_accept?(friend)
           return false unless friendly_options.require_acceptance?
           !friendships_to_accept(friend).empty?
@@ -83,17 +91,23 @@ module DataMapper
 
         # Accepts a user object and returns true if both users are
         # friends and the friendship has been accepted.
+        # @param friend
+        # @return [true, false]
         def is_friends_with?(friend)
           !self.friendship(friend).nil?
         end        
         
         # request friendship from "friend"
+        # @param friend The friend who's friendship is being requested
+        # @return The instance of the friendship_class
         def request_friendship(friend)
           return false if friendship(friend)
           self.friendships.create(:friend => friend)
         end
         
         # Accepts a user  and updates an existing friendship to be accepted.
+        # @param friend The friend that needs to be confirmed
+        # @return [self]
         def confirm_friendship_with(friend)
           self.friendship(friend,{:accepted_at => nil}).update({:accepted_at => Time.now})
           # reload so old relationship won't be lingering in the IdentityMap
@@ -102,12 +116,14 @@ module DataMapper
         end
 
         # Accepts a user and deletes a friendship between both users.
+        # @param friend The friend who's friendship will now end
+        # @return [true, false] Outcome of model.destroy
         def end_friendship_with(friend)
           self.friendship(friend).destroy if self.is_friends_with?(friend)
         end
         
         protected
-        # Accepts a user and returns the friendship associated with both users.
+        # Accepts a user and returns the friendship instance associated with both users.
         def friendship(friend, opts = {})
           friendly_options.friendship_class.first({:conditions => ["(#{friendly_options.friendship_foreign_key} = ? AND friend_id = ?) OR (friend_id = ? AND #{friendly_options.friendship_foreign_key} = ?)", self.id, friend.id, self.id, friend.id]}.merge(opts) )
         end

data/spec/dm-is-friendly_spec.rb

@@ -4,7 +4,7 @@ class Friendship
   include DataMapper::Resource
   property :person_id, Integer, :key => true
   property :friend_id, Integer, :key => true
-  property :accepted_at, DateTime, :required => false
+  property :accepted_at, DateTime
   
   belongs_to :person
   belongs_to :friend, :model => "Person", :child_key => [:friend_id]
@@ -15,175 +15,179 @@ class Person
   include DataMapper::Resource
   property :id, Serial
   property :name, String
+  property :deleted_at, ParanoidDateTime
   
   is :friendly
 end
 
+# new classes
+class Homie
+  include DataMapper::Resource
+  property :gangster_id, Integer, :key => true
+  property :friend_id, Integer, :key => true
+
+  belongs_to :gangster
+  belongs_to :friend, :model => "Gangster", :child_key => [:friend_id]
+
+end
+
+class Gangster
+  include DataMapper::Resource
+  property :id, Serial
+  property :name, String
+  is :friendly, :friendship_class => "Homie", :require_acceptance => false
+end
+
 describe 'DataMapper::Is::Friendly' do
-  before(:all) do
-    Friendship.auto_migrate!; Person.auto_migrate!
-  end
+  with_adapters do
+    before(:all) do
+      Friendship.auto_migrate!; Person.auto_migrate!
+    end
   
-  it "should have proper options set" do
-    Person.friendly_options.friendship_class.should == Friendship
-    Person.friendly_options.friend_class.should     == Person
-    Person.friendly_options.friendship_foreign_key.should == :person_id
-    Person.friendly_options.require_acceptance?.should == true
-  end
-end
+    it "should have proper options set" do
+      Person.friendly_options.friendship_class.should == Friendship
+      Person.friendly_options.friend_class.should     == Person
+      Person.friendly_options.friendship_foreign_key.should == :person_id
+      Person.friendly_options.require_acceptance?.should == true
+    end
 
-describe 'DataMapper::Is::Friendly', "with friendships" do
-  before(:all) do
-    Friendship.auto_migrate!; Person.auto_migrate!
+    describe "with friendships" do
+      before(:all) do
+        Friendship.auto_migrate!; Person.auto_migrate!
     
-    @quentin = Person.create(:name => "quentin")
-    @aaron = Person.create(:name => "aaron") # state: "pending"
-    @joe = Person.create(:name => "joe")
-  end
+        @quentin = Person.create(:name => "quentin")
+        @aaron = Person.create(:name => "aaron") # state: "pending"
+        @joe = Person.create(:name => "joe")
+      end
     
-  it "should work" do
-    lambda do
-      @joe.request_friendship(@quentin)
-    end.should change(Friendship, :count).by(1)
-  end
+      it "should work" do
+        lambda do
+          @joe.request_friendship(@quentin)
+        end.should change(Friendship, :count).by(1)
+      end
   
-  it "should only recognize friends that are confirmed" do
-    @joe.friends.should_not include(@quentin)
-    @quentin.friends.should_not include(@joe)
-  end
+      it "should only recognize friends that are confirmed" do
+        @joe.friends.should_not include(@quentin)
+        @quentin.friends.should_not include(@joe)
+      end
 
-  it "should set the proper relationships" do
-    # see if associations are correct
-    log("@quention.friendship_requests")
-    @quentin.friendship_requests.should_not include(@joe)
-    log("@joe.friendship_requests")
-    @joe.friendship_requests.should include(@quentin)
-    log("@quention.friendships_to_accept")
-    @quentin.friendships_to_accept.should include(@joe)
-    log("@joe.friendships_to_accept")
-    @joe.friendships_to_accept.should_not include(@quentin)
-  end
+      it "should set the proper relationships" do
+        # see if associations are correct
+        log("@quention.friendship_requests")
+        @quentin.friendship_requests.should_not include(@joe)
+        log("@joe.friendship_requests")
+        @joe.friendship_requests.should include(@quentin)
+        log("@quention.friendships_to_accept")
+        @quentin.friendships_to_accept.should include(@joe)
+        log("@joe.friendships_to_accept")
+        @joe.friendships_to_accept.should_not include(@quentin)
+      end
   
-  it "should also work with convenience methods" do
-    @quentin.friendship_to_accept?(@joe).should be_true
-    @joe.friendship_requested?(@quentin).should be_true      
-  end
+      it "should also work with convenience methods" do
+        @quentin.friendship_to_accept?(@joe).should be_true
+        @joe.friendship_requested?(@quentin).should be_true      
+      end
   
-  it "should have to be confirmed" do
-    # confirm the request
-    @quentin.confirm_friendship_with(@joe)
+      it "should have to be confirmed" do
+        # confirm the request
+        @quentin.confirm_friendship_with(@joe)
 
-    # see if associations are correct
-    @quentin.friends.should include(@joe)
-    @joe.friends.should include(@quentin)
+        # see if associations are correct
+        @quentin.friends.should include(@joe)
+        @joe.friends.should include(@quentin)
     
-    @quentin.friendship_to_accept?(@joe).should be_false
-    @joe.friendship_requested?(@quentin).should be_false
-  end
+        @quentin.friendship_to_accept?(@joe).should be_false
+        @joe.friendship_requested?(@quentin).should be_false
+      end
       
-  it "should not be added twice" do
-    lambda do
-      @joe.request_friendship(@quentin)
-      @joe.should have(1).friends
-      @quentin.should have(1).friends
-    end.should_not change(Friendship,:count)
-  end
+      it "should not be added twice" do
+        lambda do
+          @joe.request_friendship(@quentin)
+          @joe.should have(1).friends
+          @quentin.should have(1).friends
+        end.should_not change(Friendship,:count)
+      end
 
-  it "should be able to have multiple friends" do
-    @joe.request_friendship(@aaron)
-    @joe.friendship_requested?(@aaron).should be_true
-    @aaron.friendship_to_accept?(@joe).should be_true
-  end
+      it "should be able to have multiple friends" do
+        @joe.request_friendship(@aaron)
+        @joe.friendship_requested?(@aaron).should be_true
+        @aaron.friendship_to_accept?(@joe).should be_true
+      end
   
-  it "should be able to delete friendships" do
-    lambda do
-      # joe sleeps with quentin's wife perhaps
-      @quentin.end_friendship_with(@joe)
-    end.should change(Friendship,:count)
+      it "should be able to delete friendships" do
+        lambda do
+          # joe sleeps with quentin's wife perhaps
+          @quentin.end_friendship_with(@joe)
+        end.should change(Friendship,:count)
     
-    @quentin.reload; @joe.reload
+        @quentin.reload; @joe.reload
     
-    @quentin.friends.should_not include(@joe)
-    @joe.friends.should_not include(@quentin)
-  end
+        @quentin.friends.should_not include(@joe)
+        @joe.friends.should_not include(@quentin)
+      end
   
-end
+    end
 
-# new classes
-class Homie
-  include DataMapper::Resource
-  property :gangster_id, Integer, :key => true
-  property :friend_id, Integer, :key => true
-  
-  belongs_to :gangster
-  belongs_to :friend, :model => "Gangster", :child_key => [:friend_id]
-  
-end
 
-class Gangster
-  include DataMapper::Resource
-  property :id, Serial
-  property :name, String
-  is :friendly, :friendship_class => "Homie", :require_acceptance => false
-end
-
-describe 'DataMapper::Is::Friendly', "without requiring acceptance" do
-  before(:all) do
-    Homie.auto_migrate!; Gangster.auto_migrate!
+    describe "without requiring acceptance" do
+      before(:all) do
+        Homie.auto_migrate!; Gangster.auto_migrate!
     
-    @quentin = Gangster.create(:name => "quentin")
-    @aaron = Gangster.create(:name => "aaron") # state: "pending"
-    @joe = Gangster.create(:name => "joe")
-  end
+        @quentin = Gangster.create(:name => "quentin")
+        @aaron = Gangster.create(:name => "aaron") # state: "pending"
+        @joe = Gangster.create(:name => "joe")
+      end
     
-  it "should work" do
-    lambda do
-      @joe.request_friendship(@quentin)
-    end.should change(Homie, :count).by(1)
-  end
+      it "should work" do
+        lambda do
+          @joe.request_friendship(@quentin)
+        end.should change(Homie, :count).by(1)
+      end
   
-  it "should recognize every friend request" do
-    @joe.friends.should include(@quentin)
-    @quentin.friends.should include(@joe)
-  end
+      it "should recognize every friend request" do
+        @joe.friends.should include(@quentin)
+        @quentin.friends.should include(@joe)
+      end
 
-  it "should set the proper relationships" do
-    # see if associations are correct
-    @quentin.friendship_requests.should_not include(@joe)
-    @joe.friendship_requests.should include(@quentin)
-    @quentin.friendships_to_accept.should include(@joe)
-    @joe.friendships_to_accept.should_not include(@quentin)
-  end
+      it "should set the proper relationships" do
+        # see if associations are correct
+        @quentin.friendship_requests.should_not include(@joe)
+        @joe.friendship_requests.should include(@quentin)
+        @quentin.friendships_to_accept.should include(@joe)
+        @joe.friendships_to_accept.should_not include(@quentin)
+      end
   
-  it "should not need acceptance" do
-    @quentin.friendship_to_accept?(@joe).should be_false
-    @joe.friendship_requested?(@quentin).should be_true     
-  end
+      it "should not need acceptance" do
+        @quentin.friendship_to_accept?(@joe).should be_false
+        @joe.friendship_requested?(@quentin).should be_true     
+      end
         
-  it "should not be added twice" do
-    lambda do
-      @joe.request_friendship(@quentin)
-      @joe.should have(1).friends
-      @quentin.should have(1).friends
-    end.should_not change(Homie,:count)
-  end
+      it "should not be added twice" do
+        lambda do
+          @joe.request_friendship(@quentin)
+          @joe.should have(1).friends
+          @quentin.should have(1).friends
+        end.should_not change(Homie,:count)
+      end
 
-  it "should be able to have multiple friends" do
-    @joe.request_friendship(@aaron)
-    @joe.friendship_requested?(@aaron).should be_true
-    @aaron.friendship_to_accept?(@joe).should be_false
-  end
+      it "should be able to have multiple friends" do
+        @joe.request_friendship(@aaron)
+        @joe.friendship_requested?(@aaron).should be_true
+        @aaron.friendship_to_accept?(@joe).should be_false
+      end
   
-  it "should be able to delete friendships" do
-    lambda do
-      # joe sleeps with quentin's wife perhaps
-      @quentin.end_friendship_with(@joe)
-    end.should change(Homie,:count)
+      it "should be able to delete friendships" do
+        lambda do
+          # joe sleeps with quentin's wife perhaps
+          @quentin.end_friendship_with(@joe)
+        end.should change(Homie,:count)
     
-    @quentin.reload; @joe.reload
+        @quentin.reload; @joe.reload
     
-    @quentin.friends.should_not include(@joe)
-    @joe.friends.should_not include(@quentin)
-  end
+        @quentin.friends.should_not include(@joe)
+        @joe.friends.should_not include(@quentin)
+      end
   
-end
+    end
+  end
+end

data/spec/spec.opts

@@ -1,3 +1,2 @@
 --colour
---format progress
---loadby mtime
+--format nested

data/spec/spec_helper.rb

@@ -1,19 +1,28 @@
-# path to my git clones of the latest dm-core
+# path to my git clones of the latest dm-core and extlib
 $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), *%w[.. ..]))
 
 require 'pathname'
 require 'rubygems'
-
-gem 'rspec', '~>1.2.9'
 require 'spec'
 
+# Add all external dependencies for the plugin here
+gem 'extlib', '~>0.9.14'
+require "extlib"
+
+gem 'dm-core', '~>0.10.2'
+require 'dm-core'
+
+gem 'dm-aggregates', '~>0.10.2'
+require "dm-aggregates"
+
 require Pathname(__FILE__).dirname.expand_path.parent + 'lib/dm-is-friendly'
 
 DataMapper::Logger.new("test.log", :debug)
+# DataMapper.logger.auto_flush = true
 
 def load_driver(name, default_uri)
-  return false if ENV['ADAPTER'] != name.to_s
-
+  return false unless DRIVERS[name]
+  
   begin
     DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
     DataMapper::Repository.adapters[:default] = DataMapper::Repository.adapters[name]
@@ -24,12 +33,31 @@ def load_driver(name, default_uri)
   end
 end
 
-ENV['ADAPTER'] ||= 'sqlite3'
-
-HAS_SQLITE3  = load_driver(:sqlite3,  'sqlite3::memory:')
-HAS_MYSQL    = load_driver(:mysql,    'mysql://localhost/dm_is_friendly_test')
-HAS_POSTGRES = load_driver(:postgres, 'postgres://postgres@localhost/dm_is_friendly_test')
+ENV['ADAPTERS'] ||= 'sqlite3 mysql'
+
+DRIVERS = { 
+  :sqlite3  => 'sqlite3::memory:',
+  :mysql    => 'mysql://root:pass@localhost/dm_is_friendly_test',
+  :postgres => 'postgres://postgres@localhost/dm_is_friendly_test'
+}
+
+ADAPTERS = ENV["ADAPTERS"].split(' ')
+
+module SpecAdapterHelper
+  def with_adapters(&block)
+    ::ADAPTERS.each do |adapter|
+      describe "with #{adapter} adapter" do
+        before(:all) do
+          load_driver(adapter.to_sym, ::DRIVERS[adapter.to_sym])
+        end
+        
+        instance_eval(&block)
+      end
+    end
+  end
+end
 
 Spec::Runner.configure do |conf|
   def log(msg); DataMapper.logger.push("****** #{msg}"); end
-end
+  conf.extend(SpecAdapterHelper)
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: dm-is-friendly
 version: !ruby/object:Gem::Version 
-  version: 0.10.2
+  prerelease: false
+  segments: 
+  - 0
+  - 10
+  - 25
+  version: 0.10.25
 platform: ruby
 authors: 
 - Kabari Hendrick
@@ -9,39 +14,51 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-11 00:00:00 -06:00
+date: 2010-03-14 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: extlib
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 14
         version: 0.9.14
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: dm-core
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 2
         version: 0.10.2
-    version: 
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: dm-aggregates
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 2
         version: 0.10.2
-    version: 
+  type: :runtime
+  version_requirements: *id003
 description: 
 email: kabari@gmail.com
 executables: []
@@ -61,7 +78,6 @@ files:
 - dm-is-friendly.gemspec
 - lib/dm-is-friendly.rb
 - lib/is/friendly.rb
-- lib/is/version.rb
 - spec/dm-is-friendly_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -78,18 +94,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: DataMapper plugin that adds self-referential friendship functionality to your models.

data/lib/is/version.rb

@@ -1,10 +0,0 @@
-require "yaml"
-
-module DataMapper
-  module Is
-    module Friendly
-      # this is silly...
-      VERSION = File.open(File.join(File.dirname(__FILE__), *%w[.. .. VERSION])) { |file| YAML.load(file) }
-    end
-  end
-end