presenting 1.0.0

data/lib/presenting/search.rb

@@ -0,0 +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

data/lib/presenting/sorting.rb

@@ -0,0 +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

data/lib/presenting/view.rb

@@ -0,0 +1,3 @@
+class Presenting::View < ActionView::Base
+  delegate :protect_against_forgery?, :form_authenticity_token, :to => :controller
+end

data/lib/presenting.rb

@@ -0,0 +1,9 @@
+module Presenting
+  # prior to Rails 2.3, you need to call this manually from your config/routes.rb
+  def self.draw_routes(map)
+    map.namespace(:presentation) do |presentation|
+      presentation.stylesheet 'stylesheets/:id.css', :controller => 'assets', :action => 'stylesheet', :format => 'css'
+      presentation.javascript 'javascript/:id.js', :controller => 'assets', :action => 'javascript', :format => 'js'
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,12 @@
+ActionView::Base.class_eval { include Presenting::Helpers }
+ActionController::Base.const_set(:Search, Presenting::Search)
+ActionController::Base.const_set(:Sorting, Presenting::Sorting)
+ActionView::Helpers::FormBuilder.class_eval { include Presenting::FormHelpers }
+
+if defined? Rails # because tests don't define the Rails module
+  if Rails.version.match(/^2\.2/)
+    ActionController::Base.view_paths << File.join(File.dirname(__FILE__), 'app', 'views')
+    ActiveSupport::Dependencies.load_paths << File.dirname(__FILE__) + '/app/controllers'
+    $LOAD_PATH.unshift File.dirname(__FILE__) + '/app/controllers/'
+  end
+end

data/test/assets_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'action_controller/test_case'
+require 'action_controller/integration'
+
+class Presentation::AssetsControllerTest < ActionController::TestCase
+
+  def setup
+    ActionController::Base.perform_caching = false
+  end
+
+  # stylesheet
+
+  def test_stylesheet_routing_recognition
+    assert_recognizes({:controller => "presentation/assets", :action => "stylesheet", :id => "foo", :format => "css"}, "/presentation/stylesheets/foo.css")
+  end
+  
+  def test_stylesheet_routing_generation
+    assert_generates "/presentation/stylesheets/foo.css", {:controller => "presentation/assets", :action => "stylesheet", :id => "foo", :format => "css"}
+  end
+  
+  def test_named_stylesheet_routes
+    assert_equal "/presentation/stylesheets/foo.css", presentation_stylesheet_path("foo", :format => 'css')
+  end
+
+  def test_retrieving_a_named_stylesheet
+    get :stylesheet, :id => 'grid', :format => 'css'
+    assert_response :success
+    assert_equal @response.body, File.read(File.join(PLUGIN_ROOT, 'app', 'assets', 'stylesheets', 'grid.css'))
+  end
+  
+  def test_retrieving_multiple_named_stylesheets
+    get :stylesheet, :id => 'grid,form', :format => 'css'
+    assert_response :success
+    assert @response.body.include?(File.read(File.join(PLUGIN_ROOT, 'app', 'assets', 'stylesheets', 'grid.css')))
+    assert @response.body.include?(File.read(File.join(PLUGIN_ROOT, 'app', 'assets', 'stylesheets', 'form.css')))
+  end
+  
+  # javascript
+
+  def test_javascript_routing_recognition
+    assert_recognizes({:controller => "presentation/assets", :action => "javascript", :id => "foo", :format => "js"}, "/presentation/javascript/foo.js")
+  end
+  
+  def test_javascript_routing_generation
+    assert_generates "/presentation/javascript/foo.js", {:controller => "presentation/assets", :action => "javascript", :id => "foo", :format => "js"}
+  end
+  
+  def test_named_javascript_routes
+    assert_equal "/presentation/javascript/foo.js", presentation_javascript_path("foo", :format => 'js')
+  end
+  
+  def test_retrieving_multiple_named_javascripts
+    get :javascript, :id => 'grid,search', :format => 'js'
+    assert_response :success
+    assert @response.body.include?(File.read(File.join(PLUGIN_ROOT, 'app', 'assets', 'javascript', 'grid.js')))
+    assert @response.body.include?(File.read(File.join(PLUGIN_ROOT, 'app', 'assets', 'javascript', 'search.js')))
+  end
+end

