make_taggable 0.7.4 → 1.0.0

data/lib/make_taggable/taggable/collection.rb

@@ -1,11 +1,32 @@
+# frozen_string_literal: true
+
 module MakeTaggable::Taggable
+  ##
+  # Counting tags, for tag clouds and "most used" lists.
+  #
+  # Each context gets `<context>_counts` and `top_<context>` on both the class and its instances.
+  #
   module Collection
+    ##
+    # @param base [Class] the model being made taggable
+    # @return [void]
+    #
+    # @api private
+    #
     def self.included(base)
       base.extend MakeTaggable::Taggable::Collection::ClassMethods
       base.initialize_make_taggable_collection
     end
 
+    ##
+    # Added to every taggable model.
+    #
     module ClassMethods
+      ##
+      # Defines the counting methods for each context.
+      #
+      # @return [void]
+      #
       def initialize_make_taggable_collection
         tag_types.map(&:to_s).each do |tag_type|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -28,30 +49,56 @@ module MakeTaggable::Taggable
         end
       end
 
+      ##
+      # Adds contexts and refreshes the counting methods.
+      #
+      # @param args [Array<Symbol, String>] the contexts to add
+      # @return [void]
+      #
       def make_taggable(*args)
-        super(*args)
+        super
         initialize_make_taggable_collection
       end
 
+      ##
+      # Tags used in one context, each carrying how often it was used.
+      #
+      # @param context [Symbol, String] the tagging context
+      # @param options [Hash] options accepted by {#all_tag_counts}
+      # @return [ActiveRecord::Relation]
+      #
+      # @example
+      #   Book.tag_counts_on(:genres)
+      #
       def tag_counts_on(context, options = {})
         all_tag_counts(options.merge({on: context.to_s}))
       end
 
+      ##
+      # Tags used in one context, without counting them.
+      #
+      # @param context [Symbol, String] the tagging context
+      # @param options [Hash] options accepted by {#all_tags}
+      # @return [ActiveRecord::Relation]
+      #
       def tags_on(context, options = {})
         all_tags(options.merge({on: context.to_s}))
       end
 
       ##
-      # Calculate the tag names.
-      # To be used when you don't need tag counts and want to avoid the taggable joins.
-      #
-      # @param [Hash] options Options:
-      #                       * :start_at   - Restrict the tags to those created after a certain time
-      #                       * :end_at     - Restrict the tags to those created before a certain time
-      #                       * :conditions - A piece of SQL conditions to add to the query. Note we don't join the taggable objects for performance reasons.
-      #                       * :limit      - The maximum number of tags to return
-      #                       * :order      - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
-      #                       * :on         - Scope the find to only include a certain context
+      # Every tag applied to this model, without counting them.
+      #
+      # Cheaper than {#all_tag_counts}, which has to join the taggables.
+      #
+      # @param options [Hash] the query options
+      # @option options [Time, Date] :start_at only tags applied after this time
+      # @option options [Time, Date] :end_at only tags applied before this time
+      # @option options [String, Array] :conditions SQL conditions added to the tag query
+      # @option options [Integer] :limit the most tags to return
+      # @option options [String] :order SQL to order by, such as `"tags.name asc"`
+      # @option options [Symbol, String] :on only tags applied in this context
+      # @return [ActiveRecord::Relation]
+      #
       def all_tags(options = {})
         options = options.dup
         options.assert_valid_keys :start_at, :end_at, :conditions, :order, :limit, :on
@@ -76,17 +123,22 @@ module MakeTaggable::Taggable
       end
 
       ##
