redmine_crm 0.0.23 → 0.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb1379b61856d4d51a73e61eaa2af2505559bc55
-  data.tar.gz: dac49994dbd3c6df0727e37b4f1739cdeeb11406
+  metadata.gz: 6d6a74714a588b75a1b20bac6fe594b49f7a9a4a
+  data.tar.gz: 62f613b4e7b8a7a038e1a5fe60b4b01ace29f5dd
 SHA512:
-  metadata.gz: 58cad6ac2a7c193331c40f8e897a9462573e4ee126f623b727b5623ec437a921a4b2227aba13b91d625b8d77c1d95fbce24b4b4a580baa4864b1472cb2da38dd
-  data.tar.gz: 70f067cf96642b3dab5d66469eef34daa4c52dd6dac4af215a2c026cc7c1e7551e8771299803c8db5cde6ffa6dd41b578f73a70bc7c89911b872a960114e80db
+  metadata.gz: f64b3cbdece3d040b6c7bf05f07e4b97961696988511e501ee55ad68eb9e0b590bf01f5eaa22b5dc4d1b8ad39cf1b1008621e65610a7b5ada5a146b3ef8fd831
+  data.tar.gz: 3747a6d7b4988592833ddf96fbce37981745cdcc1ed58befc9924d18d778d1ab791a749de0d36f0300e8dfef429d4cc49a9e620a807c26d8ced06ba1fa0ae300

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in redmine_crm.gemspec
-gemspec
+gemspec

data/doc/CHANGELOG

@@ -4,6 +4,10 @@ Redmine crm gem - general functions for plugins (tags, vote, viewing, currency)
 Copyright (C) 2011-2016 RedmineUP
 http://www.redminecrm.com/
 
+== 2016-11-12 v0.0.24
+
+* Liquid gem dependency
+
 == 2016-09-28 v0.0.23
 
 * Changed RUB sybmol

data/lib/redmine_crm.rb

@@ -1,17 +1,26 @@
-require "redmine_crm/version"
-
-require "redmine_crm/tag"
-require "redmine_crm/tag_list"
-require "redmine_crm/tagging"
-require "redmine_crm/rcrm_acts_as_taggable"
-require "redmine_crm/helpers/tags_helper"
-require "redmine_crm/currency"
-require "redmine_crm/money_helper"
-require "redmine_crm/rcrm_acts_as_votable"
-require "redmine_crm/rcrm_acts_as_voter"
-require "redmine_crm/vote"
-require "redmine_crm/voter"
-require "redmine_crm/rcrm_acts_as_viewed"
+require 'redmine_crm/version'
+
+require 'redmine_crm/acts_as_taggable/tag'
+require 'redmine_crm/acts_as_taggable/tag_list'
+require 'redmine_crm/acts_as_taggable/tagging'
+require 'redmine_crm/acts_as_taggable/rcrm_acts_as_taggable'
+require 'redmine_crm/acts_as_viewed/rcrm_acts_as_viewed'
+require 'redmine_crm/acts_as_votable/rcrm_acts_as_votable'
+require 'redmine_crm/acts_as_votable/rcrm_acts_as_voter'
+require 'redmine_crm/acts_as_votable/vote'
+require 'redmine_crm/acts_as_votable/voter'
+
+require 'redmine_crm/currency'
+require 'redmine_crm/helpers/tags_helper'
+require 'redmine_crm/money_helper'
+
+require 'liquid'
+require 'redmine_crm/liquid/filters/base'
+require 'redmine_crm/liquid/filters/arrays'
+require 'redmine_crm/liquid/drops/issues_drop'
+require 'redmine_crm/liquid/drops/news_drop'
+require 'redmine_crm/liquid/drops/projects_drop'
+require 'redmine_crm/liquid/drops/users_drop'
 
 if defined?(ActiveRecord::Base)
   ActiveRecord::Base.extend(RedmineCrm::ActsAsVotable::Votable)
@@ -19,9 +28,8 @@ if defined?(ActiveRecord::Base)
 end
 
 def requires_redmine_crm(arg)
-
   def compare_versions(requirement, current)
