temple 0.1.3 → 0.1.4

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+.yardoc
+doc

data/README.md

@@ -18,7 +18,6 @@ Meta
 * Home: <http://github.com/judofyr/temple>
 * Bugs: <http://github.com/judofyr/temple/issues>
 * List: <http://groups.google.com/group/guardians-of-the-temple>
-* Core abstraction: {Temple::Core}
 
 
 Overview
@@ -28,7 +27,7 @@ Temple is built on a theory that every template consists of three elements:
 
 * Static text
 * Dynamic text (pieces of Ruby which are evaluated and sent to the client)
-* Blocks (pieces of Ruby which are evaluated and *not* sent to the client, but 
+* Blocks (pieces of Ruby which are evaluated and *not* sent to the client, but
   might change the control flow).
 
 The goal of a template engine is to take the template and eventually compile
@@ -65,13 +64,13 @@ straightforward data structure, which can easily be written by hand and
 manipulated by computers.
 
 Some examples:
-    
+
     [:static, "Hello World!"]
-    
+
     [:multi,
       [:static, "Hello "],
       [:dynamic, "@world"]]
-    
+
     [:html, :tag, "em", "Hey hey"]
 
 *NOTE:* SexpProcessor, a library written by Ryan Davis, includes a `Sexp`
@@ -90,7 +89,7 @@ So what's an abstraction? An abstraction is when you introduce a new types:
 
     # Instead of:
     [:static, "<strong>Use the force</strong>"]
-    
+
     # You use:
     [:html, :tag, "strong", [:static, "Use the force"]]
 
@@ -128,7 +127,7 @@ class. Temple then assumes the initializer takes an optional option hash:
       def initialize(options = {})
         @options = options
       end
-      
+
       def compile(exp)
         # do stuff
       end
@@ -165,8 +164,8 @@ abstraction and compile it down to the core abstraction.
 A generator is a compiler which takes an Sexp and returns a string which is
 valid Ruby code.
 
-Most of the time you would just use {Temple::Core::ArrayBuffer} or any of the
-other generators in {Temple::Core}, but nothing stops you from writing your
+Most of the time you would just use {Temple::Generators::ArrayBuffer} or any of the
+other generators in {Temple::Generators}, but nothing stops you from writing your
 own.
 
 In fact, one of the great things about Temple is that if you write a new
@@ -182,19 +181,19 @@ When you have a chain of a parsers, some filters and a generator you can finally
     class MyEngine < Temple::Engine
       # First run MyParser, passing the :strict option
       use MyParser, :strict
-      
+
       # Then a custom filter
       use MyFilter
-      
+
       # Then some general optimizations filters
       filter :MultiFlattener
       filter :StaticMerger
       filter :DynamicInliner
-      
+
       # Finally the generator
       generator :ArrayBuffer, :buffer
     end
-    
+
     engine = MyEngine.new(:strict => "For MyParser")
     engine.compile(something)
 
@@ -210,7 +209,7 @@ template engines. This gives you a wide range of features and your engine can
 be used right away in many projects.
 
     require 'tilt'
-    
+
     class MyTemplate < Tilt::Template
       def prepare
         @src = MyEngine.new(options).compile(data)
@@ -220,20 +219,20 @@ be used right away in many projects.
         @src
       end
     end
-    
+
     # Register your file extension:
     Tilt.register 'ext', MyTemplate
-    
+
     Tilt.new('example.ext').render     # => Render a file
     MyTemplate.new { "String" }.render # => Render a string
-    
+
 
 Installation
 ------------
 
     $ gem install temple
 
-    
+
 Acknowledgements
 ----------------
 

data/Rakefile

@@ -1,20 +1,25 @@
 require 'rake/testtask'
 
-def command?(command)
-  system("type #{command} > /dev/null")
+task :default => :test
+task :test do
+  sh "bacon -Ilib -Itest --automatic --quiet"
 end
 
-task :default => :test
+#Rake::TestTask.new(:test) do |t|
+#  t.libs << 'lib' << 'test'
+#  t.pattern = 'test/**/test_*.rb'
+#  t.verbose = false
+#end
 
-if RUBY_VERSION[0,3] == "1.8" and command?("turn")
-  task :test do
-    suffix = "-n #{ENV['TEST']}" if ENV['TEST']
-    sh "turn test/test_*.rb test/**/test_*.rb #{suffix}"
-  end
-else
-  Rake::TestTask.new do |t|
-    t.libs << 'lib'
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.libs << 'lib' << 'test'
     t.pattern = 'test/**/test_*.rb'
     t.verbose = false
   end
-end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: gem install rcov"
+  end
+end

data/lib/temple.rb

@@ -1,26 +1,31 @@
+require 'temple/version'
+
 module Temple
-  VERSION = "0.1.3"
-  
-  autoload :Core,       'temple/core'
-  autoload :Engine,     'temple/engine'
-  autoload :Generator,  'temple/generator'
-  autoload :Utils,      'temple/utils'
-  
-  module Engines
-    autoload :ERB,      'temple/engines/erb'
-  end
-  
-  module Parsers
-    autoload :ERB,      'temple/parsers/erb'
+  autoload :Generator,        'temple/generators'
+  autoload :Generators,       'temple/generators'
+  autoload :Engine,           'temple/engine'
+  autoload :Utils,            'temple/utils'
+  autoload :Mixins,           'temple/mixins'
+  autoload :Filter,           'temple/filter'
+  autoload :Template,         'temple/template'
+
+  module ERB
+    autoload :Engine,         'temple/erb/engine'
+    autoload :Parser,         'temple/erb/parser'
+    autoload :Template,       'temple/erb/template'
+    autoload :Trimming,       'temple/erb/trimming'
   end
-  
+
   module Filters
     autoload :MultiFlattener, 'temple/filters/multi_flattener'
     autoload :StaticMerger,   'temple/filters/static_merger'
     autoload :DynamicInliner, 'temple/filters/dynamic_inliner'
+    autoload :EscapeHTML,     'temple/filters/escape_html'
+    autoload :Debugger,       'temple/filters/debugger'
   end
 
   module HTML
     autoload :Fast,           'temple/html/fast'
+    autoload :Pretty,         'temple/html/pretty'
   end
 end

data/lib/temple/engine.rb

@@ -5,46 +5,41 @@ module Temple
   #   class MyEngine < Temple::Engine
   #     # First run MyParser, passing the :strict option
   #     use MyParser, :strict
-  # 
+  #
   #     # Then a custom filter
   #     use MyFilter
-  #      
+  #
   #     # Then some general optimizations filters
   #     filter :MultiFlattener
   #     filter :StaticMerger
   #     filter :DynamicInliner
-  #       
+  #
   #     # Finally the generator
   #     generator :ArrayBuffer, :buffer
   #   end
-  #   
+  #
   #   engine = MyEngine.new(:strict => "For MyParser")
   #   engine.compile(something)
-  # 
+  #
   class Engine
     def self.filters
       @filters ||= []
     end
-    
+
     def self.use(filter, *args, &blk)
       filters << [filter, args, blk]
     end
-    
-    # Shortcut for <tt>use Temple::Parsers::parser</tt>
-    def self.parser(parser, *args, &blk)
-      use(Temple::Parsers.const_get(parser), *args, &blk)
-    end
-    
+
     # Shortcut for <tt>use Temple::Filters::parser</tt>
     def self.filter(filter, *args, &blk)
       use(Temple::Filters.const_get(filter), *args, &blk)
     end
-    
-    # Shortcut for <tt>use Temple::Generator::parser</tt>
+
+    # Shortcut for <tt>use Temple::Generators::parser</tt>
     def self.generator(compiler, *args, &blk)
-      use(Temple::Core.const_get(compiler), *args, &blk)
+      use(Temple::Generators.const_get(compiler), *args, &blk)
     end
-    
+
     def initialize(options = {})
       @chain = self.class.filters.map do |filter, args, blk|
         opt = args.last.is_a?(Hash) ? args.last.dup : {}
@@ -52,11 +47,11 @@ module Temple
           memo[ele] = options[ele] if options.has_key?(ele)
           memo
         end
-        
+
         filter.new(opt, &blk)
       end
     end
-    
+
     def compile(thing)
       @chain.inject(thing) { |m, e| e.compile(m) }
     end

data/lib/temple/erb/engine.rb

@@ -0,0 +1,13 @@
+module Temple
+  module ERB
+    class Engine < Temple::Engine
+      use Temple::ERB::Parser, :auto_escape
+      use Temple::ERB::Trimming, :trim_mode
+      filter :EscapeHTML, :use_html_safe
+      filter :MultiFlattener
+      filter :StaticMerger
+      filter :DynamicInliner
+      generator :ArrayBuffer
+    end
+  end
+end

data/lib/temple/erb/parser.rb

@@ -0,0 +1,38 @@
+module Temple
+  module ERB
+    class Parser
+      include Mixins::Options
+
+      ERB_PATTERN = /(<%%|%%>)|<%(==?|\#)?(.*?)?-?%>/m
+
+      ESCAPED = {
+        '<%%' => '<%',
+        '%%>' => '%>',
+      }.freeze
+
+      def compile(input)
+        result = [:multi]
+        pos = 0
+        input.scan(ERB_PATTERN) do |escaped, indicator, code|
+          m = Regexp.last_match
+          text = input[pos...m.begin(0)]
+          pos  = m.end(0)
+          result << [:static, text] if !text.empty?
+          if escaped
+            result << [:static, ESCAPED[escaped]]
+          else
+            case indicator
+            when '#'
+              code.count("\n").times { result << [:newline] }
+            when /=/
+              result << (indicator.length > 1 || !options[:auto_escape] ? [:dynamic, code] : [:escape, :dynamic, code])
+            else
+              result << [:block, code]
+            end
+          end
+        end
+        result << [:static, input[pos..-1]]
+      end
+    end
+  end
+end

data/lib/temple/erb/template.rb

@@ -0,0 +1,7 @@
+module Temple
+  module ERB
+    class Template < Temple::Template
+      engine Temple::ERB::Engine
+    end
+  end
+end

data/lib/temple/erb/trimming.rb

@@ -0,0 +1,33 @@
+module Temple
+  module ERB
+    class Trimming < Filter
+      def on_multi(*exps)
+        case options[:trim_mode]
+        when '>'
+          exps.each_cons(2) do |a, b|
+            if code?(a) && static?(b)
+              b[1].gsub!(/^\n/, '')
+            end
+          end
+        when '<>'
+          exps.each_with_index do |exp, i|
+            if code?(exp) &&
+                (!exps[i-1] || static?(exps[i-1]) && exps[i-1][1] =~ /\n$/) &&
+                (exps[i+1] && static?(exps[i+1]) && exps[i+1][1] =~ /^\n/)
+              exps[i+1][1].gsub!(/^\n/, '') if exps[i+1]
+            end
+          end
+        end
+        [:multi, *exps]
+      end
+
+      def code?(exp)
+        exp[0] == :dynamic || exp[0] == :block
+      end
+
+      def static?(exp)
+        exp[0] == :static
+      end
+    end
+  end
+end

data/lib/temple/filter.rb

@@ -0,0 +1,7 @@
+module Temple
+  class Filter
+    include Utils
+    include Mixins::Dispatcher
+    include Mixins::Options
+  end
+end

data/lib/temple/filters/debugger.rb

@@ -0,0 +1,15 @@
+module Temple
+  module Filters
+    # Filter which prints Temple expression
+    class Debugger < Filter
+      def compile(exp)
+        if options[:debug]
+          puts options[:prefix] if options[:prefix]
+          puts exp.inspect
+          puts
+        end
+        exp
+      end
+    end
+  end
+end

data/lib/temple/filters/dynamic_inliner.rb

@@ -1,25 +1,17 @@
 module Temple
   module Filters
     # Inlines several static/dynamic into a single dynamic.
-    class DynamicInliner
-      def initialize(options = {})
-        @options = {}
-      end
-      
-      def compile(exp)
-        exp.first == :multi ? on_multi(*exp[1..-1]) : exp
-      end
-      
+    class DynamicInliner < Filter
       def on_multi(*exps)
         res = [:multi]
         curr = nil
         prev = []
         state = :looking
-        
+
         # We add a noop because we need to do some cleanup at the end too.
-        (exps + [:noop]).each do |exp| 
+        (exps + [:noop]).each do |exp|
           head, arg = exp
-          
+
           case head
           when :newline
             case state
@@ -30,7 +22,7 @@ module Temple
               # We've found something, so let's make sure the generated
               # dynamic contains a newline by escaping a newline and
               # starting a new string:
-              # 
+              #
               # "Hello "\
               # "#{@world}"
               prev << exp
@@ -61,22 +53,22 @@ module Temple
             # If we found a single exp last time, let's add it.
             res.concat(prev) if state == :single
             # Compile the current exp (unless it's the noop)
-            res << compile(exp) unless head == :noop
+            res << compile!(exp) unless head == :noop
             # Now we're looking for more!
             state = :looking
           end
         end
-        
+
         res
       end
-    
+
       def static(str)
-        Generator.to_ruby(str)[1..-2]
+        str.inspect[1..-2]
       end
-      
+
       def dynamic(str)
         '#{%s}' % str
       end
     end
   end
-end
+end