fiasco-template 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 11cbe3ece994f98ca8bde7971960d447f6014756
+  data.tar.gz: a49d13f4c731a7f29cd7fac9b4da6968a2fe693b
+SHA512:
+  metadata.gz: 559985260dd577af330558e26e0b6c9a851598b751342a3c436d3624a92b8424df7cfb4135a6ff7a32b0c7f8994839a0808884a355e425db5c92dc520f0aef60
+  data.tar.gz: 9a5d95d6bfaa1914d370fcb06fec9bac3c7c0f9b14dfb3a31647c754bdcaca32b9ed00bf362fbd6b57bf87a1044621b47588151aa015c673814e68efb0866672

data/lib/fiasco/template/compiler.rb

@@ -0,0 +1,79 @@
+require 'strscan'
+
+module Fiasco::Template
+  class Compiler
+    OPENERS = /(.*?)(^[ \t]*%|\{%-?|\{\{-?|\{#-?|\z)/m
+    DEFAULT_DISPLAY_VALUE = ->(outvar, literal){"#{outvar} << (#{literal}).to_s"}
+    DEFAULT_DISPLAY_TEXT = ->(text){text.dump}
+
+    def initialize(options = {})
+      @output_var = options.fetch(:output_var, '@render_output')
+      @display_value = options.fetch(:display_value, DEFAULT_DISPLAY_VALUE)
+      @display_text = options.fetch(:display_text, DEFAULT_DISPLAY_TEXT)
+    end
+
+    def closer_for(tag)
+      case tag
+      when /\{%-?/ then /(.*?)(-?%\}|\z)/m
+      when /\{\{-?/ then /(.*?)(-?}\}|\z)/m
+      when /\{#-?/ then /(.*?)(-?#\}|\z)/m
+      when '%' then /(.*?)($)/
+      end
+    end
+
+    def scan(body)
+      scanner = StringScanner.new(body)
+      open_tag = nil
+
+      until scanner.eos?
+        if open_tag
+          scanner.scan(closer_for(open_tag))
+          inner, close_tag = scanner[1], scanner[2]
+
+          case open_tag
+          when '{{', '{{-' then yield [:display,   inner]
+          when '{%', '{%-' then yield [:code,      inner]
+          when '{#', '{#-' then yield [:comment,   inner]
+          when '%'         then yield [:code_line, inner]
+          end
+
+          open_tag = nil
+        else
+          scanner.scan(OPENERS)
+          before, open_tag = scanner[1], scanner[2]
+          newlines_count = before.count("\n")
+          open_tag.lstrip! # for % which captures preceeding whitespace
+
+          text = before
+          text.lstrip! if close_tag && close_tag[0] == '-'
+          text.rstrip! if open_tag[-1] == '-'
+          text.chomp! if open_tag == '%'
+
+          yield [:text, text]
+          yield [:newlines, newlines_count]
+        end
+      end
+    end
+
+    def compile(body)
+      src = []
+
+      scan(body) do |command, data|
+        case command
+        when :newlines
+          src << "\n" * data unless data == 0
+        when :text
+          src << "#{@output_var} << #{@display_text.(data)}" unless data.empty?
+        when :code, :code_line
+          src << data
+        when :display
+          src << @display_value.(@output_var, data)
+        when :comment
+          # skip
+        end
+      end
+
+      src.join(';')
+    end
+  end
+end

data/lib/fiasco/template/render_context.rb

@@ -0,0 +1,171 @@
+require 'set'
+require_relative 'compiler'
+
+module Fiasco::Template
+  class RenderContext
+    class NullOutput; def <<(value); end; end
+
+    Entry = Struct.new(:body, :filename)
+
+    def initialize
+      @content_blocks = Hash.new {|h,k| h[k] = [] }
+      @template_locals = Hash.new {|h,k| h[k] = [] }
+      @templates = {}
+      @compiled = Set.new
+      display_value = lambda do |outvar, literal|
+        "__tmp = (#{literal}); #{outvar} << display_value(__tmp)"
+      end
+      @compiler = Compiler.new(display_value: display_value)
+    end
+
+    def block(key, &b)
+      @content_blocks[key.to_s] << b
+    end
+
+    def superblock(*args)
+      # for a blocklevel N, we can find the superblock (block with the
+      # same name defined on a parent template) in N+1
+      @blocklevel += 1
+      @content_blocks[@blockname][@blocklevel].call(*args)
+    ensure
+      @blocklevel -= 1
+    end
+
+    def yield_block(key, *args, &b)
+      key = key.to_s
+      @content_blocks[key] << b if b
+
+      if @content_blocks[key].length > 0
+        begin
+          old_blocklevel, @blocklevel = @blocklevel, -1
+          old_blockname, @blockname = @blockname, key
+
+          # @blocklevel starts at -1, making this call render
+          # the block at level 0 (the last one defined in the
+          # inheritance chain)
+          superblock(*args)
+        ensure
+          @blocklevel, @blockname = old_blocklevel, old_blockname
+        end
+      else
+        ''
+      end
+    end
+
+    def extends(base, *args)
+      # Store render output remporarily because we don't want to
+      # render any output of a child template until we render the parent
+      @render_output, @original_render_output = NullOutput.new, @render_output
+      @extends = [base, args]
+    end
+
+    def _compile(name, entry, locals = [])
+      src = "params ||= {}; @render_output ||= ''; "
+      locals.each {|var| src += "#{var} = params[:#{var}]; "}
+      src << "\n"
+      src << @compiler.compile(entry.body)
+      src << "\n@render_output"
+
+      meth = <<-EOS
+#coding:UTF-8
+define_singleton_method(:'__view__#{name}') do |params|
+#{src}
+end
+EOS
+      eval(meth, binding, entry.filename || "(TEMPLATE:#{name})", -2)
+      @compiled << name
+    end
+
+    def _process_locals(name, locals)
+      seen_variables = @template_locals[name]
+      diff = locals.keys - seen_variables
+
+      unless diff.empty?
+        seen_variables += diff
+        @compiled.delete(name)
+      end
+
+      seen_variables
+    end
+
+    def _declare(options)
+      contents = options[:path] ? File.read(options[:path]) : options[:contents]
+
+      if contents.nil?
+        raise ArgumentError.new("Need either path or contents")
+      end
+
+      entry = Entry.new(contents, options[:path])
+
+      yield(entry)
+    end
+
+    def declare(name, options = {})
+      name = name.to_s
+      _declare(options) {|e| @templates[name] = e}
+    end
+
+    def _render(name, locals = {})
+      name = name.to_s
+      variables = _process_locals(name, locals)
+
+      unless @compiled.include?(name)
+        entry = @templates.fetch(name) do
+          raise ArgumentError, "template `#{name}` not declared"
+        end
+
+        _compile(name, entry, variables)
+      end
+
+      send("__view__#{name}", locals)
+
+      if @extends
+        parent, pargs = @extends
+        @extends = nil
+        @render_output, @original_render_output = @original_render_output, nil
+        _render(parent, *pargs)
+      end
+
+      @render_output
+    end
+
+    def render(name, locals = {})
+      _render(name, locals)
+    ensure
+      @content_blocks.clear
+      @render_output = nil
+    end
+
+    alias_method :[], :render
+
+    def display_value(value)
+      str = value.to_s
+      value.tainted? ? Rack::Utils.escape_html(str) : str
+    end
+
+    def macro(mname, defaults = {}, &b)
+      arguments = b.parameters
+      define_singleton_method mname do |named = defaults, &block|
+        args = arguments.select{|t| t[0] != :block}.map do |type, name|
+          named.fetch(name) do
+            defaults.fetch(name) do
+              msg = "Macro invocation '#{mname}' is missing a required argument: #{name}"
+              raise ArgumentError, msg, caller(10)
+            end
+          end
+        end
+        b.call(*args, &block)
+      end
+    end
+
+    def load_macros(options)
+      @render_output, tmp = NullOutput.new, @render_output
+      b = binding
+      _declare(options) do |e|
+        eval(@compiler.compile(e.body), b, e.filename || 'MACROS')
+      end
+    ensure
+      @render_output = tmp
+    end
+  end
+end

data/lib/fiasco/template.rb

@@ -0,0 +1,8 @@
+module Fiasco
+  module Template
+    VERSION = '0.0.1'
+  end
+end
+
+require_relative 'template/compiler'
+require_relative 'template/render_context'

data/test/macros/fields.html

@@ -0,0 +1,12 @@
+% macro :input, type: 'text', value: '', size: 20 do |name, type, value, size|
+  <input type="{{type}}" name="{{name}}" value="{{value}}" size="{{size}}">
+% end
+% macro :label, required: false do |text, required|
+  <label>{{text}}{% if required %}<span class=required>*</span>{% end %}</label>
+% end
+% macro :field, type: 'text', required: false, lbl: nil do |type, name, lbl, required|
+  <div class=field>
+    % label text: lbl || name.gsub(/[-_]/, ' ').capitalize, required: required
+    % input name: name, type: type
+  </div>
+% end

data/test/templates/base.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html>
+  <head><title>{% yield_block('title') do %}My Site{% end %}</title></head>
+  <body class="{% yield_block('body_classes') %}">
+    <div id=wrapper>
+      <h1>{% yield_block('title') %}</h1>
+      % yield_block('contents')
+    </div>
+  </body>
+</html>

data/test/templates/child.html

@@ -0,0 +1,9 @@
+% extends 'base'
+
+{% block('title') do %}{% superblock %} -- Homepage{% end %}
+
+% block('contents') do
+      <div class=main>
+        <h2>This is the homepage</h2>
+      </div>
+% end

data/test/templates/grandchild.html

@@ -0,0 +1,5 @@
+% extends 'child'
+
+% block 'contents' do
+      Grandchild
+% end

data/test/templates/uses_macros.html

@@ -0,0 +1,9 @@
+<form method=post>
+  <fieldset>
+    % field(name: 'username', value: user_name)
+    % field(name: 'password', type: 'password')
+    % field(name: 'password_confirm', type: 'password')
+  </fieldset>
+
+  <button>Submit</button>
+</form>

data/test/templates/with_locals.html

@@ -0,0 +1 @@
+{{ local1 }} {{ local2 }}

data/test/test_compiler.rb

@@ -0,0 +1,105 @@
+require 'test/unit'
+require_relative '../lib/fiasco/template'
+
+class TestCompiler < Test::Unit::TestCase
+  def compile_and_run(body, binding)
+    @__result = ''
+    s = Fiasco::Template::Compiler.new(output_var: "@__result")
+    src = s.compile(body)
+    eval src, binding, '(template)', 1
+    @__result
+  end
+
+  def test_complete
+    body = <<-EOT
+<head><title>{{title}}</title></head>
+<body>
+  {% 3.times do |n| %}-{{n}}-{% end %}
+  {% 3.times do |n| -%}
+     -{{n}}-
+     {#- comment #}
+  {%- end %}
+
+  % val = '-' * 10
+  {{val}}
+</body>
+EOT
+
+    expected = <<-EOT
+<head><title>The Title</title></head>
+<body>
+  -0--1--2-
+  -0--1--2-
+
+  ----------
+</body>
+EOT
+
+    title = 'The Title'
+    result = compile_and_run(body, binding)
+
+    assert_equal expected, result
+  end
+
+  def test_expression_substitution
+    value = 'value'
+    result = compile_and_run('**{{value}} {{ value + value }}**', binding)
+
+    assert_equal '**value valuevalue**', result
+  end
+
+  def test_code_blocks
+    body = '{% value = 10 %}{% 3.times do %}{{ value * 100 }}{% end %}'
+    result = compile_and_run(body, binding)
+
+    assert_equal "100010001000", result
+  end
+
+  def test_code_lines
+    body = <<-EOT
+% 3.times do |n|
+Iteration: {{n}}
+% end
+EOT
+    result = compile_and_run(body, binding)
+
+    assert_equal "\nIteration: 0\nIteration: 1\nIteration: 2\n", result
+  end
+
+  def test_whitespace_handling
+    value = '|value|'
+
+    body = "  \n  {{  value  }}  \n  "
+    assert_equal "  \n  |value|  \n  ", compile_and_run(body, binding)
+
+    body = "  \n  {{-  value  }}  \n  "
+    assert_equal "|value|  \n  ", compile_and_run(body, binding)
+
+    body = "  \n  {{  value  -}}  \n  "
+    assert_equal "  \n  |value|", compile_and_run(body, binding)
+
+    body = "  \n  {{-  value  -}}  \n  "
+    assert_equal "|value|", compile_and_run(body, binding)
+  end
+
+  def test_comment
+    body = "123{# comment #}456"
+    assert_equal "123456", compile_and_run(body, binding)
+  end
+
+  def test_error_line_mapping
+    body = <<-EOT
+Line 1
+Line {{ 1 + 1 }}
+Line {{- 1 + 2 -}}
+Line {{ invalid }}
+Line 5
+EOT
+    begin
+      compile_and_run(body, binding)
+    rescue StandardError => e
+      e.backtrace[0] =~ /\(template\):(\d+):.*/
+      assert_equal "Error in line: 4", "Error in line: #{$1}"
+    end
+  end
+end

data/test/test_render_context.rb

@@ -0,0 +1,95 @@
+require 'test/unit'
+require_relative '../lib/fiasco/template'
+
+$renderer = Fiasco::Template::RenderContext.new
+
+Dir['./test/templates/*.html'].each do |path|
+  name = path.gsub(/\.html$/, '').gsub('./test/templates/', '')
+  $renderer.declare(name, path: path)
+end
+
+$renderer.load_macros(path: './test/macros/fields.html')
+
+class TestRender < Test::Unit::TestCase
+  def test_simple_render
+    expected = <<-EOS
+<!doctype html>
+<html>
+  <head><title>My Site</title></head>
+  <body class="">
+    <div id=wrapper>
+      <h1>My Site</h1>
+    </div>
+  </body>
+</html>
+EOS
+
+    assert_equal expected, $renderer.render('base')
+  end
+
+  def test_inheritance
+    expected = <<-EOS
+<!doctype html>
+<html>
+  <head><title>My Site -- Homepage</title></head>
+  <body class="">
+    <div id=wrapper>
+      <h1>My Site -- Homepage</h1>
+      <div class=main>
+        <h2>This is the homepage</h2>
+      </div>
+    </div>
+  </body>
+</html>
+EOS
+
+    assert_equal expected, $renderer.render('child')
+  end
+
+  def test_nested_inheritance
+    expected = <<-EOS
+<!doctype html>
+<html>
+  <head><title>My Site -- Homepage</title></head>
+  <body class="">
+    <div id=wrapper>
+      <h1>My Site -- Homepage</h1>
+      Grandchild
+    </div>
+  </body>
+</html>
+EOS
+
+    assert_equal expected, $renderer.render('grandchild')
+  end
+
+  def test_locals
+    assert_equal "a b\n", $renderer.render('with_locals',
+                                           local1: 'a', local2: 'b')
+  end
+
+  def test_macros
+    expected = <<-EOS
+<form method=post>
+  <fieldset>
+  <div class=field>
+  <label>Username</label>
+  <input type="text" name="username" value="" size="20">
+  </div>
+  <div class=field>
+  <label>Password</label>
+  <input type="password" name="password" value="" size="20">
+  </div>
+  <div class=field>
+  <label>Password confirm</label>
+  <input type="password" name="password_confirm" value="" size="20">
+  </div>
+  </fieldset>
+
+  <button>Submit</button>
+</form>
+EOS
+
+    assert_equal expected, $renderer.render('uses_macros', user_name: 'Admin')
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: fiasco-template
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bruno Deferrari
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-17 00:00:00.000000000 Z
+dependencies: []
+description: Templating engine inspired by Jinja2.
+email:
+- utizoc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fiasco/template/compiler.rb
+- lib/fiasco/template/render_context.rb
+- lib/fiasco/template.rb
+- test/test_compiler.rb
+- test/test_render_context.rb
+- test/macros/fields.html
+- test/templates/base.html
+- test/templates/child.html
+- test/templates/grandchild.html
+- test/templates/uses_macros.html
+- test/templates/with_locals.html
+homepage: http://github.com/tizoc/fiasco-template
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Templating engine inspired by Jinja2.
+test_files:
+- test/test_compiler.rb
+- test/test_render_context.rb
+- test/macros/fields.html
+- test/templates/base.html
+- test/templates/child.html
+- test/templates/grandchild.html
+- test/templates/uses_macros.html
+- test/templates/with_locals.html