ransack 0.1.0

data/lib/ransack/helpers.rb

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

data/lib/ransack/helpers/form_builder.rb

@@ -0,0 +1,172 @@
+require 'action_view'
+
+module Ransack
+  module Helpers
+    class FormBuilder < ::ActionView::Helpers::FormBuilder
+      def label(method, *args, &block)
+        options = args.extract_options!
+        text = args.first
+        i18n = options[:i18n] || {}
+        text ||= object.translate(method, i18n.reverse_merge(:include_associations => true)) if object.respond_to? :translate
+        super(method, text, options, &block)
+      end
+
+      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)
+        bases = [''] + association_array(options[:associations])
+        if bases.size > 1
+          collection = bases.map do |base|
+            [
+              Translate.association(base, :context => object.context),
+              object.context.searchable_columns(base).map do |c|
+                [
+                  attr_from_base_and_column(base, c),
+                  Translate.attribute(attr_from_base_and_column(base, c), :context => object.context)
+                ]
+              end
+            ]
+          end
+          @template.grouped_collection_select(
+            @object_name, :name, collection, :last, :first, :first, :last,
+            objectify_options(options), @default_options.merge(html_options)
+          )
+        else
+          collection = object.context.searchable_columns(bases.first).map do |c|
+            [
+              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(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.any?
+          collection = bases.map do |base|
+            [
+              Translate.association(base, :context => object.context),
+              object.context.searchable_columns(base).map do |c|
+                [
+                  attr_from_base_and_column(base, c),
+                  Translate.attribute(attr_from_base_and_column(base, c), :context => object.context)
+                ]
+              end
+            ]
+          end
+          @template.grouped_collection_select(
+            @object_name, :name, collection, :last, :first, :first, :last,
+            objectify_options(options), @default_options.merge(html_options)
+          ) + @template.collection_select(
+            @object_name, :dir, [['asc', object.translate('asc')], ['desc', object.translate('desc')]], :first, :last,
+            objectify_options(options), @default_options.merge(html_options)
+          )
+        else
+          collection = object.context.searchable_columns(bases.first).map do |c|
+            [
+              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(html_options)
+          ) + @template.collection_select(
+            @object_name, :dir, [['asc', object.translate('asc')], ['desc', object.translate('desc')]], :first, :last,
+            objectify_options(options), @default_options.merge(html_options)
+          )
+        end
+      end
+
+      def sort_fields(*args, &block)
+        search_fields(:s, args, block)
+      end
+
+      def condition_fields(*args, &block)
+        search_fields(:c, args, block)
+      end
+
+      def and_fields(*args, &block)
+        search_fields(:n, args, block)
+      end
+
+      def or_fields(*args, &block)
+        search_fields(:o, args, block)
+      end
+
+      def attribute_fields(*args, &block)
+        search_fields(:a, args, block)
+      end
+
+      def predicate_fields(*args, &block)
+        search_fields(:p, args, block)
+      end
+
+      def value_fields(*args, &block)
+        search_fields(:v, args, block)
+      end
+
+      def search_fields(name, args, block)
+        args << {} unless args.last.is_a?(Hash)
+        args.last[:builder] ||= options[:builder]
+        args.last[:parent_builder] = self
+        options = args.extract_options!
+        objects = args.shift
+        objects ||= @object.send(name)
+        objects = [objects] unless Array === objects
+        name = "#{options[:object_name] || object_name}[#{name}]"
+        output = ActiveSupport::SafeBuffer.new
+        objects.each do |child|
+          output << @template.fields_for("#{name}[#{options[:child_index] || nested_child_index(name)}]", child, options, &block)
+        end
+        output
+      end
+
+      def predicate_select(options = {}, html_options = {})
+        @template.collection_select(
+          @object_name, :p, Predicate.collection, :first, :last,
+          objectify_options(options), @default_options.merge(html_options)
+        )
+      end
+
+      def combinator_select(options = {}, html_options = {})
+        @template.collection_select(
+          @object_name, :m, [['or', Translate.word(:or)], ['and', Translate.word(:and)]], :first, :last,
+          objectify_options(options), @default_options.merge(html_options)
+        )
+      end
+
+      private
+
+      def association_array(obj, prefix = nil)
+        ([prefix] + case obj
+        when Array
+          obj
+        when Hash
+          obj.map do |key, value|
+            case value
+            when Array, Hash
+              bases_array(value, key.to_s)
+            else
+              [key.to_s, [key, value].join('_')]
+            end
+          end
+        else
+          [obj]
+        end).compact.flatten.map {|v| [prefix, v].compact.join('_')}
+      end
+
+      def attr_from_base_and_column(base, column)
+        [base, column].reject {|v| v.blank?}.join('_')
+      end
+
+    end
+  end
+end

data/lib/ransack/helpers/form_helper.rb

@@ -0,0 +1,27 @@
+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[:html].reverse_merge!(html_options)
+        options[:builder] ||= FormBuilder
+
+        form_for(record, options, &proc)
+      end
+
+    end
+  end
+end

data/lib/ransack/locale/en.yml

@@ -0,0 +1,67 @@
+en:
+  ransack:
+    predicate: "predicate"
+    and: "and"
+    or: "or"
+    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.rb

@@ -0,0 +1,7 @@
+require 'ransack/nodes/node'
+require 'ransack/nodes/attribute'
+require 'ransack/nodes/value'
+require 'ransack/nodes/condition'
+require 'ransack/nodes/sort'
+require 'ransack/nodes/and'
+require 'ransack/nodes/or'

data/lib/ransack/nodes/and.rb

@@ -0,0 +1,8 @@
+require 'ransack/nodes/grouping'
+
+module Ransack
+  module Nodes
+    class And < Grouping
+    end
+  end
+end

data/lib/ransack/nodes/attribute.rb

@@ -0,0 +1,36 @@
+module Ransack
+  module Nodes
+    class Attribute < Node
+      attr_reader :name, :attr
+      delegate :blank?, :==, :to => :name
+
+      def initialize(context, name = nil)
+        super(context)
+        self.name = name unless name.blank?
+      end
+
+      def name=(name)
+        @name = name
+        @attr = contextualize(name) unless name.blank?
+      end
+
+      def valid?
+        @attr
+      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/condition.rb

@@ -0,0 +1,209 @@
+module Ransack
+  module Nodes
+    class Condition < Node
+      i18n_word :attribute, :predicate, :combinator, :value
+      i18n_alias :a => :attribute, :p => :predicate, :m => :combinator, :v => :value
+
+      attr_reader :predicate
+
+      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 => [values]
+            )
+            predicate.validate(condition.values) ? condition : nil
+          end
+        end
+
+        private
+
+        def extract_attributes_and_predicate(key)
+          str = key.dup
+          name = Ransack::Configuration.predicate_keys.detect {|p| str.sub!(/_#{p}$/, '')}
+          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) && valid_combinator?
+      end
+
+      def valid_arity?
+        values.size <= 1 || predicate.compound || %w(in not_in).include?(predicate.name)
+      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, current_type)
+            self.values << val
+          end
+        when Hash
+          args.each do |index, attrs|
+            val = Value.new(@context, attrs[:value], current_type)
+            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, current_type).tap do |value|
+          self.values << value
+        end
+      end
+
+      def value
+        predicate.compound ? values.map(&:value) : values.first.value
+      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
+
+        set_value_types!
+
+        self
+      end
+
+      def persisted?
+        false
+      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=(predicate)
+        @predicate = predicate
+        predicate
+      end
+
+      def predicate_name
+        predicate.name if predicate
+      end
+      alias :p :predicate_name
+
+      def apply_predicate
+        attributes = arel_attributes.compact
+
+        if attributes.size > 1
+          case combinator
+          when 'and'
+            Arel::Nodes::Grouping.new(Arel::Nodes::And.new(
+              attributes.map {|a| a.send(predicate.arel_predicate, predicate.format(values))}
+            ))
+          when 'or'
+            attributes.inject(attributes.shift.send(predicate.arel_predicate, predicate.format(values))) do |memo, a|
+              memo.or(a.send(predicate.arel_predicate, predicate.format(values)))
+            end
+          end
+        else
+          attributes.first.send(predicate.arel_predicate, predicate.format(values))
+        end
+      end
+
+      private
+
+      def set_value_types!
+        self.values.each {|v| v.type = current_type}
+      end
+
+      def current_type
+        if predicate && predicate.type
+          predicate.type
+        elsif attributes.size > 0
+          @context.type_for(attributes.first.attr)
+        end
+      end
+
+      def valid_combinator?
+        attributes.size < 2 ||
+        ['and', 'or'].include?(combinator)
+      end
+
+      def arel_attributes
+        attributes.map(&:attr)
+      end
+
+    end
+  end
+end