acts-as-taggable-on 3.5.0 → 8.1.0

data/lib/acts_as_taggable_on/taggable/ownership.rb

@@ -27,13 +27,16 @@ module ActsAsTaggableOn::Taggable
       end
     end
 
-    def owner_tags_on(owner, context)
+    def owner_tags(owner)
       if owner.nil?
-        scope = base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ?), context.to_s])
+        scope = base_tags
       else
-        scope = base_tags.where([%(#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND
-                                    #{ActsAsTaggableOn::Tagging.table_name}.tagger_id = ? AND
-                                    #{ActsAsTaggableOn::Tagging.table_name}.tagger_type = ?), context.to_s, owner.id, owner.class.base_class.to_s])
+        scope = base_tags.where(
+          "#{ActsAsTaggableOn::Tagging.table_name}" => {
+            tagger_id: owner.id,
+            tagger_type: owner.class.base_class.to_s
+          }
+        )
       end
 
       # when preserving tag order, return tags in created order
@@ -45,6 +48,14 @@ module ActsAsTaggableOn::Taggable
       end
     end
 
+    def owner_tags_on(owner, context)
+      owner_tags(owner).where(
+        "#{ActsAsTaggableOn::Tagging.table_name}" => {
+          context: context
+        }
+      )
+    end
+
     def cached_owned_tag_list_on(context)
       variable_name = "@owned_#{context}_list"
       (instance_variable_defined?(variable_name) && instance_variable_get(variable_name)) || instance_variable_set(variable_name, {})
@@ -108,9 +119,9 @@ 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.
-          ActsAsTaggableOn::Tagging.destroy_all(taggable_id: id, taggable_type: self.class.base_class.to_s,
-                                                            tagger_type: owner.class.base_class.to_s, tagger_id: owner.id,
-                                                            tag_id: old_tags, context: context) if old_tags.present?
+          ActsAsTaggableOn::Tagging.where(taggable_id: id, taggable_type: self.class.base_class.to_s,
+                                          tagger_type: owner.class.base_class.to_s, tagger_id: owner.id,
+                                          tag_id: old_tags, context: context).destroy_all if old_tags.present?
 
           # Create new taggings:
           new_tags.each do |tag|

data/lib/acts_as_taggable_on/taggable/related.rb

@@ -49,7 +49,7 @@ module ActsAsTaggableOn::Taggable
     private
 
     def exclude_self(klass, id)
-      "#{klass.table_name}.#{klass.primary_key} != #{id} AND" if [self.class.base_class, self.class].include? klass
+      "#{klass.arel_table[klass.primary_key].not_eq(id).to_sql} AND" if [self.class.base_class, self.class].include? klass
     end
 
     def group_columns(klass)

data/lib/acts_as_taggable_on/taggable/tag_list_type.rb

@@ -0,0 +1,4 @@
+module ActsAsTaggableOn::Taggable
+  class TagListType < ActiveModel::Type::Value
+  end
+end

data/lib/acts_as_taggable_on/taggable/tagged_with_query/all_tags_query.rb

@@ -0,0 +1,111 @@
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  class AllTagsQuery < QueryBase
+    def build
+      taggable_model.joins(each_tag_in_list)
+                    .group(by_taggable)
+                    .having(tags_that_matches_count)
+                    .order(order_conditions)
+                    .readonly(false)
+    end
+
+    private
+
+    def each_tag_in_list
+      arel_join = taggable_arel_table
+
+      tag_list.each do |tag|
+        tagging_alias = tagging_arel_table.alias(tagging_alias(tag))
+        arel_join = arel_join
+                      .join(tagging_alias)
+                      .on(on_conditions(tag, tagging_alias))
+      end
+
+      if options[:match_all].present?
+        arel_join = arel_join
+          .join(tagging_arel_table, Arel::Nodes::OuterJoin)
+          .on(
+            match_all_on_conditions
+          )
+      end
+
+      return arel_join.join_sources
+    end
+
+    def on_conditions(tag, tagging_alias)
+      on_condition = tagging_alias[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+        .and(tagging_alias[:taggable_type].eq(taggable_model.base_class.name))
+        .and(
+          tagging_alias[:tag_id].in(
+            tag_arel_table.project(tag_arel_table[:id]).where(tag_match_type(tag))
+          )
+        )
+
+      if options[:start_at].present?
+        on_condition = on_condition.and(tagging_alias[:created_at].gteq(options[:start_at]))
+      end
+
+      if options[:end_at].present?
+        on_condition = on_condition.and(tagging_alias[:created_at].lteq(options[:end_at]))
+      end
+
+      if options[:on].present?
+        on_condition = on_condition.and(tagging_alias[:context].eq(options[:on]))
+      end
+
+      if (owner = options[:owned_by]).present?
+        on_condition = on_condition.and(tagging_alias[:tagger_id].eq(owner.id))
+                                   .and(tagging_alias[:tagger_type].eq(owner.class.base_class.to_s))
+      end
+
+      on_condition
+    end
+
+    def match_all_on_conditions
+      on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                      .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+
+      if options[:start_at].present?
+        on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+      end
+
+      if options[:end_at].present?
+        on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+      end
+
+      if options[:on].present?
+        on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on]))
+      end
+
+      on_condition
+    end
+
+    def by_taggable
+      return [] unless options[:match_all].present?
+
+      taggable_arel_table[taggable_model.primary_key]
+    end
+
+    def tags_that_matches_count
+      return [] unless options[:match_all].present?
+
+      taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
+
+      tagging_arel_table[:taggable_id].count.eq(
+        tag_arel_table.project(Arel.star.count).where(tags_match_type)
+      )
+    end
+
+    def order_conditions
+      order_by = []
+      order_by << tagging_arel_table.project(tagging_arel_table[Arel.star].count.as('taggings_count')).order('taggings_count DESC').to_sql if options[:order_by_matching_tag_count].present? && options[:match_all].blank?
+
+      order_by << options[:order] if options[:order].present?
+      order_by.join(', ')
+    end
+
+    def tagging_alias(tag)
+      alias_base_name = taggable_model.base_class.name.downcase
+      adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag)}")
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable/tagged_with_query/any_tags_query.rb

