RubyGems - tiny - Versions diffs - 0.2.0 - Mend

tiny 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

data/.gitignore +10 -0
data/.rspec +1 -0
data/Gemfile +4 -0
data/README.md +388 -0
data/Rakefile +1 -0
data/lib/tiny.rb +519 -0
data/lib/tiny/erubis.rb +63 -0
data/lib/tiny/html.rb +177 -0
data/lib/tiny/safe_string.rb +16 -0
data/lib/tiny/tag.rb +47 -0
data/lib/tiny/version.rb +3 -0
data/spec/erubis_spec.rb +48 -0
data/spec/fixtures/erb_list.erb +20 -0
data/spec/fixtures/erb_list_with_helpers.erb +5 -0
data/spec/fixtures/haml_list.haml +16 -0
data/spec/fixtures/haml_list_with_helpers.haml +4 -0
data/spec/helpers_spec.rb +303 -0
data/spec/integration/erb_spec.rb +83 -0
data/spec/integration/haml_spec.rb +59 -0
data/spec/integration/rails_spec.rb +42 -0
data/spec/integration/sinatra_spec.rb +42 -0
data/spec/spec_helper.rb +54 -0
data/spec/support/form_helper.rb +34 -0
data/spec/support/list_helper.rb +14 -0
data/spec/support/rails_app.rb +44 -0
data/spec/support/sinatra_app.rb +26 -0
data/spec/widget_spec.rb +146 -0
data/tiny.gemspec +31 -0
metadata +237 -0

data/.gitignore ADDED Viewed

@@ -0,0 +1,10 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+*.swp
+*.swo
+doc
+.yardoc
+tags

data/.rspec ADDED Viewed

	@@ -0,0 +1 @@
1	+ --color

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+# Specify your gem's dependencies in markup_helpers.gemspec
+gemspec

data/README.md ADDED Viewed