-      # Calculate the tag counts for all tags.
-      #
-      # @param [Hash] options Options:
-      #                       * :start_at   - Restrict the tags to those created after a certain time
-      #                       * :end_at     - Restrict the tags to those created before a certain time
-      #                       * :conditions - A piece of SQL conditions to add to the query
-      #                       * :limit      - The maximum number of tags to return
-      #                       * :order      - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
-      #                       * :at_least   - Exclude tags with a frequency less than the given value
-      #                       * :at_most    - Exclude tags with a frequency greater than the given value
-      #                       * :on         - Scope the find to only include a certain context
+      # Every tag applied to this model, each carrying how often it was used as a `count` attribute.
+      #
+      # @param options [Hash] the query options
+      # @option options [Time, Date] :start_at only tags applied after this time
+      # @option options [Time, Date] :end_at only tags applied before this time
+      # @option options [String, Array] :conditions SQL conditions added to the tag query
+      # @option options [Integer] :limit the most tags to return
+      # @option options [String] :order SQL to order by, such as `"count desc"`
+      # @option options [Integer] :at_least skip tags used fewer times than this
+      # @option options [Integer] :at_most skip tags used more times than this
+      # @option options [Symbol, String] :on only tags applied in this context
+      # @return [ActiveRecord::Relation]
+      #
+      # @example The ten most used genres
+      #   Book.all_tag_counts(on: :genres, order: "count desc", limit: 10)
+      #
       def all_tag_counts(options = {})
         options = options.dup
         options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :on, :id
@@ -101,7 +153,7 @@ module MakeTaggable::Taggable
         # Current model is STI descendant, so add type checking to the join condition
         unless descends_from_active_record?
           taggable_join = "INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{MakeTaggable::Tagging.table_name}.taggable_id"
-          taggable_join << " AND #{table_name}.#{inheritance_column} = '#{name}'"
+          taggable_join += sanitize_sql([" AND #{table_name}.#{inheritance_column} = ?", name])
           tagging_scope = tagging_scope.joins(taggable_join)
         end
 
@@ -127,8 +179,16 @@ module MakeTaggable::Taggable
         tag_scope_joins(tag_scope, tagging_scope)
       end
 
+      ##
+      # A relation's SQL with its bind parameters inlined, so it can be embedded in another query.
+      #
+      # @param relation [ActiveRecord::Relation] the relation to render
+      # @return [String]
+      #
+      # @api private
+      #
       def safe_to_sql(relation)
-        connection.respond_to?(:unprepared_statement) ? connection.unprepared_statement { relation.to_sql } : relation.to_sql
+        connection.unprepared_statement { relation.to_sql }
       end
 
       private
@@ -166,17 +226,29 @@ module MakeTaggable::Taggable
       end
     end
 
+    ##
+    # Tags used on this record in one context, each carrying how often it was used.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @param options [Hash] options accepted by {ClassMethods#all_tag_counts}
+    # @return [ActiveRecord::Relation]
+    #
     def tag_counts_on(context, options = {})
       self.class.tag_counts_on(context, options.merge(id: id))
     end
 
+    # These relations carry a custom SELECT -- the tag columns plus an aliased
+    # count -- which Active Record would otherwise fold into the COUNT(). Count
+    # rows instead, whatever the relation selects.
     module CalculationMethods
-      # Rails 5 TODO: Remove options argument as soon we remove support to
-      # activerecord-deprecated_finders.
-      # See https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/calculations.rb#L38
-      def count(column_name = :all, options = {})
-        # https://github.com/rails/rails/commit/da9b5d4a8435b744fcf278fffd6d7f1e36d4a4f2
-        super(column_name)
+      ##
+      # Counts rows rather than the relation's selected columns.
+      #
+      # @param column_name [Symbol, String] the column to count
+      # @return [Integer]
+      #
+      def count(column_name = :all)
+        super
       end
     end
   end

data/lib/make_taggable/taggable/core.rb

@@ -1,8 +1,20 @@
+# frozen_string_literal: true
+
 require_relative "tagged_with_query"
 require_relative "tag_list_type"
 
 module MakeTaggable::Taggable
+  ##
+  # The heart of tagging: the associations, the generated `<context>_list` readers and writers, and
+  # the `tagged_with` query.
+  #
   module Core
+    ##
+    # @param base [Class] the model being made taggable
+    # @return [void]
+    #
+    # @api private
+    #
     def self.included(base)
       base.extend MakeTaggable::Taggable::Core::ClassMethods
 
@@ -14,12 +26,21 @@ module MakeTaggable::Taggable
       base.initialize_make_taggable_core
     end
 
+    ##
+    # Added to every taggable model.
+    #
     module ClassMethods
