RubyGems - temple - Versions diffs - 0.2.0 → 0.3.0 - Mend

temple 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

data/.yardopts +2 -1
data/CHANGES +63 -0
data/EXPRESSIONS.md +250 -0
data/README.md +24 -12
data/lib/temple.rb +34 -18
data/lib/temple/engine.rb +11 -7
data/lib/temple/erb/engine.rb +5 -3
data/lib/temple/erb/parser.rb +5 -2
data/lib/temple/erb/template.rb +11 -0
data/lib/temple/erb/trimming.rb +9 -1
data/lib/temple/filter.rb +2 -0
data/lib/temple/filters/control_flow.rb +43 -0
data/lib/temple/filters/dynamic_inliner.rb +29 -32
data/lib/temple/filters/eraser.rb +22 -0
data/lib/temple/filters/escapable.rb +39 -0
data/lib/temple/filters/multi_flattener.rb +4 -1
data/lib/temple/filters/static_merger.rb +11 -10
data/lib/temple/filters/validator.rb +15 -0
data/lib/temple/generators.rb +41 -100
data/lib/temple/grammar.rb +56 -0
data/lib/temple/hash.rb +48 -0
data/lib/temple/html/dispatcher.rb +10 -4
data/lib/temple/html/fast.rb +50 -38
data/lib/temple/html/filter.rb +8 -0
data/lib/temple/html/pretty.rb +25 -14
data/lib/temple/mixins/dispatcher.rb +103 -0
data/lib/temple/{mixins.rb → mixins/engine_dsl.rb} +10 -95
data/lib/temple/mixins/grammar_dsl.rb +166 -0
data/lib/temple/mixins/options.rb +28 -0
data/lib/temple/mixins/template.rb +25 -0
data/lib/temple/templates.rb +2 -0
data/lib/temple/utils.rb +11 -57
data/lib/temple/version.rb +1 -1
data/test/filters/test_control_flow.rb +92 -0
data/test/filters/test_dynamic_inliner.rb +7 -7
data/test/filters/test_eraser.rb +55 -0
data/test/filters/{test_escape_html.rb → test_escapable.rb} +13 -6
data/test/filters/test_multi_flattener.rb +1 -1
data/test/filters/test_static_merger.rb +3 -3
data/test/helper.rb +8 -0
data/test/html/test_fast.rb +42 -57
data/test/html/test_pretty.rb +10 -7
data/test/mixins/test_dispatcher.rb +31 -0
data/test/mixins/test_grammar_dsl.rb +86 -0
data/test/test_engine.rb +73 -57
data/test/test_erb.rb +0 -7
data/test/test_filter.rb +26 -0
data/test/test_generator.rb +57 -36
data/test/test_grammar.rb +52 -0
data/test/test_hash.rb +39 -0
data/test/test_utils.rb +11 -38
metadata +34 -10
data/lib/temple/filters/debugger.rb +0 -26
data/lib/temple/filters/escape_html.rb +0 -33

data/lib/temple/grammar.rb ADDED Viewed

@@ -0,0 +1,56 @@
+module Temple
+  # Temple expression grammar which can be used to validate Temple expressions.
+  #
+  # Example:
+  #   Temple::Grammar.match? [:static, 'Valid Temple Expression']
+  #   Temple::Grammar.validate! [:multi, 'Invalid Temple Expression']
+  #
+  # See {file:EXPRESSIONS.md Expression documentation}.
+  #
+  # @api public
+  module Grammar
+    extend Mixins::GrammarDSL
+    Expression <<
+      # Core abstraction
+      [:multi, 'Expression*']                  |
+      [:static, String]                        |
+      [:dynamic, String]                       |
+      [:code, String]                          |
+      [:capture, String, Expression]           |
+      [:newline]                               |
+      # Control flow abstraction
+      [:if, String, Expression, 'Expression?'] |
+      [:block, String, Expression]             |
+      [:case, String, 'Case*']                 |
+      [:cond, 'Case*']                         |
+      # Escape abstraction
+      [:escape, Bool, Expression]              |
+      # HTML abstraction
+      [:html, :doctype, String]                |
+      [:html, :comment, Expression]            |
+      [:html, :tag, HTMLIdentifier, HTMLAttrs, 'Expression?']
+    EmptyExp <<
+      [:newline] | [:multi, 'EmptyExp*']
+    HTMLAttrs <<
+      Expression | [:html, :attrs, 'HTMLAttr*']
+    HTMLAttr <<
+      [:html, :attr, HTMLIdentifier, Expression]
+    HTMLIdentifier <<
+      Symbol | String
+    Case <<
+      [Condition, 'Expression*']
+    Condition <<
+      String | :else
+    Bool <<
+      true | false
+  end
+end

