wrapt 0.1.0

data/Users/dneighman/Projects/wrapt/Gemfile

@@ -0,0 +1,15 @@
+source :rubygems
+
+gem 'tilt',     :git  => 'git://github.com/hassox/tilt.git', :branch => :hassox
+gem 'any_view', :git  => 'git://github.com/hassox/any_view.git'
+
+gem 'hashie'
+
+group(:test) do
+  gem 'rspec'
+  gem 'rack'
+  gem 'ZenTest'
+  gem 'haml'
+  gem 'rake'
+  gem 'jeweler'
+end

data/Users/dneighman/Projects/wrapt/Gemfile.lock

@@ -0,0 +1,80 @@
+--- 
+dependencies: 
+  ZenTest: 
+    group: 
+    - :test
+    version: ">= 0"
+  haml: 
+    group: 
+    - :test
+    version: ">= 0"
+  any_view: 
+    group: 
+    - :default
+    version: ">= 0"
+  rake: 
+    group: 
+    - :test
+    version: ">= 0"
+  hashie: 
+    group: 
+    - :default
+    version: ">= 0"
+  rspec: 
+    group: 
+    - :test
+    version: ">= 0"
+  rack: 
+    group: 
+    - :test
+    version: ">= 0"
+  jeweler: 
+    group: 
+    - :test
+    version: ">= 0"
+  tilt: 
+    group: 
+    - :default
+    version: ">= 0"
+specs: 
+- rake: 
+    version: 0.8.7
+- ZenTest: 
+    version: 4.3.1
+- tilt: 
+    version: "0.9"
+    source: 1
+- any_view: 
+    version: 0.2.0pre
+    source: 0
+- json_pure: 
+    version: 1.4.2
+- gemcutter: 
+    version: 0.5.0
+- git: 
+    version: 1.2.5
+- haml: 
+    version: 2.2.24
+- hashie: 
+    version: 0.2.0
+- rubyforge: 
+    version: 2.0.4
+- jeweler: 
+    version: 1.4.0
+- rack: 
+    version: 1.1.0
+- rspec: 
+    version: 1.3.0
+hash: 5219adb34705354844440dcaeead99c7e6b271c5
+sources: 
+- Git: 
+    uri: git://github.com/hassox/any_view.git
+    git: git://github.com/hassox/any_view.git
+    ref: e1db4990883427eb634ae824ef95928f4ca51415
+- Git: 
+    uri: git://github.com/hassox/tilt.git
+    branch: :hassox
+    git: git://github.com/hassox/tilt.git
+    ref: 8c652c803c1a62ec9854e1c320bee58c40546349
+- Rubygems: 
+    uri: http://gemcutter.org

data/Users/dneighman/Projects/wrapt/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Daniel Neighman
+
+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/Users/dneighman/Projects/wrapt/README.textile

