redmine_crm 0.0.54 → 0.0.57

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c0e9fa1d47785da85bc39db433d55e0ba8df629e
-  data.tar.gz: 2efa0ef9d8a1a0e267ba622b098fcac20c68a378
+SHA256:
+  metadata.gz: 214cac797343372370ee81fb9edd38aba5e67ce9d47ad15276952da329f6f876
+  data.tar.gz: d1b987d030f3c4fcd6c10c6cfdd3cb42c8b7bbd2014ce2ab1653c6adce75f3e7
 SHA512:
-  metadata.gz: f74717a3d2fa3e033a32f3c02b1855d3fa4bad61edfe57c23bf2a2dcc36f26954a1e87b65aa31662455b953ac4cb42e2e3252cd6f49be52edd1b0f6815925388
-  data.tar.gz: 2d242b17ba64c4799e52f07c110b683f3cb61116833384c1bc66571e3a68df9a68f159526de9735234c6b5bba61ebd953351c1a1eed097a1f31d56af5909d6d9
+  metadata.gz: 94df5375a9504037d560bcd3da69c76d1915539056e3da79978c3548d950364afb09e594a6c4ef478e8901aa84ee407c66426d8aecc98f882929a94e43d3ab9e
+  data.tar.gz: 239c0df29c90a226d5ba7c62d5838a60311b3e3a6ac6dc70bcbeb4361f5fa130b0133de2ac1d83527a5850572e37153fa394d9a64eea6301c6946853170b4a08

data/bitbucket-pipelines.yml

@@ -19,26 +19,6 @@ pipelines:
         services:
           - mysql
           - postgres
-    - step:
-        name: Old ruby
-        image: ruby:1.9.3
-        script:
-          - sed -i "s/'rails'/'rails'\n  spec.add_runtime_dependency 'rake', '~> 11.2.0'/g" redmine_crm.gemspec
-          - sed -i "s/'rails'/'rails'\n  spec.add_runtime_dependency 'i18n', '~> 0.9.5'/g" redmine_crm.gemspec
-          - sed -i "s/'rails'/'rails'\n  spec.add_runtime_dependency 'nokogiri', '~> 1.6.8'/g" redmine_crm.gemspec
-          - sed -i "s/'rails'/'rails', '~> 4.2.11'/g" redmine_crm.gemspec
-          - sed -i "s/'sqlite3'/'sqlite3', '~> 1.3.6'/g" redmine_crm.gemspec
-          - sed -i "s/'mysql2'/'mysql2', '~> 0.4.0'/g" redmine_crm.gemspec
-          - sed -i "s/'pg'/'pg', '~> 0.18.0'/g" redmine_crm.gemspec
-          - sed -i "s/^end/  spec.add_development_dependency 'minitest', '~> 5.11.3'\nend/g" redmine_crm.gemspec
-          - sed -i "s/^end/  spec.add_development_dependency 'sprockets', '~> 3.5.2'\nend/g" redmine_crm.gemspec
-          - sed -i "s/^end/  spec.add_development_dependency 'thor', '~> 0.20.3'\nend/g" redmine_crm.gemspec
-          - sed -i "s/'rubyzip'/'rubyzip', '~> 1.3.0'/g" redmine_crm.gemspec
-          - bundle install
-          - bundle exec rake test DB=sqlite
-          - bundle exec rake test DB=mysql
-        services:
-          - mysql
 
 definitions:
   services:

data/config/locales/cs.yml

@@ -0,0 +1,13 @@
+cs:
+  label_redmine_crm_settings: Peníze
+  label_redmine_crm_money: Peníze
+
+  label_redmine_crm_disable_taxes: Znemožnit daně
+  label_redmine_crm_default_tax: Výchozí hodnota daně
+  label_redmine_crm_tax_type: Typ daně
+  label_redmine_crm_tax_type_exclusive: Bez daně
+  label_redmine_crm_tax_type_inclusive: Včetně daně
+  label_redmine_crm_default_currency: Výchozí měna
+  label_redmine_crm_major_currencies: Hlavní měny
+  label_redmine_crm_thousands_delimiter: Oddělovač tisíců
+  label_redmine_crm_decimal_separator: Desetinný oddělovač

data/config/locales/de.yml

@@ -0,0 +1,13 @@
+de:
+  label_redmine_crm_settings: Währungseinstellungen
+  label_redmine_crm_money: Währung
+
+  label_redmine_crm_disable_taxes: Steuern deaktiviert
+  label_redmine_crm_default_tax: Standard Steuersatz
+  label_redmine_crm_tax_type: Steuerart
+  label_redmine_crm_tax_type_exclusive: Steuer ausgeschlossen
+  label_redmine_crm_tax_type_inclusive: Steuer eingeschlossen
+  label_redmine_crm_default_currency: Standard Währung
+  label_redmine_crm_major_currencies: Aktive Währungen
+  label_redmine_crm_thousands_delimiter: Tausendertrennzeichen
+  label_redmine_crm_decimal_separator: Dezimaltrennzeichen

data/doc/CHANGELOG

@@ -1,9 +1,25 @@
 == Redmine CRM gem changelog
 
 Redmine crm gem - general functions for plugins (tags, vote, viewing, currency)
-Copyright (C) 2011-2020 RedmineUP
+Copyright (C) 2011-2022 RedmineUP
 https://www.redmineup.com/
  
+== 2022-02-14 v0.0.57
+
+* Fixed BigDecimal liquid bug for ruby > 2.6 
+
+== 2022-02-14 v0.0.56
+
+* Added rcrm_acts_as_priceable 
+* Added IssueRealtions drops
+
+== 2021-06-08 v0.0.55
+
+* Added Attachment Liquid drop
+* Added section to Checklist Liquid drop
+* Added Czech locale
+* Added German locale
+
 == 2020-08-10 v0.0.54
 
 * Fixed new JQuery select2 bug

data/lib/redmine_crm/acts_as_priceable/rcrm_acts_as_priceable.rb

