acts-as-taggable-on-mongoid 6.0.1.4 → 6.1.1.11

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_migration.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Models
+    module Concerns
+      # A module that defines methods to migrate a Tag model.
+      #
+      # Mongoid does not have a standardized migration scheme, but migrations of one kind or another
+      # are often a fact of life, and are in this situation because of the need to change an existing
+      # index.
+      #
+      # Using whatever migration methodology you prefer, you need to run the appropriate migration method
+      # or methods on the Tag module used by your project.
+      #
+      # The migrations are named for the ActsAsTaggableMongoid versions upon which they need to be run.
+      # Run the correct migration(s) for the version of ActsAsTaggableOnMongoid you are currently using
+      # This module does not and cannot verify the version you are migrating from nor if the migration
+      # has been run before.  Doing so is assumed to be the responsibility of your chosen
+      # Migration methodology.
+      #
+      # Example:
+      #
+      # # When a migration is needed, the method "up" is called:
+      # def up
+      #   TaggingModel.include ActsAsTaggableOnMongoid::Models::Concerns::TaggingMigration
+      #   TaggingModel.atom_migrate_up_6_0_1_to_6_1_1
+      # end
+      #
+      # The migration methods should only be run once if possible, but every reasonable effort is made to
+      # ensure that the migration methods are safe to re-run.
+      module TaggingMigration
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # :reek:UncommunicativeMethodName - The name indicates what gem versions the migration is from/to
+          def atom_migrate_up_6_0_1_to_6_1_1
+            indexes = collection.indexes
+            indexes.drop_one "tagging_taggable_context_tag_name" if indexes.get "tagging_taggable_context_tag_name"
+
+            create_indexes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOnMongoid
   module Models
     module Concerns

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_scopes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOnMongoid
   module Models
     module Concerns
@@ -8,12 +10,14 @@ module ActsAsTaggableOnMongoid
         DEFAULT_CONTEXT = "tags"
 
         included do
-          # scope :owned_by, ->(owner) { where(tagger: owner) }
-          # scope :not_owned, -> { where(tagger_id: nil, tagger_type: nil) }
+          # aliased scopes from ActsAsTaggable
+          scope :owned_by, ->(tagger) { tagged_by(tagger) }
+          scope :not_owned, -> { tagged_by(nil) }
 
-          scope :by_contexts, ->(*contexts) { where(:context.in => Array.wrap(contexts.presence || DEFAULT_CONTEXT)) }
-          scope :by_context, ->(context = DEFAULT_CONTEXT) { by_contexts(context.to_s) }
-          scope :for_tag, ->(tag_definition) { where(taggable_type: tag_definition.owner.name).by_context(tag_definition.tag_type) }
+          scope :by_tag_types, ->(*tag_types) { where(:context.in => Array.wrap(tag_types.presence || DEFAULT_CONTEXT)) }
+          scope :by_tag_type, ->(tag_type = DEFAULT_CONTEXT) { by_tag_types(tag_type.to_s) }
+          scope :tagged_by, ->(tagger) { tagger ? where(tagger: tagger) : where(:tagger_id.exists => false) }
+          scope :for_tag, ->(tag_definition) { where(taggable_type: tag_definition.owner.name).by_tag_type(tag_definition.tag_type) }
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/models/concerns/tagging_validations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsTaggableOnMongoid
   module Models
     module Concerns
@@ -8,13 +10,9 @@ module ActsAsTaggableOnMongoid
         included do
           validates :tag_name, presence: true
           validates :context, presence: true
-          validates :tag, presence: true
-          validates :taggable, presence: true
 
-          # validates :tag_id, uniqueness: {scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]}
-          validates :tag_name, uniqueness: { scope: %i[taggable_type taggable_id context] }
-          # validates :tag_id, uniqueness: {scope: [:taggable_type, :taggable_id, :context, :tagger_id, :tagger_type]}
-          validates :tag_id, uniqueness: { scope: %i[taggable_type taggable_id context] }
+          validates :tag_name, uniqueness: { scope: %i[taggable_id taggable_type context tagger_id tagger_type] }
+          validates :tag_id, uniqueness: { scope: %i[taggable_id taggable_type context tagger_id tagger_type] }
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/tag_list.rb

