acts_as_20ggable 1.0.0

data/test/lib/tag_hierarchy_builder_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+require 'tag_hierarchy_builder'
+
+class TagHierarchyBuilderTest < ActiveSupport::TestCase
+  fixtures :tags, :tags_hierarchy, :tags_synonyms, :tags_transitive_hierarchy
+
+  def hierarchy_blank?(options = {})
+    except = [ options[:except] ].flatten.compact
+    Tag.find(:all).all? { |tag| !except.include?(tag.name) || (tag.parents.empty? && tag.children.empty? && tag.synonyms.empty?) }.inspect
+  end
+
+  def test_dump_hierarchy
+    hierarchy = TagHierarchyBuilder.dump_hierarchy
+    hierarchy_fixture = [
+      ['Nature', 'Animals', 'Domestic Animals', 'Cat', 'Kitten'],
+      ['Nature', 'Animals', 'Horse'],
+      ['People', 'Children'],
+      ['People', 'Me'],
+      ['People', 'Nude'],
+    ]
+
+    assert_equal hierarchy, hierarchy_fixture
+  end
+
+  def test_dump_synonyms
+    synonyms = TagHierarchyBuilder.dump_synonyms
+    synonyms_fixture = [
+      ['Cat', 'Kitty', 'Pussy'],
+      ['Horse', 'Racehorse'],
+      ['Question', 'Problem']
+    ]
+
+    assert_equivalent synonyms, synonyms_fixture
+  end
+
+  def test_dump_orphans
+    orphans = TagHierarchyBuilder.dump_orphans
+    orphans_fixture = ['Bad', 'Crazy animal', 'Very good']
+
+    assert_equivalent orphans, orphans_fixture
+  end
+
+  def test_rebuild_hierarchy_with_empty_specification
+    TagHierarchyBuilder.rebuild_hierarchy([''])
+    assert hierarchy_blank?
+  end
+
+  def test_rebuild_hierarchy_with_only_comments_in_specification
+    TagHierarchyBuilder.rebuild_hierarchy(['#Comment one', '    # Comment two'])
+    assert hierarchy_blank?
+  end
+
+  def test_rebuild_hierarchy_with_synonyms
+    TagHierarchyBuilder.rebuild_hierarchy(['   Cat   =   Racehorse   =   Problem  '])
+
+    assert_equal Tag.find_with_like_by_name("Cat").synonyms.map(&:name).sort,
+                 ['Racehorse', 'Problem'].sort
+
+    assert hierarchy_blank?(:except => 'Cat')
+  end
+
+  def test_rebuild_hierarchy_with_synonyms_and_parents
+    TagHierarchyBuilder.rebuild_hierarchy(['Cat = Racehorse = Problem', '   Apple  /  Cocoa /   Kitty  ', 'Apple / Kitty'])
+
+    assert_equal Tag.find_with_like_by_name("Cat").synonyms.map(&:name).sort,
+                 ['Racehorse', 'Problem'].sort
+
+    assert_equal Tag.find_with_like_by_name("Cocoa").parents.map(&:name).sort,
+                ['Apple'].sort
+    assert_equal Tag.find_with_like_by_name("Kitty").parents.map(&:name).sort,
+                ['Apple', 'Cocoa'].sort
+    assert hierarchy_blank?(:except => ['Cat', 'Kitty', 'Apple', 'Cocoa'])
+  end
+
+
+  def test_rebuild_hierarchy_with_invalid_lines
+    assert_raise(TagHierarchyBuilder::WrongSpecificationSyntax) { TagHierarchyBuilder.rebuild_hierarchy(['/ HEY / YO '])}
+    assert_raise(TagHierarchyBuilder::WrongSpecificationSyntax) { TagHierarchyBuilder.rebuild_hierarchy(['HEY / YO/'])}
+
+    assert_raise(TagHierarchyBuilder::WrongSpecificationSyntax) { TagHierarchyBuilder.rebuild_hierarchy([' / HEY / YO '])}
+    assert_raise(TagHierarchyBuilder::WrongSpecificationSyntax) { TagHierarchyBuilder.rebuild_hierarchy(['HEY / YO/ '])}
+
+    assert_raise(TagHierarchyBuilder::WrongSpecificationSyntax) { TagHierarchyBuilder.rebuild_hierarchy(['= HEY = YO '])}
+    assert_raise(TagHierarchyBuilder::WrongSpecificationSyntax) { TagHierarchyBuilder.rebuild_hierarchy(['HEY = YO='])}
+
+    assert_raise(TagHierarchyBuilder::WrongSpecificationSyntax) { TagHierarchyBuilder.rebuild_hierarchy([' = HEY = YO '])}
+    assert_raise(TagHierarchyBuilder::WrongSpecificationSyntax) { TagHierarchyBuilder.rebuild_hierarchy(['HEY = YO= '])}
+  end
+
+  def test_rebuild_hierarchy_with_cycles
+    assert_raise(Tag::HierarchyCycle) { TagHierarchyBuilder.rebuild_hierarchy(['Apple/Cocoa/Banana/Apple', 'Apple/Delta'])}
+    assert_raise(Tag::HierarchyCycle) { TagHierarchyBuilder.rebuild_hierarchy(['Apple/Apple'])}
+
+    assert_raise(Tag::HierarchyCycle) { TagHierarchyBuilder.rebuild_hierarchy(['Apple/Cocoa/Banana/Apple'])}
+    assert_raise(Tag::HierarchyCycle) { TagHierarchyBuilder.rebuild_hierarchy(['Apple/Cocoa/Banana/Apple/Cocoa'])}
+  end
+
+  def test_transitive_hierarchy_rebuilding_does_not_breaks_fixture
+    tags = Tag.find(:all)
+    old_hierarchy = tags.inject({}) { |memo, tag| memo[tag] = tag.transitive_children.find(:all).sort_by(&:name); memo }
+
+    TagHierarchyBuilder.rebuild_transitive_closure
+
+    tags = Tag.find(:all)
+    new_hierarchy = tags.inject({}) { |memo, tag| memo[tag] = tag.transitive_children.find(:all).sort_by(&:name); memo }
+
+    assert_equal old_hierarchy, new_hierarchy
+  end
+end

