pakada-render 0.2.0

data/.rspec

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

data/Gemfile

@@ -0,0 +1,13 @@
+source :rubygems
+
+gemspec
+
+gem "rake"
+gem "awesome_print"
+
+gem "shotgun"
+gem "thin"
+
+gem "fakefs", :git => "https://github.com/lgierth/fakefs",
+              :branch => "fix_infinite_loop"
+gem "pakada-dispatch", :git => "https://github.com/lgierth/pakada-dispatch"

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Lars Gierth
+
+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/README.md

@@ -0,0 +1,4 @@
+Template rendering for Pakada
+=============================
+
+TODO: Write documentation

data/Rakefile

@@ -0,0 +1,4 @@
+task :default => :spec
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new :spec

data/config.ru

@@ -0,0 +1,21 @@
+require "pakada/dispatch"
+require "pakada/render"
+require "awesome_print"
+
+class ::MyModule
+  include Pakada::Module
+  @path = Pathname.new(".")
+  @dependencies << Pakada::Dispatch
+  
+  def routes
+    route :test, "/", &controller(:foo).action(:bar)
+  end
+end
+
+Pakada.instance(:default) {|ins|
+  ins.urls = ["/"]
+  ins.modules = MyModule, Pakada::Render
+}
+
+Pakada.boot
+run Pakada

data/controllers/foo.rb

@@ -0,0 +1,3 @@
+action(:bar) {
+  @name = "world"
+}

data/lib/pakada-render.rb

@@ -0,0 +1 @@
+require "pakada/theming"

data/lib/pakada/render.rb

@@ -0,0 +1,77 @@
+require "hike"
+require "tilt"
+
+require "pakada"
+
+require "pakada/render/controller"
+require "pakada/render/renderer"
+require "pakada/render/rendering"
+require "pakada/render/rendering_context"
+require "pakada/render/version"
+
+class Pakada::Render
+  include Pakada::Module
+  
+  attr_reader :load_path, :template_map
+  
+  def initialize
+    Pakada.safety(RenderingContext).send :include, Hooked
+  end
+  
+  def hooks
+    if Pakada[:dispatch]
+      Pakada[:dispatch].after :request, method(:render_layout)
+      Pakada.safety(Pakada::Dispatch::Controller).tap {|c|
+        c.around(:included) {|inner, klass|
+          inner.call klass
+          klass.send :include, Pakada.safety(Pakada::Render::Controller)
+          klass.after :new, method(:render_controller)
+        }
+      }
+    end
+  end
+  
+  def boot
+    Pakada.modules.each_value {|mod|
+      mod.extend Pakada.safety(Pakada::Render::Rendering)
+    }
+    
+    @load_path = build_load_path
+    @template_map = build_template_map(load_path)
+  end
+  
+  def build_load_path
+    Hike::Trail.new("/").tap {|load_path|
+      load_path.append_extensions *Tilt.mappings.keys
+      load_path.append_path Pakada.path.join("templates")
+      Pakada.modules.each_value {|mod|
+        load_path.append_path mod.path.join("templates")
+      }
+    }
+  end
+  
+  def build_template_map(load_path)
+    load_path.paths.map {|path|
+      prefix = %r|#{Regexp.quote path.to_s}/|
+      Dir.glob("#{path}/**/*").map {|filepath|
+        next if File.directory? filepath
+        filepath.gsub(prefix, "").rpartition(".").first
+      }
+    }.flatten.compact.uniq.inject({}) {|map, name|
+      map[name.to_sym] = Tilt.new(load_path.find(name))
+      map
+    }
+  end
+  
+  def render_controller(controller)
+    controller.response.write controller.render if controller.render?
+  end
+  
+  def render_layout(response)
+    content = []
+    response[2].each {|chunk| content << chunk }
+    response[2] = [render!(:layout, :content => content)]
+    
+    response[1].delete "Content-Length"
+  end
+end

data/lib/pakada/render/controller.rb

