redmineup 1.0.2

data/lib/redmineup/money_helper.rb

@@ -0,0 +1,66 @@
+require 'action_view'
+require 'redmineup/settings/money'
+
+module Redmineup
+  module MoneyHelper
+    def object_price(obj, price_field = :price, options = {})
+      options.merge!({:symbol => true})
+      price_to_currency(obj.try(price_field), obj.currency, options).to_s if obj.respond_to?(:currency)
+    end
+
+    def prices_collection_by_currency(prices_collection, options = {})
+      return [] if prices_collection.blank? || prices_collection == 0
+      prices = prices_collection
+      prices.reject!{|k, v| v.to_i == 0} if options[:hide_zeros]
+      prices.collect{|k, v| content_tag(:span, price_to_currency(v, k, :symbol => true), :style => "white-space: nowrap;")}.compact
+    end
+
+    def deal_currency_icon(currency)
+      case currency.to_s.upcase
+      when 'EUR'
+        'icon-money-euro'
+      when 'GBP'
+        'icon-money-pound'
+      when 'JPY'
+        'icon-money-yen'
+      else
+        'icon-money-dollar'
+      end
+    end
+
+    def collection_for_currencies_select(default_currency = Redmineup::Settings::Money.default_currency, major_currencies = Redmineup::Settings::Money.major_currencies)
+      currencies = []
+      currencies << default_currency.to_s unless default_currency.blank?
+      currencies |= major_currencies
+      currencies.map do |c|
+        currency = Redmineup::Currency.find(c)
+        ["#{currency.iso_code} (#{currency.symbol})", currency.iso_code] if currency
+      end.compact.uniq
+    end
+
+    def all_currencies
+      Currency.table.inject([]) do |array, (_, attributes)|
+        array ||= []
+        array << [attributes[:name].to_s + (attributes[:symbol].blank? ? '' : " (#{attributes[:symbol]})"), attributes[:iso_code]]
+        array
+      end.sort{|x, y| x[0] <=> y[0]}
+    end
+
+    def price_to_currency(price, currency = Redmineup::Settings::Money.default_currency, options = {})
+      return '' if price.blank?
+
+      currency = 'USD' unless currency.is_a?(String)
+      default_options = {
+        decimal_mark: Redmineup::Settings::Money.decimal_separator,
+        thousands_separator: Redmineup::Settings::Money.thousands_delimiter
+      }.reject { |_k, v| v.nil? }
+
+      currency = Redmineup::Currency.find(currency)
+      Redmineup::Currency.format(price.to_f, currency, default_options.merge(options))
+    end
+  end
+end
+
+unless ActionView::Base.included_modules.include?(Redmineup::MoneyHelper)
+  ActionView::Base.send(:include, Redmineup::MoneyHelper)
+end

data/lib/redmineup/patches/liquid_patch.rb

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

data/lib/redmineup/settings/money.rb

@@ -0,0 +1,46 @@
+require 'redmineup/settings'
+
+module Redmineup
+  class Settings
+    class Money
+      TAX_TYPE_EXCLUSIVE = 1
+      TAX_TYPE_INCLUSIVE = 2
+
+      class << self
+        def default_currency
+          Redmineup::Settings['default_currency'] || 'USD'
+        end
+
+        def major_currencies
+          currencies = Redmineup::Settings['major_currencies'].to_s.split(',').select { |c| !c.blank? }.map(&:strip)
+          currencies = %w[USD EUR GBP RUB CHF] if currencies.blank?
+          currencies.compact.uniq
+        end
+
+        def default_tax
+          Redmineup::Settings['default_tax'].to_f
+        end
+
+        def tax_type
+          ((['1', '2'] & [Redmineup::Settings['tax_type'].to_s]).first || TAX_TYPE_EXCLUSIVE).to_i
+        end
+
+        def tax_exclusive?
+          tax_type == TAX_TYPE_EXCLUSIVE
+        end
+
+        def thousands_delimiter
+          ([' ', ',', '.'] & [Redmineup::Settings['thousands_delimiter']]).first
+        end
+
+        def decimal_separator
+          ([',', '.'] & [Redmineup::Settings['decimal_separator']]).first
+        end
+
+        def disable_taxes?
+          Redmineup::Settings['disable_taxes'].to_i > 0
+        end
+      end
+    end
+  end
+end

data/lib/redmineup/settings.rb

