sbfaulkner-sinatra-helpers 0.9.1

data/README.rdoc

@@ -0,0 +1,29 @@
+= sinatra-helpers
+
+sinatra-helpers is an extension for sinatra that provides a bunch of useful helpers
+for sinatra applications.
+
+== Installation
+
+  sudo gem install sbfaulkner-sinatra-helpers -s http://gems.github.com
+
+== Usage
+
+To use the helpers simply:
+
+  require 'sinatra-helpers'
+
+If you don't want to include all of the functionality you can require specific
+functionality in smaller units:
+
+  require 'sinatra-helpers/haml'
+
+or even:
+
+  require 'sinatra-helpers/haml/partials'
+
+  
+== Legal
+
+Author:: S. Brent Faulkner <brentf@unwwwired.net>  
+License:: Copyright (c) 2009 unwwwired.net, released under the MIT license

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 9
+:patch: 1

data/lib/sinatra-helpers.rb

@@ -0,0 +1,2 @@
+require 'sinatra-helpers/haml'
+require 'sinatra-helpers/html'

data/lib/sinatra-helpers/haml.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/haml/flash.rb'
+require File.dirname(__FILE__) + '/haml/forms.rb'
+require File.dirname(__FILE__) + '/haml/links.rb'
+require File.dirname(__FILE__) + '/haml/partials.rb'

data/lib/sinatra-helpers/haml/flash.rb

@@ -0,0 +1,17 @@
+require 'sinatra/base'
+
+module Sinatra
+  module Helpers
+    module Haml
+      module Flash
+        def flash_messages
+          [ :error, :warning, :notice ].each do |f|
+            haml_tag :div, flash[f], :class => f if flash.has?(f)
+          end
+        end
+      end
+    end
+  end
+
+  helpers Helpers::Haml::Flash
+end

data/lib/sinatra-helpers/haml/forms.rb