@@ -12,6 +12,16 @@ module ActsAsTaggableOnMongoid
   #
   # If the input value(s) are to be parsed, then all values passed in are parsed.
   #
+  # Options:
+  #   parse   - True/False - indicates if all of the strings that are passed in are to be parsed
+  #             to split them into an array of strings.
+  #             Please note - if the passed in value is an array of strings, every string in the array
+  #             will be parsed.  If it is a single array, then just that string is parsed.
+  #   parser  - Class - A class that is used to parse the passed in strings.
+  #             If this parameter is supplied, parse is assumed to be truthy even if it is not passed in.
+  #   tagger  - object - An object that is to be used as the Tagger for the Taggable object.
+  #             This parameter is ignored if the tag does not support Taggers.
+  #
   # Examples:
   #   TagList.new(tag_definition, "value 1", "value 2")
   #   # > TagList<> ["value 1", "value 2"]
@@ -38,6 +48,40 @@ module ActsAsTaggableOnMongoid
       add(*args)
     end
 
+    class << self
+      def new_taggable_list(tag_definition, taggable)
+        list = ActsAsTaggableOnMongoid::TagList.new(tag_definition)
+
+        list.taggable = taggable
+
+        list
+      end
+    end
+
+    def dup
+      list          = ActsAsTaggableOnMongoid::TagList.new(tag_definition, *self)
+      list.tagger   = instance_variable_get(:@tagger) if instance_variable_defined?(:@tagger)
+      list.taggable = taggable
+
+      list
+    end
+
+    def tagger=(value)
+      return unless tag_definition.tagger?
+
+      instance_variable_set(:@tagger, value)
+    end
+
+    def tagger
+      return nil unless tag_definition.tagger?
+      return tag_definition.default_tagger(taggable) unless instance_variable_defined?(:@tagger)
+
+      tagger = instance_variable_get(:@tagger)
+      tagger = taggable&.public_send(tagger) if tagger.is_a?(Symbol)
+
+      instance_variable_set(:@tagger, tagger)
+    end
+
     ##
     # Add tags to the tag_list. Duplicate or blank tags will be ignored.
     # Use the <tt>:parse</tt> option to add an unparsed tag string.
@@ -53,6 +97,17 @@ module ActsAsTaggableOnMongoid
       self
     end
 
+    ##
+    # Replaces the tags with the tags passed in.
+    #
+    # Example:
+    #   tag_list.set("Fun", "Happy")
+    #   tag_list.set("Fun, Happy", :parse => true)
+    def set(*names)
+      clear
+      add(*names)
+    end
+
     # Append---Add the tag to the tag_list. This
     # expression returns the tag_list itself, so several appends
     # may be chained together.
@@ -63,7 +118,13 @@ module ActsAsTaggableOnMongoid
     # Concatenation --- Returns a new tag list built by concatenating the
     # two tag lists together to produce a third tag list.
     def +(other)
-      TagList.new(tag_definition).add(*self).add(other)
+      dup.add(other)
+    end
+
+    # Removal --- Returns a new tag list built by removing the
+    # passed in tag list to produce a third tag list.
+    def -(other)
+      dup.remove(other)
     end
 
     # Appends the elements of +other_tag_list+ to +self+.
@@ -75,6 +136,27 @@ module ActsAsTaggableOnMongoid
       self
     end
 
+    # Appends the elements of +other_tag_list+ to +self+.
+    def clear
+      notify_will_change
+
+      super
+
+      self
+    end
+
+    # Appends the elements of +other_tag_list+ to +self+.
+    def silent_concat(other_tag_list)
+      temp_taggable = taggable
+      self.taggable = nil
+
+      concat(other_tag_list)
+
+      self.taggable = temp_taggable
+
+      self
+    end
+
     ##
     # Remove specific tags from the tag_list.
     # Use the <tt>:parse</tt> option to add an unparsed tag string.