@@ -0,0 +1,33 @@
+module RedmineCrm
+  module ActsAsPriceable
+    module Base
+      def rcrm_acts_as_priceable(*args)
+        priceable_options = args
+        priceable_options << :price if priceable_options.empty?
+        priceable_methods = ""
+        priceable_options.each do |priceable_attr|
+          priceable_methods << %(
+            def #{priceable_attr.to_s}_to_s
+              object_price(
+                self,
+                :#{priceable_attr},
+                {
+                  :decimal_mark => RedmineCrm::Settings::Money.decimal_separator,
+                  :thousands_separator => RedmineCrm::Settings::Money.thousands_delimiter
+                }
+              ) if self.respond_to?(:#{priceable_attr})
+            end
+          )
+        end
+
+        class_eval <<-EOV
+          include RedmineCrm::MoneyHelper
+
+          #{priceable_methods}
+        EOV
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend RedmineCrm::ActsAsPriceable::Base

data/lib/redmine_crm/acts_as_taggable/rcrm_acts_as_taggable.rb

@@ -90,7 +90,7 @@ module RedmineCrm
         #Return all avalible tags for a project or global
         #Example: Question.available_tags(:project => @project_id )
         def available_tags(options = {})
-          project = options[:project]
+          projects = [[options[:project]], options[:projects]].flatten.compact
           limit = options[:limit].to_i.zero? ? 30 : options[:limit].to_i
           scope = Tag.where({})
           class_name = quote_string_value(base_class.name)
@@ -98,9 +98,9 @@ module RedmineCrm
           join << "JOIN #{Tagging.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id "
           join << "JOIN #{table_name} ON #{table_name}.id = #{Tagging.table_name}.taggable_id
             AND #{Tagging.table_name}.taggable_type = #{class_name} "
-          if attribute_names.include?('project_id') && project
+          if attribute_names.include?('project_id') && projects.any?
             join << "JOIN #{Project.table_name} ON #{Project.table_name}.id = #{table_name}.project_id"
-            scope = scope.where("#{table_name}.project_id = ?", project.id)
+            scope = scope.where("#{table_name}.project_id IN (%s)", projects.map(&:id).join(','))
           end
 
           if options[:name_like]

data/lib/redmine_crm/acts_as_taggable/tag_list.rb

@@ -58,7 +58,7 @@ module RedmineCrm
 
         map do |name|
           name.include?(delimiter) ? "\"#{name}\"" : name
-        end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+        end.join(delimiter[-1] == (' ') ? delimiter : "#{delimiter} ")
       end
 
      private

data/lib/redmine_crm/acts_as_votable/rcrm_acts_as_votable.rb

@@ -58,7 +58,7 @@ module RedmineCrm
 
         end
 
-        if self.parent::VERSION::MAJOR < 4
+        if ::ActiveRecord::VERSION::MAJOR < 4
           create_index votes_name_table, [:votable_id, :votable_type, :vote_ip]
           create_index votes_name_table, [:voter_id, :voter_type, :vote_ip]
         end

data/lib/redmine_crm/acts_as_votable/votable.rb

@@ -233,9 +233,9 @@ module RedmineCrm
         end
         self.record_timestamps = false
         if (::ActiveRecord::VERSION::MAJOR == 3) && (::ActiveRecord::VERSION::MINOR != 0)
-          self.update_attributes(updates, :without_protection => true) if !updates.empty?
+          self.assign_attributes(updates, :without_protection => true) && self.save if !updates.empty?
         else
-          self.update_attributes(updates) if !updates.empty?
+          self.assign_attributes(updates) && self.save if !updates.empty?
         end
       end
 

data/lib/redmine_crm/liquid/drops/attachment_drop.rb

@@ -0,0 +1,49 @@
+module RedmineCrm
+  module Liquid
+    class AttachmentDrop < ::Liquid::Drop
+      delegate :id,
+               :filename,
+               :title,
+               :description,
+               :filesize,
+               :content_type,
+               :digest,
+               :downloads,
+               :created_on,
+               :token,
+               :visible?,
+               :image?,
+               :thumbnailable?,
+               :is_text?,
+               :readable?,
+               to: :@attachment
+
+      delegate :id, :filename, :filesize, :description, to: :@attachment
+
+      def initialize(attachment)
+        @attachment = attachment
+      end
+
+      def url(options = {})
+        Rails.application.routes.url_helpers.download_named_attachment_url(@attachment, { filename: filename,
+                                                                                          host: Setting.host_name,
+                                                                                          protocol: Setting.protocol }.merge(options))
+      end
+
+      def link
+        link_to((@attachment.description.blank? ? @attachment.filename : @attachment.description), url)
+      end
+
+      def author
+        @author ||= UsersDrop.new @attachment.author
+      end
+
+      def read
+        @content ||= if @attachment.is_text? && @attachment.filesize <= Setting.file_max_size_displayed.to_i.kilobyte
+                       File.new(@attachment.diskfile, "rb").read
+                     end
+        @content
+      end
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/issue_relations_drop.rb

@@ -0,0 +1,41 @@
+module RedmineCrm
+  module Liquid
+    class IssueRelationsDrop < ::Liquid::Drop
+      def initialize(relations)
+        @relations = relations
+      end
+
+      def all
+        @all ||= @relations.map { |relation| IssueRelationDrop.new(relation) }
+      end
+
+      def visible
+        @visible ||= @all.select(&:visible?)
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @relations.size
+      end
+    end
+
+    class IssueRelationDrop < ::Liquid::Drop
+      delegate :relation_type, :delay, to: :@relation
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def issue_from
+        @issue_from ||= IssueDrop.new(@relation.issue_from)
+      end
+
+      def issue_to
+        @issue_to ||= IssueDrop.new(@relation.issue_to)
+      end
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/issues_drop.rb

@@ -6,14 +6,15 @@ module RedmineCrm
       end
 
       def before_method(id)
-        issue = @issues.where(:id => id).first || Issue.new
+        issue = @issues.where(id: id).first || Issue.new
         IssueDrop.new issue
       end
 
       def all
-        @all ||= @issues.map do |issue|
-          IssueDrop.new issue
-        end
+        @all ||=
+          @issues.map do |issue|
+            IssueDrop.new issue
+          end
       end
 
       def visible
@@ -49,14 +50,14 @@ module RedmineCrm
                :closed_on,
                :updated_on,
                :created_on,
-               :to => :@issue
+               to: :@issue
 
       def initialize(issue)
         @issue = issue
       end
 
       def link
-        link_to @issue.subject, self.url
+        link_to @issue.subject, url
       end
 
       def url
@@ -96,15 +97,23 @@ module RedmineCrm
       end
 
       def parent
-        @parent ||= IssueDrop.new @issue.parent if @issue.parent 
+        @parent ||= IssueDrop.new @issue.parent if @issue.parent
       end
 
       def project
-        @project ||= ProjectDrop.new @issue.project if @issue.project 
+        @project ||= ProjectDrop.new @issue.project if @issue.project
       end
 
       def subtasks
-        @subtasks ||= IssuesDrop.new @issue.children 
+        @subtasks ||= IssuesDrop.new @issue.children
+      end
+
+      def relations_from
+        @relations_from ||= IssueRelationsDrop.new(@issue.relations_from.select { |r| r.other_issue(@issue) && r.other_issue(@issue).visible? })
+      end
+
+      def relations_to
+        @relations_to ||= IssueRelationsDrop.new(@issue.relations_to.select { |r| r.other_issue(@issue) && r.other_issue(@issue).visible? })
       end
 
       def notes
@@ -126,19 +135,20 @@ module RedmineCrm
       def color
         @issue.respond_to?(:color) && @issue.color
       end
-      
+
       def day_in_state
         @issue.respond_to?(:day_in_state) && @issue.day_in_state
       end
 
       def checklists
-        @issue.respond_to?(:checklists) && @issue.checklists.map{|item| {"id_done" => item.is_done, "subject" => item.subject}}
+        @issue.respond_to?(:checklists) && @issue.checklists.map do |item|
+          { 'id_done' => item.is_done, 'subject' => item.subject, 'is_section' => item.is_section }
+        end
       end
 
       def custom_field_values
         @issue.custom_field_values
-      end      
-
+      end
     end
 
     class JournalsDrop < ::Liquid::Drop
@@ -147,9 +157,10 @@ module RedmineCrm
       end
 
       def all
-        @all ||= @journals.map do |journal|
-          JournalDrop.new journal
-        end
+        @all ||=
+          @journals.map do |journal|
+            JournalDrop.new journal
+          end
       end
 
       def visible
@@ -166,12 +177,7 @@ module RedmineCrm
     end
 
     class JournalDrop < ::Liquid::Drop
-      delegate :id,
-               :notes,
-               :created_on,
-               :private_notes,
-               :to => :@journal, 
-               allow_nil: true
+      delegate :id, :notes, :created_on, :private_notes, to: :@journal, allow_nil: true
 
       def initialize(journal)
         @journal = journal
@@ -182,10 +188,8 @@ module RedmineCrm
       end
 
       def issue
-        @issue ||= IssueDrop.new @journal.issue if @journal.issue 
+        @issue ||= IssueDrop.new @journal.issue if @journal.issue
       end
-
     end
-
   end
 end

data/lib/redmine_crm/patches/liquid_patch.rb

@@ -0,0 +1,33 @@
+module RedmineCrm
+  module Patches
+    module LiquidPatch
+      module StandardFilters
+
+        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
+          end
+        end
+
+      end
+    end
+  end
+end
+  
+unless Liquid::StandardFilters.included_modules.include?(RedmineCrm::Patches::LiquidPatch::StandardFilters)
+  Liquid::StandardFilters.send(:include, RedmineCrm::Patches::LiquidPatch::StandardFilters)
+end

data/lib/redmine_crm/version.rb

@@ -1,3 +1,3 @@
 module RedmineCrm
-  VERSION = '0.0.54'
+  VERSION = '0.0.57'
 end

data/lib/redmine_crm.rb

@@ -19,6 +19,7 @@ require 'redmine_crm/acts_as_votable/vote'
 require 'redmine_crm/acts_as_votable/voter'
 require 'redmine_crm/acts_as_draftable/rcrm_acts_as_draftable'
 require 'redmine_crm/acts_as_draftable/draft'
+require 'redmine_crm/acts_as_priceable/rcrm_acts_as_priceable'
 
 require 'redmine_crm/currency'
 require 'redmine_crm/helpers/tags_helper'
@@ -34,12 +35,15 @@ require 'redmine_crm/liquid/drops/news_drop'
 require 'redmine_crm/liquid/drops/projects_drop'
 require 'redmine_crm/liquid/drops/users_drop'
 require 'redmine_crm/liquid/drops/time_entries_drop'
+require 'redmine_crm/liquid/drops/attachment_drop'
+require 'redmine_crm/liquid/drops/issue_relations_drop'
 
 require 'redmine_crm/helpers/external_assets_helper'
 require 'redmine_crm/helpers/form_tag_helper'
 require 'redmine_crm/assets_manager'
 
 require 'redmine_crm/compatibility/application_controller_patch'
+require 'redmine_crm/patches/liquid_patch' unless BigDecimal.respond_to?(:new)
 
 module RedmineCrm
   GEM_NAME = 'redmine_crm'.freeze
@@ -61,6 +65,7 @@ end
 def requires_redmine_crm(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
@@ -69,7 +74,7 @@ def requires_redmine_crm(arg)
     version =~ /^\d+.?\d*.?\d*$/m
   end
 
-  arg = { :version_or_higher => arg } unless arg.is_a?(Hash)
+  arg = { version_or_higher: arg } unless arg.is_a?(Hash)
   arg.assert_valid_keys(:version, :version_or_higher)
 
   current = RedmineCrm::VERSION.split('.').map { |x| x.to_i }
@@ -77,6 +82,7 @@ def requires_redmine_crm(arg)
     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 redmine_crm gem version #{req} or higher (you're using #{RedmineCrm::VERSION}).\n\033[31m[ERROR]\033[0m Please update with 'bundle update redmine_crm'." if Rails.logger
         abort "\033[31mRedmine requires redmine_crm gem version #{req} or higher (you're using #{RedmineCrm::VERSION}).\nPlease update with 'bundle update redmine_crm'.\033[0m"
@@ -84,7 +90,7 @@ def requires_redmine_crm(arg)
     when :version
       req = [req] if req.is_a?(String)
       if req.is_a?(Array)
-        unless req.detect {|ver| compare_versions(ver, current) == 0}
+        unless req.detect { |ver| compare_versions(ver, current) == 0 }
           abort "\033[31mRedmine requires redmine_crm gem version #{req} (you're using #{RedmineCrm::VERSION}).\nPlease update with 'bundle update redmine_crm'.\033[0m"
         end
       elsif req.is_a?(Range)

data/redmine_crm.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.0.0"
 
   spec.add_runtime_dependency 'rails'
   spec.add_runtime_dependency 'liquid', '< 2.6.4'

data/test/acts_as_taggable/rcrm_acts_as_taggable_test.rb

@@ -3,76 +3,81 @@ require File.dirname(__FILE__) + '/../test_helper'
 class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   def test_available_tags
     assert_equivalent [tags(:feature), tags(:bug), tags(:error), tags(:question)], Issue.available_tags(Project.first)
-    assert_equivalent [tags(:error), tags(:question)], Issue.available_tags(:project => Project.first, :limit => 2)
+    assert_equivalent [tags(:error), tags(:question)], Issue.available_tags(project: Project.first, limit: 2)
   end
 
   def test_find_related_tags_with
-    assert_equivalent [tags(:feature), tags(:bug), tags(:question)], Issue.find_related_tags("error")
+    assert_equivalent [tags(:feature), tags(:bug), tags(:question)], Issue.find_related_tags('error')
     assert_equivalent [tags(:feature), tags(:error), tags(:question)], Issue.find_related_tags(tags(:bug))
-    assert_equivalent [tags(:error), tags(:question)], Issue.find_related_tags(["New feature", "bug"])
+    assert_equivalent [tags(:error), tags(:question)], Issue.find_related_tags(['New feature', 'bug'])
     assert_equivalent [tags(:feature), tags(:bug)], Issue.find_related_tags([tags(:error), tags(:question)])
   end
 
   def test_find_tagged_with_include_and_order
-    assert_equal issues(:third_issue, :first_issue, :second_issue),  Issue.find_tagged_with("question", :order => "issues.description DESC", :include => :user).to_a
+    assert_equal issues(:third_issue, :first_issue, :second_issue),
+                 Issue.find_tagged_with('question', order: 'issues.description DESC', include: :user).to_a
   end
 
   def test_find_related_tags_with_non_existent_tags
-    assert_equal [], Issue.find_related_tags("ABCDEFG")
+    assert_equal [], Issue.find_related_tags('ABCDEFG')
     assert_equal [], Issue.find_related_tags(['HIJKLM'])
   end
 
   def test_find_related_tags_with_nothing
-    assert_equal [], Issue.find_related_tags("")
+    assert_equal [], Issue.find_related_tags('')
     assert_equal [], Issue.find_related_tags([])
   end
 
   def test_find_tagged_with
-    assert_equivalent [issues(:first_issue), issues(:second_issue), issues(:third_issue)], Issue.find_tagged_with('"error"')
+    assert_equivalent [issues(:first_issue), issues(:second_issue), issues(:third_issue)],
+                      Issue.find_tagged_with('"error"')
     assert_equal Issue.find_tagged_with('"error"'), Issue.find_tagged_with(['error'])
     assert_equal Issue.find_tagged_with('"error"'), Issue.find_tagged_with([tags(:error)])
 
-    assert_equivalent [issues(:second_issue),], Issue.find_tagged_with('New feature')
+    assert_equivalent [issues(:second_issue)], Issue.find_tagged_with('New feature')
     assert_equal Issue.find_tagged_with('New feature'), Issue.find_tagged_with(['New feature'])
     assert_equal Issue.find_tagged_with('New feature'), Issue.find_tagged_with([tags(:feature)])
   end
 
   def test_find_tagged_with_nothing
-    assert_equal [], Issue.find_tagged_with("")
+    assert_equal [], Issue.find_tagged_with('')
     assert_equal [], Issue.find_tagged_with([])
   end
 
   def test_find_tagged_with_nonexistant_tags
     assert_equal [], Issue.find_tagged_with('ABCDEFG')
     assert_equal [], Issue.find_tagged_with(['HIJKLM'])
-    assert_equal [], Issue.find_tagged_with([RedmineCrm::ActsAsTaggable::Tag.new(:name => 'unsaved tag')])
+    assert_equal [], Issue.find_tagged_with([RedmineCrm::ActsAsTaggable::Tag.new(name: 'unsaved tag')])
   end
 
   def test_find_tagged_with_match_all
-    assert_equivalent [issues(:second_issue)], Issue.find_tagged_with('error, "bug", "New feature", "question"', :match_all => true)
+    assert_equivalent [issues(:second_issue)],
+                      Issue.find_tagged_with('error, "bug", "New feature", "question"', match_all: true)
   end
 
   def test_find_tagged_with_match_all_and_include
-    assert_equivalent [issues(:first_issue), issues(:second_issue), issues(:third_issue)], Issue.find_tagged_with(['error', 'question'], :match_all => true, :include => :tags)
+    assert_equivalent [issues(:first_issue), issues(:second_issue), issues(:third_issue)],
+                      Issue.find_tagged_with(%w[error question], match_all: true, include: :tags)
   end
 
   def test_find_tagged_with_conditions
-    assert_equal [], Issue.find_tagged_with('"error", bug', :conditions => '1=0')
+    assert_equal [], Issue.find_tagged_with('"error", bug', conditions: '1=0')
   end
 
   def test_find_tagged_with_duplicates_options_hash
-    options = { :conditions => '1=1' }.freeze
-    assert_nothing_raised { Issue.find_tagged_with("error", options) }
+    options = { conditions: '1=1' }.freeze
+    assert_nothing_raised { Issue.find_tagged_with('error', options) }
   end
 
   def test_find_tagged_with_exclusions
-    assert_equivalent [issues(:first_issue), issues(:third_issue)], Issue.find_tagged_with("bug", :exclude => true)
-    assert_equivalent [issues(:first_issue), issues(:third_issue)], Issue.find_tagged_with("'bug', feature", :exclude => true)
+    assert_equivalent [issues(:first_issue), issues(:third_issue)], Issue.find_tagged_with('bug', exclude: true)
+    assert_equivalent [issues(:first_issue), issues(:third_issue)],
+                      Issue.find_tagged_with("'bug', feature", exclude: true)
   end
 
   def test_find_options_for_find_tagged_with_no_tags_returns_empty_hash
-    assert_equal Hash.new, Issue.find_options_for_find_tagged_with("")
-    assert_equal Hash.new, Issue.find_options_for_find_tagged_with([nil])
+    assert_equal({}, Issue.find_options_for_find_tagged_with(''))
+    assert_equal({}, Issue.find_options_for_find_tagged_with([nil]))
   end
 
   def test_find_options_for_find_tagged_with_leaves_arguments_unchanged
@@ -82,10 +87,10 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   end
 
   def test_find_options_for_find_tagged_with_respects_custom_table_name
-    RedmineCrm::ActsAsTaggable::Tagging.table_name = "categorisations"
-    RedmineCrm::ActsAsTaggable::Tag.table_name = "categories"
+    RedmineCrm::ActsAsTaggable::Tagging.table_name = 'categorisations'
+    RedmineCrm::ActsAsTaggable::Tag.table_name = 'categories'
 
-    options = Issue.find_options_for_find_tagged_with("Hello")
+    options = Issue.find_options_for_find_tagged_with('Hello')
 
     assert_no_match(/ taggings /, options[:joins])
     assert_no_match(/ tags /, options[:joins])
@@ -93,156 +98,156 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
     assert_match(/ categorisations /, options[:joins])
     assert_match(/ categories /, options[:joins])
   ensure
-    RedmineCrm::ActsAsTaggable::Tagging.table_name = "taggings"
-    RedmineCrm::ActsAsTaggable::Tag.table_name = "tags"
+    RedmineCrm::ActsAsTaggable::Tagging.table_name = 'taggings'
+    RedmineCrm::ActsAsTaggable::Tag.table_name = 'tags'
   end
 
   def test_include_tags_on_find_tagged_with
     assert_nothing_raised do
-      Issue.find_tagged_with('error', :include => :tags)
-      Issue.find_tagged_with("error", :include => { :taggings => :tag })
+      Issue.find_tagged_with('error', include: :tags)
+      Issue.find_tagged_with('error', include: { taggings: :tag })
     end
   end
 
   def test_basic_tag_counts_on_class
-    assert_tag_counts Issue.tag_counts, :error => 3, :feature => 1, :question => 3, :bug => 1
+    assert_tag_counts Issue.tag_counts, error: 3, feature: 1, question: 3, bug: 1
   end
 
   def test_tag_counts_on_class_with_date_conditions
-    assert_tag_counts Issue.tag_counts(:start_at => Date.new(2015, 1, 1)), :error => 2, :feature => 1, :question => 3, :bug => 1
-    assert_tag_counts Issue.tag_counts(:end_at => Date.new(2014, 12, 31)), :error => 1
-    assert_tag_counts Issue.tag_counts(:start_at => Date.new(2015, 1, 31), :end_at => Date.new(2015, 3, 1)), :question => 1
+    assert_tag_counts Issue.tag_counts(start_at: Date.new(2015, 1, 1)), error: 2, feature: 1, question: 3, bug: 1
+    assert_tag_counts Issue.tag_counts(end_at: Date.new(2014, 12, 31)), error: 1
+    assert_tag_counts Issue.tag_counts(start_at: Date.new(2015, 1, 31), end_at: Date.new(2015, 3, 1)), question: 1
   end
 
   def test_tag_counts_on_class_with_frequencies
-    assert_tag_counts Issue.tag_counts(:at_least => 2), :question => 3, :error => 3
-    assert_tag_counts Issue.tag_counts(:at_most => 2), :bug => 1, :feature => 1
+    assert_tag_counts Issue.tag_counts(at_least: 2), question: 3, error: 3
+    assert_tag_counts Issue.tag_counts(at_most: 2), bug: 1, feature: 1
   end
 
   def test_tag_counts_on_class_with_frequencies_and_conditions
-    assert_tag_counts Issue.tag_counts(:at_least => 2, :conditions => '1=1'), :question => 3, :error => 3
+    assert_tag_counts Issue.tag_counts(at_least: 2, conditions: '1=1'), question: 3, error: 3
   end
 
   def test_tag_counts_duplicates_options_hash
-    options = { :at_least => 2, :conditions => '1=1' }.freeze
+    options = { at_least: 2, conditions: '1=1' }.freeze
     assert_nothing_raised { Issue.tag_counts(options) }
   end
 
   def test_tag_counts_with_limit
-    assert_equal 2, Issue.tag_counts(:limit => 2).to_a.size
-    assert_equal 2, Issue.tag_counts(:at_least => 3, :limit => 2).to_a.size
+    assert_equal 2, Issue.tag_counts(limit: 2).to_a.size
+    assert_equal 2, Issue.tag_counts(at_least: 3, limit: 2).to_a.size
   end
 
   def test_tag_counts_with_limit_and_order
-    assert_equivalent RedmineCrm::ActsAsTaggable::Tag.where(:id => [tags(:error), tags(:question)]), Issue.tag_counts(:order => 'count desc', :limit => 2)
+    assert_equivalent RedmineCrm::ActsAsTaggable::Tag.where(id: [tags(:error), tags(:question)]),
+                      Issue.tag_counts(order: 'count desc', limit: 2)
   end
 
   def test_tag_counts_on_association
-    assert_tag_counts users(:jonathan).issues.tag_counts, :error => 2, :bug => 1, :question => 2, :feature => 1
-    assert_tag_counts users(:sam).issues.tag_counts, :error => 1, :question => 1
+    assert_tag_counts users(:jonathan).issues.tag_counts, error: 2, bug: 1, question: 2, feature: 1
+    assert_tag_counts users(:sam).issues.tag_counts, error: 1, question: 1
   end
 
   def test_tag_counts_on_association_with_options
-    assert_equal [], users(:jonathan).issues.tag_counts(:conditions => '1=0')
-    assert_tag_counts users(:jonathan).issues.tag_counts(:at_most => 2), :bug => 1,
-      :feature => 1, :error => 2, :question => 2
+    assert_equal [], users(:jonathan).issues.tag_counts(conditions: '1=0')
+    assert_tag_counts users(:jonathan).issues.tag_counts(at_most: 2), bug: 1, feature: 1, error: 2, question: 2
   end
 
   def test_tag_counts_on_model_instance
-    assert_tag_counts issues(:third_issue).tag_counts, :error => 3, :question => 3
+    assert_tag_counts issues(:third_issue).tag_counts, error: 3, question: 3
   end
 
   def test_tag_counts_on_model_instance_merges_conditions
-    assert_tag_counts issues(:first_issue).tag_counts(:conditions => "tags.name = 'error'"), :error => 3
+    assert_tag_counts issues(:first_issue).tag_counts(conditions: "tags.name = 'error'"), error: 3
   end
 
   def test_tag_counts_on_model_instance_with_no_tags
-    issue = Issue.create!(:description => "desc")
+    issue = Issue.create!(description: 'desc')
 
     assert_tag_counts issue.tag_counts, {}
   end
 
   def test_tag_counts_should_sanitize_scope_conditions
-    Issue.send :where, { "tags.id = ?" => tags(:error).id } do
-      assert_tag_counts Issue.tag_counts, :error => 3
+    Issue.send :where, { 'tags.id = ?' => tags(:error).id } do
+      assert_tag_counts Issue.tag_counts, error: 3
     end
   end
 
   def test_tag_counts_respects_custom_table_names
-    RedmineCrm::ActsAsTaggable::Tagging.table_name = "categorisations"
-    RedmineCrm::ActsAsTaggable::Tag.table_name = "categories"
+    RedmineCrm::ActsAsTaggable::Tagging.table_name = 'categorisations'
+    RedmineCrm::ActsAsTaggable::Tag.table_name = 'categories'
 
-    options = Issue.find_options_for_tag_counts(:start_at => 2.weeks.ago, :end_at => Date.today)
+    options = Issue.find_options_for_tag_counts(start_at: 2.weeks.ago, end_at: Date.today)
     sql = options.values.join(' ')
 
-    assert_no_match %r{taggings}, sql
-    assert_no_match %r{tags}, sql
+    assert_no_match(/taggings/, sql)
+    assert_no_match(/tags/, sql)
 
-    assert_match /categorisations/, sql
-    assert_match /categories/, sql
+    assert_match(/categorisations/, sql)
+    assert_match(/categories/, sql)
   ensure
-    RedmineCrm::ActsAsTaggable::Tagging.table_name = "taggings"
-    RedmineCrm::ActsAsTaggable::Tag.table_name = "tags"
+    RedmineCrm::ActsAsTaggable::Tagging.table_name = 'taggings'
+    RedmineCrm::ActsAsTaggable::Tag.table_name = 'tags'
   end
 
   def test_tag_list_reader
-    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
-    assert_equivalent ["error", "New feature", "bug", "question"], issues(:second_issue).tag_list
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
+    assert_equivalent ['error', 'New feature', 'bug', 'question'], issues(:second_issue).tag_list
   end
 
   def test_reassign_tag_list
-    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
     issues(:first_issue).taggings.reload
 
     # Only an update of the issues table should be executed, the other two queries are for savepoints
     # assert_queries 3 do
-    #   issues(:first_issue).update_attributes!(:description => "new name", :tag_list => issues(:first_issue).tag_list.to_s)
+    #   issues(:first_issue).update!(:description => "new name", :tag_list => issues(:first_issue).tag_list.to_s)
     # end
 
-    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
   end
 
   def test_new_tags
-    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
-    issues(:first_issue).update_attributes!(:tag_list => "#{issues(:first_issue).tag_list}, One, Two")
-    assert_equivalent ["error", "question", "One", "Two"], issues(:first_issue).tag_list
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
+    issues(:first_issue).update!(tag_list: "#{issues(:first_issue).tag_list}, One, Two")
+    assert_equivalent %w[error question One Two], issues(:first_issue).tag_list
   end
 
   def test_remove_tag
-    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
-    issues(:first_issue).update_attributes!(:tag_list => "error")
-    assert_equivalent ["error"], issues(:first_issue).tag_list
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
+    issues(:first_issue).update!(tag_list: 'error')
+    assert_equivalent ['error'], issues(:first_issue).tag_list
   end
 
   def test_remove_and_add_tag
-    assert_equivalent ["error", "question"], issues(:first_issue).tag_list
-    issues(:first_issue).update_attributes!(:tag_list => "question, Beautiful")
-    assert_equivalent ["question", "Beautiful"], issues(:first_issue).tag_list
+    assert_equivalent %w[error question], issues(:first_issue).tag_list
+    issues(:first_issue).update!(tag_list: 'question, Beautiful')
+    assert_equivalent %w[question Beautiful], issues(:first_issue).tag_list
   end
 
   def test_tags_not_saved_if_validation_fails
     issue = issues(:first_issue)
-    assert_equivalent ["error", "question"], issue.tag_list
+    assert_equivalent %w[error question], issue.tag_list
 
     issue.stub(:valid?, false) do
-      assert !issue.update_attributes(tag_list: "One, Two")
+      assert !issue.update(tag_list: 'One, Two')
     end
-    assert_equivalent ["error", "question"], Issue.find(issue.id).tag_list
+    assert_equivalent %w[error question], Issue.find(issue.id).tag_list
   end
 
   def test_tag_list_accessors_on_new_record
-    p = Issue.new(:description => 'Test')
+    p = Issue.new(description: 'Test')
 
     assert p.tag_list.blank?
-    p.tag_list = "One, Two"
-    assert_equal "One, Two", p.tag_list.to_s
+    p.tag_list = 'One, Two'
+    assert_equal 'One, Two', p.tag_list.to_s
   end
 
   def test_clear_tag_list_with_nil
     p = issues(:second_issue)
 
     assert !p.tag_list.blank?
-    assert p.update_attributes(:tag_list => nil)
+    assert p.update(tag_list: nil)
     assert p.tag_list.blank?
 
     assert p.reload.tag_list.blank?
@@ -252,7 +257,7 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
     p = issues(:second_issue)
 
     assert !p.tag_list.blank?
-    assert p.update_attributes(:tag_list => '  ')
+    assert p.update(tag_list: '  ')
     assert p.tag_list.blank?
 
     assert p.reload.tag_list.blank?
@@ -267,7 +272,7 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   end
 
   def test_instance_tag_counts
-    assert_tag_counts issues(:first_issue).tag_counts, :error => 3, :question => 3
+    assert_tag_counts issues(:first_issue).tag_counts, error: 3, question: 3
   end
 
   def test_tag_list_populated_when_cache_nil
@@ -279,8 +284,8 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   def test_cached_tag_list_updated
     assert_nil issues(:first_issue).cached_tag_list
     issues(:first_issue).save!
-    assert_equivalent ["question", "error"], RedmineCrm::ActsAsTaggable::TagList.from(issues(:first_issue).cached_tag_list)
-    issues(:first_issue).update_attributes!(:tag_list => "None")
+    assert_equivalent %w[question error], RedmineCrm::ActsAsTaggable::TagList.from(issues(:first_issue).cached_tag_list)
+    issues(:first_issue).update!(tag_list: 'None')
 
     assert_equal 'None', issues(:first_issue).cached_tag_list
     assert_equal 'None', issues(:first_issue).reload.cached_tag_list
@@ -290,8 +295,8 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
     # Generate the cached tag list
     issues(:first_issue).save!
 
-    issues(:first_issue).update_attributes!(:tag_list => "")
-    assert_equal "", issues(:first_issue).cached_tag_list
+    issues(:first_issue).update!(tag_list: '')
+    assert_equal '', issues(:first_issue).cached_tag_list
   end
 
   def test_find_tagged_with_using_sti
@@ -300,19 +305,19 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   end
 
   def test_case_insensitivity
-    assert_difference "RedmineCrm::ActsAsTaggable::Tag.count", 1 do
-      Issue.create!(:description => "Test", :tag_list => "one")
-      Issue.create!(:description => "Test", :tag_list => "One")
+    assert_difference 'RedmineCrm::ActsAsTaggable::Tag.count', 1 do
+      Issue.create!(description: 'Test', tag_list: 'one')
+      Issue.create!(description: 'Test', tag_list: 'One')
     end
-    assert_equal Issue.find_tagged_with("question"), Issue.find_tagged_with("question")
+    assert_equal Issue.find_tagged_with('question'), Issue.find_tagged_with('question')
   end
 
   def test_tag_not_destroyed_when_unused
-    issues(:first_issue).tag_list.add("Random")
+    issues(:first_issue).tag_list.add('Random')
     issues(:first_issue).save!
 
     assert_no_difference 'RedmineCrm::ActsAsTaggable::Tag.count' do
-      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).tag_list.remove('Random')
       issues(:first_issue).save!
     end
   end
@@ -320,11 +325,11 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
   def test_tag_destroyed_when_unused
     RedmineCrm::ActsAsTaggable::Tag.destroy_unused = true
 
-    issues(:first_issue).tag_list.add("Random")
+    issues(:first_issue).tag_list.add('Random')
     issues(:first_issue).save!
 
     assert_difference 'RedmineCrm::ActsAsTaggable::Tag.count', -1 do
-      issues(:first_issue).tag_list.remove("Random")
+      issues(:first_issue).tag_list.remove('Random')
       issues(:first_issue).save!
     end
   ensure
@@ -340,6 +345,6 @@ class RcrmActsAsTaggableTest < ActiveSupport::TestCase
     issues(:first_issue).tag_list.remove('error')
     issues(:first_issue).tag_list.add('new')
     issues(:first_issue).save!
-    assert_equal %w(question new), issues(:first_issue).reload.all_tags_list
+    assert_equal %w[question new], issues(:first_issue).reload.all_tags_list
   end
 end

data/test/liquid/drops/issue_relations_drop_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../liquid_helper'
+include LiquidHelperMethods
+
+module RedmineCrm
+  class IssueRelationsDropTest < ActiveSupport::TestCase
+    def setup
+      @issue_from = Issue.find_by(subject: 'Issue 3 subject')
+      @issue_to = Issue.find_by(subject: 'Issue 4 subject')
+      @relation = IssueRelation.create!(issue_from: @issue_from, issue_to: @issue_to, relation_type: 'precedes', delay: 1)
+      @liquid_render = LiquidRender.new(
+        'issue' => Liquid::IssueDrop.new(@issue_from)
+      )
+    end
+
+    def test_relation_from_render
+      issues_text = @liquid_render.render('{% for relation in issue.relations_from %} {{relation.issue_from.id}}|{{relation.issue_to.id}}|{{relation.relation_type}}|{{relation.delay}} {% endfor %}')
+      assert_match "#{@issue_from.id}|#{@issue_to.id}|precedes|#{@relation.delay}", issues_text
+    end
+
+    def test_relation_size
+      assert_equal '1', @liquid_render.render('{{ issue.relations_from.size }}')
+    end
+  end
+end

data/test/liquid/filters/base_filter_test.rb

@@ -52,6 +52,10 @@ module RedmineCrm
       assert_equal '25', @liquid_render.render("{{24.11 | ceil }}")
     end
 
+    def test_big_decimal_filter_patch
+      assert_equal '2.8571', @liquid_render.render("{{ 20 | divided_by: 7.0 | round: 4 }}")
+    end
+
     def test_floor_filter
       assert_equal '24', @liquid_render.render("{{24.99 | floor }}")
     end

data/test/models/issue.rb

@@ -6,9 +6,16 @@ class Issue < ActiveRecord::Base
   belongs_to :user
   belongs_to :author, class_name: 'User'
 
+  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
+
   rcrm_acts_as_draftable
   rcrm_acts_as_taggable
   rcrm_acts_as_viewed
 
   scope :visible, lambda { where('1=1') }
+
+  def visible?
+    true
+  end
 end

data/test/models/issue_relation.rb

@@ -0,0 +1,10 @@
+require_relative 'issue'
+
+class IssueRelation < ActiveRecord::Base
+  belongs_to :issue_from, :class_name => 'Issue'
+  belongs_to :issue_to, :class_name => 'Issue'
+
+  def other_issue(issue)
+    (self.issue_from_id == issue.id) ? issue_to : issue_from
+  end
+end

data/test/schema.rb

@@ -21,12 +21,18 @@ ActiveRecord::Schema.define version: 0 do
     t.column "created_at", :datetime
   end
 
-
   create_table "users", :force => true do |t|
     t.column "name", :string
     t.column "language", :string
   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
+  end
+
   create_table "issues", :force => true do |t|
     t.integer  "project_id"
     t.column "subject", :string

data/test/tags_helper_test.rb

@@ -3,10 +3,10 @@ require File.dirname(__FILE__) + '/test_helper'
 # module RedmineCrm
   class TagsHelperTest < ActiveSupport::TestCase
     include RedmineCrm::TagsHelper
-    
+
     def test_tag_cloud
       cloud_elements = []
-      
+
       tag_cloud Issue.tag_counts, %w(css1 css2 css3 css4) do |tag, css_class|
         cloud_elements << [tag, css_class]
       end
@@ -16,7 +16,7 @@ require File.dirname(__FILE__) + '/test_helper'
       assert cloud_elements.include?([tags(:feature), "css2"])
       assert_equal 4, cloud_elements.size
     end
-    
+
     # def test_tag_cloud_when_no_tags
     #   cloud_elements = []
     #   tag_cloud SpecialIssue.tag_counts, %w(css1) do |tag, css_class|
@@ -26,4 +26,4 @@ require File.dirname(__FILE__) + '/test_helper'
     #   assert_equal 0, cloud_elements.size
     # end
   end
-# end
+# end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redmine_crm
 version: !ruby/object:Gem::Version
-  version: 0.0.54
+  version: 0.0.57
 platform: ruby
 authors:
 - RedmineUP
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-10 00:00:00.000000000 Z
+date: 2022-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -111,6 +111,8 @@ files:
 - app/views/redmine_crm/settings.html.erb
 - bitbucket-pipelines.yml
 - config/currency_iso.json
+- config/locales/cs.yml
+- config/locales/de.yml
 - config/locales/en.yml
 - config/locales/ru.yml
 - config/routes.rb
@@ -120,6 +122,7 @@ files:
 - lib/redmine_crm/acts_as_draftable/draft.rb
 - lib/redmine_crm/acts_as_draftable/rcrm_acts_as_draftable.rb
 - lib/redmine_crm/acts_as_list/list.rb
+- lib/redmine_crm/acts_as_priceable/rcrm_acts_as_priceable.rb
 - lib/redmine_crm/acts_as_taggable/rcrm_acts_as_taggable.rb
 - lib/redmine_crm/acts_as_taggable/tag.rb
 - lib/redmine_crm/acts_as_taggable/tag_list.rb
@@ -143,6 +146,8 @@ files:
 - lib/redmine_crm/helpers/tags_helper.rb
 - lib/redmine_crm/helpers/vote_helper.rb
 - lib/redmine_crm/hooks/views_layouts_hook.rb
+- lib/redmine_crm/liquid/drops/attachment_drop.rb
+- lib/redmine_crm/liquid/drops/issue_relations_drop.rb
 - lib/redmine_crm/liquid/drops/issues_drop.rb
 - lib/redmine_crm/liquid/drops/news_drop.rb
 - lib/redmine_crm/liquid/drops/projects_drop.rb
@@ -152,6 +157,7 @@ files:
 - lib/redmine_crm/liquid/filters/base.rb
 - lib/redmine_crm/liquid/filters/colors.rb
 - lib/redmine_crm/money_helper.rb
+- lib/redmine_crm/patches/liquid_patch.rb
 - lib/redmine_crm/settings.rb
 - lib/redmine_crm/settings/money.rb
 - lib/redmine_crm/version.rb
@@ -178,6 +184,7 @@ files:
 - test/fixtures/votable_caches.yml
 - test/fixtures/votables.yml
 - test/fixtures/voters.yml
+- test/liquid/drops/issue_relations_drop_test.rb
 - test/liquid/drops/issues_drop_test.rb
 - test/liquid/drops/news_drop_test.rb
 - test/liquid/drops/projects_drop_test.rb
@@ -187,6 +194,7 @@ files:
 - test/liquid/filters/colors_filter_test.rb
 - test/liquid/liquid_helper.rb
 - test/models/issue.rb
+- test/models/issue_relation.rb
 - test/models/news.rb
 - test/models/project.rb
 - test/models/user.rb
@@ -215,15 +223,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Common libraries for RedmineUP plugins for Redmine
@@ -250,6 +257,7 @@ test_files:
 - test/fixtures/votable_caches.yml
 - test/fixtures/votables.yml
 - test/fixtures/voters.yml
+- test/liquid/drops/issue_relations_drop_test.rb
 - test/liquid/drops/issues_drop_test.rb
 - test/liquid/drops/news_drop_test.rb
 - test/liquid/drops/projects_drop_test.rb
@@ -259,6 +267,7 @@ test_files:
 - test/liquid/filters/colors_filter_test.rb
 - test/liquid/liquid_helper.rb
 - test/models/issue.rb
+- test/models/issue_relation.rb
 - test/models/news.rb
 - test/models/project.rb
 - test/models/user.rb