data/lib/temple/hash.rb ADDED Viewed

@@ -0,0 +1,48 @@
+module Temple
+  # Immutable hash class which supports hash merging
+  # @api public
+  class ImmutableHash
+    include Enumerable
+    def initialize(*hash)
+      @hash = hash.compact
+    end
+    def include?(key)
+      @hash.any? {|h| h.include?(key) }
+    end
+    def [](key)
+      @hash.each {|h| return h[key] if h.include?(key) }
+      nil
+    end
+    def each
+      keys.each {|k| yield(k, self[k]) }
+    end
+    def keys
+      @hash.inject([]) {|keys, h| keys += h.keys }.uniq
+    end
+    def values
+      keys.map {|k| self[k] }
+    end
+  end
+  # Mutable hash class which supports hash merging
+  # @api public
+  class MutableHash < ImmutableHash
+    def initialize(*hash)
+      super({}, *hash)
+    end
+    def []=(key, value)
+      @hash.first[key] = value
+    end
+    def update(hash)
+      @hash.first.update(hash)
+    end
+  end
+end

data/lib/temple/html/dispatcher.rb CHANGED Viewed

@@ -1,16 +1,22 @@
 module Temple
   module HTML
+    # @api private
     module Dispatcher
-      def on_html_staticattrs(*attrs)
-        [:html, :staticattrs, *attrs.map {|k,v| [k, compile(v)] }]
+      def on_html_attrs(*attrs)
+        [:html, :attrs, *attrs.map {|a| compile(a) }]
+      end
+      def on_html_attr(name, content)
+        [:html, :attr, name, compile(content)]
       end
       def on_html_comment(content)
         [:html, :comment, compile(content)]
       end
-      def on_html_tag(name, attrs, closed, content)
-        [:html, :tag, name, compile(attrs), closed, compile(content)]
+      def on_html_tag(name, attrs, content = nil)
+        result = [:html, :tag, name, compile(attrs)]
+        content ? (result << compile(content)) : result
       end
     end
   end

data/lib/temple/html/fast.rb CHANGED Viewed

@@ -1,8 +1,7 @@
 module Temple
   module HTML
+    # @api public
     class Fast < Filter
-      temple_dispatch :html
       XHTML_DOCTYPES = {
         '1.1'          => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
         '5'            => '<!DOCTYPE html>',
@@ -23,14 +22,14 @@ module Temple
       set_default_options :format => :xhtml,
                           :attr_wrapper => "'",
                           :autoclose => %w[meta img link br hr input area param col base],
-                          :id_delimiter => '_'
+                          :attr_delimiter => {'id' => '_', 'class' => ' '}
-      def initialize(options = {})
+      def initialize(opts = {})
         super
         # html5 is now called html only
-        @options[:format] = :html5 if @options[:format] == :html
-        unless [:xhtml, :html4, :html5].include?(@options[:format])
-          raise "Invalid format #{@options[:format].inspect}"
+        options[:format] = :html5 if options[:format] == :html
+        unless [:xhtml, :html4, :html5].include?(options[:format])
+          raise "Invalid format #{options[:format].inspect}"
         end
       end
@@ -73,58 +72,69 @@ module Temple
           [:static, '-->']]
       end
-      def on_html_tag(name, attrs, closed, content)
-        closed ||= options[:autoclose].include?(name)
-        raise "Closed tag #{name} has content" if closed && !empty_exp?(content)
+      def on_html_tag(name, attrs, content = nil)
+        name = name.to_s
+        closed = !content || (empty_exp?(content) && options[:autoclose].include?(name))
         result = [:multi, [:static, "<#{name}"], compile(attrs)]
-        result << [:static, ' /'] if closed && xhtml?
-        result << [:static, '>'] << compile(content)
+        result << [:static, (closed && xhtml? ? ' /' : '') + '>']
+        result << compile(content) if content
         result << [:static, "</#{name}>"] if !closed
         result
       end
-      def on_html_staticattrs(*attrs)
+      def on_html_attrs(*attrs)
         result = {}
