presenting 2.0.0 → 2.0.1

data/lib/presenting/search.rb

@@ -1,185 +1,185 @@
-module Presenting
-  class Search
-    include Presenting::Configurable
-
-    # I want to support three configuration formats:
-    #
-    #   Search.new(:fields => [:first_name, :last_name, :email])
-    #
-    #   Search.new(:fields => {
-    #    'first_name' => :equals,
-    #    'last_name' => :begins_with,
-    #    'email' => :not_null
-    #   })
-    #
-    #   Search.new(:fields => {
-    #    'fname' => {:sql => 'first_name', :pattern => :equals},
-    #    'lname' => {:sql => 'last_name', :pattern => :begins_with},
-    #    'email' => {:sql => 'email', :pattern => :not_null}
-    #   })
-    def fields=(obj)
-      case obj
-        when Array
-        obj.each do |name| fields << name end
-        
-        when Hash
-        obj.each do |k, v|
-          fields << {k => v}
-        end 
-      end
-    end
-    
-    def fields
-      @fields ||= FieldSet.new
-    end
-    
-    def to_sql(params, type = :simple)
-      send("to_#{type}_sql", params) unless params.blank?
-    end
-    
-    protected
-    
-    # handles a simple search where a given term is matched against a number of fields, and can match any of them.
-    # this is usually presented to the user as a single "smart" search box.
-    def to_simple_sql(term)
-      sql = fields.map(&:fragment).join(' OR ')
-      binds = fields.collect{|f| f.bind(term)}.compact
-      [sql, binds].flatten.compact
-    end
-    
-    # handles a search setup where a user may enter a search value for any field, and anything entered must match.
-    # this is usually presented to the user as a set of labeled search boxes.
-    #
-    # example field terms:
-    #   field_terms = {
-    #     'first_name' => {:value => 'Bob'}
-    #     'last_name' => {:value => 'Smith'}
-    #   }
-    #
-    def to_field_sql(field_terms)
-      searched_fields = fields.select{|f| field_terms[f.name] and not field_terms[f.name][:value].blank?}
-      unless searched_fields.empty?
-        sql = searched_fields.map(&:fragment).join(' AND ')
-        binds = searched_fields.collect{|f| f.bind(field_terms[f.name][:value])}
-
-        [sql, binds].flatten.compact
-      end
-    end
-    
-    class FieldSet < Array
-      def <<(val)
-        if val.is_a? Hash
-          k, v = *val.to_a.first
-          opts = v.is_a?(Hash) ? v : {:pattern => v}
-          opts[:name] = k
-        else
-          opts = {:name => val}
-        end
-        super Field.new(opts)
-      end
-    end
-    
-    # TODO: a field may require extra joins when it is searched on
-    # TODO: support more than just mysql (need access to a Connection for quoting and attribute conditions)
-    class Field
-      include Presenting::Configurable
-      
-      # required (this is what appears in the parameter hash)
-      attr_reader :name
-      def name=(val)
-        @name = val.to_s
-      end
-      
-      # sql field (default == name)
-      def sql
-        @sql ||= name
-      end
-      attr_writer :sql
-      
-      # a shortcut for common operator/bind_pattern combos
-      def pattern=(val)
-        case val
-        when :equals
-          self.operator = '= ?'
-          self.bind_pattern = '?'
-        when :begins_with
-          self.operator = 'LIKE ?'
-          self.bind_pattern = '?%'
-        when :ends_with
-          self.operator = 'LIKE ?'
-          self.bind_pattern = '%?'
-        when :contains
-          self.operator = 'LIKE ?'
-          self.bind_pattern = '%?%'
-        when :null
-          self.operator = 'IS NULL'
-        when :not_null
-          self.operator = 'IS NOT NULL'
-        when :true
-          self.operator = '= ?'
-          self.bind_pattern = true
-        when :false
-          self.operator = '= ?'
-          self.bind_pattern = false
-        when :less_than
-          self.operator = '< ?'
-        when :less_than_or_equal_to, :not_greater_than
-          self.operator = '<= ?'
-        when :greater_than
-          self.operator = '> ?'
-        when :greater_than_or_equal_to, :not_less_than
-          self.operator = '>= ?'
-        end
-      end
-      
-      # the format for comparison with :sql, with an optional bind for search terms
-      # '= ?', 'LIKE ?', 'IN (?)', etc.
-      def operator
-        @operator ||= '= ?'
-      end
-      attr_writer :operator
-      
-      # formats the term BEFORE binding into the sql
-      # e.g. '?', '?%', etc.
-      def bind_pattern
-        @bind_pattern ||= '?'
-      end
-      attr_writer :bind_pattern
-      
-      # composes the sql fragment
-      def fragment
-        "#{sql} #{operator}"
-      end
-      
-      # prepares the bindable term
-      def bind(term)
-        return nil unless operator.include?('?')
-        return bind_pattern unless bind_pattern.is_a? String
-        bind_pattern == '?' ? typecast(term) : bind_pattern.sub('?', typecast(term).to_s)
-      end
-      
-      # you can set a data type for the field, which will be used to convert
-      # parameter values. currently this is mostly useful for :time searches.
-      attr_accessor :type
-      
-      protected
-      
-      def typecast(val)
-        case type
-          when :date
-          val.is_a?(String) ?
-            (Time.zone ? Time.zone.parse(val) : Time.parse(val)).to_date :
-            val
-          
-          when :time, :datetime
-          val.is_a?(String) ?
-            (Time.zone ? Time.zone.parse(val) : Time.parse(val)) :
-            val
-
-          else
-          val.to_s.strip
-        end
-      end
-    end
-  end
-end
+module Presenting
+  class Search
+    include Presenting::Configurable
+
+    # I want to support three configuration formats:
+    #
+    #   Search.new(:fields => [:first_name, :last_name, :email])
+    #
+    #   Search.new(:fields => {
+    #    'first_name' => :equals,
+    #    'last_name' => :begins_with,
+    #    'email' => :not_null
+    #   })
+    #
+    #   Search.new(:fields => {
+    #    'fname' => {:sql => 'first_name', :pattern => :equals},
+    #    'lname' => {:sql => 'last_name', :pattern => :begins_with},
+    #    'email' => {:sql => 'email', :pattern => :not_null}
+    #   })
+    def fields=(obj)
+      case obj
+        when Array
+        obj.each do |name| fields << name end
+        
+        when Hash
+        obj.each do |k, v|
+          fields << {k => v}
+        end 
+      end
+    end
+    
+    def fields
+      @fields ||= FieldSet.new
+    end
+    
+    def to_sql(params, type = :simple)
+      send("to_#{type}_sql", params) unless params.blank?
+    end
+    
+    protected
+    
+    # handles a simple search where a given term is matched against a number of fields, and can match any of them.
+    # this is usually presented to the user as a single "smart" search box.
+    def to_simple_sql(term)
+      sql = fields.map(&:fragment).join(' OR ')
+      binds = fields.collect{|f| f.bind(term)}.compact
+      [sql, binds].flatten.compact
+    end
+    
+    # handles a search setup where a user may enter a search value for any field, and anything entered must match.
+    # this is usually presented to the user as a set of labeled search boxes.
+    #
+    # example field terms:
+    #   field_terms = {
+    #     'first_name' => {:value => 'Bob'}
+    #     'last_name' => {:value => 'Smith'}
+    #   }
+    #
+    def to_field_sql(field_terms)
+      searched_fields = fields.select{|f| field_terms[f.name] and not field_terms[f.name][:value].blank?}
+      unless searched_fields.empty?
+        sql = searched_fields.map(&:fragment).join(' AND ')
+        binds = searched_fields.collect{|f| f.bind(field_terms[f.name][:value])}
+
+        [sql, binds].flatten.compact
+      end
+    end
+    
+    class FieldSet < Array
+      def <<(val)
+        if val.is_a? Hash
+          k, v = *val.to_a.first
+          opts = v.is_a?(Hash) ? v : {:pattern => v}
+          opts[:name] = k
+        else
+          opts = {:name => val}
+        end
+        super Field.new(opts)
+      end
+    end
+    
+    # TODO: a field may require extra joins when it is searched on
+    # TODO: support more than just mysql (need access to a Connection for quoting and attribute conditions)
+    class Field
+      include Presenting::Configurable
+      
+      # required (this is what appears in the parameter hash)
+      attr_reader :name
+      def name=(val)
+        @name = val.to_s
+      end
+      
+      # sql field (default == name)
+      def sql
+        @sql ||= name
+      end
+      attr_writer :sql
+      
+      # a shortcut for common operator/bind_pattern combos
+      def pattern=(val)
+        case val
+        when :equals
+          self.operator = '= ?'
+          self.bind_pattern = '?'
+        when :begins_with
+          self.operator = 'LIKE ?'
+          self.bind_pattern = '?%'
+        when :ends_with
+          self.operator = 'LIKE ?'
+          self.bind_pattern = '%?'
+        when :contains
+          self.operator = 'LIKE ?'
+          self.bind_pattern = '%?%'
+        when :null
+          self.operator = 'IS NULL'
+        when :not_null
+          self.operator = 'IS NOT NULL'
+        when :true
+          self.operator = '= ?'
+          self.bind_pattern = true
+        when :false
+          self.operator = '= ?'
+          self.bind_pattern = false
+        when :less_than
+          self.operator = '< ?'
+        when :less_than_or_equal_to, :not_greater_than
+          self.operator = '<= ?'
+        when :greater_than
+          self.operator = '> ?'
+        when :greater_than_or_equal_to, :not_less_than
+          self.operator = '>= ?'
+        end
+      end
+      
+      # the format for comparison with :sql, with an optional bind for search terms
+      # '= ?', 'LIKE ?', 'IN (?)', etc.
+      def operator
+        @operator ||= '= ?'
+      end
+      attr_writer :operator
+      
+      # formats the term BEFORE binding into the sql
+      # e.g. '?', '?%', etc.
+      def bind_pattern
+        @bind_pattern ||= '?'
+      end
+      attr_writer :bind_pattern
+      
+      # composes the sql fragment
+      def fragment
+        "#{sql} #{operator}"
+      end
+      
+      # prepares the bindable term
+      def bind(term)
+        return nil unless operator.include?('?')
+        return bind_pattern unless bind_pattern.is_a? String
+        bind_pattern == '?' ? typecast(term) : bind_pattern.sub('?', typecast(term).to_s)
+      end
+      
+      # you can set a data type for the field, which will be used to convert
+      # parameter values. currently this is mostly useful for :time searches.
+      attr_accessor :type
+      
+      protected
+      
+      def typecast(val)
+        case type
+          when :date
+          val.is_a?(String) ?
+            (Time.zone ? Time.zone.parse(val) : Time.parse(val)).to_date :
+            val
+          
+          when :time, :datetime
+          val.is_a?(String) ?
+            (Time.zone ? Time.zone.parse(val) : Time.parse(val)) :
+            val
+
+          else
+          val.to_s.strip
+        end
+      end
+    end
+  end
+end

