acts-as-taggable-on-padrino 0.1.0 → 0.1.2

data/CHANGELOG

@@ -1,3 +1,7 @@
+== 2011-06-30
+
+* Simplified code, should now work as described in te docs.
+
 == 2011-06-20
 
 * Converted to Padrino compatible Gem

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.2

data/acts-as-taggable-on-padrino.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{acts-as-taggable-on-padrino}
-  s.version = "0.1.0"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Bleigh", "John Knott"]
-  s.date = %q{2011-06-29}
+  s.date = %q{2011-06-30}
   s.description = %q{Padrino version of the popular Rails tagging plugin. With ActsAsTaggableOnPadrino, you could tag a single model on several contexts, such as skills, interests, and awards. It also provides other advanced functionality.}
   s.email = %q{john.knott@gmail.com}
   s.extra_rdoc_files = [
@@ -47,7 +47,6 @@ Gem::Specification.new do |s|
     "spec/acts_as_taggable_on_padrino/tagging_spec.rb",
     "spec/acts_as_taggable_on_padrino/tags_helper_spec.rb",
     "spec/bm.rb",
-    "spec/database.yml.sample",
     "spec/models.rb",
     "spec/schema.rb",
     "spec/spec_helper.rb",

data/lib/acts-as-taggable-on-padrino.rb

@@ -18,16 +18,14 @@ require "acts_as_taggable_on_padrino/tagging"
 
 $LOAD_PATH.shift
 
-ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
-ActiveRecord::Base.extend ActsAsTaggableOn::Tagger
-ActiveRecord::Base.extend ActsAsTaggableOn::Tag
-ActiveRecord::Base.extend ActsAsTaggableOn::Tagging
+ActiveRecord::Base.extend ActsAsTaggableOnPadrino::Taggable
+ActiveRecord::Base.extend ActsAsTaggableOnPadrino::Tagger
 
 if defined?(Padrino::Helpers::TagHelpers)
-  Padrino::Helpers::TagHelpers.send :include, ActsAsTaggableOn::TagsHelper
+  Padrino::Helpers::TagHelpers.send :include, ActsAsTaggableOnPadrino::TagsHelper
 end
 
-module ActsAsTaggableOn
+module ActsAsTaggableOnPadrino
   def like_operator
     @like_operator ||= (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? 'ILIKE' : 'LIKE')
   end

data/lib/acts_as_taggable_on_padrino/tag.rb

@@ -1,32 +1,32 @@
-module ActsAsTaggableOn
-  module Tag
-    def acts_as_tag(opts = {})
-      opts.assert_valid_keys :tagging
-      tagging_class_name = opts[:tagging] || 'Tagging'
+module ActsAsTaggableOnPadrino
+  class Tag < ::ActiveRecord::Base
+    attr_accessible :name
 
-      class_eval do
-        attr_accessible :name
+    ### ASSOCIATIONS:
 
-        ### ASSOCIATIONS:
+    has_many :taggings, :dependent => :destroy, :class_name => 'ActsAsTaggableOnPadrino::Tagging'
 
-        has_many :taggings, :dependent => :destroy, :class_name => tagging_class_name
+    ### VALIDATIONS:
+    validates_presence_of :name
+    validates_uniqueness_of :name
 
-        ### VALIDATIONS:
-        validates_presence_of :name
-        validates_uniqueness_of :name
+    ### SCOPES:
+    # Override this with 'ILIKE' for case-insensitive operation on postgres
+    cattr_accessor :like_operator
+    self.like_operator = 'LIKE'
 
-        ### SCOPES:
-        scope :named, lambda {|name| where(["name #{ActsAsTaggableOn.like_operator} ?", name]) }
-        scope :named_any, lambda {|list| where(list.map { |tag| sanitize_sql(["name #{ActsAsTaggableOn.like_operator} ?", tag.to_s]) }.join(" OR ")) }
-        scope :named_like, lambda {|name| where(["name #{ActsAsTaggableOn.like_operator} ?", "%#{name}%"]) }
-        scope :named_like_any, lambda {|list| where(list.map { |tag| sanitize_sql(["name #{ActsAsTaggableOn.like_operator} ?", "%#{tag.to_s}%"]) }.join(" OR ")) }
-      end
+    scope :named, lambda {|name| where(["name #{like_operator} ?", name]) }
+    scope :named_any, lambda {|list| where(list.map { |tag| sanitize_sql(["name #{like_operator} ?", tag.to_s]) }.join(" OR ")) }
+    scope :named_like, lambda {|name| where(["name #{like_operator} ?", "%#{name}%"]) }
+    scope :named_like_any, lambda {|list| where(list.map { |tag| sanitize_sql(["name #{like_operator} ?", "%#{tag.to_s}%"]) }.join(" OR ")) }
 
-      include ActsAsTaggableOn::Tag::InstanceMethods
-      extend ActsAsTaggableOn::Tag::ClassMethods
-    end
+    ### CLASS METHODS:
+
+    class << self
+      def using_postgresql?
+        connection.adapter_name == 'PostgreSQL'
+      end
 
-    module ClassMethods
       def find_or_create_with_like_by_name(name)
         named_like(name).first || create(:name => name)
       end
@@ -35,12 +35,12 @@ module ActsAsTaggableOn
         list = list.flatten
         return [] if list.empty?
 
-        existing_tags = named_any(list)
+        existing_tags = Tag.named_any(list)
         new_tag_names = list.reject do |name|
                           name = comparable_name(name)
                           existing_tags.any? { |tag| comparable_name(tag.name) == name }
                         end
-        created_tags  = new_tag_names.map { |name| create(:name => name) }
+        created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
 
         existing_tags + created_tags
       end
@@ -55,18 +55,18 @@ module ActsAsTaggableOn
       end
     end
 
-    module InstanceMethods
-      def ==(object)
-        super || (object.is_a?(self.class) && name == object.name)
-      end
+    ### INSTANCE METHODS:
 
-      def to_s
-        name
-      end
+    def ==(object)
+      super || (object.is_a?(Tag) && name == object.name)
+    end
 
-      def count
-        read_attribute(:count).to_i
-      end
+    def to_s
+      name
+    end
+
+    def count
+      read_attribute(:count).to_i
     end
   end
-end
+end

data/lib/acts_as_taggable_on_padrino/taggable.rb

@@ -1,18 +1,18 @@
-module ActsAsTaggableOn
+module ActsAsTaggableOnPadrino
   module Taggable
     def taggable?
       false
     end
 
     ##
-    # This is an alias for calling <tt>acts_as_taggable_on_padrino :tags</tt>.
+    # This is an alias for calling <tt>acts_as_taggable_on :tags</tt>.
     #
     # Example:
     #   class Book < ActiveRecord::Base
     #     acts_as_taggable
     #   end
-    def acts_as_taggable(opts = {})
-      acts_as_taggable_on :tags, opts
+    def acts_as_taggable
+      acts_as_taggable_on :tags
     end
 
     ##
@@ -22,41 +22,34 @@ module ActsAsTaggableOn
     #
     # Example:
     #   class User < ActiveRecord::Base
-    #     acts_as_taggable_on_padrino :languages, :skills
+    #     acts_as_taggable_on :languages, :skills
     #   end
     def acts_as_taggable_on(*tag_types)
-      opts = tag_types.extract_options!
-      opts.assert_valid_keys :tag, :tagging
-
       tag_types = tag_types.to_a.flatten.compact.map {|type| type.to_sym }
 
       if taggable?
         write_inheritable_attribute(:tag_types, (self.tag_types + tag_types).uniq)
       else
-        opts.reverse_merge!(:tag => 'Tag', :tagging => 'Tagging')
-        tag_class_name = opts[:tag]
-        tagging_class_name = opts[:tagging]
-        tag = tag_class_name.constantize
-        tagging = tagging_class_name.constantize
-
         write_inheritable_attribute(:tag_types, tag_types)
-        write_inheritable_attribute(:acts_as_taggable_on_tag_model, tag)
-        write_inheritable_attribute(:acts_as_taggable_on_tagging_model, tagging)
-        class_inheritable_reader(:tag_types, :acts_as_taggable_on_tagging_model, :acts_as_taggable_on_tag_model)
+        write_inheritable_attribute(:tag_table_name, ActsAsTaggableOnPadrino::Tag.table_name)
+        write_inheritable_attribute(:tagging_table_name, ActsAsTaggableOnPadrino::Tagging.table_name)
+        class_inheritable_reader(:tag_types, :tag_table_name, :tagging_table_name)
+
+        Tag.like_operator = 'ILIKE' if Tag.using_postgresql?
 
         class_eval do
-          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => tagging_class_name
-          has_many :base_tags, :through => :taggings, :source => :tag, :class_name => tag_class_name
+          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOnPadrino::Tagging"
+          has_many :base_tags, :through => :taggings, :source => :tag, :class_name => "ActsAsTaggableOnPadrino::Tag"
 
           def self.taggable?
             true
           end
 
-          include ActsAsTaggableOn::Taggable::Core
-          include ActsAsTaggableOn::Taggable::Collection
-          include ActsAsTaggableOn::Taggable::Cache
-          include ActsAsTaggableOn::Taggable::Ownership
-          include ActsAsTaggableOn::Taggable::Related
+          include ActsAsTaggableOnPadrino::Taggable::Core
+          include ActsAsTaggableOnPadrino::Taggable::Collection
+          include ActsAsTaggableOnPadrino::Taggable::Cache
+          include ActsAsTaggableOnPadrino::Taggable::Ownership
+          include ActsAsTaggableOnPadrino::Taggable::Related
         end
       end
     end

data/lib/acts_as_taggable_on_padrino/taggable/cache.rb

@@ -1,11 +1,11 @@
-module ActsAsTaggableOn::Taggable
+module ActsAsTaggableOnPadrino::Taggable
   module Cache
     def self.included(base)
       # Skip adding caching capabilities if table not exists or no cache columns exist
       return unless base.table_exists? && base.tag_types.any? { |context| base.column_names.include?("cached_#{context.to_s.singularize}_list") }
 
-      base.send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
+      base.send :include, ActsAsTaggableOnPadrino::Taggable::Cache::InstanceMethods
+      base.extend ActsAsTaggableOnPadrino::Taggable::Cache::ClassMethods
 
       base.class_eval do
         before_save :save_cached_tag_list

data/lib/acts_as_taggable_on_padrino/taggable/collection.rb

@@ -1,8 +1,8 @@
-module ActsAsTaggableOn::Taggable
+module ActsAsTaggableOnPadrino::Taggable
   module Collection
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Collection::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Collection::ClassMethods
+      base.send :include, ActsAsTaggableOnPadrino::Taggable::Collection::InstanceMethods
+      base.extend ActsAsTaggableOnPadrino::Taggable::Collection::ClassMethods
       base.initialize_acts_as_taggable_on_collection
     end
 
@@ -55,26 +55,26 @@ module ActsAsTaggableOn::Taggable
         options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
 
         ## Generate scope:
-        tagging_scope = acts_as_taggable_on_tagging_model.select("#{acts_as_taggable_on_tagging_model.table_name}.tag_id, COUNT(#{acts_as_taggable_on_tagging_model.table_name}.tag_id) AS tags_count").
-            joins("INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{acts_as_taggable_on_tagging_model.table_name}.taggable_id").
+        tagging_scope = ActsAsTaggableOnPadrino::Tagging.select("#{tagging_table_name}.tag_id, COUNT(#{tagging_table_name}.tag_id) AS tags_count").
+            joins("INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{tagging_table_name}.taggable_id").
             where(:taggable_type => base_class.name)
         tagging_scope = tagging_scope.where(table_name => {inheritance_column => name}) unless descends_from_active_record? # Current model is STI descendant, so add type checking to the join condition
         tagging_scope = tagging_scope.where(:taggable_id => options.delete(:id)) if options[:id]
         tagging_scope = tagging_scope.where(:context => options.delete(:on).to_s) if options[:on]
-        tagging_scope = tagging_scope.where(["#{acts_as_taggable_on_tagging_model.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
-        tagging_scope = tagging_scope.where(["#{acts_as_taggable_on_tagging_model.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+        tagging_scope = tagging_scope.where(["#{tagging_table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+        tagging_scope = tagging_scope.where(["#{tagging_table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
 
-        tag_scope = acts_as_taggable_on_tag_model.select("#{acts_as_taggable_on_tag_model.table_name}.*, #{acts_as_taggable_on_tagging_model.table_name}.tags_count AS count").order(options[:order]).limit(options[:limit])
+        tag_scope = ActsAsTaggableOnPadrino::Tag.select("#{tag_table_name}.*, #{tagging_table_name}.tags_count AS count").order(options[:order]).limit(options[:limit])
         tag_scope.where(options[:conditions]) if options[:conditions]
 
         # GROUP BY and HAVING clauses:
         at_least  = sanitize_sql(['tags_count >= ?', options.delete(:at_least)]) if options[:at_least]
         at_most   = sanitize_sql(['tags_count <= ?', options.delete(:at_most)]) if options[:at_most]
-        having    = ["COUNT(#{acts_as_taggable_on_tagging_model.table_name}.tag_id) > 0", at_least, at_most].compact.join(' AND ')
+        having    = ["COUNT(#{tagging_table_name}.tag_id) > 0", at_least, at_most].compact.join(' AND ')
 
         # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
         tagging_scope = tagging_scope.where(:taggable_id => select("#{table_name}.#{primary_key}")).
-                                      group("#{acts_as_taggable_on_tagging_model.table_name}.tag_id").
+                                      group("#{tagging_table_name}.tag_id").
                                       having(having)
 
         tag_scope = tag_scope.joins("JOIN (#{tagging_scope.to_sql}) AS taggings ON taggings.tag_id = tags.id")

data/lib/acts_as_taggable_on_padrino/taggable/core.rb

@@ -1,8 +1,8 @@
-module ActsAsTaggableOn::Taggable
+module ActsAsTaggableOnPadrino::Taggable
   module Core
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Core::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Core::ClassMethods
+      base.send :include, ActsAsTaggableOnPadrino::Taggable::Core::InstanceMethods
+      base.extend ActsAsTaggableOnPadrino::Taggable::Core::ClassMethods
 
       base.class_eval do
         attr_writer :custom_contexts
@@ -20,9 +20,9 @@ module ActsAsTaggableOn::Taggable
           context_tags     = tags_type.to_sym
 
           class_eval do
-            has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => acts_as_taggable_on_tagging_model.name,
-            :conditions => ["#{acts_as_taggable_on_tagging_model.table_name}.tag_id = #{acts_as_taggable_on_tag_model.table_name}.id AND #{acts_as_taggable_on_tagging_model.table_name}.context = ?", tags_type]
-            has_many context_tags, :through => context_taggings, :source => :tag, :class_name => acts_as_taggable_on_tag_model.name
+            has_many context_taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "ActsAsTaggableOnPadrino::Tagging",
+            :conditions => ["#{tagging_table_name}.tag_id = #{tag_table_name}.id AND #{tagging_table_name}.context = ?", tags_type]
+            has_many context_tags, :through => context_taggings, :source => :tag, :class_name => "ActsAsTaggableOnPadrino::Tag"
           end
 
           class_eval %(
@@ -48,7 +48,7 @@ module ActsAsTaggableOn::Taggable
 
       # all column names are necessary for PostgreSQL group clause
       def grouped_column_names_for(object)
-        if object.connection.adapter_name == 'PostgreSQL'
+        if ActsAsTaggableOnPadrino::Tag.using_postgresql?
           object.column_names.map { |column| "#{object.table_name}.#{column}" }.join(", ")
         else
           "#{object.table_name}.#{object.primary_key}"
@@ -70,7 +70,7 @@ module ActsAsTaggableOn::Taggable
       #   User.tagged_with("awesome", "cool", :any => true)       # Users that are tagged with awesome or cool
       #   User.tagged_with("awesome", "cool", :match_all => true) # Users that are tagged with just awesome and cool
       def tagged_with(tags, options = {})
-        tag_list = ActsAsTaggableOn::Taggable::TagList.from(tags)
+        tag_list = ActsAsTaggableOnPadrino::Taggable::TagList.from(tags)
 
         return {} if tag_list.empty?
 
@@ -80,15 +80,15 @@ module ActsAsTaggableOn::Taggable
         context = options.delete(:on)
 
         if options.delete(:exclude)
-          tags_conditions = tag_list.map { |t| sanitize_sql(["#{acts_as_taggable_on_tag_model.table_name}.name #{ActsAsTaggableOn.like_operator} ?", t]) }.join(" OR ")
-          conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{acts_as_taggable_on_tagging_model.table_name}.taggable_id FROM #{acts_as_taggable_on_tagging_model.table_name} JOIN #{acts_as_taggable_on_tag_model.table_name} ON #{acts_as_taggable_on_tagging_model.table_name}.tag_id = #{acts_as_taggable_on_tag_model.table_name}.id AND (#{tags_conditions}) WHERE #{acts_as_taggable_on_tagging_model.table_name}.taggable_type = #{quote_value(base_class.name)})"
+          tags_conditions = tag_list.map { |t| sanitize_sql(["#{tag_table_name}.name #{ActsAsTaggableOnPadrino::Tag.like_operator} ?", t]) }.join(" OR ")
+          conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{tagging_table_name}.taggable_id FROM #{tagging_table_name} JOIN #{tag_table_name} ON #{tagging_table_name}.tag_id = #{tag_table_name}.id AND (#{tags_conditions}) WHERE #{tagging_table_name}.taggable_type = #{quote_value(base_class.name)})"
 
         elsif options.delete(:any)
-          tags_conditions = tag_list.map { |t| sanitize_sql(["#{acts_as_taggable_on_tag_model.table_name}.name #{ActsAsTaggableOn.like_operator} ?", t]) }.join(" OR ")
-          conditions << "#{table_name}.#{primary_key} IN (SELECT #{acts_as_taggable_on_tagging_model.table_name}.taggable_id FROM #{acts_as_taggable_on_tagging_model.table_name} JOIN #{acts_as_taggable_on_tag_model.table_name} ON #{acts_as_taggable_on_tagging_model.table_name}.tag_id = #{acts_as_taggable_on_tag_model.table_name}.id AND (#{tags_conditions}) WHERE #{acts_as_taggable_on_tagging_model.table_name}.taggable_type = #{quote_value(base_class.name)})"
+          tags_conditions = tag_list.map { |t| sanitize_sql(["#{tag_table_name}.name #{ActsAsTaggableOnPadrino::Tag.like_operator} ?", t]) }.join(" OR ")
+          conditions << "#{table_name}.#{primary_key} IN (SELECT #{tagging_table_name}.taggable_id FROM #{tagging_table_name} JOIN #{tag_table_name} ON #{tagging_table_name}.tag_id = #{tag_table_name}.id AND (#{tags_conditions}) WHERE #{tagging_table_name}.taggable_type = #{quote_value(base_class.name)})"
 
         else
-          tags = acts_as_taggable_on_tag_model.named_any(tag_list)
+          tags = ActsAsTaggableOnPadrino::Tag.named_any(tag_list)
           return where("1 = 0") unless tags.length == tag_list.length
 
           tags.each do |tag|
@@ -97,7 +97,7 @@ module ActsAsTaggableOn::Taggable
 
             taggings_alias = "#{undecorated_table_name}_taggings_#{prefix}"
 
-            tagging_join  = "JOIN #{acts_as_taggable_on_tagging_model.table_name} #{taggings_alias}" +
+            tagging_join  = "JOIN #{tagging_table_name} #{taggings_alias}" +
                             "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
                             " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}" +
                             " AND #{taggings_alias}.tag_id = #{tag.id}"
@@ -110,7 +110,7 @@ module ActsAsTaggableOn::Taggable
         taggings_alias, tags_alias = "#{undecorated_table_name}_taggings_group", "#{undecorated_table_name}_tags_group"
 
         if options.delete(:match_all)
-          joins << "LEFT OUTER JOIN #{acts_as_taggable_on_tagging_model.table_name} #{taggings_alias}" +
+          joins << "LEFT OUTER JOIN #{tagging_table_name} #{taggings_alias}" +
                    "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
                    " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}"
 
@@ -160,7 +160,7 @@ module ActsAsTaggableOn::Taggable
 
       def tag_list_cache_on(context)
         variable_name = "@#{context.to_s.singularize}_list"
-        instance_variable_get(variable_name) || instance_variable_set(variable_name, ActsAsTaggableOn::Taggable::TagList.new(tags_on(context).names))
+        instance_variable_get(variable_name) || instance_variable_set(variable_name, ActsAsTaggableOnPadrino::Taggable::TagList.new(tags_on(context).names))
       end
 
       def tag_list_on(context)
@@ -172,28 +172,28 @@ module ActsAsTaggableOn::Taggable
         variable_name = "@all_#{context.to_s.singularize}_list"
         return instance_variable_get(variable_name) if instance_variable_get(variable_name)
 
-        instance_variable_set(variable_name, ActsAsTaggableOn::Taggable::TagList.new(all_tags_on(context).names).freeze)
+        instance_variable_set(variable_name, ActsAsTaggableOnPadrino::Taggable::TagList.new(all_tags_on(context).names).freeze)
       end
 
       ##
       # Returns all tags of a given context
       def all_tags_on(context)
         base_tags.where(:taggings => {:context => context.to_s}).
-          group(grouped_column_names_for(acts_as_taggable_on_tag_model)).
-          order("max(#{acts_as_taggable_on_tagging_model.table_name}.created_at)")
+          group(grouped_column_names_for(ActsAsTaggableOnPadrino::Tag)).
+          order("max(#{tagging_table_name}.created_at)")
       end
 
       ##
       # Returns all tags that are not owned of a given context
       def tags_on(context)
-        base_tags.where(["#{acts_as_taggable_on_tagging_model.table_name}.context = ? AND #{acts_as_taggable_on_tagging_model.table_name}.tagger_id IS NULL", context.to_s])
+        base_tags.where(["#{tagging_table_name}.context = ? AND #{tagging_table_name}.tagger_id IS NULL", context.to_s])
       end
 
       def set_tag_list_on(context, new_list)
         add_custom_context(context)
 
         variable_name = "@#{context.to_s.singularize}_list"
-        instance_variable_set(variable_name, ActsAsTaggableOn::Taggable::TagList.from(new_list))
+        instance_variable_set(variable_name, ActsAsTaggableOnPadrino::Taggable::TagList.from(new_list))
       end
 
       def tagging_contexts
@@ -216,7 +216,7 @@ module ActsAsTaggableOn::Taggable
           tag_list = tag_list_cache_on(context).uniq
 
           # Find existing tags or create non-existing tags:
-          tag_list = acts_as_taggable_on_tag_model.find_or_create_all_with_like_by_name(tag_list)
+          tag_list = ActsAsTaggableOnPadrino::Tag.find_or_create_all_with_like_by_name(tag_list)
 
           current_tags = tags_on(context)
           old_tags     = current_tags - tag_list
@@ -228,7 +228,7 @@ module ActsAsTaggableOn::Taggable
 
           if old_taggings.present?
             # Destroy old taggings:
-            acts_as_taggable_on_tagging_model.destroy_all :id => old_taggings.map {|tagging| tagging.id }
+            ActsAsTaggableOnPadrino::Tagging.destroy_all :id => old_taggings.map {|tagging| tagging.id }
           end
 
           # Create new taggings:

data/lib/acts_as_taggable_on_padrino/taggable/ownership.rb

@@ -1,8 +1,8 @@
-module ActsAsTaggableOn::Taggable
+module ActsAsTaggableOnPadrino::Taggable
   module Ownership
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Ownership::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Ownership::ClassMethods
+      base.send :include, ActsAsTaggableOnPadrino::Taggable::Ownership::InstanceMethods
+      base.extend ActsAsTaggableOnPadrino::Taggable::Ownership::ClassMethods
 
       base.class_eval do
         after_save :save_owned_tags
@@ -48,7 +48,7 @@ module ActsAsTaggableOn::Taggable
         cache = cached_owned_tag_list_on(context)
         cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
 
-        cache[owner] ||= ActsAsTaggableOn::Taggable::TagList.new(*owner_tags_on(owner, context).names)
+        cache[owner] ||= ActsAsTaggableOnPadrino::Taggable::TagList.new(*owner_tags_on(owner, context).names)
       end
 
       def set_owner_tag_list_on(owner, context, new_list)
@@ -57,7 +57,7 @@ module ActsAsTaggableOn::Taggable
         cache = cached_owned_tag_list_on(context)
         cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
 
-        cache[owner] = ActsAsTaggableOn::Taggable::TagList.from(new_list)
+        cache[owner] = ActsAsTaggableOnPadrino::Taggable::TagList.from(new_list)
       end
 
       def reload(*args)
@@ -72,7 +72,7 @@ module ActsAsTaggableOn::Taggable
         tagging_contexts.each do |context|
           cached_owned_tag_list_on(context).each do |owner, tag_list|
             # Find existing tags or create non-existing tags:
-            tag_list = acts_as_taggable_on_tag_model.find_or_create_all_with_like_by_name(tag_list.uniq)
+            tag_list = ActsAsTaggableOnPadrino::Tag.find_or_create_all_with_like_by_name(tag_list.uniq)
 
             owned_tags = owner_tags_on(owner, context)
             old_tags   = owned_tags - tag_list
@@ -80,14 +80,13 @@ module ActsAsTaggableOn::Taggable
 
             # Find all taggings that belong to the taggable (self), are owned by the owner,
             # have the correct context, and are removed from the list.
-            old_taggings = acts_as_taggable_on_tagging_model.where(
-              :taggable_id => id, :taggable_type => self.class.base_class.to_s,
-              :tagger_type => owner.class.to_s, :tagger_id => owner.id,
-              :tag_id => old_tags, :context => context)
+            old_taggings = ActsAsTaggableOnPadrino::Tagging.where(:taggable_id => id, :taggable_type => self.class.base_class.to_s,
+                                                           :tagger_type => owner.class.to_s, :tagger_id => owner.id,
+                                                           :tag_id => old_tags, :context => context)
 
             if old_taggings.present?
               # Destroy old taggings:
-              acts_as_taggable_on_tagging_model.destroy_all(:id => old_taggings.map {|tagging| tagging.id })
+              ActsAsTaggableOnPadrino::Tagging.destroy_all(:id => old_taggings.map {|tagging| tagging.id })
             end
 
             # Create new taggings:

data/lib/acts_as_taggable_on_padrino/taggable/related.rb

@@ -1,8 +1,8 @@
-module ActsAsTaggableOn::Taggable
+module ActsAsTaggableOnPadrino::Taggable
   module Related
     def self.included(base)
-      base.send :include, ActsAsTaggableOn::Taggable::Related::InstanceMethods
-      base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
+      base.send :include, ActsAsTaggableOnPadrino::Taggable::Related::InstanceMethods
+      base.extend ActsAsTaggableOnPadrino::Taggable::Related::ClassMethods
       base.initialize_acts_as_taggable_on_related
     end
 
@@ -38,7 +38,7 @@ module ActsAsTaggableOn::Taggable
 
     module InstanceMethods
       def matching_contexts_for(search_context, result_context, klass)
-        related_tags_for(search_context, klass).where("#{acts_as_taggable_on_tagging_model.table_name}.context = ?", result_context)
+        related_tags_for(search_context, klass).where("#{tagging_table_name}.context = ?", result_context)
       end
 
       def related_tags_for(context, klass)
@@ -46,12 +46,12 @@ module ActsAsTaggableOn::Taggable
 
         scope = klass.scoped
         scope = scope.where("#{klass.table_name}.id != ?", id) if self.class == klass # exclude self
-        scope.select("#{klass.table_name}.*, COUNT(#{acts_as_taggable_on_tag_model.table_name}.id) AS count").
-          from("#{klass.table_name}, #{acts_as_taggable_on_tag_model.table_name}, #{acts_as_taggable_on_tagging_model.table_name}").
-          where("#{klass.table_name}.id = #{acts_as_taggable_on_tagging_model.table_name}.taggable_id").
-          where("#{acts_as_taggable_on_tagging_model.table_name}.taggable_type = ?", klass.to_s).
-          where("#{acts_as_taggable_on_tagging_model.table_name}.tag_id = #{acts_as_taggable_on_tag_model.table_name}.id").
-          where("#{acts_as_taggable_on_tag_model.table_name}.name IN (?)", tags_to_find).
+        scope.select("#{klass.table_name}.*, COUNT(#{tag_table_name}.id) AS count").
+          from("#{klass.table_name}, #{tag_table_name}, #{tagging_table_name}").
+          where("#{klass.table_name}.id = #{tagging_table_name}.taggable_id").
+          where("#{tagging_table_name}.taggable_type = ?", klass.to_s).
+          where("#{tagging_table_name}.tag_id = #{tag_table_name}.id").
+          where("#{tag_table_name}.name IN (?)", tags_to_find).
           group(grouped_column_names_for(klass)).
           order("count DESC")
       end

data/lib/acts_as_taggable_on_padrino/taggable/tag_list.rb

@@ -1,4 +1,4 @@
-module ActsAsTaggableOn::Taggable
+module ActsAsTaggableOnPadrino::Taggable
   class TagList < Array
     cattr_accessor :delimiter
     self.delimiter = ','

data/lib/acts_as_taggable_on_padrino/tagger.rb

@@ -1,4 +1,4 @@
-module ActsAsTaggableOn
+module ActsAsTaggableOnPadrino
   module Tagger
     ##
     # Make a model a tagger. This allows an instance of a model to claim ownership
@@ -9,18 +9,14 @@ module ActsAsTaggableOn
     #     acts_as_tagger
     #   end
     def acts_as_tagger(opts={})
-      opts.assert_valid_keys :tagging, :tag
-      tagging_class_name = opts[:tagging] || 'Tagging'
-      tag_class_name = opts[:tag] || 'Tag'
-
       class_eval do
         has_many :owned_taggings, opts.merge(:as => :tagger, :dependent => :destroy,
-                                             :include => :tag, :class_name => tagging_class_name)
-        has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true, :class_name => tag_class_name
+                                             :include => :tag, :class_name => "ActsAsTaggableOnPadrino::Tagging")
+        has_many :owned_tags, :through => :owned_taggings, :source => :tag, :uniq => true, :class_name => "ActsAsTaggableOnPadrino::Tag"
       end
 
-      include ActsAsTaggableOn::Tagger::InstanceMethods
-      extend ActsAsTaggableOn::Tagger::ClassMethods
+      include ActsAsTaggableOnPadrino::Tagger::InstanceMethods
+      extend ActsAsTaggableOnPadrino::Tagger::ClassMethods
     end
 
     def is_tagger?

data/lib/acts_as_taggable_on_padrino/tagging.rb

@@ -1,29 +1,22 @@
-module ActsAsTaggableOn
-  module Tagging
-    def acts_as_tagging(opts = {})
-      opts.assert_valid_keys :tag
-      tag_class_name = opts[:tag] || 'Tag'
+module ActsAsTaggableOnPadrino
+  class Tagging < ::ActiveRecord::Base #:nodoc:
+    attr_accessible :tag,
+                    :tag_id,
+                    :context,
+                    :taggable,
+                    :taggable_type,
+                    :taggable_id,
+                    :tagger,
+                    :tagger_type,
+                    :tagger_id
 
-      class_eval do
-        attr_accessible :tag,
-                        :tag_id,
-                        :context,
-                        :taggable,
-                        :taggable_type,
-                        :taggable_id,
-                        :tagger,
-                        :tagger_type,
-                        :tagger_id
+    belongs_to :tag, :class_name => 'ActsAsTaggableOnPadrino::Tag'
+    belongs_to :taggable, :polymorphic => true
+    belongs_to :tagger,   :polymorphic => true
 
-        belongs_to :tag, :class_name => tag_class_name
-        belongs_to :taggable, :polymorphic => true
-        belongs_to :tagger,   :polymorphic => true
+    validates_presence_of :context
+    validates_presence_of :tag_id
 
-        validates_presence_of :context
-        validates_presence_of :tag_id
-
-        validates_uniqueness_of :tag_id, :scope => [ :taggable_type, :taggable_id, :context, :tagger_id, :tagger_type ]
-      end
-    end
+    validates_uniqueness_of :tag_id, :scope => [ :taggable_type, :taggable_id, :context, :tagger_id, :tagger_type ]
   end
-end
+end

data/lib/acts_as_taggable_on_padrino/tags_helper.rb

@@ -1,4 +1,4 @@
-module ActsAsTaggableOn
+module ActsAsTaggableOnPadrino
   module TagsHelper
     # See the README for an example using tag_cloud.
     def tag_cloud(tags, classes)

data/spec/acts_as_taggable_on_padrino/tag_list_spec.rb

@@ -1,8 +1,8 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe ActsAsTaggableOn::Taggable::TagList do
+describe ActsAsTaggableOnPadrino::Taggable::TagList do
   before(:each) do
-    @tag_list = ActsAsTaggableOn::Taggable::TagList.new("awesome","radical")
+    @tag_list = ActsAsTaggableOnPadrino::Taggable::TagList.new("awesome","radical")
   end
   
   it "should be an array" do

data/spec/acts_as_taggable_on_padrino/tag_spec.rb

@@ -1,19 +1,19 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe ActsAsTaggableOn::Tag do
+describe ActsAsTaggableOnPadrino::Tag do
   before(:each) do
-    @tag = TestTag.new
+    @tag = ActsAsTaggableOnPadrino::Tag.new
     @user = TaggableModel.create(:name => "Pablo")
   end
 
   describe "named like any" do
     before(:each) do
-      TestTag.create(:name => "awesome")
-      TestTag.create(:name => "epic")
+      ActsAsTaggableOnPadrino::Tag.create(:name => "awesome")
+      ActsAsTaggableOnPadrino::Tag.create(:name => "epic")
     end
 
     it "should find both tags" do
-      TestTag.named_like_any(["awesome", "epic"]).should have(2).items
+      ActsAsTaggableOnPadrino::Tag.named_like_any(["awesome", "epic"]).should have(2).items
     end
   end
 
@@ -24,17 +24,17 @@ describe ActsAsTaggableOn::Tag do
     end
 
     it "should find by name" do
-      TestTag.find_or_create_with_like_by_name("awesome").should == @tag
+      ActsAsTaggableOnPadrino::Tag.find_or_create_with_like_by_name("awesome").should == @tag
     end
 
     it "should find by name case insensitive" do
-      TestTag.find_or_create_with_like_by_name("AWESOME").should == @tag
+      ActsAsTaggableOnPadrino::Tag.find_or_create_with_like_by_name("AWESOME").should == @tag
     end
 
     it "should create by name" do
       lambda {
-        TestTag.find_or_create_with_like_by_name("epic")
-      }.should change(TestTag, :count).by(1)
+        ActsAsTaggableOnPadrino::Tag.find_or_create_with_like_by_name("epic")
+      }.should change(ActsAsTaggableOnPadrino::Tag, :count).by(1)
     end
   end
 
@@ -45,27 +45,27 @@ describe ActsAsTaggableOn::Tag do
     end
 
     it "should find by name" do
-      TestTag.find_or_create_all_with_like_by_name("awesome").should == [@tag]
+      ActsAsTaggableOnPadrino::Tag.find_or_create_all_with_like_by_name("awesome").should == [@tag]
     end
 
     it "should find by name case insensitive" do
-      TestTag.find_or_create_all_with_like_by_name("AWESOME").should == [@tag]
+      ActsAsTaggableOnPadrino::Tag.find_or_create_all_with_like_by_name("AWESOME").should == [@tag]
     end
 
     it "should create by name" do
       lambda {
-        TestTag.find_or_create_all_with_like_by_name("epic")
-      }.should change(TestTag, :count).by(1)
+        ActsAsTaggableOnPadrino::Tag.find_or_create_all_with_like_by_name("epic")
+      }.should change(ActsAsTaggableOnPadrino::Tag, :count).by(1)
     end
 
     it "should find or create by name" do
       lambda {
-        TestTag.find_or_create_all_with_like_by_name("awesome", "epic").map(&:name).should == ["awesome", "epic"]
-      }.should change(TestTag, :count).by(1)
+        ActsAsTaggableOnPadrino::Tag.find_or_create_all_with_like_by_name("awesome", "epic").map(&:name).should == ["awesome", "epic"]
+      }.should change(ActsAsTaggableOnPadrino::Tag, :count).by(1)
     end
 
     it "should return an empty array if no tags are specified" do
-      TestTag.find_or_create_all_with_like_by_name([]).should == []
+      ActsAsTaggableOnPadrino::Tag.find_or_create_all_with_like_by_name([]).should == []
     end
   end
 
@@ -81,7 +81,7 @@ describe ActsAsTaggableOn::Tag do
 
   it "should equal a tag with the same name" do
     @tag.name = "awesome"
-    new_tag = TestTag.new(:name => "awesome")
+    new_tag = ActsAsTaggableOnPadrino::Tag.new(:name => "awesome")
     new_tag.should == @tag
   end
 
@@ -93,13 +93,13 @@ describe ActsAsTaggableOn::Tag do
   it "have named_scope named(something)" do
     @tag.name = "cool"
     @tag.save!
-    TestTag.named('cool').should include(@tag)
+    ActsAsTaggableOnPadrino::Tag.named('cool').should include(@tag)
   end
 
   it "have named_scope named_like(something)" do
     @tag.name = "cool"
     @tag.save!
-    @another_tag = TestTag.create!(:name => "coolip")
-    TestTag.named_like('cool').should include(@tag, @another_tag)
+    @another_tag = ActsAsTaggableOnPadrino::Tag.create!(:name => "coolip")
+    ActsAsTaggableOnPadrino::Tag.named_like('cool').should include(@tag, @another_tag)
   end
 end

data/spec/acts_as_taggable_on_padrino/taggable_spec.rb

@@ -26,11 +26,11 @@ describe "Taggable" do
 
   it "should be able to create tags" do
     @taggable.skill_list = "ruby, rails, css"
-    @taggable.instance_variable_get("@skill_list").instance_of?(ActsAsTaggableOn::Taggable::TagList).should be_true
+    @taggable.instance_variable_get("@skill_list").instance_of?(ActsAsTaggableOnPadrino::Taggable::TagList).should be_true
     
     lambda {
       @taggable.save
-    }.should change(Tag, :count).by(3)
+    }.should change(ActsAsTaggableOnPadrino::Tag, :count).by(3)
     
     @taggable.reload
     @taggable.skill_list.sort.should == %w(ruby rails css).sort
@@ -106,7 +106,7 @@ describe "Taggable" do
     bob = TaggableModel.create(:name => "Bob", :tag_list => "ruby")
     frank = TaggableModel.create(:name => "Frank", :tag_list => "Ruby")
 
-    Tag.find(:all).size.should == 1
+    ActsAsTaggableOnPadrino::Tag.find(:all).size.should == 1
     TaggableModel.tagged_with("ruby").to_a.should == TaggableModel.tagged_with("Ruby").to_a
   end
 
@@ -246,7 +246,7 @@ describe "Taggable" do
       bob.tag_list << "happier"
       bob.tag_list << "happier"
       bob.save
-    }.should change(Tagging, :count).by(1)
+    }.should change(ActsAsTaggableOnPadrino::Tagging, :count).by(1)
   end
  
   describe "Associations" do
