redmineup 1.0.10 → 1.1.13

data/lib/redmineup/helpers/tags_helper.rb

@@ -9,5 +9,46 @@ module Redmineup
         yield tag, classes[index]
       end
     end
+
+    def tag_link(url, tag_name, options = {})
+      count      = options.delete(:count)
+      inner      = link_to(tag_name, url, options)
+      inner << content_tag('span', "(#{count})", class: 'tag-count') if count
+      css        = monochrome? ? 'tag-label' : 'tag-label-color'
+      style      = monochrome? ? {} : { style: "background-color: #{Redmineup::ActsAsTaggable::Tag.color_from_name(tag_name)}" }
+      content_tag(:span, inner, { class: css }.merge(style))
+    end
+
+    def tag_separator
+      monochrome? ? ', ' : ' '
+    end
+
+    def monochrome?
+      @monochrome ||= defined?(RedmineupTags) && !RedmineupTags.use_colors?
+    end
+
+    def tag_links(tag_list, options = {}, &url_block)
+      return if tag_list.blank?
+      content_tag(:span, class: 'tag_list') do
+        safe_join(tag_list.map { |tag| tag_link(url_block.call(tag), tag, options.dup) }, tag_separator)
+      end
+    end
+
+    # Renders span.tag_list from an array of tag objects (respond to .name and .count).
+    # Resolves URL via `{key}_tag_url(name)` in the current view context.
+    #
+    #   tag_cloud_links(contact.available_tags, :contact)   # → contact_tag_url(name)
+    #   tag_cloud_links(tags_cloud, :people)                # → people_tag_url(name)
+    def tag_cloud_links(tags, key, options = {})
+      return if tags.blank?
+      url_method = :"#{key}_tag_url"
+      raise NoMethodError, "#{url_method} is not defined in view context" unless respond_to?(url_method, true)
+      content_tag(:span, class: 'tag_list') do
+        safe_join(tags.map { |tag|
+          tag_link(send(url_method, tag.name), tag.name, options.merge(count: tag.count).dup)
+        }, tag_separator)
+      end
+    end
+
   end
 end

data/lib/redmineup/helpers/test_helper.rb

@@ -0,0 +1,12 @@
+module Redmineup
+  module TestHelper
+    module ClassMethods
+      def load_plugin_fixtures(plugin_name, *names)
+        fixtures_dir = File.join(Redmine::Plugin.find(plugin_name).directory, 'test', 'fixtures')
+        ActiveRecord::FixtureSet.create_fixtures(fixtures_dir, names)
+      end
+    end
+  end
+end
+
+ActiveSupport::TestCase.extend Redmineup::TestHelper::ClassMethods

data/lib/redmineup/hooks/views_layouts_hook.rb

@@ -3,10 +3,7 @@
 module Redmineup
   module Hooks
     class ViewsLayoutsHook < Redmine::Hook::ViewListener
-      def view_layouts_base_html_head(_context = {})
-        stylesheet_link_tag(:calendars, plugin: 'redmineup') +
-        stylesheet_link_tag(:money, plugin: 'redmineup')
-      end
+      render_on :view_layouts_base_html_head, partial: 'redmineup/additional_assets'
     end
   end
 end

data/lib/redmineup/liquid/drops/version_drop.rb

@@ -11,7 +11,6 @@ module Redmineup
                 :sharing,
                 :default_project_version,
                 :start_date,
-                :due_date,
                 :estimated_hours,
                 :spent_hours,
                 :closed?,
@@ -28,7 +27,6 @@ module Redmineup
                 :to_s_with_project,
                 :shared?,
                 :deletable?,
-                :default_project_version,
                 :to_s,
                 to: :@version
 

data/lib/redmineup/money_helper.rb

@@ -8,11 +8,19 @@ module Redmineup
       price_to_currency(obj.try(price_field), obj.currency, options).to_s if obj.respond_to?(:currency)
     end
 
-    def prices_collection_by_currency(prices_collection, options = {})
+    def prices_formatted_collection(prices_collection, options = {})
       return [] if prices_collection.blank? || prices_collection == 0
       prices = prices_collection
       prices.reject!{|k, v| v.to_i == 0} if options[:hide_zeros]
-      prices.collect{|k, v| content_tag(:span, price_to_currency(v, k, :symbol => true), :style => "white-space: nowrap;")}.compact
+      prices.map { |k, v| price_to_currency(v, k, symbol: true) }.compact
+    end
+
+    def prices_collection_by_currency(prices_collection, options = {})
+      formatted_prices = prices_formatted_collection(prices_collection, options)
+
+      formatted_prices.map do |formatted_price|
+        content_tag(:span, formatted_price, :style => "white-space: nowrap;")
+      end
     end
 
     def deal_currency_icon(currency)