@@ -0,0 +1,70 @@
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  class AnyTagsQuery < QueryBase
+    def build
+      taggable_model.select(all_fields)
+                    .where(model_has_at_least_one_tag)
+                    .order(Arel.sql(order_conditions))
+                    .readonly(false)
+    end
+
+    private
+
+    def all_fields
+      taggable_arel_table[Arel.star]
+    end
+
+    def model_has_at_least_one_tag
+      tagging_arel_table.project(Arel.star).where(at_least_one_tag).exists
+    end
+
+    def at_least_one_tag
+      exists_contition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                          .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                          .and(
+                            tagging_arel_table[:tag_id].in(
+                              tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
+                            )
+                          )
+
+      if options[:start_at].present?
+        exists_contition = exists_contition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+      end
+
+      if options[:end_at].present?
+        exists_contition = exists_contition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+      end
+
+      if options[:on].present?
+        exists_contition = exists_contition.and(tagging_arel_table[:context].eq(options[:on]))
+      end
+
+      if (owner = options[:owned_by]).present?
+        exists_contition = exists_contition.and(tagging_arel_table[:tagger_id].eq(owner.id))
+                                   .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+      end
+
+      exists_contition
+    end
+
+    def order_conditions
+      order_by = []
+      if options[:order_by_matching_tag_count].present?
+        order_by << "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{at_least_one_tag.to_sql}) desc"
+      end
+
+      order_by << options[:order] if options[:order].present?
+      order_by.join(', ')
+    end
+
+    def alias_name(tag_list)
+      alias_base_name = taggable_model.base_class.name.downcase
+      taggings_context = options[:on] ? "_#{options[:on]}" : ''
+
+      taggings_alias = adjust_taggings_alias(
+          "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag_list.join('_'))}"
+       )
+
+      taggings_alias
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable/tagged_with_query/exclude_tags_query.rb