@@ -262,10 +262,10 @@ describe "Taggable" do
   end
 
   describe "grouped_column_names_for method" do
-    if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+    if ActsAsTaggableOnPadrino::Tag.using_postgresql?
       context "on postgres" do
         it "should return all column names joined for Tag" do
-          @taggable.grouped_column_names_for(Tag).should == "tags.id, tags.name"
+          @taggable.grouped_column_names_for(ActsAsTaggableOnPadrino::Tag).should == "tags.id, tags.name"
         end
 
         it "should return all column names joined for TaggableModel" do
@@ -274,7 +274,7 @@ describe "Taggable" do
       end
     else
       it "should return the id column for Tag" do
-        @taggable.grouped_column_names_for(Tag).should == "tags.id"
+        @taggable.grouped_column_names_for(ActsAsTaggableOnPadrino::Tag).should == "tags.id"
       end
 
       it "should return the id column for TaggableModel" do

data/spec/acts_as_taggable_on_padrino/tagger_spec.rb

@@ -21,7 +21,7 @@ describe "Tagger" do
     lambda{
       @user.tag(@taggable, :with => 'ruby, scheme', :on => :tags)
       @user2.tag(@taggable, :with => 'java, python, lisp, ruby', :on => :tags)
-    }.should change(Tagging, :count).by(6)
+    }.should change(ActsAsTaggableOnPadrino::Tagging, :count).by(6)
 
     [@user, @user2, @taggable].each(&:reload)
 