-    raise ArgumentError.new("wrong version format") unless check_version_format(requirement)
+    raise ArgumentError.new('wrong version format') unless check_version_format(requirement)
     requirement = requirement.split('.').collect(&:to_i)
     requirement <=> current.slice(0, requirement.size)
   end
@@ -33,11 +41,11 @@ def requires_redmine_crm(arg)
   arg = { :version_or_higher => arg } unless arg.is_a?(Hash)
   arg.assert_valid_keys(:version, :version_or_higher)
 
-  current = RedmineCrm::VERSION.split(".").map{|x| x.to_i}
+  current = RedmineCrm::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)
+      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 redmine_crm gem version #{req} or higher (you're using #{RedmineCrm::VERSION}).\n\033[31m[ERROR]\033[0m Please update with 'bundle update redmine_crm'." if Rails.logger
         abort "\033[31mRedmine requires redmine_crm gem version #{req} or higher (you're using #{RedmineCrm::VERSION}).\nPlease update with 'bundle update redmine_crm'.\033[0m"
@@ -53,9 +61,9 @@ def requires_redmine_crm(arg)
           abort "\033[31mRedmine requires redmine_crm gem version between #{req.first} and #{req.last} (you're using #{RedmineCrm::VERSION}).\nPlease update with 'bundle update redmine_crm'.\033[0m"
         end
       else
-        raise ArgumentError.new(":version option accepts a version string, an array or a range of versions")
+        raise ArgumentError.new(':version option accepts a version string, an array or a range of versions')
       end
     end
   end
   true
-end
+end

data/lib/redmine_crm/{rcrm_acts_as_taggable.rb → acts_as_taggable/rcrm_acts_as_taggable.rb}

@@ -1,31 +1,29 @@
 require 'active_record'
 
-# module ActiveRecord #:nodoc:
 module RedmineCrm
-  module Acts #:nodoc:
+  module ActsAsTaggable #:nodoc:
     module Taggable #:nodoc:
       def self.included(base)
         base.extend(ClassMethods)
       end
-      
+
       module ClassMethods
-        
         def taggable?
           false
         end
 
         def rcrm_acts_as_taggable
-          has_many :taggings, :as => :taggable, :dependent => :destroy, :class_name => '::RedmineCrm::Tagging'#, :include => :tag
-          has_many :tags, :through => :taggings, :class_name => '::RedmineCrm::Tag'
-          
+          has_many :taggings, :as => :taggable, :dependent => :destroy, :class_name => '::RedmineCrm::ActsAsTaggable::Tagging'
+          has_many :tags, :through => :taggings, :class_name => '::RedmineCrm::ActsAsTaggable::Tag'
+
           before_save :save_cached_tag_list
-          
+
           after_create :save_tags
           after_update :save_tags
-          
-          include RedmineCrm::Acts::Taggable::InstanceMethods
-          extend RedmineCrm::Acts::Taggable::SingletonMethods
-          
+
+          include RedmineCrm::ActsAsTaggable::Taggable::InstanceMethods
+          extend RedmineCrm::ActsAsTaggable::Taggable::SingletonMethods
+
           alias_method_chain :reload, :tag_list
 
           class_eval do
@@ -34,11 +32,11 @@ module RedmineCrm
             end
           end
         end
-        
+
         def cached_tag_list_column_name
-          "cached_tag_list"
+          'cached_tag_list'
         end
-        
+
         def set_cached_tag_list_column_name(value = nil, &block)
           define_attr_method :cached_tag_list_column_name, value, &block
         end
@@ -47,9 +45,9 @@ module RedmineCrm
         # === Options hash:
         # * <tt>:table_name</tt> - use a table name other than viewings
         # To be used during migration, but can also be used in other places
-        def create_taggable_table options = {}
-          tag_name_table      = options[:tags] || :tags
-          
+        def create_taggable_table(options = {})
+          tag_name_table = options[:tags] || :tags
+
           if !self.connection.table_exists?(tag_name_table)
             self.connection.create_table(tag_name_table) do |t|
               t.column :name, :string