data/lib/presenting/sorting.rb

@@ -1,87 +1,87 @@
-module Presenting
-  class Sorting
-    include Presenting::Configurable
-    
-    # I want to support two configuration formats:
-    #
-    #   Sorting.new(:fields => [:first_name, :last_name, :email])
-    #
-    #   Sorting.new(:fields => {
-    #    'name' => 'CONCAT(first_name, last_name)',
-    #    'email' => 'email_address'
-    #   })
-    def fields=(obj)
-      case obj
-        when Array
-        obj.each do |name| fields << name end
-        
-        when Hash
-        obj.each do |k, v|
-          fields << {k => v}
-        end 
-      end
-    end
-    
-    def fields
-      @fields ||= FieldSet.new
-    end
-    
-    def to_sql(param)
-      fields.each do |field|
-        # search for and return the first known field
-        return "#{field.sql} #{desc_or_asc param[field.name]}" if param[field.name]
-      end unless param.blank?
-      # no known fields found
-      default
-    end
-    
-    # The default sorting, if no known fields are found in the parameters.
-    # Default sorting is specified by name/direction, using an array.
-    #
-    # Example:
-    #
-    #   @sorting.default = [:name, 'asc']
-    #
-    def default
-      @default ||= "#{fields.first.sql} ASC"
-    end
-    def default=(val)
-      @default = "#{fields.find{|f| f.name == val.first.to_s}.sql} #{desc_or_asc val.second}"
-    end
-    
-    protected
-    
-    def desc_or_asc(val)
-      val.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
-    end
-    
-    class FieldSet < Array
-      def <<(val)
-        if val.is_a? Hash
-          k, v = *val.to_a.first
-          opts = v.is_a?(Hash) ? v : {:sql => v}
-          opts[:name] = k
-        else
-          opts = {:name => val}
-        end
-        super Field.new(opts)
-      end
-    end
-    
-    class Field
-      include Presenting::Configurable
-      
-      # required (this is what appears in the parameter hash)
-      attr_reader :name
-      def name=(val)
-        @name = val.to_s
-      end
-
-      # sql field (default == name)
-      attr_writer :sql
-      def sql
-        @sql ||= self.name.to_s
-      end
-    end
-  end
-end
+module Presenting
+  class Sorting
+    include Presenting::Configurable
+    
+    # I want to support two configuration formats:
+    #
+    #   Sorting.new(:fields => [:first_name, :last_name, :email])
+    #
+    #   Sorting.new(:fields => {
+    #    'name' => 'CONCAT(first_name, last_name)',
+    #    'email' => 'email_address'
+    #   })
+    def fields=(obj)
+      case obj
+        when Array
+        obj.each do |name| fields << name end
+        
+        when Hash
+        obj.each do |k, v|
+          fields << {k => v}
+        end 
+      end
+    end
+    
+    def fields
+      @fields ||= FieldSet.new
+    end
+    
+    def to_sql(param)
+      fields.each do |field|
+        # search for and return the first known field
+        return "#{field.sql} #{desc_or_asc param[field.name]}" if param[field.name]
+      end unless param.blank?
+      # no known fields found
+      default
+    end
+    
+    # The default sorting, if no known fields are found in the parameters.
+    # Default sorting is specified by name/direction, using an array.
+    #
+    # Example:
+    #
+    #   @sorting.default = [:name, 'asc']
+    #
+    def default
+      @default ||= "#{fields.first.sql} ASC"
+    end
+    def default=(val)
+      @default = "#{fields.find{|f| f.name == val.first.to_s}.sql} #{desc_or_asc val.second}"
+    end
+    
+    protected
+    
+    def desc_or_asc(val)
+      val.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
+    end
+    
+    class FieldSet < Array
+      def <<(val)
+        if val.is_a? Hash
+          k, v = *val.to_a.first
+          opts = v.is_a?(Hash) ? v : {:sql => v}
+          opts[:name] = k
+        else
+          opts = {:name => val}
+        end
+        super Field.new(opts)
+      end
+    end
+    
+    class Field
+      include Presenting::Configurable
+      
+      # required (this is what appears in the parameter hash)
+      attr_reader :name
+      def name=(val)
+        @name = val.to_s
+      end
+
+      # sql field (default == name)
+      attr_writer :sql
+      def sql
+        @sql ||= self.name.to_s
+      end
+    end
+  end
+end

