yeshua_crm 1.0.0

data/lib/yeshua_crm/acts_as_votable/vote.rb

@@ -0,0 +1,28 @@
+require 'yeshua_crm/helpers/vote_helper'
+
+module YeshuaCrm
+  module ActsAsVotable
+    class Vote < ActiveRecord::Base
+      include Helpers::Words
+
+      if defined?(ProtectedAttributes) || ::ActiveRecord::VERSION::MAJOR < 4
+        attr_accessible :votable_id, :votable_type,
+          :voter_id, :voter_type,
+          :votable, :voter,
+          :vote_flag, :vote_scope,
+          :vote_ip
+      end
+
+      belongs_to :votable, :polymorphic => true
+      belongs_to :voter, :polymorphic => true
+
+      scope :up, lambda { where(:vote_flag => true) }
+      scope :down, lambda { where(:vote_flag => false) }
+      scope :for_type, lambda { |klass| where(:votable_type => klass.to_s) }
+      scope :by_type,  lambda { |klass| where(:voter_type => klass.to_s) }
+
+      validates_presence_of :votable_id
+      validates_presence_of :voter_id
+    end
+  end
+end

data/lib/yeshua_crm/acts_as_votable/voter.rb

@@ -0,0 +1,131 @@
+module YeshuaCrm
+  module ActsAsVotable
+    module Voter
+      def self.included(base)
+        # allow user to define these
+        aliases = {
+          :vote_up_for    => [:likes, :upvotes, :up_votes],
+          :vote_down_for  => [:dislikes, :downvotes, :down_votes],
+          :unvote_for     => [:unlike, :undislike],
+          :voted_on?      => [:voted_for?],
+          :voted_up_on?   => [:voted_up_for?, :liked?],
+          :voted_down_on? => [:voted_down_for?, :disliked?],
+          :voted_as_when_voting_on => [:voted_as_when_voted_on, :voted_as_when_voting_for, :voted_as_when_voted_for],
+          :find_up_voted_items   => [:find_liked_items],
+          :find_down_voted_items => [:find_disliked_items]
+        }
+
+        base.class_eval do
+          has_many :votes, :class_name => 'YeshuaCrm::ActsAsVotable::Vote', :as => :voter, :dependent => :destroy do
+            def votables
+              includes(:votable).map(&:votable)
+            end
+          end
+
+          aliases.each do |method, links|
+            links.each do |new_method|
+              alias_method(new_method, method)
+            end
+          end
+        end
+      end
+
+      # voting
+      def vote(args)
+        args[:votable].vote_by args.merge(:voter => self)
+      end
+
+      def vote_up_for(model = nil, args = {})
+        vote :votable => model, :vote_scope => args[:vote_scope], :vote => true
+      end
+
+      def vote_down_for(model = nil, args = {})
+        vote :votable => model, :vote_scope => args[:vote_scope], :vote => false
+      end
+
+      def unvote_for(model, args = {})
+        model.unvote :voter => self, :vote_scope => args[:vote_scope]
+      end
+
+      # results
+      def voted_on?(votable, args = {})
+        votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name,
+                           :vote_scope => args[:vote_scope])
+        !votes.empty?
+      end
+
+      def voted_up_on?(votable, args = {})
+        votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name,
+                           :vote_scope => args[:vote_scope], :vote_flag => true)
+        !votes.empty?
+      end
+
+      def voted_down_on?(votable, args = {})
+        votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name,
+                           :vote_scope => args[:vote_scope], :vote_flag => false)
+        !votes.empty?
+      end
+
+      def voted_as_when_voting_on(votable, args = {})
+        vote = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name,
+                          :vote_scope => args[:vote_scope]).select(:vote_flag).last
+        return nil unless vote
+        vote.vote_flag
+      end
+
+      def find_votes(extra_conditions = {})
+        votes.where(extra_conditions)
+      end
+
+      def find_up_votes(args = {})
+        find_votes :vote_flag => true, :vote_scope => args[:vote_scope]
+      end
+
+      def find_down_votes(args = {})
+        find_votes :vote_flag => false, :vote_scope => args[:vote_scope]
+      end
+
+      def find_votes_for_class(klass, extra_conditions = {})
+        find_votes extra_conditions.merge(:votable_type => klass.name)
+      end
+
+      def find_up_votes_for_class(klass, args = {})
+        find_votes_for_class klass, :vote_flag => true, :vote_scope => args[:vote_scope]
+      end
+
+      def find_down_votes_for_class(klass, args = {})
+        find_votes_for_class klass, :vote_flag => false, :vote_scope => args[:vote_scope]
+      end
+
+      # Including polymporphic relations for eager loading
+      def include_objects
+        YeshuaCrm::ActsAsVotable::Vote.includes(:votable)
+      end
+
+      def find_voted_items(extra_conditions = {})
+        options = extra_conditions.merge :voter_id => id, :voter_type => self.class.base_class.name
+        include_objects.where(options).collect(&:votable)
+      end
+
+      def find_up_voted_items(extra_conditions = {})
+        find_voted_items extra_conditions.merge(:vote_flag => true)
+      end
+
+      def find_down_voted_items(extra_conditions = {})
+        find_voted_items extra_conditions.merge(:vote_flag => false)
+      end
+
+      def get_voted(klass, extra_conditions = {})
+        klass.joins(:votes_for).merge find_votes(extra_conditions)
+      end
+
+      def get_up_voted(klass)
+        klass.joins(:votes_for).merge find_up_votes
+      end
+
+      def get_down_voted(klass)
+        klass.joins(:votes_for).merge find_down_votes
+      end
+    end
+  end
+end

data/lib/yeshua_crm/assets_manager.rb

@@ -0,0 +1,43 @@
+module YeshuaCrm
+  class AssetsManager
+    def self.install_assets
+      return unless Gem.loaded_specs['yeshua_crm']
+      source = File.join(Gem.loaded_specs['yeshua_crm'].full_gem_path, 'vendor', 'assets')
+      destination = File.join(Dir.pwd, 'public', 'plugin_assets', 'yeshua_crm')
+      return unless File.directory?(source)
+
+      source_files = Dir[source + '/**/*']
+      source_dirs = source_files.select { |d| File.directory?(d) }
+      source_files -= source_dirs
+
+      unless source_files.empty?
+        base_target_dir = File.join(destination, File.dirname(source_files.first).gsub(source, ''))
+        begin
+          FileUtils.mkdir_p(base_target_dir)
+        rescue Exception => e
+          raise "Could not create directory #{base_target_dir}: " + e.message
+        end
+      end
+
+      source_dirs.each do |dir|
+        target_dir = File.join(destination, dir.gsub(source, ''))
+        begin
+          FileUtils.mkdir_p(target_dir)
+        rescue Exception => e
+          raise "Could not create directory #{target_dir}: " + e.message
+        end
+      end
+
+      source_files.each do |file|
+        begin
+          target = File.join(destination, file.gsub(source, ''))
+          unless File.exist?(target) && FileUtils.identical?(file, target)
+            FileUtils.cp(file, target)
+          end
+        rescue Exception => e
+          raise "Could not copy #{file} to #{target}: " + e.message
+        end
+      end
+    end
+  end
+end

data/lib/yeshua_crm/currency/formatting.rb

@@ -0,0 +1,224 @@
+# encoding: UTF-8
+module YeshuaCrm
+  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/yeshua_crm/currency/heuristics.rb

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

@@ -0,0 +1,24 @@
+module YeshuaCrm
+  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