data/test/lib/tag_list_test.rb

@@ -0,0 +1,120 @@
+require 'test_helper'
+require 'tag_list'
+
+class TagListTest < ActiveSupport::TestCase
+  def test_from_leaves_string_unchanged
+    tags = '"One  ", Two'
+    original = tags.dup
+    TagList.from(tags)
+    assert_equal tags, original
+  end
+
+  def test_from_single_name
+    assert_equal %w(Fun), TagList.from("Fun")
+    assert_equal %w(Fun), TagList.from('"Fun"')
+  end
+
+  def test_from_blank
+    assert_equal [], TagList.from(nil)
+    assert_equal [], TagList.from("")
+  end
+
+  def test_from_single_quoted_tag
+    assert_equal ['with, comma'], TagList.from('"with, comma"')
+  end
+
+  def test_spaces_do_not_delineate
+    assert_equal ['A B', 'C'], TagList.from('A B, C')
+  end
+
+  def test_from_multiple_tags
+    assert_equivalent %w(Alpha Beta Delta Gamma), TagList.from("Alpha, Beta, Delta, Gamma")
+  end
+
+  def test_from_multiple_tags_with_quotes
+    assert_equivalent %w(Alpha Beta Delta Gamma), TagList.from('Alpha,  "Beta",  Gamma , "Delta"')
+  end
+
+  def test_from_with_single_quotes
+    assert_equivalent ['A B', 'C'], TagList.from("'A B', C")
+  end
+
+  def test_from_multiple_tags_with_quote_and_commas
+    assert_equivalent ['Alpha, Beta', 'Delta', 'Gamma, something'], TagList.from('"Alpha, Beta", Delta, "Gamma, something"')
+  end
+
+  def test_from_with_inner_quotes
+    assert_equivalent ["House", "Drum 'n' Bass", "Trance"], TagList.from("House, Drum 'n' Bass, Trance")
+    assert_equivalent ["House", "Drum'n'Bass", "Trance"], TagList.from("House, Drum'n'Bass, Trance")
+  end
+
+  def test_from_removes_white_space
+    assert_equivalent %w(Alpha Beta), TagList.from('" Alpha   ", "Beta  "')
+    assert_equivalent %w(Alpha Beta), TagList.from('  Alpha,  Beta ')
+  end
+
+  def test_from_and_new_treat_both_accept_arrays
+    tags = ["One", "Two"]
+
+    assert_equal TagList.from(tags), TagList.new(tags)
+  end
+
+  def test_alternative_delimiter
+    TagList.delimiter = " "
+
+    assert_equal %w(One Two), TagList.from("One Two")
+    assert_equal ['One two', 'three', 'four'], TagList.from('"One two" three four')
+  ensure
+    TagList.delimiter = ","
+  end
+
+  def test_duplicate_tags_removed
+    assert_equal %w(One), TagList.from("One, One")
+  end
+
+  def test_to_s_with_commas
+    assert_equal "Question, Crazy Animal", TagList.new("Question", "Crazy Animal").to_s
+  end
+
+  def test_to_s_with_alternative_delimiter
+    TagList.delimiter = " "
+
+    assert_equal '"Crazy Animal" Question', TagList.new("Crazy Animal", "Question").to_s
+  ensure
+    TagList.delimiter = ","
+  end
+
+  def test_add
+    tag_list = TagList.new("One")
+    assert_equal %w(One), tag_list
+
+    assert_equal %w(One Two), tag_list.add("Two")
+    assert_equal %w(One Two Three), tag_list.add(["Three"])
+  end
+
+  def test_remove
+    tag_list = TagList.new("One", "Two")
+    assert_equal %w(Two), tag_list.remove("One")
+    assert_equal %w(), tag_list.remove(["Two"])
+  end
+
+  def test_new_with_parsing
+    assert_equal %w(One Two), TagList.new("One, Two", :parse => true)
+  end
+
+  def test_add_with_parsing
+    assert_equal %w(One Two), TagList.new.add("One, Two", :parse => true)
+  end
+
+  def test_remove_with_parsing
+    tag_list = TagList.from("Three, Four, Five")
+    assert_equal %w(Four), tag_list.remove("Three, Five", :parse => true)
+  end
+
+  def test_toggle
+    tag_list = TagList.new("One", "Two")
+    assert_equal %w(One Three), tag_list.toggle("Two", "Three")
+    assert_equal %w(), tag_list.toggle("One", "Three")
+    assert_equal %w(Four), tag_list.toggle("Four")
+  end
+end