@@ -0,0 +1,45 @@
+class Pakada::Render
+  module Controller
+    def self.included(klass)
+      klass.extend Pakada.safety(self::ClassMethods)
+      klass.instance_variable_set :@rendering_rules, :render => [], :dont_render => []
+    end
+    
+    def render(template = nil, additional_locals = {})
+      if Hash === template
+        template, additional_locals = nil, template
+      end
+      template ||= options.values_at(:module, :controller, :action).join("/")
+
+      locals = instance_variables.inject({}) {|locals, key|
+        locals[key] = instance_variable_get(key)
+        locals
+      }.merge(additional_locals)
+      Pakada[options[:module]].render template.to_sym, locals
+    end
+    
+    def render?
+      action = options[:action]
+      render, dont_render = *self.class.rendering_rules.values_at(:render, :dont_render)
+      
+      !dont_render.include?(action) && (
+        !dont_render.include?(:*) || render.include?(action))
+    end
+    
+    module ClassMethods
+      attr_reader :rendering_rules
+      
+      def dont_render(action = nil, *more_actions)
+        if action
+          rendering_rules[:dont_render].push action, *more_actions
+        else
+          rendering_rules[:dont_render] = [:*]
+        end
+      end
+      
+      def render(action, *more_actions)
+        rendering_rules[:render].push action, *more_actions
+      end
+    end
+  end
+end

data/lib/pakada/render/renderer.rb

@@ -0,0 +1,29 @@
+class Pakada::Render
+  class Renderer
+    attr_reader :engine, :locals
+    
+    def initialize(engine, locals = {})
+      @engine, @locals = engine, locals
+      @instance = Pakada.instance
+    end
+    
+    def to_s
+      @string ||= Pakada.instance(@instance.name) {
+        context = Pakada.safety(Pakada::Render::RenderingContext).new
+        engine.render context, locals
+      }
+    end
+    
+    def each
+      yield to_s
+    end
+    
+    def [](key)
+     locals[key]
+    end
+    
+    def []=(key, value)
+      locals[key] = value
+    end
+  end
+end

data/lib/pakada/render/rendering.rb

@@ -0,0 +1,14 @@
+class Pakada::Render
+  module Rendering
+    def render(template, locals = {})
+      engine = Pakada[:render].template_map[template.to_sym]
+      raise ArgumentError, "Unknown template #{template.inspect}" unless engine
+      
+      Pakada.safety(Pakada::Render::Renderer).new engine, locals
+    end
+    
+    def render!(template, locals = {})
+      render(template, locals).to_s
+    end
+  end
+end

data/lib/pakada/render/rendering_context.rb

@@ -0,0 +1,4 @@
+class Pakada::Render
+  class RenderingContext
+  end
+end

data/lib/pakada/render/version.rb

@@ -0,0 +1,5 @@
+class Pakada
+  class Render
+    VERSION = "0.2.0"
+  end
+end

