ransack_ffcrm 0.6.0

data/lib/ransack/helpers/form_helper.rb

@@ -0,0 +1,75 @@
+module Ransack
+  module Helpers
+    module FormHelper
+
+      def search_form_for(record, options = {}, &proc)
+        if record.is_a?(Ransack::Search)
+          search = record
+          options[:url] ||= polymorphic_path(search.klass)
+        elsif record.is_a?(Array) && (search = record.detect {|o| o.is_a?(Ransack::Search)})
+          options[:url] ||= polymorphic_path(record.map {|o| o.is_a?(Ransack::Search) ? o.klass : o})
+        else
+          raise ArgumentError, "No Ransack::Search object was provided to search_form_for!"
+        end
+        options[:html] ||= {}
+        html_options = {
+          :class  => options[:as] ? "#{options[:as]}_search" : "#{search.klass.to_s.underscore}_search",
+          :id => options[:as] ? "#{options[:as]}_search" : "#{search.klass.to_s.underscore}_search",
+          :method => :get
+        }
+        options[:as] ||= 'q'
+        options[:html].reverse_merge!(html_options)
+        options[:builder] ||= FormBuilder
+
+        form_for(record, options, &proc)
+      end
+
+      def sort_link(search, attribute, *args)
+        raise TypeError, "First argument must be a Ransack::Search!" unless Search === search
+
+        search_params = params[:q] || {}.with_indifferent_access
+
+        attr_name = attribute.to_s
+
+        name = (args.size > 0 && !args.first.is_a?(Hash)) ? args.shift.to_s : Translate.attribute(attr_name, :context => search.context)
+
+        if existing_sort = search.sorts.detect {|s| s.name == attr_name}
+          prev_attr, prev_dir = existing_sort.name, existing_sort.dir
+        end
+
+        options = args.first.is_a?(Hash) ? args.shift.dup : {}
+        default_order = options.delete :default_order
+        current_dir = prev_attr == attr_name ? prev_dir : nil
+
+        if current_dir
+          new_dir = current_dir == 'desc' ? 'asc' : 'desc'
+        else
+          new_dir = default_order || 'asc'
+        end
+
+        html_options = args.first.is_a?(Hash) ? args.shift.dup : {}
+        css = ['sort_link', current_dir].compact.join(' ')
+        html_options[:class] = [css, html_options[:class]].compact.join(' ')
+        options.merge!(
+          :q => search_params.merge(:s => "#{attr_name} #{new_dir}")
+        )
+        link_to [ERB::Util.h(name), order_indicator_for(current_dir)].compact.join(' ').html_safe,
+                url_for(options),
+                html_options
+      end
+
+      private
+
+      def order_indicator_for(order)
+        if order == 'asc'
+          '▲'
+        elsif order == 'desc'
+          '▼'
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/ransack/helpers.rb

@@ -0,0 +1,2 @@
+require 'ransack/helpers/form_builder'
+require 'ransack/helpers/form_helper'

data/lib/ransack/locale/en.yml

@@ -0,0 +1,70 @@
+en:
+  ransack:
+    search: "search"
+    predicate: "predicate"
+    and: "and"
+    or: "or"
+    any: "any"
+    all: "all"
+    combinator: "combinator"
+    attribute: "attribute"
+    value: "value"
+    condition: "condition"
+    sort: "sort"
+    asc: "ascending"
+    desc: "descending"
+    predicates:
+      eq: "equals"
+      eq_any: "equals any"
+      eq_all: "equals all"
+      not_eq: "not equal to"
+      not_eq_any: "not equal to any"
+      not_eq_all: "not equal to all"
+      matches: "matches"
+      matches_any: "matches_any"
+      matches_all: "matches all"
+      does_not_match: "doesn't match"
+      does_not_match_any: "doesn't match any"
+      does_not_match_all: "doesn't match all"
+      lt: "less than"
+      lt_any: "less than any"
+      lt_all: "less than all"
+      lteq: "less than or equal to"
+      lteq_any: "less than or equal to any"
+      lteq_all: "less than or equal to all"
+      gt: "greater than"
+      gt_any: "greater than any"
+      gt_all: "greater than all"
+      gteq: "greater than or equal to"
+      gteq_any: "greater than or equal to any"
+      gteq_all: "greater than or equal to all"
+      in: "in"
+      in_any: "in any"
+      in_all: "in all"
+      not_in: "not in"
+      not_in_any: "not in any"
+      not_in_all: "not in all"
+      cont: "contains"
+      cont_any: "contains any"
+      cont_all: "contains all"
+      not_cont: "doesn't contain"
+      not_cont_any: "doesn't contain any"
+      not_cont_all: "doesn't contain all"
+      start: "starts with"
+      start_any: "starts with any"
+      start_all: "starts with all"
+      not_start: "doesn't start with"
+      not_start_any: "doesn't start with any"
+      not_start_all: "doesn't start with all"
+      end: "ends with"
+      end_any: "ends with any"
+      end_all: "ends with all"
+      not_end: "doesn't end with"
+      not_end_any: "doesn't end with any"
+      not_end_all: "doesn't end with all"
+      'true': "is true"
+      'false': "is false"
+      present: "is present"
+      blank: "is blank"
+      'null': "is null"
+      not_null: "is not null"

