kabari-dm-is-friendly 0.9.11

data/.document

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

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Kabari Hendrick
+
+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.markdown

@@ -0,0 +1,63 @@
+# 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.
+
+## Installation ##
+
+Probably make sure you can use github gems first.
+
+$ sudo gem install kabari-dm-is-friendly.
+
+Create a file for the friendship (or whatever you want to call it) class. An example is below.
+
+## Example DataMapper resource (i.e. 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]
+
+    end
+    
+    # /app/models/person.rb
+    class Person
+      include DataMapper::Resource
+      property :id, Integer, :serial => true
+      property :name, String
+      
+      # you need this part
+      is :friendly
+    end
+    
+### 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
+
+      belongs_to :gangster, :child_key => [:gangster_id]
+      belongs_to :homie, :class_name => "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

@@ -0,0 +1,47 @@
+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 = "manbehindtheman@kabari.name"
+    gem.homepage = "http://github.com/kabari/dm-is-friendly"
+    gem.authors = ["Kabari Hendrick"]
+    gem.add_dependency("extlib", "~> #{version}")
+    gem.add_dependency("dm-core", "~> #{version}")
+    gem.add_dependency("dm-aggregates", "~> #{version}")
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo 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 :default => :spec
+
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "dm-is-friendly #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.9.11