data/test/attribute_test.rb

@@ -0,0 +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
+

data/test/configurable_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ConfigurableTest < Presenting::Test
+  class ConfigurableUser
+    include Presenting::Configurable
+    attr_accessor :first_name
+    attr_reader   :name
+  end
+  
+  def test_setting_first_name_with_initializer
+    user = ConfigurableUser.new(:first_name => "Bob")
+    assert_equal 'Bob', user.first_name
+  end
+  
+  def test_setting_unsettable_attribute
+    assert_raises NoMethodError do
+      ConfigurableUser.new(:name => 'Bob Jenkins')
+    end
+  end
+end

data/test/details_test.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DetailsTest < Presenting::Test
+  def setup
+    @d = Presentation::Details.new
+  end
+  
+  def test_adding_a_field_by_name
+    @d.fields = ["foo"]
+    assert_equal "foo", @d.fields.first.name, "name is stringified"
+    assert_equal "foo", @d.fields.first.value, "value is assumed to be a method"
+  end
+  
+  def test_adding_a_field_by_name_and_value
+    @d.fields = [{"foo" => :bar}]
+    assert_equal "foo", @d.fields.first.name, "key is name"
+    assert_equal :bar, @d.fields.first.value, "value is value"
+  end
+  
+  def test_adding_a_field_by_name_and_options
+    @d.fields = [{"foo" => {:value => :bar}}]
+    assert_equal "foo", @d.fields.first.name, "key is name"
+    assert_equal :bar, @d.fields.first.value, "value is found and saved"
+  end
+end
+
+class DetailsRenderTest < Presentation::RenderTest
+  def setup
+    @presentation = Presentation::Details.new
+    @presentation.presentable = stub('user', :name => 'foo', :email => 'foo@example.com')
+    @presentation.controller = TestController.new
+  end
+  
+  def test_rendering_a_title
+    @presentation.title = 'Hello World'
+    
+    assert_select '.presentation-details h3', 'Hello World'
+  end
+  
+  def test_rendering_an_attribute
+    @presentation.fields = [:email]
+    
+    assert_select '.presentation-details' do
+      assert_select 'dl' do
+        assert_select 'dt', 'Email'
+        assert_select 'dd', 'foo@example.com'
+      end
+    end
+  end
+  
+  def test_rendering_sanitized_data
+    @presentation.fields = [
+      {:email => {:sanitize => false}},
+      {:name  => {:sanitize => true}}
+    ]
+    @presentation.presentable = stub('user', :name => '&', :email => '&')
+    
+    assert_select '.presentation-details' do
+      assert_select 'dl' do
+        assert_select 'dt:nth-of-type(1)', 'Email'
+        assert_select 'dd:nth-of-type(1)', '&'
+        
+        assert_select 'dt:nth-of-type(2)', 'Name'
+        assert_select 'dd:nth-of-type(2)', '&amp;'
+      end
+    end
+  end
+end

