nano-max-tool 0.0.1

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module Collection
+      extend ActiveSupport::Concern
+
+      included do
+        initialize_acts_as_taggable_on_collection
+      end
+
+      class_methods do
+        def initialize_acts_as_taggable_on_collection
+          tag_types.map(&:to_s).each do |tag_type|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{tag_type.singularize}_counts(options={})
+              tag_counts_on('#{tag_type}', options)
+            end
+
+            def #{tag_type.singularize}_counts(options = {})
+              tag_counts_on('#{tag_type}', options)
+            end
+
+            def top_#{tag_type}(limit = 10)
+              tag_counts_on('#{tag_type}', order: 'count desc', limit: limit.to_i)
+            end
+
+            def self.top_#{tag_type}(limit = 10)
+              tag_counts_on('#{tag_type}', order: 'count desc', limit: limit.to_i)
+            end
+            RUBY
+          end
+        end
+
+        def acts_as_taggable_on(*args)
+          super(*args)
+          initialize_acts_as_taggable_on_collection
+        end
+
+        def tag_counts_on(context, options = {})
+          all_tag_counts(options.merge({ on: context.to_s }))
+        end
+
+        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
+        def all_tags(options = {})
+          options = options.dup
+          options.assert_valid_keys :start_at, :end_at, :conditions, :order, :limit, :on
+
+          ## Generate conditions:
+          options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
+          ## Generate scope:
+          tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id")
+          tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*").order(options[:order]).limit(options[:limit])
+
+          # Joins and conditions
+          tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
+          tag_scope = tag_scope.where(options[:conditions])
+
+          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:
+          tagging_scope = generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key).group(group_columns)
+
+          tag_scope_joins(tag_scope, tagging_scope)
+        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
+        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
+
+          ## Generate conditions:
+          options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
+
+          ## Generate scope:
+          tagging_scope = ActsAsTaggableOn::Tagging.select("#{ActsAsTaggableOn::Tagging.table_name}.tag_id, COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) AS tags_count")
+          tag_scope = ActsAsTaggableOn::Tag.select("#{ActsAsTaggableOn::Tag.table_name}.*, #{ActsAsTaggableOn::Tagging.table_name}.tags_count AS count").order(options[:order]).limit(options[:limit])
+
+          # 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} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id"
+            taggable_join =  taggable_join + " AND #{table_name}.#{inheritance_column} = '#{name}'"
+            tagging_scope = tagging_scope.joins(taggable_join)
+          end
+
+          # Conditions
+          tagging_conditions(options).each { |condition| tagging_scope = tagging_scope.where(condition) }
+          tag_scope = tag_scope.where(options[:conditions])
+
+          # GROUP BY and HAVING clauses:
+          having = ["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) > 0"]
+          if options[:at_least]
+            having.push sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) >= ?",
+                                      options.delete(:at_least)])
+          end
+          if options[:at_most]
+            having.push sanitize_sql(["COUNT(#{ActsAsTaggableOn::Tagging.table_name}.tag_id) <= ?",
+                                      options.delete(:at_most)])
+          end
+          having = having.compact.join(' AND ')
+
+          group_columns = "#{ActsAsTaggableOn::Tagging.table_name}.tag_id"
+
+          unless options[:id]
+            # Append the current scope to the scope, because we can't use scope(:find) in RoR 3.0 anymore:
+            tagging_scope = generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
+          end
+
+          tagging_scope = tagging_scope.group(group_columns).having(having)
+
+          tag_scope_joins(tag_scope, tagging_scope)
+        end
+
+        def safe_to_sql(relation)
+          if connection.respond_to?(:unprepared_statement)
+            connection.unprepared_statement do
+              relation.to_sql
+            end
+          else
+            relation.to_sql
+          end
+        end
+
+        private
+
+        def generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
+          table_name_pkey = "#{table_name}.#{primary_key}"
+          if ActsAsTaggableOn::Utils.using_mysql?
+            # See https://github.com/mbleigh/acts-as-taggable-on/pull/457 for details
+            scoped_ids = pluck(table_name_pkey)
+            tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN (?)",
+                                                scoped_ids)
+          else
+            tagging_scope = tagging_scope.where("#{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN(#{safe_to_sql(except(:select).select(table_name_pkey))})")
+          end
+
+          tagging_scope
+        end
+
+        def tagging_conditions(options)
+          tagging_conditions = []
+          if options[:end_at]
+            tagging_conditions.push sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at <= ?",
+                                                  options.delete(:end_at)])
+          end
+          if options[:start_at]
+            tagging_conditions.push sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.created_at >= ?",
+                                                  options.delete(:start_at)])
+          end
+
+          taggable_conditions = sanitize_sql(["#{ActsAsTaggableOn::Tagging.table_name}.taggable_type = ?",
+                                              base_class.name])
+          if options[:on]
+            taggable_conditions << sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?",
+                                                 options.delete(:on).to_s])
+          end
+
+          if options[:id]
+            taggable_conditions << if options[:id].is_a? Array
+                                     sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id IN (?)",
+                                                   options[:id]])
+                                   else
+                                     sanitize_sql([" AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_id = ?",
+                                                   options[:id]])
+                                   end
+          end
+
+          tagging_conditions.push taggable_conditions
+
+          tagging_conditions
+        end
+
+        def tag_scope_joins(tag_scope, tagging_scope)
+          tag_scope = tag_scope.joins("JOIN (#{safe_to_sql(tagging_scope)}) AS #{ActsAsTaggableOn::Tagging.table_name} ON #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.id")
+          tag_scope.extending(CalculationMethods)
+        end
+      end
+
+      def tag_counts_on(context, options = {})
+        self.class.tag_counts_on(context, options.merge(id: id))
+      end
+
+      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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module Core
+      extend ActiveSupport::Concern
+
+      included do
+          attr_writer :custom_contexts
+
+          after_save :save_tags
+
+        initialize_acts_as_taggable_on_core
+      end
+
+      class_methods do
+        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" : [])
+
+            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, -> { includes(:tag).order(taggings_order).where(context: tags_type) },
+                       as: :taggable,
+                       class_name: 'ActsAsTaggableOn::Tagging',
+                       dependent: :destroy,
+                       after_add: :dirtify_tag_list,
+                       after_remove: :dirtify_tag_list
+
+              has_many context_tags, -> { order(taggings_order) },
+                       class_name: 'ActsAsTaggableOn::Tag',
+                       through: context_taggings,
+                       source: :tag
+
+              attribute "#{tags_type.singularize}_list".to_sym, ActsAsTaggableOn::Taggable::TagListType.new
+            end
+
+            taggable_mixin.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{tag_type}_list
+              tag_list_on('#{tags_type}')
+            end
+
+            def #{tag_type}_list=(new_tags)
+              parsed_new_list = ActsAsTaggableOn.default_parser.new(new_tags).parse
+
+              if self.class.preserve_tag_order? || (parsed_new_list.sort != #{tag_type}_list.sort)
+                unless #{tag_type}_list_changed?
+                  @attributes["#{tag_type}_list"] = ActiveModel::Attribute.from_user("#{tag_type}_list", #{tag_type}_list, ActsAsTaggableOn::Taggable::TagListType.new)
+                end
+                write_attribute("#{tag_type}_list", parsed_new_list)
+              end
+
+              set_tag_list_on('#{tags_type}', new_tags)
+            end
+
+            def all_#{tags_type}_list
+              all_tags_list_on('#{tags_type}')
+            end
+
+            private
+            def dirtify_tag_list(tagging)
+              attribute_will_change! tagging.context.singularize+"_list"
+            end
+            RUBY
+          end
+        end
+
+        def taggable_on(preserve_tag_order, *tag_types)
+          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(', ')
+        end
+
+        ##
+        # Return a scope of objects that are tagged with the specified tags.
+        #
+        # @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
+        #
+        # 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 = ActsAsTaggableOn.default_parser.new(tags).parse
+          options = options.dup
+
+          return none if tag_list.empty?
+
+          ::ActsAsTaggableOn::Taggable::TaggedWithQuery.build(self, ActsAsTaggableOn::Tag, ActsAsTaggableOn::Tagging,
+                                                              tag_list, options)
+        end
+
+        def is_taggable?
+          true
+        end
+
+        def taggable_mixin
+          @taggable_mixin ||= Module.new
+        end
+      end
+
+      # all column names are necessary for PostgreSQL group clause
+      def grouped_column_names_for(object)
+        self.class.grouped_column_names_for(object)
+      end
+
+      def custom_contexts
+        @custom_contexts ||= taggings.map(&:context).uniq
+      end
+
+      def is_taggable?
+        self.class.is_taggable?
+      end
+
+      def add_custom_context(value)
+        unless custom_contexts.include?(value.to_s) || self.class.tag_types.map(&:to_s).include?(value.to_s)
+          custom_contexts << value.to_s
+        end
+      end
+
+      def cached_tag_list_on(context)
+        self["cached_#{context.to_s.singularize}_list"]
+      end
+
+      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
+
+      def tag_list_cache_on(context)
+        variable_name = "@#{context.to_s.singularize}_list"
+        if instance_variable_get(variable_name)
+          instance_variable_get(variable_name)
+        elsif cached_tag_list_on(context) && ensure_included_cache_methods! && self.class.caching_tag_list_on?(context)
+          instance_variable_set(variable_name, ActsAsTaggableOn.default_parser.new(cached_tag_list_on(context)).parse)
+        else
+          instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(tags_on(context).map(&:name)))
+        end
+      end
+
+      def tag_list_on(context)
+        add_custom_context(context)
+        tag_list_cache_on(context)
+      end
+
+      def all_tags_list_on(context)
+        variable_name = "@all_#{context.to_s.singularize}_list"
+        if instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
+          return instance_variable_get(variable_name)
+        end
+
+        instance_variable_set(variable_name, ActsAsTaggableOn::TagList.new(all_tags_on(context).map(&:name)).freeze)
+      end
+
+      ##
+      # Returns all tags of a given context
+      def all_tags_on(context)
+        tagging_table_name = ActsAsTaggableOn::Tagging.table_name
+
+        opts = ["#{tagging_table_name}.context = ?", context.to_s]
+        scope = base_tags.where(opts)
+
+        if ActsAsTaggableOn::Utils.using_postgresql?
+          group_columns = grouped_column_names_for(ActsAsTaggableOn::Tag)
+          scope.order(Arel.sql("max(#{tagging_table_name}.created_at)")).group(group_columns)
+        else
+          scope.group("#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}")
+        end.to_a
+      end
+
+      ##
+      # Returns all tags that are not owned of a given context
+      def tags_on(context)
+        scope = base_tags.where([
+                                  "#{ActsAsTaggableOn::Tagging.table_name}.context = ? AND #{ActsAsTaggableOn::Tagging.table_name}.tagger_id IS NULL", context.to_s
+                                ])
+        # 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
+      end
+
+      def set_tag_list_on(context, new_list)
+        add_custom_context(context)
+
+        variable_name = "@#{context.to_s.singularize}_list"
+
+        parsed_new_list = ActsAsTaggableOn.default_parser.new(new_list).parse
+
+        instance_variable_set(variable_name, parsed_new_list)
+      end
+
+      def tagging_contexts
+        self.class.tag_types.map(&:to_s) + custom_contexts
+      end
+
+      def taggable_tenant
+        public_send(self.class.tenant_column) if self.class.tenant_column
+      end
+
+      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)
+      end
+
+      ##
+      # Find existing tags or create non-existing tags
+      def load_tags(tag_list)
+        ActsAsTaggableOn::Tag.find_or_create_all_with_like_by_name(tag_list)
+      end
+
+      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
+
+          # Find existing tags or create non-existing tags:
+          tags = find_or_create_tags_from_list_with_context(tag_list, context)
+
+          # Tag objects for currently assigned tags
+          current_tags = tags_on(context)
+
+          # Tag maintenance based on whether preserving the created order of tags
+          old_tags = current_tags - tags
+          new_tags = tags - current_tags
+          if self.class.preserve_tag_order?
+
+            shared_tags = current_tags & tags
+
+            if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
+              index = shared_tags.each_with_index do |_, i|
+                break i unless shared_tags[i] == tags[i]
+              end
+
+              # 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
+          end
+
+          # Destroy old taggings:
+          taggings.not_owned.by_context(context).where(tag_id: old_tags).destroy_all if old_tags.present?
+
+          # Create new taggings:
+          new_tags.each do |tag|
+            if taggable_tenant
+              taggings.create!(tag_id: tag.id, context: context.to_s, taggable: self, tenant: taggable_tenant)
+            else
+              taggings.create!(tag_id: tag.id, context: context.to_s, taggable: self)
+            end
+          end
+        end
+
+        true
+      end
+
+      private
+
+      def ensure_included_cache_methods!
+        self.class.columns
+      end
+
+      # Filters the tag lists from the attribute names.
+      def attributes_for_update(attribute_names)
+        tag_lists = tag_types.map { |tags_type| "#{tags_type.to_s.singularize}_list" }
+        super.delete_if { |attr| tag_lists.include? attr }
+      end
+
+      # Filters the tag lists from the attribute names.
+      def attributes_for_create(attribute_names)
+        tag_lists = tag_types.map { |tags_type| "#{tags_type.to_s.singularize}_list" }
+        super.delete_if { |attr| tag_lists.include? attr }
+      end
+
+      ##
+      # Override this hook if you wish to subclass {ActsAsTaggableOn::Tag} --
+      # context is provided so that you may conditionally use a Tag subclass
+      # only for some contexts.
+      #
+      # @example Custom Tag class for one context
+      #   class Company < ActiveRecord::Base
+      #     acts_as_taggable_on :markets, :locations
+      #
+      #     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)
+      #       else
+      #         super
+      #       end
+      #     end
+      #
+      # @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
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module Ownership
+      extend ActiveSupport::Concern
+
+      included do
+        after_save :save_owned_tags
+
+        initialize_acts_as_taggable_on_ownership
+      end
+
+      class_methods do
+        def acts_as_taggable_on(*args)
+          initialize_acts_as_taggable_on_ownership
+          super(*args)
+        end
+
+        def initialize_acts_as_taggable_on_ownership
+          tag_types.map(&:to_s).each do |tag_type|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{tag_type}_from(owner)
+              owner_tag_list_on(owner, '#{tag_type}')
+            end
+            RUBY
+          end
+        end
+      end
+
+      def owner_tags(owner)
+        scope = if owner.nil?
+                  base_tags
+                else
+                  base_tags.where(
+                    ActsAsTaggableOn::Tagging.table_name.to_s => {
+                      tagger_id: owner.id,
+                      tagger_type: owner.class.base_class.to_s
+                    }
+                  )
+                end
+
+        # when preserving tag order, return tags in created order
+        # if we added the order to the association this would always apply
+        if self.class.preserve_tag_order?
+          scope.order("#{ActsAsTaggableOn::Tagging.table_name}.id")
+        else
+          scope
+        end
+      end
+
+      def owner_tags_on(owner, context)
+        owner_tags(owner).where(
+          ActsAsTaggableOn::Tagging.table_name.to_s => {
+            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, {}
+        )
+      end
+
+      def owner_tag_list_on(owner, context)
+        add_custom_context(context)
+
+        cache = cached_owned_tag_list_on(context)
+
+        cache[owner] ||= ActsAsTaggableOn::TagList.new(*owner_tags_on(owner, context).map(&:name))
+      end
+
+      def set_owner_tag_list_on(owner, context, new_list)
+        add_custom_context(context)
+
+        cache = cached_owned_tag_list_on(context)
+
+        cache[owner] = ActsAsTaggableOn.default_parser.new(new_list).parse
+      end
+
+      def reload(*args)
+        self.class.tag_types.each do |context|
+          instance_variable_set("@owned_#{context}_list", nil)
+        end
+
+        super(*args)
+      end
+
+      def save_owned_tags
+        tagging_contexts.each do |context|
+          cached_owned_tag_list_on(context).each do |owner, tag_list|
+            # Find existing tags or create non-existing tags:
+            tags = find_or_create_tags_from_list_with_context(tag_list.uniq, context)
+
+            # Tag objects for owned tags
+            owned_tags = owner_tags_on(owner, context).to_a
+
+            # Tag maintenance based on whether preserving the created order of tags
+            old_tags = owned_tags - tags
+            new_tags = tags - owned_tags
+            if self.class.preserve_tag_order?
+
+              shared_tags = owned_tags & tags
+
+              if shared_tags.any? && tags[0...shared_tags.size] != shared_tags
+                index = shared_tags.each_with_index do |_, i|
+                  break i unless shared_tags[i] == tags[i]
+                end
+
+                # Update arrays of tag objects
+                old_tags |= owned_tags.from(index)
+                new_tags |= owned_tags.from(index) & shared_tags
+
+                # Order the array of tag objects to match the tag list
+                new_tags = tags.map do |t|
+                  new_tags.find do |n|
+                    n.name.downcase == t.name.downcase
+                  end
+                end.compact
+              end
+            else
+              # Delete discarded tags and create new tags
+            end
+
+            # Find all taggings that belong to the taggable (self), are owned by the owner,
+            # have the correct context, and are removed from the list.
+            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
+            end
+
+            # Create new taggings:
+            new_tags.each do |tag|
+              taggings.create!(tag_id: tag.id, context: context.to_s, tagger: owner, taggable: self)
+            end
+          end
+        end
+
+        true
+      end
+    end
+  end
+end