redmine_acts_as_taggable_on 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a47dcc653f37f43a611fd9c52d5b6d8a818dc05e
-  data.tar.gz: 2f9a5b64d103e28287316955901a809877522730
+  metadata.gz: af36a6d9277e4b6f7ebb23802fd4df6df58549e2
+  data.tar.gz: 170406c9ce7d640b54d6f0958733c19a788cb8b3
 SHA512:
-  metadata.gz: 68e5c10907d01cc88a51d43dc06bfbf6dc1ccc87f2207ff2cebfe0f8c915940ba101f62560ac88c5fb1ce048da50891979071851a17b10c11c5f40d47bf2dbfc
-  data.tar.gz: 69e174c227a423a591c8ee938aefcb6c06e01688d3cc406922ffcc0395a6bdeaace815e020594701d8fd7d14e05e3cce3702cae9a917d185d61ab56335ff1884
+  metadata.gz: 80e76b8c0900f2770409953877d088c65555095bdef02dc073c17227b03e94f2ba35f294de25f2330689328c459b910437274dba081b0f7fb3d45c244189779c
+  data.tar.gz: 0400ed073a494d7e57abdbc06029d07bebe198fbad7465f1f446a5dee3a7f8008b29639cfeee0229a3afefb3ed1fe90963d2ea202761dded90cda029a8302b89

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "test/bats"]
+	path = test/bats
+	url = git://github.com/sstephenson/bats.git

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+script: test/run.bash
+rvm:
+  - "2.0.0"

data/README.md

@@ -1,13 +1,13 @@
 # redmine_acts_as_taggable_on
 
 `redmine_acts_as_taggable_on` is a gem which allows multiple Redmine plugins to
-use the tables provided by `acts_as_taggable_on` without stepping on each
+use the tables provided by `acts-as-taggable-on` without stepping on each
 others' toes.
 
-## How it works
+## Why?
 
 The problem we ran into when we discovered that both `redmine_tags` and
-`redmine_knowledgebase` want to use the `acts_as_taggable_on` gem is that after
+`redmine_knowledgebase` want to use the `acts-as-taggable-on` gem is that after
 either is installed, the migration for the other fails, since the database
 tables already exist.
 
@@ -23,30 +23,33 @@ mechanism to declare that they require these tables, and providing intelligent
 migrations which only drop the tables when no other plugins are using them.
 
 `redmine_acts_as_taggable_on` also provides a limited defence against plugins
-which directly depend on `acts-as-taggable-on` by grepping through their
-Gemfiles for the string `acts-as-taggable-on`, and treating them the same way
-as plugins which use this gem, together with a gentle(-ish) suggestion to
-use this gem instead.
+which directly depend on `acts-as-taggable-on`. It does this by grepping
+through their Gemfiles for the string `acts-as-taggable-on` -- if found, it
+will treat the plugin as requiring the `acts-as-taggable-on` tables, and will
+print a gentle(-ish) suggestion to use this gem instead.
 
 ## Status
 
-**Believed to be stable; not extensively tested in the wild.**
+Believed to be stable. The automated tests currently pass on Redmine trunk,
+2.3.1, 2.2.4, and 2.1.5. However, this gem is not yet used by any Redmine
+plugins in the wild.
 
 ## Limitations
 
-This plugin cannot currently protect against situations where a plugin directly
-using `acts-as-taggable-on` has put the generated migration into its
-db/migrate, and the Redmine admin tries to uninstall it.
+This gem cannot currently protect against situations where a plugin directly
+using `acts-as-taggable-on` has put the generated migration into its db/migrate
+directory. If a user tries to migrate the plugin down by executing `rake
+redmine:plugins:migrate VERSION=0 NAME=redmine_foo_plugin`, the tables will
+still be dropped, regardless of whether other plugins are still using them.
 
-I'm in two minds about whether to fix this: one the one hand, it would require
-some nasty hackery, and it's no worse than the current situation. On the other, 
-losing one's data is not fun.
+I'm in two minds about whether to fix this: on the one hand, it would require
+some nasty monkey-patching. On the other hand, data loss is no fun at all.
 
 ## Setup
 
 Add it to your plugin's Gemfile:
 
-    gem 'redmine_acts_as_taggable_on', '~> 0.1'
+    gem 'redmine_acts_as_taggable_on', '~> 0.2'
 
 Add the migration:
 
@@ -61,4 +64,31 @@ Declare that your plugin needs `redmine_acts_as_taggable_on` inside init.rb:
       requires_acts_as_taggable_on
       ...
 
