acts-as-taggable-on 7.0.0 → 9.0.1

data/lib/acts_as_taggable_on/tag.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module ActsAsTaggableOn
   class Tag < ::ActiveRecord::Base
     self.table_name = ActsAsTaggableOn.tags_table
@@ -31,35 +32,43 @@ module ActsAsTaggableOn
     end
 
     def self.named_any(list)
-      clause = list.map { |tag|
+      clause = list.map do |tag|
         sanitize_sql_for_named_any(tag).force_encoding('BINARY')
-      }.join(' OR ')
+      end.join(' OR ')
       where(clause)
     end
 
     def self.named_like(name)
-      clause = ["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(name)}%"]
+      clause = ["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'",
+                "%#{ActsAsTaggableOn::Utils.escape_like(name)}%"]
       where(clause)
     end
 
     def self.named_like_any(list)
-      clause = list.map { |tag|
-        sanitize_sql(["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(tag.to_s)}%"])
-      }.join(' OR ')
+      clause = list.map do |tag|
+        sanitize_sql(["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'",
+                      "%#{ActsAsTaggableOn::Utils.escape_like(tag.to_s)}%"])
+      end.join(' OR ')
       where(clause)
     end
 
     def self.for_context(context)
-      joins(:taggings).
-        where(["#{ActsAsTaggableOn.taggings_table}.context = ?", context]).
-        select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
+      joins(:taggings)
+        .where(["#{ActsAsTaggableOn.taggings_table}.context = ?", context])
+        .select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
+    end
+
+    def self.for_tenant(tenant)
+      joins(:taggings)
+        .where("#{ActsAsTaggableOn.taggings_table}.tenant = ?", tenant.to_s)
+        .select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
     end
 
     ### CLASS METHODS:
 
     def self.find_or_create_with_like_by_name(name)
       if ActsAsTaggableOn.strict_case_match
-        self.find_or_create_all_with_like_by_name([name]).first
+        find_or_create_all_with_like_by_name([name]).first
       else
         named_like(name).first || create(name: name)
       end
@@ -72,27 +81,25 @@ module ActsAsTaggableOn
 
       existing_tags = named_any(list)
       list.map do |tag_name|
-        begin
-          tries ||= 3
-          comparable_tag_name = comparable_name(tag_name)
-          existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
-          existing_tag || create(name: tag_name)
-        rescue ActiveRecord::RecordNotUnique
-          if (tries -= 1).positive?
-            ActiveRecord::Base.connection.execute 'ROLLBACK'
-            existing_tags = named_any(list)
-            retry
-          end
-
-          raise DuplicateTagError.new("'#{tag_name}' has already been taken")
+        tries ||= 3
+        comparable_tag_name = comparable_name(tag_name)
+        existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
+        existing_tag || create(name: tag_name)
+      rescue ActiveRecord::RecordNotUnique
+        if (tries -= 1).positive?
+          ActiveRecord::Base.connection.execute 'ROLLBACK'
+          existing_tags = named_any(list)
+          retry
         end
+
+        raise DuplicateTagError, "'#{tag_name}' has already been taken"
       end
     end
 
     ### INSTANCE METHODS:
 
-    def ==(object)
-      super || (object.is_a?(Tag) && name == object.name)
+    def ==(other)
+      super || (other.is_a?(Tag) && name == other.name)
     end
 
     def to_s
@@ -104,7 +111,6 @@ module ActsAsTaggableOn
     end
 
     class << self
-
       private
 
       def comparable_name(str)

data/lib/acts_as_taggable_on/tag_list.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
 
 require 'active_support/core_ext/module/delegation'
 
 module ActsAsTaggableOn
   class TagList < Array
-    attr_accessor :owner
-    attr_accessor :parser
+    attr_accessor :owner, :parser
 
     def initialize(*args)
       @parser = ActsAsTaggableOn.default_parser
@@ -34,8 +34,8 @@ module ActsAsTaggableOn
 
     # Concatenation --- Returns a new tag list built by concatenating the
     # two tag lists together to produce a third tag list.
-    def +(other_tag_list)
-      TagList.new.add(self).add(other_tag_list)
+    def +(other)
+      TagList.new.add(self).add(other)
     end
 
     # Appends the elements of +other_tag_list+ to +self+.
@@ -65,12 +65,12 @@ module ActsAsTaggableOn
     #   tag_list = TagList.new("Round", "Square,Cube")
     #   tag_list.to_s # 'Round, "Square,Cube"'
     def to_s
-      tags = frozen? ? self.dup : self
+      tags = frozen? ? dup : self
       tags.send(:clean!)
 
       tags.map do |name|
         d = ActsAsTaggableOn.delimiter
-        d = Regexp.new d.join('|') if d.kind_of? Array
+        d = Regexp.new d.join('|') if d.is_a? Array
         name.index(d) ? "\"#{name}\"" : name
       end.join(ActsAsTaggableOn.glue)
     end
@@ -85,22 +85,19 @@ module ActsAsTaggableOn
       map! { |tag| tag.mb_chars.downcase.to_s } if ActsAsTaggableOn.force_lowercase
       map!(&:parameterize) if ActsAsTaggableOn.force_parameterize
 