data/test/lib/tag_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+require 'tag'
+
+class TagTest < ActiveSupport::TestCase
+  fixtures :tags, :taggings, :users, :photos, :posts
+
+  def test_name_required
+    t = Tag.create
+    assert_match /blank/, t.errors[:name].to_s
+  end
+
+  def test_name_unique
+    t = Tag.create!(:name => "My tag")
+    duplicate = t.dup
+
+    assert !duplicate.save
+    assert_match /taken/, duplicate.errors[:name].to_s
+  end
+
+  def test_taggings
+    assert_equivalent [taggings(:jonathan_sky_good), taggings(:sam_flowers_good), taggings(:sam_flower_good), taggings(:ruby_good)], tags(:good).taggings
+    assert_equivalent [taggings(:sam_ground_bad), taggings(:jonathan_bad_cat_bad)], tags(:bad).taggings
+  end
+
+  def test_to_s
+    assert_equal tags(:good).name, tags(:good).to_s
+  end
+
+  def test_equality
+    assert_equal tags(:good), tags(:good)
+    assert_equal Tag.find(1), Tag.find(1)
+    assert_equal Tag.new(:name => 'A'), Tag.new(:name => 'A')
+    assert_not_equal Tag.new(:name => 'A'), Tag.new(:name => 'B')
+  end
+
+  def test_taggings_removed_when_tag_destroyed
+    assert_difference "Tagging.count", -Tagging.count(:conditions => { :tag_id => tags(:good).id }) do
+      assert tags(:good).destroy
+    end
+  end
+
+  def test_all_counts
+    assert_tag_counts Tag.counts, :good => 4, :bad => 2, :nature => 10, :question => 2, :animal => 3, :nature_animals_domestic_cat => 1, :nature_animals_domestic_cat_kitten => 1
+  end
+end

data/test/lib/tagging_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+require 'tagging'
+
+class TaggingTest < ActiveSupport::TestCase
+  fixtures :tags, :taggings, :posts
+
+  def test_tag
+    assert_equal tags(:good), taggings(:jonathan_sky_good).tag
+  end
+
+  def test_taggable
+    assert_equal posts(:jonathan_sky), taggings(:jonathan_sky_good).taggable
+  end
+end

data/test/lib/tags_helper_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class TagsHelperTest < ActiveSupport::TestCase
+  fixtures :tags, :taggings, :posts
+
+  include ::TagsHelper
+
+  def test_tag_cloud
+    cloud_elements = []
+
+    tag_cloud Post.tag_counts, %w(css1 css2 css3 css4) do |tag, css_class|
+      cloud_elements << [tag, css_class]
+    end
+
+    assert_equal [
+      [tags(:good), "css2"],
+      [tags(:bad), "css1"],
+      [tags(:nature), "css4"],
+      [tags(:question), "css1"]
+    ], cloud_elements
+  end
+
+  def test_tag_cloud_when_no_tags
+    tag_cloud SpecialPost.tag_counts, %w(css1) do
+      assert false, "tag_cloud should not yield"
+    end
+  end
+end

