Stencil 0.1

data/doc/README

@@ -0,0 +1,2 @@
+== This is a Really Cool Ruby Thing
+=== ( That deserves better documentation than this. )

data/doc/Specifications

@@ -0,0 +1,83 @@
+
+Stencil::Template parsing an invalid template
+- should indicate the line and column of the error
+
+Stencil::RenderError
+- should has a useful string representation
+
+Stencil::Template with text directives to wrap lines
+- should transparently pass strings that don't need wrapping
+- should wrap long strings to width
+- should not re-wrap hard newlines
+- should not choke on unwrappable lines
+
+Stencil::Template with text directives to indent lines
+- should indent a single line
+- should indent multiple lines
+
+Stencil::Template with text directives to insert newlines
+- should insert a newline
+
+Stencil::ViewMatcher
+- should succeed with complex subview
+- should fail when structure is wrong
+- should fail when value doesn't match
+- should fail when matcher doesn't match
+
+Stencil::Template from a file
+- should sing and dance
+
+Stencil::Template with a file accessor and include
+- should work just fine
+
+Stencil::Template with simple value reference
+- should render numbers
+- should render strings
+
+Stencil::Template with a deep value reference
+- should render numbers
+
+Stencil::Template with a simple expression
+- should render numbers
+
+Stencil::Template with a 'with' directive
+- should render numbers
+
+Stencil::Template with a 'with' directive and a relative path
+- should render numbers
+- should render empty string if target is missing
+
+Stencil::Template with one list
+- should render combinations
+
+Stencil::Template with two lists
+- should render combinations
+
+Stencil::Template with a with-guarded list
+- should render an array
+
+Stencil::Template with an if block
+- should render true case
+- should render elseif case
+- should render false case
+- should raise error on missing case
+
+Stencil::Template nicely printing a deep list
+- should render list correctly
+
+Stencil::Template with whitespace absorbtion
+- should ignore extra whitespace in tags
+
+Stencil::DynamicTemplate for JSON
+- should render correctly
+
+Stencil::View
+- should render the correct viewset
+
+Stencil::TermStyleDirective
+- should change foreground color
+- should nest stylings
+
+Finished in 0.054271 seconds
+
+35 examples, 0 failures

data/lib/stencil/directives.rb

@@ -0,0 +1 @@
+require 'stencil/directives/base'

data/lib/stencil/directives/base.rb

