acts-as-taggable-on 2.4.0 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd04dd7817f5d465548706b2bb39ed8923bef126
-  data.tar.gz: 371cb9a485f0370ff51074edc74296219d6f1342
+  metadata.gz: d0b7cd2b4e279238a0fb8464721b40c3dbedaacd
+  data.tar.gz: edd07332dcbd884be1daab9e65d9be28b6f3f695
 SHA512:
-  metadata.gz: f6dd2e281ec95af2bf1b3779a96522a99c81aa06d09b6e59337805c94060419c9860ef707d378029214b58fae76a9d23ac67d9b94a978c91385fffb2f605d64b
-  data.tar.gz: 843b679f0dd4212e1b814323a3b253d8f8d62942acd30d0f696a64301064c6bc5d6f4b65cfb33d300929b3c2f6f7910c844e98fa9b9fabbd47c5fc03f968cb44
+  metadata.gz: 65f468a535ce620033df88d152bd5e1bff722c01a197d233794da097e682b29ad5f4ebf46b4eb46a18957d2ecda9f6699aad27b42789a2c8ee8d7c4f68e985ba
+  data.tar.gz: 2fd5249aa31f826fd56666dd3d07c4a63df1803722fc7e29c02b39fdbff6f0459316f30a1bb9345c53e885fa5a0edfd30495e211e8e6e90630600d9d60cd69a5

data/.gitignore