data/test/attribute_test.rb

@@ -1,61 +1,61 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class AttributeTest < Presenting::Test
-
-  def setup
-    @a = Presenting::Attribute.new
-  end
-
-  def test_assigning_a_symbol_name
-    @a.name = :foo
-    assert_equal "Foo", @a.name, "name is typecast to a string and titleized"
-    assert_equal :foo, @a.value, "value is assumed to be a symbol as well"
-  end
-  
-  def test_assigning_a_string_name
-    @a.name = "foo"
-    assert_equal "foo", @a.name, "name remains a string"
-    assert_equal "foo", @a.value, "value is assumed to be a string"
-  end
-  
-  def test_symbol_values
-    @a.value = :foo
-    assert_equal "bar", @a.value_from(stub('row', :foo => "bar")), "symbols are methods"
-  end
-  
-  def test_string_values
-    @a.value = "foo"
-    assert_equal "foo", @a.value_from(stub('row', :foo => "bar")), "strings are constant"
-  end
-  
-  def test_proc_values
-    @a.value = proc{|row| "hello"}
-    assert_equal "hello", @a.value_from(stub('row', :foo => "bar")), "procs are custom"
-  end
-  
-  def test_that_value_from_does_not_sanitizes_itself
-    @a.value = '<span>hello</span>'
-    @a.sanitize = true
-    assert_equal '<span>hello</span>', @a.value_from(nil)
-  end
-  
-  def test_hash_rows_with_symbol_values
-    @a.value = :foo
-    assert_equal 'bar', @a.value_from({:foo => 'bar'}), "symbols are hash keys"
-  end
-
-  def test_sanitize_is_default_true
-    assert @a.sanitize?
-  end
-  
-  def test_assigning_a_symbol_id
-    @a.id = :foo
-    assert_equal 'foo', @a.id
-  end
-  
-  def test_default_id_from_complex_name
-    @a.name = 'Hello, World!'
-    assert_equal 'hello_world', @a.id
-  end
-end
-
+require File.dirname(__FILE__) + '/test_helper'
+
+class AttributeTest < Presenting::Test
+
+  def setup
+    @a = Presenting::Attribute.new
+  end
+
+  def test_assigning_a_symbol_name
+    @a.name = :foo
+    assert_equal "Foo", @a.name, "name is typecast to a string and titleized"
+    assert_equal :foo, @a.value, "value is assumed to be a symbol as well"
+  end
+  
+  def test_assigning_a_string_name
+    @a.name = "foo"
+    assert_equal "foo", @a.name, "name remains a string"
+    assert_equal "foo", @a.value, "value is assumed to be a string"
+  end
+  
+  def test_symbol_values
+    @a.value = :foo
+    assert_equal "bar", @a.value_from(stub('row', :foo => "bar")), "symbols are methods"
+  end
+  
+  def test_string_values
+    @a.value = "foo"
+    assert_equal "foo", @a.value_from(stub('row', :foo => "bar")), "strings are constant"
+  end
+  
+  def test_proc_values
+    @a.value = proc{|row| "hello"}
+    assert_equal "hello", @a.value_from(stub('row', :foo => "bar")), "procs are custom"
+  end
+  
+  def test_that_value_from_does_not_sanitizes_itself
+    @a.value = '<span>hello</span>'
+    @a.sanitize = true
+    assert_equal '<span>hello</span>', @a.value_from(nil)
+  end
+  
+  def test_hash_rows_with_symbol_values
+    @a.value = :foo
+    assert_equal 'bar', @a.value_from({:foo => 'bar'}), "symbols are hash keys"
+  end
+
+  def test_sanitize_is_default_true
+    assert @a.sanitize?
+  end
+  
+  def test_assigning_a_symbol_id
+    @a.id = :foo
+    assert_equal 'foo', @a.id
+  end
+  
+  def test_default_id_from_complex_name
+    @a.name = 'Hello, World!'
+    assert_equal 'hello_world', @a.id
+  end
+end
+