@@ -0,0 +1,335 @@
+require 'stencil/processor'
+module Stencil
+  class Directive
+    class Source
+      def initialize(file, line, column)
+        @file, @line, @column = file, line, column
+      end
+    
+      attr_accessor :file, :line, :column
+
+      def inspect
+        "#{@file}:#{@line},#{@column}"
+      end
+
+      def exception(based_on=nil)
+        message = case based_on
+                  when String
+                    based_on
+                  when ::Exception
+                    [based_on.class, based_on.message, based_on.backtrace.first].join(": ")
+                  else
+                    "resulting from #{based_on}.inspect"
+                  end
+                    
+        re = RenderError.new(message)
+        re.line = @line
+        re.column = @column
+        re.file = @file
+        re
+      end
+    end
+
+    @@directives = {}
+
+    def self.create(location, string)
+      string = string.sub(/^\s*/,"").sub(/\s*$/,"")
+      name, arguments = string.split(/\s+/, 2)
+      klass = @@directives[name]
+      raise "Unrecognized directive: #{name}" if klass.nil?
+      return klass.new(location, arguments)
+    end
+
+    def self.register(as)
+      @@directives[as.to_s] = self
+    end
+
+    def interpret(code, data)
+      env = EvaluationHost.new(data)
+      return env.run(code)
+    end
+
+    def initialize(source, string)
+      @source = source
+      setup_parameters(string)
+    end
+
+    def setup_parameters(string)
+    end
+
+    def inspect
+      "[#{self.class.name.split("::").last} #{inspect_args}]"
+    end
+
+    def inspect_args
+      nil
+    end
+
+    def parsed(stack)
+      stack.last.add(self)
+    end
+
+    def prerender(state)
+    end
+
+    def checked_render(state)
+      begin
+        render(state)
+      rescue RenderError
+        raise
+      rescue Object => ex
+        raise @source, ex
+      end
+    end
+
+    def render(data)
+      nil
+    end
+
+    def postrender(state)
+    end
+
+    def pre_end(state)
+    end
+
+    def render_end(data)
+      nil
+    end
+  end
+
+  class Literal < Directive
+    def setup_parameters(string)
+      @value = string
+    end
+
+    def render(data)
+      @value
+    end
+
+    def inspect_args
+      @value.inspect
+    end
+  end
+
+  class Apply < Directive
+    register "apply"
+
+    def setup_parameters(string)
+      @type, @path = string.split(" ")
+    end
+
+    def render(state)
+      state.data.push_context(@path)
+      result = DynamicTemplate::formatter(@type).render_raw(state.data)
+      state.data.pop_context
+      return result
+    end
+  end
+
+  class Include < Directive
+    register "include"
+
+    def setup_parameters(string)
+      @template_path, @data_path = string.split(" ")
+    end
+
+    def render(state)
+      template = state.get_template(@template_path)
+      state.data.with_context(@data_path) do |data|
+        template.render_raw(data)
+      end
+    end
+  end
+
+  class Interpolate < Directive
+    register "="
+
+    def setup_parameters(string)
+      @code = string || "@"
+    end
+
+    def render(state)
+      return interpret(@code, state.data)
+    end
+
+    def inspect_args
+      @path
+    end
+  end
+
+  class Block < Directive
+    def initialize(location, string)
+      super
+      @apply = []
+    end
+
+    def inspect
+      "[#{self.class.name.split("::").last} #{inspect_args} {#{@apply.map{|dr| dr.inspect}.join(" ")}}]"
+    end
+
+    def add(directive)
+      @apply << directive 
+    end
+
+    def parsed(stack)
+      super
+      stack << self
+    end
+
+    def render(state)
+      @apply.map do |directive|
+        directive.checked_render(state)
+      end.flatten.compact
+    end
+
+    def ended(stack)
+      stack.pop
+    end
+  end
+
+  class With < Block
+    register :with
+
+    def setup_parameters(path)
+      @path = path
+    end
+
+    def inspect_args
+      @path
+    end
+
+    def render(state)
+      if state.data.access(@path).nil?
+        return []
+      else
+        state.data.push_context(@path)
+        res = super
+        state.data.pop_context
+
+        return res
+      end
+    end
+  end
+
+  class Each < Block
+    register :each
+
+
+    #XXX what if @list doesn't point to an array?
+    def setup_parameters(string)
+      @path, @named_context = string.split(" ", 2)
+    end
+
+    def intercept(directive)
+      @apply << directive
+      nil
+    end
+
+    def inspect_args
+      "#@path => #@named_context"
+    end
+
+    def render(state)
+      data = state.data
+      list = data.access(@path)
+      data.push_context(@path, @named_context)
+      data.push_context(@path)
+      result = (0...list.length).map do |index|
+        data.push_context("##{index}", @named_context)
+        data.push_context("##{index}")
+
+        res = super
+
+        data.pop_context(@named_context)
+        data.pop_context
+        res
+      end.flatten.compact
+      data.pop_context(@named_context)
+      data.pop_context
+
+      result
+    end
+  end
+
+  class If < Block
+    register :if
+
+    def setup_parameters(code)
+      @code = code
+      @truth = nil
+    end
+    attr_reader :truth
+
+    def inspect_args
+      @code
+    end
+
+    def determine_truth(data)
+      @truth = interpret(@code, data)
+      return @truth
+    end
+
+    def render(state)
+      if determine_truth(state.data)
+        return super
+      end
+    end
+  end
+
+  class Else < If
+    register :else
+    register :elif
+
+    def setup_parameters(code)
+      super
+      @previous = nil
+      @a_truth = false
+    end
+
+    def truth
+      @a_truth
+    end
+
+    def determine_truth(data)
+      if @previous.truth
+        @a_truth = true
+        @truth = false
+      else
+        if @code.nil?
+          @truth = true
+        else
+          @truth = interpret(@code, data)
+        end
+        @a_truth = @truth
+      end
+      @truth
+    end
+
+    def parsed(stack)
+      @previous = stack.last
+      unless If === @previous 
+        raise @source, "else has to follow if"
+      end
+      @previous.ended(stack)
+      super
+    end
+    end
+
+
+  class End < Directive
+    register :end
+    register "/"
+
+    def setup_parameters(arg)
+      @ended = nil
+      @count = arg.to_i
+      @count = 1 if @count < 1
+    end
+
+    def parsed(stack)
+      @count.times do
+        stack.last.ended(stack)
+      end
+    end
+  end
+end

