redmineup 1.1.3 → 1.1.5

data/doc/active-record-mixins.md

@@ -0,0 +1,156 @@
+# ActiveRecord mixins
+
+This page documents the model mixins provided by `redmineup`.
+
+## `up_acts_as_taggable`
+
+Adds polymorphic tagging support.
+
+### Migration
+
+```ruby
+class CreateTags < ActiveRecord::Migration[6.1]
+  def change
+    ActiveRecord::Base.create_taggable_table
+  end
+end
+```
+
+Useful migration helpers:
+
+- `ActiveRecord::Base.create_taggable_table`
+- `ActiveRecord::Base.drop_taggable_table`
+- `ActiveRecord::Base.add_tags_column(:tags, name: :color, type: :integer, default: nil)`
+- `ActiveRecord::Base.remove_tags_columns(:tags, :color)`
+
+### Model
+
+```ruby
+class Product < ApplicationRecord
+  up_acts_as_taggable
+end
+```
+
+### Runtime API
+
+- `record.tag_list` / `record.tag_list = 'a, b'`
+- `record.save_tags` (called via callbacks)
+- `Model.available_tags(project: @project, limit: 30)`
+- `Model.tagged_with(['tag1', 'tag2'])`
+- `Model.find_related_tags('tag1')`
+
+## `up_acts_as_draftable`
+
+Adds draft save/restore workflow for unsaved or changed records.
+
+### Migration
+
+```ruby
+class CreateDrafts < ActiveRecord::Migration[6.1]
+  def change
+    ActiveRecord::Base.create_drafts_table
+  end
+end
+```
+
+Helpers:
+
+- `ActiveRecord::Base.create_drafts_table`
+- `ActiveRecord::Base.drop_drafts_table`
+
+### Model
+
+```ruby
+class WikiPage < ApplicationRecord
+  up_acts_as_draftable parent: :wiki
+end
+```
+
+### Runtime API
+
+- `record.save_draft`
+- `record.update_draft(attrs)`
+- `Model.drafts(User.current)`
+- `Model.from_draft(draft_or_id)`
+
+## `up_acts_as_viewed`
+
+Tracks unique views by user (or IP) and total views.
+
+### Migration
+
+```ruby
+class CreateViewings < ActiveRecord::Migration[6.1]
+  def change
+    ActiveRecord::Base.create_viewings_table
+  end
+end
+```
+
+Optional helpers for models with embedded counters:
+
+- `ActiveRecord::Base.generate_viewings_columns(table)`
+- `Model.add_viewings_columns`
+- `Model.remove_viewings_columns`
+- `ActiveRecord::Base.drop_viewings_table`
+
+### Model
+
+```ruby
+class Question < ApplicationRecord
+  up_acts_as_viewed
+end
+```
+
+### Runtime API
+
+- `record.view(request.remote_ip, User.current)`
+- `record.viewed?`
+- `record.view_count`
+- `record.viewed_by?(request.remote_ip, User.current)`
+
+## `up_acts_as_votable` and `up_acts_as_voter`
+
+Adds voting capabilities for content and users.
+
+### Migration
+
+```ruby
+class CreateVotes < ActiveRecord::Migration[6.1]
+  def change
+    ActiveRecord::Base.create_votable_table
+  end
+end
+```
+
+Helpers:
+
+- `ActiveRecord::Base.create_votable_table`
+- `ActiveRecord::Base.drop_votable_table`
+
+### Models
+
+```ruby
+class Question < ApplicationRecord
+  up_acts_as_votable
+end
+
+class User < ApplicationRecord
+  up_acts_as_voter
+end
+```
+
+## `up_acts_as_priceable`
+
+Generates currency-aware `*_to_s` methods for price fields.
+
+### Model
+
+```ruby
+class Deal < ApplicationRecord
+  up_acts_as_priceable :amount, :tax_amount, :subtotal, :total
+end
+```
+
+This creates methods like `amount_to_s`, `tax_amount_to_s`, etc., backed by
+`Redmineup::MoneyHelper#object_price`.

data/doc/assets-money-and-utilities.md