-        attrs.each do |name, value|
-          if result[name] && %w(class id).include?(name)
-            raise 'Multiple id attributes specified, but id concatenation disabled' if name == 'id' && !options[:id_delimiter]
-            result[name] = [:multi,
-                            result[name],
-                            [:static, (name == 'class' ? ' ' : options[:id_delimiter])],
-                            value]
+        attrs.each do |attr|
+          raise(InvalidExpression, 'Attribute is not a html attr') if attr[0] != :html || attr[1] != :attr
+          name, value = attr[2].to_s, attr[3]
+          next if empty_exp?(value)
+          if result[name]
+            delimiter = options[:attr_delimiter][name]
+            raise "Multiple #{name} attributes specified" unless delimiter
+            if contains_static?(value)
+              result[name] = [:html, :attr, name,
+                              [:multi,
+                               result[name][3],
+                               [:static, delimiter],
+                               value]]
+            else
+              tmp = unique_name
+              result[name] = [:html, :attr, name,
+                              [:multi,
+                               result[name][3],
+                               [:capture, tmp, value],
+                               [:if, "!#{tmp}.empty?",
+                                [:multi,
+                                 [:static, delimiter],
+                                 [:dynamic, tmp]]]]]
+            end
           else
-            result[name] = value
+            result[name] = attr
           end
         end
-        result.sort.inject([:multi]) do |list, (name, value)|
-          list << compile_attribute(name, value)
-        end
+        [:multi, *result.sort.map {|name,attr| compile(attr) }]
       end
-      protected
-      def compile_attribute(name, value)
+      def on_html_attr(name, value)
         if empty_exp?(value)
-          [:multi]
+          compile(value)
         elsif contains_static?(value)
           attribute(name, value)
         else
-          tmp = tmp_var(:htmlattr)
+          tmp = unique_name
           [:multi,
-           [:capture, tmp, value],
-           [:block, "unless #{tmp}.empty?"],
-             attribute(name, [:dynamic, tmp]),
-           [:block, 'end']]
+           [:capture, tmp, compile(value)],
+           [:if, "!#{tmp}.empty?",
+            attribute(name, [:dynamic, tmp])]]
         end
       end
+      protected
       def attribute(name, value)
         [:multi,
-         [:static, ' '],
-         [:static, name],
-         [:static, '='],
-         [:static, options[:attr_wrapper]],
-         value,
+         [:static, " #{name}=#{options[:attr_wrapper]}"],
+         compile(value),
          [:static, options[:attr_wrapper]]]
       end
@@ -132,6 +142,8 @@ module Temple
         case exp[0]
         when :multi
           exp[1..-1].any? {|e| contains_static?(e) }
+        when :escape
+          contains_static?(exp[2])
         when :static
           true
         else

data/lib/temple/html/filter.rb ADDED Viewed

@@ -0,0 +1,8 @@
+module Temple
+  module HTML
+    # @api public
+    class Filter < Temple::Filter
+      include Dispatcher
+    end
+  end
+end

data/lib/temple/html/pretty.rb CHANGED Viewed

@@ -1,12 +1,13 @@
 module Temple
   module HTML
+    # @api public
     class Pretty < Fast
       set_default_options :indent => '  ',
                           :pretty => true,
                           :indent_tags => %w(base body dd div dl dt fieldset form head h1 h2 h3
                                              h4 h5 h6 hr html img input li link meta ol p script
                                              style table tbody td tfoot th thead title tr ul).freeze,
-                          :pre_tags => %w(pre textarea).freeze
+                          :pre_tags => %w(code pre textarea).freeze
       def initialize(opts = {})
         super
@@ -22,15 +23,23 @@ module Temple
       def on_static(content)
         if @pretty
-          content = Utils.indent(content, indent, @pre_tags)
+          content.gsub!("\n", indent) if @pre_tags !~ content
           @last = content.sub!(/\r?\n\s*$/, ' ') ? nil : :noindent
         end
         [:static, content]
       end
-      def on_dynamic(content)
-        @last = :noindent
-        [:dynamic, @pretty ? "Temple::Utils.indent((#{content}), #{indent.inspect}, _temple_pre_tags)" : content]
+      def on_dynamic(code)
+        if @pretty
+          @last = :noindent
+          tmp = unique_name
+          [:multi,
+           [:code, "#{tmp} = (#{code}).to_s"],
+           [:code, "#{tmp}.gsub!(\"\\n\", #{indent.inspect}) if #{@pre_tags_name} !~ #{tmp}"],
+           [:dynamic, tmp]]
+        else
+          [:dynamic, code]
+        end
       end
       def on_html_doctype(type)