data/lib/stencil/directives/term-style.rb

@@ -0,0 +1,127 @@
+module Stencil
+  module Styles
+    Foreground = { 
+      'black'   => 30,
+      'red'     => 31, 
+      'green'   => 32, 
+      'yellow'  => 33,
+      'blue'    => 34,
+      'magenta' => 35,
+      'cyan'    => 36,
+      'white'   => 37,
+      'default' => 39
+    }
+
+    Background = {}
+
+    Foreground.each() do |name, value|
+      Background[name] = value + 10
+    end
+
+    Extra = {
+      'clear'     => 0, 
+      'bold'      => 1,
+      'unbold'      => 22,
+      'underline' => 4,
+      'ununderline' => 24,
+      'blink'     => 5,
+      'unblink'     => 25,
+      'inverse'   => 7,
+      'uninverse'   => 27
+    }
+  end
+
+  class TermStyleDirective < Block
+    def initialize(location, string)
+      @previous_style = nil
+      @style = nil
+      super
+    end
+
+    def code_for(kind, name)
+      if kind.has_key?(name.to_s)
+        "\e[#{kind[name.to_s]}m"
+      else
+        ""
+      end
+    end
+
+    def escape_codes(options)
+      return "\e[0m" if options.empty?
+      return code_for(Styles::Foreground, options[:foreground]) + 
+        code_for(Styles::Background, options[:background]) + 
+        code_for(Styles::Extra, options[:extra])
+    end
+
+    def parsed(stack)
+      reverse = Enumerable::Enumerator::new(stack, :reverse_each)
+      @previous_style = reverse.find {|dir| TermStyleDirective === dir}
+      super
+    end
+
+    def old_style(state)
+      @old_style ||= @previous_style.style(state) rescue {:foreground => 'default', :background => 'default'}
+    end
+
+    def style(state)
+      @style ||= update_style(old_style(state), state.data)
+    end
+
+    def render(state)
+      [escape_codes(style(state))] + super + [escape_codes(old_style(state))]
+    end
+
+    def update_style(style, state)
+      return style
+    end
+  end
+
+  class ForegroundColor < TermStyleDirective
+    register :fcolor
+    def setup_parameters(color)
+      @color_text = color
+    end
+
+    def update_style(style, state)
+      return style.merge(:foreground => interpret(@color_text, state))
+    end
+  end
+
+  class Bold < TermStyleDirective
+    register :bold
+
+    def render(state)
+      [code_for(Styles::Extra, 'bold')] + 
+        super + 
+        [code_for(Styles::Extra, 'unbold')]
+    end
+  end
+
+  class Underline < TermStyleDirective
+    register :underline
+
+    def render(state)
+      [code_for(Styles::Extra, 'underline')] + 
+        super + 
+        [code_for(Styles::Extra, 'ununderline')]
+    end
+  end
+
+  class Inverse < TermStyleDirective
+    register :inverse
+
+
+    def render(state)
+      [code_for(Styles::Extra, 'inverse')] + 
+        super + 
+        [code_for(Styles::Extra, 'uninverse')]
+    end
+  end
+
+  class BackgroundColor < ForegroundColor
+    register :bcolor
+    def update_style(style, state)
+      return style.merge(:background => interpret(@color_text, state))
+    end
+  end
+end