@@ -151,13 +233,18 @@ module ActsAsTaggableOnMongoid
       self
     end
 
-    # :reek:FeatureEnvy
-    # :reek:DuplicateMethodCall
     def extract_and_apply_options!(args)
       dup_args = args.dup
       options  = dup_args.extract_options!.dup
-      options.assert_valid_keys :parse, :parser
 
+      options.assert_valid_keys :parse, :parser, :tagger
+
+      instance_variable_set(:@tagger, options[:tagger]) if options.key?(:tagger) && tag_definition.tagger?
+
+      parse_args_values(dup_args, options)
+    end
+
+    def parse_args_values(dup_args, options)
       options_parser = options[:parser]
       run_parser     = options_parser || tag_definition.parser
 

data/lib/acts_as_taggable_on_mongoid/taggable.rb

@@ -18,7 +18,14 @@ module ActsAsTaggableOnMongoid
       #   * preserve_tag_order
       #     If true, the _list accessor will save and returns tags in the order they are added to the object.
       #   * cached_in_model
-      #     Not currently supported
+      #     If true, a field is added to de-normalize/cache the list into.  Can also be a hash with options:
+      #       field: The name of the field to cache the list in
+      #       as_list: true/false - If the cached value should be an Array or a String.  No order is guaranteed
+      #                             in either case.
+      #                             Defaults to true.
+      #   * owner_id_field
+      #     If cached_in_model is true, if a tag is owned, this is the field that will be checked for a matching
+      #     owner ID for tag updates and deletes.
       #   * force_lowercase
       #     If true, values stored for tags will first be downcased to make the values effectively case-insensitive
       #   * force_parameterize
@@ -34,6 +41,18 @@ module ActsAsTaggableOnMongoid
       #     can be used.  If custom options like `parse` or `parser` are to be used for the default, the value
       #     must be passed in as an array with a hash as the last value.  Like list setters, parsing is assumed.
       #     Example:  default: ["this, is, a, list", parser: ActsAsTaggableOnMongoid::GenericParser]
+      #   * tagger
+      #     Multiple variants
+      #
+      #     true - If simply the value `true`, the tag list supports owners.  No default owner will be used when
+      #            setting or accessing tag_lists
+      #     Hash - A hash of values defining default options for the tag list:
+      #            * default_tagger
+      #              A symbol of a method on the taggable object that owns the HashList which is used to determine
+      #              the default owner for a list if an owner is not specified.
+      #            * tag_list_uses_default_tagger
+      #              true/false indicating if a non-owner method that returns a tag_list should assume the default_tagger
+      #              or return items with no owner.
 
       ##
       # This is an alias for calling <tt>acts_as_taggable_on :tags</tt>.
@@ -110,9 +129,9 @@ module ActsAsTaggableOnMongoid
          ActsAsTaggableOnMongoid::Taggable::Changeable,
          ActsAsTaggableOnMongoid::Taggable::TaggedWith,
          # include Collection - not sure we will need as done here.  Need to think more on this one.
-         # include Cache - TODO: Add this.
-         # include Ownership - TODO: Add this.
+         ActsAsTaggableOnMongoid::Taggable::Cache,
          # include Related - TODO: Add this.
+         ActsAsTaggableOnMongoid::Taggable::TaggerRelation,
          ActsAsTaggableOnMongoid::Taggable::ListTags].each do |include_module|
           include include_module unless included_modules.include?(include_module)
         end

data/lib/acts_as_taggable_on_mongoid/taggable/cache.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    # A collection of generic methods which use the tag definition to perform actions.
+    #
+    # These methods are called by the individual tag generated methods to do their work so that
+    # the code can be defined in only one location and "shared" by all tags rather than putting the code
+    # and definitions into the dynamically defined methods directly.
+    #
+    # This module actually consists almost exclusively of utility functions
+
+    # :reek:FeatureEnvy
+    # :reek:UtilityFunction
+    module Cache
+      def save_cached_tag_lists
+        tag_types.each_value do |tag_definition|
+          next unless tag_definition.cached_in_model?
+          next unless tag_list_cache_set_on(tag_definition)
+
+          list = all_tags_list_on(tag_definition)
+
+          list = list.to_s unless tag_definition.cached_in_model_as_list?
+
+          public_send("#{tag_definition.cached_in_model_field}=", list)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/changeable.rb

