jackdempsey-sequel_polymorphic 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jack Dempsey
+
+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

@@ -0,0 +1,112 @@
+Sequel Polymorphic
+==================
+
+A simple plugin for Sequel::Model's that lets you easily create polymorphic associations.
+
+ActiveRecord Style
+------------------
+
+class Asset < ActiveRecord::Base
+ belongs_to :attachable, :polymorphic => true
+end
+
+class Post < ActiveRecord::Base
+ has_many :assets, :as => :attachable
+end
+
+class Note < ActiveRecord::Base
+ has_many :assets, :as => :attachable
+end
+
+@asset.attachable = @post
+@asset.attachable = @note
+
+In Sequel you would do the following:
+
+class Asset < Sequel::Model
+  many_to_one :attachable, :reciprocal=>:assets, \
+    :dataset=>(proc do
+      klass = attachable_type.constantize
+      klass.filter(klass.primary_key=>attachable_id)
+    end), \
+    :eager_loader=>(proc do |key_hash, assets, associations|
+      id_map = {}
+      assets.each do |asset|
+        asset.associations[:attachable] = nil
+        ((id_map[asset.attachable_type] ||= {})[asset.attachable_id] ||= []) << asset
+      end
+      id_map.each do |klass_name, id_map|
+        klass = klass_name.constantize
+        klass.filter(klass.primary_key=>id_map.keys).all do |attach|
+          id_map[attach.pk].each do |asset|
+            asset.associations[:attachable] = attach
+          end
+        end
+      end
+    end)
+
+  private
+
+  def _attachable=(attachable)
+    self[:attachable_id] = (attachable.pk if attachable)
+    self[:attachable_type] = (attachable.class.name if attachable)
+  end
+end
+
+class Post < Sequel::Model
+  one_to_many :assets, :key=>:attachable_id do |ds|
+    ds.filter(:attachable_type=>'Post')
+  end
+
+  private
+
+  def _add_asset(asset)
+    asset.attachable_id = pk
+    asset.attachable_type = 'Post'
+    asset.save
+  end
+  def _remove_asset(asset)
+    asset.attachable_id = nil
+    asset.attachable_type = nil
+    asset.save
+  end
+  def _remove_all_assets
+    Asset.filter(:attachable_id=>pk, :attachable_type=>'Post')\
+      .update(:attachable_id=>nil, :attachable_type=>nil)
+  end
+end
+
+class Note < Sequel::Model
+  one_to_many :assets, :key=>:attachable_id do |ds|
+    ds.filter(:attachable_type=>'Note')
+  end
+
+  private
+
+  def _add_asset(asset)
+    asset.attachable_id = pk
+    asset.attachable_type = 'Note'
+    asset.save
+  end
+  def _remove_asset(asset)
+    asset.attachable_id = nil
+    asset.attachable_type = nil
+    asset.save
+  end
+  def _remove_all_assets
+    Asset.filter(:attachable_id=>pk, :attachable_type=>'Note')\
+      .update(:attachable_id=>nil, :attachable_type=>nil)
+  end
+end
+
+@asset.attachable = @post
+@asset.attachable = @note
+
+
+Thats quite a bit of code. With sequel_polymorphic you can now do:
+
+class Note < Sequel::Model
+  is :polymorphic, :as => :attachable
+end
+
+voila!

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+
+GEM = "sequel_polymorphic"
+GEM_VERSION = "0.0.1"
+AUTHOR = "Jack Dempsey"
+EMAIL = "jack.dempsey@gmail.com"
+HOMEPAGE = "http://jackndempsey.blogspot.com"
+SUMMARY = "A gem that provides Sequel::Models with polymorphic association capabilities"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = false
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+end
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/TODO

@@ -0,0 +1 @@
+Add support for many_to_many polymorphic

data/lib/sequel_polymorphic.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'sequel_polymorphic/sequel_polymorphic'

data/lib/sequel_polymorphic/sequel_polymorphic.rb