data/lib/ransack/naming.rb

@@ -0,0 +1,53 @@
+module Ransack
+  module Naming
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def persisted?
+      false
+    end
+
+    def to_key
+      nil
+    end
+
+    def to_param
+      nil
+    end
+
+    def to_model
+      self
+    end
+  end
+
+  class Name < String
+    attr_reader :singular, :plural, :element, :collection, :partial_path, :human, :param_key, :route_key, :i18n_key
+    alias_method :cache_key, :collection
+
+    def initialize
+      super("Search")
+      @singular = "search".freeze
+      @plural = "searches".freeze
+      @element = "search".freeze
+      @human = "Search".freeze
+      @collection = "ransack/searches".freeze
+      @partial_path = "#{@collection}/#{@element}".freeze
+      @param_key = "q".freeze
+      @route_key = "searches".freeze
+      @i18n_key = :ransack
+    end
+  end
+
+  module ClassMethods
+    def model_name
+      @_model_name ||= Name.new
+    end
+
+    def i18n_scope
+      :ransack
+    end
+  end
+
+end

data/lib/ransack/nodes/attribute.rb

@@ -0,0 +1,49 @@
+module Ransack
+  module Nodes
+    class Attribute < Node
+      include Bindable
+
+      attr_reader :name
+
+      delegate :blank?, :present?, :==, :to => :name
+      delegate :engine, :to => :context
+
+      def initialize(context, name = nil)
+        super(context)
+        self.name = name unless name.blank?
+      end
+
+      def name=(name)
+        @name = name
+        context.bind(self, name) unless name.blank?
+      end
+
+      def valid?
+        bound? && attr
+      end
+
+      def type
+        if ransacker
+          return ransacker.type
+        else
+          context.type_for(self)
+        end
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+        self.name == other.name
+      end
+      alias :== :eql?
+
+      def hash
+        self.name.hash
+      end
+
+      def persisted?
+        false
+      end
+
+    end
+  end
+end

data/lib/ransack/nodes/bindable.rb

@@ -0,0 +1,30 @@
+module Ransack
+  module Nodes
+    module Bindable
+
+      attr_accessor :parent, :attr_name
+
+      def attr
+        @attr ||= ransacker ? ransacker.attr_from(self) : context.table_for(parent)[attr_name]
+      end
+      alias :arel_attribute :attr
+
+      def ransacker
+        klass._ransackers[attr_name]
+      end
+
+      def klass
+        @klass ||= context.klassify(parent)
+      end
+
+      def bound?
+        attr_name.present? && parent.present?
+      end
+
+      def reset_binding!
+        @parent = @attr_name = @attr = @klass = nil
+      end
+
+    end
+  end
+end

data/lib/ransack/nodes/condition.rb

