temple 0.1.3 → 0.1.4

data/lib/temple/html/pretty.rb

@@ -0,0 +1,75 @@
+module Temple
+  module HTML
+    class Pretty < Fast
+      set_default_options :indent => '  ',
+                          :pretty => true
+
+      INDENT_TAGS = %w(base div doctype form head html img input li link meta ol
+                       script style table tbody td th thead title tr ul).freeze
+
+      def initialize(opts = {})
+        super
+        @last = nil
+        @stack = []
+      end
+
+      def on_static(content)
+        if options[:pretty]
+          @last = nil
+          [:static, content.gsub("\n", indent)]
+        else
+          [:static, content]
+        end
+      end
+
+      def on_dynamic(content)
+        if options[:pretty]
+          @last = nil
+          [:dynamic, %{(#{content}).to_s.gsub("\n", #{indent.inspect})}]
+        else
+          [:dynamic, content]
+        end
+      end
+
+      def on_html_doctype(type)
+        @last = 'doctype'
+        super
+      end
+
+      def on_html_comment(content)
+        return super if !options[:pretty]
+        [:multi, [:static, indent], super]
+      end
+
+      def on_html_tag(name, attrs, closed, content)
+        return super if !options[:pretty]
+
+        closed ||= options[:autoclose].include?(name)
+        raise "Closed tag #{name} has content" if closed && !empty_exp?(content)
+
+        result = [:multi, [:static, "#{tag_indent(name)}<#{name}"], compile!(attrs)]
+        result << [:static, ' /'] if closed && xhtml?
+        result << [:static, '>']
+
+        @stack << name
+        @last = name
+        result << compile!(content)
+        @stack.pop
+
+        result << [:static, "#{tag_indent(name)}</#{name}>"] if !closed
+        @last = name
+        result
+      end
+
+      # Return indentation if not in pre tag
+      def indent
+        @stack.include?('pre') ? '' : ("\n" + ((options[:indent] || '') * @stack.size))
+      end
+
+      # Return indentation before tag
+      def tag_indent(name)
+        @last && (INDENT_TAGS.include?(@last) || INDENT_TAGS.include?(name)) ? indent : ''
+      end
+    end
+  end
+end

data/lib/temple/mixins.rb

@@ -0,0 +1,66 @@
+module Temple
+  module Mixins
+    module Dispatcher
+      def self.included(base)
+        base.class_eval { extend ClassMethods }
+      end
+
+      def compile(exp)
+        compile!(exp)
+      end
+
+      def compile!(exp)
+        type, *args = exp
+        if respond_to?("on_#{type}")
+          send("on_#{type}", *args)
+        else
+          exp
+        end
+      end
+
+      def on_multi(*exps)
+        [:multi, *exps.map {|exp| compile!(exp) }]
+      end
+
+      def on_capture(name, exp)
+        [:capture, name, compile!(exp)]
+      end
+
+      module ClassMethods
+        def temple_dispatch(*bases)
+          bases.each do |base|
+            class_eval %{def on_#{base}(type, *args)
+              if respond_to?("on_" #{base.to_s.inspect} "_\#{type}")
+                send("on_" #{base.to_s.inspect} "_\#{type}", *args)
+              else
+                [:#{base}, type, *args]
+              end
+            end}
+          end
+        end
+      end
+    end
+
+    module Options
+      def self.included(base)
+        base.class_eval { extend ClassMethods }
+      end
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = self.class.default_options.merge(options)
+      end
+
+      module ClassMethods
+        def set_default_options(opts)
+          default_options.merge!(opts)
+        end
+
+        def default_options(opts = nil)
+          @default_options ||= superclass.respond_to?(:default_options) ? superclass.default_options.dup : {}
+        end
+      end
+    end
+  end
+end

data/lib/temple/template.rb

@@ -0,0 +1,35 @@
+require 'tilt'
+
+module Temple
+  # Tilt template implementation for Temple
+  class Template < Tilt::Template
+    class << self
+      def engine(engine = nil)
+        if engine
+          @engine = engine
+        elsif @engine
+          @engine
+        else
+          raise 'No engine configured'
+        end
+      end
+    end
+
+    # Prepare Temple template
+    #
+    # Called immediately after template data is loaded.
+    #
+    # @return [void]
+    def prepare
+      @src = self.class.engine.new(options.merge(:file => eval_file)).compile(data)
+    end
+
+    # A string containing the (Ruby) source code for the template.
+    #
+    # @param [Hash]   locals Local variables
+    # @return [String] Compiled template ruby code
+    def precompiled_template(locals = {})
+      @src
+      end
+  end
+end

data/lib/temple/utils.rb

@@ -1,26 +1,62 @@
-require 'irb/ruby-lex'
-require 'stringio'
-
 module Temple
   module Utils
     extend self
-    
-    LITERAL_TOKENS = [RubyToken::TkSTRING, RubyToken::TkDSTRING]
-    
-    def literal_string?(str)
-      lexer = RubyLex.new
-      lexer.set_input(StringIO.new(str.strip))
-      
-      # The first token has to be a string.
-      LITERAL_TOKENS.include?(lexer.token.class) and
-      # That has to be the only token.
-      lexer.token.nil?
+
+    # Returns an escaped copy of `html`.
+    # Strings which are declared as html_safe are not escaped.
+    #
+    # @param html [String] The string to escape
+    # @return [String] The escaped string
+    # @api public
+    def escape_html_safe(html)
+      html.html_safe? ? html : escape_html(html)
+    end
+
+    if defined?(EscapeUtils)
+      # Returns an escaped copy of `html`.
+      #
+      # @param html [String] The string to escape
+      # @return [String] The escaped string
+      # @api public
+      def escape_html(html)
+        EscapeUtils.escape_html(html.to_s)
+      end
+    elsif RUBY_VERSION > '1.9'
+      # Used by escape_html
+      # @api private
+      ESCAPE_HTML = {
+        '&' => '&',
+        '"' => '"',
+        '<' => '&lt;',
+        '>' => '&gt;',
+        '/' => '&#47;',
+      }.freeze
+
+      # Returns an escaped copy of `html`.
+      #
+      # @param html [String] The string to escape
+      # @return [String] The escaped string
+      # @api public
+      def escape_html(html)
+        html.to_s.gsub(/[&\"<>\/]/, ESCAPE_HTML)
+      end
+    else
+      # Returns an escaped copy of `html`.
+      #
+      # @param html [String] The string to escape
+      # @return [String] The escaped string
+      # @api public
+      def escape_html(html)
+        html.to_s.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/>/n, '&gt;').gsub(/</n, '&lt;').gsub(/\//, '&#47;')
+      end
     end
 
     def empty_exp?(exp)
       case exp[0]
       when :multi
-        exp[1..-1].all? { |e| e[0] == :newline }
+        exp[1..-1].all? {|e| empty_exp?(e) }
+      when :newline
+        true
       else
         false
       end

data/lib/temple/version.rb

@@ -0,0 +1,3 @@
+module Temple
+  VERSION = '0.1.4'
+end

data/temple.gemspec

@@ -1,26 +1,21 @@
 # -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + "/lib/temple/version"
 
 Gem::Specification.new do |s|
   s.name = %q{temple}
-  s.version = "0.1.3"
+  s.version = Temple::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Magnus Holm"]
-  s.date = %q{2010-01-23}
+  s.date = %q{2010-11-03}
   s.email = %q{judofyr@gmail.com}
-  s.files = [".yardopts", "LICENSE", "README.md", "Rakefile", "lib/temple.rb", "lib/temple/core.rb", "lib/temple/engine.rb", "lib/temple/engines/erb.rb", "lib/temple/filters/dynamic_inliner.rb", "lib/temple/filters/multi_flattener.rb", "lib/temple/filters/static_merger.rb", "lib/temple/generator.rb", "lib/temple/html/fast.rb", "lib/temple/parsers/erb.rb", "lib/temple/utils.rb", "temple.gemspec", "test/engines/hello.erb", "test/engines/test_erb.rb", "test/engines/test_erb_m17n.rb", "test/filters/test_dynamic_inliner.rb", "test/filters/test_static_merger.rb", "test/helper.rb", "test/test_generator.rb", "test/test_temple.rb"]
   s.homepage = %q{http://dojo.rubyforge.org/}
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Template compilation framework in RUby}
+  s.summary = %q{Template compilation framework in Ruby}
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
+  s.add_development_dependency('bacon')
 end

data/test/filters/test_dynamic_inliner.rb

@@ -1,76 +1,66 @@
-require File.dirname(__FILE__) + '/../helper'
+require 'helper'
 
-class TestTempleFiltersDynamicInliner < TestFilter(:DynamicInliner)
-  def test_several_statics_into_dynamic
-    exp = @filter.compile([:multi,
+describe Temple::Filters::DynamicInliner do
+  before do
+    @filter = Temple::Filters::DynamicInliner.new
+  end
+
+  it 'should compile several statics into dynamic' do
+    @filter.compile([:multi,
       [:static, "Hello "],
       [:static, "World\n "],
       [:static, "Have a nice day"]
-    ])
-    
-    assert_equal([:multi,
-      [:dynamic, '"Hello World\n Have a nice day"']
-    ], exp)
+    ]).should.equal [:multi, [:dynamic, '"Hello World\n Have a nice day"']]
   end
 
-  def test_several_dynamics_into_dynamic
-    exp = @filter.compile([:multi,
+  it 'should compile several dynamics into dynamic' do
+    @filter.compile([:multi,
       [:dynamic, "@hello"],
       [:dynamic, "@world"],
       [:dynamic, "@yeah"]
-    ])
-    
-    assert_equal([:multi,
-      [:dynamic, '"#{@hello}#{@world}#{@yeah}"']
-    ], exp)
+    ]).should.equal [:multi, [:dynamic, '"#{@hello}#{@world}#{@yeah}"']]
   end
-  
-  def test_static_and_dynamic_into_dynamic
-    exp = @filter.compile([:multi,
+
+  it 'should compile static and dynamic into dynamic' do
+    @filter.compile([:multi,
       [:static, "Hello"],
       [:dynamic, "@world"],
       [:dynamic, "@yeah"],
       [:static, "Nice"]
-    ])
-    
-    assert_equal([:multi,
-      [:dynamic, '"Hello#{@world}#{@yeah}Nice"']
-    ], exp)
+    ]).should.equal [:multi, [:dynamic, '"Hello#{@world}#{@yeah}Nice"']]
   end
-  
-  def test_static_and_dynamic_around_blocks
+
+  it 'should merge statics and dynamics around a block' do
     exp = @filter.compile([:multi,
       [:static, "Hello "],
       [:dynamic, "@world"],
       [:block, "Oh yeah"],
       [:dynamic, "@yeah"],
       [:static, "Once more"]
-    ])
-    
-    assert_equal([:multi,
+    ]).should.equal [:multi,
       [:dynamic, '"Hello #{@world}"'],
       [:block, "Oh yeah"],
       [:dynamic, '"#{@yeah}Once more"']
-    ], exp)
+    ]
   end
-  
-  def test_keep_blocks_intact
+
+  it 'should keep blocks intact' do
     exp = [:multi, [:block, 'foo']]
-    assert_equal(exp, @filter.compile(exp))
+    @filter.compile(exp).should.equal exp
   end
-  
-  def test_keep_single_static_intact
+
+  it 'should keep single statics intact' do
     exp = [:multi, [:static, 'foo']]
-    assert_equal(exp, @filter.compile(exp))
+    @filter.compile(exp).should.equal exp
   end
 
-  def test_keep_single_dynamic_intact
+  it 'should keep single dynamic intact' do
     exp = [:multi, [:dynamic, 'foo']]
-    assert_equal(exp, @filter.compile(exp))
+    @filter.compile(exp).should.equal exp
   end
-  
-  def test_inline_inside_multi
-    exp = @filter.compile([:multi,
+
+  it 'should inline inside multi' do
+    @filter.compile([:multi,
       [:static, "Hello "],
       [:dynamic, "@world"],
       [:multi,
@@ -78,39 +68,33 @@ class TestTempleFiltersDynamicInliner < TestFilter(:DynamicInliner)
         [:dynamic, "@world"]],
       [:static, "Hello "],
       [:dynamic, "@world"]
-    ])
-    
-    assert_equal([:multi,
+    ]).should.equal [:multi,
       [:dynamic, '"Hello #{@world}"'],
       [:multi, [:dynamic, '"Hello #{@world}"']],
       [:dynamic, '"Hello #{@world}"']
-    ], exp)
+    ]
   end
-  
-  def test_merge_across_newlines
+
+  it 'should merge across newlines' do
     exp = @filter.compile([:multi,
       [:static, "Hello \n"],
       [:newline],
       [:dynamic, "@world"],
       [:newline]
-    ])
-    
-    assert_equal([:multi,
+    ]).should.equal [:multi,
       [:dynamic, ['"Hello \n"', '"#{@world}"', '""'].join("\\\n")]
-    ], exp)
+    ]
   end
-  
-  def test_static_followed_by_newline
-    exp = @filter.compile([:multi,
+
+  it 'should compile static followed by newline' do
+    @filter.compile([:multi,
       [:static, "Hello \n"],
       [:newline],
       [:block, "world"]
-    ])
-    
-    assert_equal([:multi,
+    ]).should.equal [:multi,
       [:static, "Hello \n"],
       [:newline],
       [:block, "world"]
-    ], exp)
+    ]
   end
 end