@@ -61,89 +59,88 @@ module RedmineCrm
             self.connection.create_table(taggings_name_table) do |t|
               t.column :tag_id, :integer
               t.column :taggable_id, :integer
-              
+
               # You should make sure that the column created is
               # long enough to store the required class names.
               t.column :taggable_type, :string
-              
+
               t.column :created_at, :datetime
             end
 
             self.connection.add_index :taggings, :tag_id
             self.connection.add_index :taggings, [:taggable_id, :taggable_type]
           end
-
         end
-  
-        def drop_taggable_table options = {}
-          tag_name_table      = options[:tags] || :tags
+
+        def drop_taggable_table(options = {})
+          tag_name_table = options[:tags] || :tags
           if self.connection.table_exists?(tag_name_table)
             self.connection.drop_table tag_name_table
           end
+
           taggings_name_table = options[:taggings] || :taggings
           if self.connection.table_exists?(taggings_name_table)
             self.connection.drop_table taggings_name_table
           end
-
         end
       end
-      
+
       module SingletonMethods
-        #Return all avalible tags for a project or global
-        #Example: Question.available_tags(@project_id )
-        def available_tags(project=nil, limit=30)
+        # Return all avalible tags for a project or global
+        # Example: Question.available_tags(@project_id )
+        def available_tags(project = nil, limit = 30)
           scope = Tag.where({})
-          class_name = quote_value(base_class.name, nil)
+          class_name = quote_value(base_class.name)
           join = []
           join << "JOIN #{Tagging.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id "
-          join << "JOIN #{table_name} ON #{table_name}.id = #{Tagging.table_name}.taggable_id 
+          join << "JOIN #{table_name} ON #{table_name}.id = #{Tagging.table_name}.taggable_id
             AND #{Tagging.table_name}.taggable_type = #{class_name} "
-          if self.attribute_names.include? "project_id"
+          if self.attribute_names.include?('project_id')
             if project
-                join << "JOIN #{Project.table_name} ON #{Project.table_name}.id = #{table_name}.project_id"
+              join << "JOIN #{Project.table_name} ON #{Project.table_name}.id = #{table_name}.project_id"
             else
-                scope = scope.where("#{table_name}.project_id IS NULL")
+              scope = scope.where("#{table_name}.project_id IS NULL")
             end
           end
 
-          group_fields = ""
+          group_fields = ''
           group_fields << ", #{Tag.table_name}.created_at" if Tag.respond_to?(:created_at)
           group_fields << ", #{Tag.table_name}.updated_at" if Tag.respond_to?(:updated_at)
 
           scope = scope.joins(join.join(' '))
           scope = scope.select("#{Tag.table_name}.*, COUNT(DISTINCT #{Tagging.table_name}.taggable_id) AS count")
-          scope = scope.group("#{Tag.table_name}.id, #{Tag.table_name}.name #{group_fields} HAVING COUNT(*) > 0")
+          scope = scope.group("#{Tag.table_name}.id, #{Tag.table_name}.name #{group_fields}")
+          scope = scope.having('COUNT(*) > 0')
           scope = scope.order("#{Tag.table_name}.name")
           scope = scope.limit(limit) if limit
           scope
         end
         # Returns an array of related tags.
         # Related tags are all the other tags that are found on the models tagged with the provided tags.
-        # 
+        #
         # Pass either a tag, string, or an array of strings or tags.
-        # 
+        #
         # Options:
         #   :order - SQL Order how to order the tags. Defaults to "count DESC, tags.name".
         def find_related_tags(tags, options = {})
           tags = tags.is_a?(Array) ? TagList.new(tags.map(&:to_s)) : TagList.from(tags)
-          
+
           related_models = find_tagged_with(tags)
-          
+
           return [] if related_models.blank?
-          
+
           related_ids = related_models.map{|c| c.id }.join(",")