@@ -44,21 +53,22 @@ module Temple
         [:multi, [:static, indent], super]
       end
-      def on_html_tag(name, attrs, closed, content)
+      def on_html_tag(name, attrs, content = nil)
         return super unless @pretty
-        closed ||= options[:autoclose].include?(name)
-        raise "Closed tag #{name} has content" if closed && !empty_exp?(content)
+        name = name.to_s
+        closed = !content || (empty_exp?(content) && options[:autoclose].include?(name))
         @pretty = false
         result = [:multi, [:static, "#{tag_indent(name)}<#{name}"], compile(attrs)]
-        result << [:static, ' /'] if closed && xhtml?
-        result << [:static, '>']
+        result << [:static, (closed && xhtml? ? ' /' : '') + '>']
         @pretty = !options[:pre_tags].include?(name)
-        @indent += 1
-        result << compile(content)
-        @indent -= 1
+        if content
+          @indent += 1
+          result << compile(content)
+          @indent -= 1
+        end
         result << [:static, "#{tag_indent(name)}</#{name}>"] if !closed
         @pretty = true
@@ -68,7 +78,8 @@ module Temple
       protected
       def preamble
-        [:block, "_temple_pre_tags = /#{@pre_tags.source}/"]
+        @pre_tags_name = unique_name
+        [:code, "#{@pre_tags_name} = /#{@pre_tags.source}/"]
       end
       # Return indentation if not in pre tag

data/lib/temple/mixins/dispatcher.rb ADDED Viewed

@@ -0,0 +1,103 @@
+module Temple
+  module Mixins
+    # @api private
+    module CoreDispatcher
+      def on_multi(*exps)
+        multi = [:multi]
+        exps.each {|exp| multi << compile(exp) }
+        multi
+      end
+      def on_capture(name, exp)
+        [:capture, name, compile(exp)]
+      end
+    end
+    # @api private
+    module EscapeDispatcher
+      def on_escape(flag, exp)
+        [:escape, flag, compile(exp)]
+      end
+    end
+    # @api private
+    module ControlFlowDispatcher
+      def on_if(condition, *cases)
+        [:if, condition, *cases.compact.map {|e| compile(e) }]
+      end
+      def on_case(arg, *cases)
+        [:case, arg, *cases.map {|condition, exp| [condition, compile(exp)] }]
+      end
+      def on_block(code, content)
+        [:block, code, compile(content)]
+      end
+      def on_cond(*cases)
+        [:cond, *cases.map {|condition, exp| [condition, compile(exp)] }]
+      end
+    end
+    # @api private
+    module CompiledDispatcher
+      def call(exp)
+        compile(exp)
+      end
+      def compile(exp)
+        dispatcher(exp)
+      end
+      private
+      def case_statement(types)
+        code = "type, *args = args\ncase type\n"
+        types.each do |name, method|
+          code << "when #{name.to_sym.inspect}\n" <<
+            (Hash === method ? case_statement(method) : "#{method}(*args)\n")
+        end
+        code << "else\nexp\nend\n"
+      end
+      def dispatcher(exp)
+        replace_dispatcher(exp)
+      end
+      def replace_dispatcher(exp)
+        types = {}
+        self.class.instance_methods.each do |method|
+          next if method.to_s !~ /^on_(.*)$/
+          method_types = $1.split('_')
+          (0...method_types.size).inject(types) do |tmp, i|
+            raise "Invalid temple dispatcher #{method}" unless Hash === tmp
+            if i == method_types.size - 1
+              tmp[method_types[i]] = method
+            else
+              tmp[method_types[i]] ||= {}
+            end
+          end
+        end
+        self.class.class_eval %{
+          def dispatcher(exp)
+            if self.class == #{self.class}
+              args = exp
+              #{case_statement(types)}
+            else
+              replace_dispatcher(exp)
+            end
+          end
+        }
+        dispatcher(exp)
+      end
+    end
+    # @api private
+    module Dispatcher
+      include CompiledDispatcher
+      include CoreDispatcher
+      include EscapeDispatcher
+      include ControlFlowDispatcher
+    end
+  end
+end