@@ -0,0 +1,149 @@
+require 'sinatra/base'
+require 'active_support/inflector'
+
+module Sinatra
+  module Helpers
+    module Haml
+      module Forms
+        CHECKBOX_DEFAULTS = {:type => :checkbox, :value => 1}
+        FILE_FIELD_DEFAULTS = {:type => :file}
+        HIDDEN_FIELD_DEFAULTS = {:type => :hidden}
+        PASSWORD_FIELD_DEFAULTS = {:type => :password}
+        TEXT_FIELD_DEFAULTS = {:type => :text}
+        TEXT_AREA_DEFAULTS = {}
+        SELECT_DEFAULTS = {}
+
+        def errors_for(object)
+          unless object.errors.empty?
+            errors = object.errors.full_messages
+            haml_tag :div, :id => 'errors' do
+              haml_tag :p, %Q(Unable to save #{object.class.name.humanize} due to the following #{errors.size == 1 ? 'error' : "#{errors.size} errors"}:)
+              haml_tag :ul do
+                haml_concat list_of(errors) { |error| haml_concat(error) }
+              end
+            end
+          end
+        end
+
+        def parameterize(arg)
+          case arg
+          when Array
+            arg.compact.collect { |a| parameterize(a) }
+          when String
+            arg
+          when Symbol, Numeric
+            arg.to_s
+          else
+            arg.class.name.underscore
+          end
+        end
+
+        def object_for(*args)
+          args.pop if args.last.is_a?(Hash)
+          args.pop
+          case object = args.last
+          when String, Symbol
+            if args.length > 1
+              object_for(*args).send(object)
+            else
+              instance_variable_get "@#{object}"
+            end
+          else
+            object
+          end
+        end
+
+        def value_for(*args)
+          object = object_for(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          object.send args.pop
+        end
+
+        def id_for(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          index = options[:index]
+          method = args.pop
+          args << index << method
+          parameterize(args).join('_')
+        end
+
+        def name_for(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          index = options[:index]
+          method = args.pop
+          # pluralize collection name when indexed... explicit parameterization
+          args << parameterize(args.pop).pluralize << index if index
+          args << method
+          parameterize(args).inject { |name,part| "#{name}[#{part}]" }
+        end
+
+        def extract_options(*args)
+          args.last.is_a?(Hash) ? args.last.reject { |k,v| k.to_s == 'index' } : {}
+        end
+
+        def label(*args)
+          { :for => id_for(*args) }.merge extract_options(*args)
+        end
+
+        def input(*args)
+          { :id => id_for(*args), :name => name_for(*args) }.merge extract_options(*args)
+        end
+
+        def checkbox(*args)
+          args << {} unless args.last.is_a?(Hash)
+          options = args.last
+          options[:checked] = value_for(*args) unless options.include?(:checked)
+          CHECKBOX_DEFAULTS.merge input(*args)
+        end
+    
+        def file_field(*args)
+          args << {} unless args.last.is_a?(Hash)
+          options = args.last
+          options[:value] = value_for(*args) unless options.include?(:value)
+          FILE_FIELD_DEFAULTS.merge input(*args)
+        end
+
+        def hidden_field(*args)
+          args << {} unless args.last.is_a?(Hash)
+          options = args.last
+          options[:value] = value_for(*args) unless options.include?(:value)
+          HIDDEN_FIELD_DEFAULTS.merge input(*args)
+        end
+    
+        def password_field(*args)
+          args << {} unless args.last.is_a?(Hash)
+          options = args.last
+          options[:value] = value_for(*args) unless options.include?(:value)
+          PASSWORD_FIELD_DEFAULTS.merge input(*args)
+        end
+    
+        def text_field(*args)
+          args << {} unless args.last.is_a?(Hash)
+          options = args.last
+          options[:value] = value_for(*args) unless options.include?(:value)
+          TEXT_FIELD_DEFAULTS.merge input(*args)
+        end
+    
+        def text_area(*args)
+          args << {} unless args.last.is_a?(Hash)
+          options = args.last
+          TEXT_AREA_DEFAULTS.merge input(*args)
+        end
+    
+        def select(*args)
+          SELECT_DEFAULTS.merge input(*args)
+        end
+    
+        def options_of(collection, options = {}, &block)
+          collection.each do |option|
+            text, value = option
+            selected = block_given? ? block.call(option) : nil
+            haml_tag :option, text, options.merge(:selected => selected, :value => value)
+          end
+        end
+      end
+    end
+  end
+
+  helpers Helpers::Haml::Forms
+end

data/lib/sinatra-helpers/haml/links.rb

@@ -0,0 +1,102 @@
+require 'sinatra/base'
+
+module Sinatra
+  module Helpers
+    module Haml
+      module Links
+        def domain(tld_length = 1)
+          request.host.split('.')[-(tld_length+1)..-1].join('.')
+        end
+
+        def subdomain(name, tld_length = 1)
+          "#{name}.#{domain(tld_length)}"
+        end
+
+        def subdomain_url(name, tld_length = 1)
+          "http://#{subdomain(name, tld_length)}"
+        end
+
+        def asset_url(path, tld_length = 1)
+          "#{subdomain_url('assets', tld_length)}#{path}"
+        end
+
+        def css(path, options = {})
+          { :href => asset_url(path), :media => "all", :rel => "stylesheet", :type => "text/css" }.merge(options)
+        end
+
+        def icon(path, options = {})
+          { :href => asset_url(path), :rel => 'icon', :type => 'image/x-icon' }.merge(options)
+        end
+
+        def javascript(path, options = {})
+          { :src => asset_url(path), :type => 'text/javascript' }.merge(options)
+        end
+
+        def image(path, options = {})
+          options[:width], options[:height] = options.delete(:size).split('x') if options.include?(:size)
+          options[:alt] ||= File.basename(path, '.*')
+          { :src => asset_url(path) }.merge(options)
+        end
+
+        def action(path, options = {})
+          { :action => path, :method => 'post' }.merge(options)
+        end
+
+        def href(path, options = {})
+          script = if options.include?(:success)
+            path, original_path = '#', path
+            javascript_for_ajax(original_path, options)
+          elsif method = options.delete(:method)
+            path, original_path = '#', path
+            javascript_for_method(original_path, method)
+          else
+            options.delete(:onclick)
+          end
+          confirm = options.delete(:confirm)
+          script = javascript_with_confirmation(script, confirm) if confirm
+          result = { :href => path }
+          result[:onclick] = script unless script.nil?
+          result.merge(options)
+        end
+
+      protected
+        def javascript_options(options)
+          options.collect do |key,value|
+            value = "'#{value}'" if [:type,:url].include? key
+            "#{key}:#{value}"
+          end.join(',')
+        end
+
+        def javascript_with_confirmation(javascript, prompt)
+          prompt = 'Are you sure?' if prompt == true
+          javascript = 'return true;' if javascript.nil?
+          "if (confirm('#{prompt}')) { #{javascript} }; return false;"
+        end
+
+        def javascript_for_method(action, method)
+          javascript = "$('<form></form>').css('display','none').attr({'method':'post','action':'#{action}'})"
+          javascript << ".append($('<input type=\"hidden\">').attr({'name':'_method','value':'#{method}'}))" if method != 'post'
+          javascript << ".appendTo($(this).parent()).submit();return false;"
+        end
+
+        def javascript_for_ajax(url, options = {})
+          ajax_options = {:url => url}
+          success = options.delete(:success)
+          if !success.is_a?(Hash)
+            function = "$('#{success}').replaceWith(html)"
+          elsif success.include?(:update)
+            function = success[:position] || 'replaceWith'
+            function = "$('#{success[:update]}').#{function}(html);"
+          elsif success.include?(:remove)
+            function = "$('#{success[:remove]}').remove();"
+          end
+          ajax_options[:type] = options.delete(:method) if options.include?(:method)
+          ajax_options[:success] = "function(html){#{function}}"
+          "$.ajax({#{javascript_options(ajax_options)}});return false;"
+        end
+      end
+    end
+  end
+
+  helpers Helpers::Haml::Links
+end

data/lib/sinatra-helpers/haml/partials.rb

@@ -0,0 +1,26 @@
+require 'sinatra/base'
+require 'enumerator'
+
+module Sinatra
+  module Helpers
+    module Haml
+      module Partials
+        def haml_partial(name, options = {})
+          item_name = name.to_sym
+          counter_name = "#{name}_counter".to_sym
+          if collection = options.delete(:collection)
+            collection.enum_for(:each_with_index).collect do |item,index|
+              haml_partial name, options.merge(:locals => {item_name => item, counter_name => index+1})
+            end.join
+          elsif object = options.delete(:object)
+            haml_partial name, options.merge(:locals => {item_name => object, counter_name => nil})
+          else
+            haml "_#{name}".to_sym, options.merge(:layout => false)
+          end
+        end
+      end
+    end
+  end
+
+  helpers Helpers::Haml::Partials
+end

data/lib/sinatra-helpers/html.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/html/escape'

data/lib/sinatra-helpers/html/escape.rb

@@ -0,0 +1,20 @@
+require 'sinatra/base'
+
+module Sinatra
+  module Helpers
+    module Html
+      module Escape
+        def h(text)
+          Rack::Utils.escape_html(text)
+        end
+
+        def h!(text, blank_text = ' ')
+          return blank_text if text.nil? || text.empty?
+          h text
+        end
+      end
+    end
+  end
+
+  helpers Helpers::Html::Escape
+end

data/test/haml/flash_test.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class MockFlash < Hash
+  def initialize(flash = {})
+    flash.each { |k,v| self[k] = v }
+  end
+
+  alias_method :has?, :include?
+end
+
+class FlashTest < Test::Unit::TestCase
+  include Haml::Helpers
+  include Sinatra::Helpers::Haml::Flash
+
+  attr_reader :flash
+
+  def setup
+    init_haml_helpers
+    super
+  end
+
+  def test_should_not_show_message_for_empty_flash
+    @flash = MockFlash.new
+    flash_messages
+    assert_html ''
+  end
+
+  def test_should_show_message_for_error_flash
+    @flash = MockFlash.new :error => 'error message'
+    flash_messages
+    assert_html 'div', 1
+    assert_html 'div.error', :html => 'error message', :count => 1
+  end
+
+  def test_should_show_message_for_warning_flash
+    @flash = MockFlash.new :warning => 'warning message'
+    flash_messages
+    assert_html 'div', 1
+    assert_html 'div.warning', :html => 'warning message', :count => 1
+  end
+
+  def test_should_show_message_for_notice_flash
+    @flash = MockFlash.new :notice => 'notice message'
+    flash_messages
+    assert_html 'div', 1
+    assert_html 'div.notice', :html => 'notice message', :count => 1
+  end
+
+  def test_should_show_messages_for_multiple_flash
+    @flash = MockFlash.new :error => 'error message', :warning => 'warning message', :notice => 'notice message'
+    flash_messages
+    assert_html 'div', 3
+    assert_html 'div.error', :html => 'error message', :count => 1
+    assert_html 'div.warning', :html => 'warning message', :count => 1
+    assert_html 'div.notice', :html => 'notice message', :count => 1
+  end
+end

data/test/haml/forms_test.rb

@@ -0,0 +1,219 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class FormsTest < Test::Unit::TestCase
+  include Haml::Helpers
+  include Sinatra::Helpers::Haml::Forms
+
+  def setup
+    @invoice = mock
+    @invoice.stubs(:id => Time.now.to_i, :class => stub(:name => 'Invoice'))
+    init_haml_helpers
+    super
+  end
+
+  def test_object_for_should_return_object
+    assert_equal @invoice, object_for(:invoice, :id)
+  end
+
+  def test_object_for_should_support_explicit_object
+    assert_equal @invoice, object_for(@invoice, :id)
+  end
+
+  def test_value_for_should_return_value
+    @invoice.stubs(:client_name => 'Client name')
+    assert_equal @invoice.client_name, value_for(:invoice, :client_name)
+  end
+
+  def test_value_for_should_support_explicit_object
+    @invoice.stubs(:client_name => 'Client name')
+    assert_equal @invoice.client_name, value_for(@invoice, :client_name)
+  end
+
+  def test_id_for_should_build_simple_id
+    assert_equal "invoice_id", id_for(:invoice, :id)
+  end
+
+  def test_name_for_should_build_simple_name
+    assert_equal "invoice[id]", name_for(:invoice, :id)
+  end
+
+  def test_id_for_should_support_explicit_object
+    assert_equal "invoice_id", id_for(@invoice, :id)
+  end
+
+  def test_name_for_should_support_explicit_object
+    assert_equal "invoice[id]", name_for(@invoice, :id)
+  end
+
+  def test_id_for_should_index_collection
+    assert_equal "line_1_id", id_for(:line, :id, :index => 1)
+  end
+
+  def test_name_for_should_index_collection
+    assert_equal "lines[1][id]", name_for(:line, :id, :index => 1)
+  end
+
+  def test_id_for_should_index_collection_by_id
+    line = line_stub
+    assert_equal "invoice_line_#{line.id}_id", id_for(:invoice, line, :id, :index => line.id)
+  end
+
+  def test_name_for_should_index_collection_by_id
+    line = line_stub
+    assert_equal "invoice[lines][#{line.id}][id]", name_for(:invoice, line, :id, :index => line.id)
+  end
+
+  def test_id_for_should_index_collection_by_new_id
+    line = line_stub
+    assert_equal "invoice_line_#{line.id}_id", id_for(:invoice, line, :id, :index => line.id)
+  end
+
+  def test_name_for_should_index_collection_by_new_id
+    line = line_stub
+    assert_equal "invoice[lines][#{line.id}][id]", name_for(:invoice, line, :id, :index => line.id)
+  end
+
+  def test_name_and_id_should_index_collection_by_same_new_id
+    line = line_stub
+    id = line.id
+    assert_equal "invoice_line_#{id}_id", id_for(:invoice, line, :id, :index => line.id)
+    assert_equal "invoice[lines][#{id}][id]", name_for(:invoice, line, :id, :index => line.id)
+  end
+
+  def test_id_for_should_support_parts
+    assert_equal "invoice_invoiced_on_year", id_for(@invoice, :invoiced_on, :year)
+  end
+
+  def test_name_for_should_support_parts
+    assert_equal "invoice[invoiced_on][year]", name_for(@invoice, :invoiced_on, :year)
+  end
+
+  def test_value_for_should_support_parts
+    @invoice.stubs(:invoiced_on => Time.now)
+    assert_equal @invoice.invoiced_on.year, value_for(@invoice, :invoiced_on, :year)
+  end
+
+  def test_id_for_should_support_parent
+    assert_equal "invoice_line_1_description", id_for(:invoice, :line, :description, :index => 1)
+  end
+
+  def test_name_for_should_support_parent
+    assert_equal "invoice[lines][1][description]", name_for(:invoice, :line, :description, :index => 1)
+  end
+
+  def test_id_for_should_support_explicit_object_with_parent
+    line = line_stub
+    assert_equal "invoice_line_1_description", id_for(@invoice, line, :description, :index => 1)
+  end
+
+  def test_name_for_should_support_explicit_object_with_parent
+    line = line_stub
+    assert_equal "invoice[lines][1][description]", name_for(@invoice, line, :description, :index => 1)
+  end
+
+  def test_errors_for_returns_nil_when_no_errors
+    @invoice.stubs(:errors => stub(:empty? => true))
+    errors_for(@invoice)
+    assert_html '', nil
+  end
+
+  def test_errors_for_returns_error_messages
+    @invoice.stubs(:class => stub(:name => 'Class name'), :errors => stub(:empty? => false, :full_messages => ['Field name']))
+    errors_for(@invoice)
+    assert_html 'p', :html => /Class name/, :count => 1
+    assert_html 'li', :html => /Field name/, :min => 1
+  end
+
+  def test_label
+    result = label(@invoice, :client_name)
+    assert_equal id_for(@invoice, :client_name), result[:for]
+  end
+
+  def test_checkbox
+    line = line_stub(:taxable => true)
+    @invoice.stubs(:lines).returns([line])
+    result = checkbox(@invoice, line, :taxable, :index => 1)
+    assert_equal :checkbox, result[:type]
+    assert_equal name_for(@invoice, line, :taxable, :index => 1), result[:name]
+    assert_equal id_for(@invoice, line, :taxable, :index => 1), result[:id]
+    assert_equal 1, result[:value]
+    assert result[:checked]
+  end
+
+  def test_checkbox_not_checked
+    line = line_stub(:taxable => false)
+    @invoice.stubs(:lines => [line])
+    result = checkbox(@invoice, line, :taxable, :index => 1)
+    assert_equal :checkbox, result[:type]
+    assert_equal name_for(@invoice, line, :taxable, :index => 1), result[:name]
+    assert_equal id_for(@invoice, line, :taxable, :index => 1), result[:id]
+    assert_equal 1, result[:value]
+    assert !result[:checked]
+  end
+
+  def test_hidden_field
+    @invoice.stubs(:client_name => 'Client name')
+    result = hidden_field(@invoice, :client_name)
+    assert_equal :hidden, result[:type]
+    assert_equal name_for(@invoice, :client_name), result[:name]
+    assert_equal id_for(@invoice, :client_name), result[:id]
+    assert_equal @invoice.client_name, result[:value]
+  end
+
+  def test_text_field
+    @invoice.stubs(:client_name => 'Client name')
+    result = text_field(@invoice, :client_name)
+    assert_equal :text, result[:type]
+    assert_equal name_for(@invoice, :client_name), result[:name]
+    assert_equal id_for(@invoice, :client_name), result[:id]
+    assert_equal @invoice.client_name, result[:value]
+  end
+
+  def test_text_area
+    result = text_area(@invoice, :client_name)
+    assert_equal name_for(@invoice, :client_name), result[:name]
+    assert_equal id_for(@invoice, :client_name), result[:id]
+  end
+
+  def test_select
+    result = select(@invoice, :client_name)
+    assert_equal name_for(@invoice, :client_name), result[:name]
+    assert_equal id_for(@invoice, :client_name), result[:id]
+  end
+
+  def test_options_of
+    dwarfs = %w(Bashful Doc Dopey Grumpy Happy Sleepy Sneezy)
+    options_of dwarfs
+    assert_html 'option', :count => 7 do |options|
+      assert_equal dwarfs, options.collect { |o| o.inner_html }
+    end
+  end
+
+  def test_options_of_with_selection
+    dwarfs = %w(Bashful Doc Dopey Grumpy Happy Sleepy Sneezy)
+    options_of dwarfs do |dwarf|
+      dwarf == 'Sleepy'
+    end
+    assert_html 'option', :count => 7 do |options|
+      assert_equal dwarfs, options.collect { |o| o.inner_html }
+    end
+    assert_html 'option[@selected="selected"]', :count => 1, :html => 'Sleepy'
+  end
+
+  def test_options_of_with_values
+    months = Date::MONTHNAMES.enum_for(:each_with_index).collect[1..12]
+    options_of months
+    assert_html 'option', :count => 12 do |options|
+      options.each_with_index do |option,i|
+        assert_html option, "option[@value='#{months[i].last}']", months[i].first
+      end
+    end
+  end
+
+protected
+  def line_stub(methods = {})
+    line = stub({:class => stub(:name => 'Line'), :id => Time.now.to_i}.merge(methods))
+    @invoice.stubs(:lines).returns([line])
+    line
+  end
+end

data/test/haml/links_test.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class LinksTest < Test::Unit::TestCase
+  include Haml::Helpers
+  include Sinatra::Helpers::Haml::Links
+
+  attr_reader :request
+
+  def setup
+    @request = mock()
+    @request.stubs(:host => 'www.example.com')
+    init_haml_helpers
+    super
+  end
+
+  def test_domain
+    assert_equal 'example.com', domain
+  end
+
+  def test_subdomain
+    assert_equal 'test.example.com', subdomain('test')
+  end
+
+  def test_subdomain_url
+    assert_equal 'http://another.example.com', subdomain_url('another')
+  end
+
+  def test_asset_url
+    assert_equal 'http://assets.example.com/images/logo.gif', asset_url('/images/logo.gif')
+  end
+
+  def test_css
+    assert_equal({ :href => 'http://assets.example.com/stylesheets/test.css', :media => 'all', :rel => 'stylesheet', :type => 'text/css' }, css('/stylesheets/test.css'))
+  end
+
+  def test_icon
+    assert_equal({ :href => 'http://assets.example.com/icons/save.gif', :rel => 'icon', :type => 'image/x-icon' }, icon('/icons/save.gif'))
+  end
+
+  def test_javascript
+    assert_equal({ :src => 'http://assets.example.com/javascripts/jquery.js', :type => 'text/javascript' }, javascript('/javascripts/jquery.js'))
+  end
+
+  def test_image
+    assert_equal({ :alt => 'test', :height => '100', :src => 'http://assets.example.com/images/test.jpg', :width => '200' }, image('/images/test.jpg', :size => '200x100'))
+  end
+
+  def test_action
+    assert_equal({ :action => '/invoices/123', :method => 'post' }, action('/invoices/123'))
+  end
+
+  def test_action_should_override_method
+    assert_equal({ :action => '/invoices/123', :method => 'delete' }, action('/invoices/123', :method => 'delete'))
+  end
+
+  def test_href
+    assert_equal({ :href => '/link' }, href('/link'))
+  end
+
+  def test_href_should_support_method_using_hidden_form
+    assert_equal({ :href => '#', :onclick => "$('<form></form>').css('display','none').attr({'method':'post','action':'/link'}).append($('<input type=\"hidden\">').attr({'name':'_method','value':'put'})).appendTo($(this).parent()).submit();return false;" }, href('/link', :method => 'put'))
+  end
+
+  def test_href_should_support_confirm
+    assert_equal({ :href=>"/link", :onclick => "if (confirm('Really?')) { return true; }; return false;" }, href('/link', :confirm => 'Really?'))
+  end
+
+  def test_href_should_support_ajax
+    assert_equal({ :href=> "#", :onclick=> "$.ajax({url:'/link',success:function(html){$('#result').replaceWith(html);}});return false;" }, href('/link', :success => { :update => '#result' }))
+  end
+end

data/test/haml/partials_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PartialsTest < Test::Unit::TestCase
+  include Haml::Helpers
+  include Sinatra::Helpers::Haml::Partials
+  include Sinatra::Templates
+
+  @templates = {}
+
+  class << self
+    attr_accessor :templates
+  end
+
+  attr_accessor :options
+
+  def setup
+    @options = mock()
+    @options.stubs(:views => File.dirname(__FILE__) + '/views')
+    init_haml_helpers
+    super
+  end
+
+  def test_partial
+    assert_html haml_partial('thing'), nil, "<p>Hello world</p>\n"
+  end
+
+  def test_partial_with_object
+    assert_html haml_partial('object', :object => mock(:name => 'object')), nil, "<p>Hello object</p>\n"
+  end
+
+  def test_partial_with_locals
+    assert_html haml_partial('object', :locals => { :object => mock(:name => 'local')}), nil, "<p>Hello local</p>\n"
+  end
+
+  def test_partial_with_collection
+    assert_html haml_partial('object', :collection => [ mock(:name => 'one'), mock(:name => 'two')]), nil, "<p>Hello one</p>\n<p>Hello two</p>\n"
+  end
+end

data/test/haml/views/_object.haml

@@ -0,0 +1 @@
+%p== Hello #{object.name}

data/test/haml/views/_thing.haml

@@ -0,0 +1 @@
+%p Hello world

data/test/html/escape_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class EscapeTest < Test::Unit::TestCase
+  include Sinatra::Helpers::Html::Escape
+
+  def test_h_should_escape_text
+    assert_equal 'this &amp; that', h('this & that')
+  end
+
+  def test_h_should_return_blank_for_empty_string
+    assert_equal '', h('')
+  end
+
+  def test_h_should_return_blank_for_nil
+    assert_equal '', h(nil)
+  end
+
+  def test_hbang_should_escape_text
+    assert_equal 'this &amp; that', h!('this & that')
+  end
+
+  def test_hbang_should_return_nbsp_for_empty_string
+    assert_equal '&nbsp;', h!('')
+  end
+
+  def test_hbang_should_return_nbsp_for_nil
+    assert_equal '&nbsp;', h!(nil)
+  end
+
+  def test_hbang_should_return_arbitrary_placeholder_for_empty_string
+    assert_equal 'N/A', h!('', 'N/A')
+  end
+
+  def test_hbang_should_return_arbitrary_placeholder_for_nil
+    assert_equal 'N/A', h!(nil, 'N/A')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+
+$:.unshift File.dirname(__FILE__) + '../lib'
+
+require 'haml'
+
+require 'sinatra-helpers'
+
+require 'test/unit'
+require 'mocha'
+require 'hpricot'
+
+class Test::Unit::TestCase
+  def assert_html(*args) # [doc], selector, match)
+    match = args.pop
+    selector = args.pop
+    html = args.pop || haml_buffer.buffer
+    html = html.to_html if html.respond_to? :to_html
+    selection = Hpricot(html)/selector unless match.nil?
+    case match
+    when NilClass
+      assert_equal selector, html
+    when Numeric
+      assert_equal match, selection.size, "Expected selection of exactly <#{match}>"
+    when String
+      assert_equal match, selection.inner_html, "Expected selection to equal <#{match}>"
+    when Regexp
+      assert_match match, selection.inner_html, "Expected selection to match <#{match}>"
+    when Hash
+      assert selection.size >= match[:min], "Expected selection of at least <#{match[:min]}>" if match.include?(:min)
+      assert selection.size <= match[:max], "Expected selection of at most <#{match[:max]}>" if match.include?(:max)
+      assert_html html, selector, match[:count] if match.include?(:count)
+      assert_html html, selector, match[:html] if match.include?(:html)
+    end
+    if block_given? && !selection.empty?
+      yield selection
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: sbfaulkner-sinatra-helpers
+version: !ruby/object:Gem::Version 
+  version: 0.9.1
+platform: ruby
+authors: 
+- S. Brent Faulkner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: a bunch of useful helpers for sinatra applications
+email: brentf@unwwwired.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/sinatra-helpers
+- lib/sinatra-helpers/haml
+- lib/sinatra-helpers/haml/flash.rb
+- lib/sinatra-helpers/haml/forms.rb
+- lib/sinatra-helpers/haml/links.rb
+- lib/sinatra-helpers/haml/partials.rb
+- lib/sinatra-helpers/haml.rb
+- lib/sinatra-helpers/html
+- lib/sinatra-helpers/html/escape.rb
+- lib/sinatra-helpers/html.rb
+- lib/sinatra-helpers.rb
+- test/haml
+- test/haml/flash_test.rb
+- test/haml/forms_test.rb
+- test/haml/links_test.rb
+- test/haml/partials_test.rb
+- test/haml/views
+- test/haml/views/_object.haml
+- test/haml/views/_thing.haml
+- test/html
+- test/html/escape_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/sbfaulkner/sinatra-helpers
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: a bunch of useful helpers for sinatra applications
+test_files: []
+