fat_free_crm 0.18.2 → 0.19.0

data/vendor/gems/ransack_ui-1.3.4/app/assets/stylesheets/ransack_ui_bootstrap/index.css

@@ -0,0 +1,3 @@
+/*
+ *= require_tree .
+ */

data/vendor/gems/ransack_ui-1.3.4/app/assets/stylesheets/ransack_ui_bootstrap/search.css.scss

@@ -0,0 +1,41 @@
+.ransack_search {
+  .remove_fields, .ransack_attribute, .ransack_predicate,
+  .ransack_query, .ransack_sort_order, .ransack_sort,
+  .btn-group-select {
+    margin: 0 5px;
+    vertical-align: middle;
+    margin-bottom: 0;
+  }
+
+  .btn-group-select { display: inline-block; }
+
+  .remove_fields {
+    margin-right: 4px;
+    img { margin-bottom: 4px; }
+    &:hover { opacity: 0.6; }
+  }
+  .remove_fields.btn {
+    padding: 0px 3px 2px;
+    &:hover { opacity: 1; }
+  }
+
+  .add_fields.btn {
+    margin-top: 20px;
+  }
+
+  .btn {
+    i    { line-height: 16px; }
+    span { margin-left: 5px; }
+  }
+  .btn-small { padding-left: 6px; }
+
+  .combinator { margin-bottom: 20px; }
+
+  .filters > p {
+    margin-top: 20px;
+  }
+
+  .fields.sort {
+    margin-bottom: 20px;
+  }
+}

data/vendor/gems/ransack_ui-1.3.4/app/views/ransack_ui/_condition_fields.html.erb

@@ -0,0 +1,15 @@
+<div class="fields condition" data-object-name="<%= f.object_name %>">
+  <%= link_to_remove_fields t('ransack.remove_condition'), f, options %>
+
+  <%= f.attribute_fields do |a| %>
+    <span class="fields" data-object-name="<%= f.object_name %>">
+    <%= a.attribute_select({}, :class => 'ransack_attribute') %>
+  <% end %>
+
+  <%= f.predicate_select({}, :class => 'ransack_predicate') %>
+
+  <%= f.value_fields do |v| %>
+    <span class="fields value" data-object-name="<%= f.object_name %>">
+    <%= v.text_field :value, :style => "width: 200px;", :class => "ransack_query" %>
+  <% end %>
+</div>

data/vendor/gems/ransack_ui-1.3.4/app/views/ransack_ui/_grouping_fields.html.erb

@@ -0,0 +1,16 @@
+<div class="fields well" data-object-name="<%= f.object_name %>">
+  <div class="combinator">
+    <% key = (f.object_name =~ /[0]/) ? :group_first : :group_rest %>
+    <% combinator = f.combinator_select({}, :class => 'ransack_combinator') %>
+    <%= t("ransack.#{key}", :combinator => combinator).html_safe %>
+  </div>
+
+  <div class="filters">
+    <% f.object.build_condition unless f.object.conditions.any? %>
+    <%= f.condition_fields do |c| %>
+      <%= render 'ransack_ui/condition_fields', :f => c, :options => options %>
+    <% end %>
+
+    <%= link_to_add_fields t('ransack.add_condition'), f, :condition, options %>
+  </div>
+</div>

data/vendor/gems/ransack_ui-1.3.4/app/views/ransack_ui/_search.html.erb

@@ -0,0 +1,29 @@
+<%= search_form_for @ransack_search, :url => (options[:url] || url_for(:action => :index)),
+  :html => {:method => :get, :class => "ransack_search"}, :remote => !!options[:remote] do |f| %>
+
+  <%= javascript_tag do %>
+    if (window.Ransack == null) { window.Ransack = {}; }
+    Ransack.alt_predicates_i18n = <%= I18n.translate(:"ransack.predicates.alt", :default => {}).to_json.html_safe %>;
+    Ransack.value_field_labels  = <%= f.labels_for_value_fields.to_json.html_safe %>
+  <% end %>
+
+  <div class="row">
+    <div class="span12 well">
+      <%= f.sort_fields do |s| %>
+        <%= render 'ransack_ui/sort_fields', :f => s %>
+      <% end %>
+
+      <%= f.grouping_fields do |g| %>
+        <%= render 'ransack_ui/grouping_fields', :f => g, :options => options %>
+      <% end %>
+
+      <%= link_to_add_fields t('ransack.add_group'), f, :grouping, options %>
+
+      <div class="pull-right">
+        <%= hidden_field_tag :distinct, '1' %>
+        <%= hidden_field_tag :page, '1' %>
+        <%= f.submit t('ransack.submit'), :class => 'btn btn-primary btn-large submit-search' %>
+      </div>
+    </div>
+  </div>
+<% end %>