@@ -0,0 +1,388 @@
+# tiny
+Tiny is a framework agnostic markup builder. It is useful for defining
+view helpers or generating HTML markup using ruby objects, leveraging
+inheritance and composition while defining templates.
+It is inspired by Erector and Markaby but with a minimalistic aproach
+and it opts for evaluating content blocks in their original context
+rather than using instance\_eval thus instance variables need not to be
+"smuggled in". It also attempts to be a tiny framework for defining view
+helpers to be used in ERB and HAML templates from Rails, Sinatra or any
+other framework.
+It provides a mixin for inline building HTML markup from any class or to
+define pure ruby object templates with all object-oriented programming
+advantages such as inheritance and encapsulation.
+Tiny is pretty much fully documented. Please check [Tiny
+Rdoc](http://rdoc.info/github/maca/tiny/master/file/README.md) for more
+info.
+## Install
+    $ gem install tiny
+## Usage
+    require 'tiny'
+    class MyPage < Tiny::Widget
+      def markup
+        html do
+          head do
+            title "Hello"
+          end
+          body do
+            h1 "Hello"
+            p :class => 'content' do
+              text "Lorem ipsum..."
+            end
+          end
+        end
+      end
+    end
+    MyPage.new.to_html
+    # => <html>
+      <head>
+        <title>Hello</title>
+      </head>
+      <body>
+        <h1>Hello</h1>
+        <p>
+          Lorem ipsum...
+        </p>
+      </body>
+    </html>
+## Markup Helpers
+There are a few was of generating markup with Tiny, while one is by
+encapsulated classes inheriting from `Tiny::Widget`, another one is
+doing it inline by including `Tiny::Helpers` in any context.
+Including `Tiny::Helpers` gives access to a handfull of methods, the
+basic one is `html_tag` aliased as `tag`.
+    include Tiny::Helpers
+    tag(:ul) do
+      tag(:li) do
+        tag :a, 'Home', :class => 'home', :href => '/'
+      end
+      ...
+    end
+    # => <ul>
+      <li>
+        <a class="home" href="/">Home</a>
+      </li>
+      ...
+    </ul>
+## HTML tags
+Tags are self closed or explicitly closed depeding on the tag name.
+Attributes are HTML-escaped and mapped as follows:
+    tag(:link, :href => 'my-styles.css')
+    # => <link href="my-styles.css" />
+    tag(:li, 'Bicycle', :class => ['with-discount', 'in-stock'])
+    # => <li class="with-discount in-stock">Bicycle</li>
+    tag(:textarea, :disabled => true)
+    # => <textarea disabled></textarea>
+    tag(:textarea, :disabled => false)
+    # => <textarea></textarea>
+Tag content can be defined either by passing a string and optionally an
+attributes hash or by passing a content block.
+## Markup
+Other methods for generating markup are `text` for appending HTML
+escaped `text`, `text!` or `append!` for appending HTML, `comment`, `cdata`
+and `doctype`.
+The method `with_buffer` is for capturing template content, just like
+Rails `capture` but it also serves for concatenating content.
+    with_buffer do
+      tag(:h1, "Hello")
+      tag(:p, "Lorem ipsum...")
+    end
+    # => <h1>Hello</h1>
+    <p>Lorem ipsum...</p>
+## Rails
+Tiny ActionView helpers are allready included in ActionView, no further
+step is required for using Tiny in Rails view helpers, just use `html_tag`
+instead of `tag` because ActionView allready defines `tag`.
+The advantage over Rails' markup method such as `tag` and `content\_tag` is
+that generated strings need not to be explicitly concatenated.
+In addition to defining view helpers to be used from templates, a
+`Widget` can substitute a template view with the benefit of inheritance.
+No template handler es provided but is not cumbersome explicitly
+rendering the Widget.
+    controller Products
+      def index
+        products = Product.all
+        render :text => MyProductList.new(products).to_html
+      end
+      ...
+    end
+## Sinatra
+For using the markup helpers:
+    class MyApp < Sinatra::Base
+      helpers Tiny::Helpers
+      get '/home' do
+        with_buffer do
+          doctype
+          html do
+            ...
+          end
+        end
+      end
+    end
+Rendering `Tiny::Widgets`
+    class MyApp < Sinatra::Base
+      get '/products' do
+        products = Product.all
+        MyProductList.new(products).to_html
+      end
+    end
+## Shortcuts
+Including `Tiny::HTML` gives access to shortcuts for HTML tags. Caution
+must be exercised because its quite a few methods.
+## View Inheritance
+    class Template < Tiny::Widget
+      def markup
+        doctype
+        html do
+          head do
+            title @title
+          end
+          body do
+            navigation
+            section(:id => 'content') do
+              yield
+            end
+            footer_content
+          end
+        end
+      end
+      def navigation
+        nav(:id) do
+          tag(:ul) do
+            tag(:li) do
+              tag :a, 'Home', :class => 'home', :href => '/'
+            end
+            tag(:li) do
+              tag :a, 'About', :class => 'about', :href => '/about'
+            end
+            tag(:li) do
+              tag :a, 'Home', :class => 'products', :href => '/products'
+            end
+          end
+        end
+      end
+      def footer_content
+        footer "© 2012"
+      end
+    end
+    class HomePage < Template
+      def initialize
+        @title = "Home"
+      end
+      def markup
+        super do
+          h1 "Welcome!!"
+          p "Lorem ipsum..."
+        end
+      end
+    end
+    HomePage.new.to_html
+    # => <!DOCTYPE html>
+    <html>
+      <head>
+        <title>Home</title>
+      </head>
+      <body>
+        <nav>
+          <ul>
+            <li>
+              <a class="home" href="/">Home</a>
+            </li>
+            <li>
+              <a class="about" href="/about">About</a>
+            </li>
+            <li>
+              <a class="products" href="/products">Home</a>
+            </li>
+          </ul>
+        </nav>
+        <section id="content">
+          <h1>Welcome!!</h1>
+          <p>Lorem ipsum...</p>
+        </section>
+        <footer>
+          © 2012
+        </footer>
+      </body>
+    </html>
+## View helpers for HAML and ERB templates
+One of the Tiny's main goals is providing facilities for defining view
+helpers that can be used from Ruby or templating laguages regardless of
+the web framework.
+A Widget can take a block while calling `to_html`. Tiny can determine
+wether the block was originated in an ERB or HAML template or not and
+treat it accordingly. #to\_html forwards the passed block to #markup but
+concatenates the result of calling it.
+    class MyForm < Tiny::Widget
+      def initialize(action)
+        @action = action
+      end
+      def markup
+        form(:action => @action) do
+          fieldset do
+            yield(self)
+          end
+        end
+      end
+      def text_input(name, value)
+        TextInput.new(name, value).to_html
+      end
+    end
+    class TextInput < Tiny::Widget
+      def initialize(name, value)
+        @name, @value = name, value
+      end
+      def markup
+        label(@name.capitalize, :for => @name)
+        input(:type => 'text', :id => @name, :name => @name, :value => @value)
+      end
+    end
+    def my_form(action, &block)
+      # the block is forwarded to MyForm#to_html
+      MyForm.new(action).to_html(&block)
+    end
+Using the helper from an ERB template, note that Tiny allows explicitly
+concatenating calls with blocks just like with Rails ERB.
+    <%= my_form('/login') do |form| %>
+      <%= form.text_input 'email', 'email@example.com' %>
+    <% end %>
+    # => <form action="/login">
+      ...
+      <fieldset>
+        <label for="email">Email</label>
+        <input type="text" id="email" name="email" value="email@example.com" />
+      </fieldset>
+      ...
+    </form>
+Using the same helper from Ruby:
+    my_form('/login') do |form|
+      append! form.text_input 'email', 'email@example.com'
+    end
+    # => <form action="/login">
+      ...
+      <fieldset>
+        <label for="email">Email</label>
+        <input type="text" id="email" name="email" value="email@example.com" />
+      </fieldset>
+      ...
+    </form>
+## HTML Representation For Any Object.
+By including the `Rendering` any object can emit it's HTML representation.
+Whether this is or isn't a good idea is up to you.
+    class User < Model
+      include Tiny::Rendering
+      def markup
+        div(:id => "user-#{self.id}") do
+          img :src => self.avatar_url
+          dl do
+            dt "First Name"
+            dd self.first_name
+            dt "Last Name"
+            dd self.last_name
+          end
+        end
+      end
+    end
+    user = User.create(:first_name => 'Macario',
+      :last_name => 'Ortega',
+      :avatar_url => 'http://example.com/profile/dbg.jpeg')
+    user.to_html
+    # => <div id="user-1">
+      <img src="http://example.com/profile/dbg.jpeg" />
+      <dl>
+        <dt>First Name</dt>
+        <dd>Macario</dd>
+        <dt>Last Name</dt>
+        <dd>Ortega</dd>
+      </dl>
+    </div>
+== LICENSE:
+(The MIT License)
+Copyright (c) 2012 Macario Ortega
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile ADDED Viewed

	@@ -0,0 +1 @@
1	+ require "bundler/gem_tasks"

data/lib/tiny.rb ADDED Viewed

@@ -0,0 +1,519 @@
+require 'erubis'
+require 'haml'
+require 'tilt'
+require 'escape_utils'
+require 'tiny/version'
+require 'tiny/erubis'
+require 'tiny/safe_string'
+require 'tiny/tag'
+require 'tiny/html'
+module Tiny
+  # Provides basic markup generation support.
+  module Markup
+    # Generates an HTML tag or structured HTML markup
+    #
+    # This method is the basis for defining html helper functions or
+    # constructing html markup using pure ruby.
+    #
+    # HTML attributes are HTML-escaped and tags are explicitly or self
+    # closed depeding on the tag name.
+    #
+    # Calls to markup generating methods within the content block are
+    # appended to the tag's content.
+    # See {Markup} and {HTML}.
+    #
+    # Content blocks originating from HAML or ERB templates are
+    # correctly captured and handled.
+    #
+    # @param name [Symbol, String] The name of the tag.
+    # @param attrs_or_content [Hash, String] Tag's attributes or content.
+    # @param attrs [Hash] Tag's attributes if content string passed.
+    # @yield Content block.
+    #
+    # @return [String] HTML markup
+    #
+    # @example Attribute mapping
+    #
+    #   html_tag(:link, :href => 'my-styles.css')
+    #   # => <link href="my-styles.css" />
+    #   html_tag(:li, 'Bicycle', :class => ['with-discount', 'in-stock'])
+    #   # => <li class="with-discount in-stock">Bicycle</li>
+    #   html_tag(:textarea, :disabled => true)
+    #   # => <textarea disabled></textarea>
+    #   html_tag(:textarea, :disabled => false)
+    #   # => <textarea></textarea>
+    #
+    # @example HTML-escaping
+    #
+    #   html_tag(:a, 'Art&Copy', :href => '/art&copy')
+    #   # => <a href="/art&amp;copy">Art&amp;copy</a>
+    #
+    # @example Tag closing
+    #
+    #   html_tag(:p)    # => <p></p>
+    #   html_tag(:link) # => <link />
+    #
+    # @example Content block
+    #
+    #   html_tag(:ul) do
+    #     html_tag(:li, 'Cheese')
+    #     html_tag(:li, 'Ham')
+    #     html_tag(:li, 'Milk')
+    #   end
+    #   # => <ul>
+    #     <li>Cheese</li>
+    #     <li>Haml</li>
+    #     <li>Milk</li>
+    #   </ul>
+    #
+    #   html_tag(:p) do
+    #     text 'Neque porro quisquam est qui dolorem...'
+    #     'this string will be ignored'
+    #   end
+    #   # => <p>
+    #   Neque porro quisquam est qui dolorem...
+    #   </p>
+    #
+    # @example ERB blocks
+    #
+    #   !!!ruby
+    #   # application_helper.rb
+    #   module ApplicationHelper
+    #     def my_form(url, &block)
+    #       html_tag(:form, :action => url) do
+    #         ...
+    #         html_tag(:fieldset, &block)
+    #         ...
+    #       end
+    #     end
+    #
+    #     def text_input(name, value)
+    #       html_tag(:input, :type => 'text', :name => name, :value => value)
+    #     end
+    #   end
+    #
+    #   # form.erb
+    #   <%= my_form '/login' do %>
+    #     <%= text_input 'email', @email %>
+    #   <% end %>
+    #   # => <form action="/login">
+    #     ...
+    #     <fieldset>
+    #       <input type="text" name="email" value="email@example.com" />
+    #     </fieldset>
+    #     ...
+    #   </form>
+    #
+    #
+    def html_tag name, attrs_or_content = {}, attrs = nil, &block
+      append! Tag.new(name, attrs_or_content, attrs).render(&block)
+    end
+    # Appends an HTML coment to the content.
+    #
+    #   div do
+    #     comment 'foo'
+    #   end
+    #   # => <div>
+    #     <!-- foo -->
+    #   </div>
+    #
+    # @return [SafeString] HTML content.
+    #
+    def comment content
+      append! "<!-- #{content.to_s.gsub(/-(?=-)/, '- ')} -->"
+    end
+    # Appends a CDATA section to the content.
+    #
+    #   div do
+    #     cdata 'foo'
+    #   end
+    #   # => <div>
+    #   <![CDATA[foo]]>
+    #   </div>
+    #
+    # @return [String] CDATA section.
+    #
+    def cdata content
+      content = content.to_s.gsub(']]>', ']]]]><![CDATA[>')
+      append! "<![CDATA[#{content}]]>"
+    end
+    # Appends the doctype to the content
+    #
+    #   with_buffer do
+    #     doctype
+    #     html_tag(:html) do
+    #       ...
+    #     end
+    #   end
+    #   # => <!DOCTYPE html>
+    #   <html>
+    #     ...
+    #   </html>
+    #
+    # @return [String] Doctype.
+    #
+    def doctype
+      append! "<!DOCTYPE html>"
+    end
+  end
+  # Buffering and capturing support.
+  module Buffering
+    # Appends sanitized text to the content.
+    #
+    #   html_tag(:p) do
+    #     text 'Foo &'
+    #     text 'Bar'
+    #   end
+    #   # => <p>
+    #   Foo &amp;
+    #   Bar
+    #   </p>
+    #
+    # @return [String] HTML-escaped.
+    #
+    def append string
+      string = Helpers.sanitize(string)
+      if working_buffer
+        working_buffer << string.gsub(/(?<!^|\n)\z/, "\n")
+      else
+        string
+      end
+    end
+    alias text append
+    # Appends non HTML-escaped text to the content.
+    #
+    #   html_tag(:p) do
+    #     append! 'Foo & Bar'
+    #     append! '<evil>'
+    #   end
+    #   # => <p>
+    #   Foo & Bar
+    #   <evil>
+    #   </p>
+    #
+    # Shortcut for
+    #
+    #   append raw(content)
+    #
+    # @return [SafeString] Non HTML-escaped.
+    #
+    def append! content
+      append raw(content)
+    end
+    alias text! append!
+    # Returns content that won't be HTML escaped when appended to content.
+    #
+    # @return [SafeString] Considered html safe.
+    #
+    def raw val
+      SafeString.new val.to_s
+    end
+    # Buffers calls to markup generating methods.
+    # @see Markup
+    # @see HTML
+    #
+    # @example Not using #with_buffer Only the last tag is returned.
+    #   def my_helper
+    #     html_tag(:span, 'Foo')
+    #     html_tag(:span, 'Bar')
+    #   end
+    #   my_helper()
+    #   # => <span>Bar</span>
+    #
+    # @example By using #with_buffer structured markup is generated.
+    #   def my_helper
+    #     with_buffer do
+    #       html_tag(:span, 'Foo')
+    #       html_tag(:span, 'Bar')
+    #     end
+    #   end
+    #   my_helper()
+    #   # => <span>Foo</span>
+    #   <span>Bar</span>
+    #
+    # @param args [any] n number of arguments to be passed to block evaluation.
+    # @yield [*args] Content block.
+    #
+    # @return [String] HTML markup.
+    #
+    def with_buffer *args, &block
+      buffer_stack << ''
+      yield *args
+      buffer_stack.pop
+    end
+    private
+    # Pushing and popping.
+    def buffer_stack
+      @buffer_stack ||= []
+    end
+    # Current buffer from the buffer stack.
+    def working_buffer
+      buffer_stack.last
+    end
+  end
+  # Provides support for using Tiny helpers within a HAML template.
+  module HamlTemplating
+    include Buffering
+    include Markup
+    # Extracts a section of a HAML template or buffers a block not
+    # originated from an HAML template. Akin to Rails capture method.
+    #
+    # @see Buffering#with_buffer
+    #
+    # @param args [any] n number of arguments to be passed to block evaluation.
+    # @yield [*args] HAML block or content block.
+    # @return [String] HTML markup.
+    #
+    def with_buffer *args, &block
+      ::Haml::Helpers.block_is_haml?(block) ? capture_haml(*args, &block) : super
+    end
+  end
+  # Provides support for using Tiny helpers within an Erubis template.
+  module ErubisTemplating
+    include Buffering
+    include Markup
+    # Extracts a section of a ERB template or buffers a block not
+    # originated from an ERB template. Akin to Rails capture method.
+    #
+    # @see Buffering#with_buffer
+    #
+    # @param args [any] n number of arguments to be passed to block evaluation.
+    # @yield [*args] ERB block or content block.
+    # @return [String] HTML markup.
+    #
+    def with_buffer *args, &block
+      erb_block?(block) ? capture_erb(*args, &block) : super
+    end
+    # Capture a section of an ERB template.
+    #
+    # @param args [any] n number of arguments to be passed to block evaluation
+    # @return [String] HTML markup
+    # @yield [*args]
+    #
+    def capture_erb *args, &block
+      output_buffer = eval('_buf', block.binding)
+      buffer = output_buffer.dup
+      output_buffer.clear and yield(*args)
+      return output_buffer.dup
+    ensure
+      output_buffer.replace buffer
+    end
+    # Was the block defined within an ERB template?
+    #
+    # @param block [Proc] a Proc object
+    #
+    def erb_block? block
+      block && eval('defined?(__in_erb_template)', block.binding)
+    end
+  end
+  # Include this module anywhere you want to use markup generation, or
+  # define view helpers using Tiny.
+  module Helpers
+    include Buffering
+    include Markup
+    include ErubisTemplating
+    include HamlTemplating
+    # Alias for {Markup#html_tag}
+    #
+    # @return [String] HTML markup
+    #
+    def tag name, attrs_or_content = {}, attrs = nil, &block
+      html_tag name, attrs_or_content, attrs, &block
+    end
+    # HTML-escapes the passed value unless the content is considered
+    # safe ({SafeString#html_safe? html_safe?} is implemented and
+    # returns true)
+    #
+    # @param value [String, Object]
+    # @return [String]
+    #
+    def self.sanitize value
+      if value.respond_to?(:html_safe?) && value.html_safe?
+        value.to_s
+      else
+        EscapeUtils.escape_html value.to_s
+      end
+    end
+  end
+  # Support for HTML markup generation for classes, can be included in
+  # any class that is to be represented with HTML markup.
+  # @see Widget
+  #
+  # @example
+  #   class User < Model
+  #     include Tiny::Rendering
+  #
+  #     def markup
+  #       div(:id => "user-#{self.id}") do
+  #         img :src => self.avatar_url
+  #         dl do
+  #           dt "First Name"
+  #           dd self.first_name
+  #           dt "Last Name"
+  #           dd self.last_name
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   user = User.create(:first_name => 'Macario',
+  #     :last_name => 'Ortega',
+  #     :avatar_url => 'http://example.com/profile/dbg.jpeg')
+  #   user.to_html
+  #   # => <div id="user-1">
+  #     <img src="http://example.com/profile/dbg.jpeg" />
+  #     <dl>
+  #       <dt>First Name</dt>
+  #       <dd>Macario</dd>
+  #       <dt>Last Name</dt>
+  #       <dd>Ortega</dd>
+  #     </dl>
+  #   </div>
+  #
+  module Rendering
+    include HTML
+    include Helpers
+    # Override this method with specific markup.
+    #
+    # @yield [self] Content block (from calling to {#render}).
+    # @see Widget
+    #
+    def markup
+      raise NotImplementedError
+    end
+    # Renders the html markup specified by #markup.
+    #
+    # @return [String] HTML markup.
+    # @see Widget.
+    #
+    def render &block
+      with_buffer do
+        next markup unless block_given?
+        markup do |args|
+          context = eval('self', block.binding)
+          append! context.instance_eval{ with_buffer(*args, &block) }
+        end
+      end
+    end
+    alias to_html render
+  end
+  module ActionViewAdditions
+    include Buffering
+    include Markup
+    # Extracts a section of a template or buffers a block not
+    # originated from an template.
+    #
+    # @see Buffering#with_buffer
+    #
+    # @param args [any] n number of arguments to be passed to block evaluation.
+    # @yield [*args] HAML block or content block.
+    # @return [String] HTML markup.
+    #
+    def with_buffer *args, &block
+      block_from_template?(block) ? capture(*args, &block) : super
+    end
+    # Appends sanitized text to the content.
+    # @see Buffering#append
+    def append markup
+      super(markup).html_safe
+    end
+    # Returns true if the block was originated in an ERB or HAML template.
+    def block_from_template? block
+      block && eval('defined?(output_buffer)', block.binding) == 'local-variable'
+    end
+  end
+  # @example
+  #   class MyForm < Tiny::Widget
+  #     def initialize(action)
+  #       @action = action
+  #     end
+  #
+  #     def markup
+  #       form(:action => @action) do
+  #         fieldset do
+  #           yield(self)
+  #         end
+  #       end
+  #     end
+  #
+  #     def text_input(name, value)
+  #       TextInput.new(name, value).to_html
+  #     end
+  #   end
+  #
+  #   class TextInput < Tiny::Widget
+  #     def initialize(name, value)
+  #       @name, @value = name, value
+  #     end
+  #
+  #     def markup
+  #       label(@name.capitalize, :for => @name)
+  #       input(:type => 'text', :id => @name, :name => @name, :value => @value)
+  #     end
+  #   end
+  #
+  #   def my_form(action, &block)
+  #     MyForm.new(action).to_html(&block)
+  #   end
+  #
+  #   my_form('/login') do |form|
+  #     append! form.text_input 'email', 'email@example.com'
+  #   end
+  #   # => <form action="/login">
+  #     ...
+  #     <fieldset>
+  #       <label for="email">Email</label>
+  #       <input type="text" id="email" name="email" value="email@example.com" />
+  #     </fieldset>
+  #     ...
+  #   </form>
+  #
+  #   # from template
+  #   <%= my_form('/login') do |form| %>
+  #     <%= form.text_input 'email', 'email@example.com' %>
+  #   <% end %>
+  #   # => <form action="/login">
+  #     ...
+  #     <fieldset>
+  #       <label for="email">Email</label>
+  #       <input type="text" id="email" name="email" value="email@example.com" />
+  #     </fieldset>
+  #     ...
+  #   </form>
+  #
+  # @see Rendering
+  #
+  class Widget
+    include Rendering
+  end
+  ActionView::Base.send :include, ActionViewAdditions if defined?(ActionView)
+end