temple 0.0.1

data/README

@@ -0,0 +1,7 @@
+= Temple, a template compilation framework for Ruby
+
+I just wrote a 7521px long blog post about Temple, and I'm way too tired to
+write anything sensible here.
+
+* Read http://judofyr.net/posts/temple.html
+* Join http://groups.google.com/group/guardians-of-the-temple

data/Rakefile

@@ -0,0 +1,20 @@
+task :default => :spec
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new {|t| t.spec_opts = ['--color']}
+
+
+begin
+  project = 'temple'
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = project
+    gem.summary = "Template compilation framework in Ruby"
+    gem.email = "judofyr@gmail.com"
+    gem.homepage = "http://github.com/judofyr/#{project}"
+    gem.authors = ["Magnus Holm"]
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/temple.rb

@@ -0,0 +1,19 @@
+module Temple
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip.split('.').map{|i|i.to_i}
+  
+  autoload :Core,       'temple/core'
+  autoload :Engine,     'temple/engine'
+  autoload :Generator,  'temple/generator'
+  
+  module Parsers
+    autoload :ERB,      'temple/parsers/erb'
+    autoload :Mustache, 'temple/parsers/mustache'
+  end
+  
+  module Filters
+    autoload :Mustache,       'temple/filters/mustache'
+    autoload :StaticMerger,   'temple/filters/static_merger'
+    autoload :DynamicInliner, 'temple/filters/dynamic_inliner'
+    autoload :Escapable,      'temple/filters/escapable'
+  end
+end

data/lib/temple/core.rb

@@ -0,0 +1,84 @@
+module Temple
+  module Core
+    #   _buf = []
+    #   _buf << "static"
+    #   _buf << dynamic
+    #   block do
+    #     _buf << "more static"
+    #   end
+    #   _buf.join
+    class ArrayBuffer < Generator
+      def preamble;  buffer " = []\n" end
+      def postamble; buffer ".join"   end
+      
+      def on_static(text)
+        buffer " << #{text.inspect}\n"
+      end
+      
+      def on_dynamic(code)
+        buffer " << (#{code})\n"
+      end
+      
+      def on_block(code)
+        code + "\n"
+      end
+    end
+    
+    # Just like ArrayBuffer, but doesn't call #join on the array.
+    class Array < ArrayBuffer
+      def postamble; buffer; end
+    end
+    
+    #   _buf = ''
+    #   _buf << "static"
+    #   _buf << dynamic.to_s
+    #   block do
+    #     _buf << "more static"
+    #   end
+    #   _buf
+    class StringBuffer < ArrayBuffer
+      def preamble;  buffer " = ''\n" end
+      def postamble; buffer end
+      
+      def on_dynamic(code)
+        buffer " << (#{code}).to_s\n"
+      end
+    end
+    
+    # Compiles into a single double-quoted string.
+    #
+    # This doesn't make so much sense when you have blocks, so it's
+    # kinda funky.  You probably want to use Filters::DynamicInliner instead.
+    # For now, check out the source for #on_multi.
+    class Interpolation < Generator
+      def preamble;  '"' end
+      def postamble; '"' end
+      
+      def on_static(text)
+        text.inspect[1..-2]
+      end
+      
+      def on_dynamic(code)
+        '#{%s}' % code
+      end
+      
+      def on_multi(*exps)
+        if exps.detect { |exp| exp[0] == :block }
+          '#{%s}' % exps.map do |exp|
+            if exp[0] == :block
+              exp[1]
+            else
+              compile(exp)
+            end
+          end.join
+        else
+          super
+        end  
+      end
+      
+      def on_block(code)
+        '#{%s;nil}' % code
+      end
+    end
+  end
+end

data/lib/temple/engine.rb