@@ -0,0 +1,71 @@
+# Assets, money, and shared utilities
+
+## Asset helpers
+
+Provided by `Redmineup::ExternalAssetsHelper`:
+
+- `redmineup_assets`
+- `select2_assets` (alias for `redmineup_assets`)
+- `chartjs_assets`
+
+`redmineup_assets` includes:
+
+- `consumer.js`
+- `select2.js`
+- `select2_helpers.js`
+- `redmineup.css`
+
+The gem also hooks `view_layouts_base_html_head` and renders
+`redmineup/_additional_assets`, so shared assets can be included globally.
+Helpers are idempotent and safe to call from plugin views.
+
+## Money and currency
+
+### Settings API
+
+`Redmineup::Settings::Money` provides access to plugin-level money settings:
+
+- `default_currency`
+- `major_currencies`
+- `default_tax`
+- `tax_type`, `tax_exclusive?`
+- `thousands_delimiter`
+- `decimal_separator`
+- `disable_taxes?`
+
+### Formatting helpers
+
+`Redmineup::MoneyHelper` provides:
+
+- `price_to_currency(price, currency, options = {})`
+- `object_price(record, :price)`
+- `prices_collection_by_currency(hash, hide_zeros: true)`
+- `collection_for_currencies_select`
+- `all_currencies`
+
+`up_acts_as_priceable` uses these helpers to generate `*_to_s` methods on
+models.
+
+### Admin UI
+
+`Redmineup::Currency.add_admin_money_menu` registers a Redmine admin menu item
+that points to:
+
+- `redmineup_settings_path(:money)`
+
+## Misc shared helpers and patches
+
+- `Redmineup::CalendarsHelper#calendar_day_css_classes`
+- Liquid patch for numeric conversion in `Liquid::StandardFilters`
+- Liquid filters/drops under `lib/redmineup/liquid/**`
+- Compatibility and ActionCable patches loaded at gem boot
+
+## Version requirements in plugins
+
+Plugins typically guard compatibility in `init.rb`:
+
+```ruby
+requires_redmineup version_or_higher: '1.1.5'
+```
+
+Use this to fail fast when a plugin depends on newer helper or API behavior.

data/doc/tagging-and-select2.md

@@ -0,0 +1,108 @@
+# Tagging and Select2 helpers
+
+This page covers view helpers used by RedmineUP plugins for tag rendering,
+tag editing, and select2-backed filters.
+
+## Tag rendering helpers
+
+Provided by `Redmineup::TagsHelper`:
+
+- `tag_link(url, tag_name, options = {})`
+- `tag_links(tag_list, options = {}) { |tag| url }`
+- `tag_cloud(tags, classes) { |tag, css_class| ... }`
+- `tag_cloud_links(tags, key, options = {})`
+- `tag_separator`
+
+### Recommended pattern
+
+Define `*_tag_url` per plugin context:
+
+```ruby
+def contact_tag_url(tag_name, options = {})
+  {
+    controller: 'contacts',
+    action: 'index',
+    set_filter: 1,
+    fields: [:tags],
+    values: { tags: [tag_name] },
+    operators: { tags: '=' }
+  }.merge(options)
+end
+```
+
+Then render the cloud via convention:
+
+```erb
+<%= tag_cloud_links(Contact.available_tags(project: @project), :contact) %>
+```
+
+`tag_cloud_links(tags, :contact)` expects `contact_tag_url(name)` to be defined
+in the current view context.
+
+## Tag editors with Select2
+
+Provided by `Redmineup::FormTagHelper`:
+
+- `select2_tag(name, option_tags = nil, options = {})`
+- `select2(...)` (alias)
+- `tag_list_field_tag(name, value = [], options = {})`
+- `transform_to_select2(type, options = {})`
+
+`ActionView::Helpers::FormBuilder` is extended with:
+
+- `f.tag_list_field(:tag_list, **options)`
+
+### Example: form object API
+
+```erb
+<%= f.tag_list_field :tag_list, width: '95%' %>
+```
+
+### Example: standalone field API
+
+```erb
+<%= tag_list_field_tag 'product[tag_list]', @product.tag_list, taggable_type: 'Product' %>
+```
+
+### Example: query/filter select2 transform
+
+```erb
+<%= transform_to_select2 'product_tags',
+      url: auto_complete_taggable_tags_path(project_id: @project, taggable_type: 'Product') %>
+```
+
+## Tag autocomplete endpoint
+
+`redmineup` adds a shared route:
+
+- `GET /auto_completes/taggable_tags`
+
+Named route:
+
+- `auto_complete_taggable_tags_path`
+
+Typical params used by plugins:
+
+- `taggable_type`: model class name (`Contact`, `Person`, `Product`, `Issue`, `DriveEntry`)
+- `project_id`: optional project scope
+- `limit`: optional result size limit
+
+Response format:
+
+```json
+[
+  { "id": "important", "text": "important" },
+  { "id": "vip", "text": "vip" }
+]
+```
+
+## Real plugin usage
+
+Patterns above are used by:
+
+- `redmine_contacts` (`contact_tag_url`, `contact_tag_links`, `f.tag_list_field`)
+- `redmine_people` (`people_tag_url`, `tag_cloud_links`, bulk edit tag forms)
+- `redmine_products` (`product_tag_url`, `tag_list_field_tag`, select2 filters)
+- `redmine_questions` (`question_tag_url`, `tag_cloud_links`)
+- `redmine_drive` (`drive_entry_tag_url`, select2 tag filters)
+- `redmineup_tags` (issue tag forms with `tag_list_field_tag`)