@@ -40,9 +40,9 @@ module ActsAsTaggableOnMongoid
         tag_types.each_value do |tag_definition|
           tag_list_name = tag_definition.tag_list_name
 
-          next unless changed_attributes.key? tag_list_name
+          next unless public_send("#{tag_list_name}_changed?")
 
-          changed_values[tag_list_name] = [changed_attributes[tag_list_name], public_send(tag_list_name)]
+          changed_values[tag_list_name] = public_send("#{tag_list_name}_change")
         end
 
         changed_values
@@ -60,11 +60,12 @@ module ActsAsTaggableOnMongoid
       private
 
       def attribute_will_change!(attribute_name)
-        return super if tag_types.none? { |_tag_name, tag_definition| tag_definition.tag_list_name.to_s == attribute_name.to_s }
+        tag_definition = tag_types.detect { |_tag_name, tag_def| tag_def.tag_list_name.to_s == attribute_name.to_s }&.last
+        return super if tag_definition.blank?
 
         return if changed_attributes.key?(attribute_name)
 
-        changed_attributes[attribute_name] = public_send(attribute_name)&.dup
+        changed_attributes[attribute_name] = tag_list_cache_on(tag_definition)&.dup
       end
     end
   end

data/lib/acts_as_taggable_on_mongoid/taggable/core.rb

@@ -22,6 +22,7 @@ module ActsAsTaggableOnMongoid
         # attr_writer :custom_contexts
 
         after_save :save_tags
+        before_save :save_cached_tag_lists
       end
 
       class_methods do
@@ -40,14 +41,99 @@ module ActsAsTaggableOnMongoid
         end
       end
 
-      def apply_pre_processed_defaults
-        super
+      def apply_post_processed_defaults
+        defaults = super
 
-        set_tag_list_defaults
+        defaults |= set_tag_list_defaults
+
+        defaults
       end
 
       private
 
+      def set_tag_list(tag_definition, new_tags)
+        dup_tags        = Array.wrap(new_tags).dup
+        options         = dup_tags.extract_options!.dup
+        options[:parse] = options.fetch(:parse) { true }
+
+        new_list          = tag_definition.parse(*dup_tags, options)
+        new_list.taggable = self
+        new_list.tagger   = tag_definition.tag_list_default_tagger(self) unless options.key?(:tagger)
+
+        mark_tag_list_changed(new_list)
+        tag_list_set(new_list)
+      end
+
+      def get_tag_list_change(tag_definition)
+        tag_list_name = tag_definition.tag_list_name
+
+        return nil unless public_send("#{tag_list_name}_changed?")
+
+        changed_value = new_record? ? tag_definition.default_tagger_tag_list(self) : changed_attributes[tag_list_name]
+        current_value = tag_list_cache_on(tag_definition)
+
+        return nil if (changed_value <=> current_value)&.zero?
+
+        tag_list_change_value(tag_definition, changed_value, current_value)
+      end
+
+      def tag_list_change_value(tag_definition, changed_value, current_value)
+        if tag_definition.tagger?
+          [changed_value.dup, current_value.dup]
+        else
+          [changed_value[nil].dup, current_value[nil].dup]
+        end
+      end
+
+      def get_tag_list_changed(tag_definition)
+        tag_list_name = tag_definition.tag_list_name
+
+        return false unless changed_attributes.key?(tag_list_name)
+
+        changed_value = new_record? ? tag_definition.default_tagger_tag_list(self) : changed_attributes[tag_list_name]
+        current_value = tag_list_cache_on(tag_definition)
+
+        !(changed_value <=> current_value)&.zero?
+      end
+
+      def get_tag_list_was(tag_definition)
+        default_tagger = tag_definition.tag_list_default_tagger(self)
+        return tag_definition.default_tagger_tag_list(self)[default_tagger].dup if new_record?
+
+        tag_list_name = tag_definition.tag_list_name
+
+        if public_send "#{tag_list_name}_changed?"
+          changed_attributes[tag_list_name][default_tagger].dup
+        else
+          public_send(tag_list_name).dup
+        end
+      end
+
+      def get_tag_lists_was(tag_definition)
+        return tag_definition.default_tagger_tag_list(self).dup if new_record?
+
+        tag_list_name = tag_definition.tag_list_name
+
+        if public_send "#{tag_list_name}_changed?"
+          changed_attributes[tag_list_name].dup
+        else
+          public_send(tag_definition.tagger_tag_lists_name).dup
+        end
+      end
+
+      def get_tagger_list_was(tag_definition, tagger)
+        return nil unless tag_definition.tagger?
+        return tag_definition.default_tagger_tag_list(self)[tagger].dup if new_record?
+
+        tag_list_name = tag_definition.tag_list_name
+
+        if public_send "#{tag_list_name}_changed?"
+          changed_attributes[tag_list_name][tagger].dup
+        else
+          public_send(tag_definition.tagger_tag_list_name, tagger).dup
+        end
+      end
+
       def tag_list_cache_set_on(tag_definition)
         variable_name = tag_definition.tag_list_variable_name
 
