acts_as_20ggable 1.0.0

data/lib/tag.rb

@@ -0,0 +1,146 @@
+class Tag < ActiveRecord::Base
+  class HierarchyCycle < StandardError; end
+
+  SYMBOL = /[^#=\/]/.freeze
+
+  attr_accessor :mark
+  attr_accessible :mark, :name
+
+  has_many :taggings, :dependent => :destroy
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  validates_format_of :name, :with => /\A#{SYMBOL}*\Z/
+  validates_format_of :name, :with => /\A\S\Z|\A\S.*\S\Z/
+
+  cattr_accessor :destroy_unused
+  self.destroy_unused = false
+
+  has_and_belongs_to_many :children, :class_name => 'Tag', :foreign_key => 'tag_id',
+                                                           :association_foreign_key => 'child_id',
+                                                           :join_table => 'tags_hierarchy'
+
+  has_and_belongs_to_many :parents, :class_name => 'Tag', :foreign_key => 'child_id',
+                                                           :association_foreign_key => 'tag_id',
+                                                           :join_table => 'tags_hierarchy'
+
+  has_and_belongs_to_many :transitive_children, :class_name => 'Tag', :foreign_key => 'tag_id',
+                                                          :association_foreign_key => 'child_id',
+                                                          :join_table => 'tags_transitive_hierarchy'
+
+  has_and_belongs_to_many :synonyms, :class_name => 'Tag', :foreign_key => 'tag_id',
+                                                           :association_foreign_key => 'synonym_id',
+                                                           :join_table => 'tags_synonyms'
+
+  scope :with_joined_hierarchy_and_synonyms, -> {
+   joins("LEFT OUTER JOIN tags_hierarchy AS tags_hierarchy_parent ON tags_hierarchy_parent.tag_id = #{Tag.table_name}.id "+
+             "LEFT OUTER JOIN tags_hierarchy AS tags_hierarchy_child ON tags_hierarchy_child.child_id = #{Tag.table_name}.id "+
+             "LEFT OUTER JOIN tags_synonyms AS tags_synonyms_left ON tags_synonyms_left.tag_id = #{Tag.table_name}.id " +
+             "LEFT OUTER JOIN tags_synonyms AS tags_synonyms_right ON tags_synonyms_right.synonym_id = #{Tag.table_name}.id ")
+  }
+
+  scope :with_joined_hierarchy, -> {
+   joins("LEFT OUTER JOIN tags_hierarchy AS tags_hierarchy_parent ON tags_hierarchy_parent.tag_id = #{Tag.table_name}.id "+
+             "LEFT OUTER JOIN tags_hierarchy AS tags_hierarchy_child ON tags_hierarchy_child.child_id = #{Tag.table_name}.id")
+  }
+
+
+  # Scopes for "With joined hierarchy"
+  scope :without_children, -> { where('tags_hierarchy_parent.child_id IS NULL') }
+  scope :without_parents, -> { where('tags_hierarchy_child.tag_id IS NULL') }
+  scope :with_parents, -> { where('tags_hierarchy_child.tag_id IS NOT NULL') }
+  scope :without_synonyms, -> { where('tags_synonyms_left.synonym_id IS NULL AND tags_synonyms_right.tag_id IS NULL') }
+
+
+  # LIKE is used for cross-database case-insensitivity
+  def self.find_or_create_with_like_by_name(name)
+    find_with_like_by_name(name) || create(:name => name)
+  end
+
+  def self.find_or_create_with_like_by_name!(name)
+    find_with_like_by_name(name) || create!(:name => name)
+  end
+
+  def self.find_with_like_by_name(name)
+    where("name LIKE ?", name).first
+  end
+
+  def ==(object)
+    super || (object.is_a?(Tag) && name == object.name)
+  end
+
+  def to_s
+    name
+  end
+
+  def to_param
+    name
+  end
+
+  def count
+    read_attribute(:count).to_i
+  end
+
+  def marked?
+    read_attribute(:mark).to_i == 1
+  end
+
+  def check_mark!(condition)
+    self.mark = taggings.find(:first, :conditions => condition) ? 1 : 0
+  end
+
+  class << self
+    # Calculate the tag counts for all tags.
+    #  :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 '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
+    #  :mark_condition - Set 'mark' attribute on tags conforms this condition
+    #                    primarliy used with per-user taggings like ['taggings.create_by_id = ?', user.id]
+
+    def counts(options = {})
+      find(:all, options_for_counts(options))
+    end
+
+    def options_for_counts(options = {})
+      options.assert_valid_keys :start_at, :end_at, :conditions, :at_least, :at_most, :order, :limit, :joins, :mark_condition
+      options = options.dup
+
+      start_at = sanitize_sql(["#{Tagging.table_name}.created_at >= ?", options.delete(:start_at)]) if options[:start_at]
+      end_at = sanitize_sql(["#{Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]
+
+      conditions = [
+        options.delete(:conditions),
+        start_at,
+        end_at
+      ].compact
+
+      conditions = conditions.any? ? conditions.join(' AND ') : nil
+
+      mark_condition = options.delete(:mark_condition)
+      mark_condition = sanitize_sql(mark_condition) if mark_condition
+      mark_select = "GROUP_CONCAT(DISTINCT IF((#{sanitize_sql(mark_condition)}), 1, NULL)) as mark" if mark_condition
+      base_select = "#{Tag.table_name}.id, #{Tag.table_name}.name, COUNT(*) AS count"
+
+      select = [ base_select, mark_select ].compact.join(', ')
+
+      joins = ["INNER JOIN #{Tagging.table_name} ON #{Tag.table_name}.id = #{Tagging.table_name}.tag_id"]
+      joins << options.delete(:joins) if options[:joins]
+
+      at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options[:at_least]
+      at_most   = sanitize_sql(['COUNT(*) <= ?', options.delete(:at_most)]) if options[:at_most]
+      having    = [at_least, at_most].compact.join(' AND ')
+      group_by  = "#{Tag.table_name}.id, #{Tag.table_name}.name HAVING COUNT(*) > 0"
+      group_by << " AND #{having}" unless having.blank?
+
+      { :select     => select,
+        :joins      => joins.join(" "),
+        :conditions => conditions,
+        :group      => group_by
+      }.update(options)
+    end
+  end
+end

data/lib/tag_counts_extension.rb

@@ -0,0 +1,3 @@
+# Deprecated
+module TagCountsExtension #:nodoc:
+end

data/lib/tag_hierarchy_builder.rb

@@ -0,0 +1,201 @@
+class TagHierarchyBuilder
+  class WrongSpecificationSyntax < StandardError; end
+
+  def self.rebuild_transitive_closure
+    Tag.transaction do
+      Tag.connection.execute('DELETE from tags_transitive_hierarchy')
+
+      # (0) — тесты!
+      # OPTIMIZE
+      tags = Tag.includes(:synonyms, :children, :transitive_children)
+      transitive_children = { }
+
+      tags.each do |tag|
+        transitive_children[tag] = []
+        tag.children.each do |tag_child|
+          transitive_children[tag] << tag_child
+        end
+      end
+
+      visited_tags = []
+      root = {} ; comp = [] ; stack = []
+      tags.each do |outer_tag|
+        next if visited_tags.include?(outer_tag)
+        reclambda do |this, tag|
+          visited_tags << tag
+          root[tag] = tag; stack.push(tag)
+          tag.children.each do |child|
+            this.call(child) unless visited_tags.include?(child)
+            if !comp.include?(child)
+              root[tag] = visited_tags.index(tag) < visited_tags.index(child) ? tag : child
+            end
+            transitive_children[tag] += transitive_children[child]
+          end
+          if root[tag] == tag
+            loop do
+              w = stack.pop
+              comp << w
+              transitive_children[w] = transitive_children[tag] # Pointer assignment!
+              break if w == tag
+            end
+          end
+        end.call(outer_tag)
+      end
+
+      tags.each do |tag|
+        tag.synonyms.each do |synonym|
+          transitive_children[tag] << synonym unless transitive_children[tag].include?(synonym)
+          transitive_children[synonym] << tag unless transitive_children[synonym].include?(tag)
+        end
+      end
+
+      tags.each do |tag|
+        tag.transitive_children = transitive_children[tag].uniq
+      end
+    end
+  end
+
+  def self.rebuild_hierarchy(specification)
+    # TODO save old hierarchy somewhere.
+
+    Tag.transaction do
+      Tag.connection.execute('DELETE from tags_hierarchy')
+      Tag.connection.execute('DELETE from tags_synonyms')
+
+      specification.each do |line|
+        next if line.blank?
+        next if line =~ /^\s*#.*/ # If line is a comment
+        next if line =~ /^\s*#{Tag::SYMBOL}+\s*$/ # If line is a single tag
+        begin
+          if line =~ /^\s*#{Tag::SYMBOL}+\s*(=\s*#{Tag::SYMBOL}+\s*)+$/
+            instantiate_synonyms(line)
+            next
+          end
+
+          if line =~ /^\s*#{Tag::SYMBOL}+\s*(\/\s*#{Tag::SYMBOL}+\s*)+$/
+            instantiate_hierarchy(line)
+            next
+          end
+
+          raise WrongSpecificationSyntax.new("Line #{line}")
+        rescue ActiveRecord::RecordInvalid => _
+          raise WrongSpecificationSyntax.new("Line #{line}")
+        end
+      end
+
+      hierarchy_acyclic? or raise Tag::HierarchyCycle
+      rebuild_transitive_closure
+    end
+  end
+
+  # Input should be validated
+  def self.instantiate_synonyms(line)
+    # (2) TODO validate synonyms repetition? Like Cat = Kitty and Kitty = Cat
+    # То есть ни один из «синонимов» не может быть в «стволе»
+    # (3) FIXME а ведь можно намутить цикл при помощи сочетания синонимов и иерархии.
+    # Ни один из синонимов не может участвовать в «иерархии»
+    # То есть нам нужна flat иерархия, flat ствол и flat синонимы
+    # Причём хранить с номерами строк и выдавать ошибки «в такой-то строке»
+    # (4) TODO Мы хотим гламурные сообщения о циклах. Для этого опять-таки нужно можно воспользоваться тем flatten.
+    # Итого тесты. Сообщения об ошибках:
+    # "Левый синтаксис в строке 5"
+    # "Синоним AAA из строки 15 участвует в иерархии в строках …"
+    # "Синоним BBB из строки 15 повторяется в строке …"
+    syns = line.split('=').map(&:strip)
+
+    b = Tag.find_or_create_with_like_by_name!(syns.shift)
+    syns.each do |syn|
+      b.synonyms << Tag.find_or_create_with_like_by_name!(syn)
+    end
+  end
+
+  def self.instantiate_hierarchy(line)
+    line = line.split('/').map(&:strip)
+
+    line.each_cons(2) do |(p, c)|
+      p = Tag.find_or_create_with_like_by_name!(p)
+      c = Tag.find_or_create_with_like_by_name!(c)
+
+      raise Tag::HierarchyCycle.new if c.parents.include?(p) || c == p
+
+      c.parents << p
+    end
+  end
+
+  def self.hierarchy_acyclic?
+    # OPTIMIZE
+    tags = Tag.includes(:children)
+
+    tags_status = tags.map { |x| [ x, :unvisited ] }.flatten
+    tags_status = Hash[*tags_status]
+
+    tags.each do |tag|
+      next if tags_status[tag] != :unvisited
+      (reclambda do |this, tag|
+        return false if tags_status[tag] == :processing
+        tags_status[tag] = :processing
+        tag.children.any? do |child|
+          this.call(child)
+        end
+        tags_status[tag] = :closed
+      end).call(tag)
+    end
+    return true
+  end
+
+  # ==== DUMPER ======
+
+  def self.dump_tags
+    ['# Categories'] +
+    dump_hierarchy.map { |chain| chain * ' / '} +
+    ['', '# Synonyms'] +
+    dump_synonyms.map { |chain| chain * ' = '} +
+    ['', '# Unlinked tags'] +
+    dump_orphans
+  end
+
+  def self.dump_hierarchy
+    tags_chains = Tag.with_joined_hierarchy.without_children.with_parents.find(:all).map { |x| [x] }
+
+    # OPTIMIZE
+    while chain = tags_chains.detect { |chain| !chain.first.parents.empty? }
+      tags_chains.delete(chain)
+      chain.first.parents.each do |parent|
+        raise Tag::HierarchyCycle.new if chain.include?(parent)
+        tags_chains << ([parent] + chain)
+      end
+    end
+
+    tags_chains.map { |chain| chain.map { |tag| tag.name } }.sort_by { |chain| chain * ' ' }
+  end
+
+  def self.dump_synonyms
+    # OPTIMIZE N+1
+    tags_with_synonyms = Tag.includes(:synonyms)
+
+    tags_with_synonyms.map { |t|
+      [ t.name, *t.synonyms.pluck(:name).sort ]
+    }.keep_if(&:second)
+  end
+
+  def self.dump_orphans
+    # OPTIMIZE
+    Tag.with_joined_hierarchy_and_synonyms.without_children.without_parents.without_synonyms.
+      pluck(:name)
+  end
+end
+
+# FIXME move somewhere, uhm
+def reclambda
+  lambda do |f|
+    f.call(f)
+  end.call(lambda do |f|
+             lambda do |this|
+               lambda do |*args|
+                 yield(this, *args)
+               end
+             end.call(lambda do |x|
+                       f.call(f).call(x)
+                      end)
+           end)
+end

data/lib/tag_list.rb

@@ -0,0 +1,108 @@
+class TagList < Array
+  cattr_accessor :delimiter
+  self.delimiter = ','
+
+  def initialize(*args)
+    add(*args)
+  end
+
+  # Add tags to the tag_list. Duplicate or blank tags will be ignored.
+  #
+  #   tag_list.add("Fun", "Happy")
+  #
+  # Use the <tt>:parse</tt> option to add an unparsed tag string.
+  #
+  #   tag_list.add("Fun, Happy", :parse => true)
+  def add(*names)
+    extract_and_apply_options!(names)
+    concat(names)
+    clean!
+    self
+  end
+
+  # Remove specific tags from the tag_list.
+  #
+  #   tag_list.remove("Sad", "Lonely")
+  #
+  # Like #add, the <tt>:parse</tt> option can be used to remove multiple tags in a string.
+  #
+  #   tag_list.remove("Sad, Lonely", :parse => true)
+  def remove(*names)
+    extract_and_apply_options!(names)
+    delete_if { |name| names.include?(name) }
+    self
+  end
+
+  # Toggle the presence of the given tags.
+  # If a tag is already in the list it is removed, otherwise it is added.
+  def toggle(*names)
+    extract_and_apply_options!(names)
+
+    names.each do |name|
+      include?(name) ? delete(name) : push(name)
+    end
+
+    clean!
+    self
+  end
+
+  # Transform the tag_list into a tag string suitable for edting in a form.
+  # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+  #
+  #   tag_list = TagList.new("Round", "Square,Cube")
+  #   tag_list.to_s # 'Round, "Square,Cube"'
+  def to_s
+    clean!
+
+    map do |name|
+      name.include?(delimiter) ? "\"#{name}\"" : name
+    end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+  end
+
+ private
+  # Remove whitespace, duplicates, and blanks.
+  def clean!
+    reject!(&:blank?)
+    map!(&:strip)
+    uniq!
+  end
+
+  def extract_and_apply_options!(args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    options.assert_valid_keys :parse
+
+    if options[:parse]
+      args.map! { |a| self.class.from(a) }
+    end
+
+    args.flatten!
+  end
+
+  class << self
+    # Returns a new TagList using the given tag string.
+    #
+    #   tag_list = TagList.from("One , Two,  Three")
+    #   tag_list # ["One", "Two", "Three"]
+    def from(source)
+      new.tap do |tag_list|
+
+        case source
+          when Array
+            tag_list.add(source)
+          else
+            string = source.to_s.dup
+
+            # Parse the quoted tags
+            [
+              /\s*#{delimiter}\s*(['"])(.*?)\1\s*/,
+              /^\s*(['"])(.*?)\1\s*#{delimiter}?/
+            ].each do |re|
+              string.gsub!(re) { tag_list << $2; "" }
+            end
+
+            tag_list.add(string.split(delimiter))
+        end
+      end
+    end
+  end
+end