@@ -0,0 +1,123 @@
+module Sequel
+  module Plugins
+    module Polymorphic
+      # Apply the plugin to the model.
+      def self.apply(model, options = {})
+      end
+
+      module InstanceMethods
+
+      end
+
+      module ClassMethods
+        def many_to_one(*args, &block)
+          able, options = *args
+          options ||= {}
+          if options[:polymorphic]
+            model = self.class.to_s.downcase
+            plural_model = model.pluralize
+            singular_model = model.singularize
+            self.class_eval %{
+              associate(:many_to_one, :#{able}, :reciprocal=>:#{plural_model},
+                 :dataset=>(proc { klass = #{able}_type.constantize; klass.filter(klass.primary_key=>#{able}_id) }), 
+                 :eager_loader=>(proc do |key_hash, #{plural_model}, associations|
+                   id_map = {}
+                   #{plural_model}.each do |#{singular_model}| 
+                     #{singular_model}.associations[:#{able}] = nil; 
+                     ((id_map[#{singular_model}.#{able}_type] ||= {})[#{singular_model}.#{able}_id] ||= []) << #{singular_model}
+                   end
+                   id_map.each do |klass_name, id_map|
+                     klass = klass_name.constantize
+                     klass.filter(klass.primary_key=>id_map.keys).all do |related_obj|
+                       id_map[related_obj.pk].each { |#{singular_model}| #{singular_model}.associations[:#{able}] = related_obj }
+                     end
+                   end
+                 end)
+              )
+             
+              private
+             
+              def _#{able}=(#{able})
+                self[:#{able}_id] = (#{able}.pk if #{able})
+                self[:#{able}_type] = (#{able}.class.name if #{able})
+              end
+            }
+          else
+            associate(:many_to_one, *args, &block)
+          end
+        end
+        
+        alias :belongs_to :many_to_one
+
+        def one_to_many(*args, &block)
+          many_of_class, options = *args
+          options ||= {}
+          many_class = many_of_class.to_s.singularize
+          if able = options[:as]
+            associate(:one_to_many, many_of_class, :key=>"#{able}_id".to_sym) do |ds|
+              ds.filter("#{able}_type".to_sym => self.class.to_s)
+            end
+
+             method_definitions = %{
+               private
+           
+               def _add_#{many_class}(#{many_class})
+                 #{many_class}.#{able}_id = pk
+                 #{many_class}.#{able}_type = '#{self}'
+                 #{many_class}.save
+               end
+               def _remove_#{many_class}(#{many_class})
+                 #{many_class}.#{able}_id = nil
+                 #{many_class}.#{able}_type = nil
+                 #{many_class}.save
+               end
+               def _remove_all_#{many_of_class}
+                 #{many_class.capitalize}.filter(:#{able}_id=>pk, :#{able}_type=>'#{self}').update(:#{able}_id=>nil, :#{able}_type=>nil)
+               end
+             }
+             self.class_eval method_definitions
+          else
+            associate(:one_to_many, *args, &block)
+          end
+        end
+        
+        alias :has_many :one_to_many
+        
+        #example:   many_to_many :tags, :through => :taggings, :as => :taggable
+        def many_to_many(*args, &block)
+          many_to_class, options = *args # => :tags, :through => :taggings, :as => :taggable
+          many_class = many_to_class.to_s.singularize # => tag
+          options ||= {}
+          if through = (options[:through] or options[:join_table]) and able = options[:as]
+            through_klass = through.to_s.singularize.capitalize # => Tagging
+            # self in the block passed to associate is an instance of the class, hence the self.class call
+            associate(:many_to_many, many_to_class,
+                      :left_key => "#{able}_id".to_sym,
+                      :join_table => through) { |ds| ds.filter("#{able}_type".to_sym => self.class.to_s) }
+
+            method_string = %{
+              private
+
+              def _add_#{many_class}(#{many_class})
+                #{through_klass}.create(:#{many_class}_id => #{many_class}.pk, :#{able}_id => pk, :#{able}_type => '#{self}')
+              end
+
+              def _remove_#{many_class}(#{many_class})
+                #{through_klass}.filter(:#{many_class}_id => #{many_class}.pk, :#{able}_id => pk, :#{able}_type => '#{self}').delete
+              end
+
+              def _remove_all_#{many_to_class}
+                #{through_klass}.filter(:#{able}_id=>pk, :#{able}_type=>'#{self}').delete
+              end
+            }
+            self.class_eval method_string
+          else
+            associate(:many_to_many, *args, &block)
+          end
+        end
+      end # ClassMethods
+    end # Polymorphic
+  end # Plugins
+end # Sequel
+
+

data/spec/sequel-setup.rb

@@ -0,0 +1,36 @@
+DB = Sequel.sqlite
+ 
+class Asset < Sequel::Model
+  set_schema do
+    primary_key :id
+    varchar :name
+    integer :attachable_id
+    varchar :attachable_type
+  end
+  
+  is :polymorphic, :belongs_to => :attachable
+  
+end
+
+class Post < Sequel::Model
+  set_schema do
+    primary_key :id
+    varchar :name
+  end
+
+  is :polymorphic, :has_many => :assets, :as => :attachable
+
+end
+
+
+class Note < Sequel::Model
+  set_schema do
+    primary_key :id
+    varchar :name
+  end
+
+  is :polymorphic, :has_many => :assets, :as => :attachable
+
+end
+
+[Asset, Post, Note].each {|klass| klass.create_table!}

data/spec/sequel_polymorphic/sequel_polymorphic_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# Models we have: Post(name), Note(name), Asset(name)
+describe Sequel::Plugins::Polymorphic do
+  it "should add :as to has_many/one_to_many" do
+    
+  end
+
+  it "should add :polymorphic => true to belongs_to" do
+    
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'spec'
+require 'sequel'
+
+require File.dirname(__FILE__) + '/sequel-setup'
+require File.dirname(__FILE__) + '/../lib/sequel_polymorphic'
+
+
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: jackdempsey-sequel_polymorphic
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jack Dempsey
+autorequire: sequel_polymorphic
+bindir: bin
+cert_chain: []
+
+date: 2008-12-08 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A gem that provides Sequel::Models with polymorphic association capabilities
+email: jack.dempsey@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/sequel_polymorphic
+- lib/sequel_polymorphic/sequel_polymorphic.rb
+- lib/sequel_polymorphic.rb
+- spec/sequel-setup.rb
+- spec/sequel_polymorphic
+- spec/sequel_polymorphic/sequel_polymorphic_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://jackndempsey.blogspot.com
+post_install_message: 
+rdoc_options: []
+
+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: 2
+summary: A gem that provides Sequel::Models with polymorphic association capabilities
+test_files: []
+