@@ -0,0 +1,82 @@
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  class ExcludeTagsQuery < QueryBase
+    def build
+      taggable_model.joins(owning_to_tagger)
+                    .where(tags_not_in_list)
+                    .having(tags_that_matches_count)
+                    .readonly(false)
+    end
+
+    private
+
+    def tags_not_in_list
+      return taggable_arel_table[:id].not_in(
+            tagging_arel_table
+              .project(tagging_arel_table[:taggable_id])
+              .join(tag_arel_table)
+              .on(
+                  tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
+                  .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                  .and(tags_match_type)
+                )
+          )
+
+        # FIXME: missing time scope, this is also missing in the original implementation
+    end
+
+
+    def owning_to_tagger
+      return [] unless options[:owned_by].present?
+
+      owner = options[:owned_by]
+
+      arel_join = taggable_arel_table
+        .join(tagging_arel_table)
+        .on(
+            tagging_arel_table[:tagger_id].eq(owner.id)
+            .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+            .and(tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key]))
+            .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+          )
+
+      if options[:match_all].present?
+        arel_join = arel_join
+          .join(tagging_arel_table, Arel::Nodes::OuterJoin)
+          .on(
+            match_all_on_conditions
+          )
+      end
+
+      return arel_join.join_sources
+    end
+
+    def match_all_on_conditions
+      on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+
+      if options[:start_at].present?
+        on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+      end
+
+      if options[:end_at].present?
+        on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+      end
+
+      if options[:on].present?
+        on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on]))
+      end
+
+      on_condition
+    end
+
+    def tags_that_matches_count
+      return [] unless options[:match_all].present?
+
+      taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
+
+      tagging_arel_table[:taggable_id].count.eq(
+        tag_arel_table.project(Arel.star.count).where(tags_match_type)
+      )
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable/tagged_with_query/query_base.rb

@@ -0,0 +1,61 @@
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  class QueryBase
+    def initialize(taggable_model, tag_model, tagging_model, tag_list, options)
+      @taggable_model = taggable_model
+      @tag_model      = tag_model
+      @tagging_model  = tagging_model
+      @tag_list       = tag_list
+      @options        = options
+    end
+
+    private
+
+    attr_reader :taggable_model, :tag_model, :tagging_model, :tag_list, :options
+
+    def taggable_arel_table
+      @taggable_arel_table ||= taggable_model.arel_table
+    end
+
+    def tag_arel_table
+      @tag_arel_table ||= tag_model.arel_table
+    end
+
+    def tagging_arel_table
+      @tagging_arel_table ||=tagging_model.arel_table
+    end
+
+    def tag_match_type(tag)
+      matches_attribute = tag_arel_table[:name]
+      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+
+      if options[:wild].present?
+        matches_attribute.matches("%#{escaped_tag(tag)}%", "!", ActsAsTaggableOn.strict_case_match)
+      else
+        matches_attribute.matches(escaped_tag(tag), "!", ActsAsTaggableOn.strict_case_match)
+      end
+    end
+
+    def tags_match_type
+      matches_attribute = tag_arel_table[:name]
+      matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+
+      if options[:wild].present?
+        matches_attribute.matches_any(tag_list.map{|tag| "%#{escaped_tag(tag)}%"}, "!", ActsAsTaggableOn.strict_case_match)
+      else
+        matches_attribute.matches_any(tag_list.map{|tag| "#{escaped_tag(tag)}"}, "!", ActsAsTaggableOn.strict_case_match)
+      end
+    end
+
+    def escaped_tag(tag)
+      tag = tag.downcase unless ActsAsTaggableOn.strict_case_match
+      ActsAsTaggableOn::Utils.escape_like(tag)
+    end
+
+    def adjust_taggings_alias(taggings_alias)
+      if taggings_alias.size > 75
+        taggings_alias = 'taggings_alias_' + Digest::SHA1.hexdigest(taggings_alias)
+      end
+      taggings_alias
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable/tagged_with_query.rb

@@ -0,0 +1,16 @@
+require_relative 'tagged_with_query/query_base'
+require_relative 'tagged_with_query/exclude_tags_query'
+require_relative 'tagged_with_query/any_tags_query'
+require_relative 'tagged_with_query/all_tags_query'
+
+module ActsAsTaggableOn::Taggable::TaggedWithQuery
+  def self.build(taggable_model, tag_model, tagging_model, tag_list, options)
+    if options[:exclude].present?
+      ExcludeTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+    elsif options[:any].present?
+      AnyTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+    else
+      AllTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable.rb

@@ -54,6 +54,23 @@ module ActsAsTaggableOn
       taggable_on(true, tag_types)
     end
 
+    def acts_as_taggable_tenant(tenant)
+      if taggable?
+        self.tenant_column = tenant
+      else
+        class_attribute :tenant_column
+        self.tenant_column = tenant
+      end
+
+      # each of these add context-specific methods and must be
+      # called on each call of taggable_on
+      include Core
+      include Collection
+      include Cache
+      include Ownership
+      include Related
+    end
+
     private
 
       # Make a model taggable on specified contexts
@@ -78,6 +95,7 @@ module ActsAsTaggableOn
         self.tag_types = tag_types
         class_attribute :preserve_tag_order
         self.preserve_tag_order = preserve_tag_order