data/lib/stencil/directives/text.rb

@@ -0,0 +1,62 @@
+
+module Stencil
+  class Newline < Literal
+    register "nl" 
+    def setup_parameters(dummy)
+      super("\n")
+    end
+  end
+
+  class Wrap < Block
+    register "wrap"
+    def setup_parameters(width)
+      @width_text = width
+    end
+  
+    def render(state)
+      env = EvaluationHost.new(state.data)
+      width = env.run(@width_text)
+      res = super.compact.join("")
+      scanner = StringScanner.new(res)
+      scanner.skip(/\s*/m)
+
+      result = []
+      line = scanner.scan(/\S+/m) || ""
+
+      until scanner.eos? 
+        white = scanner.scan(/\s*/m)
+        white.gsub(/\n/) do |nl|
+          result << line + "\n"
+          line = ""
+        end
+        word = scanner.scan(/\S+/m)
+        next if word.nil?
+        if word.length > (width - line.length)
+          result << line + "\n"
+          line = word
+        else
+          line << (" " + word)
+        end
+      end
+
+      result << line
+
+      return result
+    end
+  end
+
+  class Indent < Block
+    register "indent" 
+
+    def setup_parameters(spaces)
+      @space_text = spaces
+    end
+
+    def render(state)
+      spaces = " " * interpret(@space_text, state.data)
+      res = super.compact.join("")
+      res = spaces + res.gsub(/\n(?!$)/, "\n" + spaces)
+      return res
+    end
+  end
+end

data/lib/stencil/dynamic-template.rb