data/test/field_search_test.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FieldSearchTest < Presenting::Test
+  def setup
+    @s = Presentation::FieldSearch.new
+  end
+
+  def test_adding_a_field_by_name
+    @s.fields = [:foo]
+    assert_equal "Foo", @s.fields.first.name
+    assert_equal :text, @s.fields.first.type
+  end
+
+  def test_adding_a_field_by_name_and_type
+    @s.fields = [{"foo" => :bar}]
+    assert_equal "foo", @s.fields.first.name
+    assert_equal :bar, @s.fields.first.type
+  end
+
+  def test_adding_a_field_by_name_and_options
+    @s.fields = [{"foo" => {:type => :bar}}]
+    assert_equal "foo", @s.fields.first.name
+    assert_equal :bar, @s.fields.first.type
+  end
+end
+
+class FieldSearchFieldTest < Presenting::Test
+  def setup
+    @f = Presentation::FieldSearch::Field.new
+  end
+
+  def test_assigning_a_symbol_name
+    @f.name = :foo
+    assert_equal "Foo", @f.name, "name is typecast to a string and titleized"
+  end
+
+  def test_assigning_a_string_name
+    @f.name = "foo"
+    assert_equal "foo", @f.name, "name remains a string"
+  end
+
+  def test_default_type
+    assert_equal :text, @f.type
+  end
+end
+
+class FieldSearchRenderingTest < Presentation::RenderTest
+  def setup
+    @presentation = Presentation::FieldSearch.new
+    @presentation.controller = TestController.new
+    @presentation.controller.request.path = '/users'
+  end
+
+  def test_rendering_a_form_reuses_current_path
+    assert_select 'form[action=/users?][method=get]'
+  end
+
+  def test_rendering_a_text_field
+    @presentation.fields << {:foo => :text}
+    assert_select "form input[type=text][name='search[foo][value]']"
+  end
+
+  def test_rendering_a_text_field_with_existing_value
+    @presentation.fields << {:foo => :text}
+    @presentation.controller.params[:search] = {'foo' => {:value => 'bar'}}
+    assert_select "form input[type=text][name='search[foo][value]'][value=bar]"
+  end
+
+  def test_rendering_a_checkbox_field
+    @presentation.fields << {:foo => :checkbox}
+    assert_select "form input[type=checkbox][name='search[foo][value]'][value=1]"
+  end
+
+  def test_rendering_a_checkbox_field_with_existing_value
+    @presentation.fields << {:foo => :checkbox}
+    @presentation.controller.params[:search] = {'foo' => {:value => '1'}}
+
+    assert_select "form input[type=checkbox][name='search[foo][value]'][value=1][checked=checked]"
+  end
+
+  def test_rendering_a_dropdown_field_with_existing_value
+    @presentation.fields << {:foo => {:type => :dropdown, :options => [["Dollar", "$"], ["Kroner", "DKK"]]}}
+    @presentation.controller.params[:search] = {'foo' => {:value => 'DKK'}}
+
+    assert_select "form select[name='search[foo][value]']" do
+      assert_select "option[value='$']"
+      assert_select "option[value='$'][selected='selected']", false
+      assert_select "option[value='DKK'][selected='selected']"
+    end
+  end
+
+  def test_rendering_a_dropdown_field_with_integers_and_existing_value
+    @presentation.fields << {:foo => {:type => :dropdown, :options => [["Dollar", 1], ["Kroner", 2]]}}
+    @presentation.controller.params[:search] = {'foo' => {:value => '2'}}
+
+    assert_select "form select[name='search[foo][value]']" do
+      assert_select "option[value='1']"
+      assert_select "option[value='1'][selected='selected']", false
+      assert_select "option[value='2'][selected='selected']"
+    end
+  end
+end

data/test/field_set_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FieldSetTest < Presenting::Test
+  def setup
+    @set = Presenting::FieldSet.new(Presenting::Attribute, :name, :value)
+  end
+  
+  def test_reading_a_field_by_name
+    @set << "foo"
+    assert_equal "foo", @set["foo"].name
+  end
+  
+  def test_pushing_a_field_by_name
+    @set << "foo"
+    assert_equal "foo", @set.first.name
+  end
+  
+  def test_pushing_a_field_by_name_and_value
+    @set << {"foo" => :bar}
+    assert_equal "foo", @set.first.name
+    assert_equal :bar, @set.first.value
+  end
+  
+  def test_pushing_a_field_by_name_and_options
+    @set << {"foo" => {:value => :bar}}
+    assert_equal "foo", @set.first.name
+    assert_equal :bar, @set.first.value
+  end
+  
+  def test_adding_a_field_by_name
+    @set["foo"] = nil
+    assert_equal "foo", @set.first.name
+  end
+  
+  def test_adding_a_field_by_name_and_value
+    @set["foo"] = :bar
+    assert_equal "foo", @set.first.name
+    assert_equal :bar, @set.first.value
+  end
+  
+  def test_adding_a_field_by_name_and_options
+    @set["foo"] = {:value => :bar}
+    assert_equal "foo", @set.first.name
+    assert_equal :bar, @set.first.value
+  end
+end