zrb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d95c6b276edcdeb944acbb480dc0104d5cf0bd0
+  data.tar.gz: 8583aaf2793e75e1f4f8b4e2bb37a769243178b3
+SHA512:
+  metadata.gz: 80a4758f359a27d984fd2b52d9120e132adccb17ebcea23c6c183d5ad36f21c73e2e82214d648c20f270fc21094b6f59eaa7c051666acbd5cd9c0af3803bc496
+  data.tar.gz: d3ecbb267cd5add08f970ae5659065d0114ecb58afe47534f0ea22cb2a2d2c68ff3e49c220a8c988cd7063eec1ba29e8518cf2c1e9fb7db7f7edf0b0ab1e8f7a

data/README.md

@@ -0,0 +1,54 @@
+# ZRB, simple Ruby template engine
+
+ZRB is a lightweight template engine with the following features:
+
+* Automatic HTML escaping of expressions
+* Ruby-like syntax for expressions: `#{person.name}`
+* Helper functions can capture the result of yielding a block
+* Block helpers are supported
+
+Example:
+
+```zrb
+<h1>Welcome #{user.name}</h1>
+
+<ul>
+  <? messages.each do |msg| ?>
+    <li>#{msg.text}</li>
+  <? end ?>
+</ul>
+
+<?= form_for messages_path do |f| ?>
+  <textarea name="content"></textarea>
+<? end ?>
+```
+
+## Usage
+
+ZRB uses [Tilt](https://github.com/rtomayko/tilt) for rendering.
+`ZRB::Template` is a Tilt template and you can use all of Tilt's
+features:
+
+```ruby
+require 'zrb'
+tmpl = ZRB::Template.new('index.zrb')
+tmpl.render(scope, :user => user)
+```
+
+Note however that ZRB has one strict requirement on the scope: **The
+scope must implement the method `build_zrb_buffer`**. This method should
+return an instance of `ZRB::Buffer` (or a subclass like
+`ZRB::HTMLBuffer`). This is required in order to support block helpers:
+
+```ruby
+class RenderScope
+  def build_zrb_buffer
+    @_buffer = ZRB::HTMLBuffer.new
+  end
+
+  def form_for(path, &blk)
+    "<form>#{@_buffer.capture(blk)}</form>"
+  end
+end
+```
+

data/lib/zrb.rb

@@ -0,0 +1,193 @@
+module ZRB
+  class Parser
+    attr_reader :data, :source, :filename, :lineno
+
+    def initialize(data, filename, lineno)
+      @data = data
+      @filename = filename
+      @lineno = lineno
+      @source = ""
+      @state = :ruby
+      generate
+    end
+
+    SPACE = /[\t ]/
+
+    TOKEN = /
+      (.*?) # Regular text
+      (?:
+        ( # Expression start
+          \#\{
+        ) 
+
+      | (?: # Statement
+          (^#{SPACE}*)? 
+          \<\? (.*?) \?>
+          (#{SPACE}*\n)?  # Remove trailing newline
+        ) 
+      | \z
+      )
+    /mx
+
+    EXPR_CLOSE = '}'
+
+    def parse
+      pos = 0
+      while pos < data.size
+        match = data.match(TOKEN, pos)
+        raise SyntaxError, "#{filename}:#{lineno}: parse error" unless match
+        all, text, expr, statement_space, statement, _ = *match
+        pos += all.size
+
+        yield :text, text unless text.empty?
+
+        if expr
+          # Start looking for a closing brace
+          closing_pos = pos
+          begin
+            closing_pos = data.index(EXPR_CLOSE, closing_pos + 1)
+            break unless closing_pos
+            expr = data[pos...closing_pos]
+          end until valid_ruby?(expr)
+
+          if !closing_pos
+            raise SyntaxError, "#{filename}:#{lineno}: unclosed brace"
+          end
+
+          yield :expression, expr
+
+          pos = closing_pos + 1
+        end
+
+        yield :newline if statement_space
+
+        if statement
+          case statement[0]
+          when ?=
+            # block expression
+            yield :block_expression, statement[1..-1]
+          when ?#
+            # comment
+            yield :comment, statement[1..-1]
+          else
+            yield :statement, statement
+          end
+        end
+      end 
+    end
+
+    def valid_ruby?(text)
+      catch(:halt) do
+        eval("BEGIN{throw :halt};#{text}")
+      end
+    rescue SyntaxError
+      false
+    else
+      true
+    end
+
+    def ensure_string
+      if @state != :string
+        source << 'buffer.append_string("'
+        @state = :string
+      end
+    end
+
+    def append_text(text)
+      escaped = text.split("\n", -1).map { |part| part.inspect[1..-2] }.join("\n")
+
+      ensure_string
+      source << escaped
+    end
+
+    def append_expr(ruby)
+      ensure_string
+      source << "\#{buffer.escape((#{ruby}))}"
+    end
+
+    def append_ruby(ruby)
+      source << '");' if @state == :string
+      source << ruby
+      @state = :ruby
+    end
+
+    def append_newline
+      if @state == :string
+        source << "\"\\\n\""
+      else
+        source << "\n"
+      end
+    end
+
+    def generate
+      append_ruby('buffer = build_zrb_buffer;')
+
+      parse do |type, value|
+        case type
+        when :text
+          append_text(value)
+        when :expression
+          append_expr(value)
+        when :block_expression
+          append_ruby("buffer.append=#{value};")
+        when :statement
+          append_ruby("#{value};")
+        when :newline
+          append_newline
+        end
+      end
+
+      append_ruby('buffer')
+    end
+  end
+
+  require 'tilt'
+
+  class Template < Tilt::Template
+    def prepare
+      @src = Parser.new(data, eval_file, line).source
+    end
+
+    def precompiled_template(locals)
+      @src
+    end
+
+    Tilt.register Template, 'zrb'
+  end
+
+  class Buffer < String
+    def escape(other)
+      other.to_s
+    end
+
+    def append=(other)
+      self << escape(other)
+    end
+
+    def append_string(other)
+      self << other
+    end
+
+    def capture(blk)
+      start = self.size
+      blk.call
+    ensure
+      return self.slice!(start..-1)
+    end
+  end
+
+  require 'cgi'
+
+  class HTMLBuffer < Buffer
+    def to_html; self end
+
+    def escape(other)
+      if other.respond_to?(:to_html)
+        other.to_html
+      else
+        CGI.escape_html(other.to_s)
+      end
+    end
+  end
+end
+

data/lib/zrb/version.rb

@@ -0,0 +1,4 @@
+module ZRB
+  VERSION = '1.0.0'
+end
+

data/test/test_zrb.rb

@@ -0,0 +1,97 @@
+require 'minitest/autorun'
+require 'zrb'
+
+class TestZRB < Minitest::Test
+  include ZRB
+  
+  def build_zrb_buffer
+    flunk "no buffer setup" unless @buffer
+    return @buffer
+  ensure
+    @buffer = nil
+  end
+
+  def test_text
+    @buffer = Buffer.new
+    t = Template.new { "Hello world" }
+    assert_equal "Hello world", t.render(self)
+
+    @buffer = Buffer.new
+    t = Template.new { "Hello\nworld" }
+    assert_equal "Hello\nworld", t.render(self)
+  end
+
+  def test_capture
+    @buffer = Buffer.new
+    t = Template.new { <<-EOF }
+    <? @res = buffer.capture(proc do ?>
+      Hello world!
+    <? end) ?>
+    EOF
+
+    assert_equal "", t.render(self).strip
+    assert_instance_of Buffer, @res
+    assert_equal "Hello world!", @res.strip
+  end
+
+  def test_stmt_spacing
+    t = Template.new { <<-EOF }
+<? if check ?>
+hello
+<? else ?>
+world
+<? end ?>
+    EOF
+
+    @buffer = Buffer.new
+    assert_equal "hello\n", t.render(self, :check => true)
+    @buffer = Buffer.new
+    assert_equal "world\n", t.render(self, :check => false)
+  end
+
+  def test_nested_capture
+    @buffer = Buffer.new
+    t = Template.new { <<-EOF }
+    <? @res1 = buffer.capture(proc do ?>
+      Hello world!
+      <? @res2 = buffer.capture(proc do ?>
+        Hello second!
+      <? end) ?>
+    <? end) ?>
+    EOF
+
+    assert_equal "", t.render(self).strip
+    assert_instance_of Buffer, @res1
+    assert_instance_of Buffer, @res2
+    assert_equal "Hello world!", @res1.strip
+    assert_equal "Hello second!", @res2.strip
+  end
+
+  def test_expr
+    @buffer = Buffer.new
+    t = Template.new { 'Hello #{1 + 1}' }
+    assert_equal "Hello 2", t.render(self)
+  end
+
+  def form_for(&blk)
+    "<form>#{@form_buffer.capture(blk).strip}</form>"
+  end
+
+  def test_block_expr
+    @form_buffer = @buffer = Buffer.new
+    t = Template.new { <<-EOF }
+    <?= form_for do ?>
+    Hello world!
+    <? end ?>
+    EOF
+
+    assert_equal "<form>Hello world!</form>", t.render(self).strip
+  end
+
+  def test_html
+    @buffer = HTMLBuffer.new
+    t = Template.new { 'Hello #{"&"}' }
+    assert_equal "Hello &amp;", t.render(self)
+  end
+end
+

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: zrb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Magnus Holm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- judofyr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/zrb.rb
+- lib/zrb/version.rb
+- test/test_zrb.rb
+homepage: https://github.com/judofyr/zrb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple template engine
+test_files: []