-      ActsAsTaggableOn.strict_case_match ? uniq! : uniq!{ |tag| tag.downcase }
+      ActsAsTaggableOn.strict_case_match ? uniq! : uniq!(&:downcase)
       self
     end
 
-
     def extract_and_apply_options!(args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       options.assert_valid_keys :parse, :parser
 
-      parser = options[:parser] ? options[:parser] : @parser
+      parser = options[:parser] || @parser
 
       args.map! { |a| parser.new(a).parse } if options[:parse] || options[:parser]
 
       args.flatten!
     end
-
   end
 end
-

data/lib/acts_as_taggable_on/taggable/cache.rb

@@ -1,89 +1,91 @@
-module ActsAsTaggableOn::Taggable
-  module Cache
-    def self.included(base)
-      # When included, conditionally adds tag caching methods when the model
-      #   has any "cached_#{tag_type}_list" column
-      base.extend Columns
-    end
+# frozen_string_literal: true
 
-    module Columns
-      # ActiveRecord::Base.columns makes a database connection and caches the
-      #   calculated columns hash for the record as @columns.  Since we don't
-      #   want to add caching methods until we confirm the presence of a
-      #   caching column, and we don't want to force opening a database
-      #   connection when the class is loaded, here we intercept and cache
-      #   the call to :columns as @acts_as_taggable_on_cache_columns
-      #   to mimic the underlying behavior.  While processing this first
-      #   call to columns, we do the caching column check and dynamically add
-      #   the class and instance methods
-      #   FIXME: this method cannot compile in rubinius
-      def columns
-        @acts_as_taggable_on_cache_columns ||= begin
-          db_columns = super
-          _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
-          db_columns
-        end
+module ActsAsTaggableOn
+  module Taggable
+    module Cache
+      def self.included(base)
+        # When included, conditionally adds tag caching methods when the model
+        #   has any "cached_#{tag_type}_list" column
+        base.extend Columns
       end
 
-      def reset_column_information
-        super
-        @acts_as_taggable_on_cache_columns = nil
-      end
+      module Columns
+        # ActiveRecord::Base.columns makes a database connection and caches the
+        #   calculated columns hash for the record as @columns.  Since we don't
+        #   want to add caching methods until we confirm the presence of a
+        #   caching column, and we don't want to force opening a database
+        #   connection when the class is loaded, here we intercept and cache
+        #   the call to :columns as @acts_as_taggable_on_cache_columns
+        #   to mimic the underlying behavior.  While processing this first
+        #   call to columns, we do the caching column check and dynamically add
+        #   the class and instance methods
+        #   FIXME: this method cannot compile in rubinius
+        def columns
+          @acts_as_taggable_on_cache_columns ||= begin
+            db_columns = super
+            _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
+            db_columns
+          end
+        end
 
-      private
+        def reset_column_information
+          super
+          @acts_as_taggable_on_cache_columns = nil
+        end
+
+        private
 
-      # @private
-      def _has_tags_cache_columns?(db_columns)
-        db_column_names = db_columns.map(&:name)
-        tag_types.any? do |context|
-          db_column_names.include?("cached_#{context.to_s.singularize}_list")
+        # @private
+        def _has_tags_cache_columns?(db_columns)
+          db_column_names = db_columns.map(&:name)
+          tag_types.any? do |context|
+            db_column_names.include?("cached_#{context.to_s.singularize}_list")
+          end
         end
-      end
 
-      # @private
-      def _add_tags_caching_methods
-        send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
-        extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
+        # @private
+        def _add_tags_caching_methods
+          send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
+          extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
 
-        before_save :save_cached_tag_list
+          before_save :save_cached_tag_list
 
-        initialize_tags_cache
+          initialize_tags_cache
+        end
       end
-    end
 
-    module ClassMethods
-      def initialize_tags_cache
-        tag_types.map(&:to_s).each do |tag_type|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      module ClassMethods
+        def initialize_tags_cache
+          tag_types.map(&:to_s).each do |tag_type|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def self.caching_#{tag_type.singularize}_list?
               caching_tag_list_on?("#{tag_type}")
             end
-          RUBY
+            RUBY
+          end
         end
-      end
 
-      def acts_as_taggable_on(*args)
-        super(*args)
-        initialize_tags_cache
-      end
+        def acts_as_taggable_on(*args)
+          super(*args)
+          initialize_tags_cache
+        end
 
-      def caching_tag_list_on?(context)
-        column_names.include?("cached_#{context.to_s.singularize}_list")
+        def caching_tag_list_on?(context)
+          column_names.include?("cached_#{context.to_s.singularize}_list")
+        end
       end
-    end
 
-    module InstanceMethods
-      def save_cached_tag_list
-        tag_types.map(&:to_s).each do |tag_type|
-          if self.class.send("caching_#{tag_type.singularize}_list?")
-            if tag_list_cache_set_on(tag_type)
+      module InstanceMethods
+        def save_cached_tag_list
+          tag_types.map(&:to_s).each do |tag_type|
+            if self.class.send("caching_#{tag_type.singularize}_list?") && tag_list_cache_set_on(tag_type)
               list = tag_list_cache_on(tag_type).to_a.flatten.compact.join("#{ActsAsTaggableOn.delimiter} ")
               self["cached_#{tag_type.singularize}_list"] = list
             end
           end
-        end
 
-        true
+          true
+        end
       end
     end
   end