yeshoua_crm 1.0.0

data/lib/yeshoua_crm/currency/formatting.rb

@@ -0,0 +1,224 @@
+# encoding: UTF-8
+module YeshouaCrm
+  class Currency
+    module Formatting
+      def self.included(base)
+        [
+          [:thousands_separator, :delimiter, ","],
+          [:decimal_mark, :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 =>".",
+          :thousands_separator => ",",
+          :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/yeshoua_crm/currency/heuristics.rb

@@ -0,0 +1,151 @@
+module YeshouaCrm
+  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/yeshoua_crm/currency/loader.rb

@@ -0,0 +1,24 @@
+module YeshouaCrm
+  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
+        currencies = parse_currency_file("currency_iso.json")
+        # currencies.merge! parse_currency_file("currency_non_iso.json")
+        # currencies.merge! parse_currency_file("currency_backwards_compatible.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

data/lib/yeshoua_crm/helpers/external_assets_helper.rb

@@ -0,0 +1,17 @@
+module YeshouaCrm
+  module ExternalAssetsHelper
+    include ActionView::Helpers::JavaScriptHelper
+
+    def select2_assets
+      return if @select2_tag_included
+      @select2_tag_included = true
+      javascript_include_tag('select2', :plugin => 'yeshoua_crm') + stylesheet_link_tag('select2', :plugin => 'yeshoua_crm')
+    end
+
+    def chartjs_assets
+      return if @chartjs_tag_included
+      @chartjs_tag_included = true
+      javascript_include_tag('Chart.bundle.min', :plugin => 'yeshoua_crm')
+    end
+  end
+end

data/lib/yeshoua_crm/helpers/form_tag_helper.rb

@@ -0,0 +1,123 @@
+module YeshouaCrm
+  module FormTagHelper
+    # Allows include select2 into your views.
+    #
+    # ==== Examples
+    #   select2_tag 'city_id', '<option value="1">Lisbon</option>...'
+    #   select2_tag 'city_id', options_for_select(...)
+    #   select2_tag 'tag_list', nil, :multiple => true, :data => [{ id: 0, text: 'deal' }, ...], :tags => true, :include_hidden => false %>
+    #   select2_tag 'tag_list', options_for_select(...), :multiple => true, :style => 'width: 100%;', :url => '/tags', :placeholder => '+ add tag', :tags => true %>
+    #
+    # You may use select_tag options and additional options.
+    #
+    # ==== Additional options
+    # * <tt>:url</tt> Allows searches for remote data using the ajax.
+    # * <tt>:data</tt> Load dropdown options from a local array if +url+ option not set.
+    # * <tt>:placeholder</tt> Supports displaying a placeholder value.
+    # * <tt>:include_hidden</tt> Adds hidden field after select when +multiple+ option true. Default value true.
+    #
+    # <b>Note:</b> The HTML specification says when +multiple+ parameter passed to select and all options got deselected
+    # web browsers do not send any value to server.
+    #
+    # In case if you don't want the helper to generate this hidden field you can specify
+    # <tt>include_hidden: false</tt> option.
+    #
+    # Also aliased as: select2
+    #
+    #   select2 'city_id', options_for_select(...)
+    #
+    def select2_tag(name, option_tags = nil, options = {})
+      id = sanitize_to_id(name)
+      placeholder = options[:placeholder] || 'Select ...'
+
+      content_for(:header_tags) { select2_assets }
+      result = select_tag(name, option_tags, options)
+      if options[:multiple] && options.fetch(:include_hidden, true)
+        result << hidden_field_tag("#{name}[]", '')
+      end
+
+      result << javascript_tag(<<-JS)
+        $(function () {
+            $('select#' + '#{id}').select2({
+                #{select2_data_source_options(options)},
+                #{select2_tags_options(options)},
+                placeholder: '#{placeholder}'
+            });
+        });
+      JS
+    end
+
+    alias select2 select2_tag
+
+    # Transforms select filter field into select2
+    #
+    # ==== Examples
+    #   transform_to_select2 'issue_tags', url: auto_complete_tags_url
+    #   transform_to_select2 'manager_id', format_state: 'formatStateWithAvatar', min_input_length: 1, url: '/managers'
+    #
+    # ==== Options
+    # * <tt>:url</tt> Defines URL to search remote data using the ajax.
+    # * <tt>:format_state</tt> Defines template of search results in the drop-down.
+    # * <tt>:min_input_length</tt> Minimum number of characters required to start a search. Default value 0.
+    # * <tt>:width</tt> Sets the width of the control. Default value '60%'.
+    #
+    def transform_to_select2(field, options = {})
+      return if field.empty?
+
+      result = ''.html_safe
+      unless @transform_to_select2_included
+      result << javascript_include_tag('select2_helpers', plugin: 'yeshoua_crm')
+        @transform_to_select2_included = true
+      end
+
+      result << javascript_tag(<<-JS)
+          select2Filters['#{field}'] = {
+              url: '#{options[:url].to_s}',
+              formatState: #{options.fetch(:format_state, 'undefined')},
+              minimumInputLength: #{options.fetch(:min_input_length, 0)},
+              width: '#{options.fetch(:with, '60%')}'
+          };
+      JS
+    end
+
+    private
+
+    def select2_data_source_options(options = {})
+      if options[:url].to_s.empty?
+        "data: #{options.fetch(:data, []).to_json}"
+      else
+        "ajax: {
+             url: '#{options[:url]}',
+             dataType: 'json',
+             delay: 250,
+             data: function (params) {
+                 return { q: params.term };
+             },
+             processResults: function (data, params) {
+                 return { results: data };
+             },
+             cache: true
+         }"
+      end
+    end
+
+    def select2_tags_options(options = {})
+      if options.fetch(:tags, false)
+        "tags: true,
+         tokenSeparators: [','],
+         createTag: function (params) {
+             var term = $.trim(params.term);
+             if (term === '' || term.indexOf(',') > -1) {
+                 return null; // Return null to disable tag creation
+             }
+             return {
+                 id: term,
+                 text: term
+             }
+         }"
+      else
+        'tags: false'
+      end
+    end
+  end
+end