data/dm-is-friendly.gemspec

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dm-is-friendly}
+  s.version = "0.9.11"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kabari Hendrick"]
+  s.date = %q{2009-06-15}
+  s.email = %q{manbehindtheman@kabari.name}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "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"
+  ]
+  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.3}
+  s.summary = %q{DataMapper plugin that adds self-referential friendship functionality to your models.}
+  s.test_files = [
+    "spec/dm-is-friendly_spec.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_runtime_dependency(%q<extlib>, ["~> 0.9.11"])
+      s.add_runtime_dependency(%q<dm-core>, ["~> 0.9.11"])
+      s.add_runtime_dependency(%q<dm-aggregates>, ["~> 0.9.11"])
+    else
+      s.add_dependency(%q<extlib>, ["~> 0.9.11"])
+      s.add_dependency(%q<dm-core>, ["~> 0.9.11"])
+      s.add_dependency(%q<dm-aggregates>, ["~> 0.9.11"])
+    end
+  else
+    s.add_dependency(%q<extlib>, ["~> 0.9.11"])
+    s.add_dependency(%q<dm-core>, ["~> 0.9.11"])
+    s.add_dependency(%q<dm-aggregates>, ["~> 0.9.11"])
+  end
+end

data/lib/dm-is-friendly.rb

@@ -0,0 +1,26 @@
+# Needed to import datamapper and other gems
+require 'rubygems'
+require 'pathname'
+
+# Add all external dependencies for the plugin here
+gem 'extlib', '~>0.9.11'
+require "extlib"
+
+gem 'dm-core', '~>0.9.11'
+require 'dm-core'
+
+gem 'dm-aggregates', '~>0.9.11'
+require "dm-aggregates"
+
+# Require plugin-files
+require Pathname(__FILE__).dirname.expand_path / 'is' / 'friendly'
+
+# Include the plugin in Resource
+# module DataMapper
+#   module Model
+#     include DataMapper::Is::Friendly
+#   end # module Model
+# end # module DataMapper
+
+# An alternative way to do the same thing as above:
+DataMapper::Model.append_extensions(DataMapper::Is::Friendly)

data/lib/is/friendly.rb

@@ -0,0 +1,159 @@
+# Home baked self-referential :through relationship
+module DataMapper
+  module Is
+    module Friendly
+      
+      def is_friendly(options = {})
+        options = {:require_acceptance => true, :friendship_class => "Friendship" }.merge(options)
+        @friendly_config = FriendlyConfig.new(self, options)
+        class << self; self; end.class_eval do
+          attr_reader :friendly_config      
+          def friendly_config; @friendly_config; end
+        end
+        
+        class_eval(<<-EOS,(__FILE__),(__LINE__)
+        has n, :friendships, :class_name => "#{friendly_config.friendship_class.name}"
+        has n, :friends_by_me, :through => :friendships, :class_name => "#{self.name}",
+                         :child_key => [:#{Extlib::Inflection.foreign_key(self.name)}]
+        has n, :friended_by, :through => :friendships, :class_name => "#{self.name}",
+                             :remote_name => "#{self.name.downcase}", :child_key => [:friend_id]
+        EOS
+        )
+        
+        # stuff like this didn't work as of DM 0.9.10, hence the mass amounts of hand ql queries
+        # returns all the people I have requested frienship from
+        # has n, :friendship_requests, :through => :friendships, :class_name => "Person",
+                                     # :child_key => [:person_id]
+        # returns all the people that have requested my friendship
+        # has n, :friendships_to_accept, :through => :friendships, :class_name => "Person",
+                                     # :remote_name => :person, :child_key => [:friend_id]
+        
+        include DataMapper::Is::Friendly::InstanceMethods
+      end
+      
+      class FriendlyConfig
+        attr_reader :friendship_class, :friend_class
+        
+        def initialize(klazz, opts)
+          @friendship_class = Object.full_const_get(opts[:friendship_class])
+          @friend_class = klazz
+          @require_acceptance = opts[:require_acceptance]
+        end
+      
+        def friendship_foreign_key
+          Extlib::Inflection.foreign_key(friend_class.name)
+        end
+      
+        def friend_foreign_key
+          Extlib::Inflection.foreign_key(friendship_class.name)
+        end
+        
+        def friend_table_name
+          Extlib::Inflection.tableize(friend_class.name)
+        end
+      
+        def friendship_table_name
+          Extlib::Inflection.tableize(friendship_class.name)
+        end
+              
+        def require_acceptance?
+          @require_acceptance
+        end   
+      end
+      
+      module InstanceMethods
+        
+        def friends
+          friends_sql = <<-SQL
+             SELECT #{friendly_config.friend_table_name}.* FROM #{friendly_config.friend_table_name} INNER JOIN #{friendly_config.friendship_table_name} 
+             ON #{friendly_config.friend_table_name}.id = #{friendly_config.friendship_table_name}.#{friendly_config.friendship_foreign_key} WHERE ((#{friendly_config.friendship_table_name}.friend_id = #{id}) #{acceptance_sql(true)})
+             UNION
+             SELECT #{friendly_config.friend_table_name}.* FROM #{friendly_config.friend_table_name} INNER JOIN #{friendly_config.friendship_table_name} 
+             ON #{friendly_config.friend_table_name}.id = #{friendly_config.friendship_table_name}.friend_id WHERE ((#{friendly_config.friendship_table_name}.#{friendly_config.friendship_foreign_key} = #{id}) #{acceptance_sql(true)})
+          SQL
+          
+          self.class.find_by_sql(friends_sql)
+        end
+        
+        # returns all the people I have requested frienship from
+        def friendship_requests(friend = nil)
+          sql = [%{SELECT #{friendly_config.friend_table_name}.* FROM #{friendly_config.friend_table_name} INNER JOIN #{friendly_config.friendship_table_name}}]
+          sql << %{ON #{friendly_config.friend_table_name}.id = #{friendly_config.friendship_table_name}.friend_id}
+          sql << %{WHERE ((#{friendly_config.friendship_table_name}.#{friendly_config.friendship_foreign_key} = #{id}) #{acceptance_sql}}
+          sql << select_friendship_sql(friend) if friend
+          sql << ") #{'LIMIT 1' if friend}"
+          self.class.find_by_sql(sql.join(' '))
+        end
+        
+        # returns all the people that have requested my friendship
+        def friendships_to_accept(friend = nil)
+          sql = [%{SELECT #{friendly_config.friend_table_name}.* FROM #{friendly_config.friend_table_name} INNER JOIN #{friendly_config.friendship_table_name}}]
+          sql << %{ON #{friendly_config.friend_table_name}.id = #{friendly_config.friendship_table_name}.#{friendly_config.friendship_foreign_key}} 
+          sql << %{WHERE ((#{friendly_config.friendship_table_name}.friend_id = #{id}) #{acceptance_sql}}
+          sql << select_friendship_sql(friend,true) if friend
+          sql << ") #{'LIMIT 1' if friend}"
+          self.class.find_by_sql(sql.join(' '))
+        end
+        
+        # see if there is a pending friendship request from this person to another
+        def friendship_requested?(friend)
+          # return false unless friendly_config.require_acceptance?
+          !friendship_requests(friend).empty? #.detect{|f| f.friend_id = friend.id} #.first('friendships.friend_id' => friend.id)
+        end
+        
+        # see if user has a friend request to accept from this person
+        def friendship_to_accept?(friend)
+          return false unless friendly_config.require_acceptance?
+          !friendships_to_accept(friend).empty? #first('friendships.person_id' => friend.id)
+        end
+
+        # Accepts a user object and returns true if both users are
+        # friends and the friendship has been accepted.
+        def is_friends_with?(friend)
+          !self.friendship(friend).nil?
+        end        
+        
+        # request friendship from "friend"
+        def request_friendship(friend)
+          return false if friendship(friend)
+          self.friendships.create(:friend => friend)
+        end
+        
+        # Accepts a user object and updates an existing friendship to
+        # be accepted.
+        def confirm_friendship_with(friend)
+          self.friendship(friend,{:accepted_at => nil}).update_attributes({:accepted_at => Time.now})
+          # reload so old relationship won't be lingering
+          friend.reload
+          self.reload
+        end
+
+        # Accepts a user object and deletes a friendship between both 
+        # users.
+        def end_friendship_with(friend)
+          self.friendship(friend).destroy if self.is_friends_with?(friend)
+        end
+        
+        protected
+        # Accepts a user object and returns the friendship object 
+        # associated with both users.
+        def friendship(friend, opts = {})
+          friendly_config.friendship_class.first({:conditions => ["(#{friendly_config.friendship_foreign_key} = ? AND friend_id = ?) OR (friend_id = ? AND #{friendly_config.friendship_foreign_key} = ?)", self.id, friend.id, self.id, friend.id]}.merge(opts) )
+        end
+        
+        def friendly_config; self.class.friendly_config; end                
+        
+        private
+        def acceptance_sql(accepted = false)
+          "AND #{friendly_config.friendship_table_name}.accepted_at IS #{accepted ? 'NOT' : ''} NULL" if friendly_config.require_acceptance?
+        end
+        
+        # because of DM bug in 0.9.10
+        def select_friendship_sql(friend, for_me = false)
+          "AND #{friendly_config.friendship_table_name}.#{for_me ? friendly_config.friendship_foreign_key : 'friend_id'} = #{friend.id}"
+        end
+        
+      end
+    end # Friendly
+  end # Is
+end # DataMapper

data/lib/is/version.rb

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

data/spec/dm-is-friendly_spec.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class Friendship
+  include DataMapper::Resource
+  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]
+  
+end
+
+class Person
+  include DataMapper::Resource
+  property :id, Integer, :serial => true
+  property :name, String
+  is :friendly
+end
+
+
+describe 'DataMapper::Is::Friendly' do
+  before(:all) do
+    Friendship.auto_migrate!; Person.auto_migrate!
+  end
+  
+  it "should have proper config" do
+    Person.friendly_config.friendship_class.should == Friendship
+    Person.friendly_config.friend_class.should     == Person
+    Person.friendly_config.friendship_foreign_key.should == "person_id"
+    Person.friendly_config.friend_table_name.should == "people"
+    Person.friendly_config.friendship_table_name.should == "friendships"
+    Person.friendly_config.require_acceptance?.should == true
+  end
+end
+
+describe 'DataMapper::Is::Friendly', "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
+    
+  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 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 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)
+
+    # 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
+      
+  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 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.friends.should_not include(@joe)
+    @joe.friends.should_not include(@quentin)
+  end
+  
+end
+
+# new classes
+class Homie
+  include DataMapper::Resource
+  property :gangster_id, Integer, :key => true
+  property :friend_id, Integer, :key => true
+  
+  belongs_to :gangster, :child_key => [:gangster_id]
+  belongs_to :friend, :class_name => "Gangster", :child_key => [:friend_id]
+  
+end
+
+class Gangster
+  include DataMapper::Resource
+  property :id, Integer, :serial => true
+  property :name, String
+  is :friendly, :friendship_class => "Homie", :require_acceptance => false
+end
+
+describe 'DataMapper::Is::Friendly', "with changed options" 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
+    
+  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 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 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 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.friends.should_not include(@joe)
+    @joe.friends.should_not include(@quentin)
+  end
+  
+end

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'pathname'
+require 'rubygems'
+
+gem 'rspec', '~>1.2.6'
+require 'spec'
+
+require Pathname(__FILE__).dirname.expand_path.parent + 'lib/dm-is-friendly'
+
+def load_driver(name, default_uri)
+  return false if ENV['ADAPTER'] != name.to_s
+
+  begin
+    DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
+    DataMapper::Repository.adapters[:default] = DataMapper::Repository.adapters[name]
+    true
+  rescue LoadError => e
+    warn "Could not load do_#{name}: #{e}"
+    false
+  end
+end
+
+ENV['ADAPTER'] ||= 'sqlite3'
+
+HAS_SQLITE3  = load_driver(:sqlite3,  'sqlite3::memory:')
+HAS_MYSQL    = load_driver(:mysql,    'mysql://localhost/dm_core_test')
+HAS_POSTGRES = load_driver(:postgres, 'postgres://postgres@localhost/dm_core_test')

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: kabari-dm-is-friendly
+version: !ruby/object:Gem::Version 
+  version: 0.9.11
+platform: ruby
+authors: 
+- Kabari Hendrick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.11
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.11
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-aggregates
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.11
+    version: 
+description: 
+email: manbehindtheman@kabari.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- 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
+has_rdoc: false
+homepage: http://github.com/kabari/dm-is-friendly
+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.2.0
+signing_key: 
+specification_version: 3
+summary: DataMapper plugin that adds self-referential friendship functionality to your models.
+test_files: 
+- spec/dm-is-friendly_spec.rb
+- spec/spec_helper.rb