@@ -0,0 +1,42 @@
+module Temple
+  # An engine is simply a chain of compilers (that includes both parsers,
+  # filters and generators).
+  #
+  #   class ERB < Temple::Engine
+  #     parser :ERB            # shortcut for use Temple::Parsers::ERB
+  #     filter :Escapable      #              use Temple::Filters::Escapable
+  #     filter :DynamicInliner #              use Temple::Filters::DynamicInliner
+  #     generator :ArrayBuffer  #              use Temple::Core::ArrayBuffer
+  #  end
+  class Engine
+    def self.filters
+      @filters ||= []
+    end
+    
+    def self.use(filter, *args, &blk)
+      filters << [filter, args, blk]
+    end
+    
+    def self.parser(parser, *args, &blk)
+      use(Temple::Parsers.const_get(parser), *args, &blk)
+    end
+    
+    def self.filter(filter, *args, &blk)
+      use(Temple::Filters.const_get(filter), *args, &blk)
+    end
+    
+    def self.generator(compiler, *args, &blk)
+      use(Temple::Core.const_get(compiler), *args, &blk)
+    end
+    
+    def initialize(options = {})
+      @chain = self.class.filters.map do |filter, args, blk|
+        filter.new(*args, &blk)
+      end
+    end
+    
+    def compile(thing)
+      @chain.inject(thing) { |m, e| e.compile(m) }
+    end
+  end
+end

data/lib/temple/filters/dynamic_inliner.rb

@@ -0,0 +1,62 @@
+module Temple
+  module Filters
+    # Inlines several static/dynamic into a single dynamic.
+    class DynamicInliner
+      def compile(exp)
+        exp.first == :multi ? on_multi(*exp[1..-1]) : exp
+      end
+      
+      def on_multi(*exps)
+        res = [:multi]
+        curr = nil
+        prev = nil
+        state = :looking
+        
+        # We add a noop because we need to do some cleanup at the end too.
+        (exps + [:noop]).each do |exp| 
+          head, arg = exp
+
+          if head == :dynamic || head == :static
+            case state
+            when :looking
+              # Found a single static/dynamic.  We don't want to turn this
+              # into a dynamic yet.  Instead we store it, and if we find
+              # another one, we add both then.
+              state = :single
+              prev = exp
+              curr = [:dynamic, '"' + send(head, arg)]
+            when :single
+              # Yes! We found another one.  Append the content to the current
+              # dynamic and add it to the result.
+              curr[1] << send(head, arg)
+              res << curr
+              state = :several
+            when :several
+              # Yet another dynamic/single.  Just add it now.
+              curr[1] << send(head, arg)
+            end
+          else
+            # We need to add the closing quote.
+            curr[1] << '"' unless state == :looking
+            # If we found a single exp last time, let's add it.
+            res << prev if state == :single
+            # Compile the current exp (unless it's the noop)
+            res << compile(exp) unless head == :noop
+            # Now we're looking for more!
+            state = :looking
+          end
+        end
+        
+        res
+      end
+    
+      def static(str)
+        str.inspect[1..-2]
+      end
+      
+      def dynamic(str)
+        '#{%s}' % str
+      end
+    end
+  end
+end

data/lib/temple/filters/escapable.rb

@@ -0,0 +1,25 @@
+module Temple
+  module Filters
+    class Escapable
+      def initialize(options = {})
+        @escaper = options[:escaper] || 'CGI.escapeHTML(%s.to_s)'
+      end
+      
+      def compile(exp)
+        return exp if !exp.is_a?(Enumerable) || exp.is_a?(String)
+        
+        if exp[0] == :static && is_escape?(exp[1])
+          [:static, eval(@escaper % exp[1][1].inspect)]
+        elsif is_escape?(exp)
+          @escaper % exp[1]
+        else
+          exp.map { |e| compile(e) }
+        end
+      end
+      
+      def is_escape?(exp)
+        exp.respond_to?(:[]) && exp[0] == :escape
+      end
+    end
+  end
+end

data/lib/temple/filters/mustache.rb