data/lib/redmineup/patches/action_cable_base_patch.rb

@@ -0,0 +1,25 @@
+module Redmineup
+  module Patches
+    module ActionCableBasePatch
+      def self.prepended(base)
+        base.extend(ClassMethods)
+        base.delegate :rup_broadcast_to, to: :class
+      end
+
+      module ClassMethods
+        def rup_broadcast_to(*args)
+          # TODO: Remove to 2 args after plugins update
+          if args.length == 3
+            klass, model, message = args
+            ActionCable.rup_server(klass).broadcast(broadcasting_for(model), message)
+          else
+            model, message = args
+            ActionCable.rup_server.broadcast(broadcasting_for(model), message)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActionCable::Channel::Base.prepend(Redmineup::Patches::ActionCableBasePatch)

data/lib/redmineup/patches/action_cable_patch.rb

@@ -0,0 +1,19 @@
+module Redmineup
+  module Patches
+    module ActionCablePatch
+      def self.prepended(base)
+        base.class_eval do
+          module_function def rup_server(klass = 'ActionCable::Connection::RupConnection')
+            @rup_servers ||= {}
+            return @rup_servers[klass] if @rup_servers[klass]
+
+            config = ActionCable::Server::RupConfiguration.new(connection_klass: klass)
+            @rup_servers[klass] = ActionCable::Server::RupServer.new(config: config)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActionCable.prepend(Redmineup::Patches::ActionCablePatch)

data/lib/redmineup/patches/auto_completes_controller_patch.rb

@@ -0,0 +1,17 @@
+module Redmineup
+  module Patches
+    module AutoCompletesControllerPatch
+      DEFAULT_TAGS_LIMIT = 10
+
+      def taggable_tags
+        limit = params.delete(:limit) || DEFAULT_TAGS_LIMIT
+        klass = Object.const_get(params[:taggable_type].camelcase) if params[:taggable_type].present?
+
+        tags = klass && klass.available_tags(params.merge(limit: limit, name_like: params[:q])) || Redmineup::ActsAsTaggable::Tag.limit(limit)
+        render json: tags.map { |tag| { id: tag.name, text: tag.name } }
+      end
+    end
+  end
+end
+
+AutoCompletesController.prepend(Redmineup::Patches::AutoCompletesControllerPatch)

data/lib/redmineup/patches/compatibility/routing_mapper_patch.rb

@@ -2,28 +2,15 @@ module Redmineup
   module Patches
     module Compatibility
       module RoutingMapperPatch
-        def self.included(base)
-          base.send(:include, InstanceMethods)
+        def constraints(options = {}, &block)
+          return super(options, &block) unless options.is_a?(Hash)
 
-          base.class_eval do
-            alias_method :constraints_without_redmineup, :constraints
-            alias_method :constraints, :constraints_with_redmineup
-          end
-        end
-
-        module InstanceMethods
-          def constraints_with_redmineup(options = {}, &block)
-            return constraints_without_redmineup(options, &block) unless options.is_a?(Hash)
-
-            options[:object_type] = /.+/ if options[:object_type] && options[:object_type].is_a?(Regexp)
-            constraints_without_redmineup(options, &block)
-          end
+          options[:object_type] = /.+/ if options[:object_type] && options[:object_type].is_a?(Regexp)
+          super(options, &block)
         end
       end
     end
   end
 end
 
-unless ActionDispatch::Routing::Mapper.included_modules.include?(Redmineup::Patches::Compatibility::RoutingMapperPatch)
-  ActionDispatch::Routing::Mapper.send(:include, Redmineup::Patches::Compatibility::RoutingMapperPatch)
-end
+ActionDispatch::Routing::Mapper.prepend(Redmineup::Patches::Compatibility::RoutingMapperPatch)

data/lib/redmineup/patches/compatibility/sprite_patch.rb

@@ -2,20 +2,12 @@ module Redmineup
   module Patches
     module Compatibility
       module SpritePatch
-        def self.included(base)
-          base.send(:include, InstanceMethods)
-        end
-
-        module InstanceMethods
-          def sprite_icon(icon_name, label = nil, icon_only: false, size: '18', css_class: nil, sprite: "icons", plugin: nil)
-            label
-          end
+        def sprite_icon(icon_name, label = '', icon_only: false, size: '18', css_class: nil, sprite: "icons", plugin: nil, rtl: false)
+          label
         end
       end
     end
   end
 end
 
-unless ActionView::Base.included_modules.include?(Redmineup::Patches::Compatibility::SpritePatch)
-  ActionView::Base.send(:include, Redmineup::Patches::Compatibility::SpritePatch)
-end
+ApplicationHelper.prepend(Redmineup::Patches::Compatibility::SpritePatch)