data/pakada-render.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pakada/render/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pakada-render"
+  s.version     = Pakada::Render::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Lars Gierth"]
+  s.email       = ["lars.gierth@gmail.com"]
+  s.homepage    = "https://rubygems.org/gems/pakada-render"
+  s.summary     = %q{Template rendering for Pakada}
+  #s.description = %q{TODO: Write a gem description}
+
+  s.add_dependency "pakada"
+  s.add_dependency "tilt"
+  s.add_dependency "hike"
+  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fakefs"
+
+  s.files         = `git ls-files`.split("\n") - [".gitignore", ".travis.yml"]
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/controller_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+describe Pakada::Render::Controller do
+  let(:controller) {
+    Pakada.safety(Pakada::Dispatch::Controller).create {
+      include Pakada.safety(Pakada::Render::Controller)
+      action(:bar) {}
+    }
+  }
+  let(:obj) {
+    options = {
+      :module => :foo_module,
+      :controller => :foo,
+      :action => :bar
+    }
+    controller.new({}, options, &proc {})
+  }
+  
+  let(:foo_module) { stub "foo module" }
+  
+  before {
+    Pakada.modules[:foo_module] = foo_module
+  }
+  
+  context ".included(klass)" do
+    let(:klass) { stub "includer class" }
+    
+    it "extends klass with ClassMethods" do
+      class_methods = Pakada.safety(Pakada::Render::Controller::ClassMethods)
+      klass.should_receive(:extend).with class_methods
+      
+      Pakada.safety(Pakada::Render::Controller).included klass
+    end
+    
+    it "defaults #rendering_rules to empty Arrays" do
+      Pakada.safety(Pakada::Render::Controller).included klass
+      
+      klass.rendering_rules[:render].should be_an(Array)
+      klass.rendering_rules[:render].should be_empty
+      
+      klass.rendering_rules[:dont_render].should be_an(Array)
+      klass.rendering_rules[:dont_render].should be_empty
+    end
+  end
+  
+  context "#render(template, additional_locals)" do
+    let(:renderer) { stub "renderer" }
+    
+    it "returns a Renderer for the passed template" do
+      foo_module.should_receive(:render) {|template|
+        template.should equal(:foo)
+        renderer
+      }
+      
+      obj.render(:foo).should equal(renderer)
+    end
+    
+    it "passes all instance variables as locals to the Renderer" do
+      foo_module.should_receive(:render) {|template, locals|
+        locals[:@options].should equal(obj.options)
+        locals[:@params].should equal(obj.params)
+        locals[:@request].should equal(obj.request)
+        locals[:@response].should equal(obj.response)
+      }
+      obj.render additional_locals
+    end
+    
+    let(:additional_locals) {
+      {
+        :foo => stub("foo local"),
+        :bar => stub("bar local")
+      }
+    }
+    
+    it "merges additional_locals into the locals for Renderer" do
+      foo_module.should_receive(:render) {|template, locals|
+        locals[:foo].should equal(additional_locals[:foo])
+        locals[:bar].should equal(additional_locals[:bar])
+      }
+      obj.render additional_locals
+    end
+  end
+  
+  context "#render" do
+    it "defaults template to :<module>/<controller>/<action>" do
+      foo_module.should_receive(:render) {|template|
+        template.should equal(:"foo_module/foo/bar")
+      }
+      obj.render
+    end
+  end
+  
+  context "#render?" do
+    it "returns true by default" do
+      obj.render?.should be_true
+    end
+    
+    it "returns false if dont_render rules include action" do
+      controller.dont_render :bar
+      
+      obj.render?.should be_false
+    end
+    
+    it "returns false if dont_render rules include wildcard" do
+      controller.dont_render
+      
+      obj.render?.should be_false
+    end
+    
+    it "prioritizes render rules" do
+      controller.dont_render
+      controller.render :bar
+      
+      obj.render?.should be_true
+    end
+  end
+  
+  context ".render(action, *more_actions)" do
+    it "adds each action to the render ruleset" do
+      controller.tap {|c|
+        c.render :foo, :bar, :baz
+        c.rendering_rules[:render].should include(:foo)
+        c.rendering_rules[:render].should include(:bar)
+        c.rendering_rules[:render].should include(:baz)
+      }
+    end
+  end
+  
+  context ".dont_render(action, *more_actions)" do
+    it "adds each action to the dont_render ruleset" do
+      controller.tap {|c|
+        c.dont_render :foo, :bar, :baz
+        c.rendering_rules[:dont_render].should include(:foo)
+        c.rendering_rules[:dont_render].should include(:bar)
+        c.rendering_rules[:dont_render].should include(:baz)
+      }
+    end
+  end
+  
+  context ".dont_render" do
+    it "adds a wildcard to the dont_render ruleset" do
+      controller.dont_render
+      controller.rendering_rules[:dont_render].should include(:*)
+    end
+  end
+end

data/spec/render_spec.rb