@@ -0,0 +1,53 @@
+module Redmineup
+  class Settings
+    SECTIONS = {
+      'money' => { id: :money, label: :label_redmineup_money, partial: 'money' }
+    }.freeze
+
+    class << self
+      def initialize_gem_settings
+        return if !Object.const_defined?('Setting') || Setting.respond_to?(:plugin_redmineup)
+
+        if Setting.respond_to?(:define_setting)
+          Setting.send(:define_setting, 'plugin_redmineup', 'default' => default_settings, 'serialized' => true)
+        elsif Setting.respond_to?(:available_settings)
+          Setting.available_settings['plugin_redmineup'] = { 'default' => default_settings, 'serialized' => true }
+          Setting.class.send(:define_method, 'plugin_redmineup', -> { Setting['plugin_redmineup'] })
+          Setting.class.send(:define_method, 'plugin_redmineup=', lambda do |val|
+            setting = find_or_default('plugin_redmineup')
+            setting.value = val || ''
+            @cached_settings['plugin_redmineup'] = nil
+            setting.save(validate: false)
+            setting.value
+          end)
+        end
+        @settings_initialized
+      end
+
+      # Use apply instead attrs assign because it can rewrite other attributes
+      def apply=(values)
+        initialize_gem_settings unless @settings_initialized
+
+        Setting.plugin_redmineup = Setting.plugin_redmineup.merge(values)
+      end
+
+      def values
+        initialize_gem_settings unless @settings_initialized
+        Object.const_defined?('Setting') ? Setting.plugin_redmineup : {}
+      end
+
+      def [](value)
+        initialize_gem_settings unless @settings_initialized
+        return Setting.plugin_redmineup[value] if Object.const_defined?('Setting')
+
+        nil
+      end
+
+      private
+
+      def default_settings
+        {}
+      end
+    end
+  end
+end

data/lib/redmineup/version.rb

@@ -0,0 +1,3 @@
+module Redmineup
+  VERSION = '1.0.2'
+end

data/lib/redmineup.rb

@@ -0,0 +1,108 @@
+require 'active_record'
+require 'action_view'
+
+require 'redmineup/version'
+require 'redmineup/engine'
+
+require 'redmineup/settings'
+require 'redmineup/settings/money'
+
+require 'redmineup/acts_as_list/list'
+require 'redmineup/acts_as_taggable/tag'
+require 'redmineup/acts_as_taggable/tag_list'
+require 'redmineup/acts_as_taggable/tagging'
+require 'redmineup/acts_as_taggable/up_acts_as_taggable'
+require 'redmineup/acts_as_viewed/up_acts_as_viewed'
+require 'redmineup/acts_as_votable/up_acts_as_votable'
+require 'redmineup/acts_as_votable/up_acts_as_voter'
+require 'redmineup/acts_as_votable/vote'
+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/currency'
+require 'redmineup/helpers/tags_helper'
+require 'redmineup/money_helper'
+require 'redmineup/colors_helper'
+
+require 'liquid'
+require 'redmineup/liquid/filters/base'
+require 'redmineup/liquid/filters/arrays'
+require 'redmineup/liquid/filters/colors'
+require 'redmineup/liquid/drops/issues_drop'
+require 'redmineup/liquid/drops/news_drop'
+require 'redmineup/liquid/drops/projects_drop'
+require 'redmineup/liquid/drops/users_drop'
+require 'redmineup/liquid/drops/time_entries_drop'
+require 'redmineup/liquid/drops/attachment_drop'
+require 'redmineup/liquid/drops/issue_relations_drop'
+
+require 'redmineup/helpers/external_assets_helper'
+require 'redmineup/helpers/form_tag_helper'
+require 'redmineup/helpers/rup_calendar_helper'
+require 'redmineup/assets_manager'
+
+require 'redmineup/compatibility/application_controller_patch'
+require 'redmineup/compatibility/routing_mapper_patch'
+require 'redmineup/patches/liquid_patch' unless BigDecimal.respond_to?(:new)
+
+module Redmineup
+  GEM_NAME = 'redmineup'.freeze
+end
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.send :include, Redmineup::ActsAsList::List
+  ActiveRecord::Base.extend(Redmineup::ActsAsVotable::Voter)
+  ActiveRecord::Base.extend(Redmineup::ActsAsVotable::Votable)
+end
+
+Redmineup::AssetsManager.install_assets
+
+if defined?(ActionView::Base)
+  ActionView::Base.send :include, Redmineup::ExternalAssetsHelper
+  ActionView::Base.send :include, Redmineup::FormTagHelper
+end
+
+def requires_redmineup(arg)
+  def compare_versions(requirement, current)
+    raise ArgumentError.new('wrong version format') unless check_version_format(requirement)
+
+    requirement = requirement.split('.').collect(&:to_i)
+    requirement <=> current.slice(0, requirement.size)
+  end
+
+  def check_version_format(version)
+    version =~ /^\d+.?\d*.?\d*$/m
+  end
+
+  arg = { version_or_higher: arg } unless arg.is_a?(Hash)
+  arg.assert_valid_keys(:version, :version_or_higher)
+
+  current = Redmineup::VERSION.split('.').map { |x| x.to_i }
+  arg.each do |k, req|
+    case k
+    when :version_or_higher
+      raise ArgumentError.new(':version_or_higher accepts a version string only') unless req.is_a?(String)
+
+      unless compare_versions(req, current) <= 0
+        Rails.logger.error "\033[31m[ERROR]\033[0m Redmine requires redmineup gem version #{req} or higher (you're using #{Redmineup::VERSION}).\n\033[31m[ERROR]\033[0m Please update with 'bundle update redmineup'." if Rails.logger
+        abort "\033[31mRedmine requires redmineup gem version #{req} or higher (you're using #{Redmineup::VERSION}).\nPlease update with 'bundle update redmineup'.\033[0m"
+      end
+    when :version
+      req = [req] if req.is_a?(String)
+      if req.is_a?(Array)
+        unless req.detect { |ver| compare_versions(ver, current) == 0 }
+          abort "\033[31mRedmine requires redmineup gem version #{req} (you're using #{Redmineup::VERSION}).\nPlease update with 'bundle update redmineup'.\033[0m"
+        end
+      elsif req.is_a?(Range)
+        unless compare_versions(req.first, current) <= 0 && compare_versions(req.last, current) >= 0
+          abort "\033[31mRedmine requires redmineup gem version between #{req.first} and #{req.last} (you're using #{Redmineup::VERSION}).\nPlease update with 'bundle update redmineup'.\033[0m"
+        end
+      else
+        raise ArgumentError.new(':version option accepts a version string, an array or a range of versions')
+      end
+    end
+  end
+  true
+end