@@ -0,0 +1,212 @@
+module Ransack
+  module Nodes
+    class Condition < Node
+      i18n_word :attribute, :predicate, :combinator, :value
+      i18n_alias :a => :attribute, :p => :predicate, :m => :combinator, :v => :value
+
+      attr_accessor :predicate
+      attr_writer :is_default
+
+      class << self
+        def extract(context, key, values)
+          attributes, predicate = extract_attributes_and_predicate(key)
+          if attributes.size > 0
+            combinator = key.match(/_(or|and)_/) ? $1 : nil
+            condition = self.new(context)
+            condition.build(
+              :a => attributes,
+              :p => predicate.name,
+              :m => combinator,
+              :v => predicate.wants_array ? Array(values) : [values]
+            )
+            # TODO: Figure out what to do with multiple types of attributes, if anything.
+            # Tempted to go with "garbage in, garbage out" on this one
+            predicate.validate(condition.values, condition.default_type) ? condition : nil
+          end
+        end
+
+        private
+
+        def extract_attributes_and_predicate(key)
+          str = key.dup
+          name = Predicate.detect_and_strip_from_string!(str)
+          predicate = Predicate.named(name)
+          raise ArgumentError, "No valid predicate for #{key}" unless predicate
+          attributes = str.split(/_and_|_or_/)
+          [attributes, predicate]
+        end
+      end
+
+      def valid?
+        attributes.detect(&:valid?) && predicate && valid_arity? && predicate.validate(values, default_type) && valid_combinator?
+      end
+
+      def valid_arity?
+        values.size <= 1 || predicate.wants_array
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+      alias :a :attributes
+
+      def attributes=(args)
+        case args
+        when Array
+          args.each do |attr|
+            attr = Attribute.new(@context, attr)
+            self.attributes << attr if attr.valid?
+          end
+        when Hash
+          args.each do |index, attrs|
+            attr = Attribute.new(@context, attrs[:name])
+            self.attributes << attr if attr.valid?
+          end
+        else
+          raise ArgumentError, "Invalid argument (#{args.class}) supplied to attributes="
+        end
+      end
+      alias :a= :attributes=
+
+      def values
+        @values ||= []
+      end
+      alias :v :values
+
+      def values=(args)
+        case args
+        when Array
+          args.each do |val|
+            val = Value.new(@context, val)
+            self.values << val
+          end
+        when Hash
+          args.each do |index, attrs|
+            val = Value.new(@context, attrs[:value])
+            self.values << val
+          end
+        else
+          raise ArgumentError, "Invalid argument (#{args.class}) supplied to values="
+        end
+      end
+      alias :v= :values=
+
+      def combinator
+        @attributes.size > 1 ? @combinator : nil
+      end
+
+      def combinator=(val)
+        @combinator = ['and', 'or'].detect {|v| v == val.to_s} || nil
+      end
+      alias :m= :combinator=
+      alias :m :combinator
+
+      def build_attribute(name = nil)
+        Attribute.new(@context, name).tap do |attribute|
+          self.attributes << attribute
+        end
+      end
+
+      def build_value(val = nil)
+        Value.new(@context, val).tap do |value|
+          self.values << value
+        end
+      end
+
+      def value
+        predicate.wants_array ? values.map {|v| v.cast(default_type)} : values.first.cast(default_type)
+      end
+
+      def build(params)
+        params.with_indifferent_access.each do |key, value|
+          if key.match(/^(a|v|p|m)$/)
+            self.send("#{key}=", value)
+          end
+        end
+
+        self
+      end
+
+      def persisted?
+        false
+      end
+
+      def default?
+        @is_default
+      end
+
+      def key
+        @key ||= attributes.map(&:name).join("_#{combinator}_") + "_#{predicate.name}"
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+        self.attributes == other.attributes &&
+        self.predicate == other.predicate &&
+        self.values == other.values &&
+        self.combinator == other.combinator
+      end
+      alias :== :eql?
+
+      def hash
+        [attributes, predicate, values, combinator].hash
+      end
+
+      def predicate_name=(name)
+        self.predicate = Predicate.named(name)
+      end
+      alias :p= :predicate_name=
+
+      def predicate_name
+        predicate.name if predicate
+      end
+      alias :p :predicate_name
+
+      def arel_predicate
+        predicates = attributes.map do |attr|
+          attr.attr.send(predicate.arel_predicate, formatted_values_for_attribute(attr))
+        end
+
+        if predicates.size > 1
+          case combinator
+          when 'and'
+            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(predicates))
+          when 'or'
+            predicates.inject(&:or)
+          end
+        else
+          predicates.first
+        end
+      end
+
+      def validated_values
+        values.select {|v| predicate.validator.call(v.value)}
+      end
+
+      def casted_values_for_attribute(attr)
+        validated_values.map {|v| v.cast(predicate.type || attr.type)}
+      end
+
+      def formatted_values_for_attribute(attr)
+        formatted = casted_values_for_attribute(attr).map do |val|
+          val = attr.ransacker.formatter.call(val) if attr.ransacker && attr.ransacker.formatter
+          val = predicate.format(val)
+          val
+        end
+        predicate.wants_array ? formatted : formatted.first
+      end
+
+      def default_type
+        predicate.type || (attributes.first && attributes.first.type)
+      end
+
+      private
+
+      def valid_combinator?
+        attributes.size < 2 ||
+        ['and', 'or'].include?(combinator)
+      end
+
+    end
+  end
+end

data/lib/ransack/nodes/grouping.rb