@@ -42,7 +42,7 @@ describe "Tagger" do
     
     lambda {
       @user2.tag(@taggable, :with => 'java, python, lisp', :on => :tags)
-    }.should change(Tagging, :count).by(-1)
+    }.should change(ActsAsTaggableOnPadrino::Tagging, :count).by(-1)
 
     [@user, @user2, @taggable].each(&:reload)
     
@@ -61,7 +61,7 @@ describe "Tagger" do
 
     lambda {
       @user2.tag(@taggable, :with => 'epic', :on => :tags)
-    }.should change(Tagging, :count).by(-1)
+    }.should change(ActsAsTaggableOnPadrino::Tagging, :count).by(-1)
 
     @taggable.reload  
     @taggable.all_tags_list.should include('awesome')
@@ -78,7 +78,7 @@ describe "Tagger" do
     
     lambda {
       @taggable.update_attributes(:tag_list => "")
-    }.should change(Tagging, :count).by(-1)
+    }.should change(ActsAsTaggableOnPadrino::Tagging, :count).by(-1)
     
     @taggable.tag_list.should == []
     @taggable.all_tags_list.sort.should == %w(ruby scheme).sort

data/spec/acts_as_taggable_on_padrino/tagging_spec.rb

@@ -1,13 +1,13 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe ActsAsTaggableOn::Tagging do
+describe ActsAsTaggableOnPadrino::Tagging do
   before(:each) do
