make_taggable 0.6.3

data/lib/make_taggable/tag_list.rb

@@ -0,0 +1,102 @@
+require "active_support/core_ext/module/delegation"
+
+module MakeTaggable
+  class TagList < Array
+    attr_accessor :owner
+    attr_accessor :parser
+
+    def initialize(*args)
+      @parser = MakeTaggable.default_parser
+      add(*args)
+    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.
+    #
+    # Example:
+    #   tag_list.add("Fun", "Happy")
+    #   tag_list.add("Fun, Happy", :parse => true)
+    def add(*names)
+      extract_and_apply_options!(names)
+      concat(names)
+      clean!
+      self
+    end
+
+    # Append---Add the tag to the tag_list. This
+    # expression returns the tag_list itself, so several appends
+    # may be chained together.
+    def <<(obj)
+      add(obj)
+    end
+
+    # Concatenation --- Returns a new tag list built by concatenating the
+    # two tag lists together to produce a third tag list.
+    def +(other)
+      TagList.new.add(self).add(other)
+    end
+
+    # Appends the elements of +other_tag_list+ to +self+.
+    def concat(other_tag_list)
+      super(other_tag_list).send(:clean!)
+      self
+    end
+
+    ##
+    # Remove specific tags from the tag_list.
+    # Use the <tt>:parse</tt> option to add an unparsed tag string.
+    #
+    # Example:
+    #   tag_list.remove("Sad", "Lonely")
+    #   tag_list.remove("Sad, Lonely", :parse => true)
+    def remove(*names)
+      extract_and_apply_options!(names)
+      delete_if { |name| names.include?(name) }
+      self
+    end
+
+    ##
+    # Transform the tag_list into a tag string suitable for editing in a form.
+    # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+    #
+    # Example:
+    #   tag_list = TagList.new("Round", "Square,Cube")
+    #   tag_list.to_s # 'Round, "Square,Cube"'
+    def to_s
+      tags = frozen? ? dup : self
+      tags.send(:clean!)
+
+      tags.map { |name|
+        d = MakeTaggable.delimiter
+        d = Regexp.new d.join("|") if d.is_a? Array
+        name.index(d) ? "\"#{name}\"" : name
+      }.join(MakeTaggable.glue)
+    end
+
+    private
+
+    # Convert everything to string, remove whitespace, duplicates, and blanks.
+    def clean!
+      reject!(&:blank?)
+      map!(&:to_s)
+      map!(&:strip)
+      map! { |tag| tag.mb_chars.downcase.to_s } if MakeTaggable.force_lowercase
+      map!(&:parameterize) if MakeTaggable.force_parameterize
+
+      MakeTaggable.strict_case_match ? uniq! : uniq! { |tag| tag.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] || @parser
+
+      args.map! { |a| parser.new(a).parse } if options[:parse] || options[:parser]
+
+      args.flatten!
+    end
+  end
+end

data/lib/make_taggable/taggable.rb

@@ -0,0 +1,100 @@
+module MakeTaggable
+  module Taggable
+    def taggable?
+      false
+    end
+
+    ##
+    # This is an alias for calling <tt>make_taggable :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_taggable
+    #   end
+    def acts_as_taggable
+      make_taggable :tags
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_ordered_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_ordered_taggable
+    #   end
+    def acts_as_ordered_taggable
+      acts_as_ordered_taggable_on :tags
+    end
+
+    ##
+    # Make a model taggable on specified contexts.
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     make_taggable :languages, :skills
+    #   end
+    def make_taggable(*tag_types)
+      taggable_on(false, tag_types)
+    end
+
+    ##
+    # Make a model taggable on specified contexts
+    # and preserves the order in which tags are created
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_ordered_taggable_on :languages, :skills
+    #   end
+    def acts_as_ordered_taggable_on(*tag_types)
+      taggable_on(true, tag_types)
+    end
+
+    private
+
+    # Make a model taggable on specified contexts
+    # and optionally preserves the order in which tags are created
+    #
+    # Separate methods used above for backwards compatibility
+    # so that the original make_taggable method is unaffected
+    # as it's not possible to add another argument to the method
+    # without the tag_types being enclosed in square brackets
+    #
+    # NB: method overridden in core module in order to create tag type
+    #     associations and methods after this logic has executed
+    #
+    def taggable_on(preserve_tag_order, *tag_types)
+      tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
+
+      if taggable?
+        self.tag_types = (self.tag_types + tag_types).uniq
+        self.preserve_tag_order = preserve_tag_order
+      else
+        class_attribute :tag_types
+        self.tag_types = tag_types
+        class_attribute :preserve_tag_order
+        self.preserve_tag_order = preserve_tag_order
+
+        class_eval do
+          has_many :taggings, as: :taggable, dependent: :destroy, class_name: "::MakeTaggable::Tagging"
+          has_many :base_tags, through: :taggings, source: :tag, class_name: "::MakeTaggable::Tag"
+
+          def self.taggable?
+            true
+          end
+        end
+      end
+
+      # each of these add context-specific methods and must be
+      # called on each call of taggable_on
+      include Core
+      include Collection
+      include Cache
+      include Ownership
+      include Related
+    end
+  end
+end