@@ -0,0 +1,203 @@
+require "spec_helper"
+require "fileutils"
+
+describe Pakada::Render do
+  let(:render) { Pakada::Render.new }
+  
+  context "#initialize" do
+    it "makes RenderingContext hookable" do
+      render
+      Pakada.safety(Pakada::Render::RenderingContext).should respond_to(:instance_hooked)
+    end
+  end
+  
+  context "#hooks" do
+    let(:dispatch) { stub "dispatch module" }
+    
+    before {
+      Pakada.modules[:dispatch] = dispatch
+      dispatch.stub :after
+    }
+    
+    it "hooks Pakada::Dispatch#request with #render_layout" do
+      dispatch.should_receive(:after) {|method, block|
+        method.should equal(:request)
+        block.should == render.method(:render_layout)
+      }
+      render.hooks
+    end
+    
+    let(:klass) { stub "controller class", :include => nil }
+    
+    it "hooks Pakada::Dispatch::Controller.included to include Controller" do
+      Pakada.safety(Pakada::Dispatch::Controller).should_receive(:around) {|method, &block|
+        method.should equal(:included)
+        klass.should_receive(:send).with :include, Pakada.safety(Pakada::Render::Controller)
+        klass.should_receive(:after) {|method, block|
+          method.should equal(:new)
+          block.should == render.method(:render_controller)
+        }
+        block.call stub(:call => nil), klass
+      }
+      render.hooks
+    end
+    
+    it "hooks Pakada::Dispatch::Controller.included to hook controller#new with #render_controller" do
+      Pakada.safety(Pakada::Dispatch::Controller).should_receive(:around) {|method, &block|
+        method.should equal(:included)
+        klass.should_receive(:after) {|method, block|
+          method.should equal(:new)
+          block.should == render.method(:render_controller)
+        }
+        block.call stub(:call => nil), klass
+      }
+      render.hooks
+    end
+  end
+  
+  context "#boot" do
+    let(:load_path) { stub "load path" }
+    let(:template_map) { stub "template map" }
+    
+    before {
+      render.stub :build_load_path => load_path
+      render.stub :build_template_map => template_map
+      render.boot
+    }
+    
+    it "includes Rendering into each module" do
+      Pakada.modules.each_value {|mod|
+        rendering = Pakada.safety(Pakada::Render::Rendering)
+        (class << mod; self; end).included_modules.should include(rendering)
+      }
+    end
+    
+    it "builds the load path" do
+      render.load_path.should equal(load_path)
+    end
+    
+    it "builds the template map" do
+      render.template_map.should equal(template_map)
+    end
+  end
+  
+  context "#build_load_path" do
+    let(:load_path) { render.build_load_path }
+    
+    it "adds each of Tilt's mappings as an extension" do
+      Tilt.mappings.keys.each {|ext|
+        load_path.extensions.should include(".#{ext}")
+      }
+    end
+    
+    it "adds the Pakada instance's path first" do
+      load_path.paths[0].should == Pakada.path.join("templates").to_s
+    end
+    
+    it "adds each module's path" do
+      Pakada.modules.each_value {|mod|
+        load_path.paths.should include(mod.path.join("templates").to_s)
+      }
+    end
+  end
+  
+  context "#build_template_map(load_path)" do
+    let(:baz) { stub "baz engine" }
+    let(:layout) { stub "layout engine" }
+    let(:derp) { stub "derp engine" }
+    
+    before {
+      # undefined method `file?' for #<FakeFS::File::Stat:0xa72a808>
+      #FakeFS.activate!
+      
+      Pakada.stub :path => Pathname.new("spec/tmp/instance").expand_path
+      Pakada[:render].stub :path => Pathname.new("spec/tmp/pakada-render").expand_path
+      Pakada[:dispatch].stub :path => Pathname.new("spec/tmp/pakada-dispatch").expand_path
+      
+      path = Pakada[:render].path.join("templates")
+      FileUtils.mkdir_p path.join("foo/bar")
+      FileUtils.touch path.join("foo/bar/baz.erb").to_s
+      FileUtils.touch path.join("layout.md").to_s
+      FileUtils.touch path.join("herp_derp.haml").to_s
+      
+      path = Pakada[:dispatch].path.join("templates")
+      FileUtils.mkdir_p path.join("foo/bar")
+      FileUtils.touch path.join("foo/bar/baz.sass").to_s
+      FileUtils.touch path.join("layout.coffee").to_s
+      FileUtils.touch path.join("herp_derp.textile").to_s
+      
+      path = Pakada.path.join("templates")
+      FileUtils.mkdir_p path.join("foo/bar")
+      FileUtils.touch path.join("foo/bar/baz.str").to_s
+      FileUtils.touch path.join("layout.less").to_s
+      FileUtils.touch path.join("herp_derp.creole").to_s
+      
+      @engines = {
+        path.join("foo/bar/baz.str").to_s => baz,
+        path.join("layout.less").to_s => layout,
+        path.join("herp_derp.creole").to_s => derp
+      }
+    }
+    
+    after {
+      #FakeFS.deactivate!
+      #FakeFS::FileSystem.clear
+      
+      FileUtils.rm_rf "spec/tmp"
+    }
+    
+    let(:map) { render.build_template_map render.build_load_path }
+    
+    it "evaluates the complete load path" do
+      Tilt.should_receive(:new).exactly(3).times {|path| @engines[path] }
+      map.should == {
+       :"foo/bar/baz" => baz,
+       :layout => layout,
+       :herp_derp => derp
+      }
+    end
+  end
+  
+  context "#render_controller" do
+    let(:controller) { stub "controller", :response => stub("response") }
+    let(:result) { stub "result" }
+    
+    before { controller.stub :render => result }
+    
+    it "renders the controller's template" do
+      controller.stub :render? => true
+      controller.response.should_receive(:write).with result
+      
+      render.render_controller controller
+    end
+    
+    it "doesn't render if it's not supposed to" do
+      controller.stub :render? => false
+      controller.response.should_not_receive :write
+      
+      render.render_controller controller
+    end
+  end
+  
+  context "#render_layout" do
+    let(:response) {
+      [200, {"Content-Length" => "123"}, [content]]
+    }
+    let(:content) { stub "content" }
+    
+    before { render.stub :render! }
+    
+    it "render's a layout around the content" do
+      render.should_receive(:render!) {|template, locals|
+        template.should equal(:layout)
+        locals[:content].should == [content]
+      }
+      render.render_layout response
+    end
+    
+    it "removes the Content-Length header" do
+      render.render_layout response
+      response[1]["Content-Length"].should be_nil
+    end
+  end
+end

