RubyGems - tiny - Versions diffs - 0.2.0 - Mend

tiny 0.2.0

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