-    @tagging = TestTagging.new
+    @tagging = ActsAsTaggableOnPadrino::Tagging.new
   end
 
   it "should not be valid with a invalid tag" do
     @tagging.taggable = TaggableModel.create(:name => "Bob Jones")
-    @tagging.tag = TestTag.new(:name => "")
+    @tagging.tag = ActsAsTaggableOnPadrino::Tag.new(:name => "")
     @tagging.context = "tags"
 
     @tagging.should_not be_valid
@@ -17,10 +17,10 @@ describe ActsAsTaggableOn::Tagging do
 
   it "should not create duplicate taggings" do
     @taggable = TaggableModel.create(:name => "Bob Jones")
-    @tag = TestTag.create(:name => "awesome")
+    @tag = ActsAsTaggableOnPadrino::Tag.create(:name => "awesome")
 
     lambda {
-      2.times { TestTagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags') }
-    }.should change(TestTagging, :count).by(1)
+      2.times { ActsAsTaggableOnPadrino::Tagging.create(:taggable => @taggable, :tag => @tag, :context => 'tags') }
+    }.should change(ActsAsTaggableOnPadrino::Tagging, :count).by(1)
   end
 end

data/spec/acts_as_taggable_on_padrino/tags_helper_spec.rb

@@ -1,13 +1,13 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe ActsAsTaggableOn::TagsHelper do
+describe ActsAsTaggableOnPadrino::TagsHelper do
   before(:each) do
     @bob = TaggableModel.create(:name => "Bob Jones",  :language_list => "ruby, php")
     @tom = TaggableModel.create(:name => "Tom Marley", :language_list => "ruby, java")
     @eve = TaggableModel.create(:name => "Eve Nodd",   :language_list => "ruby, c++")
     
     @helper = class Helper
