test_redmine_vz 0.0.24

data/lib/redmine_crm/currency/heuristics.rb

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

@@ -0,0 +1,24 @@
+module RedmineCrm
+  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/redmine_crm/helpers/tags_helper.rb

@@ -0,0 +1,15 @@
+module RedmineCrm
+  module TagsHelper
+    # See the README for an example using tag_cloud.
+    def tag_cloud(tags, classes)
+      return if tags.empty?
+      
+      max_count = tags.sort_by(&:count).last.count.to_f
+      
+      tags.each do |tag|
+        index = ((tag.count / max_count) * (classes.size - 1)).round
+        yield tag, classes[index]
+      end
+    end
+  end
+end

data/lib/redmine_crm/helpers/vote_helper.rb

@@ -0,0 +1,38 @@
+module RedmineCrm
+  module ActsAsVotable::Helpers
+
+    # this helper provides methods that help find what words are 
+    # up votes and what words are down votes
+    #
+    # It can be called 
+    #
+    # votable_object.votable_words.that_mean_true
+    #
+    module Words
+
+      def votable_words
+        VotableWords
+      end
+
+    end
+
+    class VotableWords
+
+      def self.that_mean_true
+        ['up', 'upvote', 'like', 'liked', 'positive', 'yes', 'good', 'true', 1, true]
+      end
+
+      def self.that_mean_false
+        ['down', 'downvote', 'dislike', 'disliked', 'negative', 'no', 'bad', 'false', 0, false]
+      end
+
+      # check is word is a true or bad vote
+      # if the word is unknown, then it counts it as a true/good
+      # vote.  this exists to allow all voting to be good by default
+      def self.meaning_of word
+        !that_mean_false.include?(word)
+      end
+
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/issues_drop.rb

@@ -0,0 +1,61 @@
+module RedmineCrm
+  module Liquid
+    class IssuesDrop < ::Liquid::Drop
+      def initialize(issues)
+        @issues = issues
+      end
+
+      def before_method(id)
+        issue = @issues.where(:id => id).first || Issue.new
+        IssueDrop.new issue
+      end
+
+      def all
+        @all ||= @issues.map do |issue|
+          IssueDrop.new issue
+        end
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @issues.size
+      end
+    end
+
+    class IssueDrop < ::Liquid::Drop
+      include ActionView::Helpers::UrlHelper
+
+      delegate :id,
+               :subject,
+               :description,
+               :visible?,
+               :open?,
+               :start_date,
+               :due_date,
+               :overdue?,
+               :completed_percent,
+               :updated_on,
+               :created_on,
+               :to => :@issue
+
+      def initialize(issue)
+        @issue = issue
+      end
+
+      def link
+        link_to @issue.name, self.url
+      end
+
+      def url
+        Rails.application.routes.url_helpers.issue_path(@issue)
+      end
+
+      def author
+        @users ||= UsersDrop.new @issue.author
+      end
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/news_drop.rb

@@ -0,0 +1,45 @@
+module RedmineCrm
+  module Liquid
+    class NewssDrop < ::Liquid::Drop
+      def initialize(newss)
+        @newss = newss
+      end
+
+      def before_method(id)
+        news = @newss.where(:id => id).first || News.new
+        NewsDrop.new news
+      end
+
+      def last
+        NewsDrop.new News.last
+      end
+
+      def all
+        @all ||= @newss.map do |news|
+          NewsDrop.new news
+        end
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @newss.size
+      end
+    end
+
+    class NewsDrop < ::Liquid::Drop
+
+      delegate :id, :title, :summary, :description, :visible?, :commentable?, :to => :@news
+
+      def initialize(news)
+        @news = news
+      end
+
+      def author
+        UserDrop.new @news.author
+      end
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/projects_drop.rb

@@ -0,0 +1,78 @@
+module RedmineCrm
+  module Liquid
+    class ProjectsDrop < ::Liquid::Drop
+
+      def initialize(projects)
+        @projects = projects
+      end
+
+      def before_method(identifier)
+        project = @projects.where(:identifier => identifier).first || Project.new
+        ProjectDrop.new project
+      end
+
+      def all
+        @all ||= @projects.map do |project|
+          ProjectDrop.new project
+        end
+      end
+
+      def active
+        @active ||= @projects.select(&:active?).map do |project|
+          ProjectDrop.new project
+        end
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @projects.size
+      end
+    end
+
+    class ProjectDrop < ::Liquid::Drop
+      include ActionView::Helpers::UrlHelper
+
+      delegate :id,
+               :identifier,
+               :name,
+               :is_public,
+               :description,
+               :visible?,
+               :active?,
+               :archived?,
+               :short_description,
+               :start_date,
+               :due_date,
+               :overdue?,
+               :completed_percent,
+               :to => :@project
+
+      def initialize(project)
+        @project = project
+      end
+
+      def link
+        link_to @project.name, self.url
+      end
+
+      def url
+        Rails.application.routes.url_helpers.project_path(@project)
+      end
+
+      def issues
+        @issues ||= IssuesDrop.new @project.issues.visible
+      end
+
+      def users
+        @users ||= UsersDrop.new @project.users
+      end
+
+      def subprojects
+        @subprojects ||= ProjectsDrop.new @project.children
+      end
+    end
+  end
+end

data/lib/redmine_crm/liquid/drops/users_drop.rb

@@ -0,0 +1,59 @@
+module RedmineCrm
+  module Liquid
+    class UsersDrop < ::Liquid::Drop
+      def initialize(users)
+        @users = users
+      end
+
+      def before_method(login)
+        user = @users.where(:login => login).first || User.new
+        UserDrop.new user
+      end
+
+      def current
+        UserDrop.new User.current
+      end
+
+      def all
+        @all ||= @users.map do |user|
+          UserDrop.new user
+        end
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def size
+        @users.size
+      end
+    end
+
+    class UserDrop < ::Liquid::Drop
+
+      delegate :id, :name, :firstname, :lastname, :mail, :active?, :admin?, :logged?, :language, :to => :@user
+
+      def initialize(user)
+        @user = user
+      end
+
+      def avatar
+        ApplicationController.helpers.avatar(@user)
+      end
+
+      def permissions
+        roles = @user.memberships.collect { |m| m.roles }.flatten.uniq
+        roles << (@user.logged? ? Role.non_member : Role.anonymous)
+        roles.map(&:permissions).flatten.uniq.map(&:to_s)
+      end
+
+      def groups
+        @user.groups.map(&:name)
+      end
+
+      def projects
+        ProjectsDrop.new @user.memberships.map(&:project).flatten.select(&:visible?).uniq
+      end
+    end
+  end
+end