@@ -66,35 +152,57 @@ module ActsAsTaggableOnMongoid
         # end
 
         instance_variable_get(variable_name) ||
-            tag_list_set(ActsAsTaggableOnMongoid::TagList.new(tag_definition, tags_on(tag_definition).map(&:tag_name)))
+            tagger_tag_list_set(tagger_tag_list_from_taggings(tag_definition, all_tags_on(tag_definition)))
+      end
+
+      def tagger_tag_list_from_taggings(tag_definition, taggings)
+        tagger_tag_list = ActsAsTaggableOnMongoid::TaggerTagList.new(tag_definition, self)
+
+        taggings.each do |tagging|
+          tagger_tag_list[tagging.tagger].silent_concat [tagging.tag_name]
+        end
+
+        tagger_tag_list
       end
 
       def tag_list_on(tag_definition)
         # add_custom_context(tag_definition)
 
-        tag_list_cache_on(tag_definition)
+        tag_list_cache_on(tag_definition)[tag_definition.tag_list_default_tagger(self)]
       end
 
       def all_tags_list_on(tag_definition)
-        variable_name   = tag_definition.all_tag_list_variable_name
-        cached_variable = instance_variable_get(variable_name)
-
-        return cached_variable if instance_variable_defined?(variable_name) && cached_variable
-
-        instance_variable_set(variable_name, ActsAsTaggableOnMongoid::TagList.new(tag_definition, all_tags_on(tag_definition).map(&:name)).freeze)
+        tag_list_cache_on(tag_definition).flatten
       end
 
       ##
       # Returns all tags of a given context
       def all_tags_on(tag_definition)
-        tag_definition.tags_table.for_tag(tag_definition).to_a
+        scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type)
+
+        # when preserving tag order, return tags in created order
+        # if we added the order to the association this would always apply
+        scope = scope.order_by(*tag_definition.taggings_order) if tag_definition.preserve_tag_order?
+
+        scope
       end
 
       ##
       # Returns all tags that are not owned of a given context
       def tags_on(tag_definition)
-        # scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type, tagger_id: nil)
-        scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type)
+        scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type, :tagger_id.exists => false)
+
+        # when preserving tag order, return tags in created order
+        # if we added the order to the association this would always apply
+        scope = scope.order_by(*tag_definition.taggings_order) if tag_definition.preserve_tag_order?
+
+        scope
+      end
+
+      ##
+      # Returns all tags that are owned by a given tagger of a given context
+      def tagger_tags_on(tagger, tag_definition)
+        scope = public_send(tag_definition.taggings_name).where(context: tag_definition.tag_type, tagger: tagger)
 
         # when preserving tag order, return tags in created order
         # if we added the order to the association this would always apply