-That's it. Your plugin should now migrate up and down intelligently.
+That's it. Your plugin will now migrate up and down intelligently. For example:
+
+    cd /path/to/redmine
+
+    cp -r /some/plugin/using/this/gem       plugins/redmine_foo
+    cp -r /another/plugin/using/this/gem    plugins/redmine_bar
+
+    rake redmine:plugins:migrate
+
+    Migrating redmine_bar (Redmine bar)...
+    ==  AddTagsAndTaggings: migrating =========================================
+    -- create_table(:tags)
+       -> 0.0039s
+    -- create_table(:taggings)
+       -> 0.0007s
+    -- add_index(:taggings, :tag_id)
+       -> 0.0003s
+    -- add_index(:taggings, [:taggable_id, :taggable_type, :context])
+       -> 0.0003s
+    ==  AddTagsAndTaggings: migrated (0.0059s) ================================
+
+    Migrating redmine_foo (Redmine foo)...
+    ==  AddTagsAndTaggings: migrating =========================================
+    -- Not creating "tags" and "taggings" because they already exist
+    ==  AddTagsAndTaggings: migrated (0.0006s) ================================
+
+You can look at the [test script](test/test.bats) to see how other situations
+are handled.

data/lib/redmine_acts_as_taggable_on/migration.rb

@@ -1,13 +1,16 @@
 require 'generators/acts_as_taggable_on/migration/templates/active_record/migration'
 
 class RedmineActsAsTaggableOn::Migration < ActsAsTaggableOnMigration
+  class SchemaMismatchError < StandardError; end
+
   def up
     enforce_declarations!
+    check_for_old_style_plugins
 
-    if performed?
-      say 'Not creating "tags" and "taggings" because they already exist'
-    else
+    if ok_to_go_up?
       super
+    else
+      say 'Not creating "tags" and "taggings" because they already exist'
     end
   end
 
@@ -19,35 +22,11 @@ class RedmineActsAsTaggableOn::Migration < ActsAsTaggableOnMigration
     else
       say 'Not dropping "tags" and "taggings" because they\'re still needed by'
       say 'the following plugins:'
-      requiring_plugins.each { |p| say p.id, true }
+      plugins_still_using_tables.each { |p| say p.id, true }
     end
   end
 
   private
-  def performed?
-    ['tags', 'taggings'].any? do |table|
-      ActiveRecord::Base.connection.table_exists? table
-    end
-  end
-
-  # A list of plugins which require redmine_acts_as_taggable_on.
-  #
-  # We reject the current one because we don't want to say
-  #
-  #   refusing to migrate redmine_foo down: tags and taggings tables are still
-  #   required by redmine_foo
-  #
-  # That would be silly.
-  def requiring_plugins
-    Redmine::Plugin.all.
-      select(&:requires_acts_as_taggable_on?).
-      reject {|p| p == Redmine::Plugin::Migrator.current_plugin }
-  end
-
-  def ok_to_go_down?
-    requiring_plugins.empty?
-  end
-
   def enforce_declarations!
     unless current_plugin_declaration_made?
       msg = "You have to declare that you need redmine_acts_as_taggable_on inside\n"
@@ -58,6 +37,74 @@ class RedmineActsAsTaggableOn::Migration < ActsAsTaggableOnMigration
   end
 
   def current_plugin_declaration_made?