-      include ActsAsTaggableOn::TagsHelper
+      include ActsAsTaggableOnPadrino::TagsHelper
     end.new
   end
   

data/spec/models.rb

@@ -1,19 +1,3 @@
-class Tag < ActiveRecord::Base
-  acts_as_tag
-end
-
-class TestTag < ActiveRecord::Base
-  acts_as_tag
-end
-
-class Tagging < ActiveRecord::Base
-  acts_as_tagging
-end
-
-class TestTagging < ActiveRecord::Base
-  acts_as_tagging :tag => 'TestTag'
-end
-
 class TaggableModel < ActiveRecord::Base
   acts_as_taggable
   acts_as_taggable_on :languages

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts-as-taggable-on-padrino
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,12 +10,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-06-29 00:00:00.000000000 +01:00
+date: 2011-06-30 00:00:00.000000000 +01:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &13175840 !ruby/object:Gem::Requirement
+  requirement: &20418920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -23,10 +23,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *13175840
+  version_requirements: *20418920
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &13175360 !ruby/object:Gem::Requirement
+  requirement: &20418440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -34,10 +34,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13175360
+  version_requirements: *20418440
 - !ruby/object:Gem::Dependency
   name: mysql
-  requirement: &13174880 !ruby/object:Gem::Requirement
+  requirement: &20417960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -45,10 +45,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13174880
+  version_requirements: *20417960
 - !ruby/object:Gem::Dependency
   name: pg
