template-inheritance 0.0.0.0.0.0.0.0.1 → 0.1

data/.gitignore

@@ -0,0 +1,9 @@
+/*.gem
+
+.DS_Store
+.cache
+.yardoc
+
+script/*
+.bundle
+.rvmrc

data/README.textile

@@ -1,3 +1,20 @@
 h1. About
 
-Currently this is just a placeholder, but in the future you can expect here a framework-agnostic template inheritance implementation from Rango.
+This is a framework-agnostic template inheritance engine from Rango.
+
+h1. Usage
+
+<pre>
+require "template-inheritance"
+
+TemplateInheritance::Template.paths &lt;&lt; File.expand_path("..", __FILE__)
+
+template = TemplateInheritance::Template.new("site/post.html.haml")
+template.render(post: post)
+</pre>
+
+h1. Haml Extensions
+
+<pre>
+Tilt::HamlTemplate.options[:default_attributes] = {form: {method: "post"}}
+</pre>

data/example/base.html.haml

@@ -0,0 +1,31 @@
+!!! 5
+
+/ Why should be poor templates so low-level?
+/ Even they deserve their Kernel#require!
+- includes "shared/google_analytics.html"
+
+%html
+  %head
+    / This is a great fun, the content for the block value
+    / can be just anything, not just some dumb string.
+    / The default value is there just in case that no
+    / scripts would be provided in children templates.
+    - block(:scripts, Array.new).each do |script|
+      %script{src: "/scripts/#{script}"}
+  %body
+    / Just to make sure that the default value for
+    / method works (as defined in example.rb).
+    %form{action: "/search"}
+
+    = block(:google_analytics)
+    = block(:main) do
+      / This is default content for the 'main' block.
+      / In case that we wouldn't fill in the block in
+      / any of child templates, the default content
+      / would be rendered. If we fill in the block,
+      / the default content is ignored.
+
+      / We can use either block(name, content)
+      / or block(name) { content }.
+
+      No content yet.

data/example/example.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
+require "ostruct"
+require "template-inheritance"
+
+TemplateInheritance::Template.paths << File.expand_path("..", __FILE__)
+
+post = OpenStruct.new(title: "My First Post!", content: "This is my first post!")
+
+# setup
+Tilt::HamlTemplate.options[:default_attributes] = {form: {method: "post"}}
+
+template = TemplateInheritance::Template.new("site/post.html.haml")
+puts "", template.render(post: post)

data/example/shared/google_analytics.html.haml

@@ -0,0 +1,8 @@
+/ This about this template as about a library, it
+/ provides some blocks (API) and it changes others.
+- block(:scripts).unshift("ga.js")
+
+- block(:google_analytics) do
+  / Google Analytics
+  %script
+    // Some clever JS magic.

data/example/site/_wtf.html.haml

@@ -0,0 +1,3 @@
+%p
+  Tell me why on Earth should I use partials now? But if you want them, here you are!
+  == Now let's test the local variables for partials, do they work? : #{local}

data/example/site/base.html.haml

@@ -0,0 +1,38 @@
+/ Extends means "use this template as a layout". Of course
+/ as this is template inheritance, the layout can have its
+/ own layout which can have its own layout etc, there's no
+/ restriction.
+
+/ The right fun starts with conditional extends, for example
+/ extends "base.html" unless request.ajax? (works in Rango)
+/ So in case of a XHR request it will just render current
+/ template without any layouting. Then if you use code
+/ "= block(:main)" instead of "- block(:main)", it will
+/ actually returns result of the block(:main) into the
+/ template. This way you are agnostic to XHR/non-XHR
+/ requests, simply return wrapped HTML or just the
+/ required chunk depending on the type of request.
+- extends "base.html" # unless request.ajax?
+
+/ Oh yeah you can access the value and modify it as you like!
+- block(:scripts).unshift("mootools-core.js")
+
+/ You might thing that the following solution might work
+/ as well, but it won't, because in this case it'd be the
+/ default value and default value is used just in case it
+/ won't get any value in the child template.
+/- block(:scripts, block(:scripts) + ["mootools-core"])
+
+/ However there's the extend_block helper which
+/ will rewrite the value from the child template:
+/- extend_block(:scripts, block(:scripts) + ["mootools-core"])
+
+/ Another one is enhance_block which does the same,
+/ but unlike the extend_block helper, it doesn't
+/ fail in case the block isn't defined yet.
+
+/ And you can also clear block using clear_block(name).
+
+- block(:main) do
+  %h1 Welcome to my cool blog!
+  = block(:post)

data/example/site/post.html.haml

@@ -0,0 +1,17 @@
+/ Paths
+
+/ ./base.html: Find template base.html in the same directory as current template.
+/ ../base.html: Find template base.html in parent directory of current template.
+
+/ base.html: find template base.html in TemplateInheritance::Template.paths array.
+/   The lookup works same as Ruby's require lookup, it's basically
+/   TemplateInheritance::Template.paths.find { |dir| File.join(dir, template_name) }
+- extends "./base.html"
+
+- block(:scripts, ["post.js"])
+
+- block(:post) do
+  %h2= post.title
+  %p= post.content
+
+  = partial "./wtf", local: true

data/lib/template-inheritance.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+require "template-inheritance/exts/tilt"
+require "template-inheritance/helpers"
+
+module TemplateInheritance
+  @@development = true
+  def self.development=(boolean)
+    @@development = boolean
+  end
+
+  def self.development?
+    @@development
+  end
+
+  def self.logger
+    @@logger ||= SimpleLogger.new
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  class TemplateNotFound < StandardError
+    def initialize(message = "Template not found")
+    end
+  end
+
+  class SimpleLogger
+    def log(message)
+      puts "~ #{message}"
+    end
+
+    alias_method :info, :log
+    alias_method :debug, :log
+  end
+
+  class Template
+    def self.paths
+      @@paths ||= Array.new
+    end
+
+    # template -> supertemplate is the same relationship as class -> superclass
+    # @since 0.0.2
+    attr_accessor :path, :scope, :supertemplate, :context
+
+    # @since 0.0.2
+    attr_writer :blocks
+    def blocks
+      @blocks ||= Hash.new
+    end
+
+    # @since 0.0.2
+    def initialize(path, scope = Object.new)
+      self.path  = path#[scope.class.template_prefix.chomp("/"), template].join("/")
+      self.scope = scope
+      self.scope.extend(TemplateHelpers)
+      # this enables template caching
+      unless TemplateInheritance.development?
+        self.scope.extend(Tilt::CompileSite)
+      end
+      self.scope.template = self
+    end
+
+    # @since 0.0.2
+    def fullpath
+      @fullpath ||= begin
+        if self.path.match(/^(\/|\.)/) # /foo or ./foo
+          Dir[self.path, "#{self.path}.*"].find {|file| !File.directory?(file)}
+        else
+          self.find_in_paths
+        end
+      end
+    end
+
+    def adapter
+      snake_case(self.template.class.name.split("::").last).sub("_template", "")
+    end
+
+    def extension # haml, erb ...
+      File.extname(path)[1..-1]
+    end
+
+    def template(options = Hash.new)
+      @template ||= Tilt.new(self.fullpath, nil, options)
+    end
+
+    # @since 0.0.2
+    def render(context = Hash.new)
+      raise TemplateNotFound.new("Template #{self.path} wasn't found in these paths: #{self.class.paths.inspect}") if self.fullpath.nil?
+      TemplateInheritance.logger.info("Rendering template #{self.path} with context keys #{context.keys.inspect}")
+      self.scope.context = self.context = context # so we can access context in the scope object as well
+      value = self.template.render(self.scope, context)
+      TemplateInheritance.logger.debug("Available blocks: #{self.blocks.keys.inspect}")
+      if self.supertemplate
+        TemplateInheritance.logger.debug("Extends call: #{self.supertemplate}")
+        supertemplate = self.class.new(self.supertemplate, self.scope)
+        supertemplate.blocks = self.blocks
+        return supertemplate.render(context)
+      end
+      value
+    end
+
+    protected
+    def find_in_paths
+      self.class.paths.each do |directory|
+        path = File.join(directory, self.path)
+        return Dir[path, "#{path}.*"].find {|file| !File.directory?(file)}
+      end
+    end
+
+    def snake_case(string)
+      return string.downcase if string =~ /^[A-Z]+$/
+      string.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+        return $+.downcase
+    end
+  end
+end

data/lib/template-inheritance/exts/haml.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+# Option default_attributes
+#
+# A hash of default attributes for tags (`{tag => {attribute => default_value}}`).
+# Attributes of each tag will reverse merged with his default attributes, so you
+# don't have to write over and over that script tag has attribute `type` with value
+# `text/javascript`. For example, `%script` compiles to `<script type="text/javascript"></script>`.
+# Defaults to `{script: {type: "text/javascript"}, form: {method: "POST"}}`
+
+module Haml
+  module Precompiler
+    alias_method :__prerender_tag__, :prerender_tag
+    def prerender_tag(name, self_close, attributes)
+      # merge given attributes with default attributes from options
+      defaults = Tilt::HamlTemplate.options[:default_attributes][name.to_sym]
+      attributes = defaults.merge(attributes) if defaults
+      __prerender_tag__(name, self_close, attributes)
+    end
+  end
+
+  class Buffer
+    alias_method :__open_tag__, :open_tag
+    def open_tag(name, self_closing, try_one_line, preserve_tag, escape_html, class_id,
+                 nuke_outer_whitespace, nuke_inner_whitespace, obj_ref, content, *attributes_hashes)
+      defaults = Tilt::HamlTemplate.options[:default_attributes][name.to_sym]
+      attributes_hashes.unshift(defaults) if defaults
+
+      __open_tag__(name, self_closing, try_one_line, preserve_tag, escape_html, class_id,
+                    nuke_outer_whitespace, nuke_inner_whitespace, obj_ref, content, *attributes_hashes)
+    end
+  end
+end

data/lib/template-inheritance/exts/tilt.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require "tilt"
+
+module TemplateInheritance
+  module TiltExtensions
+    # Tilt::HamlTemplate.options[:default_attributes] = {script: {type: "text/javascript"}, form: {method: "POST"}}
+    module Haml
+      def self.included(klass)
+        klass.send(:remove_method, :initialize_engine)
+        def klass.options
+          @options ||= Hash.new
+        end
+      end
+
+      def initialize_engine
+        require_template_library 'haml' unless defined? ::Haml::Engine
+        require "template-inheritance/exts/haml" if self.class.options[:default_attributes]
+      end
+
+      def initialize(*args)
+        super
+        self.options.merge!(self.class.options)
+      end
+    end
+  end
+end
+
+Tilt::HamlTemplate.send(:include, TemplateInheritance::TiltExtensions::Haml)

data/lib/template-inheritance/helpers.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+module TemplateInheritance
+  SubtemplateNotFound = Class.new(StandardError)
+
+  module TemplateHelpers
+    def self.extended(scope)
+      class << scope
+        attr_accessor :template
+        attr_accessor :context
+        # @example Capture being used in a .html.erb page:
+        #   <% @foo = capture do %>
+        #     <p>Some Foo content!</p>
+        #   <% end %>
+        #
+        # @params [*args]  Arguments to pass to the block.
+        # @params [&block] The template block to call.
+        # @return [String] The output of the block.
+        # @api private
+        def capture(*args, &block)
+          capture_method = "capture_#{self.template.adapter}"
+          if self.respond_to?(capture_method) # tilt doesn't support @_out_buf for haml
+            self.send("capture_#{self.template.adapter}", *args, &block)
+          else
+            # @_out_buf comes from tilt
+            unless self.instance_variable_defined?("@_out_buf")
+              raise "Adapter #{self.template.adapter} doesn't support capturing"
+            end
+            _old_buf, @_out_buf = @_out_buf, ""
+            block.call(*args)
+            @_out_buf = _old_buf.chomp.strip
+          end
+        end
+
+        def concat(string)
+          concat_method = "concat_#{self.template.adapter}"
+          if self.respond_to?(concat_method) # tilt doesn't support @_out_buf for haml
+            self.send("concat_#{self.template.adapter}", string)
+          else
+            # @_out_buf comes from tilt
+            unless self.instance_variable_defined?("@_out_buf")
+              raise "Adapter #{self.template.adapter} doesn't support concating"
+            end
+            @_out_buf << string
+          end
+        end
+      end
+    end
+
+    def self.included(scope_class)
+      scope_class.class_eval { attr_accessor :template }
+    end
+
+    # post/show.html: it's block is the block we like to see in output
+    # post/base.html
+    # base.html: here it will be rendered, so we need block to returns the correct block code
+    # @since 0.0.2
+    # @version 0.2
+    def block(name, value = nil, &block)
+      raise ArgumentError, "Block has to have a name!" if name.nil?
+      raise ArgumentError, "You have to provide value or block, not both of them!" if value && block
+      self.template.blocks[name] ||= block ? self.template.scope.capture(&block) : value
+      return self.template.blocks[name]
+    end
+
+    # - extend_block(:head) do
+    #   = pupu :lighter, syntax: "html", theme: "standard"
+    #   = block(:head)
+    def extend_block(name, value = nil, &block)
+      unless self.template.blocks[name]
+        raise NameError, "Block #{name.inspect} wasn't defined yet, you can't extend it!"
+      end
+      self.enhance_block(name, value, &block)
+    end
+
+    def enhance_block(name, value = nil, &block)
+      raise ArgumentError, "Block has to have a name!" if name.nil?
+      raise ArgumentError, "You have to provide value or block, not both of them!" if value && block
+      value = self.template.scope.capture(&block) if value.nil? && block
+      self.template.blocks[name] = value if value
+      return self.template.blocks[name]
+    end
+
+    # Clears default content of given block.
+    #
+    # @example
+    #   clear_block(:flyout)
+    def clear_block(name)
+      raise ArgumentError, "You need to specify name of block to clear." if name.nil?
+      self.template.blocks[name] = String.new
+    end
+
+    # Low-level rendering method for templates.
+    #
+    # @since 0.2
+    # @example
+    #   render "base.html"
+    #   render "./base.html"
+    #   render "../base.html"
+    def render(path, context = Hash.new)
+      full_path = normalize_template_path(path)
+      original_template = self.template
+      template = TemplateInheritance::Template.new(full_path, self) # self is scope
+      self.template = original_template
+      return template.render(context)
+    rescue Exceptions::TemplateNotFound # FIXME: this doesn't work
+      raise SubtemplateNotFound, "Template #{path} doesn't exist in #{full_path}"
+    end
+
+    # partial "products/list"
+    # @since 0.0.2
+    # @version 0.2.1
+    def partial(template, extra_context = Hash.new)
+      # NOTE: we can't use File.split because it normalize the path,
+      # so "./base.html" will be the same as "base.html", but it shouldn't be
+      *path, basename = template.split("/")
+      render File.join(path.join("/"), "_#{basename}"), self.template.context.merge(extra_context)
+    end
+
+    # @since 0.2
+    def includes(template, context = Hash.new)
+      render normalize_template_path(template), context
+      return true
+    end
+
+    # extends "base.html"
+    # @since 0.0.2
+    def extends(path)
+      # we can't just create a new template, because it has to do it after it reads the whole file
+      self.template.supertemplate = normalize_template_path(path)
+    end
+
+    # @since 0.2
+    def normalize_template_path(template)
+      if template.start_with?("./")
+        File.expand_path(File.join(File.dirname(self.template.fullpath), template))
+      elsif template.start_with?("../")
+        File.expand_path(File.join(File.dirname(self.template.fullpath), "..", template))
+      else
+        template
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--format
+progress
+--loadby
+mtime

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+SPEC_ROOT  = File.dirname(__FILE__)
+STUBS_ROOT = File.join(SPEC_ROOT, "stubs")
+
+$:.unshift(File.join(SPEC_ROOT, "..", "lib"))
+
+begin
+  # Require the preresolved locked set of gems.
+  require File.expand_path("../.bundle/environment", __FILE__)
+rescue LoadError
+  # Fallback on doing the resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end
+
+require "spec" # so you can run ruby spec/rango/whatever_spec.rb
+
+require "rango"
+require "logger"
+Rango.logger = Logger.new("/dev/null")
+
+class RecursiveOpenStruct < OpenStruct
+  def initialize(attributes = Hash.new)
+    attributes.each do |key, value|
+      if value.is_a?(Hash)
+        attributes[key] = OpenStruct.new(value)
+      end
+    end
+    super(attributes)
+  end
+end
+
+module Spec
+  module Matchers
+    def match(expected)
+      Matcher.new(:match, expected) do |expected|
+        match do |actual|
+          actual.match(expected)
+        end
+      end
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.before(:all) do
+    Rango.environment = "test"
+  end
+end

data/spec/stubs/block/block.html.haml

@@ -0,0 +1,2 @@
+= block(:second) do
+  a block

data/spec/stubs/block/blocks.html.haml

@@ -0,0 +1,5 @@
+- block(:head, nil)
+- block(:head, "first")
+- block(:head, "second")
+
+= block(:head)

data/spec/stubs/block/error.html.haml

@@ -0,0 +1,2 @@
+= block(:content, "value") do
+  Content from block

data/spec/stubs/block/getter.html.haml

@@ -0,0 +1,3 @@
+- block(:content, "Hello World!")
+
+= block(:content)

data/spec/stubs/block/value.html.haml

@@ -0,0 +1 @@
+= block(:one, "a value")

data/spec/stubs/context_id.html.haml

@@ -0,0 +1 @@
+= self.object_id

data/spec/stubs/enhance_block/basic.html.haml

@@ -0,0 +1,5 @@
+- block(:content) do
+  Original
+
+= enhance_block(:content) do
+  I own the only #{block(:content)}!

data/spec/stubs/enhance_block/error.html.haml

@@ -0,0 +1,3 @@
+= enhance_block(:content, "another value") do
+  Content from block
+

data/spec/stubs/enhance_block/name_error.html.haml

@@ -0,0 +1 @@
+- enhance_block(nil)

data/spec/stubs/enhance_block/nil.html.haml

@@ -0,0 +1,3 @@
+- block(:content, "Original")
+
+= enhance_block(:content, nil)

data/spec/stubs/enhance_block/standalone.html.haml

@@ -0,0 +1,2 @@
+= enhance_block(:content) do
+  Hello World!

data/spec/stubs/extend_block/basic.html.haml

@@ -0,0 +1,5 @@
+- block(:content) do
+  Original
+
+= extend_block(:content) do
+  I own the only #{block(:content)}!

data/spec/stubs/extend_block/error.html.haml

@@ -0,0 +1,5 @@
+- block(:content, "value")
+
+= extend_block(:content, "another value") do
+  Content from block
+

data/spec/stubs/extend_block/error2.html.haml

@@ -0,0 +1 @@
+= extend_block(:content, "foo")

data/spec/stubs/extend_block/name_error.html.haml

@@ -0,0 +1 @@
+- extend_block(nil)

data/spec/stubs/extend_block/nil.html.haml

@@ -0,0 +1,4 @@
+- block(:content) do
+  Original
+
+= extend_block(:content, nil)

data/spec/stubs/includes/base.html.haml

@@ -0,0 +1 @@
+== #{block(:title)} by #{block(:author)}

data/spec/stubs/includes/basic.html.haml

@@ -0,0 +1 @@
+= includes "library.html"

data/spec/stubs/includes/includes.html.haml

@@ -0,0 +1,7 @@
+- includes "library.html"
+
+%html
+  %head
+    %title= block(:title)
+
+  %body= block(:content)

data/spec/stubs/includes/integration.html.haml

@@ -0,0 +1,4 @@
+- includes "library.html"
+- extends "includes/base.html"
+
+= block(:author, "Jakub Stastny")

data/spec/stubs/includes/integration2.html.haml

@@ -0,0 +1,4 @@
+- extends "includes/base.html"
+- includes "library.html"
+
+= block(:author, "Jakub Stastny")

data/spec/stubs/index.html.haml

@@ -0,0 +1 @@
+= title

data/spec/stubs/inheritance/basic/base.html.haml

@@ -0,0 +1,2 @@
+%html
+  %body= block(:content)

data/spec/stubs/inheritance/basic/index.html.haml

@@ -0,0 +1,2 @@
+- extends "inheritance/basic/base.html"
+- block(:content, "Hello!")

data/spec/stubs/inheritance/capture/haml/base.html.haml

@@ -0,0 +1,2 @@
+%html
+  %body= block(:content)

data/spec/stubs/inheritance/capture/haml/index.html.haml

@@ -0,0 +1,3 @@
+- extends "inheritance/capture/haml/base.html"
+- block(:content) do
+  Hello!

data/spec/stubs/library.html.haml

@@ -0,0 +1,3 @@
+- block(:title, "Greeting") # we don't want to show this in the partial
+- block(:content) do
+  Hello World!

data/spec/stubs/test.html.haml

@@ -0,0 +1 @@
+%html

data/spec/stubs/variables.html.haml

@@ -0,0 +1 @@
+= title

data/spec/templates/helpers_spec.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+require_relative "../../spec_helper"
+require "rango/templates/helpers"
+
+Rango::Template.template_paths.clear.push(File.join(STUBS_ROOT, "templates"))
+
+describe Rango::TemplateHelpers do
+  include Rango::TemplateHelpers
+  describe "#partial" do
+    it "should work" do
+      pending "This can't work because self.template doesn't exist, we have to use render mixin"
+      partial "basic.html"
+    end
+
+    it "should share context with the parent template" do
+      pending
+    end
+
+    it "should be able to specify additional context which isn't propagated to the parent template" do
+      pending
+    end
+  end
+
+  describe "#render" do
+    it "should consider 'path.html' as a path relative to Template.template_paths" do
+      pending
+    end
+
+    it "should consider './path.html' as a path relative to the current template" do
+      pending
+    end
+
+    it "should look for '../path.html' in the parent directory of directory with current template" do
+      pending
+    end
+  end
+
+  describe "#includes" do
+    require "rango/mixins/render"
+    it "should return true" do
+      Rango::RenderMixin.render("includes/basic.html").strip.should eql("true")
+    end
+
+    it "should work with blocks" do
+      Rango::RenderMixin.render("includes/includes.html")
+    end
+
+    it "should work with extends" do
+      output = Rango::RenderMixin.render("includes/integration.html")
+      output.strip.should eql("Greeting by Jakub Stastny")
+    end
+
+    it "should work with extends" do
+      output = Rango::RenderMixin.render("includes/integration2.html")
+      output.strip.should eql("Greeting by Jakub Stastny")
+    end
+  end
+
+  describe "extends" do
+  end
+
+  describe "block" do
+    it "should raise argument error if name isn't specified" do
+      -> { block(nil) }.should raise_error(ArgumentError)
+    end
+
+    it "should work as a setter if a value is provided" do
+      output = Rango::RenderMixin.render("block/value.html")
+      output.strip.should eql("a value")
+    end
+
+    it "should work as a setter if a block is provided" do
+      output = Rango::RenderMixin.render("block/block.html")
+      output.strip.should eql("a block")
+    end
+
+    it "should work as a getter" do
+      output = Rango::RenderMixin.render("block/getter.html")
+      output.strip.should eql("Hello World!")
+    end
+
+    it "should raise argument error if both value and block is provided" do
+      -> { Rango::RenderMixin.render("block/error.html") }.should raise_error(ArgumentError)
+    end
+
+    it "should store the first non-nil value" do
+      output = Rango::RenderMixin.render("block/blocks.html")
+      output.strip.should eql("first")
+    end
+  end
+
+  describe "extend_block" do
+    it "should raise argument error if name isn't specified" do
+      -> { Rango::RenderMixin.render("extend_block/name_error.html") }.should raise_error(NameError)
+    end
+
+    it "should raise argument error if both value and block is provided" do
+      -> { Rango::RenderMixin.render("extend_block/error.html") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise argument error if block of given name doesn't exist so far" do
+      -> { Rango::RenderMixin.render("extend_block/error2.html") }.should raise_error
+    end
+
+    it "should work with super()-like inheritance" do
+      Rango::RenderMixin.render("extend_block/basic.html")
+    end
+
+    it "should do nothing if the value or block is nil" do
+      output = Rango::RenderMixin.render("extend_block/nil.html")
+      output.strip.should eql("Original")
+    end
+  end
+
+  describe "enhance_block" do
+    it "should work even if the block isn't defined so far" do
+      output = Rango::RenderMixin.render("enhance_block/standalone.html")
+      output.strip.should eql("Hello World!")
+    end
+
+    it "should not raise argument error if name isn't specified" do
+      -> { Rango::RenderMixin.render("enhance_block/name_error.html") }.should_not raise_error(NameError)
+    end
+
+    it "should raise argument error if both value and block is provided" do
+      -> { Rango::RenderMixin.render("enhance_block/error.html") }.should raise_error(ArgumentError)
+    end
+
+    it "should work with super()-like inheritance" do
+      Rango::RenderMixin.render("enhance_block/basic.html")
+    end
+
+    it "should do nothing if the value or block is nil" do
+      output = Rango::RenderMixin.render("enhance_block/nil.html")
+      output.strip.should eql("Original")
+    end
+  end
+end

data/spec/templates/template_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require_relative "../../spec_helper"
+require "rango/templates/template"
+
+Rango::Template.template_paths.clear.push(File.join(STUBS_ROOT, "templates"))
+
+describe Rango::Template do
+  describe "#initialize" do
+    it "should take path as a first argument" do
+      template = Rango::Template.new("test.html")
+      template.path.should eql("test.html")
+    end
+
+    it "should take scope as an optional second argument" do
+      scope  = Object.new
+      template = Rango::Template.new("test.html", scope)
+      template.scope.should eql(scope)
+    end
+  end
+
+  describe "#fullpath" do
+    it "should find" do
+      template = Rango::Template.new("test.html")
+      fullpath = File.join(STUBS_ROOT, "templates", "test.html.haml")
+      template.fullpath.should eql(fullpath)
+    end
+  end
+
+  describe "#render" do
+    it "should raise TemplateNotFound if template can't be found" do
+      template = Rango::Template.new("idonotexist.html")
+      -> { template.render }.should raise_error(Rango::Exceptions::TemplateNotFound)
+    end
+
+    it "should render" do
+      template = Rango::Template.new("test.html")
+      template.render.should eql("<html></html>\n")
+    end
+
+    it "should have template inheritance" do
+      template = Rango::Template.new("inheritance/basic/index.html")
+    end
+
+    it "should capture haml" do
+      template = Rango::Template.new("inheritance/capture/haml/index.html")
+      template.render
+      template.blocks[:content].should match("Hello!")
+    end
+  end
+
+  describe "variables" do
+    before(:each) do
+      @template = Rango::Template.new("variables.html")
+    end
+
+    it "should capture erb" do
+      # @template.render(title: "Hi!").should match("Hi!")
+    end
+  end
+end

data/template-inheritance.gemspec

@@ -0,0 +1,42 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+require "base64"
+
+Gem::Specification.new do |s|
+  s.name = "template-inheritance"
+  s.version = "0.1"
+  s.authors = ["Jakub Šťastný aka Botanicus"]
+  s.homepage = "http://github.com/botanicus/template-inheritance"
+  s.summary = ""
+  s.description = "" # TODO: long description
+  s.cert_chain = nil
+  s.email = Base64.decode64("c3Rhc3RueUAxMDFpZGVhcy5jeg==\n")
+  s.has_rdoc = true
+
+  # files
+  s.files = `git ls-files`.split("\n")
+
+  s.require_paths = ["lib"]
+
+  # Ruby version
+  # Current JRuby with --1.9 switch has RUBY_VERSION set to "1.9.2dev"
+  # and RubyGems don't play well with it, so we have to set minimal
+  # Ruby version to 1.9, even if it actually is 1.9.1
+  s.required_ruby_version = ::Gem::Requirement.new("~> 1.9")
+
+  # dependencies
+  s.add_dependency "tilt"
+  s.add_dependency "haml"
+
+  # begin
+  #   require "changelog"
+  # rescue LoadError
+  #   warn "You have to have changelog gem installed for post install message"
+  # else
+  #   s.post_install_message = CHANGELOG.new.version_changes
+  # end
+
+  # RubyForge
+  s.rubyforge_project = "template-inheritance"
+end

metadata

@@ -4,28 +4,22 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 0
-  - 0
-  - 0
-  - 0
-  - 0
-  - 0
   - 1
-  version: 0.0.0.0.0.0.0.0.1
+  version: "0.1"
 platform: ruby
 authors: 
 - "Jakub \xC5\xA0\xC5\xA5astn\xC3\xBD aka Botanicus"
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2010-03-24 00:00:00 +00:00
+date: 2010-10-02 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: tilt
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -34,6 +28,19 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: haml
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
 description: ""
 email: stastny@101ideas.cz
 executables: []
@@ -43,7 +50,54 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .gitignore
 - README.textile
+- example/base.html.haml
+- example/example.rb
+- example/shared/google_analytics.html.haml
+- example/site/_wtf.html.haml
+- example/site/base.html.haml
+- example/site/post.html.haml
+- lib/template-inheritance.rb
+- lib/template-inheritance/exts/haml.rb
+- lib/template-inheritance/exts/tilt.rb
+- lib/template-inheritance/helpers.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/stubs/block/block.html.haml
+- spec/stubs/block/blocks.html.haml
+- spec/stubs/block/error.html.haml
+- spec/stubs/block/getter.html.haml
+- spec/stubs/block/value.html.haml
+- spec/stubs/context_id.html.haml
+- spec/stubs/enhance_block/basic.html.haml
+- spec/stubs/enhance_block/error.html.haml
+- spec/stubs/enhance_block/name_error.html.haml
+- spec/stubs/enhance_block/nil.html.haml
+- spec/stubs/enhance_block/standalone.html.haml
+- spec/stubs/extend_block/basic.html.haml
+- spec/stubs/extend_block/error.html.haml
+- spec/stubs/extend_block/error2.html.haml
+- spec/stubs/extend_block/name_error.html.haml
+- spec/stubs/extend_block/nil.html.haml
+- spec/stubs/includes/base.html.haml
+- spec/stubs/includes/basic.html.haml
+- spec/stubs/includes/includes.html.haml
+- spec/stubs/includes/integration.html.haml
+- spec/stubs/includes/integration2.html.haml
+- spec/stubs/index.html.haml
+- spec/stubs/inheritance/basic/base.html.haml
+- spec/stubs/inheritance/basic/index.html.haml
+- spec/stubs/inheritance/capture/haml/base.html.haml
+- spec/stubs/inheritance/capture/haml/index.html.haml
+- spec/stubs/library.html.haml
+- spec/stubs/test.html.haml
+- spec/stubs/variables.html.haml
+- spec/templates/exts/haml_spec.rb
+- spec/templates/exts/tilt_spec.rb
+- spec/templates/helpers_spec.rb
+- spec/templates/template_spec.rb
+- template-inheritance.gemspec
 has_rdoc: true
 homepage: http://github.com/botanicus/template-inheritance
 licenses: []
@@ -54,6 +108,7 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ~>
     - !ruby/object:Gem::Version 
@@ -62,6 +117,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 9
       version: "1.9"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -71,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: template-inheritance
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: ""