redmineup 1.1.17 → 1.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7ef56cb9d7465fe5dab138bb27ff1c61bc0e8ca150e7bbaed7f2251deeb7291
-  data.tar.gz: da0ed59b5e23cc244d63ef70793d6b37a374254f256f2520d39d8a1e8d6df74c
+  metadata.gz: 506b754be350ea6e3591880f2d292171d54d6085f1c02bc16cfa5f42b0913bc1
+  data.tar.gz: 0400ce05a2c86b9f5704333ff05eb11faef0d6377efa81b42c33ca5b9abde33a
 SHA512:
-  metadata.gz: d5499b14f2026f9fab97e79a7effc512ba1c74129d2d255e85ce7d19992cd19b6fe0c2f7fd4d44d30eb6ad2fc241ab7447b9df28446ca9262c6388968bba3d7e
-  data.tar.gz: 2072701fba9e5b4b147e7221058fa1afbc35acaf292c1330a286df888122aefa04817d58a05fb1271963cf97f3ce5339454789e174ab77bf7f02267fa0959858
+  metadata.gz: c1866918b5aed3b47aeb0a5b0eb74f65172ad383171bc82e434bc26346300948303d08a9b2c60932b044d94da6ba5053ee76c49e425c5cbab328b8225ca473fe
+  data.tar.gz: 1f278a0fe544255d064352e25aa1faaca6ac15b42a1167ec82053acf650b7c2d902b9466f8b98fdb5001428b3b53626fcba787db93b0cb399996b3538db703a5

data/Rakefile

@@ -6,6 +6,6 @@ task default: :test
 desc 'Run tests'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.test_files = FileList['test/**/*_test.rb'].exclude('test/redmine/**/*')
   t.verbose = true
 end

data/app/assets/stylesheets/redmineup.css

@@ -260,9 +260,7 @@
   padding: 0 3px;
 }
 .rup-tag-select.select2-container--default .select2-selection--multiple .select2-selection__choice {
-  border: 1px solid rgba(0, 0, 0, 0.2);
-  border-radius: 3px;
-  font-size: 10px;
+  font-size: 0.65rem;
   line-height: 1.3;
   padding: 2px 4px;
 }
@@ -397,27 +395,28 @@ div.tags-cloud { text-align: center; }
   border-radius: 3px;
   padding: 2px 4px;
   display: inline-block;
-  font-size: 0.85em;
+  font-size: 0.65rem;
   line-height: 1.3;
-  margin: 0 0 5px 2px;
-  overflow-wrap: anywhere;
+  margin: 0 2px 2px 0;
+  white-space: nowrap;
   max-width: 100%;
   box-sizing: border-box;
   vertical-align: top;
 }
 