data/spec/renderer_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+describe Pakada::Render::Renderer do
+  let(:engine) { stub "engine" }
+  let(:locals) { stub "locals" }
+  let(:renderer) {
+    Pakada.safety(Pakada::Render::Renderer).new engine, locals
+  }
+  let(:rendered_template) { stub "renderer template "}
+  
+  context "#initialize(engine, locals)" do
+    it "sets engine and locals" do
+      renderer.engine.should equal(engine)
+      renderer.locals.should equal(locals)
+    end
+  end
+  
+  context "#to_s" do
+    let(:context) { stub "context" }
+    
+    before {
+      Pakada.safety(Pakada::Render::RenderingContext).stub :new => context
+      Pakada.instance(:foo) {}
+      renderer
+    }
+    
+    it "renders the template with the locals and a clean RenderingContext" do
+      engine.should_receive(:render) {|ctx, lkls|
+        context.should equal(ctx)
+        locals.should equal(lkls)
+        rendered_template
+      }
+      renderer.to_s.should equal(rendered_template)
+    end
+    
+    it "memoizes the renderer template" do
+      engine.should_receive(:render).once { rendered_template }
+      renderer.to_s
+      renderer.to_s.should equal(rendered_template)
+    end
+    
+    it "renders within the context of the Pakada instance it was created in" do
+      engine.should_receive(:render) {
+        Pakada.instance.should equal(Pakada.instance(:default))
+      }
+      Pakada.instance(:foo) { renderer.to_s }
+    end
+  end
+  
+  context "#each" do
+    it "yields the result of #to_s" do
+      renderer.should_receive(:to_s) { rendered_template }
+      yielded = []
+      renderer.each {|y| yielded << y }
+      
+      yielded.should == [rendered_template]
+    end
+  end
+  
+  context "#[](key)" do
+    let(:locals) {
+      {
+        :foo => stub("foo local")
+      }
+    }
+    
+    it "returns the value for the specified key in locals" do
+      renderer[:foo].should equal(locals[:foo])
+    end
+  end
+  
+  context "#[](key, value)" do
+    let(:locals) {
+      {
+        :foo => stub("foo local")
+      }
+    }
+    let(:bar) { stub "bar local" }
+    
+    it "sets the value for the specified key in locals" do
+      renderer[:bar] = bar
+      renderer[:bar].should equal(bar)
+    end
+  end
+end