data/lib/redmineup/patches/compatibility_patch.rb

@@ -1,9 +1,3 @@
-if Redmine::VERSION.to_s < "4" 
-  require 'redmineup/patches/compatibility/application_controller_patch'
-end
-if Redmine::VERSION.to_s < "5" 
-  require 'redmineup/patches/compatibility/user_patch'
-end
 if Redmine::VERSION.to_s < "6"
   require 'redmineup/patches/compatibility/sprite_patch'
 end

data/lib/redmineup/patches/liquid_patch.rb

@@ -2,32 +2,23 @@ module Redmineup
   module Patches
     module LiquidPatch
       module StandardFilters
+        private
 
-        def self.included(base)
-          base.class_eval do
-            
-            private
-    
-            def to_number(obj)
-              case obj
-              when Float
-                BigDecimal(obj.to_s)
-              when Numeric
-                obj
-              when String
-                (obj.strip =~ /^\d+\.\d+$/) ? BigDecimal(obj) : obj.to_i
-              else
-                0
-              end
-            end
+        def to_number(obj)
+          case obj
+          when Float
+            BigDecimal(obj.to_s)
+          when Numeric
+            obj
+          when String
+            (obj.strip =~ /^\d+\.\d+$/) ? BigDecimal(obj) : obj.to_i
+          else
+            0
           end
         end
-
       end
     end
   end
 end
-  
-unless Liquid::StandardFilters.included_modules.include?(Redmineup::Patches::LiquidPatch::StandardFilters)
-  Liquid::StandardFilters.send(:include, Redmineup::Patches::LiquidPatch::StandardFilters)
-end
+
+Liquid::StandardFilters.prepend(Redmineup::Patches::LiquidPatch::StandardFilters)

data/lib/redmineup/version.rb

@@ -1,3 +1,3 @@
 module Redmineup
-  VERSION = '1.0.10'
+  VERSION = '1.1.13'
 end

data/lib/redmineup.rb

@@ -44,6 +44,8 @@ require 'redmineup/liquid/drops/custom_field_enumeration_drop'
 require 'redmineup/helpers/external_assets_helper'
 require 'redmineup/helpers/form_tag_helper'
 require 'redmineup/helpers/calendars_helper'
+require 'redmineup/helpers/datetime_helper'
+require 'redmineup/helpers/test_helper'
 require 'redmineup/assets_manager'
 
 require 'redmineup/patches/liquid_patch'
@@ -54,9 +56,21 @@ module Redmineup
   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' unless defined?(ApplicationRecord)
+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)
   ActiveRecord::Base.send :include, Redmineup::ActsAsList::List
@@ -66,13 +80,25 @@ end
 
 if defined?(Propshaft::Assembly)
   Propshaft::Assembly.prepend(Module.new do
-    def initialize(config)
-      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}"
+    def self.prepended(base)
+      base.class_eval do
+        cattr_accessor :redmineup_patched
+      end
+    end
+
+    def config
+      return super if self.class.redmineup_patched
 
-      config[:redmine_extension_paths] << Redmine::AssetPath.new(base_dir, paths, asset_prefix)
-      super
+      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
@@ -83,47 +109,26 @@ 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)
-
-    requirement = requirement.split('.').collect(&:to_i)
-    requirement <=> current.slice(0, requirement.size)
-  end
+  arg = { version_or_higher: arg } unless arg.is_a?(Hash)
+  arg.assert_valid_keys(:version_or_higher)
 
-  def check_version_format(version)
-    version =~ /^\d+.?\d*.?\d*$/m
+  requirement = arg[:version_or_higher]
+  unless requirement.is_a?(String)
+    raise ArgumentError, ':version_or_higher accepts a version string only'
   end
 
-  arg = { version_or_higher: arg } unless arg.is_a?(Hash)
-  arg.assert_valid_keys(:version, :version_or_higher)
+  current = Gem::Version.new(Redmineup::VERSION)
+  required = Gem::Version.new(requirement)
 
-  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)
+  return true if required <= current
 
-      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/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/filters/additional_filter_test.rb

@@ -15,7 +15,9 @@ module Redmineup
       attachments = [attachment]
       @issue_drop.define_singleton_method(:attachments) { attachments }
       Attachment.stub(:latest_attach, attachment) do
-        assert_equal '<p>description with image <img src="mock_url" title="attach_image" alt="attach_image" loading="lazy" /></p>', @strainer.parse_inline_attachments(text, @issue_drop)
+        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
 
@@ -25,6 +27,8 @@ module Redmineup
       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

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