-.tag-label-color { color: white; }
-.tag-label-plain { background-color: #efefef; color: #333; }
+.tag-label-color, .tag-label-color a, .tag-label-color a:link, .tag-label-color a:visited { color: #fff !important; }
+.tag-label-plain { background-color: #efefef; }
+.tag-label-plain, .tag-label-plain a, .tag-label-plain a:link, .tag-label-plain a:visited { color: #333 !important; }
 
 .tag-label a, .tag-label-color a { color: inherit; text-decoration: none; font-weight: normal; }
 .tag-label a:hover, .tag-label a:focus, .tag-label-color a:hover, .tag-label-color a:focus { text-decoration: none; }
 
 .tag-label:hover, .tag-label-color:hover { filter: brightness(0.85); }
-table.list .tag-label, table.list .tag-label-color { margin-bottom: 0; }
 
 .tag-link a { font-weight: normal; }
 
 .tag_list { margin-top: 5px; display: inline-block; }
+td.tags, .tag_list { white-space: normal; }
 
 span.tag-input { display: inline-block; }
 

data/app/assets/stylesheets/select2.css

@@ -217,8 +217,8 @@
   border-width: 0 4px 5px 4px;
 }
 .select2-container--default .select2-selection--multiple {
-  background-color: white;
-  border: 1px solid #ccc;
+  background-color: var(--oc-white, #fff);
+  border: 1px solid var(--oc-gray-4, #ced4da);
   border-radius: 3px;
   cursor: text;
 }

data/app/views/redmineup/journals/_history.html.erb

@@ -0,0 +1,33 @@
+<% new_markup = up_journal_new_markup? %>
+<% Journal.preload_journals_details_custom_fields(journals.to_a) %>
+<div class="journals">
+  <% journals.to_a.each do |journal| %>
+    <div id="change-<%= journal.id %>" class="<%= journal.css_classes %>">
+      <div class="note">
+        <% if new_markup %>
+          <h4 class="journal-header">
+            <span class="journal-info">
+              <%= avatar(journal.user) %>
+              <%= authoring journal.created_on, journal.user, label: :label_updated_time_by %>
+            </span>
+          </h4>
+        <% else %>
+          <h4 class="note-header">
+            <%= avatar(journal.user) %>
+            <%= authoring journal.created_on, journal.user, label: :label_updated_time_by %>
+          </h4>
+        <% end %>
+        <%= content_tag('div', class: ('journal-content' if new_markup)) do %>
+          <% if journal.visible_details.any? %>
+            <%= content_tag('ul', class: new_markup ? 'journal-details' : 'details') do %>
+              <% journal.visible_details.each do |detail| %>
+                <li><%= up_journal_detail(detail, journal) %></li>
+              <% end %>
+            <% end %>
+          <% end %>
+          <%= content_tag('div', textilizable(journal, :notes), class: 'wiki') if show_notes && journal.notes.present? %>
+        <% end %>
+      </div>
+    </div>
+  <% end %>
+</div>

data/doc/CHANGELOG

@@ -4,6 +4,13 @@ Redmine UP gem - general functions for plugins (tags, vote, viewing, currency)
 Copyright (C) 2011-2026 Kirill Bezrukov (RedmineUP)
 https://www.redmineup.com/
 
+== 2026-10-28 v1.1.18
+
+* Added up_acts_as_journalized: change history for any model
+* Added open_only option to Issue available_tags
+* Updated tags: no commas between chips
+* Fixed tags text color and wrapping in tables
+
 == 2026-10-24 v1.1.17
 
 * Fixed gem breaking Redmine 5.0-6.0 on start (Norwegian locale)

data/lib/redmineup/acts_as_journalized/hook.rb

@@ -0,0 +1,16 @@
+module Redmineup
+  module ActsAsJournalized
+    class Hook < Redmine::Hook::Listener
+      def after_plugins_loaded(_context)
+        return unless Gem::Version.new(Redmine::VERSION.to_s) >= Gem::Version.new('5.0')
+
+        require File.expand_path('journal_patch', __dir__)
+        require File.expand_path('journal_event', __dir__)
+        ::Journal.prepend(JournalPatch) unless ::Journal.include?(JournalPatch)
+        Redmineup::ActsAsJournalized.journalized_classes.each do |klass|
+          Redmineup::ActsAsJournalized.register_activity(klass) if klass.up_journalized_options[:activity]
+        end
+      end
+    end
+  end
+end

data/lib/redmineup/acts_as_journalized/journal_event.rb

@@ -0,0 +1,30 @@
+module Redmineup
+  class JournalEvent < ::Journal
+    def self.visible(user = User.current, options = {})
+      visible_for(user, options)
+    end
+
+    def event_title
+      title = up_activity_options[:title]
+      title ? title.call(self) : journalized.to_s
+    end
+
+    def event_url(options = {})
+      up_activity_options[:url].call(self).merge(options)
+    end
+
+    def event_type
+      up_activity_options[:css_type] || "#{journalized_type.underscore.dasherize}-edit"
+    end
+
+    def event_group
+      journalized
+    end
+
+    private
+
+    def up_activity_options
+      journalized.up_journalized_options[:activity]
+    end
+  end
+end

data/lib/redmineup/acts_as_journalized/journal_patch.rb

@@ -0,0 +1,87 @@
+module Redmineup
+  module ActsAsJournalized
+    module JournalPatch
+      def self.prepended(base)
+        base.extend(ClassMethods)
+        base.singleton_class.prepend(IssueOnlyVisible)
+      end
+
+      module IssueOnlyVisible
+        def visible(*)
+          super.where(journalized_type: 'Issue')
+        end
+      end
+
+      module ClassMethods
+        def up_project_ids(options)
+          project = options[:project]
+          return [project.id] unless options.fetch(:with_subprojects, Setting.display_subprojects_issues?)
+
+          project.self_and_descendants.ids
+        end
+
+        def visible_for(user = User.current, options = {})
+          conditions = Redmineup::ActsAsJournalized.journalized_classes.map do |klass|
+            raise ArgumentError, "#{klass.name} must define scope :visible" unless klass.respond_to?(:visible)
+
+            visible = klass.visible(user).reorder(nil)
+            visible = visible.where(klass.table_name => { project_id: up_project_ids(options) }) if options[:project] && klass.column_names.include?('project_id')
+            visible = visible.except(:eager_load).left_outer_joins(*visible.eager_load_values) if visible.eager_load_values.any?
+            sanitize_sql_array(
+              ["#{table_name}.journalized_type = ? AND #{table_name}.journalized_id IN (#{visible.select(klass.arel_table[:id]).to_sql})",
+               klass.base_class.name]
+            )
+          end
+          conditions.empty? ? none : where(conditions.join(' OR '))
+        end
+      end
+
+      def up_journalized?
+        journalized.respond_to?(:up_journalized?)
+      end
+
+      def up_start_blank
+        @attributes_before_change = {}
+        @custom_values_before_change = {}
+      end
+
+      def editable_by?(usr)
+        return super unless up_journalized?
+
+        permission = journalized.up_journalized_options[:edit_notes_permission]
+        return false unless permission && usr&.logged?
+
+        if permission.respond_to?(:call)
+          permission.call(self, usr)
+        else
+          usr.allowed_to?(permission, journalized.project)
+        end
+      end
+
+      def up_update_notes(usr, text)
+        return false unless editable_by?(usr)
+
+        self.notes = text
+        self.updated_by_id = usr.id if has_attribute?(:updated_by_id)
+        save
+      end
+
+      private
+
+      def add_watcher
+        super unless up_journalized?
+      end
+
+      def split_private_notes
+        up_journalized? || super
+      end
+
+      def send_notification
+        return super unless up_journalized?
+
+        notifier = journalized.up_journalized_options[:notify]
+        notifier&.call(self) if notify?
+      end
+    end
+  end
+end

data/lib/redmineup/acts_as_journalized/up_acts_as_journalized.rb

@@ -0,0 +1,118 @@
+module Redmineup
+  module ActsAsJournalized
+    EXCLUDED_ATTRIBUTES = %w(id created_on updated_on created_at updated_at lock_version).freeze
+    OPTION_KEYS = %i[association associations only except journalize_create activity notify edit_notes_permission detail_formatter].freeze
+
+    def self.registry
+      @registry ||= []
+    end
+
+    def self.journalized_classes
+      registry.filter_map(&:safe_constantize)
+    end
+
+    def self.register_activity(klass)
+      return unless defined?(::Redmineup::JournalEvent)
+
+      activity = klass.up_journalized_options[:activity]
+      type = (activity[:type] || "#{klass.name.underscore}_journals").to_s
+      class_name = klass.name
+      ::Redmineup::JournalEvent.acts_as_activity_provider(
+        type: type,
+        author_key: :user_id,
+        scope: -> { ::Redmineup::ActsAsJournalized.activity_scope(class_name.constantize) }
+      )
+    end
+
+    def self.activity_scope(klass)
+      keys = Array(klass.up_journalized_options[:activity][:keys]).map(&:to_s)
+      scope = ::Redmineup::JournalEvent.preload(:user, :journalized).where(journalized_type: klass.base_class.name)
+      notes = "#{::Journal.table_name}.notes <> ''"
+      return scope.where(notes) if keys.empty?
+
+      details = ::JournalDetail.table_name
+      scope.joins("LEFT OUTER JOIN #{details} ON #{details}.journal_id = #{::Journal.table_name}.id")
+           .where("#{notes} OR (#{details}.property = 'attr' AND #{details}.prop_key IN (?))", keys).distinct
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def up_acts_as_journalized(options = {})
+        options.assert_valid_keys(*OPTION_KEYS)
+        if options[:activity] && !options[:activity][:url].respond_to?(:call)
+          raise ArgumentError, 'up_acts_as_journalized: activity needs :url lambda'
+        end
+
+        class_attribute :up_journalized_options, instance_writer: false
+        self.up_journalized_options = options
+
+        has_many options.fetch(:association, :journals), as: :journalized, class_name: 'Journal', dependent: :destroy, inverse_of: :journalized
+        (options[:associations] || {}).each do |association, attributes|
+          attributes.each do |attribute|
+            define_method("#{association}_#{attribute}") { public_send(association)&.public_send(attribute) }
+          end
+        end
+        before_save :up_prepare_journal
+        after_save :up_save_journal
+        include InstanceMethods
+        include NoCustomFields unless method_defined?(:custom_field_values)
+
+        Redmineup::ActsAsJournalized.registry << name unless Redmineup::ActsAsJournalized.registry.include?(name)
+        Redmineup::ActsAsJournalized.register_activity(self) if options[:activity]
+      end
+    end
+
+    module NoCustomFields
+      def custom_field_values
+        []
+      end
+    end
+
+    module InstanceMethods
+      def up_journalized?
+        true
+      end
+
+      def init_journal(user = User.current, notes = '')
+        @current_journal ||= Journal.new(journalized: self, user: user, notes: notes).tap do
+          @tag_list = Redmineup::ActsAsTaggable::TagList.new(*@tag_list) if @tag_list
+        end
+      end
+
+      def current_journal
+        @current_journal
+      end
+
+      def clear_journal
+        @current_journal = nil
+      end
+
+      def journalized_attribute_names
+        options = up_journalized_options
+        names = self.class.column_names - EXCLUDED_ATTRIBUTES - Array(options[:except]).map(&:to_s)
+        names = names.reject { |name| name.end_with?('_count') }
+        names &= Array(options[:only]).map(&:to_s) if options[:only]
+        names << 'tag_list' if respond_to?(:tag_list) && !Array(options[:except]).map(&:to_s).include?('tag_list')
+        names + (options[:associations] || {}).flat_map { |association, attributes| attributes.map { |attribute| "#{association}_#{attribute}" } }
+      end
+
+      private
+
+      def up_prepare_journal
+        current_journal.up_start_blank if current_journal && new_record? && up_journalized_options[:journalize_create]
+      end
+
+      def up_save_journal
+        return unless current_journal
+
+        current_journal.save
+        clear_journal
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include Redmineup::ActsAsJournalized

data/lib/redmineup/acts_as_taggable/up_acts_as_taggable.rb

@@ -156,6 +156,11 @@ module Redmineup
             projects_joined = true
           end
 
+          if options[:open_only] && reflect_on_association(:status)&.klass == IssueStatus
+            scope = scope.joins("JOIN #{IssueStatus.table_name} ON #{IssueStatus.table_name}.id = #{table_name}.status_id").
+              where(IssueStatus.table_name => { is_closed: false })
+          end
+
           if base_class.respond_to?(:visible_condition)
             visible_condition = base_class.visible_condition(User.current)
             if visible_condition.include?('project_id') && !projects_joined

data/lib/redmineup/engine.rb

@@ -9,6 +9,8 @@ module Redmineup
       require File.expand_path('../redmineup/patches/auto_completes_controller_patch', __dir__)
 
       require File.expand_path('../redmineup/hooks/views_layouts_hook', __dir__)
+
+      require File.expand_path('../redmineup/acts_as_journalized/hook', __dir__)
     end
   end
 end

data/lib/redmineup/helpers/journals_helper.rb

@@ -0,0 +1,53 @@
+module Redmineup
+  module JournalsHelper
+    def up_journal_detail(detail, journal, options = {})
+      formatter = journal.journalized.up_journalized_options[:detail_formatter]
+      text = formatter&.call(detail, journal)
+      return text if text
+
+      label, old_value, value = up_journal_detail_values(detail, journal)
+      text =
+        if detail.old_value.blank? && detail.value.present?
+          l(:text_journal_set_to, label: label, value: value)
+        elsif detail.value.blank?
+          l(:text_journal_deleted, label: label, old: old_value)
+        else
+          l(:text_journal_changed, label: label, old: old_value, new: value)
+        end
+      options[:no_html] ? text : text.html_safe
+    end
+
+    def up_render_journal_history(journals, show_notes: true)
+      render partial: 'redmineup/journals/history', locals: { journals: journals, show_notes: show_notes }
+    end
+
+    def up_journal_new_markup?
+      Gem::Version.new(Redmine::VERSION.to_s) >= Gem::Version.new('6.1')
+    end
+
+    private
+
+    def up_journal_detail_values(detail, journal)
+      record = journal.journalized
+      if detail.property == 'cf'
+        field = CustomField.find_by(id: detail.prop_key)
+        return [h(detail.prop_key), h(detail.old_value), h(detail.value)] unless field
+
+        format = ->(v) { v.blank? ? '' : field.format.formatted_value(self, field, v, record, false) }
+        [h(field.name), h(format.call(detail.old_value)), h(format.call(detail.value))]
+      else
+        key = detail.prop_key.to_s
+        name = key.delete_suffix('_id')
+        reflection = record.class.reflect_on_association(name) if name != key
+        format = lambda do |v|
+          next '' if v.blank?
+          next v.to_s unless reflection
+
+          target = reflection.klass.find_by(id: v)
+          target && (!target.respond_to?(:visible?) || target.visible?) ? target.to_s : v.to_s
+        end
+        [h(l("field_#{key}", default: l("field_#{name}", default: name.humanize))), h(format.call(detail.old_value)), h(format.call(detail.value))]
+      end
+    end
+  end
+end

data/lib/redmineup/helpers/tags_helper.rb

@@ -20,7 +20,7 @@ module Redmineup
     end
 
     def tag_separator
-      monochrome? ? ', ' : ' '
+      ' '
     end
 
     def monochrome?

data/lib/redmineup/version.rb

@@ -1,3 +1,3 @@
 module Redmineup
-  VERSION = '1.1.17'
+  VERSION = '1.1.18'
 end

data/lib/redmineup.rb

@@ -20,6 +20,7 @@ require 'redmineup/acts_as_votable/voter'
 require 'redmineup/acts_as_draftable/up_acts_as_draftable'
 require 'redmineup/acts_as_draftable/draft'
 require 'redmineup/acts_as_priceable/up_acts_as_priceable'
+require 'redmineup/acts_as_journalized/up_acts_as_journalized'
 
 require 'redmineup/currency'
 require 'redmineup/helpers/tags_helper'
@@ -42,6 +43,7 @@ require 'redmineup/liquid/drops/version_drop'
 require 'redmineup/liquid/drops/custom_field_enumeration_drop'
 
 require 'redmineup/helpers/external_assets_helper'
+require 'redmineup/helpers/journals_helper'
 require 'redmineup/helpers/form_tag_helper'
 require 'redmineup/helpers/calendars_helper'
 require 'redmineup/helpers/datetime_helper'
@@ -109,6 +111,7 @@ 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::JournalsHelper
   ActionView::Base.send :include, Redmineup::TagsHelper
 end
 

data/test/acts_as_journalized/up_acts_as_journalized_test.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UpActsAsJournalizedTest < ActiveSupport::TestCase
+  def setup
+    @user = User.first || User.create!(login: 'journalist')
+    @thing = JournalizedThing.create!(name: 'one', status: 'new')
+  end
+
+  def test_attribute_change_is_journaled
+    @thing.init_journal(@user, 'why')
+    @thing.update!(status: 'done')
+
+    journal = @thing.journals.last
+    assert_equal 'why', journal.notes
+    assert_equal [%w(status new done)], journal.details.map { |d| [d.prop_key, d.old_value, d.value] }
+  end
+
+  def test_repeated_edits_keep_every_step
+    %w(a b c).each do |status|
+      @thing.init_journal(@user)
+      @thing.update!(status: status)
+    end
+
+    assert_equal 3, @thing.journals.count
+    assert_equal [%w(new a), %w(a b), %w(b c)], @thing.journals.order(:id).map { |j| [j.details.first.old_value, j.details.first.value] }
+  end
+
+  def test_several_changes_make_one_journal
+    @thing.init_journal(@user)
+    @thing.update!(status: 'done', due_date: Date.new(2026, 1, 1))
+
+    assert_equal 1, @thing.journals.count
+    assert_equal %w(due_date status), @thing.journals.first.details.map(&:prop_key).sort
+  end
+
+  def test_notes_only_journal
+    @thing.init_journal(@user, 'just a note')
+    @thing.save!
+
+    assert_equal 1, @thing.journals.count
+    assert_empty @thing.journals.first.details
+  end
+
+  def test_unchanged_save_without_notes_makes_no_journal
+    @thing.init_journal(@user)
+    @thing.save!
+
+    assert_equal 0, @thing.journals.count
+  end
+
+  def test_no_journal_without_init_journal
+    @thing.update!(status: 'done')
+
+    assert_equal 0, @thing.journals.count
+  end
+
+  def test_rollback_leaves_no_journal
+    JournalizedThing.transaction do
+      @thing.init_journal(@user, 'x')
+      @thing.update!(status: 'done')
+      raise ActiveRecord::Rollback
+    end
+
+    assert_equal 0, Journal.where(journalized_type: 'JournalizedThing').count
+  end
+
+  def test_create_is_not_journaled_by_default
+    thing = JournalizedThing.new(name: 'two', status: 'new')
+    thing.init_journal(@user)
+    thing.save!
+
+    assert_equal 0, thing.journals.count
+  end
+
+  def test_excluded_and_counter_attributes_are_not_tracked
+    names = @thing.journalized_attribute_names
+
+    assert_includes names, 'status'
+    assert_not_includes names, 'id'
+    assert_not_includes names, 'updated_on'
+    assert_not_includes names, 'comments_count'
+  end
+
+  def test_destroy_deletes_journals
+    @thing.init_journal(@user, 'x')
+    @thing.update!(status: 'done')
+
+    assert_difference('Journal.count', -1) { @thing.destroy }
+  end
+
+  def test_unknown_option_is_rejected
+    assert_raises(ArgumentError) { Class.new(ActiveRecord::Base) { self.table_name = 'journalized_things'; up_acts_as_journalized foo: 1 } }
+  end
+
+  def test_activity_needs_url
+    assert_raises(ArgumentError) { Class.new(ActiveRecord::Base) { self.table_name = 'journalized_things'; up_acts_as_journalized activity: {} } }
+  end
+
+  def test_custom_field_values_fallback
+    assert_equal [], @thing.custom_field_values
+  end
+
+  def test_registered
+    assert_includes Redmineup::ActsAsJournalized.registry, 'JournalizedThing'
+  end
+end

data/test/models/journal.rb

@@ -1,6 +1,44 @@
+class JournalDetail < ActiveRecord::Base
+  belongs_to :journal
+end
+
 class Journal < ActiveRecord::Base
   belongs_to :journalized, :polymorphic => true
   belongs_to :issue, :foreign_key => :journalized_id
 
   belongs_to :user
+  has_many :details, :class_name => 'JournalDetail', :dependent => :delete_all, :inverse_of => :journal
+
+  attr_accessor :notify
+
+  def initialize(*args)
+    super
+    if journalized
+      journalized.new_record? ? self.notify = false : start
+    end
+  end
+
+  def save(*args)
+    journalize_changes
+    (new_record? && notes.blank? && details.empty?) ? false : super()
+  end
+
+  def start
+    @attributes_before_change = journalized.journalized_attribute_names.index_with { |name| journalized.send(name) }
+    @custom_values_before_change = {}
+    self
+  end
+
+  def journalize_changes
+    if @attributes_before_change
+      (journalized.journalized_attribute_names + @attributes_before_change.keys).uniq.each do |name|
+        before = @attributes_before_change[name]
+        after = journalized.send(name)
+        next if before == after || (before.blank? && after.blank?)
+
+        details << JournalDetail.new(property: 'attr', prop_key: name, old_value: before, value: after)
+      end
+    end
+    start
+  end
 end

data/test/models/journalized_thing.rb

@@ -0,0 +1,5 @@
+class JournalizedThing < ActiveRecord::Base
+  scope :visible, lambda { |*| where('1=1') }
+
+  up_acts_as_journalized except: :updated_on
+end

data/test/redmine/acts_as_journalized/journalized_redmine_test.rb

@@ -0,0 +1,264 @@
+require File.join(Dir.pwd, 'test/test_helper')
+
+ActiveRecord::Base.connection.create_table :up_journalized_records, force: true do |t|
+  t.references :project
+  t.string :name
+  t.date :due_date
+  t.string :status
+  t.integer :comments_count, default: 0
+  t.datetime :created_on
+  t.datetime :updated_on
+end
+Minitest.after_run { ActiveRecord::Base.connection.drop_table :up_journalized_records, if_exists: true }
+
+class UpJournalizedRecordCustomField < CustomField
+  def type_name
+    :label_project_plural
+  end
+end
+
+class UpJournalizedRecord < (defined?(ApplicationRecord) ? ApplicationRecord : ActiveRecord::Base)
+  NOTIFIED = []
+
+  belongs_to :project
+  acts_as_customizable
+
+  scope :visible, lambda { |user = User.current, _options = {}|
+    joins(:project).where(Project.allowed_to_condition(user, :view_issues))
+  }
+
+  def visible?(user = User.current)
+    user.allowed_to?(:view_issues, project)
+  end
+
+  up_acts_as_journalized(
+    notify: ->(journal) { NOTIFIED << journal.id },
+    edit_notes_permission: :edit_issues,
+    activity: { type: 'up_records', url: ->(journal) { { controller: 'welcome' } }, title: ->(journal) { "Record #{journal.journalized.name}" } }
+  )
+end
+
+Redmine::Activity.register :up_records, class_name: 'Redmineup::JournalEvent'
+
+class UpActsAsJournalizedRedmineTest < ActiveSupport::TestCase
+  fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles, :enabled_modules, :trackers,
+           :issue_statuses, :issues, :journals, :journal_details, :enumerations, :custom_fields, :custom_values,
+           :projects_trackers, :watchers, :issue_categories, :versions
+
+  def setup
+    User.current = nil
+    UpJournalizedRecord::NOTIFIED.clear
+    @project = Project.find(1)
+    @user = User.find(2)
+    @field = UpJournalizedRecordCustomField.create!(
+      name: 'Up tags', field_format: 'list', multiple: true, possible_values: %w(a b c), is_for_all: true
+    )
+    @record = UpJournalizedRecord.create!(project: @project, name: 'rec', status: 'new')
+  end
+
+  def test_attribute_and_notes
+    @record.init_journal(@user, 'changed')
+    @record.update!(status: 'done', due_date: Date.new(2026, 1, 2))
+
+    journal = @record.journals.last
+    assert_equal 'changed', journal.notes
+    assert_equal %w(due_date status), journal.details.map(&:prop_key).sort
+    assert_equal 'attr', journal.details.first.property
+  end
+
+  def test_multiple_value_custom_field
+    @record.reload
+    @record.init_journal(@user)
+    @record.custom_field_values = { @field.id.to_s => %w(a b) }
+    @record.save!
+
+    @record.reload
+    @record.init_journal(@user)
+    @record.custom_field_values = { @field.id.to_s => %w(b c) }
+    @record.save!
+
+    details = @record.journals.order(:id).flat_map { |j| j.details.map { |d| [d.property, d.old_value, d.value] } }
+    assert_includes details, ['cf', nil, 'a']
+    assert_includes details, ['cf', nil, 'b']
+    assert_includes details, ['cf', 'a', nil]
+    assert_includes details, ['cf', nil, 'c']
+  end
+
+  def test_notes_only
+    @record.init_journal(@user, 'only note')
+    @record.save!
+
+    assert_equal ['only note'], @record.journals.map(&:notes)
+    assert_empty @record.journals.first.details
+  end
+
+  def test_unchanged_save_without_notes_has_no_journal
+    @record.init_journal(@user)
+    @record.save!
+
+    assert_equal 0, @record.journals.count
+  end
+
+  def test_rollback_leaves_no_journal
+    UpJournalizedRecord.transaction do
+      @record.init_journal(@user, 'x')
+      @record.update!(status: 'done')
+      raise ActiveRecord::Rollback
+    end
+
+    assert_equal 0, Journal.where(journalized_type: 'UpJournalizedRecord').count
+  end
+
+  def test_create_with_journalize_create
+    UpJournalizedRecord.up_journalized_options = UpJournalizedRecord.up_journalized_options.merge(journalize_create: true)
+    record = UpJournalizedRecord.new(project: @project, name: 'new', status: 'open')
+    record.init_journal(@user)
+    record.save!
+
+    keys = record.journals.first.details.map(&:prop_key)
+    assert_includes keys, 'name'
+    assert_includes keys, 'status'
+  ensure
+    UpJournalizedRecord.up_journalized_options = UpJournalizedRecord.up_journalized_options.except(:journalize_create)
+  end
+
+  def test_no_watchers_and_no_issue_mail
+    ActionMailer::Base.deliveries.clear
+    assert_no_difference 'Watcher.count' do
+      @record.init_journal(@user, 'x')
+      @record.update!(status: 'done')
+    end
+    assert_empty ActionMailer::Base.deliveries
+  end
+
+  def test_notify_callback_runs_after_commit
+    @record.init_journal(@user, 'x')
+    @record.update!(status: 'done')
+
+    assert_equal [@record.journals.last.id], UpJournalizedRecord::NOTIFIED
+  end
+
+  def test_notify_callback_skipped_when_journal_notify_is_false
+    @record.init_journal(@user, 'x').notify = false
+    @record.update!(status: 'done')
+
+    assert_empty UpJournalizedRecord::NOTIFIED
+  end
+
+  def test_issue_journals_are_unaffected
+    ActionMailer::Base.deliveries.clear
+    Setting.notified_events = %w(issue_updated)
+    issue = Issue.find(1)
+    issue.init_journal(@user, 'issue note')
+    issue.update!(subject: 'changed subject')
+
+    assert_equal 'issue note', issue.journals.last.notes
+    assert_equal 'subject', issue.journals.last.details.first.prop_key
+    assert_not_empty ActionMailer::Base.deliveries
+  end
+
+  def test_issue_visible_scope_ignores_journals_of_other_types
+    @record.init_journal(@user, 'collision')
+    @record.save!
+    journal = @record.journals.last
+    Journal.where(id: journal.id).update_all(journalized_id: 1)
+
+    assert_not_includes Journal.visible(@user).pluck(:id), journal.id
+    assert_includes Journal.visible(@user).pluck(:id), Journal.where(journalized_type: 'Issue', journalized_id: 1).first.id
+  end
+
+  def test_history_hides_custom_field_details_of_invisible_fields
+    @field.update!(visible: false, role_ids: [])
+    @record.reload
+    @record.init_journal(@user)
+    @record.custom_field_values = { @field.id.to_s => %w(a) }
+    @record.save!
+
+    journal = @record.journals.last
+    assert_equal 1, journal.details.size
+    assert_empty journal.visible_details(User.find(2))
+    assert_equal 1, journal.visible_details(User.find(1)).size
+  end
+
+  def test_visible_for
+    hidden = UpJournalizedRecord.create!(project: Project.find(2), name: 'hidden')
+    [@record, hidden].each do |record|
+      record.init_journal(@user, 'n')
+      record.save!
+    end
+    Project.find(2).update!(is_public: false)
+    Member.where(project_id: 2, user_id: @user.id).delete_all
+
+    ids = Journal.visible_for(@user).pluck(:journalized_id, :journalized_type)
+    assert_includes ids, [@record.id, 'UpJournalizedRecord']
+    assert_not_includes ids, [hidden.id, 'UpJournalizedRecord']
+    assert Journal.visible_for(@user).all? { |j| j.journalized_type == 'UpJournalizedRecord' }
+  end
+
+  def test_activity_event
+    @record.init_journal(@user, 'visible note')
+    @record.save!
+
+    fetcher = Redmine::Activity::Fetcher.new(@user)
+    fetcher.scope = ['up_records']
+    event = fetcher.events(Date.today - 1, Date.today + 1).first
+
+    assert_equal "Record rec", event.event_title
+    assert_equal 'visible note', event.event_description
+    assert_equal @record, event.event_group
+  end
+
+  def test_activity_is_limited_to_project
+    other = UpJournalizedRecord.create!(project: Project.find(2), name: 'other')
+    [@record, other].each do |record|
+      record.init_journal(@user, 'n')
+      record.save!
+    end
+
+    events = Redmineup::JournalEvent.find_events('up_records', User.find(1), nil, nil, project: Project.find(2))
+    assert_equal [other], events.map(&:event_group)
+  end
+
+  def test_activity_only_notes_and_listed_keys
+    @record.init_journal(@user)
+    @record.update!(status: 'quiet')
+    fetcher = Redmine::Activity::Fetcher.new(@user)
+    fetcher.scope = ['up_records']
+    assert_empty fetcher.events(Date.today - 1, Date.today + 1)
+
+    UpJournalizedRecord.up_journalized_options = UpJournalizedRecord.up_journalized_options.merge(activity: UpJournalizedRecord.up_journalized_options[:activity].merge(keys: %w(status)))
+    @record.init_journal(@user)
+    @record.update!(status: 'loud')
+    assert_equal 2, fetcher.events(Date.today - 1, Date.today + 1).size
+  ensure
+    UpJournalizedRecord.up_journalized_options = UpJournalizedRecord.up_journalized_options.merge(activity: UpJournalizedRecord.up_journalized_options[:activity].except(:keys))
+  end
+
+  def test_editable_by_and_update_notes
+    @record.init_journal(@user, 'old')
+    @record.update!(status: 'x')
+    journal = @record.journals.last
+
+    assert journal.editable_by?(User.find(2))
+    assert_not journal.editable_by?(User.anonymous)
+    assert journal.up_update_notes(@user, 'new')
+    assert_equal 'new', journal.reload.notes
+    assert_equal @user.id, journal.updated_by_id if journal.has_attribute?(:updated_by_id)
+  end
+
+  def test_journal_detail_escapes_deleted_custom_field_values
+    detail = JournalDetail.new(property: 'cf', prop_key: '999999', old_value: '<b>old</b>', value: '<script>x</script>')
+    html = ApplicationController.new.view_context.up_journal_detail(detail, @record.journals.build)
+
+    assert_no_match(/<script>|<b>/, html)
+  end
+
+  def test_journal_detail_text
+    @record.init_journal(@user)
+    @record.update!(status: 'done')
+    detail = @record.journals.last.details.first
+
+    view = ApplicationController.new.view_context
+    assert_match(/new/, view.up_journal_detail(detail, @record.journals.last, no_html: true))
+  end
+end

data/test/schema.rb

@@ -34,6 +34,23 @@ ActiveRecord::Schema.define version: 0 do
     t.boolean :private_notes, default: false, null: false
   end
 
+  create_table :journal_details, force: true do |t|
+    t.integer :journal_id, default: 0, null: false
+    t.string :property, limit: 30, default: '', null: false
+    t.string :prop_key, limit: 30, default: '', null: false
+    t.text :old_value
+    t.text :value
+  end
+
+  create_table :journalized_things, force: true do |t|
+    t.string :name
+    t.date :due_date
+    t.string :status
+    t.integer :comments_count, default: 0
+    t.datetime :created_on
+    t.datetime :updated_on
+  end
+
   create_table :tags, force: true do |t|
     t.string :name
     t.string :color

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redmineup
 version: !ruby/object:Gem::Version
-  version: 1.1.17
+  version: 1.1.18
 platform: ruby
 authors:
 - RedmineUP
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-24 00:00:00.000000000 Z
+date: 2026-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -129,6 +129,7 @@ files:
 - app/controllers/redmineup_controller.rb
 - app/views/redmineup/_additional_assets.html.erb
 - app/views/redmineup/_money.html.erb
+- app/views/redmineup/journals/_history.html.erb
 - app/views/redmineup/settings.html.erb
 - config/currency_iso.json
 - config/locales/ar.yml
@@ -194,6 +195,10 @@ files:
 - lib/redmineup.rb
 - lib/redmineup/acts_as_draftable/draft.rb
 - lib/redmineup/acts_as_draftable/up_acts_as_draftable.rb
+- lib/redmineup/acts_as_journalized/hook.rb
+- lib/redmineup/acts_as_journalized/journal_event.rb
+- lib/redmineup/acts_as_journalized/journal_patch.rb
+- lib/redmineup/acts_as_journalized/up_acts_as_journalized.rb
 - lib/redmineup/acts_as_list/list.rb
 - lib/redmineup/acts_as_priceable/up_acts_as_priceable.rb
 - lib/redmineup/acts_as_taggable/tag.rb
@@ -217,6 +222,7 @@ files:
 - lib/redmineup/helpers/datetime_helper.rb
 - lib/redmineup/helpers/external_assets_helper.rb
 - lib/redmineup/helpers/form_tag_helper.rb
+- lib/redmineup/helpers/journals_helper.rb
 - lib/redmineup/helpers/tags_helper.rb
 - lib/redmineup/helpers/test_helper.rb
 - lib/redmineup/helpers/vote_helper.rb
@@ -248,6 +254,7 @@ files:
 - redmineup.gemspec
 - test/acts_as_draftable/draft_test.rb
 - test/acts_as_draftable/rup_acts_as_draftable_test.rb
+- test/acts_as_journalized/up_acts_as_journalized_test.rb
 - test/acts_as_taggable/rup_acts_as_taggable_test.rb
 - test/acts_as_taggable/tag_list_test.rb
 - test/acts_as_taggable/tag_test.rb
@@ -285,11 +292,13 @@ files:
 - test/models/issue.rb
 - test/models/issue_relation.rb
 - test/models/journal.rb
+- test/models/journalized_thing.rb
 - test/models/news.rb
 - test/models/project.rb
 - test/models/user.rb
 - test/models/vote_classes.rb
 - test/money_helper_test.rb
+- test/redmine/acts_as_journalized/journalized_redmine_test.rb
 - test/schema.rb
 - test/tags_helper_test.rb
 - test/tags_helper_view_test.rb
@@ -321,6 +330,7 @@ summary: Common libraries for RedmineUP plugins for Redmine
 test_files:
 - test/acts_as_draftable/draft_test.rb
 - test/acts_as_draftable/rup_acts_as_draftable_test.rb
+- test/acts_as_journalized/up_acts_as_journalized_test.rb
 - test/acts_as_taggable/rup_acts_as_taggable_test.rb
 - test/acts_as_taggable/tag_list_test.rb
 - test/acts_as_taggable/tag_test.rb
@@ -358,11 +368,13 @@ test_files:
 - test/models/issue.rb
 - test/models/issue_relation.rb
 - test/models/journal.rb
+- test/models/journalized_thing.rb
 - test/models/news.rb
 - test/models/project.rb
 - test/models/user.rb
 - test/models/vote_classes.rb
 - test/money_helper_test.rb
+- test/redmine/acts_as_journalized/journalized_redmine_test.rb
 - test/schema.rb
 - test/tags_helper_test.rb
 - test/tags_helper_view_test.rb