-          Tag.select( #find(:all, options.merge({
+          Tag.select(
             "#{Tag.table_name}.*, COUNT(#{Tag.table_name}.id) AS count").joins(
             "JOIN #{Tagging.table_name} ON #{Tagging.table_name}.taggable_type = '#{base_class.name}'
               AND  #{Tagging.table_name}.taggable_id IN (#{related_ids})
               AND  #{Tagging.table_name}.tag_id = #{Tag.table_name}.id").order(
             options[:order] || "count DESC, #{Tag.table_name}.name").group(
-            "#{Tag.table_name}.id, #{Tag.table_name}.name HAVING #{Tag.table_name}.name NOT IN (#{tags.map { |n| quote_value(n, nil) }.join(",")})")
-          # }))
+            "#{Tag.table_name}.id, #{Tag.table_name}.name HAVING #{Tag.table_name}.name NOT IN (#{tags.map { |n| quote_value(n) }.join(",")})")
         end
-        
+
         # Pass either a tag, string, or an array of strings or tags.
-        # 
+        #
         # Options:
         #   :exclude - Find models that are not tagged with the given tags
         #   :match_all - Find models that match all of the given tags, not just one
@@ -151,32 +148,32 @@ module RedmineCrm
         def find_tagged_with(*args)
           options = find_options_for_find_tagged_with(*args)
           options.blank? ? [] : select(options[:select]).where(options[:conditions]).joins(options[:joins]).order(options[:order]).to_a
-          # find(:all, options)
         end
+
         alias_method :tagged_with, :find_tagged_with
-        
+
         def find_options_for_find_tagged_with(tags, options = {})
           tags = tags.is_a?(Array) ? TagList.new(tags.map(&:to_s)) : TagList.from(tags)
           options = options.dup
-          
+
           return {} if tags.empty?
-          
+
           conditions = []
           conditions << sanitize_sql(options.delete(:conditions)) if options[:conditions]
-          
+
           taggings_alias, tags_alias = "#{table_name}_taggings", "#{table_name}_tags"
-          
+
           joins = [
-            "INNER JOIN #{Tagging.table_name} #{taggings_alias} ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}",
+            "INNER JOIN #{Tagging.table_name} #{taggings_alias} ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}",
             "INNER JOIN #{Tag.table_name} #{tags_alias} ON #{tags_alias}.id = #{taggings_alias}.tag_id"
           ]
-          
+
           if options.delete(:exclude)
             conditions << <<-END
               #{table_name}.id NOT IN
                 (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name}
                  INNER JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id
-                 WHERE #{tags_condition(tags)} AND #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name, nil)})
+                 WHERE #{tags_condition(tags)} AND #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})
             END
           else
             if options.delete(:match_all)
@@ -185,23 +182,23 @@ module RedmineCrm
               conditions << tags_condition(tags, tags_alias)
             end
           end
-          
+
           { :select => "DISTINCT #{table_name}.* ",
             :joins => joins.join(" "),
             :conditions => conditions.join(" AND ")
           }.reverse_merge!(options)
         end
-        
+
         def joins_for_match_all_tags(tags)
           joins = []
-          
+
           tags.each_with_index do |tag, index|
             taggings_alias, tags_alias = "taggings_#{index}", "tags_#{index}"
 
             join = <<-END
               INNER JOIN #{Tagging.table_name} #{taggings_alias} ON
                 #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND
-                #{taggings_alias}.taggable_type = #{quote_value(base_class.name, nil)}
+                #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}
 
               INNER JOIN #{Tag.table_name} #{tags_alias} ON
                 #{taggings_alias}.tag_id = #{tags_alias}.id AND
@@ -210,12 +207,12 @@ module RedmineCrm
 
             joins << sanitize_sql([join, tag])
           end
-          
-          joins.join(" ")
+
+          joins.join(' ')
         end
-        
+
         # Calculate the tag counts for all tags.
-        # 
+        #
         # See Tag.counts for available options.
         def tag_counts(options = {})
           # Tag.find(:all, find_options_for_tag_counts(options))
@@ -223,35 +220,39 @@ module RedmineCrm
           Tag.select(opt[:select]).where(opt[:conditions]).joins(opt[:joins]).group(opt[:group]).having(opt[:having]).order(opt[:order]).limit(options[:limit])
         end
         alias_method :all_tag_counts, :tag_counts