-  requirement: &13169320 !ruby/object:Gem::Requirement
+  requirement: &20417480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -56,10 +56,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13169320
+  version_requirements: *20417480
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &13168840 !ruby/object:Gem::Requirement
+  requirement: &20417000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -67,10 +67,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13168840
+  version_requirements: *20417000
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &13168360 !ruby/object:Gem::Requirement
+  requirement: &20416520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -78,10 +78,10 @@ dependencies:
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *13168360
+  version_requirements: *20416520
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &13167880 !ruby/object:Gem::Requirement
+  requirement: &20416040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -89,10 +89,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13167880
+  version_requirements: *20416040
 - !ruby/object:Gem::Dependency
   name: database_cleaner
-  requirement: &13167400 !ruby/object:Gem::Requirement
+  requirement: &20415560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -100,7 +100,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *13167400
+  version_requirements: *20415560
 description: Padrino version of the popular Rails tagging plugin. With ActsAsTaggableOnPadrino,
   you could tag a single model on several contexts, such as skills, interests, and
   awards. It also provides other advanced functionality.
@@ -141,7 +141,6 @@ files:
 - spec/acts_as_taggable_on_padrino/tagging_spec.rb
 - spec/acts_as_taggable_on_padrino/tags_helper_spec.rb
 - spec/bm.rb
-- spec/database.yml.sample
 - spec/models.rb
 - spec/schema.rb
 - spec/spec_helper.rb

data/spec/database.yml.sample

@@ -1,17 +0,0 @@
-sqlite3:
-  adapter: sqlite3
-  database: acts_as_taggable_on.sqlite3
-
-mysql:
-  adapter: mysql
-  hostname: localhost
-  username: root
-  password:
-  database: acts_as_taggable_on
-
-postgresql:
-  adapter: postgresql
-  hostname: localhost
-  username: postgres
-  password:
-  database: acts_as_taggable_on