dm-is-friendly 0.10.2

data/.document

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

data/.gitignore

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

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
+      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

@@ -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 = "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}")
+  end
+  Jeweler::GemcutterTasks.new
+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.10.2

data/dm-is-friendly.gemspec

@@ -0,0 +1,62 @@
+# 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{dm-is-friendly}
+  s.version = "0.10.2"
+
+  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.email = %q{kabari@gmail.com}
+  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.5}
+  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.14"])
+      s.add_runtime_dependency(%q<dm-core>, ["~> 0.10.2"])
+      s.add_runtime_dependency(%q<dm-aggregates>, ["~> 0.10.2"])
+    else
+      s.add_dependency(%q<extlib>, ["~> 0.9.14"])
+      s.add_dependency(%q<dm-core>, ["~> 0.10.2"])
+      s.add_dependency(%q<dm-aggregates>, ["~> 0.10.2"])
+    end
+  else
+    s.add_dependency(%q<extlib>, ["~> 0.9.14"])
+    s.add_dependency(%q<dm-core>, ["~> 0.10.2"])
+    s.add_dependency(%q<dm-aggregates>, ["~> 0.10.2"])
+  end
+end
+

data/lib/dm-is-friendly.rb

@@ -0,0 +1,19 @@
+# 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'
+
+# Include the plugin in Model
+DataMapper::Model.append_extensions(DataMapper::Is::Friendly)

data/lib/is/friendly.rb

@@ -0,0 +1,131 @@
+# 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_options = FriendlyConfig.new(self, options)        
+        def self.friendly_options; @friendly_options; end
+        
+        class_eval(<<-RUBY,(__FILE__),(__LINE__+1)
+        has n, :friendships, :model => #{options[:friendship_class]}
+        has n, :friends_by_me, :through => :friendships, :model => "#{self.name}", :via => :#{self.name.downcase}
+        has n, :friended_by, :through => :friendships, :model => "#{self.name}",
+                             :via => :#{self.name.downcase}
+        RUBY
+        )
+        
+        include DataMapper::Is::Friendly::InstanceMethods
+      end
+      
+      # This class holds the configuration options for the plugin.
+      class FriendlyConfig
+        attr_reader :friend_class, :friendship_foreign_key, :friend_foreign_key
+        
+        def initialize(klazz, opts)
+          @friend_class           = klazz
+          @friendship_class_name  = opts[:friendship_class]
+          @friendship_foreign_key = Extlib::Inflection.foreign_key(@friend_class.name).to_sym
+          @friend_foreign_key     = Extlib::Inflection.foreign_key(@friendship_class_name).to_sym
+          @require_acceptance     = opts[:require_acceptance]
+        end
+        
+        def friendship_class
+          Object.full_const_get(@friendship_class_name)
+        end
+        
+        def require_acceptance?
+          @require_acceptance
+        end   
+      end
+      
+      module InstanceMethods
+        
+        # returns all of the friends this person has that are accepted
+        def friends
+          friendship_requests(nil,true).union(friendships_to_accept(nil,true))
+        end
+                
+        # returns all the people I have requested frienship from
+        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)
+        end
+                
+        # returns all the people that have requested my 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)
+        end
+        
+        # see if there is a pending friendship request from this person to another
+        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
+        def friendship_to_accept?(friend)
+          return false unless friendly_options.require_acceptance?
+          !friendships_to_accept(friend).empty?
+        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  and updates an existing friendship to be accepted.
+        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
+          friend.reload
+          self.reload
+        end
+
+        # Accepts a user 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 and returns the friendship 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
+        
+        def friendly_options; self.class.friendly_options; end                
+        
+        private
+        def friend_acceptance_condition(conditions, accepted = false)
+          accepted ? (conditions[:accepted_at.not] = nil) : (conditions[:accepted_at] = nil) if friendly_options.require_acceptance?
+        end
+        
+        def friend_scope_condition(conditions, friend = nil, for_me = false)
+          return unless friend
+          key_name = for_me ? friendly_options.friendship_foreign_key : :friend_id
+          conditions[key_name] = friend.id
+          conditions[:limit] = 1
+        end
+      end
+    end # Friendly
+  end # Is
+end # DataMapper

data/lib/is/version.rb

@@ -0,0 +1,10 @@
+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

data/spec/dm-is-friendly_spec.rb

@@ -0,0 +1,189 @@
+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, :required => false
+  
+  belongs_to :person
+  belongs_to :friend, :model => "Person", :child_key => [:friend_id]
+  
+end
+
+class Person
+  include DataMapper::Resource
+  property :id, Serial
+  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 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
+
+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
+    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 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
+  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!
+    
+    @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,35 @@
+# path to my git clones of the latest dm-core
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), *%w[.. ..]))
+
+require 'pathname'
+require 'rubygems'
+
+gem 'rspec', '~>1.2.9'
+require 'spec'
+
+require Pathname(__FILE__).dirname.expand_path.parent + 'lib/dm-is-friendly'
+
+DataMapper::Logger.new("test.log", :debug)
+
+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_is_friendly_test')
+HAS_POSTGRES = load_driver(:postgres, 'postgres://postgres@localhost/dm_is_friendly_test')
+
+Spec::Runner.configure do |conf|
+  def log(msg); DataMapper.logger.push("****** #{msg}"); end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: dm-is-friendly
+version: !ruby/object:Gem::Version 
+  version: 0.10.2
+platform: ruby
+authors: 
+- Kabari Hendrick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-11 00:00:00 -06: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.14
+    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.10.2
+    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.10.2
+    version: 
+description: 
+email: kabari@gmail.com
+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: true
+homepage: http://github.com/kabari/dm-is-friendly
+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: DataMapper plugin that adds self-referential friendship functionality to your models.
+test_files: 
+- spec/dm-is-friendly_spec.rb
+- spec/spec_helper.rb