+        class_attribute :tenant_column
 
         class_eval do
           has_many :taggings, as: :taggable, dependent: :destroy, class_name: '::ActsAsTaggableOn::Tagging'
@@ -96,7 +114,6 @@ module ActsAsTaggableOn
       include Cache
       include Ownership
       include Related
-      include Dirty
     end
   end
 end

data/lib/acts_as_taggable_on/tagger.rb

@@ -15,18 +15,19 @@ module ActsAsTaggableOn
       #   end
       def acts_as_tagger(opts={})
         class_eval do
-          has_many_with_taggable_compatibility :owned_taggings,
-                                               opts.merge(
-                                                   as: :tagger,
-                                                   dependent: :destroy,
-                                                   class_name: '::ActsAsTaggableOn::Tagging'
-                                               )
+          owned_taggings_scope = opts.delete(:scope)
 
-          has_many_with_taggable_compatibility :owned_tags,
-                                               through: :owned_taggings,
-                                               source: :tag,
-                                               class_name: '::ActsAsTaggableOn::Tag',
-                                               uniq: true
+          has_many :owned_taggings, owned_taggings_scope,
+                   **opts.merge(
+                     as: :tagger,
+                     class_name: '::ActsAsTaggableOn::Tagging',
+                     dependent: :destroy
+                   )
+
+          has_many :owned_tags, -> { distinct },
+                   class_name: '::ActsAsTaggableOn::Tag',
+                   source: :tag,
+                   through: :owned_taggings
         end
 
         include ActsAsTaggableOn::Tagger::InstanceMethods

data/lib/acts_as_taggable_on/tagging.rb

@@ -1,25 +1,20 @@
 module ActsAsTaggableOn
   class Tagging < ::ActiveRecord::Base #:nodoc:
-    #TODO, remove from 4.0.0
-    attr_accessible :tag,
-                    :tag_id,
-                    :context,
-                    :taggable,
-                    :taggable_type,
-                    :taggable_id,
-                    :tagger,
-                    :tagger_type,
-                    :tagger_id if defined?(ActiveModel::MassAssignmentSecurity)
+    self.table_name = ActsAsTaggableOn.taggings_table
 
+    DEFAULT_CONTEXT = 'tags'
     belongs_to :tag, class_name: '::ActsAsTaggableOn::Tag', counter_cache: ActsAsTaggableOn.tags_counter
     belongs_to :taggable, polymorphic: true
-    belongs_to :tagger,   polymorphic: true
+
+    belongs_to :tagger, polymorphic: true, optional: true
 
     scope :owned_by, ->(owner) { where(tagger: owner) }
     scope :not_owned, -> { where(tagger_id: nil, tagger_type: nil) }
 
-    scope :by_contexts, ->(contexts = ['tags']) { where(context: contexts) }
-    scope :by_context, ->(context= 'tags') { by_contexts(context.to_s) }
+    scope :by_contexts, ->(contexts) { where(context: (contexts || DEFAULT_CONTEXT)) }
+    scope :by_context, ->(context = DEFAULT_CONTEXT) { by_contexts(context.to_s) }
+
+    scope :by_tenant, ->(tenant) { where(tenant: tenant) }
 
     validates_presence_of :context
     validates_presence_of :tag_id
@@ -35,7 +30,7 @@ module ActsAsTaggableOn
         if ActsAsTaggableOn.tags_counter
           tag.destroy if tag.reload.taggings_count.zero?
         else
-          tag.destroy if tag.reload.taggings.count.zero?
+          tag.destroy if tag.reload.taggings.none?
         end
       end
     end

data/lib/acts_as_taggable_on/utils.rb

@@ -13,7 +13,6 @@ module ActsAsTaggableOn
       end
 
       def using_mysql?
-        #We should probably use regex for mysql to support prehistoric adapters
         connection && connection.adapter_name == 'Mysql2'
       end
 
@@ -21,14 +20,14 @@ module ActsAsTaggableOn
         Digest::SHA1.hexdigest(string)[0..6]
       end
 
-      def active_record4?
-        ::ActiveRecord::VERSION::MAJOR == 4
-      end
-
       def like_operator
         using_postgresql? ? 'ILIKE' : 'LIKE'
       end
 
