redmineup 1.0.2 → 1.1.13

data/lib/redmineup.rb

@@ -27,6 +27,7 @@ require 'redmineup/money_helper'
 require 'redmineup/colors_helper'
 
 require 'liquid'
+require 'redmineup/liquid/filters/additional'
 require 'redmineup/liquid/filters/base'
 require 'redmineup/liquid/filters/arrays'
 require 'redmineup/liquid/filters/colors'
@@ -37,18 +38,38 @@ require 'redmineup/liquid/drops/users_drop'
 require 'redmineup/liquid/drops/time_entries_drop'
 require 'redmineup/liquid/drops/attachment_drop'
 require 'redmineup/liquid/drops/issue_relations_drop'
+require 'redmineup/liquid/drops/version_drop'
+require 'redmineup/liquid/drops/custom_field_enumeration_drop'
 
 require 'redmineup/helpers/external_assets_helper'
 require 'redmineup/helpers/form_tag_helper'
-require 'redmineup/helpers/rup_calendar_helper'
+require 'redmineup/helpers/calendars_helper'
+require 'redmineup/helpers/datetime_helper'
+require 'redmineup/helpers/test_helper'
 require 'redmineup/assets_manager'
 
-require 'redmineup/compatibility/application_controller_patch'
-require 'redmineup/compatibility/routing_mapper_patch'
-require 'redmineup/patches/liquid_patch' unless BigDecimal.respond_to?(:new)
+require 'redmineup/patches/liquid_patch'
 
 module Redmineup
   GEM_NAME = 'redmineup'.freeze
+
+  def self.plugin_installed?(plugin_id)
+    Rails.root.join("plugins/#{plugin_id}/init.rb").exist?
+  end
+
+  def self.cable_available?
+    Rails.version > '4.0'
+  end
+end
+
+require 'application_record' if !defined?(ApplicationRecord) && Rails.version < '7.2.2'
+
+if Redmineup.cable_available?
+  require 'action_cable/server/rup_configuration'
+  require 'action_cable/server/rup_server'
+  require 'action_cable/connection/rup_connection'
+  require 'redmineup/patches/action_cable_base_patch'
+  require 'redmineup/patches/action_cable_patch'
 end
 
 if defined?(ActiveRecord::Base)
@@ -57,52 +78,57 @@ if defined?(ActiveRecord::Base)
   ActiveRecord::Base.extend(Redmineup::ActsAsVotable::Votable)
 end
 
-Redmineup::AssetsManager.install_assets
+if defined?(Propshaft::Assembly)
+  Propshaft::Assembly.prepend(Module.new do
+    def self.prepended(base)
+      base.class_eval do
+        cattr_accessor :redmineup_patched
+      end
+    end
+
+    def config
+      return super if self.class.redmineup_patched
+
+      original_config = super
+      if defined?(Redmine::AssetPath)
+        base_dir = Pathname.new(Redmineup::AssetsManager.base_path)
+        paths = Redmineup::AssetsManager.assets_paths.map { |path| Pathname.new(path)}
+        asset_prefix = "plugin_assets/#{Redmineup::GEM_NAME}"
+
+        original_config[:redmine_extension_paths] << Redmine::AssetPath.new(base_dir, paths, asset_prefix)
+        self.class.redmineup_patched = true
+      end
+      original_config
+    end
+  end)
+else
+  Redmineup::AssetsManager.install_assets
+end
 
 if defined?(ActionView::Base)
+  ActionView::Base.send :include, Redmineup::CalendarsHelper
   ActionView::Base.send :include, Redmineup::ExternalAssetsHelper
   ActionView::Base.send :include, Redmineup::FormTagHelper
+  ActionView::Base.send :include, Redmineup::TagsHelper
 end
 
 def requires_redmineup(arg)
-  def compare_versions(requirement, current)
-    raise ArgumentError.new('wrong version format') unless check_version_format(requirement)
+  arg = { version_or_higher: arg } unless arg.is_a?(Hash)
+  arg.assert_valid_keys(:version_or_higher)
 