data/vendor/gems/ransack_ui-1.3.4/app/views/ransack_ui/_sort_fields.html.erb

@@ -0,0 +1,4 @@
+<div class="fields sort">
+  <span class="sort_by">Sort by:</span>
+  <%= f.sort_select %>
+</div>

data/vendor/gems/ransack_ui-1.3.4/config/locales/en.yml

@@ -0,0 +1,24 @@
+en:
+  ransack:
+    predicates:
+      alt:
+        date:
+          lt: "is before"
+          lt_any: "is before any"
+          lt_all: "is before all"
+          lteq: "is before or on"
+          lteq_any: "is before or on any"
+          lteq_all: "is before or on all"
+          gt: "is after"
+          gt_any: "is after any"
+          gt_all: "is after all"
+          gteq: "is after or on"
+          gteq_any: "is after or on any"
+          gteq_all: "is after or on all"
+
+    submit: Search
+    add_group: Add a filter group
+    group_first: "Show results where %{combinator} of the following match:"
+    group_rest: "...and where %{combinator} of the following match:"
+    add_condition: Add a filter
+    remove_condition: Remove filter

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui.rb

@@ -0,0 +1,9 @@
+require "ransack_ui/version"
+require "ransack_ui/rails/engine"
+require "ransack_chronic"
+
+# Require ransack overrides
+require 'ransack_ui/adapters/active_record'
+Dir.glob(File.expand_path('../ransack_ui/ransack_overrides/**/*.rb', __FILE__)) {|f| require f }
+
+require "ransack"

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui/adapters/active_record.rb

@@ -0,0 +1,6 @@
+# Extend original ransack adapter first
+require 'ransack/constants'
+require 'ransack/adapters/active_record'
+
+require 'ransack_ui/adapters/active_record/base'
+ActiveRecord::Base.extend RansackUI::Adapters::ActiveRecord::Base

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui/adapters/active_record/base.rb

@@ -0,0 +1,46 @@
+module RansackUI
+  module Adapters
+    module ActiveRecord
+      module Base
+
+        def self.extended(base)
+          base.class_eval do
+            class_attribute :_ransackable_associations
+            class_attribute :_ransack_can_autocomplete
+            self._ransackable_associations ||= []
+            self._ransack_can_autocomplete = false
+          end
+        end
+
+        def has_ransackable_associations(associations)
+          self._ransackable_associations = associations
+        end
+
+        def ransack_can_autocomplete
+          self._ransack_can_autocomplete = true
+        end
+
+        # Return array of attributes with [name, type]
+        # (Default to :string type for ransackers)
+        def ransackable_attributes(auth_object = nil)
+          columns.map{|c| [c.name, c.type] } +
+          _ransackers.keys.map {|k,v| [k, v.type || :string] }
+        end
+
+        def ransackable_associations(auth_object = nil)
+          all_associations = reflect_on_all_associations.map {|a| a.name.to_s}
+          if self._ransackable_associations.any?
+            # Return intersection of all associations, and associations defined on the model
+            all_associations & self._ransackable_associations
+          else
+            all_associations
+          end
+        end
+
+        def ransortable_attributes(auth_object = nil)
+          ransackable_attributes(auth_object).map(&:first)
+        end
+      end
+    end
+  end
+end

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui/controller_helpers.rb

@@ -0,0 +1,18 @@
+module RansackUI
+  module ControllerHelpers
+    # Builds @ransack_search object from params[:q]
+    # Model class can be passed in or inferred from controller name.
+    #
+    # Should be used as a before_filter, e.g.:
+    #    before_filter :load_ransack_search, :only => :index
+    #
+    # Can also be called as a function if needed. Will return the search object.
+    #
+    def load_ransack_search(klass = nil)
+      klass ||= controller_path.classify.constantize
+      @ransack_search = klass.ransack(params[:q])
+      @ransack_search.build_grouping if @ransack_search.groupings.empty?
+      @ransack_search
+    end
+  end
+end

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui/rails/engine.rb