@@ -0,0 +1,162 @@
+h1. Wrapt
+
+Wrapt is a rack middleware that provides facilities to any rack application for wrapping the content in a consistent layout.
+
+Wrapt is intended to sit out the front of a rack graph (but doesn't have to), and is only activated when a downstream application asks to be wrapped in a layout. This means that disparate rack applications that have been mounted, may share the same layout and appear to belong to a single application.
+
+Wrapt injects a layout object into the Rack environment which is idle until activated.  To activeate, just assign it some content, and return it as the body portion of your response.
+
+h2. Example
+
+Declare your middleware stack
+<pre><code lang='ruby'>use Wrapt
+run MyApp
+</code></pre>
+
+Get your application using the wrapt layout
+<pre><code>class MyApp
+  def self.call(env)
+    new.call(env)
+  end
+
+  def call(env)
+    layout = env['layout']
+    layout.content = "This is the content of my app"
+    Rack::Response.new(layout).finish
+  end
+end
+</code></pre>
+
+Say our layout file looked like this:
+
+<pre><code>%html
+  %body
+    = yield
+</code></pre>
+
+We would end up with:
+
+<pre><code lang='html'><html>
+  <body>
+    This is the content of my app
+  </body>
+</html>
+</code></pre>
+
+h2. Layout Files
+
+Wrapt is built on "Tilt":http://github.com/rtomayko/tilt Any tilt compatible template is usable.
+
+A layout file is one that is constructed for use with a layout.  To fill in the content into the layout template, you 'yield'.
+
+h3. Template Location
+
+By default, wrapt will look in the following palces for your layout templates:
+
+* layouts
+* views/layouts
+* app/views/layouts
+
+You can customize this by passing an array of directory locations to wrapt when declaring the middleware.
+
+<pre><code>use Wrapt do |wrapt|
+  wrapt.layout_dirs = ["/path/to/my/layouts", "/fallback/path/to/layouts"]
+end
+</code></pre>
+
+Directories are checked in order and the first template found is used.
+
+h3. Template Naming
+
+Templates follow a simple naming convention.
+
+<pre><code><template_name>.<format>.<template_type></code></pre>
+
+For example.  The default template name is "application" with a default format of "html".  This will match anything then of the form "application.html"
+
+And will render the layout, inserting the content in the right spot.
+
+You can define the name of the default template when declaring the middleware
+
+<pre><code>use Wrapt do |wrapt|
+  wrapt.default_template = "my_default_layout"
+end
+</code></pre>
+
+You can also select the layout to use inside a request.  The following sets the layout for all downstream applications as 'special' (unless it's changed downstream')
+
+<pre><code>def call(env)
+  layout = env['layout']
+
+  layout.template_name = "special"
+  app.call(env)
+end
+</code></pre>
+
+h3. Format
+
+Layouts are associated with a format.  By default the format is html.  Tempaltes are selected by their name with <name>.<format>.<template_type>.
+
+You can select a default format when declaring the middleware
+
+<pre><code>use Wrapt do |wrapt|
+  wrapt.default_format = :json
+end
+</code></pre>
+
+Or in the request
+<pre><code>def call(env)
+  layout = env['layout']
+  layout.format = :json
+  layout.content = {:my => "hash"}.to_json
+end
+</code></pre>
+
+h3. Content Sections
+
+Wrapt allows you to have different sections of content.  To declare this:
+
+<pre><code>layout.content = "foo" # main content
+layout.set_content_for(:nav, "some navigation")
+</code></pre>
+
+Once that content is set, you may then use it in the layout by yielding to the layout.
+
+<pre><code>%h1 My Layout
+= yield # yields the main content
+
+%nav
+  = yield :nav # yields the content with the label :nav
+</code></pre>
+
+h3. Helpers
+
+You can include any helpers you need into the layout by including them into
+
+Wrapt::Helpers
+
+h3. Wrapping content on demand
+
+You can use the layouter object to wrap content on demand
+
+<pre><code>def call(env)
+  layout = env['layout']
+  wrapped_content = layout.wrap("my content", :layout => :inner_layout, :format => :json)
+  layout.content = wrapped_content
+  Rack::Response(layout).finish
+end
+</code></pre>
+
+h2. Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+h2. Copyright
+
+Copyright (c) 2010 Daniel Neighman. See LICENSE for details.

data/Users/dneighman/Projects/wrapt/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "wrapt"
+    gem.summary = %Q{TODO: one-line summary of your gem}
+    gem.description = %Q{TODO: longer description of your gem}
+    gem.email = "has.sox@gmail.com"
+    gem.homepage = "http://github.com/hassox/wrapt"
+    gem.authors = ["Daniel Neighman"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "wrapt #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/Users/dneighman/Projects/wrapt/VERSION

@@ -0,0 +1 @@
+0.1.0

data/Users/dneighman/Projects/wrapt/lib/wrapt.rb

@@ -0,0 +1,7 @@
+require 'hashie'
+require 'tilt'
+
+require 'wrapt/wrapt'
+require 'wrapt/layout'
+require 'wrapt/helpers'
+require 'wrapt/layout_context'

data/Users/dneighman/Projects/wrapt/lib/wrapt/helpers.rb

@@ -0,0 +1,6 @@
+class Wrapt
+  # Included in the LayoutContext.
+  # Mixin any helpers or methods into the Wrapt::Helpers module
+  module Helpers
+  end
+end

data/Users/dneighman/Projects/wrapt/lib/wrapt/layout.rb

@@ -0,0 +1,132 @@
+class Wrapt
+  class Layout
+    include Enumerable
+    attr_accessor :wrapt, :env, :template_name, :format
+
+    def initialize(wrapt, env)
+      @env = env
+      @wrapt = wrapt
+      @content_for = Hashie::Mash.new
+    end
+
+    # Is the wrapt instance that created this layouter set as a master?
+    # @see Wrapt#master?
+    def master?
+      @wrapt.master?
+    end
+
+    # Gets the format that this layouter has been set to.
+    # Defaults to the default_format of the wrapt instance
+    #
+    # May be set with Wrapt::Layout#format=
+    #
+    # @see Wrapt#default_format
+    def format
+      @format ||= @wrapt.default_format
+    end
+
+    # Gets the template name that this layouter has.
+    # Defaults to the wrapts instances default_template
+    #
+    # May be set with Wrapt::Layout#default_template=
+    #
+    # @see Wrapt.default_template
+    def template_name
+      @template_name ||= @wrapt.default_template
+    end
+
+    # Wraps the given content into the layout using the same base
+    # as the layouter currently has
+    #
+    # @params [String] content The content to form the main body of the layout
+    # @params [Hash] opts an options hash
+    # @option opts [String|Symbol] :layout the name of a layout template to use
+    # @option opts [String|Symbol] :format the format of the layout template to use
+    # @api public
+    def wrap(content, opts={})
+      layout = self.dup
+
+      layout.format         = opts[:format] if opts[:format]
+      layout.template_name  = opts[:layout] if opts[:layout]
+
+      layout.content = content
+      layout.map.join
+    end
+
+    def dup
+      dupped = super
+      dupped.instance_variable_set('@content_for', Hashie::Mash.new)
+      dupped
+    end
+
+    # Set the content for the layout for the given label
+    # @param [Symbol] label The label to identify the content to insert
+    # @param [String] content The content to set for this label
+    # @block The return of the block is used as preference.  Block is optional
+    #
+    # @see Wrapt::Layout#content_for
+    # @api public
+    def set_content_for(label = :content, content = nil)
+      if block_given?
+        content = block.call
+      end
+
+      content_for[label] = content
+    end
+
+    # Provides access to the content_for hash.
+    # Content may be accessed for concatination etc
+    #
+    # When using content_for you can provide different contents for you layouts.
+    # The default content label is :content
+    # @example
+    #   # In your application
+    #   layout = env['layout']
+    #   layout.set_content_for(:foo, "Foo Content")
+    #   layout.content = "Normal Content"
+    #
+    #
+    #   # In the layout
+    #   <%= yield %>          <-- inserts the content labeled :content
+    #   <%= yield :content %> <-- insert the content labeled :content
+    #   <%= yield :foo %>     <-- insert the content labled :foo
+    #
+    # @api public
+    def content_for
+      @content_for
+    end
+
+    # Set the main content for the layout
+    # @api public
+    def content=(content)
+      set_content_for(:content, content)
+    end
+
+    # An easy method to get the wrapped results
+    # @api public
+    def to_s
+      map.join
+    end
+
+    # The interface for rack.
+    # @api public
+    def each
+      opts = {}
+      opts[:format]   ||= format
+      template = template_name
+
+      template = @wrapt.template(template, opts)
+
+      output = if template
+        template.render(LayoutContext.new) do |*args|
+          label = args.first || :content
+          content_for[label]
+        end
+      else
+        content_for[:content]
+      end
+      yield output
+      output
+    end
+  end
+end

data/Users/dneighman/Projects/wrapt/lib/wrapt/layout_context.rb

@@ -0,0 +1,9 @@
+class Wrapt
+  # The context used within the layouts
+  # Anything that is required to be avaible in the view context should be included into the Helpers module, or the LayoutContext
+  # @see Wrapt::Helpers
+  class LayoutContext
+    include Tilt::CompileSite
+    include Helpers
+  end
+end

data/Users/dneighman/Projects/wrapt/lib/wrapt/wrapt.rb

@@ -0,0 +1,175 @@
+# Wrapt is a specialised middleware that wraps content in a given layout
+#
+# Wrapt injects an object into the environment which you can use to provide content to.
+# When you're done, return the wrapt object as the body for your request and the layout will be applied.
+#
+# You can pass variables through the rack through the environment via the 'request.variables' key which will be a hash like object
+#
+#
+# @example
+#
+# def call(e)
+#   wrapt = e['layout']
+#   wrapt.content = "Here's some content"
+#   [200, {"Content-Type" => "text/html"}, wrapt]
+# end
+#
+# Produces:
+#   <!-- wrapping layout -->
+#     Here's some content
+#   <!-- footer wrapping layout -->
+#
+# A layout directory may be specified that points to any layouts that are to be used.
+#
+# A format may be specified for the layout if it is intended not to use html.
+# Simply tell wrapt the format to use via the +format=+ method.
+#
+# If you don't want a layout, simply don't use the wrapt object.
+class Wrapt
+
+  # Wrapt is initialized as middleware in a Rack stack
+  # @block the wrapt instance is passed to the block for further configuration
+  #   You can set layout template directories,
+  #   Default format, default layout or declare the layouter as the "master"
+  #
+  # @see Wrapt#master!
+  # @see Wrapt#layout_dirs
+  # @see Wrapt#default_format
+  # @see Wrapt#default_template
+  def initialize(app)
+    @app = app
+    @master = false
+    yield self if block_given?
+  end
+
+  # Declare this wrapt instance to be the master
+  # This will mean that all downstream wrapt instances will be ignored
+  # and this layouter will be used for the entire downstream graph
+  #
+  # @api public
+  def master!
+    @master = true
+  end
+
+  # Checks to see if this layouter is a master
+  # @api private
+  def master?
+    !!@master
+  end
+
+  def call(env)
+    env['request.variables'] ||= Hashie::Mash.new
+    layout = env['layout']
+    if !layout || (layout && !layout.master?)
+      env['layout'] = Layout.new(self, env)
+    end
+    r = @app.call(env) # just return what the app returns… If it wants a layout, it will return it.
+    env['layout'] = layout if layout
+    r
+  end
+
+  # Set the layout directories
+  # These are the directories that wrapt will inspect (in order) when it attempts to find the given layouts
+  # @param [Array] dirs An array of directories where wrapt should look to find the layout templates
+  # @api public
+  def layout_dirs=(dirs)
+    @layout_dirs = Array.new(dirs).flatten
+  end
+
+  # Provides access to the directories where wrapt will inspect to find the layouts
+  # @api public
+  # @return [Array] An array of directories that wrapt will look in for template files
+  def layout_dirs
+    @layout_dirs ||= begin
+      [
+        File.join(Dir.pwd, "layouts"),
+        File.join(Dir.pwd, "views/layouts"),
+        File.join(Dir.pwd, "app/views/layouts")
+      ]
+    end
+  end
+
+  # The default template name wrapt will use when none is specified
+  # @api public
+  # @return [String] default template name
+  def default_template
+    @default_template ||= "application"
+  end
+
+  # set the default template
+  # @api public
+  # @see Wrapt#default_template
+  def default_template=(name)
+    @default_template = name
+  end
+
+  # Get the default format that has been defined for the instance of wrapt
+  #
+  # The format is used by default in the template file name.
+  # The default naming convention for the template name is
+  #   <template_name>.<format>.<template_type>
+  #
+  # @example
+  #   application.html.haml
+  # @api public
+  def default_format
+    @default_format ||= :html
+  end
+
+  # Set the default format for this instance of wrapt
+  # @see Wrapt#default_format
+  # @api public
+  def default_format=(format)
+    @default_format = format
+  end
+
+  # Fetches the named template with any given options
+  #
+  # @param [String|Symbol] The template name to fetch
+  # @param [Hash] opts
+  # @option opts [String|Symbol] :format Provide the format for the template that will be used
+  # @return [Tilt::Template|NilClass] A template file to use to render the layout
+  # @api public
+  def template(name, opts={})
+    format = opts.fetch(:format, default_format)
+    template_name = template_name_and_format_glob(name,format, opts)
+
+    return _template_cache[template_name] if _template_cache[template_name]
+
+    file = nil
+    layout_dirs.detect do |dir|
+      file = Dir[File.join(dir, template_name)].first
+    end
+
+    if file.nil?
+      nil
+    else
+      _template_cache[template_name] = Tilt.new(file)
+    end
+  end
+
+  private
+  # Calculates the relative filename of the template
+  # @param [String|Symbol] name The template name
+  # @param [String|Symbol] format The template format
+  # @param [Hash] opts An options hash that is provided to the template method
+  #
+  # @see Wrapt#template
+  # @api overwritable
+  def template_name_and_format(name, format, opts)
+    "#{name}.#{format}"
+  end
+
+  # Provides a glob from the template_name_and_format to look up the file from
+  # @api private
+  def template_name_and_format_glob(name, format, opts)
+    "#{template_name_and_format(name,format,opts)}.*"
+  end
+
+  # A cache for the template files so that they're only loaded once
+  # @api private
+  def _template_cache
+    @cache ||= {}
+  end
+end
+

data/Users/dneighman/Projects/wrapt/spec/alt_layouts/second.html.haml

@@ -0,0 +1 @@
+%h1 Second (Alternative)

data/Users/dneighman/Projects/wrapt/spec/layouts/first.html.haml

@@ -0,0 +1 @@
+%h1 Layout: First

data/Users/dneighman/Projects/wrapt/spec/layouts/multiple.html.haml

@@ -0,0 +1,3 @@
+%h1 Multiple Contents
+.content= yield
+.foo= yield :foo

data/Users/dneighman/Projects/wrapt/spec/layouts/other.html.haml

@@ -0,0 +1,4 @@
+%h1 Other Template
+
+.content
+  = yield

data/Users/dneighman/Projects/wrapt/spec/layouts/wrapper.html.haml

@@ -0,0 +1,4 @@
+%h1 Wrapper Template
+
+.content
+  = yield

data/Users/dneighman/Projects/wrapt/spec/layouts/wrapper.jsonp.erb

@@ -0,0 +1,2 @@
+var data = { content: '<%= yield %>' }
+my_function(data);

data/Users/dneighman/Projects/wrapt/spec/layouts/wrapper.xml.haml

@@ -0,0 +1,4 @@
+%h1 Wrapper Template XML
+
+.content
+  = yield

data/Users/dneighman/Projects/wrapt/spec/spec.opts

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

data/Users/dneighman/Projects/wrapt/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'wrapt'
+require 'spec'
+require 'spec/autorun'
+require 'rack'
+require 'haml'
+
+Spec::Runner.configure do |config|
+
+end

data/Users/dneighman/Projects/wrapt/spec/wrapt_spec.rb

@@ -0,0 +1,245 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Wrapt do
+  before(:all) do
+    unless defined?(SpecWraptApp)
+      SpecWraptApp = lambda do |e|
+        msg = $message || "ok"
+        layout = e['layout']
+
+        out = if layout
+          layout.content = msg
+          layout
+        else
+          msg
+        end
+        Rack::Response.new(out).finish
+      end
+    end
+  end
+
+  def layouts_dirs
+    [File.join(File.dirname(__FILE__), "layouts")]
+  end
+
+  def alt_layouts_dirs
+    [File.join(File.dirname(__FILE__), "alt_layouts")]
+  end
+
+  describe "defining the middleware" do
+    before do
+      @wrapt = Wrapt.new(SpecWraptApp){|w| w.default_template = "wrapper"}
+    end
+
+    it "should allow me to define the directories to use to find the templates" do
+      w = Wrapt.new(SpecWraptApp)
+      w.layout_dirs = layouts_dirs
+      w.layout_dirs.should == layouts_dirs
+    end
+
+    it "should allow me to set the layout_dirs in the middleware" do
+      w = Wrapt.new(SpecWraptApp) do |wrapt|
+        wrapt.layout_dirs = layouts_dirs
+      end
+      w.layout_dirs.should == layouts_dirs
+    end
+
+    it "should provide me with the Dir.pwd/layouts as the default location to find layouts" do
+      @wrapt.layout_dirs.should == [
+        File.join(Dir.pwd, "layouts"),
+        File.join(Dir.pwd, "views/layouts"),
+        File.join(Dir.pwd, "app/views/layouts")
+      ]
+    end
+
+    it "should use the 'application' template by default" do
+      wrapt = Wrapt.new(SpecWraptApp)
+      wrapt.default_template.should == "application"
+    end
+
+    it "should allow me to set my own default template" do
+      @wrapt.default_template = "my_template"
+      @wrapt.default_template.should == "my_template"
+    end
+
+    it "should allow me to set a default format" do
+      @wrapt.default_format = :json
+      @wrapt.default_format.should == :json
+    end
+
+    it "should have a default format of :html" do
+      @wrapt.default_format.should == :html
+    end
+
+    it "should provide a hook for me to work out the format to use"
+  end
+
+  describe "managing templates" do
+    before do
+      @wrapt = Wrapt.new(SpecWraptApp) do |w|
+        w.layout_dirs = layouts_dirs
+      end
+    end
+
+    it "should find me a template of a given name with the format for the current request" do
+      @wrapt.template(:first).should be_a_kind_of(Tilt::Template)
+    end
+
+    it "should return nil when there is no format found of that name" do
+      @wrapt.template("not_a_real_template").should be_nil
+    end
+
+    it "should return nil when there is no format found of that format" do
+      @wrapt.template(:first, :format => :no_real_forma).should be_nil
+    end
+
+    it "should search all the layout directories provided to return the template" do
+      @wrapt = Wrapt.new(SpecWraptApp) do |w|
+        w.layout_dirs = layouts_dirs + alt_layouts_dirs
+      end
+      @wrapt.template(:second).should be_a_kind_of(Tilt::Template)
+      @wrapt.template(:second).render.should match(/Second \(Alternative\)/)
+    end
+  end
+
+  describe "injecting into the environment" do
+    before do
+      @wrapt = Wrapt.new(SpecWraptApp){|w| w.default_template = :wrapper}
+    end
+
+    it "should inject a Wrapt::Layout object into the environment" do
+      env = {}
+      @wrapt.call(env)
+      env['layout'].should be_an_instance_of(Wrapt::Layout)
+    end
+
+    it "should make sure there's a request.variables key in the env" do
+      env = {}
+      @wrapt.call(env)
+      vars = env['request.variables']
+      vars.should_not be_nil
+      vars.should respond_to(:[])
+      vars.should respond_to(:[]=)
+      vars.should respond_to(:clear)
+      vars.should respond_to(:keys)
+    end
+
+    it "should allow me to define an upstream wrapt as the master, meaning it won't be replaced by any downstream ones" do
+      env = Rack::MockRequest.env_for("/")
+      @wrapt.master!
+      wrapt2 = Wrapt.new(SpecWraptApp) do |wrapt|
+        wrapt.default_format = :jsonp
+        wrapt.default_template = :wrapper
+      end
+
+      @wrapt.call(env)
+      r = wrapt2.call(env)
+
+      layout = env['layout']
+      result = r[2].body.to_s
+      result.should_not include("{ content")
+      layout.wrapt.should == @wrapt
+    end
+
+    it "should allow me to define an upstream wrapt and a downstream, and have the downstream one work downstream and the upstream one work upstream" do
+      env = Rack::MockRequest.env_for("/")
+
+      wrapt2 = Wrapt.new(SpecWraptApp) do |wrapt|
+        wrapt.default_format = :jsonp
+        wrapt.default_template = :wrapper
+        wrapt.layout_dirs = layouts_dirs
+      end
+
+      s = @wrapt.call(env)
+      r = wrapt2.call(env)
+
+      result = r[2].body.to_s
+      result.should include("{ content")
+      layout = env['layout']
+      layout.wrapt.should == @wrapt
+    end
+  end
+
+  describe Wrapt::Layout do
+    before(:all) do
+      unless defined?(WraptApp)
+        WraptApp = lambda do |e|
+          layout = e['layout']
+          layout.content = $msg || "ok"
+          Rack::Response.new(layout).finish
+        end
+      end
+    end
+
+    before do
+      @wrapt = Wrapt.new(WraptApp) do |w|
+        w.layout_dirs = layouts_dirs
+        w.default_template = "wrapper"
+      end
+
+      @env = Rack::MockRequest.env_for("/")
+      @wrapt.call(@env)
+      @layout = @env['layout']
+    end
+
+    describe "on demand" do
+      it "should wrap content on demand" do
+        result = @layout.wrap("Hi There")
+        result.should include("Hi There")
+        result.should include("<h1>Wrapper Template</h1>")
+      end
+
+      it "should wrap the content with a different layout" do
+        result = @layout.wrap("Hi There", :layout => :other)
+        result.should include("Other Template")
+        result.should include("Hi There")
+      end
+
+      it "should wrap the content with a different format" do
+        result = @layout.wrap("Hi There", :format => :xml)
+        result.should include("<h1>Wrapper Template XML</h1>")
+        result.should include("Hi There")
+      end
+    end
+
+    it "should allow me to set the content" do
+      @layout.content = "This is some content of mine"
+      result = @layout.map.join
+      result.should include("This is some content of mine")
+      result.should include("<h1>Wrapper Template</h1>")
+    end
+
+    it "should allow me to set the format of a request" do
+      @layout.format = :xml
+      result = @layout.map.join
+      result.should include("<h1>Wrapper Template XML</h1>")
+    end
+
+    it "should ask the middleware for the format if no format is set" do
+      @wrapt = Wrapt.new(WraptApp) do |w|
+        w.layout_dirs = layouts_dirs
+        w.default_template = "wrapper"
+        w.default_format   = :jsonp
+      end
+      @env = Rack::MockRequest.env_for("/")
+      @wrapt.call(@env)
+      @layout = @env['layout']
+      @layout.content = "json data"
+      result = @layout.map.join
+      result.should include("{ content: 'json data' }")
+    end
+
+    it "should provide me with the wrapped layout with to_s" do
+      @layout.to_s.should == @layout.map.join
+    end
+
+    it "should yield multiple contents" do
+      @layout.content = "Main Content"
+      @layout.set_content_for(:foo, "Foo Content")
+      @layout.template_name = "multiple"
+      result = @layout.to_s
+      result.should include("<div class='content'>Main Content</div>")
+      result.should include("<div class='foo'>Foo Content</div>")
+    end
+  end
+end

data/Users/dneighman/Projects/wrapt/wrapt.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require 'bundler'
+
+Gem::Specification.new do |s|
+  s.name = %q{wrapt}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Daniel Neighman"]
+  s.date = %q{2010-04-30}
+  s.description = %q{Layouts in rack}
+  s.summary = %q{Layouts in rack}
+  s.homepage = %q{http://github.com/hassox/wrapt}
+  s.email = %q{has.sox@gmail.com}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+
+  s.files = Dir[File.join(Dir.pwd, "**/*")]
+
+  s.add_bundler_dependencies
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: wrapt
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel Neighman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-30 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  name: any_view
+  prerelease: false
+  requirement: *id001
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  name: hashie
+  prerelease: false
+  requirement: *id002
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  name: tilt
+  prerelease: false
+  requirement: *id003
+  type: :runtime
+description: Layouts in rack
+email: has.sox@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- /Users/dneighman/Projects/wrapt/Gemfile
+- /Users/dneighman/Projects/wrapt/Gemfile.lock
+- /Users/dneighman/Projects/wrapt/lib/wrapt/helpers.rb
+- /Users/dneighman/Projects/wrapt/lib/wrapt/layout.rb
+- /Users/dneighman/Projects/wrapt/lib/wrapt/layout_context.rb
+- /Users/dneighman/Projects/wrapt/lib/wrapt/wrapt.rb
+- /Users/dneighman/Projects/wrapt/lib/wrapt.rb
+- /Users/dneighman/Projects/wrapt/LICENSE
+- /Users/dneighman/Projects/wrapt/Rakefile
+- /Users/dneighman/Projects/wrapt/README.textile
+- /Users/dneighman/Projects/wrapt/spec/alt_layouts/second.html.haml
+- /Users/dneighman/Projects/wrapt/spec/layouts/first.html.haml
+- /Users/dneighman/Projects/wrapt/spec/layouts/multiple.html.haml
+- /Users/dneighman/Projects/wrapt/spec/layouts/other.html.haml
+- /Users/dneighman/Projects/wrapt/spec/layouts/wrapper.html.haml
+- /Users/dneighman/Projects/wrapt/spec/layouts/wrapper.jsonp.erb
+- /Users/dneighman/Projects/wrapt/spec/layouts/wrapper.xml.haml
+- /Users/dneighman/Projects/wrapt/spec/spec.opts
+- /Users/dneighman/Projects/wrapt/spec/spec_helper.rb
+- /Users/dneighman/Projects/wrapt/spec/wrapt_spec.rb
+- /Users/dneighman/Projects/wrapt/VERSION
+- /Users/dneighman/Projects/wrapt/wrapt.gemspec
+has_rdoc: true
+homepage: http://github.com/hassox/wrapt
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Layouts in rack
+test_files: []
+