+      ##
+      # Builds the associations and the `<context>_list` methods for each context.
+      #
+      # @return [void]
+      #
       def initialize_make_taggable_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_taggings = :"#{tag_type}_taggings"
           context_tags = tags_type.to_sym
           taggings_order = (preserve_tag_order? ? "#{MakeTaggable::Tagging.table_name}.id" : [])
 
@@ -38,7 +59,7 @@ module MakeTaggable::Taggable
               through: context_taggings,
               source: :tag
 
-            attribute "#{tags_type.singularize}_list".to_sym, MakeTaggable::Taggable::TagListType.new
+            attribute :"#{tags_type.singularize}_list", MakeTaggable::Taggable::TagListType.new
           end
 
           taggable_mixin.class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -50,12 +71,8 @@ module MakeTaggable::Taggable
               parsed_new_list = MakeTaggable.default_parser.new(new_tags).parse
 
               if self.class.preserve_tag_order? || (parsed_new_list.sort != #{tag_type}_list.sort)
-                if MakeTaggable::Utils.legacy_activerecord?
-                  set_attribute_was("#{tag_type}_list", #{tag_type}_list)
-                else
-                  unless #{tag_type}_list_changed?
-                    @attributes["#{tag_type}_list"] = ActiveModel::Attribute.from_user("#{tag_type}_list", #{tag_type}_list, MakeTaggable::Taggable::TagListType.new)
-                  end
+                unless #{tag_type}_list_changed?
+                  @attributes["#{tag_type}_list"] = ActiveModel::Attribute.from_user("#{tag_type}_list", #{tag_type}_list, MakeTaggable::Taggable::TagListType.new)
                 end
                 write_attribute("#{tag_type}_list", parsed_new_list)
               end
@@ -75,8 +92,17 @@ module MakeTaggable::Taggable
         end
       end
 
+      ##
+      # Adds contexts and rebuilds the generated methods.
+      #
+      # @param preserve_tag_order [TrueClass, FalseClass] whether to keep tags in the order added
+      # @param tag_types [Array<Symbol, String>] the contexts to add
+      # @return [void]
+      #
+      # @api private
+      #
       def taggable_on(preserve_tag_order, *tag_types)
-        super(preserve_tag_order, *tag_types)
+        super
         initialize_make_taggable_core
       end
 
@@ -86,26 +112,34 @@ module MakeTaggable::Taggable
       end
 
       ##
-      # Return a scope of objects that are tagged with the specified tags.
+      # Records tagged with the given tags.
+      #
+      # By default a record must carry every tag given. `:any` relaxes that to at least one, and
+      # `:exclude` inverts it to none.
       #
-      # @param tags The tags that we want to query for
-      # @param [Hash] options A hash of options to alter you query:
-      #                       * <tt>:exclude</tt> - if set to true, return objects that are *NOT* tagged with the specified tags
-      #                       * <tt>:any</tt> - if set to true, return objects that are tagged with *ANY* of the specified tags
-      #                       * <tt>:order_by_matching_tag_count</tt> - if set to true and used with :any, sort by objects matching the most tags, descending
-      #                       * <tt>:match_all</tt> - if set to true, return objects that are *ONLY* tagged with the specified tags
-      #                       * <tt>:owned_by</tt> - return objects that are *ONLY* owned by the owner
-      #                       * <tt>:start_at</tt> - Restrict the tags to those created after a certain time
-      #                       * <tt>:end_at</tt> - Restrict the tags to those created before a certain time
+      # @param tags [String, Array<String>] the tags to match
+      # @param options [Hash] the query options
+      # @option options [TrueClass, FalseClass] :any match records carrying any of the tags
+      # @option options [TrueClass, FalseClass] :exclude match records carrying none of the tags
+      # @option options [TrueClass, FalseClass] :match_all match records carrying only these tags
+      # @option options [TrueClass, FalseClass] :wild match tags containing the given text
+      # @option options [TrueClass, FalseClass] :order_by_matching_tag_count with `:any`, order by
+      #   how many tags matched, most first
+      # @option options [ActiveRecord::Base] :owned_by only tags applied by this tagger
+      # @option options [Symbol, String] :on only tags applied in this context
+      # @option options [Time, Date] :start_at only tags applied after this time
+      # @option options [Time, Date] :end_at only tags applied before this time
+      # @return [ActiveRecord::Relation] empty when no tags are given
+      #
+      # @example Every tag
+      #   User.tagged_with(["awesome", "cool"])
+      #
+      # @example Any tag, most matches first
+      #   User.tagged_with(["awesome", "cool"], any: true, order_by_matching_tag_count: true)
+      #
+      # @example Scoped to a context and an owner
+      #   Photo.tagged_with("paris", on: :locations, owned_by: @user)
       #
-      # Example:
-      #   User.tagged_with(["awesome", "cool"])                     # Users that are tagged with awesome and cool
-      #   User.tagged_with(["awesome", "cool"], :exclude => true)   # Users that are not tagged with awesome or cool
-      #   User.tagged_with(["awesome", "cool"], :any => true)       # Users that are tagged with awesome or cool
-      #   User.tagged_with(["awesome", "cool"], :any => true, :order_by_matching_tag_count => true)  # Sort by users who match the most tags, descending
-      #   User.tagged_with(["awesome", "cool"], :match_all => true) # Users that are tagged with just awesome and cool
-      #   User.tagged_with(["awesome", "cool"], :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
-      #   User.tagged_with(["awesome", "cool"], :owned_by => foo, :start_at => Date.today ) # Users that are tagged with just awesome, cool by 'foo' and starting today
       def tagged_with(tags, options = {})
         tag_list = MakeTaggable.default_parser.new(tags).parse
         options = options.dup
@@ -119,6 +153,12 @@ module MakeTaggable::Taggable
         true
       end
 
+      ##
+      # The module the generated `<context>_list` methods are defined on, so a model can override
+      # one and call `super`.
+      #
+      # @return [Module]
+      #
       def taggable_mixin
         @taggable_mixin ||= Module.new
       end
@@ -129,6 +169,11 @@ module MakeTaggable::Taggable
       self.class.grouped_column_names_for(object)
     end
 
+    ##
+    # Contexts this record has been tagged in beyond those the model declares.
+    #
+    # @return [Array<String>]
+    #
     def custom_contexts
       @custom_contexts ||= taggings.map(&:context).uniq
     end
@@ -137,19 +182,43 @@ module MakeTaggable::Taggable
       self.class.is_taggable?
     end
 
+    ##
+    # Records a context the model does not declare, so it takes part in saving and reloading.
+    #
+    # @param value [Symbol, String] the context
+    # @return [Array<String>, NilClass]
+    #
     def add_custom_context(value)
       custom_contexts << value.to_s unless custom_contexts.include?(value.to_s) || self.class.tag_types.map(&:to_s).include?(value.to_s)
     end
 
+    ##
+    # The rendered tag list held in this context's caching column, if the model has one.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [String, NilClass]
+    #
     def cached_tag_list_on(context)
       self["cached_#{context.to_s.singularize}_list"]
     end
 
+    ##
+    # Whether a context's tag list has been loaded or assigned on this record.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [TrueClass, FalseClass, MakeTaggable::TagList]
+    #
     def tag_list_cache_set_on(context)
       variable_name = "@#{context.to_s.singularize}_list"
       instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
     end
 
+    ##
+    # A context's tag list, loading it from the caching column or the database as needed.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [MakeTaggable::TagList]
+    #
     def tag_list_cache_on(context)
       variable_name = "@#{context.to_s.singularize}_list"
       if instance_variable_get(variable_name)
@@ -161,11 +230,28 @@ module MakeTaggable::Taggable
       end
     end
 
+    ##
+    # A context's tag list, covering contexts the model does not declare.
+    #
+    # Only unowned tags appear here. Use {#all_tags_list_on} to include tags applied by a tagger.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [MakeTaggable::TagList]
+    #
+    # @example
+    #   @user.tag_list_on(:customs) # => ["one", "two"]
+    #
     def tag_list_on(context)
       add_custom_context(context)
       tag_list_cache_on(context)
     end
 
+    ##
+    # A context's tag list including tags applied by a tagger.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [MakeTaggable::TagList] frozen
+    #
     def all_tags_list_on(context)
       variable_name = "@all_#{context.to_s.singularize}_list"
       return instance_variable_get(variable_name) if instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
@@ -199,6 +285,18 @@ module MakeTaggable::Taggable
       scope
     end
 
+    ##
+    # Replaces a context's tag list, covering contexts the model does not declare. Saved with the
+    # record.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @param new_list [String, Array<String>] the tags to apply
+    # @return [MakeTaggable::TagList]
+    #
+    # @example
+    #   @user.set_tag_list_on(:customs, "same, as, tag, list")
+    #   @user.save
+    #
     def set_tag_list_on(context, new_list)
       add_custom_context(context)
 
@@ -209,17 +307,28 @@ module MakeTaggable::Taggable
       instance_variable_set(variable_name, parsed_new_list)
     end
 
+    ##
+    # Every context this record tags in, declared and dynamic alike.
+    #
+    # @return [Array<String>]
+    #
     def tagging_contexts
       self.class.tag_types.map(&:to_s) + custom_contexts
     end
 
+    ##
+    # Reloads the record, discarding the tag lists held in memory.
+    #
+    # @param args [Array<Object>] arguments forwarded to Active Record
+    # @return [ActiveRecord::Base] self
+    #
     def reload(*args)
       self.class.tag_types.each do |context|
         instance_variable_set("@#{context.to_s.singularize}_list", nil)
         instance_variable_set("@all_#{context.to_s.singularize}_list", nil)
       end
 
-      super(*args)
+      super
     end
 
     ##
@@ -228,6 +337,11 @@ module MakeTaggable::Taggable
       MakeTaggable::Tag.find_or_create_all_with_like_by_name(tag_list)
     end
 
+    ##
+    # Writes every assigned tag list to the database. Runs after save.
+    #
+    # @return [TrueClass]
+    #
     def save_tags
       tagging_contexts.each do |context|
         next unless tag_list_cache_set_on(context)
@@ -298,14 +412,17 @@ module MakeTaggable::Taggable
     end
 
     ##
-    # Override this hook if you wish to subclass {MakeTaggable::Tag} --
-    # context is provided so that you may conditionally use a Tag subclass
-    # only for some contexts.
+    # Finds or creates the tag records for a list, given the context they are being applied in.
     #
-    # @example Custom Tag class for one context
+    # Override it to keep a separate vocabulary for one context by returning tags from a
+    # {MakeTaggable::Tag} subclass.
+    #
+    # @example A separate Tag subclass for one context
     #   class Company < ActiveRecord::Base
     #     make_taggable :markets, :locations
     #
+    #     private
+    #
     #     def find_or_create_tags_from_list_with_context(tag_list, context)
     #       if context.to_sym == :markets
     #         MarketTag.find_or_create_all_with_like_by_name(tag_list)
@@ -313,9 +430,12 @@ module MakeTaggable::Taggable
     #         super
     #       end
     #     end
+    #   end
+    #
+    # @param tag_list [Array<String>] the tags to find or create
+    # @param _context [Symbol] the context the tags are being applied in
+    # @return [Array<MakeTaggable::Tag>]
     #
-    # @param [Array<String>] tag_list Tags to find or create
-    # @param [Symbol] context The tag context for the tag_list
     def find_or_create_tags_from_list_with_context(tag_list, _context)
       load_tags(tag_list)
     end

data/lib/make_taggable/taggable/ownership.rb

@@ -1,5 +1,21 @@
+# frozen_string_literal: true
+
 module MakeTaggable::Taggable
+  ##
+  # Tags applied by a tagger, kept separate from the record's own tags.
+  #
+  # Owned tags do not appear in `tag_list`, which only ever returns unowned tags. Use
+  # `all_tags_list` to see both together.
+  #
+  # @see MakeTaggable::Tagger
+  #
   module Ownership
+    ##
+    # @param base [Class] the model being made taggable
+    # @return [void]
+    #
+    # @api private
+    #
     def self.included(base)
       base.extend MakeTaggable::Taggable::Ownership::ClassMethods
 
@@ -10,12 +26,26 @@ module MakeTaggable::Taggable
       base.initialize_make_taggable_ownership
     end
 
+    ##
+    # Added to every taggable model.
+    #
     module ClassMethods
+      ##
+      # Adds contexts and refreshes the ownership readers.
+      #
+      # @param args [Array<Symbol, String>] the contexts to add
+      # @return [void]
+      #
       def make_taggable(*args)
         initialize_make_taggable_ownership
-        super(*args)
+        super
       end
 
+      ##
+      # Defines a `<context>_from(owner)` reader for each context.
+      #
+      # @return [void]
+      #
       def initialize_make_taggable_ownership
         tag_types.map(&:to_s).each do |tag_type|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -27,6 +57,12 @@ module MakeTaggable::Taggable
       end
     end
 
+    ##
+    # This record's tags belonging to one owner, across every context.
+    #
+    # @param owner [ActiveRecord::Base, NilClass] the tagger, or `nil` for every tag on the record
+    # @return [ActiveRecord::Relation]
+    #
     def owner_tags(owner)
       scope = if owner.nil?
         base_tags
@@ -48,6 +84,16 @@ module MakeTaggable::Taggable
       end
     end
 
+    ##
+    # This record's tags belonging to one owner, in one context.
+    #
+    # @param owner [ActiveRecord::Base, NilClass] the tagger, or `nil` for every tag on the record
+    # @param context [Symbol, String] the tagging context
+    # @return [ActiveRecord::Relation]
+    #
+    # @example
+    #   @photo.owner_tags_on(@user, :locations)
+    #
     def owner_tags_on(owner, context)
       owner_tags(owner).where(
         MakeTaggable::Tagging.table_name.to_s => {
@@ -56,11 +102,24 @@ module MakeTaggable::Taggable
       )
     end
 
+    ##
+    # The per-owner tag lists held in memory for a context, keyed by owner.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [Hash{ActiveRecord::Base => MakeTaggable::TagList}]
+    #
     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, {})
     end
 
+    ##
+    # One owner's tag list for a context.
+    #
+    # @param owner [ActiveRecord::Base] the tagger
+    # @param context [Symbol, String] the tagging context
+    # @return [MakeTaggable::TagList]
+    #
     def owner_tag_list_on(owner, context)
       add_custom_context(context)
 
@@ -69,6 +128,14 @@ module MakeTaggable::Taggable
       cache[owner] ||= MakeTaggable::TagList.new(*owner_tags_on(owner, context).map(&:name))
     end
 
+    ##
+    # Replaces one owner's tag list for a context. Saved with the record.
+    #
+    # @param owner [ActiveRecord::Base] the tagger
+    # @param context [Symbol, String] the tagging context
+    # @param new_list [String, Array<String>] the tags to apply
+    # @return [MakeTaggable::TagList]
+    #
     def set_owner_tag_list_on(owner, context, new_list)
       add_custom_context(context)
 
@@ -77,14 +144,25 @@ module MakeTaggable::Taggable
       cache[owner] = MakeTaggable.default_parser.new(new_list).parse
     end
 
+    ##
+    # Reloads the record, discarding the owned tag lists held in memory.
+    #
+    # @param args [Array<Object>] arguments forwarded to Active Record
+    # @return [ActiveRecord::Base] self
+    #
     def reload(*args)
       self.class.tag_types.each do |context|
         instance_variable_set("@owned_#{context}_list", nil)
       end
 
-      super(*args)
+      super
     end
 
+    ##
+    # Writes every owner's tag lists to the database. Runs after save.
+    #
+    # @return [TrueClass]
+    #
     def save_owned_tags
       tagging_contexts.each do |context|
         cached_owned_tag_list_on(context).each do |owner, tag_list|
@@ -120,8 +198,8 @@ module MakeTaggable::Taggable
           # have the correct context, and are removed from the list.
           if old_tags.present?
             MakeTaggable::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
+              tagger_type: owner.class.base_class.to_s, tagger_id: owner.id,
+              tag_id: old_tags, context: context).destroy_all
           end
 
           # Create new taggings: