danwrong-liquid-inheritance 0.1

data/CHANGELOG

@@ -0,0 +1 @@
+v0.1 Initial release

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Dan Webb
+
+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/Manifest

@@ -0,0 +1,10 @@
+CHANGELOG
+lib/liquid_inheritance.rb
+lib/tags/block.rb
+lib/tags/extends.rb
+LICENSE
+liquid-inheritance.gemspec
+Manifest
+Rakefile
+README.textile
+test/liquid_inheritance_test.rb

data/README.textile

@@ -0,0 +1,15 @@
+h1. Liquid Inheritance
+
+(C) Dan Webb 2009 under and MIT License (see LICENSE)
+
+This gem adds Django-style template inheritance to the "Liquid":http://www.liquidmarkup.org/ templating language.
+
+h2. Usage
+
+Simply install the gem then in your project:
+
+@require 'liquid-inheritance'@
+
+You then have access to the extends and block tags just like you do in Django.  It works identically so for more info "read the Django docs on template inheritance":http://docs.djangoproject.com/en/dev/topics/templates/#template-inheritance
+
+That's all folks.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'echoe'
+
+Echoe.new("liquid-inheritance") do |p|
+  p.author = "Dan Webb"
+  p.email = 'dan@danwebb.net'
+  p.summary = "Adds Django style template inheritance to Liquid"
+  p.url = "http://github.com/danwrong/liquid-inheritance/"
+  p.runtime_dependencies = ["liquid >= 1.9.0"]
+  p.retain_gemspec = true
+end

data/lib/liquid_inheritance.rb

@@ -0,0 +1,9 @@
+require 'liquid'
+
+module LiquidInheritance
+  autoload :Extends, 'tags/extends'
+  autoload :Block, 'tags/block'
+end
+
+Liquid::Template.register_tag(:extends, LiquidInheritance::Extends)
+Liquid::Template.register_tag(:block, LiquidInheritance::Block)

data/lib/tags/block.rb

@@ -0,0 +1,56 @@
+module LiquidInheritance
+  
+  class BlockDrop < ::Liquid::Drop
+    def initialize(block)
+      @block = block
+    end
+    
+    def super
+      @block.call_super(@context)
+    end
+  end
+    
+  class Block < ::Liquid::Block
+    Syntax = /(\w)+/
+    
+    attr_accessor :parent
+    attr_reader :name
+    
+    def initialize(tag_name, markup, tokens)  
+      if markup =~ Syntax
+        @name = $1
+      else
+        raise Liquid::SyntaxError.new("Syntax Error in 'block' - Valid syntax: block [name]")
+      end
+      
+      super if tokens
+    end
+    
+    def render(context)
+      context.stack do
+        context['block'] = BlockDrop.new(self)
+        
+        render_all(@nodelist, context)
+      end
+    end
+    
+    def add_parent(nodelist)
+      if parent
+        parent.add_parent(nodelist)
+      else
+        self.parent = Block.new(@tag_name, @name, nil)
+        parent.nodelist = nodelist
+      end
+    end
+    
+    def call_super(context)
+      if parent
+        parent.render(context)
+      else
+        ''
+      end
+    end
+    
+  end
+  
+end

data/lib/tags/extends.rb

@@ -0,0 +1,101 @@
+module LiquidInheritance
+  
+  class Extends < ::Liquid::Block
+    Syntax = /(#{Liquid::QuotedFragment})/
+    
+    def initialize(tag_name, markup, tokens)     
+      if markup =~ Syntax 
+        @template_name = $1
+      else
+        raise Liquid::SyntaxError.new("Syntax Error in 'extends' - Valid syntax: extends [template]")
+      end
+      
+      super
+      
+      @blocks = @nodelist.inject({}) do |m, node|
+        m[node.name] = node if node.is_a?(::LiquidInheritance::Block); m
+      end
+    end
+    
+    def parse(tokens)
+      parse_all(tokens)
+    end
+    
+    def render(context)
+      template = load_template(context)
+      parent_blocks = find_blocks(template.root)
+      
+      @blocks.each do |name, block|
+        if pb = parent_blocks[name]
+          pb.parent = block.parent
+          pb.add_parent(pb.nodelist)
+          pb.nodelist = block.nodelist
+        else
+          if is_extending?(template)
+            template.root.nodelist << block
+          end
+        end
+      end
+      
+      template.render(context)
+    end 
+    
+    private
+    
+    def parse_all(tokens)
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift 
+        case token
+        when /^#{Liquid::TagStart}/                   
+          if token =~ /^#{Liquid::TagStart}\s*(\w+)\s*(.*)?#{Liquid::TagEnd}$/
+            # fetch the tag from registered blocks
+            if tag = Liquid::Template.tags[$1]
+              @nodelist << tag.new($1, $2, tokens)
+            else
+              # this tag is not registered with the system 
+              # pass it to the current block for special handling or error reporting
+              unknown_tag($1, $2, tokens)
+            end              
+          else
+            raise Liquid::SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
+          end
+        when /^#{Liquid::VariableStart}/
+          @nodelist << create_variable(token)
+        when ''
+          # pass
+        else
+          @nodelist << token
+        end
+      end
+    end
+    
+    def load_template(context)
+      source = Liquid::Template.file_system.read_template_file(context[@template_name])      
+      Liquid::Template.parse(source)
+    end
+    
+    def find_blocks(node, blocks={})
+      if node.respond_to?(:nodelist)
+        node.nodelist.inject(blocks) do |b, node|
+          if node.is_a?(LiquidInheritance::Block)
+            b[node.name] = node
+          else
+            find_blocks(node, b)
+          end
+          
+          b
+        end
+      end
+      
+      blocks
+    end
+    
+    def is_extending?(template)
+      template.root.nodelist.any? { |node| node.is_a?(Extends) }
+    end
+    
+  end
+  
+end

data/liquid-inheritance.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{liquid-inheritance}
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dan Webb"]
+  s.date = %q{2009-04-09}
+  s.description = %q{Adds Django style template inheritance to Liquid}
+  s.email = %q{dan@danwebb.net}
+  s.extra_rdoc_files = ["CHANGELOG", "lib/liquid_inheritance.rb", "lib/tags/block.rb", "lib/tags/extends.rb", "LICENSE", "README.textile"]
+  s.files = ["CHANGELOG", "lib/liquid_inheritance.rb", "lib/tags/block.rb", "lib/tags/extends.rb", "LICENSE", "liquid-inheritance.gemspec", "Manifest", "Rakefile", "README.textile", "test/liquid_inheritance_test.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/danwrong/liquid-inheritance/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Liquid-inheritance", "--main", "README.textile"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{liquid-inheritance}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Adds Django style template inheritance to Liquid}
+  s.test_files = ["test/liquid_inheritance_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<liquid>, [">= 0", "= 1.9.0"])
+    else
+      s.add_dependency(%q<liquid>, [">= 0", "= 1.9.0"])
+    end
+  else
+    s.add_dependency(%q<liquid>, [">= 0", "= 1.9.0"])
+  end
+end

data/test/liquid_inheritance_test.rb

@@ -0,0 +1,173 @@
+$:.unshift(File.join(File.dirname(__FILE__), '../lib'))
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'redgreen' rescue nil
+
+require 'liquid_inheritance'
+
+class TestFileSystem
+  
+  def read_template_file(path)
+    if path == 'simple'
+      'test'
+    elsif path == 'complex'
+      %{
+        beginning
+        
+        {% block thing %}
+        rarrgh
+        {% endblock %}
+        
+        {% block another %}
+        bum
+        {% endblock %}
+        
+      end
+      }
+    elsif 'nested'
+      %{
+        {% extends 'complex' %}
+        
+        {% block thing %}
+        from nested
+        {% endblock %}
+        
+        {% block another %}
+        from nested (another)
+        {% endblock %}
+      }
+    else
+      %{
+        {% extends 'complex' %}
+        
+        {% block thing %}
+        from nested
+        {% endblock %}
+      }
+    end
+  end
+  
+end
+
+class LiquidInheritanceTest < Test::Unit::TestCase
+  context 'given a template with an extends tag' do
+    setup do
+      Liquid::Template.file_system = TestFileSystem.new
+    end
+    
+    should 'output the contents of the extended template' do
+      template = Liquid::Template.parse %{
+        {% extends 'simple' %}
+        
+        {% block thing %}
+        yeah
+        {% endblock %}
+      }
+      
+      assert_contains(template.render, /test/)
+    end
+    
+    should 'render original content of block if no child block given' do
+      template = Liquid::Template.parse %{
+        {% extends 'complex' %}
+      }
+      
+      assert_contains(template.render, /rarrgh/)
+      assert_contains(template.render, /bum/)
+    end
+    
+    should 'render child content of block if child block given' do
+      template = Liquid::Template.parse %{
+        {% extends 'complex' %}
+        
+        {% block thing %}
+        booyeah
+        {% endblock %}
+      }
+      
+      assert_contains(template.render, /booyeah/)
+      assert_contains(template.render, /bum/)
+    end
+    
+    should 'render child content of blocks if multiple child blocks given' do
+      template = Liquid::Template.parse %{
+        {% extends 'complex' %}
+        
+        {% block thing %}
+        booyeah
+        {% endblock %}
+        
+        {% block another %}
+        blurb
+        {% endblock %}
+      }
+      
+      assert_contains(template.render, /booyeah/)
+      assert_contains(template.render, /blurb/)
+    end
+    
+    should 'should remember context of child template' do
+      template = Liquid::Template.parse %{
+        {% extends 'complex' %}
+        
+        {% block thing %}
+        booyeah
+        {% endblock %}
+        
+        {% block another %}
+        {{ a }}
+        {% endblock %}
+      }
+      
+      res = template.render 'a' => 1234
+      
+      assert_contains(res, /booyeah/)
+      assert_contains(res, /1234/)
+    end
+    
+    should 'should work with nested templates' do
+      template = Liquid::Template.parse %{
+        {% extends 'nested' %}
+        
+        {% block thing %}
+        booyeah
+        {% endblock %}
+      }
+      
+      res = template.render 'a' => 1234
+      
+      assert_contains(res, /booyeah/)
+      assert_contains(res, /from nested/)
+    end
+    
+    should 'should work with nested templates if middle template skips a block' do
+      template = Liquid::Template.parse %{
+        {% extends 'nested2' %}
+        
+        {% block another %}
+        win
+        {% endblock %}
+      }
+      
+      res = template.render
+      
+      assert_contains(res, /win/)
+    end
+    
+    should 'should render parent for block.super' do
+      template = Liquid::Template.parse %{
+        {% extends 'complex' %}
+        
+        {% block thing %}
+        {{ block.super }}
+        {% endblock %}
+      }
+      
+      res = template.render 'a' => 1234
+      
+      assert_contains(res, /rarrgh/)
+    end
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: danwrong-liquid-inheritance
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Dan Webb
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: liquid
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.9.0
+    version: 
+description: Adds Django style template inheritance to Liquid
+email: dan@danwebb.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- lib/liquid_inheritance.rb
+- lib/tags/block.rb
+- lib/tags/extends.rb
+- LICENSE
+- README.textile
+files: 
+- CHANGELOG
+- lib/liquid_inheritance.rb
+- lib/tags/block.rb
+- lib/tags/extends.rb
+- LICENSE
+- liquid-inheritance.gemspec
+- Manifest
+- Rakefile
+- README.textile
+- test/liquid_inheritance_test.rb
+has_rdoc: true
+homepage: http://github.com/danwrong/liquid-inheritance/
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Liquid-inheritance
+- --main
+- README.textile
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: liquid-inheritance
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Adds Django style template inheritance to Liquid
+test_files: 
+- test/liquid_inheritance_test.rb