@@ -0,0 +1,98 @@
+require 'stencil/template'
+
+module Stencil
+  class DynamicTemplate < Template
+    @@formatters = Hash.new
+    def self.formatter(kind, &file_opener)
+      file_opener ||= DefaultFileOpener
+      formatter = @@formatters[kind.to_s]
+      if Class === formatter
+        formatter = formatter.new(&file_opener)
+        @@formatters[kind] = formatter
+      end
+      formatter
+    end
+
+    def self.register(kind)
+      @@formatters[kind.to_s] = self
+      define_method(:my_name){kind.to_s}
+    end
+
+    def initialize(&file_opener)
+      @hash_template = parse(*self.class.hash_template)
+      @array_template = parse(*self.class.array_template)
+      @item_template = parse(*self.class.item_template)
+      @file_opener = file_opener
+    end
+
+    def parse(string, file, line)
+      super(string.gsub(/\[;\s*reapply/, "[;apply #{my_name}"), file, line)
+    end
+
+    def array_render(data)
+      state = State.new(data, &@file_opener)
+      res = render_with(state, @array_template)
+      return res
+    end
+
+    def hash_render(data)
+      pairs = data.access("").map{|k,v| {"key" => k, "value" => v}}
+      state = State.new(data, &@file_opener) 
+      state.data.inject_dataset("pair", pairs)
+      render_with(state, @hash_template)
+    end
+
+    def item_render(data)
+      state = State.new(data, &@file_opener) 
+      res = render_with(state, @item_template)
+    end
+
+    def render_raw(data)
+      res = nil
+      case data.access("")
+      when Array
+        res = array_render(data)
+      when Hash
+        res = hash_render(data)
+      else
+        res = item_render(data)
+      end
+      return res
+    end
+
+    class << self
+      attr_reader :hash_template, :array_template, :item_template
+
+      def line_and_file
+        m = %r{^([^:]+):(\d+)}.match caller[1]
+        if m.nil?
+          return []
+        else
+          return [m[1], m[2].to_i]
+        end
+      end
+
+      def list(string)
+        @array_template = [string] + line_and_file
+      end
+
+      def hash(string)
+        @hash_template = [string] + line_and_file
+      end
+
+      def item(string)
+        @item_template = [string] + line_and_file
+      end
+    end
+  end
+
+  class JSONTemplate < DynamicTemplate
+    register :json
+
+    hash "{[;nl;][;each pair h;][;indent 2;][;= @h:key;]: [;reapply @h:value;][;if @h+1;], [;/;][;/;][;nl;][;/;]}"
+
+    list "[ [;each @ i;][;reapply @i;][;if @i+1;], [;/;][;/;] ]"
+
+    item "[;=;]"
+  end
+end

data/lib/stencil/processor.rb

@@ -0,0 +1,35 @@
+
+module Stencil
+  class EvaluationHost
+    remove_methods = self.instance_methods(true)
+    remove_methods -= %w{binding extend}
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+    remove_methods.each do |method|
+      undef_method(method)
+    end
+    $VERBOSE = old_verbose
+
+    remove_constants = constants
+    remove_constants.each do |const|
+      remove_const(const)
+    end
+
+    def self.const_missing(name)
+      raise "Access to constants (including classes) is not allowed in template processing"
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def val(path)
+      @data.access(path)
+    end
+
+    def run(code)
+      code = code.gsub(/@([^\s.]*)/){|m| "val('#{$1}')"}
+      return ::Kernel::eval(code, binding)
+    end
+  end
+end

data/lib/stencil/spec/view_matcher.rb

@@ -0,0 +1,146 @@
+module Kernel
+  def at_path(*args)
+    Stencil::ViewMatcher::AtPath::Expectation.new(args, self)
+  end
+end
+
+module Stencil
+  module ViewMatcher
+    def have_subview(view)
+      return SubviewMatcher.new(view)
+    end
+
+    class SubviewMatcher
+      def initialize(subview)
+        @subview = subview
+      end
+
+      def matches?(view)
+        @view = view
+        create_submatches([], @subview)
+        return true
+      end
+
+      def create_submatches(path, subview)
+        case subview
+        when Hash
+          subview.each_pair do |name, value|
+            create_submatches(path + [name], value)
+          end
+        when Array
+          subview.each_with_index do |value, index|
+            create_submatches(path + [index], value)
+          end
+        else
+          if subview.respond_to?(:matches?)
+            @view.at_path(*path).should(subview)
+          else
+            @view.at_path(*path).should == subview
+          end
+        end
+      end
+    end
+
+    module AtPath
+      class PositiveOperatorMatcher < ::Spec::Matchers::PositiveOperatorMatcher
+        def initialize(path, actual)
+          @path = path
+          super(actual)
+        end
+
+        ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+          define_method(operator) do |expected|
+            begin
+              super
+            rescue ::Spec::Expectations::ExpectationNotMetError => enme
+              message = "At #{@path.inspect}\n" + enme.message
+              Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+            end
+          end
+        end
+      end
+
+      class NegativeOperatorMatcher < ::Spec::Matchers::NegativeOperatorMatcher
+        def initialize(path, actual)
+          @path = path
+          super(actual)
+        end
+
+        ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+          define_method(operator) do |expected|
+            begin
+              super
+            rescue ::Spec::Expectations::ExpectationNotMetError => enme
+              message = "At #{@path.inspect}\n" + enme.message
+              Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+            end
+          end
+        end
+      end
+
+      class Expectation
+        def initialize(path, actual)
+          @path, @actual = path, actual
+          @thumb = @actual
+          @into = []
+        end
+
+        def should(matcher=nil, &block)
+          dereference
+          if matcher.nil?
+            ::Spec::Matchers.last_should = :should
+            ::Spec::Matchers.last_matcher = matcher
+            return PositiveOperatorMatcher.new(@path, @thumb)
+          end
+
+          begin
+            Spec::Expectations::PositiveExpectationHandler.handle_matcher(@thumb, matcher, &block)
+          rescue ::Spec::Expectations::ExpectationNotMetError => enme
+            message = "At #{@path.inspect}\n" + enme.message
+            Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+          end
+        end
+
+        def should_not(matcher=nil, &block)
+          dereference
+
+          if matcher.nil?
+            ::Spec::Matchers.last_should = :should_not
+            ::Spec::Matchers.last_matcher = matcher
+            return NegativeOperatorMatcher.new(@path, @thumb) 
+          end
+
+          begin
+            Spec::Expectations::NegativeExpectationHandler.handle_matcher(@thumb, matcher, &block)
+          rescue ::Spec::Expectations::ExpectationNotMetError => enme
+            message = "At #{@path.inspect}\n" + enme.message
+            Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+          end
+        end
+
+        def dereference
+          @path.each do |segment|
+            @into << segment
+            case @thumb
+            when Array
+              unless Integer === segment
+                deref_fail
+              end
+            when Hash
+              unless @thumb.has_key?(segment)
+                deref_fail
+              end
+            else
+              deref_fail
+            end
+            @thumb = @thumb[segment] rescue deref_fail
+          end
+        end
+
+        def deref_fail
+          ::Spec::Expectations.fail_with("Member: #{@thumb.class.name} at (#{@into[0..-2].inspect}) has no index #{@into.last.inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/stencil/template.rb

@@ -0,0 +1,269 @@
+require 'strscan'
+require 'stencil/processor'
+require 'stencil/directives'
+
+module Stencil
+  class Exception < ::Exception; end
+  class RenderError < Exception
+    attr_accessor :line, :column, :file, :based_on
+
+    def message
+      super + " at: #@file:#@line,#@column"
+    end
+  end
+  class ParseError < Exception; end
+
+
+  class Data
+    def initialize(data)
+      @data = data
+      @path = []
+    end
+
+    def relative(string)
+      path = @path.dup
+      s = StringScanner.new(string||"")
+
+      goto = s.scan(/[^:#]*/)
+      g = StringScanner.new(goto)
+
+      while g.rest?
+        go = g.getch
+
+        case go
+        when "^"
+          path.pop
+        when "/"
+          path.clear
+        when "+"
+          number = g.scan(/\d+/).to_i
+          here = path.pop
+          path.push(here + number)
+        when "-"
+          number = g.scan(/\d+/).to_i
+          here = path.pop
+          path.push(here - number)
+        else 
+          raise "Unrecognized path offset: #{go}"
+        end
+      end
+
+      while s.rest?
+        delim = s.getch
+        segment = s.scan(/[^:#]*/)
+          case delim
+          when ":"
+            path << segment
+          when "#"
+            path << segment.to_i
+          end
+      end
+
+      path
+    end
+
+    def recontext(string)
+      result = Data.new(@data)
+      result.path = relative(string)
+      return result
+    end
+
+    attr_accessor :data, :point, :path
+
+    def access(string)
+      data = @data
+      path = relative(string)
+      path.each do |segment|
+        data = data[segment]
+      end
+      return data
+    end
+  end
+
+
+  class Template
+    class DataContext
+      def initialize(data)
+        @datasets = Hash.new{|h,k| h[k]=[]}
+        @datasets[nil] << Data.new(data)
+      end
+
+      def context_name(path)
+        m = /^@?([a-z]*)/.match(path)
+        which = m[1]
+        which = nil if which.empty?
+        path = m.post_match
+        return which,path
+      end
+
+      def push_context(path, onto=nil)
+        which, path = context_name(path)
+        @datasets[onto] << @datasets[which].last.recontext(path)
+      end
+
+      def pop_context(from=nil)
+        @datasets[from].pop
+      end
+
+      def with_context(path, onto = nil)
+        push_context(path, onto)
+        result = yield(self)
+        pop_context(onto)
+        return result
+      end
+
+      def inject_dataset(name, dataset)
+        @datasets[name] << Data.new(dataset)
+      end
+
+      def access(path)
+        which, path = context_name(path)
+        @datasets[which].last.access(path)
+      end
+    end
+
+    class State
+      def initialize(data, &file_opener)
+        @data = data
+        @file_opener = file_opener
+      end
+
+      def get_template(path)
+        Template::file(path, &@file_opener)
+      end
+
+      attr_accessor :data
+    end
+
+    DefaultFileOpener = proc do |path|
+        File.open(path) do |file|
+          file.read
+        end
+      end
+
+
+    class << self
+      def string(data, file=nil, line=nil, &file_open)
+        m = %r{^([^:]+):(\d+)}.match caller[0]
+        file ||= m[1] unless m.nil?
+        line ||= m[2].to_i unless m.nil?
+
+        file ||= ""
+        line ||= 1
+        template = self.new(data, file, line)
+        template.file_opener = file_open unless file_open.nil?
+        return template
+      end
+
+      def file(path, &file_open)
+        file_open ||= DefaultFileOpener
+        template = self.new(file_open[path], path)
+        template.file_opener = file_open
+        return template
+      end
+    end
+
+    def initialize(template, file="", line=1, column=1)
+      @template = parse(template, file, line, column)
+      @file_opener = DefaultFileOpener
+    end
+
+    class DocumentScanner
+      def initialize(string, file="", line=1, column=1)
+        @file = file
+        @begin_line, @begin_column = line,column
+        @end_line, @end_column = line,column
+        @scanner = StringScanner.new(string)
+      end
+    
+      attr_accessor :file, :line, :col
+
+      def scan(pattern)
+        result = @scanner.scan(pattern)
+        return nil if result.nil?
+
+        lines = result.split("\n")
+        @begin_line = @end_line
+        @begin_column = @end_column
+        if lines.length > 1
+          @end_line += lines.length - 1
+          @end_column = lines.last.length + 1
+        else
+          @end_column += result.length
+        end
+        return result
+      end
+
+      def rest
+        @scanner.rest
+      end
+
+      def rest?
+        @scanner.rest?
+      end
+
+      def location
+        Directive::Source.new(@file, @begin_line, @begin_column)
+      end
+    end
+    attr_writer :file_opener
+
+    BeginDirective = %r{\[;}m
+      EndDirective = %r{;\]}m
+        UntilDirective = %r{.*?(?=#{BeginDirective})}m
+        FinishDirective = %r{.*?(?=#{EndDirective})}m
+
+
+        def parse(template, file="", line=1, column=1)
+          scanner = DocumentScanner.new(template, file, line, column)
+          result = [Block.new(scanner.location, "")]
+          last_newline = 0
+
+          while scanner.rest?
+            literal = scanner.scan(UntilDirective)
+
+            unless literal.nil? or literal.empty? 
+              result.last.add(Literal.new(scanner.location, literal))
+            end
+
+            delim = scanner.scan(BeginDirective)
+
+            if delim.nil?
+              result.last.add(Literal.new(scanner.location, scanner.rest))
+              break
+            end
+
+            directive = scanner.scan(FinishDirective)
+
+            directive = Directive.create(scanner.location, directive)
+            directive.parsed(result)
+
+            scanner.scan(EndDirective)
+          end
+
+          raise "Unterminated directives: #{result[1..-1].inspect}" unless result.length == 1
+          result.last
+        end
+
+        def render(data)
+          data_context = DataContext.new(data)
+          render_raw(data_context).compact.join("")
+        end
+
+        def render_raw(data)
+          state = State.new(data, &@file_opener)
+          render_with(state, @template)
+        end
+
+        def render_with(state, template)
+          begin
+            result = template.checked_render(state)
+            return result
+          rescue RenderError
+            raise
+          rescue Object => ex
+            raise RenderError, [ex.class, ex.message].join(" ")
+          end
+        end
+  end
+end

data/lib/stencil/view.rb

@@ -0,0 +1,133 @@
+module Stencil
+  module ViewHost 
+    class Renderer
+      def initialize(data, capsule)
+        @data = data
+        @capsule = capsule
+      end
+
+      def go
+        instance_eval(&@capsule.block)
+      end
+
+      attr_reader :data
+    end
+
+    class EvalRenderer < Renderer
+      def go
+        @data.instance_eval(&@capsule.block)
+      end
+    end
+
+    def view(mod = nil, &block)
+      render_class = EvalRenderer
+      unless mod.nil?
+        render_class = Class.new(EvalRenderer) do 
+          include(mod)
+        end
+      end
+      sub_view(render_class, &block)
+    end
+    module_function :view
+
+    def sub_view(render_class, &block)
+      template = ViewDefinition.create_template(render_class, &block)
+      return View.new(template)
+    end
+    module_function :sub_view
+  end
+
+  class ViewDefinition
+    def self.create_template(render_class, &block)
+      definer = self.new(render_class)
+      return definer.instance_eval(&block)
+    end
+
+    def initialize(render_class)
+      @render_class = render_class
+    end
+
+    def item(&block)
+      Capsule.new(@render_class, &block)
+    end
+
+    def list(&block)
+      ListCapsule.new(@render_class, &block)
+    end
+  end
+
+  class Capsule
+    def initialize(render_class, &block)
+      @render_class = render_class
+      @block = block
+    end
+    attr_reader :block
+
+    def render(data)
+      @render_class.new(data, self).go
+    end
+  end
+
+  class ListCapsule < Capsule
+    def initialize(render_class, &block)
+      super
+      @mapping = nil
+    end
+
+    def map(&block)
+      @mapping = ViewHost.sub_view(@render_class, &block)
+      self
+    end
+
+    def render(data)
+      list = super
+      rendered = list.map do |item|
+        @mapping.viewset(item)
+      end
+      rendered
+    end
+  end
+
+  class View
+    def initialize(template)
+      @template = template
+    end
+
+    attr_reader :template
+
+    def render_map(data, hash)
+      rendered = {}
+      hash.each_pair do |key, value|
+        rendered[key.to_s] = render_sub(data, value)
+      end
+      rendered
+    end
+
+    def render_list(data, list)
+      list.map do |item|
+        render_sub(data, item)
+      end
+    end
+
+    def render_item(data, item)
+      item
+    end
+
+    def render_sub(data, template)
+      case template
+      when Hash
+        render_map(data, template)
+      when Array
+        render_list(data, template)
+      when Capsule
+        render_sub(data, template.render(data))
+      else 
+        render_item(data, template)
+      end
+    end
+
+    def viewset(data)
+      render_sub(data, @template)
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: Stencil
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Judson Lester
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-28 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: "  Stencil is a templating library with a number of design goals.\n\n  *  Limited code in templates.  This isn't meant to embed ruby in anything - \n  it allows for simple control structures, since that's typically what you need \n  in a template, but full access to the Ruby\n  interpreter is just a tempatation into sin. (From a separation of concerns \n  standpoint.)  There's a certain amount of code available in conditionals and \n  interpolations, since otherwise they're much harder to do...\n\n  *  Easy to extend.  If you do need something extra from a template, not \n  having it in the templating language is frustrating.  It's easy to add \n  features to stencil, since they're described in as well-designed classes.\n\n  * Generic output.  Not everything is a website or a mime-encoded email.  It's \n  nice to be able to spit out generic text from time to time.\n\n  * Data sourced from simple datatypes - hashes and array, referenced with data \n  paths.  Views can be extracted from any object, or built up in code.\n"
+email: nyarly@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- doc/README
+- doc/Specifications
+files: 
+- lib/stencil/spec/view_matcher.rb
+- lib/stencil/processor.rb
+- lib/stencil/directives.rb
+- lib/stencil/template.rb
+- lib/stencil/dynamic-template.rb
+- lib/stencil/directives/text.rb
+- lib/stencil/directives/base.rb
+- lib/stencil/directives/term-style.rb
+- lib/stencil/view.rb
+- doc/README
+- doc/Specifications
+has_rdoc: true
+homepage: http://stencil-templ.rubyforge.org/
+licenses: []
+
+post_install_message: Another tidy package brought to you by Judson
+rdoc_options: 
+- --inline-source
+- --main
+- doc/README
+- --title
+- Stencil-0.1 RDoc
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: stencil-templ
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Output agnostic templating engine
+test_files: []
+