data/lib/redmineup/acts_as_taggable/tag.rb

@@ -1,3 +1,5 @@
+require 'digest/md5'
+
 module Redmineup
   module ActsAsTaggable #:nodoc:
     class Tag < ActiveRecord::Base #:nodoc:
@@ -17,6 +19,10 @@ module Redmineup
         where("LOWER(name) LIKE LOWER(?)", name).first || create(:name => name)
       end
 
+      def self.color_from_name(str)
+        "##{Digest::MD5.hexdigest(str.to_s)[0..5]}"
+      end      
+
       def ==(object)
         super || (object.is_a?(Tag) && name == object.name)
       end
@@ -30,11 +36,15 @@ module Redmineup
       end
 
       def color
-        return ('#' + "%06x" % super) unless super.nil?
+        if self.class.column_names.include?('color')
+          db_color = read_attribute(:color)
+          return ('#' + "%06x" % db_color) unless db_color.nil?
+        end
+        self.class.color_from_name(name)
       end
 
       def color=(color)
-        write_attribute(:color, color.from(1).hex) unless color.blank?
+        write_attribute(:color, color.sub(/\A#/, '').hex) unless color.blank?
       end
 
       class << self
@@ -74,7 +84,7 @@ module Redmineup
           having    = 'COUNT(*) > 0'
           having    = [having, at_least, at_most].compact.join(' AND ')
           group_by  = "#{Tag.table_name}.id, #{Tag.table_name}.name"
-          # group_by << " AND #{having}" unless having.blank?
+          group_by << ", #{Tag.table_name}.color" if column_names.include?('color')
 
           select_condition = if self.column_names.include?('color')
             "#{Tag.table_name}.id, #{Tag.table_name}.name, #{Tag.table_name}.color, COUNT(*) AS count"

data/lib/redmineup/acts_as_taggable/up_acts_as_taggable.rb

@@ -52,6 +52,7 @@ module Redmineup
           if !self.connection.table_exists?(tag_name_table)
             self.connection.create_table(tag_name_table) do |t|
               t.column :name, :string
+              t.column :color, :integer
             end
           end
 
@@ -64,6 +65,7 @@ module Redmineup
               # You should make sure that the column created is
               # long enough to store the required class names.
               t.column :taggable_type, :string
+              t.column :color, :integer, default: nil
 
               t.column :created_at, :datetime
             end
@@ -82,16 +84,16 @@ module Redmineup
         #
         # E.g.: ActiveRecord::Base.add_tags_column(:tags, name: :color, type: :string, default: nil)
         def add_tags_column(table_name = :tags, **options)
-          tag_column = options || { name: :color, type: :int, default: nil }
+          tag_column = options
           tag_column.assert_valid_keys(:name, :type, :default)
 
           raise ArgumentError, "Table `#{table_name}' not found" unless self.connection.table_exists?(table_name)
 
           self.table_name = table_name
-          unless self.connection.column_exists?(table_name, tag_column[:name])
-            self.connection.add_column table_name, tag_column[:name], tag_column[:type], default: tag_column[:default]
-            self.reset_column_information
-          end
+          return if connection.column_exists?(table_name, tag_column[:name])
+
+          connection.add_column table_name, tag_column[:name], tag_column[:type], default: tag_column[:default]
+          reset_column_information
         end
 
         # Remove the up_acts_as_taggable specific columns
@@ -147,6 +149,7 @@ module Redmineup
           group_fields = ''
           group_fields << ", #{Tag.table_name}.created_at" if Tag.respond_to?(:created_at)
           group_fields << ", #{Tag.table_name}.updated_at" if Tag.respond_to?(:updated_at)
+          group_fields << ", #{Tag.table_name}.color" if Tag.column_names.include?('color')
 
           if base_class.respond_to?(:visible_condition)
             visible_condition = base_class.visible_condition(User.current)

data/lib/redmineup/engine.rb

@@ -1,4 +1,14 @@
 module Redmineup
-   class Engine < Rails::Engine
-   end
+  class Engine < Rails::Engine
+    config.to_prepare do
+      next unless defined?(::Redmine::Plugin)
+
+      require 'auto_completes_controller'
+
+      require File.expand_path('../redmineup/patches/compatibility_patch', __dir__)
+      require File.expand_path('../redmineup/patches/auto_completes_controller_patch', __dir__)
+
+      require File.expand_path('../redmineup/hooks/views_layouts_hook', __dir__)
+    end
+  end
 end

data/lib/redmineup/helpers/external_assets_helper.rb

@@ -2,12 +2,18 @@ module Redmineup
   module ExternalAssetsHelper
     include ActionView::Helpers::JavaScriptHelper
 
+    def redmineup_assets
+      return if @redmineup_assets_included
+      
+      @redmineup_assets_included = true
+      javascript_include_tag('consumer', plugin: GEM_NAME) +
+        javascript_include_tag('select2', plugin: GEM_NAME) +
+        javascript_include_tag('select2_helpers', plugin: GEM_NAME) +
+        stylesheet_link_tag('redmineup', plugin: GEM_NAME)
+    end
+
     def select2_assets
-      return if @select2_tag_included
-      @select2_tag_included = true
-      javascript_include_tag('select2', plugin: GEM_NAME) +
-        stylesheet_link_tag('select2', plugin: GEM_NAME) +
-        javascript_include_tag('select2_helpers', plugin: GEM_NAME)
+      redmineup_assets
     end
 
     def chartjs_assets

data/lib/redmineup/helpers/form_tag_helper.rb

@@ -49,6 +49,31 @@ module Redmineup
 
     alias select2 select2_tag
 
+    # Renders a select2 tag field for a tag list (standalone, no form object).
+    # Analogous to text_field_tag.
+    #
+    # ==== Example
+    #   tag_list_field_tag 'entry[tag_list]', entry.tag_list,
+    #     url: auto_complete_taggable_tags_path(taggable_type: 'DriveEntry')
+    def tag_list_field_tag(name, value = [], options = {})
+      url = options.delete(:url)
+      taggable_type = options.delete(:taggable_type)
+      width = options.delete(:width)
+      project_id = options.delete(:project_id)
+      placeholder = options.delete(:placeholder)
+      select2_tag(
+        name,
+        options_for_select(value, value),
+        {
+          multiple:    true,
+          width:       width || '95%',
+          url:         url || auto_complete_taggable_tags_path(taggable_type: taggable_type, project_id: project_id),
+          placeholder: placeholder || l(:lable_redmineup_add_tag),
+          tags:        true
+        }.merge(options)
+      )
+    end
+
     # Transforms select filters of +type+ fields into select2
     #
     # ==== Examples
@@ -86,3 +111,20 @@ module Redmineup
 
   end
 end
+
+# Extends Rails FormBuilder with tag_list_field, analogous to f.text_field.
+#
+# ==== Example
+#   <%= f.tag_list_field :tag_list %>
+ActionView::Helpers::FormBuilder.class_eval do
+  def tag_list_field(method, **options)
+    url = options.fetch(:url) {
+      @template.auto_complete_taggable_tags_path(taggable_type: @object.class.name)
+    }
+    @template.tag_list_field_tag(
+      "#{@object_name}[#{method}]",
+      @object.public_send(method),
+      {url: url}.merge(options.except(:url))
+    )
+  end
+end

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/hooks/views_layouts_hook.rb

@@ -3,11 +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') +
-        javascript_include_tag(:consumer, plugin: 'redmineup')
-      end
+      render_on :view_layouts_base_html_head, partial: 'redmineup/additional_assets'
     end
   end
 end

data/lib/redmineup/patches/auto_completes_controller_patch.rb

@@ -0,0 +1,19 @@
+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)) || Redmineup::ActsAsTaggable::Tag.limit(limit)
+        render json: tags.map { |tag| { id: tag.name, text: tag.name } }
+      end
+    end
+  end
+end
+
+unless AutoCompletesController.included_modules.include?(Redmineup::Patches::AutoCompletesControllerPatch)
+  AutoCompletesController.include(Redmineup::Patches::AutoCompletesControllerPatch)
+end

data/lib/redmineup/version.rb

@@ -1,3 +1,3 @@
 module Redmineup
-  VERSION = '1.1.3'
+  VERSION = '1.1.5'
 end

data/lib/redmineup.rb

@@ -106,6 +106,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::TagsHelper
 end
 
 def requires_redmineup(arg)

data/test/acts_as_taggable/tag_test.rb

@@ -34,16 +34,19 @@ class TagTest < ActiveSupport::TestCase
   end
 
   def test_color
-    colors = %w(#aaaaaa #bbbbbb)
-    colorized = [tags(:bug), tags(:feature)]
-    colorized.each do |tag|
-      assert_equal colors.include?(tag.color), true
-    end
+    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
 
-    not_colorized = [tags(:error), tags(:question)]
-    not_colorized.each do |tag|
-      assert_nil tag.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

data/test/tags_helper_view_test.rb

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