data/redmineup.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redmineup/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "redmineup"
+  spec.version       = Redmineup::VERSION
+  spec.authors       = ["RedmineUP"]
+  spec.email         = ["support@redmineup.com"]
+  spec.summary       = %q{Common libraries for RedmineUP plugins for Redmine}
+  spec.description   = %q{Common libraries for RedmineUP plugins (www.redmineup.com) for Redmine. Required Redmine from http://redmine.org}
+  spec.homepage      = "https://www.redmineup.com"
+  spec.license       = "GPL-2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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', '> 4.0', '< 5.0'
+  spec.add_runtime_dependency 'rubyzip'
+
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'mysql2'
+  spec.add_development_dependency 'pg'
+end

data/test/acts_as_draftable/draft_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class DraftTest < ActiveSupport::TestCase
+  def test_restore
+    issue = Issue.new(subject: 'some subject', description: 'some description')
+
+    issue.save_draft
+    restored_issue = Redmineup::ActsAsDraftable::Draft.find(issue.draft_id).restore
+
+    assert_equal issue.subject, restored_issue.subject
+    assert_equal issue.description, restored_issue.description
+  end
+
+  def test_restore_all
+    first_issue = Issue.new(subject: 'first subject')
+    first_issue.save_draft
+    second_issue = Issue.new(subject: 'second subject')
+    second_issue.save_draft
+
+    restored_issues = Redmineup::ActsAsDraftable::Draft.restore_all
+    assert_equal [first_issue.subject, second_issue.subject], restored_issues.map(&:subject).sort
+  end
+
+  private
+
+  def current_user
+    users(:sam)
+  end
+end

data/test/acts_as_draftable/rup_acts_as_draftable_test.rb

@@ -0,0 +1,178 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+class RupActsAsDraftableTest < ActiveSupport::TestCase
+  def test_up_acts_as_draftable_without_arguments
+    assert_nothing_raised do
+      Project.up_acts_as_draftable
+    end
+  end
+
+  def test_up_acts_as_draftable_with_parent
+    assert_nothing_raised do
+      News.up_acts_as_draftable(parent: :author)
+    end
+    assert User.new.respond_to?(:drafts)
+  end
+
+  def test_up_acts_as_draftable_with_non_existing_parent
+    assert_raises do
+      Issue.up_acts_as_draftable(parent: :foo)
+    end
+  end
+
+  def test_up_acts_as_draftable_with_non_hash_argument
+    assert_raises do
+      Issue.up_acts_as_draftable('bar')
+    end
+  end
+
+  def test_up_acts_as_draftable_with_invalid_hash_key
+    assert_raises do
+      Issue.up_acts_as_draftable(baz: 'qux')
+    end
+  end
+
+  def test_drafts
+    Issue.up_acts_as_draftable parent: :project
+    issue = Issue.new
+    issue.save_draft
+
+    assert_equal 1, Issue.drafts(current_user).count
+    assert_equal Redmineup::ActsAsDraftable::Draft, Issue.drafts(current_user).first.class
+  end
+
+  def test_from_draft
+    Issue.up_acts_as_draftable parent: :project
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft
+
+    issue_from_draft = Issue.from_draft(issue.draft_id)
+
+    assert_equal Issue, issue_from_draft.class
+    assert_equal true, issue_from_draft.new_record?
+    assert_equal issue.draft_id, issue_from_draft.draft_id
+
+    assert_equal issue.subject, issue_from_draft.subject
+  end
+
+  def test_draft_deleted_after_save
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft
+
+    issue_from_draft = Issue.from_draft(issue.draft_id)
+
+    assert_difference 'Issue.count' do
+      assert_difference 'Redmineup::ActsAsDraftable::Draft.count', -1 do
+        issue_from_draft.save!
+      end
+    end
+    assert_nil issue_from_draft.draft_id
+  end
+
+  def test_from_draft_with_non_existing_draft_id
+    assert_raises do
+      Issue.from_draft(999)
+    end
+  end
+
+  def test_from_draft_with_wrong_type
+    Project.up_acts_as_draftable
+
+    project = Project.new
+    project.save_draft
+
+    assert_raises do
+      Issue.from_draft(project.draft_id)
+    end
+  end
+
+  def test_dump_to_draft
+    assert_equal String, Issue.new.dump_to_draft.class
+  end
+
+  def test_load_from_draft
+    attributes = {subject: 'subject', description: 'description'}
+    draft = Issue.new(attributes).dump_to_draft
+
+    issue = Issue.new
+    issue.load_from_draft(draft)
+
+    assert_equal attributes[:subject], issue.subject
+    assert_equal attributes[:description], issue.description
+  end
+
+  def test_save_draft
+    Issue.up_acts_as_draftable parent: :project
+    attributes = { subject: 'subject' }
+    issue = Issue.new(attributes)
+
+    assert_no_difference 'Issue.count' do
+      assert_difference 'Redmineup::ActsAsDraftable::Draft.count' do
+        result = issue.save_draft
+        assert_equal true, result
+      end
+    end
+    assert_not_nil issue.draft_id
+
+    draft = Redmineup::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal 'Issue', draft.target_type
+    assert_equal current_user.id, draft.user_id
+    assert_equal attributes[:subject], draft.restore.subject
+  end
+
+  def test_save_draft_with_associations
+    Issue.up_acts_as_draftable parent: :project
+    issue = Issue.new(project: projects(:second_project))
+    issue.save_draft
+
+    draft = Redmineup::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.project.name, draft.restore.project.name
+  end
+
+  def test_save_draft_updates_existing_draft
+    Issue.up_acts_as_draftable parent: :project
+    issue = Issue.new
+    issue.save_draft
+
+    issue.subject = 'changed subject'
+    assert_no_difference 'Issue.count' do
+      assert_no_difference 'Redmineup::ActsAsDraftable::Draft.count' do
+        issue.save_draft
+      end
+    end
+
+    draft = Redmineup::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.subject, draft.restore.subject
+  end
+
+  def test_save_draft_does_not_save_persisted_object
+    issue = issues(:second_issue)
+    assert_equal false, issue.save_draft
+  end
+
+  def test_save_draft_saves_persisted_but_changed_object
+    issue = issues(:second_issue)
+    issue.subject = 'changed subject'
+    assert_equal true, issue.save_draft
+  end
+
+  def test_update_draft
+    issue = Issue.new(subject: 'subject')
+    issue.save_draft
+
+    assert_no_difference 'Issue.count' do
+      assert_no_difference 'Redmineup::ActsAsDraftable::Draft.count' do
+        issue.update_draft(subject: 'updated_subject')
+      end
+    end
+
+    draft = Redmineup::ActsAsDraftable::Draft.find(issue.draft_id)
+    assert_equal issue.subject, draft.restore.subject
+  end
+
+  private
+
+  def current_user
+    users(:sam)
+  end
+end