@@ -0,0 +1,183 @@
+module Ransack
+  module Nodes
+    class Grouping < Node
+      attr_reader :conditions
+      attr_accessor :combinator
+      alias :m :combinator
+      alias :m= :combinator=
+
+      i18n_word :condition, :and, :or
+      i18n_alias :c => :condition, :n => :and, :o => :or
+
+      delegate :each, :to => :values
+
+      def initialize(context, combinator = nil)
+        super(context)
+        self.combinator = combinator.to_s if combinator
+      end
+
+      def persisted?
+        false
+      end
+
+      def translate(key, options = {})
+        super or Translate.attribute(key.to_s, options.merge(:context => context))
+      end
+
+      def conditions
+        @conditions ||= []
+      end
+      alias :c :conditions
+
+      def conditions=(conditions)
+        case conditions
+        when Array
+          conditions.each do |attrs|
+            condition = Condition.new(@context).build(attrs)
+            self.conditions << condition if condition.valid?
+          end
+        when Hash
+          conditions.each do |index, attrs|
+            condition = Condition.new(@context).build(attrs)
+            self.conditions << condition if condition.valid?
+          end
+        end
+
+        self.conditions.uniq!
+      end
+      alias :c= :conditions=
+
+      def [](key)
+        if condition = conditions.detect {|c| c.key == key.to_s}
+          condition
+        else
+          nil
+        end
+      end
+
+      def []=(key, value)
+        conditions.reject! {|c| c.key == key.to_s}
+        self.conditions << value
+      end
+
+      def values
+        conditions + groupings
+      end
+
+      def respond_to?(method_id)
+        super or begin
+          method_name = method_id.to_s
+          writer = method_name.sub!(/\=$/, '')
+          attribute_method?(method_name) ? true : false
+        end
+      end
+
+      def build_condition(opts = {})
+        new_condition(opts).tap do |condition|
+          self.conditions << condition
+        end
+      end
+
+      def new_condition(opts = {})
+        attrs = opts[:attributes] || 1
+        vals = opts[:values] || 1
+        condition = Condition.new(@context)
+        condition.predicate_name = opts[:predicate] || 'eq'
+        condition.is_default = true
+        attrs.times { condition.build_attribute }
+        vals.times { condition.build_value }
+        condition
+      end
+
+      def groupings
+        @groupings ||= []
+      end
+      alias :g :groupings
+
+      def groupings=(groupings)
+        case groupings
+        when Array
+          groupings.each do |attrs|
+            grouping_object = new_grouping(attrs)
+            self.groupings << grouping_object if grouping_object.values.any?
+          end
+        when Hash
+          groupings.each do |index, attrs|
+            grouping_object = new_grouping(attrs)
+            self.groupings << grouping_object if grouping_object.values.any?
+          end
+        else
+          raise ArgumentError, "Invalid argument (#{groupings.class}) supplied to groupings="
+        end
+      end
+      alias :g= :groupings=
+
+      def method_missing(method_id, *args)
+        method_name = method_id.to_s
+        writer = method_name.sub!(/\=$/, '')
+        if attribute_method?(method_name)
+          writer ? write_attribute(method_name, *args) : read_attribute(method_name)
+        else
+          super
+        end
+      end
+
+      def attribute_method?(name)
+        name = strip_predicate_and_index(name)
+        case name
+        when /^(g|c|m|groupings|conditions|combinator)=?$/
+          true
+        else
+          name.split(/_and_|_or_/).select {|n| !@context.attribute_method?(n)}.empty?
+        end
+      end
+
+      def build_grouping(params = {})
+        params ||= {}
+        new_grouping(params).tap do |new_grouping|
+          self.groupings << new_grouping
+        end
+      end
+
+      def new_grouping(params = {})
+        Grouping.new(@context).build(params)
+      end
+
+      def build(params)
+        params.with_indifferent_access.each do |key, value|
+          case key
+          when /^(g|c|m)$/
+            self.send("#{key}=", value)
+          else
+            write_attribute(key.to_s, value)
+          end
+        end
+        self
+      end
+
+      private
+
+      def write_attribute(name, val)
+        # TODO: Methods
+        if condition = Condition.extract(@context, name, val)
+          self[name] = condition
+        end
+      end
+
+      def read_attribute(name)
+        if self[name].respond_to?(:value)
+          self[name].value
+        else
+          self[name]
+        end
+      end
+
+      def strip_predicate_and_index(str)
+        string = str.split(/\(/).first
+        Predicate.detect_and_strip_from_string!(string)
+        string
+      end
+
+    end
+  end
+end

data/lib/ransack/nodes/node.rb

@@ -0,0 +1,34 @@
+module Ransack
+  module Nodes
+    class Node
+      attr_reader :context
+      delegate :contextualize, :to => :context
+      class_attribute :i18n_words
+      class_attribute :i18n_aliases
+      self.i18n_words = []
+      self.i18n_aliases = {}
+
+      class << self
+        def i18n_word(*args)
+          self.i18n_words += args.map(&:to_s)
+        end
+
+        def i18n_alias(opts = {})
+          self.i18n_aliases.merge! Hash[opts.map {|k, v| [k.to_s, v.to_s]}]
+        end
+      end
+
+      def initialize(context)
+        @context = context
+      end
+
+      def translate(key, options = {})
+        key = i18n_aliases[key.to_s] if i18n_aliases.has_key?(key.to_s)
+        if i18n_words.include?(key.to_s)
+          Translate.word(key)
+        end
+      end
+
+    end
+  end
+end