@@ -3,9 +3,9 @@
 /pkg/*
 .bundle
 .ruby-version
-Gemfile.lock
 spec/database.yml
 tmp*.sw?
 *.sw?
 tmp
 *.gem
+*.lock

data/Appraisals

@@ -0,0 +1,7 @@
+appraise "rails-3" do
+  gem "rails", "3.2.13"
+end
+
+appraise "rails-4" do
+  gem "rails", "4.0.0.beta1"
+end

data/Gemfile

@@ -1,3 +1,5 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
+
 gemspec
 
+gem 'appraisal'

data/README.md

@@ -14,18 +14,28 @@ Enter Acts as Taggable On. Rather than tying functionality to a specific keyword
 tag "contexts" that can be used locally or in combination in the same way steroids
 was used.
 
-## Installation
+## Compatibility
+
+Versions 2.x are compatible with Ruby 1.8.7+ and Rails 3.
+
+Versions 2.4.1 and up are compatible with Rails 4 too (thanks to arabonradar and cwoodcox).
 
-### Rails 2.x
+Versions 3.x (currently unreleased) are compatible with Ruby 1.9.3+ and Rails 3 and 4.
 
-Not supported any more! It is time for update guys.
+For an up-to-date roadmap, see https://github.com/mbleigh/acts-as-taggable-on/issues/milestones
 
-### Rails 3.x
+## Installation
 
 To use it, add it to your Gemfile:
 
 ```ruby
-gem 'acts-as-taggable-on', '~> 2.3.1'
+gem 'acts-as-taggable-on'
+```
+
+and bundle:
+
+```ruby
+bundle
 ```
 
 #### Post Installation
@@ -38,12 +48,15 @@ rake db:migrate
 ## Testing
 
 Acts As Taggable On uses RSpec for its test coverage. Inside the gem
-directory, you can run the specs for RoR 3.x with:
+directory, you can run the specs with:
 
 ```shell
+bundle
 rake spec
 ```
 
+If you want, add a `.ruby-version` file in the project root (and use rbenv or RVM) to work on a specific version of Ruby.
+
 ## Usage
 
 ```ruby
@@ -277,21 +290,14 @@ If you want to change the default delimiter (it defaults to ','). You can also p
 ActsAsTaggableOn.delimiter = ','
 ```
 
-## Changelog
-
-See [CHANGELOG](https://github.com/mbleigh/acts-as-taggable-on/blob/master/CHANGELOG.md).
-
 ## Contributors
 
 We have a long list of valued contributors. [Check them all](https://github.com/mbleigh/acts-as-taggable-on/contributors)
 
-## Maintainers
+## Maintainer
 
-* [Artem Kramarenko](https://github.com/artemk) (artemk)
 * [Joost Baaij](https://github.com/tilsammans)
 
-## Author
-
-* [Michael Bleigh](https://github.com/mbleigh)
+## License
 
-Copyright (c) 2007-2011 Michael Bleigh (http://mbleigh.com/) and Intridea Inc. (http://intridea.com/), released under the [MIT license](https://github.com/mbleigh/acts-as-taggable-on/blob/master/MIT-LICENSE.md)
+See [LICENSE](https://github.com/mbleigh/acts-as-taggable-on/blob/master/LICENSE.md)

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rubygems'
-require 'bundler'
-Bundler.setup :default, :development
+require 'bundler/setup'
+require 'appraisal'
 
 desc 'Default: run specs'
 task :default => :spec  

data/acts-as-taggable-on.gemspec

@@ -1,32 +1,35 @@
-$:.push File.dirname(__FILE__) + '/lib'
-require 'acts-as-taggable-on/version'
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_taggable_on/version'
 
 Gem::Specification.new do |gem|
-  gem.name = %q{acts-as-taggable-on}
-  gem.authors = ["Michael Bleigh"]
-  gem.date = %q{2012-07-16}
-  gem.description = %q{With ActsAsTaggableOn, you can tag a single model on several contexts, such as skills, interests, and awards. It also provides other advanced functionality.}
-  gem.summary = "Advanced tagging for Rails."
-  gem.email = %q{michael@intridea.com}
-  gem.homepage      = ''
+  gem.name          = "acts-as-taggable-on"
+  gem.version       = ActsAsTaggableOn::VERSION
+  gem.authors       = ["Michael Bleigh", "Joost Baaij"]
+  gem.email         = ["michael@intridea.com", "joost@spacebabies.nl"]
+  gem.description   = %q{With ActsAsTaggableOn, you can tag a single model on several contexts, such as skills, interests, and awards. It also provides other advanced functionality.}
+  gem.summary       = "Advanced tagging for Rails."
+  gem.homepage      = 'https://github.com/mbleigh/acts-as-taggable-on'
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
 
   if File.exists?('UPGRADING')
-    gem.post_install_message = File.read("UPGRADING")
+    gem.post_install_message = File.read('UPGRADING')
   end
 
-  gem.add_runtime_dependency 'rails', '~> 3.0'
+  gem.add_runtime_dependency 'rails', ['>= 3', '< 5']
+
+  gem.add_development_dependency 'rspec-rails', '2.13.0' # 2.13.1 is broken
   gem.add_development_dependency 'rspec', '~> 2.6'
-  gem.add_development_dependency 'ammeter', '~> 0.1.3'
+  gem.add_development_dependency 'ammeter'
   gem.add_development_dependency 'sqlite3'
   gem.add_development_dependency 'mysql2', '~> 0.3.7'
   gem.add_development_dependency 'pg'
   gem.add_development_dependency 'guard'
   gem.add_development_dependency 'guard-rspec'
-
-  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  gem.files         = `git ls-files`.split("\n")
-  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.name          = "acts-as-taggable-on"
-  gem.require_paths = ['lib']
-  gem.version       = ActsAsTaggableOn::VERSION
 end

data/gemfiles/rails_3.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "rails", "3.2.13"
+
+gemspec :path=>"../"

data/gemfiles/rails_4.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "rails", :github => 'rails/rails'
+
+gemspec :path=>"../"

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

@@ -36,6 +36,7 @@ end
 require "acts_as_taggable_on/utils"
 
 require "acts_as_taggable_on/taggable"
+require "acts_as_taggable_on/acts_as_taggable_on/compatibility"
 require "acts_as_taggable_on/acts_as_taggable_on/core"
 require "acts_as_taggable_on/acts_as_taggable_on/collection"
 require "acts_as_taggable_on/acts_as_taggable_on/cache"
@@ -53,6 +54,7 @@ $LOAD_PATH.shift
 
 
 if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend ActsAsTaggableOn::Compatibility
   ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
   ActiveRecord::Base.send :include, ActsAsTaggableOn::Tagger
 end

data/lib/acts_as_taggable_on/acts_as_taggable_on/collection.rb

@@ -86,12 +86,10 @@ module ActsAsTaggableOn::Taggable
         group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
 
         # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
-        scoped_select = "#{table_name}.#{primary_key}"
-        tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{select(scoped_select).to_sql})").
-                                      group(group_columns)
-
-        tag_scope = tag_scope.joins("JOIN (#{tagging_scope.to_sql}) AS #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id")
-        tag_scope
+        ids = select("#{table_name}.#{primary_key}").map(&:id)
+        tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(?)", ids).group(group_columns)
+        
+        tag_scope.joins("JOIN (#{tagging_scope.to_sql}) AS #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id")
       end
       
       ##
@@ -166,7 +164,7 @@ module ActsAsTaggableOn::Taggable
         scoped_select = "#{table_name}.#{primary_key}"
         select_query = "#{select(scoped_select).to_sql}"
 
-        res = ActiveRecord::Base.connection.select_all(select_query).map { |item| item.values }.flatten.join(",")
+        res = ActiveRecord::Base.connection.select_all(select_query).map { |item| item.values }.flatten.compact.join(",")
         res = "NULL" if res.blank?
 
         tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{res})")

data/lib/acts_as_taggable_on/acts_as_taggable_on/compatibility.rb

@@ -0,0 +1,34 @@
+module ActsAsTaggableOn::Compatibility
+  def has_many_with_compatibility(name, options = {}, &extention)
+    if ActiveRecord::VERSION::MAJOR >= 4
+      scope, opts = build_scope_and_options(options)
+      has_many(name, scope, opts, &extention)
+    else
+      has_many(name, options, &extention)
+    end
+  end
+
+  def build_scope_and_options(opts)
+    scope_opts, opts = parse_options(opts)
+
+    unless scope_opts.empty?
+      scope = lambda do 
+        scope_opts.inject(self) { |result, hash| result.send *hash }
+      end
+    end
+
+    [defined?(scope) ? scope : nil, opts]
+  end
+
+  def parse_options(opts)
+    scope_opts = {}
+    [:order, :having, :select, :group, :limit, :offset, :readonly].each do |o|
+      scope_opts[o] = opts.delete o if opts[o]
+    end
+    scope_opts[:where] = opts.delete :conditions if opts[:conditions]
+    scope_opts[:joins] = opts.delete :include if opts [:include]
+    scope_opts[:distinct] = opts.delete :uniq if opts[:uniq]
+
+    [scope_opts, opts]
+  end
+end

data/lib/acts_as_taggable_on/acts_as_taggable_on/core.rb

@@ -13,28 +13,30 @@ module ActsAsTaggableOn::Taggable
     end
 
     module ClassMethods
+
       def initialize_acts_as_taggable_on_core
         include taggable_mixin
         tag_types.map(&:to_s).each do |tags_type|
           tag_type         = tags_type.to_s.singularize
           context_taggings = "#{tag_type}_taggings".to_sym
           context_tags     = tags_type.to_sym
-          taggings_order   = (preserve_tag_order? ? "#{ActsAsTaggableOn::Tagging.table_name}.id" : nil)
-          
+          taggings_order   = (preserve_tag_order? ? "#{ActsAsTaggableOn::Tagging.table_name}.id" : [])
+
           class_eval do
             # when preserving tag order, include order option so that for a 'tags' context
             # the associations tag_taggings & tags are always returned in created order
-            has_many context_taggings, :as => :taggable,
-                                       :dependent => :destroy,
-                                       :include => :tag,
-                                       :class_name => "ActsAsTaggableOn::Tagging",
-                                       :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_type],
-                                       :order => taggings_order
-                                       
-            has_many context_tags, :through => context_taggings,
-                                   :source => :tag,
-                                   :class_name => "ActsAsTaggableOn::Tag",
-                                   :order => taggings_order
+            has_many_with_compatibility context_taggings, :as => :taggable,
+                                        :dependent => :destroy,
+                                        :class_name => "ActsAsTaggableOn::Tagging",
+                                        :order => taggings_order,
+                                        :conditions => ["#{ActsAsTaggableOn::Tagging.table_name}.context = (?)", tags_type],
+                                        :include => :tag
+
+            has_many_with_compatibility context_tags, :through => context_taggings,
+                                        :source => :tag,
+                                        :class_name => "ActsAsTaggableOn::Tag",
+                                        :order => taggings_order
+
           end
 
           taggable_mixin.class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -57,7 +59,7 @@ module ActsAsTaggableOn::Taggable
         super(preserve_tag_order, *tag_types)
         initialize_acts_as_taggable_on_core
       end
-      
+
       # all column names are necessary for PostgreSQL group clause
       def grouped_column_names_for(object)
         object.column_names.map { |column| "#{object.table_name}.#{column}" }.join(", ")
@@ -81,12 +83,14 @@ module ActsAsTaggableOn::Taggable
       #   User.tagged_with("awesome", "cool", :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
       def tagged_with(tags, options = {})
         tag_list = ActsAsTaggableOn::TagList.from(tags)
-        empty_result = scoped(:conditions => "1 = 0")
+        empty_result = where("1 = 0")
 
         return empty_result if tag_list.empty?
 
         joins = []
         conditions = []
+        having = []
+        select_clause = []
 
         context = options.delete(:on)
         owned_by = options.delete(:owned_by)
@@ -102,15 +106,23 @@ module ActsAsTaggableOn::Taggable
 
           conditions << "#{table_name}.#{primary_key} NOT IN (SELECT #{ActsAsTaggableOn::Tagging.table_name}.taggable_id FROM #{ActsAsTaggableOn::Tagging.table_name} JOIN #{ActsAsTaggableOn::Tag.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND (#{tags_conditions}) WHERE #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})"
 
+          if owned_by
+            joins <<  "JOIN #{ActsAsTaggableOn::Tagging.table_name}" +
+                      "  ON #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = #{quote_value(base_class.name)}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = #{owned_by.id}" +
+                      " AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = #{quote_value(owned_by.class.base_class.to_s)}"
+          end
+
         elsif options.delete(:any)
           # get tags, drop out if nothing returned (we need at least one)
-          if options.delete(:wild)
-            tags = ActsAsTaggableOn::Tag.named_like_any(tag_list)
+          tags = if options.delete(:wild)
+            ActsAsTaggableOn::Tag.named_like_any(tag_list)
           else
-            tags = ActsAsTaggableOn::Tag.named_any(tag_list)
+            ActsAsTaggableOn::Tag.named_any(tag_list)
           end
 
-          return scoped(:conditions => "1 = 0") unless tags.length > 0
+          return empty_result unless tags.length > 0
 
           # setup taggings alias so we can chain, ex: items_locations_taggings_awesome_cool_123
           # avoid ambiguous column name
@@ -129,29 +141,37 @@ module ActsAsTaggableOn::Taggable
           conditions << tags.map { |t| "#{taggings_alias}.tag_id = #{t.id}" }.join(" OR ")
           select_clause = "DISTINCT #{table_name}.*" unless context and tag_types.one?
 
-          joins << tagging_join
+          if owned_by
+              tagging_join << " AND " +
+                  sanitize_sql([
+                      "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                      owned_by.id,
+                      owned_by.class.base_class.to_s
+                  ])
+          end
 
+          joins << tagging_join
         else
           tags = ActsAsTaggableOn::Tag.named_any(tag_list)
+
           return empty_result unless tags.length == tag_list.length
 
           tags.each do |tag|
-
             taggings_alias = adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{sha_prefix(tag.name)}")
-
             tagging_join  = "JOIN #{ActsAsTaggableOn::Tagging.table_name} #{taggings_alias}" +
                             "  ON #{taggings_alias}.taggable_id = #{quote}#{table_name}#{quote}.#{primary_key}" +
                             " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}" +
                             " AND #{taggings_alias}.tag_id = #{tag.id}"
+
             tagging_join << " AND " + sanitize_sql(["#{taggings_alias}.context = ?", context.to_s]) if context
 
             if owned_by
                 tagging_join << " AND " +
-                    sanitize_sql([
-                        "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
-                        owned_by.id,
-                        owned_by.class.base_class.to_s
-                    ])
+                  sanitize_sql([
+                    "#{taggings_alias}.tagger_id = ? AND #{taggings_alias}.tagger_type = ?",
+                    owned_by.id,
+                    owned_by.class.base_class.to_s
+                  ])
             end
 
             joins << tagging_join
@@ -171,13 +191,13 @@ module ActsAsTaggableOn::Taggable
           having = "COUNT(#{taggings_alias}.taggable_id) = #{tags.size}"
         end
 
-        scoped(:select     => select_clause,
-               :joins      => joins.join(" "),
-               :group      => group,
-               :having     => having,
-               :conditions => conditions.join(" AND "),
-               :order      => options[:order],
-               :readonly   => false)
+        select(select_clause) \
+          .joins(joins.join(" ")) \
+          .where(conditions.join(" AND ")) \
+          .group(group) \
+          .having(having) \
+          .order(options[:order]) \
+          .readonly(false)
       end
 
       def is_taggable?
@@ -252,12 +272,10 @@ module ActsAsTaggableOn::Taggable
 
         if ActsAsTaggableOn::Tag.using_postgresql?
           group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
-          scope = scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
+          scope.order("max(#{tagging_table_name}.created_at)").group(group_columns)
         else
-          scope = scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
-        end
-
-        scope.all
+          scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
+        end.to_a
       end
 
       ##
@@ -267,7 +285,7 @@ module ActsAsTaggableOn::Taggable
         # when preserving tag order, return tags in created order
         # if we added the order to the association this would always apply
         scope = scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id") if self.class.preserve_tag_order?
-        scope.all
+        scope
       end
 
       def set_tag_list_on(context, new_list)
@@ -309,7 +327,6 @@ module ActsAsTaggableOn::Taggable
       def save_tags
         tagging_contexts.each do |context|
           next unless tag_list_cache_set_on(context)
-
           # List of currently assigned tag names
           tag_list = tag_list_cache_on(context).uniq
 
@@ -321,13 +338,22 @@ module ActsAsTaggableOn::Taggable
 
           # Tag maintenance based on whether preserving the created order of tags
           if self.class.preserve_tag_order?
-            # First off order the array of tag objects to match the tag list
-            # rather than existing tags followed by new tags
-            tags = tag_list.map{|l| tags.detect{|t| t.name.downcase == l.downcase}}
-            # To preserve tags in the order in which they were added
-            # delete all current tags and create new tags if the content or order has changed
-            old_tags = (tags == current_tags ? [] : current_tags)
-            new_tags = (tags == current_tags ? [] : tags)
+            old_tags, new_tags = current_tags - tags, tags - current_tags
+
+            shared_tags = current_tags & tags
+
+            if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
+              index = shared_tags.each_with_index { |_, i| break i unless shared_tags[i] == tags[i] }
+
+              # Update arrays of tag objects
+              old_tags |= current_tags[index...current_tags.size]
+              new_tags |= current_tags[index...current_tags.size] & shared_tags
+
+              # Order the array of tag objects to match the tag list
+              new_tags = tags.map do |t| 
+                new_tags.find { |n| n.name.downcase == t.name.downcase }
+              end.compact
+            end
           else
             # Delete discarded tags and create new tags
             old_tags = current_tags - tags
@@ -336,8 +362,7 @@ module ActsAsTaggableOn::Taggable
 
           # Find taggings to remove:
           if old_tags.present?
-            old_taggings = taggings.where(:tagger_type => nil, :tagger_id => nil,
-                                          :context => context.to_s, :tag_id => old_tags).all
+            old_taggings = taggings.where(:tagger_type => nil, :tagger_id => nil, :context => context.to_s, :tag_id => old_tags)
           end
 
           # Destroy old taggings: