redmineup 1.0.2

data/lib/redmineup/colors_helper.rb

@@ -0,0 +1,192 @@
+module Redmineup
+  class ColorsHelper
+    NAMED_COLORS = {
+      'aliceblue' => 'f0f8ff',
+      'antiquewhite' => 'faebd7',
+      'aqua' => '00ffff',
+      'aquamarine' => '7fffd4',
+      'azure' => 'f0ffff',
+      'beige' => 'f5f5dc',
+      'bisque' => 'ffe4c4',
+      'black' => '000',
+      'blanchedalmond' => 'ffebcd',
+      'blue' => '0000ff',
+      'blueviolet' => '8a2be2',
+      'brown' => 'a52a2a',
+      'burlywood' => 'deb887',
+      'burntsienna' => 'ea7e5d',
+      'cadetblue' => '5f9ea0',
+      'chartreuse' => '7fff00',
+      'chocolate' => 'd2691e',
+      'coral' => 'ff7f50',
+      'cornflowerblue' => '6495ed',
+      'cornsilk' => 'fff8dc',
+      'crimson' => 'dc143c',
+      'cyan' => '00ffff',
+      'darkblue' => '00008b',
+      'darkcyan' => '008b8b',
+      'darkgoldenrod' => 'b8860b',
+      'darkgray' => 'a9a9a9',
+      'darkgreen' => '006400',
+      'darkgrey' => 'a9a9a9',
+      'darkkhaki' => 'bdb76b',
+      'darkmagenta' => '8b008b',
+      'darkolivegreen' => '556b2f',
+      'darkorange' => 'ff8c00',
+      'darkorchid' => '9932cc',
+      'darkred' => '8b0000',
+      'darksalmon' => 'e9967a',
+      'darkseagreen' => '8fbc8f',
+      'darkslateblue' => '483d8b',
+      'darkslategray' => '2f4f4f',
+      'darkslategrey' => '2f4f4f',
+      'darkturquoise' => '00ced1',
+      'darkviolet' => '9400d3',
+      'deeppink' => 'ff1493',
+      'deepskyblue' => '00bfff',
+      'dimgray' => '696969',
+      'dimgrey' => '696969',
+      'dodgerblue' => '1e90ff',
+      'firebrick' => 'b22222',
+      'floralwhite' => 'fffaf0',
+      'forestgreen' => '228b22',
+      'fuchsia' => 'ff00ff',
+      'gainsboro' => 'dcdcdc',
+      'ghostwhite' => 'f8f8ff',
+      'gold' => 'ffd700',
+      'goldenrod' => 'daa520',
+      'gray' => '808080',
+      'green' => '008000',
+      'greenyellow' => 'adff2f',
+      'grey' => '808080',
+      'honeydew' => 'f0fff0',
+      'hotpink' => 'ff69b4',
+      'indianred' => 'cd5c5c',
+      'indigo' => '4b0082',
+      'ivory' => 'fffff0',
+      'khaki' => 'f0e68c',
+      'lavender' => 'e6e6fa',
+      'lavenderblush' => 'fff0f5',
+      'lawngreen' => '7cfc00',
+      'lemonchiffon' => 'fffacd',
+      'lightblue' => 'add8e6',
+      'lightcoral' => 'f08080',
+      'lightcyan' => 'e0ffff',
+      'lightgoldenrodyellow' => 'fafad2',
+      'lightgray' => 'd3d3d3',
+      'lightgreen' => '90ee90',
+      'lightgrey' => 'd3d3d3',
+      'lightpink' => 'ffb6c1',
+      'lightsalmon' => 'ffa07a',
+      'lightseagreen' => '20b2aa',
+      'lightskyblue' => '87cefa',
+      'lightslategray' => '789',
+      'lightslategrey' => '789',
+      'lightsteelblue' => 'b0c4de',
+      'lightyellow' => 'ffffe0',
+      'lime' => '00ff00',
+      'limegreen' => '32cd32',
+      'linen' => 'faf0e6',
+      'magenta' => 'ff00ff',
+      'maroon' => '800000',
+      'mediumaquamarine' => '66cdaa',
+      'mediumblue' => '0000cd',
+      'mediumorchid' => 'ba55d3',
+      'mediumpurple' => '9370db',
+      'mediumseagreen' => '3cb371',
+      'mediumslateblue' => '7b68ee',
+      'mediumspringgreen' => '00fa9a',
+      'mediumturquoise' => '48d1cc',
+      'mediumvioletred' => 'c71585',
+      'midnightblue' => '191970',
+      'mintcream' => 'f5fffa',
+      'mistyrose' => 'ffe4e1',
+      'moccasin' => 'ffe4b5',
+      'navajowhite' => 'ffdead',
+      'navy' => '000080',
+      'oldlace' => 'fdf5e6',
+      'olive' => '808000',
+      'olivedrab' => '6b8e23',
+      'orange' => 'ffa500',
+      'orangered' => 'ff4500',
+      'orchid' => 'da70d6',
+      'palegoldenrod' => 'eee8aa',
+      'palegreen' => '98fb98',
+      'paleturquoise' => 'afeeee',
+      'palevioletred' => 'db7093',
+      'papayawhip' => 'ffefd5',
+      'peachpuff' => 'ffdab9',
+      'peru' => 'cd853f',
+      'pink' => 'ffc0cb',
+      'plum' => 'dda0dd',
+      'powderblue' => 'b0e0e6',
+      'purple' => '800080',
+      'rebeccapurple' => '663399',
+      'red' => 'ff0000',
+      'rosybrown' => 'bc8f8f',
+      'royalblue' => '4169e1',
+      'saddlebrown' => '8b4513',
+      'salmon' => 'fa8072',
+      'sandybrown' => 'f4a460',
+      'seagreen' => '2e8b57',
+      'seashell' => 'fff5ee',
+      'sienna' => 'a0522d',
+      'silver' => 'c0c0c0',
+      'skyblue' => '87ceeb',
+      'slateblue' => '6a5acd',
+      'slategray' => '708090',
+      'slategrey' => '708090',
+      'snow' => 'fffafa',
+      'springgreen' => '00ff7f',
+      'steelblue' => '4682b4',
+      'tan' => 'd2b48c',
+      'teal' => '008080',
+      'thistle' => 'd8bfd8',
+      'tomato' => 'ff6347',
+      'turquoise' => '40e0d0',
+      'violet' => 'ee82ee',
+      'wheat' => 'f5deb3',
+      'white' => 'fff',
+      'whitesmoke' => 'f5f5f5',
+      'yellow' => 'ffff00',
+      'yellowgreen' => '9acd32'
+    }
+
+    class << self
+      # Amount should be a decimal between 0 and 1. Lower means darker
+
+      def darken_color(input_color, amount=0.4)
+        hex_color = hex_color(input_color).gsub('#','')
+        rgb = hex_color.scan(/../).map {|color| color.hex}
+        rgb[0] = (rgb[0].to_i * amount).round
+        rgb[1] = (rgb[1].to_i * amount).round
+        rgb[2] = (rgb[2].to_i * amount).round
+        "#%02x%02x%02x" % rgb
+      end
+        
+      # Amount should be a decimal between 0 and 1. Higher lightgreen lighter
+      def lighten_color(input_color, amount=0.6)
+        hex_color = hex_color(input_color).gsub('#','')
+        rgb = hex_color.scan(/../).map {|color| color.hex}
+        rgb[0] = [(rgb[0].to_i + 255 * amount).round, 255].min
+        rgb[1] = [(rgb[1].to_i + 255 * amount).round, 255].min
+        rgb[2] = [(rgb[2].to_i + 255 * amount).round, 255].min
+        "#%02x%02x%02x" % rgb
+      end
+
+      def contrasting_text_color(input_color)
+        color = hex_color(input_color).gsub('#','')
+        convert_to_brightness_value(color) > 382.5 ? darken_color(color) : lighten_color(color)
+      end
+      
+      def hex_color(input_color)
+        "##{NAMED_COLORS[input_color] || input_color}"
+      end
+
+      def convert_to_brightness_value(input_color)
+         (hex_color(input_color).scan(/../).map {|color| color.hex}).sum
+      end
+
+    end
+  end
+end

data/lib/redmineup/compatibility/application_controller_patch.rb

@@ -0,0 +1,33 @@
+module Redmineup
+  module Patches
+    module ApplicationControllerPatch
+      def self.included(base) # :nodoc:
+        base.extend(ClassMethods)
+        base.class_eval do
+          unloadable # Send unloadable so it will not be unloaded in development
+        end
+      end
+
+      module ClassMethods
+        def before_action(*filters, &block)
+          before_filter(*filters, &block)
+        end
+
+        def after_action(*filters, &block)
+          after_filter(*filters, &block)
+        end
+
+        def skip_before_action(*filters, &block)
+          skip_before_filter(*filters, &block)
+        end
+      end
+    end
+  end
+end
+
+unless ActionController::Base.methods.include?(:before_action)
+  ActionController::Base.send(
+    :include,
+    Redmineup::Patches::ApplicationControllerPatch
+  )
+end

data/lib/redmineup/compatibility/routing_mapper_patch.rb

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

data/lib/redmineup/currency/formatting.rb

@@ -0,0 +1,224 @@
+# encoding: UTF-8
+module Redmineup
+  class Currency
+    module Formatting
+      def self.included(base)
+        [
+          [:thousands_separator, :delimiter, Redmineup::Settings::Money.thousands_delimiter],
+          [:decimal_mark, :separator, Redmineup::Settings::Money.decimal_separator]
+        ].each do |method, name, character|
+          define_i18n_method(method, name, character)
+        end
+      end
+
+      def self.define_i18n_method(method, name, character)
+        define_method(method) do
+          if self.class.use_i18n
+            begin
+              I18n.t name, :scope => "number.currency.format", :raise => true
+            rescue I18n::MissingTranslationData
+              I18n.t name, :scope =>"number.format", :default => (currency.send(method) || character)
+            end
+          else
+            currency.send(method) || character
+          end
+        end
+        alias_method name, method
+      end
+
+      def format(value, currency, *rules)
+        # support for old format parameters
+        rules = normalize_formatting_rules(rules)
+        if currency
+          rules = self.localize_formatting_rules(rules, currency)
+          rules = self.translate_formatting_rules(rules, currency.code) if rules[:translate]
+          rules[:decimal_mark] = currency.decimal_mark if rules[:decimal_mark].nil?
+          rules[:decimal_places] = currency.decimal_places
+          rules[:subunit_to_unit] = currency.subunit_to_unit
+          rules[:thousands_separator] = currency.thousands_separator if rules[:thousands_separator].nil?
+        end
+        rules = Currency.default_formatting_rules.merge(rules){|key, v1, v2| v2.nil? ? v1 : v2}
+
+        # if fractional == 0
+        if rules[:display_free].respond_to?(:to_str)
+          return rules[:display_free]
+        elsif rules[:display_free]
+          return "free"
+        end
+        # end
+
+        symbol_value = currency.try(:symbol) || ""
+
+        formatted = value.abs.to_s
+
+        # if rules[:rounded_infinite_precision]
+        if currency
+          formatted.gsub!(/#{rules[:decimal_mark]}/, '.') unless '.' == rules[:decimal_mark]
+          formatted = ((BigDecimal(formatted) * currency.subunit_to_unit).round / BigDecimal(currency.subunit_to_unit.to_s)).to_s("F")
+          formatted.gsub!(/\..*/) do |decimal_part|
+            decimal_part << '0' while decimal_part.length < (currency.decimal_places + 1)
+            decimal_part
+          end
+          formatted.gsub!(/\./, rules[:decimal_mark]) unless '.' == rules[:decimal_mark]
+        end
+
+        sign = value < 0 ? '-' : ''
+
+        if rules[:no_cents] || (rules[:no_cents_if_whole] && cents % currency.subunit_to_unit == 0)
+          formatted = "#{formatted.to_i}"
+        end
+
+        # thousands_separator_value = currency.thousands_separator
+        # Determine thousands_separator
+        if rules.has_key?(:thousands_separator)
+          thousands_separator_value = rules[:thousands_separator] || ''
+        end
+        decimal_mark = rules[:decimal_mark]
+        # Apply thousands_separator
+        formatted.gsub!(regexp_format(formatted, rules, decimal_mark, symbol_value),
+                        "\\1#{thousands_separator_value}")
+
+        symbol_position = symbol_position_from(rules, currency) if currency
+
+        if rules[:sign_positive] == true && (value >= 0)
+          sign = '+'
+        end
+
+        if rules[:sign_before_symbol] == true
+          sign_before = sign
+          sign = ''
+        end
+
+        if symbol_value && !symbol_value.empty?
+          symbol_value = "<span class=\"currency_symbol\">#{symbol_value}</span>" if rules[:html_wrap_symbol]
+          formatted = if symbol_position == :before
+            symbol_space = rules[:symbol_before_without_space] === false ? " " : ""
+            "#{sign_before}#{symbol_value}#{symbol_space}#{sign}#{formatted}"
+          else
+            symbol_space = rules[:symbol_after_without_space] ? "" : " "
+            "#{sign_before}#{sign}#{formatted}#{symbol_space}#{symbol_value}"
+          end
+        else
+          formatted="#{sign_before}#{sign}#{formatted}"
+        end
+
+        # apply_decimal_mark_from_rules(formatted, rules)
+
+        if rules[:with_currency]
+          formatted << " "
+          formatted << '<span class="currency">' if rules[:html]
+          formatted << currency.to_s
+          formatted << '</span>' if rules[:html]
+        end
+        formatted
+      end
+
+      def default_formatting_rules
+        {
+          decimal_mark: Redmineup::Settings::Money.decimal_separator || '.',
+          thousands_separator: Redmineup::Settings::Money.thousands_delimiter || ',',
+          subunit_to_unit: 100
+        }
+      end
+
+      def regexp_format(formatted, rules, decimal_mark, symbol_value)
+        regexp_decimal = Regexp.escape(decimal_mark)
+        if rules[:south_asian_number_formatting]
+          /(\d+?)(?=(\d\d)+(\d)(?:\.))/
+        else
+          # Symbols may contain decimal marks (E.g "դր.")
+          if formatted.sub(symbol_value.to_s, "") =~ /#{regexp_decimal}/
+            /(\d)(?=(?:\d{3})+(?:#{regexp_decimal}))/
+          else
+            /(\d)(?=(?:\d{3})+(?:[^\d]{1}|$))/
+          end
+        end
+      end
+
+      def translate_formatting_rules(rules, iso_code)
+        begin
+          rules[:symbol] = I18n.t iso_code, :scope => "number.currency.symbol", :raise => true
+        rescue I18n::MissingTranslationData
+          # Do nothing
+        end
+        rules
+      end
+
+      def localize_formatting_rules(rules, currency)
+        if currency.iso_code == "JPY" && I18n.locale == :ja
+          rules[:symbol] = "円" unless rules[:symbol] == false
+          rules[:symbol_position] = :after
+          rules[:symbol_after_without_space] = true
+        elsif currency.iso_code == "CHF"
+          rules[:symbol_before_without_space] = false
+        end
+        rules
+      end
+
+      def symbol_value_from(rules)
+        if rules.has_key?(:symbol)
+          if rules[:symbol] === true
+            symbol
+          elsif rules[:symbol]
+            rules[:symbol]
+          else
+            ""
+          end
+        elsif rules[:html]
+          currency.html_entity == '' ? currency.symbol : currency.html_entity
+        elsif rules[:disambiguate] and currency.disambiguate_symbol
+          currency.disambiguate_symbol
+        else
+          symbol
+        end
+      end
+
+      def symbol_position_from(rules, currency)
+        if rules.has_key?(:symbol_position)
+          if [:before, :after].include?(rules[:symbol_position])
+            return rules[:symbol_position]
+          else
+            raise ArgumentError, ":symbol_position must be ':before' or ':after'"
+          end
+        elsif currency.symbol_first?
+          :before
+        else
+          :after
+        end
+      end
+
+      private
+
+      # Cleans up formatting rules.
+      #
+      # @param [Hash] rules
+      #
+      # @return [Hash]
+      def normalize_formatting_rules(rules)
+        if rules.size == 0
+          rules = {}
+        elsif rules.size == 1
+          rules = rules.pop
+          rules = { rules => true } if rules.is_a?(Symbol)
+        end
+        rules[:decimal_mark] = rules[:separator] || rules[:decimal_mark]
+        rules[:thousands_separator] = rules[:delimiter] || rules[:thousands_separator]
+        rules
+      end
+
+      # Applies decimal mark from rules to formatted
+      #
+      # @param [String] formatted
+      # @param [Hash]   rules
+      def apply_decimal_mark_from_rules(formatted, rules)
+        if rules.has_key?(:decimal_mark) && rules[:decimal_mark]
+          # && rules[:decimal_mark] != decimal_mark
+
+          regexp_decimal = Regexp.escape(rules[:decimal_mark])
+          formatted.sub!(/(.*)(#{regexp_decimal})(.*)\Z/,
+                         "\\1#{rules[:decimal_mark]}\\3")
+        end
+      end
+    end
+  end
+end

data/lib/redmineup/currency/heuristics.rb

@@ -0,0 +1,151 @@
+module Redmineup
+  class Currency
+    module Heuristics
+
+      # An robust and efficient algorithm for finding currencies in
+      # text. Using several algorithms it can find symbols, iso codes and
+      # even names of currencies.
+      # Although not recommendable, it can also attempt to find the given
+      # currency in an entire sentence
+      #
+      # Returns: Array (matched results)
+      def analyze(str)
+        return Analyzer.new(str, search_tree).process
+      end
+
+      private
+
+      # Build a search tree from the currency database
+      def search_tree
+        @_search_tree ||= {
+          :by_symbol => currencies_by_symbol,
+          :by_iso_code => currencies_by_iso_code,
+          :by_name => currencies_by_name
+        }
+      end
+
+      def currencies_by_symbol
+        {}.tap do |r|
+          table.each do |dummy, c|
+            symbol = (c[:symbol]||"").downcase
+            symbol.chomp!('.')
+            (r[symbol] ||= []) << c
+
+            (c[:alternate_symbols]||[]).each do |ac|
+              ac = ac.downcase
+              ac.chomp!('.')
+              (r[ac] ||= []) << c
+            end
+          end
+        end
+      end
+
+      def currencies_by_iso_code
+        {}.tap do |r|
+          table.each do |dummy,c|
+            (r[c[:iso_code].downcase] ||= []) << c
+          end
+        end
+      end
+
+      def currencies_by_name
+        {}.tap do |r|
+          table.each do |dummy,c|
+            name_parts = c[:name].downcase.split
+            name_parts.each {|part| part.chomp!('.')}
+
+            # construct one branch per word
+            root = r
+            while name_part = name_parts.shift
+              root = (root[name_part] ||= {})
+            end
+
+            # the leaf is a currency
+            (root[:value] ||= []) << c
+          end
+        end
+      end
+
+      class Analyzer
+        attr_reader :search_tree, :words
+        attr_accessor :str, :currencies
+
+        def initialize str, search_tree
+          @str = (str||'').dup
+          @search_tree = search_tree
+          @currencies = []
+        end
+
+        def process
+          format
+          return [] if str.empty?
+
+          search_by_symbol
+          search_by_iso_code
+          search_by_name
+
+          prepare_reply
+        end
+
+        def format
+          str.gsub!(/[\r\n\t]/,'')
+          str.gsub!(/[0-9][\.,:0-9]*[0-9]/,'')
+          str.gsub!(/[0-9]/, '')
+          str.downcase!
+          @words = str.split
+          @words.each {|word| word.chomp!('.'); word.chomp!(',') }
+        end
+
+        def search_by_symbol
+          words.each do |word|
+            if found = search_tree[:by_symbol][word]
+              currencies.concat(found)
+            end
+          end
+        end
+
+        def search_by_iso_code
+          words.each do |word|
+            if found = search_tree[:by_iso_code][word]
+              currencies.concat(found)
+            end
+          end
+        end
+
+        def search_by_name
+          # remember, the search tree by name is a construct of branches and leaf!
+          # We need to try every combination of words within the sentence, so we
+          # end up with a x^2 equation, which should be fine as most names are either
+          # one or two words, and this is multiplied with the words of given sentence
+
+          search_words = words.dup
+
+          while search_words.length > 0
+            root = search_tree[:by_name]
+
+            search_words.each do |word|
+              if root = root[word]
+                if root[:value]
+                  currencies.concat(root[:value])
+                end
+              else
+                break
+              end
+            end
+
+            search_words.delete_at(0)
+          end
+        end
+
+        def prepare_reply
+          codes = currencies.map do |currency|
+            currency[:iso_code]
+          end
+          codes.uniq!
+          codes.sort!
+          codes
+        end
+      end
+    end
+  end
+end

data/lib/redmineup/currency/loader.rb

@@ -0,0 +1,23 @@
+module Redmineup
+  class Currency
+    module Loader
+      DATA_PATH = File.expand_path("../../../../config", __FILE__)
+
+      # Loads and returns the currencies stored in JSON files
+      # in the config directory.
+      #
+      # @return [Hash]
+      def load_currencies
+        parse_currency_file('currency_iso.json')
+      end
+
+      private
+
+      def parse_currency_file(filename)
+        json = File.read("#{DATA_PATH}/#{filename}")
+        json.force_encoding(::Encoding::UTF_8) if defined?(::Encoding)
+        JSON.parse(json, symbolize_names: true)
+      end
+    end
+  end
+end