data/spec/rendering_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe Pakada::Render::Rendering do
+  let(:render) { stub "render module" }
+  let(:renderer) { stub "renderer" }
+  let(:obj) {
+    Object.new.tap {|obj| obj.extend Pakada.safety(Pakada::Render::Rendering) }
+  }
+  
+  let(:engine) { stub "engine" }
+  let(:locals) { stub "locals" }
+  
+  before {
+    Pakada.safety(Pakada::Render::Renderer).stub :new => renderer
+    
+    Pakada.modules[:render] = render
+    render.stub :template_map => {
+      :foo => engine
+    }
+  }
+  
+  context "#render(template, locals)" do
+    it "raises an ArgumentError if there's no engine for the template" do
+      expect { obj.render :i_dont_exist }.to raise_error(ArgumentError)
+    end
+    
+    it "returns a Renderer for the specified template and locals" do
+      Pakada.safety(Pakada::Render::Renderer).should_receive(:new) {|ngin, lcls|
+        ngin.should equal(engine)
+        lcls.should equal(locals)
+        renderer
+      }
+      obj.render(:foo, locals).should equal(renderer)
+    end
+    
+    it "defaults locals to an empty Hash" do
+      Pakada.safety(Pakada::Render::Renderer).should_receive(:new) {|ngin, lcls|
+        lcls.should be_a(Hash)
+        lcls.should be_empty
+        renderer
+      }
+      obj.render(:foo).should equal(renderer)
+    end
+  end
+  
+  context "#render!(template, locals)" do
+    let(:rendered_template) { stub "rendered template" }
+    
+    it "returns #render#to_s" do
+      renderer.should_receive(:to_s) { rendered_template }
+      obj.render!(:foo, locals).should equal(rendered_template)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require "pakada/render"
+require "pakada/dispatch"
+
+require "fakefs/safe"
+
+begin
+  require "awesome_print"
+rescue LoadError; end
+
+RSpec.configure do |config|
+  config.before(:each) {
+    Pakada.instances.clear
+    Pakada.instance(:default) {}
+    
+    Pakada.stack.clear
+    Pakada.stack.push Pakada.instances[:default]
+  }
+end

data/templates/layout.erb

@@ -0,0 +1,3 @@
+<pre>
+  <%= content.join "\n" %>
+</pre>

data/templates/my_module/foo/bar.erb

@@ -0,0 +1 @@
+hello <%= @name %>!

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: pakada-render
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Lars Gierth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-03 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pakada
+  requirement: &72808660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *72808660
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: &72808220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *72808220
+- !ruby/object:Gem::Dependency
+  name: hike
+  requirement: &72807800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *72807800
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &72807480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *72807480
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: &72806970 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *72806970
+description: 
+email:
+- lars.gierth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- config.ru
+- controllers/foo.rb
+- lib/pakada-render.rb
+- lib/pakada/render.rb
+- lib/pakada/render/controller.rb
+- lib/pakada/render/renderer.rb
+- lib/pakada/render/rendering.rb
+- lib/pakada/render/rendering_context.rb
+- lib/pakada/render/version.rb
+- pakada-render.gemspec
+- spec/controller_spec.rb
+- spec/render_spec.rb
+- spec/renderer_spec.rb
+- spec/rendering_spec.rb
+- spec/spec_helper.rb
+- templates/layout.erb
+- templates/my_module/foo/bar.erb
+homepage: https://rubygems.org/gems/pakada-render
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Template rendering for Pakada
+test_files: []