implementation/tests of the template inheritance mechanism

lib/liquid/tags/extends.rb

@@ -0,0 +1,78 @@
+module Liquid
+
+  # Extends allows designer to use template inheritance
+  #
+  #   {% extends home %}
+  #   {% block content }Hello world{% endblock %}
+  #
+  class Extends < Block
+    Syntax = /(#{QuotedFragment}+)/
+
+    def initialize(tag_name, markup, options)
+      super
+
+      if markup =~ Syntax
+        @template_name = $1.gsub(/["']/o, '').strip
+      else
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.extends".freeze)))
+      end
+    end
+
+    def parse(tokens)
+      # get the nodes of the template the object inherits from
+      parent_template = parse_parent_template
+
+      # find the blocks in case there is a call to
+      # the super method inside the current template
+      @options.merge!(:blocks => self.find_blocks(parent_template.root.nodelist))
+
+      # finally, process the rest of the tokens
+      # the tags/blocks other than the InheritedBlock type will be ignored.
+      super
+
+      # replace the nodes of the current template by the ones from the parent
+      @nodelist = parent_template.root.nodelist.clone
+    end
+
+    def blank?
+      false
+    end
+
+    protected
+
+    def find_blocks(nodelist, blocks = {})
+      if nodelist && nodelist.any?
+        0.upto(nodelist.size - 1).each do |index|
+          node = nodelist[index]
+
+          # is the node an inherited block?
+          if node.respond_to?(:call_super)
+            new_node = node.class.clone_block(node)
+
+            nodelist.insert(index, new_node)
+            nodelist.delete_at(index + 1)
+
+            blocks[node.name] = new_node
+          end
+          if node.respond_to?(:nodelist)
+            # find nested blocks too
+            self.find_blocks(node.nodelist, blocks)
+          end
+        end
+      end
+      blocks
+    end
+
+    private
+
+    def parse_parent_template
+      source = Template.file_system.read_template_file(@template_name, {})
+      Template.parse(source)
+    end
+
+    def assert_missing_delimitation!
+    end
+  end
+
+  Template.register_tag('extends', Extends)
+end

lib/liquid/tags/inherited_block.rb

@@ -0,0 +1,102 @@
+module Liquid
+
+  # Blocks are used with the Extends tag to define
+  # the content of blocks. Nested blocks are allowed.
+  #
+  #   {% extends home %}
+  #   {% block content }Hello world{% endblock %}
+  #
+  class InheritedBlock < Block
+    Syntax = /(#{QuotedFragment}+)/
+
+    attr_accessor :parent
+    attr_accessor :nodelist
+    attr_reader   :name
+
+    def initialize(tag_name, markup, options)
+      super
+
+      if markup =~ Syntax
+        @name = $1.gsub(/["']/o, '').strip
+      else
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.block")), options[:line])
+      end
+
+      self.set_full_name!(options)
+
+      (options[:block_stack] ||= []).push(self)
+      options[:current_block] = self
+    end
+
+    def render(context)
+      context.stack do
+        context['block'] = InheritedBlockDrop.new(self)
+        render_all(@nodelist, context)
+      end
+    end
+
+    def end_tag
+      self.register_current_block
+
+      options[:block_stack].pop
+      options[:current_block] = options[:block_stack].last
+    end
+
+    def call_super(context)
+      if parent
+        parent.render(context)
+      else
+        ''
+      end
+    end
+
+    def self.clone_block(block)
+      new_block = new(block.send(:instance_variable_get, :"@tag_name"), block.name, {})
+      new_block.parent = block.parent
+      new_block.nodelist = block.nodelist
+      new_block
+    end
+
+    protected
+
+    def set_full_name!(options)
+      if options[:current_block]
+        @name = options[:current_block].name + '/' + @name
+      end
+    end
+
+    def register_current_block
+      options[:blocks] ||= {}
+
+      block = options[:blocks][@name]
+
+      if block
+        # copy the existing block in order to make it a parent of the parsed block
+        new_block = self.class.clone_block(block)
+
+        # replace the up-to-date version of the block in the parent template
+        block.parent = new_block
+        block.nodelist = @nodelist
+      end
+    end
+
+  end
+
+  class InheritedBlockDrop < Drop
+
+    def initialize(block)
+      @block = block
+    end
+
+    def name
+      @block.name
+    end
+
+    def super
+      @block.call_super(@context)
+    end
+
+  end
+
+  Template.register_tag('block', InheritedBlock)
+end

test/integration/tags/extends_tag_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+class LayoutFileSystem
+  def read_template_file(template_path, context)
+    case template_path
+    when "base"
+      "<body>base</body>"
+
+    when "inherited"
+      "{% extends base %}"
+
+    when "page_with_title"
+      "<body><h1>{% block title %}Hello{% endblock %}</h1><p>Lorem ipsum</p></body>"
+
+    when "product"
+      "<body><h1>Our product: {{ name }}</h1>{% block info %}{% endblock %}</body>"
+
+    when "product_with_warranty"
+      "{% extends product %}{% block info %}<p>mandatory warranty</p>{% endblock %}"
+
+    when "product_with_static_price"
+      "{% extends product %}{% block info %}<h2>Some info</h2>{% block price %}<p>$42.00</p>{% endblock %}{% endblock %}"
+
+    else
+      template_path
+    end
+  end
+end
+
+class ExtendsTagTest < Test::Unit::TestCase
+  include Liquid
+
+  def setup
+    Liquid::Template.file_system = LayoutFileSystem.new
+  end
+
+  def test_template_extends_another_template
+    assert_template_result "<body>base</body>",
+      "{% extends base %}"
+  end
+
+  def test_template_extends_an_inherited_template
+    assert_template_result "<body>base</body>",
+      "{% extends inherited %}"
+  end
+
+  def test_template_can_pass_variables_to_the_parent_template
+    assert_template_result "<body><h1>Our product: Macbook</h1></body>",
+      "{% extends product %}", 'name' => 'Macbook'
+  end
+
+  def test_template_can_pass_variables_to_the_inherited_parent_template
+    assert_template_result "<body><h1>Our product: PC</h1><p>mandatory warranty</p></body>",
+      "{% extends product_with_warranty %}", 'name' => 'PC'
+  end
+
+  def test_template_does_not_render_statements_outside_blocks
+    assert_template_result "<body>base</body>",
+      "{% extends base %} Hello world"
+  end
+
+  def test_template_extends_another_template_with_a_single_block
+    assert_template_result "<body><h1>Hello</h1><p>Lorem ipsum</p></body>",
+      "{% extends page_with_title %}"
+  end
+
+  def test_template_overrides_a_block
+    assert_template_result "<body><h1>Sweet</h1><p>Lorem ipsum</p></body>",
+      "{% extends page_with_title %}{% block title %}Sweet{% endblock %}"
+  end
+
+  def test_template_has_access_to_the_content_of_the_overriden_block
+    assert_template_result "<body><h1>Hello world</h1><p>Lorem ipsum</p></body>",
+      "{% extends page_with_title %}{% block title %}{{ block.super }} world{% endblock %}"
+  end
+
+  def test_template_accepts_nested_blocks
+    assert_template_result "<body><h1>Our product: iPhone</h1><h2>Some info</h2><p>$42.00</p><p>(not on sale)</p></body>",
+      "{% extends product_with_static_price %}{% block info/price %}{{ block.super }}<p>(not on sale)</p>{% endblock %}", 'name' => 'iPhone'
+  end
+
+end # ExtendsTagTest