data/lib/make_taggable/taggable/cache.rb

@@ -0,0 +1,90 @@
+module MakeTaggable::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
+
+    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 @make_taggable_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
+        @make_taggable_cache_columns ||= begin
+          db_columns = super
+          _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
+          db_columns
+        end
+      end
+
+      def reset_column_information
+        super
+        @make_taggable_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")
+        end
+      end
+
+      # @private
+      def _add_tags_caching_methods
+        send :include, MakeTaggable::Taggable::Cache::InstanceMethods
+        extend MakeTaggable::Taggable::Cache::ClassMethods
+
+        before_save :save_cached_tag_list
+
+        initialize_tags_cache
+      end
+    end
+
+    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
+        end
+      end
+
+      def make_taggable(*args)
+        super(*args)
+        initialize_tags_cache
+      end
+
+      def caching_tag_list_on?(context)
+        column_names.include?("cached_#{context.to_s.singularize}_list")
+      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)
+              list = tag_list_cache_on(tag_type).to_a.flatten.compact.join("#{MakeTaggable.delimiter} ")
+              self["cached_#{tag_type.singularize}_list"] = list
+            end
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/make_taggable/taggable/collection.rb

@@ -0,0 +1,183 @@
+module MakeTaggable::Taggable
+  module Collection
+    def self.included(base)
+      base.extend MakeTaggable::Taggable::Collection::ClassMethods
+      base.initialize_make_taggable_collection
+    end
+
+    module ClassMethods
+      def initialize_make_taggable_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 make_taggable(*args)
+        super(*args)
+        initialize_make_taggable_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 = MakeTaggable::Tagging.select("#{MakeTaggable::Tagging.table_name}.tag_id")
+        tag_scope = MakeTaggable::Tag.select("#{MakeTaggable::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 = "#{MakeTaggable::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 = MakeTaggable::Tagging.select("#{MakeTaggable::Tagging.table_name}.tag_id, COUNT(#{MakeTaggable::Tagging.table_name}.tag_id) AS tags_count")
+        tag_scope = MakeTaggable::Tag.select("#{MakeTaggable::Tag.table_name}.*, #{MakeTaggable::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} = #{MakeTaggable::Tagging.table_name}.taggable_id"
+          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(#{MakeTaggable::Tagging.table_name}.tag_id) > 0"]
+        having.push sanitize_sql(["COUNT(#{MakeTaggable::Tagging.table_name}.tag_id) >= ?", options.delete(:at_least)]) if options[:at_least]
+        having.push sanitize_sql(["COUNT(#{MakeTaggable::Tagging.table_name}.tag_id) <= ?", options.delete(:at_most)]) if options[:at_most]
+        having = having.compact.join(" AND ")
+
+        group_columns = "#{MakeTaggable::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)
+        connection.respond_to?(:unprepared_statement) ? connection.unprepared_statement { relation.to_sql } : relation.to_sql
+      end
+
+      private
+
+      def generate_tagging_scope_in_clause(tagging_scope, table_name, primary_key)
+        table_name_pkey = "#{table_name}.#{primary_key}"
+        if MakeTaggable::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("#{MakeTaggable::Tagging.table_name}.taggable_id IN (?)", scoped_ids)
+        else
+          tagging_scope = tagging_scope.where("#{MakeTaggable::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 = []
+        tagging_conditions.push sanitize_sql(["#{MakeTaggable::Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+        tagging_conditions.push sanitize_sql(["#{MakeTaggable::Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+
+        taggable_conditions = sanitize_sql(["#{MakeTaggable::Tagging.table_name}.taggable_type = ?", base_class.name])
+        taggable_conditions << sanitize_sql([" AND #{MakeTaggable::Tagging.table_name}.context = ?", options.delete(:on).to_s]) if options[:on]
+        taggable_conditions << sanitize_sql([" AND #{MakeTaggable::Tagging.table_name}.taggable_id = ?", options[:id]]) if options[:id]
+
+        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 #{MakeTaggable::Tagging.table_name} ON #{MakeTaggable::Tagging.table_name}.tag_id = #{MakeTaggable::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