-    requirement = requirement.split('.').collect(&:to_i)
-    requirement <=> current.slice(0, requirement.size)
+  requirement = arg[:version_or_higher]
+  unless requirement.is_a?(String)
+    raise ArgumentError, ':version_or_higher accepts a version string only'
   end
 
-  def check_version_format(version)
-    version =~ /^\d+.?\d*.?\d*$/m
-  end
+  current = Gem::Version.new(Redmineup::VERSION)
+  required = Gem::Version.new(requirement)
 
-  arg = { version_or_higher: arg } unless arg.is_a?(Hash)
-  arg.assert_valid_keys(:version, :version_or_higher)
+  return true if required <= current
 
-  current = Redmineup::VERSION.split('.').map { |x| x.to_i }
-  arg.each do |k, req|
-    case k
-    when :version_or_higher
-      raise ArgumentError.new(':version_or_higher accepts a version string only') unless req.is_a?(String)
-
-      unless compare_versions(req, current) <= 0
-        Rails.logger.error "\033[31m[ERROR]\033[0m Redmine requires redmineup gem version #{req} or higher (you're using #{Redmineup::VERSION}).\n\033[31m[ERROR]\033[0m Please update with 'bundle update redmineup'." if Rails.logger
-        abort "\033[31mRedmine requires redmineup gem version #{req} or higher (you're using #{Redmineup::VERSION}).\nPlease update with 'bundle update redmineup'.\033[0m"
-      end
-    when :version
-      req = [req] if req.is_a?(String)
-      if req.is_a?(Array)
-        unless req.detect { |ver| compare_versions(ver, current) == 0 }
-          abort "\033[31mRedmine requires redmineup gem version #{req} (you're using #{Redmineup::VERSION}).\nPlease update with 'bundle update redmineup'.\033[0m"
-        end
-      elsif req.is_a?(Range)
-        unless compare_versions(req.first, current) <= 0 && compare_versions(req.last, current) >= 0
-          abort "\033[31mRedmine requires redmineup gem version between #{req.first} and #{req.last} (you're using #{Redmineup::VERSION}).\nPlease update with 'bundle update redmineup'.\033[0m"
-        end
-      else
-        raise ArgumentError.new(':version option accepts a version string, an array or a range of versions')
-      end
-    end
-  end
-  true
+  message = "Redmine requires redmineup gem version #{requirement} or higher " \
+            "(you're using #{Redmineup::VERSION}).\n" \
+            "Please update with 'bundle update redmineup --conservative'."
+  Rails.logger&.error("\033[31m[ERROR]\033[0m #{message}")
+  abort "\033[31m#{message}\033[0m"
 end

data/test/acts_as_taggable/rup_acts_as_taggable_test.rb

@@ -338,7 +338,7 @@ class RupActsAsTaggableTest < ActiveSupport::TestCase
 
   def test_tags_condition
     assert_equal "(tags_TABLE.name LIKE #{tags(:feature).id} OR tags_TABLE.name LIKE #{tags(:bug).id})",
-                 Issue.send(:tags_condition, [tags(:feature), tags(:bug)], 'tags_TABLE')
+                 Issue.send(:tags_condition, [tags(:feature), tags(:bug)], 'tags_TABLE').gsub("'", "")
   end
 
   def test_all_tags_list

data/test/acts_as_taggable/tag_test.rb

@@ -33,6 +33,22 @@ class TagTest < ActiveSupport::TestCase
     assert_equal tags(:error).name, tags(:error).to_s
   end
 
