ransack 0.1.0

data/lib/ransack/nodes/grouping.rb

@@ -0,0 +1,207 @@
+module Ransack
+  module Nodes
+    class Grouping < Node
+      attr_reader :conditions
+      i18n_word :condition, :and, :or
+      i18n_alias :c => :condition, :n => :and, :o => :or
+
+      delegate :each, :to => :values
+
+      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 + ors + ands
+      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 = Predicate.named('eq')
+        attrs.times { condition.build_attribute }
+        vals.times { condition.build_value }
+        condition
+      end
+
+      def ands
+        @ands ||= []
+      end
+      alias :n :ands
+
+      def ands=(ands)
+        case ands
+        when Array
+          ands.each do |attrs|
+            and_object = And.new(@context).build(attrs)
+            self.ands << and_object if and_object.values.any?
+          end
+        when Hash
+          ands.each do |index, attrs|
+            and_object = And.new(@context).build(attrs)
+            self.ands << and_object if and_object.values.any?
+          end
+        else
+          raise ArgumentError, "Invalid argument (#{ands.class}) supplied to ands="
+        end
+      end
+      alias :n= :ands=
+
+      def ors
+        @ors ||= []
+      end
+      alias :o :ors
+
+      def ors=(ors)
+        case ors
+        when Array
+          ors.each do |attrs|
+            or_object = Or.new(@context).build(attrs)
+            self.ors << or_object if or_object.values.any?
+          end
+        when Hash
+          ors.each do |index, attrs|
+            or_object = Or.new(@context).build(attrs)
+            self.ors << or_object if or_object.values.any?
+          end
+        else
+          raise ArgumentError, "Invalid argument (#{ors.class}) supplied to ors="
+        end
+      end
+      alias :o= :ors=
+
+      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 /^(n|o|c|ands|ors|conditions)=?$/
+          true
+        else
+          name.split(/_and_|_or_/).select {|n| !@context.attribute_method?(n)}.empty?
+        end
+      end
+
+      def build_and(params = {})
+        params ||= {}
+        new_and(params).tap do |new_and|
+          self.ands << new_and
+        end
+      end
+
+      def new_and(params = {})
+        And.new(@context).build(params)
+      end
+
+      def build_or(params = {})
+        params ||= {}
+        new_or(params).tap do |new_or|
+          self.ors << new_or
+        end
+      end
+
+      def new_or(params = {})
+        Or.new(@context).build(params)
+      end
+
+      def build(params)
+        params.with_indifferent_access.each do |key, value|
+          case key
+          when /^(n|o|c)$/
+            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
+        Ransack::Configuration.predicate_keys.detect {|p| string.sub!(/_#{p}$/, '')}
+        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

data/lib/ransack/nodes/or.rb

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

data/lib/ransack/nodes/sort.rb

@@ -0,0 +1,39 @@
+module Ransack
+  module Nodes
+    class Sort < Node
+      attr_reader :name, :attr, :dir
+      i18n_word :asc, :desc
+
+      class << self
+        def extract(context, str)
+          attr, direction = str.split(/\s+/,2)
+          self.new(context).build(:name => attr, :dir => direction)
+        end
+      end
+
+      def build(params)
+        params.with_indifferent_access.each do |key, value|
+          if key.match(/^(name|dir)$/)
+            self.send("#{key}=", value)
+          end
+        end
+
+        self
+      end
+
+      def valid?
+        @attr
+      end
+
+      def name=(name)
+        @name = name
+        @attr = contextualize(name) unless name.blank?
+      end
+
+      def dir=(dir)
+        @dir = %w(asc desc).include?(dir) ? dir : 'asc'
+      end
+
+    end
+  end
+end

data/lib/ransack/nodes/value.rb

@@ -0,0 +1,120 @@
+module Ransack
+  module Nodes
+    class Value < Node
+      attr_reader :value_before_cast, :type
+      delegate :blank?, :to => :value_before_cast
+
+      def initialize(context, value = nil, type = nil)
+        super(context)
+        @value_before_cast = value
+        self.type = type if type
+      end
+
+      def value=(val)
+        @value_before_cast = value
+        @value = nil
+      end
+
+      def value
+        @value ||= cast_to_type(@value_before_cast, @type)
+      end
+
+      def persisted?
+        false
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+        self.value_before_cast == other.value_before_cast
+      end
+      alias :== :eql?
+
+      def hash
+        value_before_cast.hash
+      end
+
+      def type=(type)
+        @value = nil
+        @type = type
+      end
+
+      def cast_to_type(val, type)
+        case type
+        when :date
+          cast_to_date(val)
+        when :datetime, :timestamp, :time
+          cast_to_time(val)
+        when :boolean
+          cast_to_boolean(val)
+        when :integer
+          cast_to_integer(val)
+        when :float
+          cast_to_float(val)
+        when :decimal
+          cast_to_decimal(val)
+        else
+          cast_to_string(val)
+        end
+      end
+
+      def cast_to_date(val)
+        if val.respond_to?(:to_date)
+          val.to_date rescue nil
+        else
+          y, m, d = *[val].flatten
+          m ||= 1
+          d ||= 1
+          Date.new(y,m,d) rescue nil
+        end
+      end
+
+      # FIXME: doesn't seem to be casting, even with Time.zone.local
+      def cast_to_time(val)
+        if val.is_a?(Array)
+          Time.zone.local(*val) rescue nil
+        else
+          unless val.acts_like?(:time)
+            val = val.is_a?(String) ? Time.zone.parse(val) : val.to_time rescue val
+          end
+          val.in_time_zone
+        end
+      end
+
+      def cast_to_boolean(val)
+        if val.is_a?(String) && val.blank?
+          nil
+        else
+          Constants::TRUE_VALUES.include?(val)
+        end
+      end
+
+      def cast_to_string(val)
+        val.respond_to?(:to_s) ? val.to_s : String.new(val)
+      end
+
+      def cast_to_integer(val)
+        val.blank? ? nil : val.to_i
+      end
+
+      def cast_to_float(val)
+        val.blank? ? nil : val.to_f
+      end
+
+      def cast_to_decimal(val)
+        if val.blank?
+          nil
+        elsif val.class == BigDecimal
+          val
+        elsif val.respond_to?(:to_d)
+          val.to_d
+        else
+          val.to_s.to_d
+        end
+      end
+
+      def array_of_arrays?(val)
+        Array === val && Array === val.first
+      end
+    end
+  end
+end

data/lib/ransack/predicate.rb

@@ -0,0 +1,57 @@
+module Ransack
+  class Predicate
+    attr_reader :name, :arel_predicate, :type, :formatter, :validator, :compound
+
+    class << self
+      def named(name)
+        Configuration.predicates[name.to_s]
+      end
+
+      def for_attribute_name(attribute_name)
+        self.named(Configuration.predicate_keys.detect {|p| attribute_name.to_s.match(/_#{p}$/)})
+      end
+
+      def collection
+        Configuration.predicates.map {|k, v| [k, Translate.predicate(k)]}
+      end
+    end
+
+    def initialize(opts = {})
+      @name = opts[:name]
+      @arel_predicate = opts[:arel_predicate]
+      @type = opts[:type]
+      @formatter = opts[:formatter]
+      @validator = opts[:validator]
+      @compound = opts[:compound]
+    end
+
+    def format(vals)
+      if formatter
+        vals.select {|v| validator ? validator.call(v.value_before_cast) : !v.blank?}.
+             map {|v| formatter.call(v.value)}
+      else
+        vals.select {|v| validator ? validator.call(v.value_before_cast) : !v.blank?}.
+             map {|v| v.value}
+      end
+    end
+
+    def eql?(other)
+      self.class == other.class &&
+      self.name == other.name
+    end
+    alias :== :eql?
+
+    def hash
+      name.hash
+    end
+
+    def validate(vals)
+      if validator
+        vals.select {|v| validator.call(v.value_before_cast)}.any?
+      else
+        vals.select {|v| !v.blank?}.any?
+      end
+    end
+
+  end
+end