@@ -0,0 +1,70 @@
+module Temple
+  module Filters
+    # A Mustache filter which compiles Mustache-nodes into Core and Escapable.
+    # It's currently built for the Interpolation generator, but works with the
+    # others too.
+    class Mustache
+      def initialize
+        @tmpid = 0
+      end
+      
+      def tmpid
+        @tmpid += 1
+      end
+      
+      def compile(exp)
+        case exp.first
+        when :mustache
+          send("on_#{exp[1]}", *exp[2..-1])
+        when :multi
+          [:multi, *exp[1..-1].map { |e| compile(e) }]
+        else
+          exp
+        end
+      end
+      
+      def on_evar(name)
+        exp = on_var(name)
+        exp[1] = [:escape, exp[1]]
+        exp
+      end
+      
+      def on_var(name)
+        [:dynamic, "ctx[#{name.inspect}]"]
+      end
+      
+      def on_section(name, content)
+        res = [:multi]
+        code = compile(content)
+        ctxtmp = "ctx#{tmpid}"
+        
+        block = <<-EOF
+        if v = ctx[#{name.inspect}]
+          v = [v] if v.is_a?(Hash) # shortcut when passed a single hash
+          if v.respond_to?(:each)
+            #{ctxtmp} = ctx.dup
+            begin
+              r = v.map { |h| ctx.update(h); CODE }.join
+            rescue TypeError => e
+              raise TypeError,
+                "All elements in {{#{name.to_s}}} are not hashes!"
+            end
+            ctx.replace(#{ctxtmp})
+            r
+          else
+            CODE
+          end
+        end
+        EOF
+        
+        block.split("CODE").each do |str|
+          res << [:block, str]
+          res << code
+        end
+        
+        res.pop
+        res
+      end
+    end
+  end
+end

data/lib/temple/filters/static_merger.rb

@@ -0,0 +1,41 @@
+module Temple
+  module Filters
+    # Merges several statics into a single static.  Example:
+    #
+    #   [:multi,
+    #     [:static, "Hello "],
+    #     [:static, "World!"]]
+    #
+    # Compiles to:
+    # 
+    #   [:multi,
+    #     [:static, "Hello World!"]]
+    class StaticMerger
+      def compile(exp)
+        exp.first == :multi ? on_multi(*exp[1..-1]) : exp
+      end
+
+      def on_multi(*exps)
+        res = [:multi]
+        curr = nil
+        state = :looking
+        
+        exps.each do |exp|
+          if exp.first == :static
+            if state == :looking
+              res << [:static, (curr = exp[1].dup)]
+              state = :static
+            else
+              curr << exp[1]
+            end
+          else
+            res << compile(exp)
+            state = :looking
+          end
+        end
+        
+        res
+      end
+    end
+  end
+end

data/lib/temple/generator.rb

@@ -0,0 +1,32 @@
+module Temple
+  class Generator
+    DEFAULT_OPTIONS = {
+      :buffer => "_buf"
+    }
+    
+    def initialize(options = {})
+      @options = DEFAULT_OPTIONS.merge(options)
+    end
+    
+    def compile(exp)
+      preamble + compile_part(exp) + postamble
+    end
+    
+    def compile_part(exp)
+      send("on_#{exp.first}", *exp[1..-1])
+    end
+    
+    def buffer(str = '')
+      @options[:buffer] + str
+    end
+    
+    # Sensible defaults
+    
+    def preamble;  '' end
+    def postamble; '' end
+    
+    def on_multi(*exp)
+      exp.map { |e| compile_part(e) }.join
+    end
+  end
+end

data/lib/temple/parsers/erb.rb

@@ -0,0 +1,28 @@
+module Temple
+  module Parsers
+    # A dead simple ERB parser which compiles directly to Core.
+    # It's crappy, but it works for now.
+    class ERB
+      def compile(src)
+        result = [:multi]
+        while src =~ /<%(.*?)%>/
+          result << [:static, $`]
+          text = $1[1..-1].strip
+          case $1[0]
+          when ?#
+            next
+          when ?=
+            text = [:escape, text] if $1[1] == ?=
+            head = :dynamic
+          else
+            head = :block
+          end
+          result << [head, text]
+          src = $'
+        end
+        result << [:static, src]
+        result
+      end
+    end                      
+  end
+end

data/lib/temple/parsers/mustache.rb

@@ -0,0 +1,68 @@
+module Temple
+  module Parsers
+    # A Mustache parser which compiles into Mustache-nodes:
+    # 
+    #   {{ name }}      # => [:mustache, :evar, :name]
+    #   {{{ name }}}    # => [:mustache, :var, :name]
+    #   {{#name}} code {{/name}} # => [:mustache, :section, :name, code]
+    #   {{> simple }}   # => [:mustache, :partial, :simple]
+    class Mustache
+      attr_accessor :otag, :ctag
+      
+      def compile(src)
+        res = [:multi]
+        while src =~ /#{otag}\#([^\}]*)#{ctag}\s*(.+?)#{otag}\/\1#{ctag}\s*/m
+          # $` = The string to the left of the last successful match
+          res << compile_tags($`)
+          name = $1.strip.to_sym
+          code = compile($2)
+          res << [:mustache, :section, name, code]
+          # $' = The string to the right of the last successful match
+          src = $'
+        end
+        res << compile_tags(src)
+      end
+      
+      def compile_tags(src)
+        res = [:multi]
+        while src =~ /#{otag}(#|=|!|<|>|\{)?(.+?)\1?#{ctag}+/
+          res << [:static, $`]
+          case $1
+          when '#'
+            raise "Unclosed section"
+          when '!'
+            # ignore comments
+          when '='
+            self.otag, self.ctag = $2.strip.split(' ', 2)
+          when '>', '<'
+            res << [:mustache, :partial, $2.strip.to_sym]
+          when '{'
+            res << [:mustache, :var, $2.strip.to_sym]
+          else
+            res << [:mustache, :evar, $2.strip.to_sym]
+          end
+          src = $'
+        end
+        res << [:static, src]
+      end
+      
+      # {{ - opening tag delimiter
+      def otag
+        @otag ||= Regexp.escape('{{')
+      end
+
+      def otag=(tag)
+        @otag = Regexp.escape(tag)
+      end
+
+      # }} - closing tag delimiter
+      def ctag
+        @ctag ||= Regexp.escape('}}')
+      end
+
+      def ctag=(tag)
+        @ctag = Regexp.escape(tag)
+      end
+    end
+  end
+end

data/spec/dynamic_inliner_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe_filter :DynamicInliner do
+  it "should merge several statics into dynamic" do
+    @filter.compile([:multi,
+      [:static, "Hello "],
+      [:static, "World\n "],
+      [:static, "Have a nice day"]
+    ]).should == [:multi,
+      [:dynamic, '"Hello World\n Have a nice day"']
+    ]
+  end
+  
+  it "should merge several dynamics into a single dynamic" do
+    @filter.compile([:multi,
+      [:dynamic, "@hello"],
+      [:dynamic, "@world"],
+      [:dynamic, "@yeah"]
+    ]).should == [:multi,
+      [:dynamic, '"#{@hello}#{@world}#{@yeah}"']
+    ]
+  end
+  
+  it "should merge static+dynamic into dynamic" do
+    @filter.compile([:multi,
+      [:static, "Hello"],
+      [:dynamic, "@world"],
+      [:dynamic, "@yeah"],
+      [:static, "Nice"]
+    ]).should == [:multi,
+      [:dynamic, '"Hello#{@world}#{@yeah}Nice"']
+    ]
+  end
+  
+  it "should merge static+dynamic around blocks" do
+    @filter.compile([:multi,
+      [:static, "Hello "],
+      [:dynamic, "@world"],
+      [:block, "Oh yeah"],
+      [:dynamic, "@yeah"],
+      [:static, "Once more"]
+    ]).should == [:multi,
+      [:dynamic, '"Hello #{@world}"'],
+      [:block, "Oh yeah"],
+      [:dynamic, '"#{@yeah}Once more"']
+    ]
+  end
+  
+  it "should keep blocks intact" do
+    exp = [:multi, [:block, 'foo']]
+    @filter.compile(exp).should == exp
+  end
+  
+  it "should keep single static intact" do
+    exp = [:multi, [:static, 'foo']]
+    @filter.compile(exp).should == exp
+  end
+
+  it "should keep single dynamic intact" do
+    exp = [:multi, [:dynamic, 'foo']]
+    @filter.compile(exp).should == exp
+  end
+  
+  it "should inline inside multi" do
+    @filter.compile([:multi,
+      [:static, "Hello "],
+      [:dynamic, "@world"],
+      [:multi,
+        [:static, "Hello "],
+        [:dynamic, "@world"]],
+      [:static, "Hello "],
+      [:dynamic, "@world"]
+    ]).should == [:multi,
+      [:dynamic, '"Hello #{@world}"'],
+      [:multi, [:dynamic, '"Hello #{@world}"']],
+      [:dynamic, '"Hello #{@world}"']
+    ]
+  end
+end

data/spec/escapable_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'cgi'
+
+describe_filter :Escapable do
+  it "should escape everywhere" do
+    @filter.compile([:multi,
+      [:dynamic, [:escape, "@hello"]],
+      [:block, [:escape, "@world"]]
+    ]).should == [:multi,
+      [:dynamic, "CGI.escapeHTML(@hello.to_s)"],
+      [:block, "CGI.escapeHTML(@world.to_s)"]
+    ]
+  end
+  
+  it "should automatically escape static content" do
+    @filter.compile([:multi,
+      [:static, [:escape, "<hello>"]],
+      [:block, [:escape, "@world"]]
+    ]).should == [:multi,
+      [:static, "&lt;hello&gt;"],
+      [:block, "CGI.escapeHTML(@world.to_s)"]
+    ]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'temple'
+
+def describe_filter(name, &blk)
+  klass = Temple::Filters.const_get(name)
+  describe(klass) do
+    before do
+      @filter = klass.new
+    end
+    
+    instance_eval(&blk)
+  end
+end

data/spec/static_merger_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe_filter :StaticMerger do
+  it "should merge several statics" do
+    @filter.compile([:multi,
+      [:static, "Hello "],
+      [:static, "World, "],
+      [:static, "Good night"]
+    ]).should == [:multi,
+      [:static, "Hello World, Good night"]
+    ]
+  end
+  
+  it "should merge several statics around block" do
+    @filter.compile([:multi,
+      [:static, "Hello "],
+      [:static, "World!"],
+      [:block, "123"],
+      [:static, "Good night, "],
+      [:static, "everybody"]
+    ]).should == [:multi,
+      [:static, "Hello World!"],
+      [:block, "123"],
+      [:static, "Good night, everybody"]
+    ]
+  end
+end

data/spec/temple_spec.rb

@@ -0,0 +1,5 @@
+describe Temple do
+  it "has a VERSION" do
+    Temple::VERSION.join('.').should =~ /^\d+\.\d+\.\d+$/
+  end
+end

data/temple.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{temple}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Magnus Holm"]
+  s.date = %q{2009-12-15}
+  s.email = %q{judofyr@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "README",
+     "Rakefile",
+     "VERSION",
+     "lib/temple.rb",
+     "lib/temple/core.rb",
+     "lib/temple/engine.rb",
+     "lib/temple/filters/dynamic_inliner.rb",
+     "lib/temple/filters/escapable.rb",
+     "lib/temple/filters/mustache.rb",
+     "lib/temple/filters/static_merger.rb",
+     "lib/temple/generator.rb",
+     "lib/temple/parsers/erb.rb",
+     "lib/temple/parsers/mustache.rb",
+     "spec/dynamic_inliner_spec.rb",
+     "spec/escapable_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/static_merger_spec.rb",
+     "spec/temple_spec.rb",
+     "temple.gemspec"
+  ]
+  s.homepage = %q{http://github.com/judofyr/temple}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Template compilation framework in Ruby}
+  s.test_files = [
+    "spec/spec_helper.rb",
+     "spec/static_merger_spec.rb",
+     "spec/escapable_spec.rb",
+     "spec/dynamic_inliner_spec.rb",
+     "spec/temple_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: temple
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Magnus Holm
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-15 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: judofyr@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- VERSION
+- lib/temple.rb
+- lib/temple/core.rb
+- lib/temple/engine.rb
+- lib/temple/filters/dynamic_inliner.rb
+- lib/temple/filters/escapable.rb
+- lib/temple/filters/mustache.rb
+- lib/temple/filters/static_merger.rb
+- lib/temple/generator.rb
+- lib/temple/parsers/erb.rb
+- lib/temple/parsers/mustache.rb
+- spec/dynamic_inliner_spec.rb
+- spec/escapable_spec.rb
+- spec/spec_helper.rb
+- spec/static_merger_spec.rb
+- spec/temple_spec.rb
+- temple.gemspec
+has_rdoc: true
+homepage: http://github.com/judofyr/temple
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Template compilation framework in Ruby
+test_files: 
+- spec/spec_helper.rb
+- spec/static_merger_spec.rb
+- spec/escapable_spec.rb
+- spec/dynamic_inliner_spec.rb
+- spec/temple_spec.rb