+  def test_color
+    assert_equal '#aaaaaa', tags(:feature).color # 11184810 = 0xaaaaaa
+    assert_equal '#bbbbbb', tags(:bug).color     # 12303291 = 0xbbbbbb
+    # no DB color — falls back to color_from_name, not nil
+    assert_equal Redmineup::ActsAsTaggable::Tag.color_from_name('error'), tags(:error).color
+    assert_equal Redmineup::ActsAsTaggable::Tag.color_from_name('question'), tags(:question).color
+  end
+
+  def test_color_from_name
+    color = Redmineup::ActsAsTaggable::Tag.color_from_name('error')
+    assert_match(/\A#[0-9a-f]{6}\z/, color)
+    assert_equal color, Redmineup::ActsAsTaggable::Tag.color_from_name('error') # deterministic
+    assert_not_equal color, Redmineup::ActsAsTaggable::Tag.color_from_name('other')
+    assert_match(/\A#[0-9a-f]{6}\z/, Redmineup::ActsAsTaggable::Tag.color_from_name(nil))
+  end
+
   def test_tag_is_equal_to_itself
     tag = tags(:error)
     assert_equal tag, tag

data/test/acts_as_votable/votable_test.rb

@@ -67,7 +67,7 @@ class VotableTest < ActiveSupport::TestCase
     assert_equal votable.find_votes_for(:vote_scope => 'rank').size, 1
   end
 
-  def test_two_votes_for_when_voting_on_two_diff_scopes
+  def test_two_votes_for_when_voting_on_two_diff_scopes_dup
     votable.vote_by(:voter => voters(:voter), :vote => 'yes', :vote_scope => 'weekly_rank')
     votable.vote_by(:voter => voters(:voter), :vote => 'yes', :vote_scope => 'monthly_rank')
     assert_equal votable.votes_for.size, 2
@@ -404,7 +404,7 @@ class VotableTest < ActiveSupport::TestCase
     assert_equal votable_cache.cached_scoped_test_votes_total, 1
   end
 
-  def test_update_cached_total_votes_for_when_a_vote_up_is_removed
+  def test_update_cached_total_votes_for_when_a_vote_up_is_removed_dup
     votable_cache.vote_by(:voter => voter, :vote => 'true', :vote_scope => "test")
     votable_cache.unvote(:voter => voter, :vote_scope => "test")
     assert_equal votable_cache.cached_scoped_test_votes_total, 0
@@ -440,44 +440,44 @@ class VotableTest < ActiveSupport::TestCase
     assert_equal votable_cache.cached_scoped_test_votes_score, 0
   end
 
-  def test_update_cached_up_votes_for_if_there_is_an_up_vote_column
+  def test_update_cached_up_votes_for_if_there_is_an_up_vote_column_dup
     votable_cache.cached_scoped_test_votes_up = 50
     votable_cache.vote_by(:voter => voter, :vote_scope => "test")
     votable_cache.vote_by(:voter => voter, :vote_scope => "test")
     assert_equal votable_cache.cached_scoped_test_votes_up, 1
   end
 
-  def test_update_cached_down_votes_for_if_there_is_a_down_vote_column
+  def test_update_cached_down_votes_for_if_there_is_a_down_vote_column_dup
     votable_cache.cached_scoped_test_votes_down = 50
     votable_cache.vote_by(:voter => voter, :vote => 'false', :vote_scope => "test")
     assert_equal votable_cache.cached_scoped_test_votes_down, 1
   end
 
-  def test_update_cached_up_votes_for_when_a_vote_up_is_removed
+  def test_update_cached_up_votes_for_when_a_vote_up_is_removed_dup
     votable_cache.vote_by :voter => voter, :vote => 'true', :vote_scope => "test"
     votable_cache.unvote :voter => voter, :vote_scope => "test"
     assert_equal votable_cache.cached_scoped_test_votes_up, 0
   end
 
-  def test_update_cached_down_votes_for_when_a_vote_down_is_removed
+  def test_update_cached_down_votes_for_when_a_vote_down_is_removed_dup
     votable_cache.vote_by(:voter => voter, :vote => 'false', :vote_scope => "test")
     votable_cache.unvote(:voter => voter, :vote_scope => "test")
     assert_equal votable_cache.cached_scoped_test_votes_down, 0
   end
 
-  def test_select_from_cached_total_votes_for_if_there_a_total_column
+  def test_select_from_cached_total_votes_for_if_there_a_total_column_dup
     votable_cache.vote_by(:voter => voter, :vote_scope => "test")
     votable_cache.cached_scoped_test_votes_total = 50
     assert_equal votable_cache.count_votes_total(false, "test"), 50
   end
 
-  def test_select_from_cached_up_votes_for_if_there_is_an_up_vote_column
+  def test_select_from_cached_up_votes_for_if_there_is_an_up_vote_column_dup
     votable_cache.vote_by(:voter => voter, :vote_scope => "test")
     votable_cache.cached_scoped_test_votes_up = 50
     assert_equal votable_cache.count_votes_up(false, "test"), 50
   end
 
-  def test_select_from_cached_down_votes_for_if_there_is_a_down_vote_column
+  def test_select_from_cached_down_votes_for_if_there_is_a_down_vote_column_dup
     votable_cache.vote_by(:voter => voter, :vote => 'false', :vote_scope => "test")
     votable_cache.cached_scoped_test_votes_down = 50
     assert_equal votable_cache.count_votes_down(false, "test"), 50

data/test/acts_as_votable/voter_test.rb

@@ -188,7 +188,7 @@ class VoterTest < ActiveSupport::TestCase
   end
 
   # describe '#find_up_voted_items
-  def test_returns_objects_that_a_user_has_upvoted_for
+  def test_returns_objects_that_a_user_has_upvoted_for_dup
     votable.vote_by(:voter => voter)
     votables(:votable2).vote_by :voter => voters(:voter2)
     assert voter.find_up_voted_items.include? votable
@@ -197,7 +197,7 @@ class VoterTest < ActiveSupport::TestCase
     assert_equal voter.find_liked_items.size, 1
   end
 
-  def test_returns_objects_that_a_user_has_upvoted_for_using_scope
+  def test_returns_objects_that_a_user_has_upvoted_for_using_scope_dup
     votable.vote_by(:voter => voter, :vote_scope => 'rank')
     votables(:votable2).vote_by(:voter => voters(:voter2), :vote_scope => 'rank')
     assert voter.find_up_voted_items(:vote_scope => 'rank').include? votable
@@ -226,7 +226,7 @@ class VoterTest < ActiveSupport::TestCase
     assert_equal voter.find_down_voted_items(:vote_scope => 'rank').size, 0
   end
 
-  def test_returns_objects_that_a_user_has_downvoted_for
+  def test_returns_objects_that_a_user_has_downvoted_for_dup
     votable.vote_down voter
     votables(:votable2).vote_down voters(:voter2)
     assert voter.find_down_voted_items.include? votable
@@ -235,7 +235,7 @@ class VoterTest < ActiveSupport::TestCase
     assert_equal voter.find_disliked_items.size, 1
   end
 
-  def test_returns_objects_that_a_user_has_downvoted_for_using_scope
+  def test_returns_objects_that_a_user_has_downvoted_for_using_scope_dup
     votable.vote_down voter, :vote_scope => 'rank'
     votables(:votable2).vote_down voters(:voter2), :vote_scope => 'rank'
     assert voter.find_down_voted_items(:vote_scope => 'rank').include? votable

data/test/database.yml

@@ -1,17 +1,17 @@
 sqlite:
   adapter: sqlite3
-  database: ':memory:'
+  database: ":memory:"
 
 mysql:
   adapter: mysql2
   database: redmineup_test
   username: root
   password: password
-  host: 127.0.0.1
+  host: mysql
 
 postgresql:
   adapter: postgresql
   database: redmineup_test
   user: postgres
   password: password
-  host: 127.0.0.1
+  host: postgres

data/test/fixtures/tags.yml

@@ -3,9 +3,11 @@ error:
   
 feature:
   name: New feature
+  color: 11184810
   
 bug:
   name: bug
+  color: 12303291
   
 question:
   name: question

data/test/liquid/drops/issues_drop_test.rb

@@ -26,6 +26,11 @@ module Redmineup
       assert_equal @user.name, @liquid_render.render('{{ issue.author.name }}')
     end
 
+    def test_issue_attachments
+      attachment_author = @issue.attachments.first.author.name
+      assert_equal attachment_author, @liquid_render.render('{% assign attach = issue.attachments | first %}{{ attach.author.name }}')
+    end
+
     def test_issue_delegated
       assert_equal [@issue.id, @issue.subject, @issue.description].join('|'),
                    @liquid_render.render('{{ issue.id }}|{{ issue.subject }}|{{ issue.description }}')

data/test/liquid/filters/additional_filter_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../liquid_helper'
+include LiquidHelperMethods
+
+module Redmineup
+  class AdditionalFilterTest < ActiveSupport::TestCase
+    def setup
+      @issue = Issue.first
+      @issue_drop = Liquid::IssueDrop.new(@issue)
+      @strainer = ::Liquid::Context.new.strainer
+    end
+
+    def test_parse_inline_attachments
+      text = '<p>description with image <img src="screenshot.png" /></p>'
+      attachment = mock_attachment
+      attachments = [attachment]
+      @issue_drop.define_singleton_method(:attachments) { attachments }
+      Attachment.stub(:latest_attach, attachment) do
+        expected_string = '<p>description with image ' \
+        '<img src=\'data:image/content_type;base64,to_base64_string\'  title="attach_image" alt="attach_image" /></p>'
+        assert_equal expected_string, @strainer.parse_inline_attachments(text, @issue_drop)
+      end
+    end
+
+    private
+
+    def mock_attachment
+      attachment = Minitest::Mock.new
+      attachment.expect(:url, 'mock_url')
+      attachment.expect(:description, "attach_image")
+      attachment.expect(:content_type, "content_type")
+      attachment.expect(:to_base64_string, "to_base64_string")
+      attachment
+    end
+  end
+end

data/test/liquid/filters/arrays_filter_test.rb

@@ -17,9 +17,9 @@ module Redmineup
     end
 
     def test_where_filter
-      assert_match '{"name"=>"two", "value"=>5}', @liquid_render.render("{{ objects_arr | where: 'name', 'two' }}")
-      assert_match '{"name"=>"one", "value"=>10}', @liquid_render.render("{{ objects_arr | where: 'value', 6, '>' }}")
-      assert_match '{"name"=>"one", "value"=>10}', @liquid_render.render("{{ objects_arr | where: 'name', 'on', 'match' }}")
+      assert_match ws('{"name"=>"two", "value"=>5}'), ws(@liquid_render.render("{{ objects_arr | where: 'name', 'two' }}"))
+      assert_match ws('{"name"=>"one", "value"=>10}'), ws(@liquid_render.render("{{ objects_arr | where: 'value', 6, '>' }}"))
+      assert_match ws('{"name"=>"one", "value"=>10}'), ws(@liquid_render.render("{{ objects_arr | where: 'name', 'on', 'match' }}"))
       assert_match '3', @liquid_render.render("{{ objects_arr | where: 'value', '', 'any' | size }}")
       assert_match '1', @liquid_render.render("{{ objects_arr | where: 'value', '', 'none' | size }}")
       assert_match '2', @liquid_render.render("{{ issues.all | where: 'author.name', 'Jonathan', '==' | size }}")
@@ -27,5 +27,8 @@ module Redmineup
       assert_match '0', @liquid_render.render("{{ issues.all | where: 'author.name', '', 'none' | size }}")
     end
 
+    def ws(string)
+      string.delete(' ')
+    end
   end
 end

data/test/liquid/liquid_helper.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class LiquidRender
-  
+
   def initialize(drops = {})
     @objects_hash = [
       {'name' => 'one', "value" => 10},

data/test/models/attachment.rb

@@ -1,3 +1,8 @@
 class Attachment < ActiveRecord::Base
   belongs_to :author, :class_name => "User"
+
+  def self.latest_attach(attachments, filename)
+    # stub method for test
+    # returned one attachment
+  end
 end

data/test/models/issue.rb

@@ -8,6 +8,7 @@ class Issue < ActiveRecord::Base
 
   has_many :relations_from, class_name: 'IssueRelation', foreign_key: 'issue_from_id', dependent: :delete_all
   has_many :relations_to, class_name: 'IssueRelation', foreign_key: 'issue_to_id', dependent: :delete_all
+  has_many :journals, foreign_key: 'journalized_id'
 
   up_acts_as_draftable
   up_acts_as_taggable
@@ -18,4 +19,8 @@ class Issue < ActiveRecord::Base
   def visible?
     true
   end
+
+  def attachments
+    Attachment.all
+  end
 end

data/test/models/journal.rb

@@ -0,0 +1,6 @@
+class Journal < ActiveRecord::Base
+  belongs_to :journalized, :polymorphic => true
+  belongs_to :issue, :foreign_key => :journalized_id
+
+  belongs_to :user
+end

data/test/schema.rb

@@ -25,97 +25,109 @@ ActiveRecord::Schema.define version: 0 do
     t.datetime :updated_at
   end
 
-  create_table "tags", :force => true do |t|
-    t.column "name", :string
+  create_table :journals, force: true  do |t|
+    t.integer :journalized_id, default: 0, null: false
+    t.string :journalized_type, limit: 30, default: "", null: false
+    t.integer :user_id, default: 0, null: false
+    t.text :notes
+    t.datetime :created_on, null: false
+    t.boolean :private_notes, default: false, null: false
   end
 
-  create_table "taggings", :force => true do |t|
-    t.column "tag_id", :integer
-    t.column "taggable_id", :integer
-    t.column "taggable_type", :string
-    t.column "created_at", :datetime
+  create_table :tags, force: true do |t|
+    t.string :name
+    t.string :color
   end
 
-  create_table "users", :force => true do |t|
-    t.column "name", :string
-    t.column "language", :string
+  create_table :taggings, force: true do |t|
+    t.integer  :tag_id
+    t.integer  :taggable_id
+    t.string   :taggable_type
+    t.datetime :created_at
   end
 
-  create_table "issue_relations", :force => true do |t|
-    t.column "issue_from_id", :integer
-    t.column "issue_to_id", :integer
-    t.column "relation_type", :string
-    t.column "delay", :integer
+  create_table :users, force: true do |t|
+    t.string :name
+    t.string :language
   end
 
-  create_table "issues", :force => true do |t|
-    t.integer  "project_id"
-    t.column "subject", :string
-    t.column "description", :string
-    t.column "closed", :boolean
-    t.column "cached_tag_list", :string
-    t.column "user_id", :integer
-    t.column "author_id", :integer
-    t.column "views", :integer, :default => 0
-    t.column "total_views", :integer, :default => 0
+  create_table :categories, force: true do |t|
+    t.string :name
   end
 
-  create_table "votes", :force => true do |t|
-    t.references "votable", :polymorphic => true
-    t.references "voter", :polymorphic => true
-
-    t.boolean "vote_flag"
-    t.string "vote_scope"
-    t.integer "vote_weight"
-    t.string "vote_ip"
-
+  create_table :issue_relations, force: true do |t|
+    t.integer :issue_from_id
+    t.integer :issue_to_id
+    t.string  :relation_type
+    t.integer :delay
+  end
+
+  create_table :issues, force: true do |t|
+    t.integer :project_id
+    t.string  :subject
+    t.string  :description
+    t.boolean :closed
+    t.string  :cached_tag_list
+    t.integer :user_id
+    t.integer :author_id
+    t.integer :views, default: 0
+    t.integer :total_views, default: 0
+  end
+
+  create_table :votes, force: true do |t|
+    t.references :votable, polymorphic: true
+    t.references :voter, polymorphic: true
+    t.boolean  :vote_flag
+    t.string   :vote_scope
+    t.integer  :vote_weight
+    t.string   :vote_ip
     t.timestamps
   end
 
-  create_table "news", :force => true do |t|
-    t.string   "title"
-    t.text     "description"
-    t.integer  "author_id"
+  create_table :news, force: true do |t|
+    t.string  :title
+    t.text    :description
+    t.integer :author_id
   end
 
-  create_table "projects", :force => true do |t|
-    t.string   "name"
-    t.text     "description"
-    t.string   "identifier"
-    t.integer  "status"
+  create_table :projects, force: true do |t|
+    t.string  :name
+    t.text    :description
+    t.string  :identifier
+    t.integer :status
   end
 
-  create_table :voters, :force => true do |t|
+  create_table :voters, force: true do |t|
     t.string :name
   end
 
-  create_table :not_voters, :force => true do |t|
+  create_table :not_voters, force: true do |t|
     t.string :name
   end
 
-  create_table :votables, :force => true do |t|
+  create_table :votables, force: true do |t|
     t.string :name
   end
 
-  create_table :votable_voters, :force => true do |t|
+  create_table :votable_voters, force: true do |t|
     t.string :name
   end
 
-  create_table :sti_votables, :force => true do |t|
+  create_table :sti_votables, force: true do |t|
     t.string :name
     t.string :type
   end
 
-  create_table :sti_not_votables, :force => true do |t|
+  create_table :sti_not_votables, force: true do |t|
     t.string :name
     t.string :type
   end
 
-  create_table :not_votables, :force => true do |t|
+  create_table :not_votables, force: true do |t|
     t.string :name
   end
 
-  create_table :votable_caches, :force => true do |t|
+  create_table :votable_caches, force: true do |t|
     t.string :name
     t.integer :cached_votes_total
     t.integer :cached_votes_score
@@ -134,11 +146,11 @@ ActiveRecord::Schema.define version: 0 do
     t.float :cached_scoped_weighted_average
   end
 
-  create_table :viewings, :force => true do |t|
+  create_table :viewings, force: true do |t|
     t.column :viewer_id,   :integer
     t.column :viewed_id,   :integer
     t.column :viewed_type, :string
-    t.column :ip, :string, :limit => '24'
+    t.column :ip, :string, limit: '45'
     t.column :created_at, :datetime
   end
 end

data/test/tags_helper_view_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TagsHelperViewTest < ActionView::TestCase
+  include Redmineup::TagsHelper
+  include Redmineup::FormTagHelper
+
+  def stub_tag_url(name) 
+    "/stub_tags/#{name}" # URL stub for tag_cloud_links(tags, :stub)
+  end
+
+  def test_tag_link
+    result = tag_link('/tags/error', 'error', count: 3)
+    assert_includes result, 'tag-label-color'
+    assert_includes result, 'background-color: #'
+    assert_includes result, '(3)'
+  end
+
+  def test_tag_links
+    result = tag_links(['error', 'bug']) { |t| "/tags/#{t}" }
+    assert_includes result, 'class="tag_list"'
+    assert_nil tag_links([]) { |t| "/tags/#{t}" }
+  end
+
+  def test_tag_cloud_links
+    result = tag_cloud_links(Issue.tag_counts, :stub)
+    assert_includes result, 'class="tag_list"'
+    assert_includes result, '/stub_tags/'
+    assert_nil tag_cloud_links([], :stub)
+    assert_raises(NoMethodError) { tag_cloud_links(Issue.tag_counts, :unknown_xyz) }
+  end
+
+  def test_tag_list_field_tag
+    result = tag_list_field_tag('issue[tag_list]', ['bug'],
+                                url: '/auto_completes/taggable_tags',
+                                width: '60%', tags: false,
+                                placeholder: '+ add tag')
+    assert_includes result, 'name="issue[tag_list][]"'
+    assert_includes result, '"width":"60%"'
+    assert_includes result, '"tags":false'
+  end
+end