sequel_polymorphic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ba44333d65bad98de9c9645057d24ddc8513242
+  data.tar.gz: d44a526e09d8cca923ff8a3e61fe8bd6f9baca1d
+SHA512:
+  metadata.gz: ccda128f94078c89326d8f98af390f7382d0f79a4927d6836dbca2e35111e77b056c9ebfafeb2e11027488824728f4f9c8e9904c6591ea3832d553eb2f951c08
+  data.tar.gz: 62157d1f0941c1762aa686ef784439b6f79be198f15839067a6e522e569fe15559bd605efed8f1a736a29c22d16b6a298ca8711efbb67a018396a5fd4f5dc757

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.md

@@ -0,0 +1,122 @@
+#Sequel Polymorphic
+
+A simple plugin for Sequel::Model's that lets you easily create polymorphic associations.
+
+##ActiveRecord Style
+
+```ruby
+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
+```
+
+## Sequel (without plugin)
+
+In Sequel you would do the following:
+
+```ruby
+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:
+
+## Polymorphic
+
+```ruby
+class Note < Sequel::Model
+  one_to_many :assets, :as => :attachable
+end
+
+class Asset < Sequel::Model
+  many_to_one :attachable, :polymorphic => true
+end
+
+```

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,117 @@
+module Sequel
+  module Plugins
+    module Polymorphic
+      # Apply the plugin to the model.
+      def self.apply(model, options = {})
+      end
+
+      module InstanceMethods
+
+      end
+
+      module ClassMethods
+
+        # Example: Comment.many_to_one :commentable, polymorphic: true
+        def many_to_one(*args, &block)
+          able, options = *args
+          options ||= {}
+
+          if options[:polymorphic]
+            model = self.to_s.downcase          # comment
+            plural_model = pluralize(model)     # comments
+
+            associate(:many_to_one, able,
+              :reciprocal => plural_model.to_sym,
+              :setter => (proc do |able_instance|
+                self[:"#{able}_id"]   = (able_instance.pk if able_instance)
+                self[:"#{able}_type"] = (able_instance.class.name if able_instance)
+              end),
+              :dataset => (proc do
+                klass = constantize(send(:"#{able}_type"))
+                klass.where(klass.primary_key => send(:"#{able}_id"))
+              end),
+              :eager_loader => (proc do |eo|
+                id_map = {}
+                eo[:rows].each do |model|
+                  model.associations[able] = nil
+                  ((id_map[model.send(:"#{able}_type")] ||= {})[model.send(:"#{able}_id")] ||= []) << model
+                end
+                id_map.each do |klass_name, id_map|
+                  klass = constantize(klass_name)
+                  klass.where(klass.primary_key=>id_map.keys).all do |related_obj|
+                    id_map[related_obj.pk].each do |model|
+                      model.associations[able] = related_obj
+                    end
+                  end
+                end
+              end)
+            )
+
+          else
+            associate(:many_to_one, *args, &block)
+          end
+        end
+
+        alias :belongs_to :many_to_one
+
+
+        # Creates a one-to-many relationship. NB: Removing/clearing nullifies the *able fields in the related objects
+        # Example: Post.one_to_many :comments, as: :commentable
+        def one_to_many(*args, &block)
+          collection_name, options = *args
+          options ||= {}
+
+          if able = options[:as]
+            able_id           = :"#{able}_id"
+            able_type         = :"#{able}_type"
+            many_dataset_name = :"#{collection_name}_dataset"
+
+            associate(:one_to_many, collection_name,
+              :key        => able_id,
+              :reciprocal => able,
+              :conditions => {able_type => self.to_s},
+              :adder      => proc { |many_of_instance| many_of_instance.update(able_id => pk, able_type => self.class.to_s) },
+              :remover    => proc { |many_of_instance| many_of_instance.update(able_id => nil, able_type => nil) },
+              :clearer    => proc { send(many_dataset_name).update(able_id => nil, able_type => nil) }
+            )
+
+          else
+            associate(:one_to_many, *args, &block)
+          end
+        end
+
+        alias :has_many :one_to_many
+
+
+        # Creates a many-to-many relationship. NB: Removing/clearing the collection deletes the instances in the through relationship (as opposed to nullifying the *able fields as in the one-to-many)
+        # Example: Post.many_to_many :tags, :through => :taggings, :as => :taggable
+        def many_to_many(*args, &block)
+          collection_name, options = *args
+          options ||= {}
+
+          if through = (options[:through] || options[:join_table]) and able = options[:as]
+            able_id                = :"#{able}_id"
+            able_type              = :"#{able}_type"
+            collection_singular    = singularize(collection_name.to_s).to_sym # => tag
+            collection_singular_id = :"#{collection_singular}_id"
+            through_klass          = constantize(singularize(through.to_s).capitalize) # => Tagging
+
+            associate(:many_to_many, collection_name,
+              :left_key   => able_id,
+              :join_table => through,
+              :conditions => {able_type => self.to_s},
+              :adder      => proc { |many_of_instance| through_klass.create(collection_singular_id => many_of_instance.pk, able_id => pk, able_type => self.class.to_s) },
+              :remover    => proc { |many_of_instance| through_klass.where(collection_singular_id => many_of_instance.pk, able_id => pk, able_type => self.class.to_s).delete },
+              :clearer    => proc { through_klass.where(able_id => pk, able_type => self.class.to_s).delete }
+            )
+
+          else
+            associate(:many_to_many, *args, &block)
+          end
+        end
+      end # ClassMethods
+    end # Polymorphic
+  end # Plugins
+end # Sequel
+
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: sequel_polymorphic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jack Dempsey
+- Dave Myron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: A gem that provides Sequel::Models with polymorphic association capabilities
+email: therealdave.myron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+- TODO
+files:
+- LICENSE
+- README.md
+- TODO
+- lib/sequel_polymorphic.rb
+- lib/sequel_polymorphic/sequel_polymorphic.rb
+homepage: https://github.com/jackdempsey/sequel_polymorphic
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: A gem that provides Sequel::Models with polymorphic association capabilities
+test_files: []