-        
+
         def find_options_for_tag_counts(options = {})
           options = options.dup
           scope = scope_attributes
           # scope(:find)
-          
+
           conditions = []
           conditions << send(:sanitize_conditions, options.delete(:conditions)) if options[:conditions]
-          conditions << send(:sanitize_conditions, scope) if scope 
-          conditions << "#{Tagging.table_name}.taggable_type = #{quote_value(base_class.name, nil)}"
-          conditions << type_condition unless descends_from_active_record? 
+          conditions << send(:sanitize_conditions, scope) if scope
+          conditions << "#{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)}"
+          conditions << type_condition unless descends_from_active_record?
           conditions.compact!
           conditions = conditions.join(" AND ")
-          
+
           joins = ["INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"]
           joins << options.delete(:joins) if options[:joins].present?
           # joins << scope[:joins] if scope && scope[:joins].present?
           joins = joins.join(" ")
-          
+
           options = { :conditions => conditions, :joins => joins }.update(options)
-          
+
           Tag.options_for_counts(options)
         end
 
         def caching_tag_list?
           column_names.include?(cached_tag_list_column_name)
         end
-        
+
        private
+        def quote_value(object)
+          sanitize(object)
+        end
+
         def tags_condition(tags, table_name = Tag.table_name)
           condition = tags.map { |t| sanitize_sql(["#{table_name}.name LIKE ?", t]) }.join(" OR ")
           "(" + condition + ")" unless condition.blank?
@@ -270,39 +271,39 @@ module RedmineCrm
           "(#{segments.join(') AND (')})" unless segments.empty?
         end
       end
-      
+
       module InstanceMethods
         def tag_list
-          return @tag_list if @tag_list
-          
-          if self.class.caching_tag_list? and !(cached_value = send(self.class.cached_tag_list_column_name)).nil?
+          return @tag_list if @tag_list ||= nil
+
+          if self.class.caching_tag_list? && !(cached_value = send(self.class.cached_tag_list_column_name)).nil?
             @tag_list = TagList.from(cached_value)
           else
             @tag_list = TagList.new(*tags.map(&:name))
           end
         end
-        
+
         def tag_list=(value)
           @tag_list = TagList.from(value)
         end
-        
+
         def save_cached_tag_list
           if self.class.caching_tag_list?
             self[self.class.cached_tag_list_column_name] = tag_list.to_s
           end
         end
-        
+
         #build list from related tags
         def all_tags_list
           tags.pluck(:name)
         end
-        
+
         def save_tags
           return unless @tag_list
-          
+
           new_tag_names = @tag_list - tags.map(&:name)
           old_tags = tags.reject { |tag| @tag_list.include?(tag.name) }
-          
+
           self.class.transaction do
             if old_tags.any?
               taggings.where("tag_id IN (?)", old_tags.map(&:id)).each(&:destroy)
@@ -312,20 +313,20 @@ module RedmineCrm
               tags << Tag.find_or_create_with_like_by_name(new_tag_name)
             end
           end
-          
+
           true
         end
-        
+
         # Calculate the tag counts for the tags used by this model.
         #
         # The possible options are the same as the tag_counts class method.
         def tag_counts(options = {})
           return [] if tag_list.blank?
-          
+
           options[:conditions] = self.class.send(:merge_conditions, options[:conditions], self.class.send(:tags_condition, tag_list))
           self.class.tag_counts(options)
         end
-        
+
         def reload_with_tag_list(*args) #:nodoc:
           @tag_list = nil
           reload_without_tag_list(*args)
@@ -335,4 +336,9 @@ module RedmineCrm
   end
 end
 
-ActiveRecord::Base.send(:include, RedmineCrm::Acts::Taggable)
+ActiveRecord::Base.send(:include, RedmineCrm::ActsAsTaggable::Taggable)
+
+# Class aliases
+RedmineCrm::Tag = RedmineCrm::ActsAsTaggable::Tag
+RedmineCrm::TagList = RedmineCrm::ActsAsTaggable::TagList
+RedmineCrm::Tagging = RedmineCrm::ActsAsTaggable::Tagging