-    Redmine::Plugin::Migrator.current_plugin.requires_acts_as_taggable_on?
+    current_plugin.requires_acts_as_taggable_on?
+  end
+
+  def current_plugin
+    Redmine::Plugin::Migrator.current_plugin
+  end
+
+  # Check if any plugins are using acts-as-taggable-on directly; the purpose of
+  # this is only to print a warning if so.
+  def check_for_old_style_plugins
+    Redmine::Plugin.all.each { |p| p.requires_acts_as_taggable_on? }
+    nil
+  end
+
+  def ok_to_go_up?
+    tables_already_exist = %w(tags taggings).any? do |table|
+      ActiveRecord::Base.connection.table_exists? table
+    end
+    if tables_already_exist
+      assert_schema_match!
+      return false
+    end
+    true
+  end
+
+  def assert_schema_match!
+    if (obtain_structure('tags') != expected_tags_structure) ||
+       (obtain_structure('taggings') != expected_taggings_structure)
+      msg = "A plugin is already using the \"tags\" or \"taggings\" tables, and\n"
+      msg << "the structure of the table does not match the structure expected\n"
+      msg << "by #{current_plugin.id}.\n"
+      raise SchemaMismatchError, msg
+    end
+  end
+
+  def obtain_structure(table_name)
+    ActiveRecord::Base.connection.columns(table_name).
+      reject { |c| %w(created_at updated_at id).include? c.name }.
+      map { |c| [c.name, c.type.to_s] }.
+      sort
+  end
+
+  def expected_tags_structure
+    [
+      ['name', 'string']
+    ]
+  end
+
+  def expected_taggings_structure
+    [
+      ['tag_id', 'integer'],
+      ['taggable_id', 'integer'],
+      ['taggable_type', 'string'],
+      ['tagger_id', 'integer'],
+      ['tagger_type', 'string'],
+      ['context', 'string'],
+    ].sort
+  end
+
+  # A list of plugins which are using the acts_as_taggable_on tables (excluding
+  # the current one)
+  def plugins_still_using_tables
+    Redmine::Plugin.all.
+      select(&:using_acts_as_taggable_on_tables?).
+      reject {|p| p == Redmine::Plugin::Migrator.current_plugin }
+  end
+
+  def ok_to_go_down?
+    plugins_still_using_tables.empty?
   end
 end

data/lib/redmine_acts_as_taggable_on/redmine_plugin_patch.rb

@@ -18,6 +18,12 @@ module RedmineActsAsTaggableOn::RedminePluginPatch
     false
   end
 
+  def using_acts_as_taggable_on_tables?
+    return false unless requires_acts_as_taggable_on?
+    return false if Redmine::Plugin::Migrator.current_version(self) == 0
+    true
+  end
+
   private
   def gemfile_path
     File.join(self.directory, 'Gemfile')

data/lib/redmine_acts_as_taggable_on/version.rb

@@ -1,3 +1,3 @@
 module RedmineActsAsTaggableOn
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/redmine_acts_as_taggable_on.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "acts-as-taggable-on", "~> 2.4"
+  spec.add_runtime_dependency "acts-as-taggable-on", ">= 2.3", "< 2.5"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/test/mk_temp_redmine.bash

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -e
+
+# makes a new Redmine installation in a temporary directory, using SQLite as
+# the database.
+make_temp_redmine() {
+  local branch="$1"
+  [ -z "$branch" ] && branch="trunk"
+
+  # for branches which have slashes in them, like tags/2.3.0
+  local branch_filename="${branch//\//-}"
+  temp_redmine=`mktemp -d /tmp/redmine_acts_as_taggable_on.$branch_filename.XXXXXXX`
+  pushd "$temp_redmine"
+
+  svn checkout "http://svn.redmine.org/redmine/$branch" redmine
+  pushd redmine
+
+  echo "production:
+  adapter: sqlite3
+  database: db/redmine.sqlite3" > config/database.yml
+
+  bundle install
+  rake generate_secret_token db:create db:migrate
+
+  popd
+  popd
+}
+
+make_temp_redmine >/dev/null
+echo "$temp_redmine"