@@ -105,41 +213,56 @@ module ActsAsTaggableOnMongoid
 
       def mark_tag_list_changed(new_list)
         tag_definition   = new_list.tag_definition
-        current_tag_list = public_send(tag_definition.tag_list_name)
+        current_tag_list = tag_list_cache_on(tag_definition)
 
-        if (tag_definition.preserve_tag_order? && new_list != current_tag_list) ||
-            new_list.sort != current_tag_list.sort
-          current_tag_list.notify_will_change
-        end
+        return if current_tag_list == new_list
+
+        current_tag_list.notify_will_change
+      end
+
+      def tagger_tag_list_set(new_list)
+        instance_variable_set(new_list.tag_definition.tag_list_variable_name, new_list)
       end
 
       def tag_list_set(new_list)
         # add_custom_context(tag_definition, owner)
 
         new_list.taggable = self
+        tag_definition    = new_list.tag_definition
+        tagger_tag_list   = ActsAsTaggableOnMongoid::TaggerTagList.new(tag_definition, self)
 
-        instance_variable_set(new_list.tag_definition.tag_list_variable_name, new_list)
+        tagger_tag_list[new_list.tagger] = new_list
+
+        instance_variable_set(tag_definition.tag_list_variable_name, tagger_tag_list)
       end
 
       ##
       # Find existing tags or create non-existing tags
-      def load_tags(tag_definition, tag_list)
-        tag_definition.tags_table.find_or_create_all_with_like_by_name(tag_definition, tag_list)
+      def load_tags(tag_definition, tagger_tag_list)
+        tag_definition.tags_table.find_or_create_tagger_list_with_like_by_name(tag_definition, tagger_tag_list)
       end
 
       def set_tag_list_defaults
-        return unless new_record?
+        return [] unless new_record?
 
+        defaulted_values = []
         tag_types.each_value do |tag_definition|
-          default = tag_definition.default
+          next if instance_variable_defined?(tag_definition.tag_list_variable_name)
+
+          default = tag_definition.taggable_default(self)
           next unless default.present?
 
-          tag_list_name = tag_definition.tag_list_name
-          next if public_send(tag_list_name).present?
+          set_default_value(tag_definition, default)
 
-          public_send("#{tag_list_name}=", default)
-          changed_attributes.delete tag_list_name
+          defaulted_values << tag_definition.tag_list_name
         end
+
+        defaulted_values
+      end
+
+      def set_default_value(tag_definition, default)
+        public_send(tag_definition.tagger_tag_lists_name)[default.tagger] = default
+        changed_attributes.delete tag_definition.tag_list_name
       end
 
       def save_tags
@@ -167,11 +290,11 @@ module ActsAsTaggableOnMongoid
       end
 
       def extract_tag_list_changes(tag_definition)
-        tag_list = tag_list_cache_on(tag_definition).uniq
+        tag_list = tag_list_cache_on(tag_definition)
 
         # Find existing tags or create non-existing tags:
         tags         = find_or_create_tags_from_list_with_context(tag_definition, tag_list)
-        current_tags = tags_on(tag_definition).map(&:tag).compact
+        current_tags = all_tags_on(tag_definition)
 
         tag_list_diff = ActsAsTaggableOnMongoid::Taggable::Utils::TagListDiff.new tag_definition: tag_definition,
                                                                                   tags:           tags,
@@ -210,10 +333,10 @@ module ActsAsTaggableOnMongoid
       #       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_definition, tag_list)
-        load_tags(tag_definition, tag_list)
+      # @param [Array<String>] tagger_tag_list Tags to find or create grouped by tagger
+      # @param [Symbol] tag_definition The tag context for the tag_list
+      def find_or_create_tags_from_list_with_context(tag_definition, tagger_tag_list)
+        load_tags(tag_definition, tagger_tag_list)
       end
     end
   end