@@ -0,0 +1,21 @@
+require 'ransack_ui/view_helpers'
+require 'ransack_ui/controller_helpers'
+
+module RansackUI
+  module Rails
+    class Engine < ::Rails::Engine
+      initializer "ransack_ui.view_helpers" do
+        ActionView::Base.send :include, ViewHelpers
+      end
+
+      initializer "ransack_ui.controller_helpers" do
+        ActionController::Base.send :include, ControllerHelpers
+      end
+
+      config.before_configuration do
+        # Add images to be precompiled
+        ::Rails.application.config.assets.precompile += %w(ransack_ui/delete.png ransack_ui/calendar.png)
+      end
+    end
+  end
+end

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui/ransack_overrides/adapters/active_record/base.rb

@@ -0,0 +1,47 @@
+require 'ransack/adapters/active_record/base'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      module Base
+        # Return array of attributes with [name, type]
+        # (Default to :string type for ransackers)
+        def ransackable_attributes(auth_object = nil)
+          columns.map{|c| [c.name, c.type] } +
+          _ransackers.map {|k,v| [k, v.type || :string] }
+        end
+
+        def self.extended(base)
+          alias :search :ransack unless base.method_defined? :search
+          base.class_eval do
+            class_attribute :_ransackers
+            class_attribute :_ransackable_associations
+            class_attribute :_ransack_can_autocomplete
+            self._ransackers ||= {}
+            self._ransackable_associations ||= []
+            self._ransack_can_autocomplete = false
+          end
+        end
+
+        def has_ransackable_associations(associations)
+          self._ransackable_associations = associations
+        end
+
+        def ransack_can_autocomplete
+          self._ransack_can_autocomplete = true
+        end
+
+        def ransackable_associations(auth_object = nil)
+          all_associations = reflect_on_all_associations.map {|a| a.name.to_s}
+          if self._ransackable_associations.any?
+            # Return intersection of all associations, and associations defined on the model
+            all_associations & self._ransackable_associations
+          else
+            all_associations
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui/ransack_overrides/configuration.rb

@@ -0,0 +1,15 @@
+require 'ransack/configuration'
+
+module Ransack
+  Configuration.class_eval do
+    # Set default predicate options for predicate_select in form builder
+    # This is ignored if any options are passed
+    def default_predicates=(options)
+      self.options[:default_predicates] = options
+    end
+
+    def ajax_options=(options)
+      self.options[:ajax_options] = options
+    end
+  end
+end

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui/ransack_overrides/context.rb

@@ -0,0 +1,9 @@
+require 'ransack/context'
+
+module Ransack
+  Context.class_eval do
+    def ransackable_attribute?(str, klass)
+      klass.ransackable_attributes(auth_object).map(&:first).include? str
+    end
+  end
+end

data/vendor/gems/ransack_ui-1.3.4/lib/ransack_ui/ransack_overrides/helpers/form_builder.rb