data/test/lib/tags_hierarchy_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class TagsHierarchyTest < ActiveSupport::TestCase
+  fixtures :tags, :taggings, :videos, :users, :tags_transitive_hierarchy
+
+  def test_find_tagged_with_subtags
+    assert_equivalent [videos(:jonathan_good_cat), videos(:sam_kitten)],
+                      Video.find_tagged_with('"Domestic Animals"')
+
+  end
+end
+

data/test/support/activerecord_test_connector.rb

@@ -0,0 +1,129 @@
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_support/multibyte' # needed for Ruby 1.9.1
+require 'stringio'
+
+$query_count = 0
+$query_sql = []
+
+ignore_sql = /
+    ^(
+      PRAGMA | SHOW\ max_identifier_length |
+      SELECT\ (currval|CAST|@@IDENTITY|@@ROWCOUNT) |
+      SHOW\ ((FULL\ )?FIELDS|TABLES)
+    )\b |
+    \bFROM\ (sqlite_master|pg_tables|pg_attribute)\b
+  /x
+
+ActiveSupport::Notifications.subscribe(/^sql\./) do |*args|
+  payload = args.last
+  unless payload[:name] =~ /^Fixture/ or payload[:sql] =~ ignore_sql
+    $query_count += 1
+    $query_sql << payload[:sql]
+  end
+end
+
+module ActiverecordTestConnector
+  extend self
+
+  attr_accessor :able_to_connect
+  attr_accessor :connected
+
+  FIXTURES_PATH = File.expand_path('../../fixtures', __FILE__)
+
+  Fixtures = defined?(ActiveRecord::FixtureSet) ? ActiveRecord::FixtureSet :
+             defined?(ActiveRecord::Fixtures) ? ActiveRecord::Fixtures :
+             ::Fixtures
+
+  # Set our defaults
+  self.connected = false
+  self.able_to_connect = true
+
+  def setup
+    unless self.connected || !self.able_to_connect
+      setup_connection
+      load_schema
+      add_load_path FIXTURES_PATH
+      self.connected = true
+    end
+  rescue Exception => e  # errors from ActiveRecord setup
+    $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n"
+    self.able_to_connect = false
+  end
+
+  private
+
+  def add_load_path(path)
+    dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
+    dep.autoload_paths.unshift path
+  end
+
+  def setup_connection
+    db = ENV['DB'].blank?? 'sqlite3' : ENV['DB']
+
+    configurations = YAML.load_file(File.expand_path('../../support/database.yml', __FILE__))
+    raise "no configuration for '#{db}'" unless configurations.key? db
+    configuration = configurations[db]
+
+    # ActiveRecord::Base.logger = Logger.new(STDOUT) if $0 == 'irb'
+
+    ActiveRecord::Base.configurations = { db => configuration }
+    ActiveRecord::Base.establish_connection(db.to_sym)
+    ActiveRecord::Base.default_timezone = :utc
+  end
+
+  def load_schema
+    begin
+      $stdout = StringIO.new
+      ActiveRecord::Migration.verbose = false
+      load File.join(FIXTURES_PATH, 'schema.rb')
+    ensure
+      $stdout = STDOUT
+    end
+  end
+
+  module FixtureSetup
+    def fixtures(*tables)
+      cattr_accessor :loaded_fixtures
+      cattr_accessor :fixture_cache
+      cattr_accessor :fixture_table_names
+
+      table_names = tables.map { |t| t.to_s }
+      self.fixture_table_names = table_names
+
+      define_method(:setup) do
+        fixtures = Fixtures.create_fixtures ActiverecordTestConnector::FIXTURES_PATH, self.class.fixture_table_names
+        self.class.loaded_fixtures = {}
+        self.class.fixture_cache = {}
+
+        unless fixtures.nil?
+          if fixtures.instance_of?(Fixtures)
+            self.class.loaded_fixtures[fixtures.table_name] = fixtures
+          else
+            fixtures.each { |f| self.class.loaded_fixtures[f.table_name] = f }
+          end
+        end
+      end
+
+      define_method(:teardown) do
+        Fixtures.reset_cache
+      end
+
+      table_names.each do |table_name|
+        define_method(table_name) do |*fixtures|
+          self.class.fixture_cache[table_name] ||= {}
+
+          instances = fixtures.map do |fixture|
+            if self.class.loaded_fixtures[table_name][fixture.to_s]
+              self.class.fixture_cache[table_name][fixture] ||= self.class.loaded_fixtures[table_name][fixture.to_s].find
+            else
+              raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+            end
+          end
+
+          instances.size == 1 ? instances.first : instances
+        end
+      end
+    end
+  end
+end