+      def legacy_activerecord?
+        ActiveRecord.version <= Gem::Version.new('5.3.0')
+      end
+
       # escape _ and % characters in strings, since these are wildcards in SQL.
       def escape_like(str)
         str.gsub(/[!%_]/) { |x| '!' + x }

data/lib/acts_as_taggable_on/version.rb

@@ -1,4 +1,3 @@
 module ActsAsTaggableOn
-  VERSION = '3.5.0'
+  VERSION = '8.1.0'
 end
-

data/spec/acts_as_taggable_on/acts_as_taggable_on_spec.rb

@@ -73,14 +73,6 @@ describe 'Acts As Taggable On' do
     end
   end
 
-  describe 'Reloading' do
-    it 'should save a model instantiated by Model.find' do
-      taggable = TaggableModel.create!(name: 'Taggable')
-      found_taggable = TaggableModel.find(taggable.id)
-      found_taggable.save
-    end
-  end
-
   describe 'Matching Contexts' do
     it 'should find objects with tags of matching contexts' do
       taggable1 = TaggableModel.create!(name: 'Taggable 1')
@@ -142,7 +134,7 @@ describe 'Acts As Taggable On' do
       taggable1.save
 
       column = TaggableModel.connection.quote_column_name("context")
-      offer_alias = TaggableModel.connection.quote_table_name("taggings")
+      offer_alias = TaggableModel.connection.quote_table_name(ActsAsTaggableOn.taggings_table)
       need_alias = TaggableModel.connection.quote_table_name("need_taggings_taggable_models_join")
 
       expect(TaggableModel.joins(:offerings, :needs).to_sql).to include "#{offer_alias}.#{column}"
@@ -154,7 +146,7 @@ describe 'Acts As Taggable On' do
   describe 'Tagging Contexts' do
     it 'should eliminate duplicate tagging contexts ' do
       TaggableModel.acts_as_taggable_on(:skills, :skills)
-      expect(TaggableModel.tag_types.freq[:skills]).to_not eq(3)
+      expect(TaggableModel.tag_types.freq[:skills]).to eq(1)
     end
 
     it 'should not contain embedded/nested arrays' do
@@ -178,6 +170,15 @@ describe 'Acts As Taggable On' do
         TaggableModel.acts_as_taggable_on([nil])
       }).to_not raise_error
     end
+
+    it 'should include dynamic contexts in tagging_contexts' do
+      taggable = TaggableModel.create!(name: 'Dynamic Taggable')
+      taggable.set_tag_list_on :colors, 'tag1, tag2, tag3'
+      expect(taggable.tagging_contexts).to eq(%w(tags languages skills needs offerings array colors))
+      taggable.save
+      taggable = TaggableModel.where(name: 'Dynamic Taggable').first
+      expect(taggable.tagging_contexts).to eq(%w(tags languages skills needs offerings array colors))
+    end
   end
 
   context 'when tagging context ends in an "s" when singular (ex. "status", "glass", etc.)' do
@@ -191,7 +192,7 @@ describe 'Acts As Taggable On' do
       its(:cached_glass_list)    { should be_blank }
 
       context 'language taggings cache after update' do
-        before  { @taggable.update_attributes(language_list: 'ruby, .net') }
+        before  { @taggable.update(language_list: 'ruby, .net') }
         subject { @taggable }
 
         its(:language_list)        { should == ['ruby', '.net']}
@@ -200,7 +201,7 @@ describe 'Acts As Taggable On' do
       end
 
       context 'status taggings cache after update' do
-        before  { @taggable.update_attributes(status_list: 'happy, married') }
+        before  { @taggable.update(status_list: 'happy, married') }
         subject { @taggable }
 
         its(:status_list)        { should     == ['happy', 'married'] }
@@ -213,7 +214,7 @@ describe 'Acts As Taggable On' do
 
       context 'glass taggings cache after update' do
         before do
-          @taggable.update_attributes(glass_list: 'rectangle, aviator')
+          @taggable.update(glass_list: 'rectangle, aviator')
         end
 
         subject { @taggable }

data/spec/acts_as_taggable_on/acts_as_tagger_spec.rb

@@ -72,7 +72,7 @@ describe 'acts_as_tagger' do
         expect(@taggable.tag_list_on(:foo_boo)).to be_empty
         expect(-> {
           @tagger.tag(@taggable, with: 'this, and, that', on: :foo_boo, force: false)
-        }).to raise_error
+        }).to raise_error(RuntimeError)
       end
 
       it 'should not create the tag context on-the-fly when the default is over-ridden' do