@@ -0,0 +1,262 @@
+require 'ransack/helpers/form_builder'
+
+module Ransack
+  module Helpers
+    FormBuilder.class_eval do
+      cattr_accessor :cached_searchable_attributes_for_base
+      self.cached_searchable_attributes_for_base = {}
+
+      def attribute_select(options = {}, html_options = {})
+        raise ArgumentError, "attribute_select must be called inside a search FormBuilder!" unless object.respond_to?(:context)
+        options[:include_blank] = true unless options.has_key?(:include_blank)
+
+        # Set default associations set on model with 'has_ransackable_associations'
+        if options[:associations].nil?
+          options[:associations] = object.context.klass.ransackable_associations
+        end
+
+        bases = [''] + association_array(options[:associations])
+        if bases.size > 1
+          @template.select(
+            @object_name, :name,
+            @template.grouped_options_for_select(attribute_collection_for_bases(bases), object.name),
+            objectify_options(options), @default_options.merge(html_options)
+          )
+        else
+          @template.select(
+            @object_name, :name, attribute_collection_for_base(bases.first),
+            objectify_options(options), @default_options.merge(html_options)
+          )
+        end
+      end
+
+      def sort_select(options = {}, html_options = {})
+        raise ArgumentError, "sort_select must be called inside a search FormBuilder!" unless object.respond_to?(:context)
+        options[:include_blank] = true unless options.has_key?(:include_blank)
+        bases = [''] + association_array(options[:associations])
+        if bases.size > 1
+          @template.select(
+            @object_name, :name,
+            @template.grouped_options_for_select(attribute_collection_for_bases(bases), object.name),
+            objectify_options(options), @default_options.merge({:class => 'ransack_sort'}).merge(html_options)
+          ) + @template.collection_select(
+            @object_name, :dir, [['asc', object.translate('asc')], ['desc', object.translate('desc')]], :first, :last,
+            objectify_options(options.except(:include_blank)), @default_options.merge({:class => 'ransack_sort_order'}).merge(html_options)
+          )
+        else
+          # searchable_attributes now returns [c, type]
+          collection = object.context.searchable_attributes(bases.first).map do |c, type|
+            [
+              attr_from_base_and_column(bases.first, c),
+              Translate.attribute(attr_from_base_and_column(bases.first, c), :context => object.context)
+            ]
+          end
+          @template.collection_select(
+            @object_name, :name, collection, :first, :last,
+            objectify_options(options), @default_options.merge({:class => 'ransack_sort'}).merge(html_options)
+          ) + @template.collection_select(
+            @object_name, :dir, [['asc', object.translate('asc')], ['desc', object.translate('desc')]], :first, :last,
+            objectify_options(options.except(:include_blank)), @default_options.merge({:class => 'ransack_sort_order'}).merge(html_options)
+          )
+        end
+      end
+
+      def labels_for_value_fields
+        labels = {}
+
+        object.groupings.each do |grouping|
+          grouping.conditions.each do |condition|
+            condition.values.each do |value|
+              # If value is present, and the attribute is an association,
+              # load the selected record and include the record name as a data attribute
+              if value.value.present?
+                condition_attributes = condition.attributes
+                if condition_attributes.any?
+                  attribute = condition_attributes.first.name
+                  klass_name = foreign_klass_for_attribute(attribute)
+
+                  if klass_name
+                    klass = klass_name.constantize
+
+                    value_object = klass.find_by_id(value.value)
+                    if value_object
+                      labels[attribute] ||= {}
+
+                      if value_object.respond_to? :full_name
+                        labels[attribute][value.value] = value_object.full_name
+                      elsif value_object.respond_to? :name
+                        labels[attribute][value.value] = value_object.name
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        labels
+      end
+
+
+      def predicate_keys(options)
+        keys = options[:compounds] ? Predicate.names : Predicate.names.reject {|k| k.match(/_(any|all)$/)}
+        if only = options[:only]
+          if only.respond_to? :call
+            keys = keys.select {|k| only.call(k)}
+          else
+            only = Array.wrap(only).map(&:to_s)
+            # Create compounds hash, e.g. {"eq" => ["eq", "eq_any", "eq_all"], "blank" => ["blank"]}
+            key_groups = keys.inject(Hash.new([])){ |h,k| h[k.sub(/_(any|all)$/, '')] += [k]; h }
+            # Order compounds hash by 'only' keys
+            keys = only.map {|k| key_groups[k] }.flatten.compact
+          end
+        end
+        keys
+      end
+
+      def predicate_select(options = {}, html_options = {})
+        options = Ransack.options[:default_predicates] || {} if options.blank?
+
+        options[:compounds] = true if options[:compounds].nil?
+        keys = predicate_keys(options)
+        # If condition is newly built with build_condition(),
+        # then replace the default predicate with the first in the ordered list
+        @object.predicate_name = keys.first if @object.default?
+        @template.collection_select(
+          @object_name, :p, keys.map {|k| [k, Translate.predicate(k)]}, :first, :last,
+          objectify_options(options), @default_options.merge(html_options)
+        )
+      end
+
+      def attribute_collection_for_bases(bases)
+        bases.map do |base|
+          if collection = attribute_collection_for_base(base)
+            [
+              Translate.association(base, :context => object.context),
+              collection
+            ]
+          end
+        end.compact
+      end
+
+      def attribute_collection_for_base(base)
+        klass = object.context.traverse(base)
+        ajax_options = Ransack.options[:ajax_options] || {}
+
+        # Detect any inclusion validators to build list of options for a column
+        column_select_options = klass.validators.each_with_object({}) do |v, hash|
+          if v.is_a? ActiveModel::Validations::InclusionValidator
+            v.attributes.each do |a|
+              # Try to translate options from activerecord.attribute_options.<model>.<attribute>
+              inclusions = v.send(:delimiter)
+              inclusions = inclusions.call if inclusions.respond_to?(:call) # handle lambda
+              hash[a.to_s] = inclusions.each_with_object({}) do |o, options|
+                options[o.to_s] = I18n.translate("activerecord.attribute_options.#{klass.to_s.downcase}.#{a}.#{o}", :default => o.to_s.titleize)
+              end
+            end
+          end
+        end
+
+        if klass.respond_to?(:ransack_column_select_options)
+          column_select_options.merge!(klass.ransack_column_select_options)
+        end
+
+        searchable_attributes_for_base(base).map do |attribute_data|
+          column = attribute_data[:column]
+
+          html_options = {}
+
+          # Add column type as data attribute
+          html_options[:'data-type'] = attribute_data[:type]
+          # Set 'base' attribute if attribute is on base model
+          html_options[:'data-root-model'] = true if base.blank?
+
+          # Set column options if detected from inclusion validator
+          if column_select_options[column]
+            # Format options as an array of hashes with id and text columns, for Select2
+            html_options[:'data-select-options'] = column_select_options[column].map {|id, text|
+              {:id => id, :text => text}
+            }.to_json
+          end
+
+          foreign_klass = attribute_data[:foreign_klass]
+
+          if foreign_klass
+            # If field is a foreign key, set up 'data-ajax-*' attributes for auto-complete
+            controller = ActiveSupport::Inflector::tableize(foreign_klass.to_s)
+            html_options[:'data-ajax-entity'] = I18n.translate(controller, :default => controller)
+            if ajax_options[:url]
+              html_options[:'data-ajax-url'] = ajax_options[:url].sub(':controller', controller)
+            else
+              html_options[:'data-ajax-url'] = "/#{controller}.json"
+            end
+            html_options[:'data-ajax-type'] = ajax_options[:type] || 'GET'
+            html_options[:'data-ajax-key']  = ajax_options[:key]  || 'query'
+          end
+
+          [
+            attribute_data[:label],
+            attribute_data[:attribute],
+            html_options
+          ]
+        end
+      rescue UntraversableAssociationError => e
+        nil
+      end
+
+
+      private
+
+      def searchable_attributes_for_base(base)
+        cache_prefix = object.context.klass.table_name
+        cache_key = base.blank? ? cache_prefix : [cache_prefix, base].join('_')
+
+        self.class.cached_searchable_attributes_for_base[cache_key] ||= object.context.searchable_attributes(base).map do |column, type|
+          klass = object.context.traverse(base)
+          foreign_keys = klass.reflect_on_all_associations.select(&:belongs_to?).
+                           each_with_object({}) {|r, h| h[r.foreign_key.to_sym] = r.class_name }
+
+          # Don't show 'id' column for base model
+          next nil if base.blank? && column == 'id'
+
+          attribute = attr_from_base_and_column(base, column)
+          attribute_label = Translate.attribute(attribute, :context => object.context)
+
+          # Set model name as label for 'id' column on that model's table.
+          if column == 'id'
+            foreign_klass = object.context.traverse(base).model_name
+            # Check that model can autocomplete. If not, skip this id column.
+            next nil unless ActiveSupport::Inflector::constantize(foreign_klass.to_s)._ransack_can_autocomplete
+
+            attribute_label = I18n.translate(foreign_klass, :default => foreign_klass)
+          else
+            foreign_klass = foreign_keys[column.to_sym]
+          end
+
+          attribute_data = {
+            label: attribute_label,
+            type: type,
+            column: column,
+            attribute: attribute
+          }
+          attribute_data[:foreign_klass] = foreign_klass if foreign_klass
+          attribute_data
+        end.compact
+      end
+
+      def foreign_klass_for_attribute(attribute)
+        associations = object.context.klass.ransackable_associations
+        bases = [''] + association_array(associations)
+
+        bases.each do |base|
+          searchable_attributes_for_base(base).each do |attribute_data|
+            if attribute == attribute_data[:attribute]
+              return attribute_data[:foreign_klass]
+            end
+          end
+        end
+      end
+    end
+  end
+end