data/test/run.bash

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -e
+
+# Run all the tests on a specific branch of Redmine.
+run_tests_on_branch() {
+  temp_redmine_path="`test/mk_temp_redmine.bash "$1"`"
+  export temp_redmine_path
+
+  [ -f test/bats/bin/bats ] || git submodule update
+
+  local test_status=0
+  test/bats/bin/bats test/test.bats || test_status=1
+
+  if [ "$test_status" -eq 1 ]; then
+    echo "Some tests failed on redmine:$1. You can inspect the tree at $temp_redmine_path"
+  else
+    rm -rf "$temp_redmine_path"
+  fi
+
+  return $test_status
+}
+
+RAILS_ENV="production"
+export RAILS_ENV
+
+redmine_acts_as_taggable_on_path="$(cd "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"
+export redmine_acts_as_taggable_on_path
+pushd "$redmine_acts_as_taggable_on_path" >/dev/null
+
+branches=(trunk tags/2.3.1 tags/2.2.4 tags/2.1.5)
+test_status=0
+
+for branch in ${branches[@]}; do
+  echo    "testing on branch: $branch"
+  echo -n "==================="
+  # make the underline the same length as the title
+  echo ${branch//?/=}
+
+  run_tests_on_branch "$branch" || test_status=1
+  echo
+done
+
+popd >/dev/null
+exit $test_status

data/test/test.bats

@@ -0,0 +1,143 @@
+#!/usr/bin/env bats
+
+load test_helpers
+
+# files which should be backed up and restored to how they were at the start
+# between each test
+preserved_files=(db/redmine.sqlite3 db/schema.rb)
+
+setup() {
+  pushd "$temp_redmine_path/redmine" >/dev/null
+  for file in $preserved_files; do
+      cp $file $file.bak
+  done
+}
+
+teardown() {
+  rm -rf plugins/*
+  for file in $preserved_files; do
+      mv $file.bak $file
+  done
+  popd >/dev/null
+}
+
+@test "migrates upwards with solitary proper plugin" {
+  mk_proper_plugin "foo"
+  rake redmine:plugins:migrate
+
+  db_table_exists 'tags'
+  db_table_exists 'taggings'
+}
+
+@test "migrates downwards with solitary proper plugin" {
+  mk_proper_plugin "foo"
+  rake redmine:plugins:migrate
+  rake redmine:plugins:migrate NAME=redmine_foo VERSION=0
+
+  ! db_table_exists 'tags'
+  ! db_table_exists 'taggings'
+}
+
+@test "migrates upwards with two proper plugins" {
+  mk_proper_plugin "foo"
+  rake redmine:plugins:migrate
+
+  mk_proper_plugin "bar"
+  run rake redmine:plugins:migrate
+  [ "$status" -eq 0 ]
+  assert_contain 'Not creating "tags" and "taggings"' "$output"
+
+  db_table_exists 'tags'
+  db_table_exists 'taggings'
+}
+
+@test "doesn't drop tables when another proper plugin exists" {
+  mk_proper_plugin "foo"
+  mk_proper_plugin "bar"
+
+  rake redmine:plugins:migrate
+
+  echo 'Now migrating down...'
+  run rake redmine:plugins:migrate NAME=redmine_foo VERSION=0
+  [ "$status" -eq 0 ]
+  assert_contain 'Not dropping "tags" and "taggings"' "$output"
+
+  # Should say still needed by redmine_bar
+  assert_contain '-> redmine_bar' "$output"
+  # Should not say still needed by redmine_foo
+  ! assert_contain '-> redmine_foo' "$output"
+
+  db_table_exists 'tags'
+  db_table_exists 'taggings'
+}
+
+@test "migrates downwards with two proper plugins" {
+  mk_proper_plugin "foo"
+  mk_proper_plugin "bar"
+
+  rake redmine:plugins:migrate
+  rake redmine:plugins:migrate NAME=redmine_foo VERSION=0
+  rake redmine:plugins:migrate NAME=redmine_bar VERSION=0
+
+  ! db_table_exists 'tags'
+  ! db_table_exists 'taggings'
+}
+
+@test "schema sanity check when migrating proper plugin up" {
+  mk_standard_plugin "baz"
+
+  mkdir -p plugins/redmine_baz/db/migrate
+  echo "class AddTags < ActiveRecord::Migration
+  def up
+    create_table :tags do |t|
+      t.integer :foo
+    end
+  end
+
+  def down
+    drop_table :tags
+  end
+end" > plugins/redmine_baz/db/migrate/001_add_tags.rb
+
+  rake redmine:plugins:migrate
+
+  mk_proper_plugin "foo"
+  run rake redmine:plugins:migrate
+  [ "$status" -ne 0 ]
+  assert_contain 'table does not match' "$output"
+}
+
+@test "enforces that declarations were made" {
+  mk_plugin_missing_declaration "quux"
+
+  run rake redmine:plugins:migrate
+  [ "$status" -ne 0 ]
+  echo "$output"
+  assert_contain 'You have to declare that you need' "$output"
+}
+
+@test "warns about acts-as-taggable-on when going up" {
+  mk_proper_plugin "foo"
+  mk_old_style_plugin "bar"
+
+  run rake redmine:plugins:migrate
+  [ "$status" -eq 0 ]
+  echo "$output"
+  assert_contain "WARNING: The plugin redmine_bar is using 'acts-" "$output"
+}
+
+@test "warns about acts-as-taggable-on when going down" {
+  mk_proper_plugin "foo"
+  mk_old_style_plugin "bar"
+
+  rake redmine:plugins:migrate
+
+  # Note that we have to migrate redmine_foo down so that the
+  # RedmineActsAsTaggableOn::Migration class does the migration, because it
+  # does the checking. Migrating redmine_bar down would not trigger the
+  # warning.
+  run rake redmine:plugins:migrate NAME=redmine_foo VERSION=0
+  [ "$status" -eq 0 ]
+  echo "$output"
+  assert_contain "WARNING: The plugin redmine_bar is using 'acts-" "$output"
+}

data/test/test_helpers.bash

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+
+# Create an empty skeleton Redmine plugin. It's given the name redmine_$1.
+mk_standard_plugin() {
+  local name="redmine_$1"
+  mkdir plugins/$name
+  pushd plugins/$name >/dev/null
+
+  echo "Redmine::Plugin.register(:$name) { name '$name' }" > init.rb
+
+  popd >/dev/null
+
+  echo "Created a standard redmine plugin: $name"
+}
+
+# Create a plugin which uses the redmine_acts_as_taggable_on gem properly.
+mk_proper_plugin() {
+  mk_standard_plugin "$1" >/dev/null
+  local name="redmine_$1"
+  pushd plugins/$name >/dev/null
+
+  echo "gem 'redmine_acts_as_taggable_on',
+  :path => '$redmine_acts_as_taggable_on_path'" > Gemfile
+
+  echo "require 'redmine_acts_as_taggable_on/initialize'
+Redmine::Plugin.register(:$name) { requires_acts_as_taggable_on }" \
+    > init.rb
+
+  mkdir -p db/migrate
+  echo "class AddTagsAndTaggings < RedmineActsAsTaggableOn::Migration; end" \
+    > db/migrate/001_add_tags_and_taggings.rb
+
+  bundle >/dev/null
+
+  popd >/dev/null
+
+  echo "Created a redmine plugin using redmine_acts_as_taggable_on: $name"
+}
+
+# Create a plugin which uses redmine_acts_as_taggable_on but without the
+# declaration in init.rb
+mk_plugin_missing_declaration() {
+  mk_proper_plugin "$1" >/dev/null
+  local name="redmine_$1"
+  pushd plugins/$name >/dev/null
+
+  echo "require 'redmine_acts_as_taggable_on/initialize'
+Redmine::Plugin.register(:$name) { name '$name' }" > init.rb
+
+  popd >/dev/null
+
+  echo "Created a redmine plugin using redmine_acts_as_taggable_on"
+  echo "  (but without the declaration): $name"
+}
+
+# Create a plugin which uses acts-as-taggable-on directly, and which expects
+# you to do rails g acts_as_taggable_on:migration yourself.
+mk_old_style_plugin() {
+  mk_standard_plugin "$1" >/dev/null
+  local name="redmine_$1"
+  pushd plugins/$name >/dev/null
+
+  echo "gem 'acts-as-taggable-on'" > Gemfile
+  bundle >/dev/null
+  popd >/dev/null
+
+  echo "Created a plugin using acts-as-taggable-on without the embedded"
+  echo "  migration: $name"
+}
+
+db_query() {
+  # use -init to ensure ~/.sqliterc isn't read
+  sqlite3 -init "" db/redmine.sqlite3 "$1"
+}
+
+db_table_exists() {
+  db_query "SELECT 'it exists'
+  FROM sqlite_master
+  WHERE type='table' AND name='$1'" | grep 'it exists' >/dev/null
+
+  exists="$?"
+  if [ "$exists" -eq 1 ]; then
+      echo "Database table $1 exists."
+  else
+      echo "Database table $1 does not exist."
+  fi
+
+  return $exists
+}
+
+assert_contain() {
+  echo -n "Checking whether a string contains '$1'... "
+  if [[ "$2" == *"$1"* ]]; then
+      echo "Yep."
+  else
+      echo "Nope."
+      return 1
+  fi
+}

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: redmine_acts_as_taggable_on
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Harry Garrood
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-08 00:00:00.000000000 Z
+date: 2013-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: acts-as-taggable-on
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - <
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - <
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -60,6 +66,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .gitmodules
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -70,6 +78,10 @@ files:
 - lib/redmine_acts_as_taggable_on/redmine_plugin_patch.rb
 - lib/redmine_acts_as_taggable_on/version.rb
 - redmine_acts_as_taggable_on.gemspec
+- test/mk_temp_redmine.bash
+- test/run.bash
+- test/test.bats
+- test/test_helpers.bash
 homepage: https://github.com/hdgarrood/redmine_acts_as_taggable_on
 licenses:
 - GPLv2
@@ -90,10 +102,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Allows multiple Redmine plugins to use the acts_as_taggable_on gem without
   stepping on each others' toes.
-test_files: []
+test_files:
+- test/mk_temp_redmine.bash
+- test/run.bash
+- test/test.bats
+- test/test_helpers.bash
 has_rdoc: