opulent 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44c953a9be6c659e56a0c33bc41637d7e1e0730d
-  data.tar.gz: 260dd8c631ab34debe0748cc53a27024988246b6
+  metadata.gz: adcb317d2774dc8ee749c9a36ac819b409812ad4
+  data.tar.gz: 50c443fb0d1df18f2455aff4f52c0ba0f7187cea
 SHA512:
-  metadata.gz: 59e7c5c79cca92558ca68f2ab5be229bdd2815e4cb5a488465d3e0d391e548626905e1398327ebdc52746fb70cf688705ef7d6eaf2b696b40f2e717b3f795140
-  data.tar.gz: 5d0a8ad12ca13ba645417a1f73b0bfbb46f96b57db9d509976c777a5761feae6dcbfec48fee944c79f8063813116ca5d9d5e7ce08d59a72f912ab29a54dc8ccd
+  metadata.gz: e2ba4bdb98dc6754ade2083b1a812c8577398013ffb7f77265ac09c10a95c6da76fdbc3bb2b1f5f710b514d9c7854379f5aa6809ddea5ebe300ca91b5f0c85b1
+  data.tar.gz: f581c87ad7188a2de2821a5705e3e94481720eaf7d8a6865ddcef8e721b66e6ec92fc52e33792f88635e05cb65d0e11ac9ec6eae5e7ef15fa03e1929ec89d882

data/benchmark/benchmark.rb

@@ -1,7 +1,5 @@
 require 'benchmark'
 require_relative '../lib/opulent'
-require 'slim'
-require 'haml'
 
 # Choose the benchmark you want to run
 BENCHMARK = :node
@@ -10,7 +8,8 @@ BENCHMARK = :node
 N = 1000
 
 # Templating engine initialization
-puts "BENCHMARK"
+puts "BENCHMARK\n--\n"
+
 case BENCHMARK
 when :node
   case_folder = 'cases/node/'
@@ -24,22 +23,34 @@ when :node
     c: 5
   }
 
-  scope = Object.new
+  op = Opulent.new :"#{case_folder}node"
+  # op2 = Opulent.new :"#{case_folder}yield", def: op.def
+
+  puts op.render(op, locals){}
+  #
+  # puts op.render(op, locals){
+  #   op2.render(op, locals){}
+  # }
+
+  puts "\n\n"
+
+  puts op.template
+  puts "\n\n"
 
   Benchmark.bm do |x|
     x.report("haml") do
       N.times do
-        haml.render(scope, locals) do end
+        haml.render(Object.new, locals){}
       end
     end
     x.report("opulent") do
       N.times do
-        opulent.render(scope, locals) do end
+        opulent.render(Object.new, locals){}
       end
     end
     x.report("slim") do
       N.times do
-        slim.render(scope, locals) do end
+        slim.render(Object.new, locals){}
       end
     end
   end

data/benchmark/cases/node/node.haml

@@ -1,17 +1,7 @@
-%html
+- a = "hello"
+- kls = ['a', 'b', 'c']
+
+%html hello=a
   %head
-    %title Hello world
-    %meta(name="description" content="Node benchmark")
-  %body
-    %nav.navbar
-      %ul.nav.left
-        %li Home
-        %li About
-        %li Contact
-    #content
-      .container
-        .row
-          .col-md-12
-            | Hello world, this is a dummy text used for the speed benchmark in Opulent
-    %footer
-      | Copyright © Hello world!
+  %body class=kls
+    %p Hello world!

data/benchmark/cases/node/node.op

@@ -1,14 +1,7 @@
-html
+- a = "hello"
+- kls = ['a', 'b', 'c']
+
+html hello=a
   head
-    title
-    meta
-  body
-    nav
-      ul
-        li
-        li
-        li
-    content
-      container
-        row
-          col-md-12
+  body class=kls
+    p Hello world!

data/benchmark/cases/node/node.slim

@@ -1,19 +1,7 @@
-html
+- a = "hello"
+- kls = ['a', 'b', 'c']
+
+html hello=a
   head
-    - a = 3
-    title =a
-    meta name="description" content="Node benchmark"
-  body
-    nav.navbar
-      ul.nav.left
-        li Home
-        li About
-        li Contact
-    #content
-      .container
-        .row
-          .col-md-12
-            | Hello world, this is a dummy text used for
-              the speed benchmark in Opulent
-    footer
-      | Copyright © Hello world!
+  body class=kls
+    p Hello world!

data/docs/comments.md

@@ -17,6 +17,11 @@ Block comments are marked up with two forward slash characters `//`.
 ## Output Comments
 By default, comments are only for reference inside Opulent files. You can output them
 by adding an exclamation character `!`, to resemble HTML.
+
 ```html
 /! This comment will be outputted
 ```
+
+```html
+<!-- This comment will be outputted -->
+```

data/docs/filters.md

@@ -0,0 +1,31 @@
+# Opulent Filters
+
+Filters let you use other languages within a opulent template. They take a block of plain text as an input.
+Some filters also have a default tag associated with them, such as the `css` filter and `javascript` filter.
+
+```html
+:markdown
+  # Markdown
+
+  I often like including markdown documents.
+
+:coffee-script
+  console.log 'This is coffeescript'
+```
+
+By default, the following filters are included:
+
+```
+:coffeescript
+:javascript
+:scss
+:sass
+:css
+:cdata
+:escaped
+:markdown
+:maruku
+:textile
+```
+
+Each filter uses its associated gem and requires it to be installed.

data/docs/nodes.md

@@ -30,4 +30,92 @@ Nodes such as text can be written inline without any identifier. However, when w
 ```sass
 ul
   li > a href="http://google.com" Google
+
+a href="google" > i.fa.fa-circle
+  | Hello world
+```
+
+```html
+<ul>
+  <li>
+    <a href="http://google.com">Google</a>
+  </li>
+</ul>
+
+<a href="http://google.com">
+  <i class="fa fa-circle"></i>
+  Google
+</a>
+```
+
+## Inline Text Feed
+We can write text directly inline with our node.
+
+```sass
+p This is <escaped> inline text
+p ~ This is <unescaped> inline text
+
+p | This is <escaped> multiline text
+  which is more indented than the paragraph node.
+p |~ This is <unescaped> multiline text
+  which is more indented than the paragraph node.
+```
+
+```html
+<p>This is &lt;escaped&gt; inline text</p>
+<p>This is <unescaped> inline text</p>
+
+<p>This is &lt;escaped&gt; multiline text which is more indented than the paragraph node.</p>
+<p>This is <escaped> multiline text which is more indented than the paragraph node.</p>
+```
+
+## Explicit Inline Text Feed
+If we want Opulent to parse the following part as text explicitly, we can use a backslash `\` character,
+which stops the parsing of the current line and starts getting a text feed.
+
+```
+p id="paragraph" Inside
+
+p \id="paragraph" Inside
+```
+
+The `\` character will gather the rest of the line as text.
+
+```html
+<p id="paragraph">Inside</p>
+
+<p>id="paragraph" Inside</p>
+```
+
+## Whitespace
+
+Sometimes we need to leave a leading or trailing whitespace at a certain node, like `strong` or `a`.
+We can do that using pointer arrows.
+
+```
+| We want a space before
+strong<- this text.
+```
+
+```
+strong-> This text
+| has a space after it.
+```
+
+```
+| Before
+strong<-> this text
+| and after it.
+```
+
+## Self Enclosing
+
+We can explicitly self enclose nodes. By default, Opulent knows that nodes such as `img` need to be self enclosed.
+
+```
+mynode /
+```
+
+```html
+<mynode>
 ```

data/docs/reference.md

@@ -3,9 +3,10 @@ Opulent is an __Intelligent Web Templating Engine__ created for extremely fast a
 
 ### Language Reference
 
-1. [Attributes](attributes.md)
-2. [Control Structures](control-structures.md)
-3. [Expressions](expressions.md)
-4. [Comments](comments.md)
-5. [Doctype](doctype.md)
-5. [Nodes](nodes.md)
+1. [Nodes](nodes.md)
+2. [Attributes](attributes.md)
+3. [Control Structures](control-structures.md)
+4. [Expressions](expressions.md)
+5. [Comments](comments.md)
+6. [Doctype](doctype.md)
+7. [Filters](filters.md)

data/lib/opulent.rb

@@ -1,5 +1,5 @@
 require 'tilt'
-require 'htmlentities'
+require 'escape_utils'
 require_relative 'opulent/compiler.rb'
 require_relative 'opulent/context.rb'
 require_relative 'opulent/engine.rb'
@@ -9,3 +9,4 @@ require_relative 'opulent/parser.rb'
 require_relative 'opulent/settings.rb'
 require_relative 'opulent/template.rb'
 require_relative 'opulent/tokens.rb'
+require_relative 'opulent/utils.rb'

data/lib/opulent/compiler.rb

@@ -1,4 +1,4 @@
-require_relative 'compiler/block.rb'
+require_relative 'compiler/buffer.rb'
 require_relative 'compiler/comment.rb'
 require_relative 'compiler/control.rb'
 require_relative 'compiler/define.rb'
@@ -8,19 +8,23 @@ require_relative 'compiler/filter.rb'
 require_relative 'compiler/node.rb'
 require_relative 'compiler/root.rb'
 require_relative 'compiler/text.rb'
+require_relative 'compiler/yield.rb'
 
 # @Opulent
 module Opulent
   # @Compiler
   class Compiler
-    Buffer = :_buffer
+    Buffer = :@_opulent_buffer
+
+    OpulentKey = :_opulent_key
+    OpulentValue = :_opulent_value
 
     # All node Objects (Array) must follow the next convention in order
     # to make parsing faster
     #
     # [:node_type, :value, :attributes, :children, :indent]
     #
-    # @param path [String] Current file path needed for require nodes
+    # @param path [String] Current file path needed for include nodes
     #
     def initialize
       # Setup convention accessors
@@ -30,15 +34,18 @@ module Opulent
       @children = 3
       @indent = 4
 
-      # Create the HTML Entities encoder/decoder
-      @entities = HTMLEntities.new
-
       # Get special node types from the settings
       @multi_node = Settings::MultiNode
       @inline_node = Settings::InlineNode
 
-      # Quick accessor for default yield constant
-      @default_yield = Settings::DefaultYield
+      # Initialize amble object
+      @template = [[:preamble]]
+
+      # Incrmental counters
+      @current_variable_count = 0
+      @current_attribute = 0
+      @current_extension = 0
+      @current_definition = 0
 
       # The node stack is needed to keep track of all the visited nodes
       # from the current branch level
@@ -58,7 +65,7 @@ module Opulent
     # @param root_node [Array] Root node containing all document nodes
     # @param context [Context] Context holding environment variables
     #
-    def compile(root_node, context)
+    def compile(root_node, context = nil)
       # Compiler generated code
       @code = ""
       @generator = ""
@@ -71,15 +78,9 @@ module Opulent
         root child, 0, context
       end
 
-      return @code
-    end
+      @template << [:postamble]
 
-    # Escape a given input value using htmlentities
-    #
-    # @param value [String] String to be escaped
-    #
-    def escape(value)
-      @entities.encode value
+      return templatize
     end
 
     # Remove the last newline from the current code buffer
@@ -113,7 +114,7 @@ module Opulent
       when :binding
         data[0] = data[0].to_s.match(/\`(.*)\'/)
         data[0] = data[0][1] if data[0]
-        "Found an undefined local variable or method \"#{data[0]}\" at \"#{data[1]}\"."
+        "Found an undefined local variable or method \"#{data[0]}\"."
       when :variable_name
         data[0] = data[0].to_s.match(/\`(.*)\'/)[1]
         "Found an undefined local variable or method \"#{data[0]}\" in locals."

data/lib/opulent/compiler/buffer.rb

@@ -0,0 +1,260 @@
+# @Opulent
+module Opulent
+  class Compiler
+    # Output an object stream into the template
+    #
+    # @param string [String] Buffer input string
+    #
+    def buffer(string)
+      @template << [:buffer, string]
+    end
+
+    # Output and escape an object stream into the template
+    #
+    # @param string [String] Buffer input string
+    #
+    def buffer_escape(string)
+      @template << [:escape, string]
+    end
+
+    # Output and freeze a String stream into the template
+    #
+    # @param string [String] Buffer input string
+    #
+    def buffer_freeze(string)
+      if @template[-1][0] == :freeze
+        @template[-1][1] += string
+      else
+        @template << [:freeze, string]
+      end
+    end
+
+    # Evaluate a stream into the template
+    #
+    # @param string [String] Buffer input string
+    #
+    def buffer_eval(string)
+      @template << [:eval, string]
+    end
+
+    # Set a local variable through buffer eval an object stream into the template
+    #
+    # @param name [String] Variable identifier to be set
+    # @param name [String] Variable value to be set
+    #
+    def buffer_set_variable(name, value)
+      local_variable = "_opulent_#{name}_#{@current_variable_count += 1}"
+      buffer_eval "#{local_variable} = #{value}"
+      local_variable
+    end
+
+    # Remove last n characters from the most recent template item
+    #
+    # @param type [Symbol] Remove only if last buffer part is of this type
+    # @param n [Fixnum] Number of characters to be removed
+    #
+    def buffer_remove_last_character(type = :freeze, n = 1)
+      @template[-1][1] = @template[-1][1][0..-1-n] if @template[-1][0] == type
+    end
+
+    # Turn call node attributes into a hash string
+    #
+    # @param attributes [Array] Array of node attributes
+    #
+    def buffer_attributes_to_hash(attributes)
+      "{" + attributes.inject([]) do |extend_map, (key, attribute)|
+        extend_map << ("#{key}: " + if key == :class
+          '[' + attribute.map do |exp|
+            exp[@value]
+          end.join(", ") + ']'
+        else
+          attribute[@value]
+        end)
+      end.join(', ') + "}"
+    end
+
+    # Go through the node attributes and apply extension where needed
+    #
+    # @param attributes [Array] Array of node attributes, from parser
+    # @param extension [String] Extension identifier
+    #
+    def buffer_attributes(attributes, extension)
+      # Proc for setting class attribute extension, used as DRY closure
+      #
+      buffer_class_attribute_type_check = Proc.new do |variable, escape = true|
+        class_variable = buffer_set_variable :local, variable
+        buffer_eval "if #{class_variable}.is_a? Array"
+        escape ? buffer_escape("#{class_variable}.join ' '") : buffer("#{class_variable}.join ' '")
+        buffer_eval "elsif #{class_variable}.is_a? Hash"
+        escape ? buffer_escape("#{class_variable}.to_a.join ' '") : buffer("#{class_variable}.to_a.join ' '")
+        buffer_eval "elsif [TrueClass, NilClass, FalseClass].include? #{class_variable}.class"
+        buffer_eval "else"
+        escape ? buffer_escape("#{class_variable}") : buffer("#{class_variable}")
+        buffer_eval "end"
+      end
+
+      # Handle class attributes by checking if they're simple, noninterpolated
+      # strings and extend them if needed
+      #
+      buffer_class_attribute = Proc.new do |attribute|
+        if attribute[@value] =~ Tokens[:exp_string]
+          buffer_split_by_interpolation attribute[@value][1..-2]
+        else
+          buffer_class_attribute_type_check[attribute[@value], attribute[@options][:escaped]]
+        end
+      end
+
+
+      # If we have class attributes, process each one and check if we have an
+      # extension for them
+      if attributes[:class]
+        buffer_freeze " class=\""
+
+        # Process every class attribute
+        attributes[:class].each do |node_class|
+          buffer_class_attribute[node_class]
+          buffer_freeze " "
+        end
+
+        # Remove trailing whitespace from the buffer
+        buffer_remove_last_character
+
+        # Check for extension with :class key
+        if extension
+          buffer_eval "if #{extension}.has_key? :class"
+          buffer_freeze " "
+          buffer_class_attribute_type_check["#{extension}.delete(:class)"]
+          buffer_eval "end"
+        end
+
+        buffer_freeze '"'
+      elsif extension
+        # If we do not have class attributes but we do have an extension, try to
+        # see if the extension contains a class attribute
+        buffer_eval "if #{extension}.has_key? :class"
+        buffer_freeze " class=\""
+        buffer_class_attribute_type_check["#{extension}.delete(:class)"]
+        buffer_freeze '"'
+        buffer_eval "end"
+      end
+
+      # Proc for setting class attribute extension, used as DRY closure
+      #
+      buffer_data_attribute_type_check = Proc.new do |key, variable, escape = true, dynamic = false|
+        # @Array
+        buffer_eval "if #{variable}.is_a? Array"
+        dynamic ? buffer("\" #{key}=\\\"\"") : buffer_freeze(" #{key}=\"")
+        escape ? buffer_escape("#{variable}.join '_'") : buffer("#{variable}.join '_'")
+        buffer_freeze '"'
+
+        # @Hash
+        buffer_eval "elsif #{variable}.is_a? Hash"
+        buffer_eval "#{variable}.each do |#{OpulentKey}, #{OpulentValue}|"
+        dynamic ? buffer("\" #{key}-\"") : buffer_freeze(" #{key}-") # key-hashkey="
+        buffer "\"\#{#{OpulentKey}}\""
+        buffer_freeze "=\""
+        escape ? buffer_escape("_opulent_value") : buffer("_opulent_value") # value
+        buffer_freeze '"'
+        buffer_eval "end"
+
+        # @TrueClass
+        buffer_eval "elsif #{variable}.is_a? TrueClass"
+        dynamic ? buffer("\" #{key}\"") : buffer_freeze(" #{key}")
+
+        # @FalseClass
+        buffer_eval "elsif [NilClass, FalseClass].include? #{variable}.class"
+
+        # @Object
+        buffer_eval "else"
+        dynamic ? buffer("\" #{key}=\\\"\"") : buffer_freeze(" #{key}=\"")
+        escape ? buffer_escape("#{variable}") : buffer("#{variable}")
+        buffer_freeze '"'
+
+        # End
+        buffer_eval "end"
+      end
+
+      # Handle data (normal) attributes by checking if they're simple, noninterpolated
+      # strings and extend them if needed
+      #
+      buffer_data_attribute = Proc.new do |key, attribute|
+        # When we have an extension for our attributes, check current key.
+        # If it exists, check it's type and generate everything dynamically
+        if extension
+          buffer_eval "if #{extension}.has_key? :#{key}"
+          variable = buffer_set_variable :local, "#{extension}.delete(:#{key})"
+          buffer_data_attribute_type_check[key, variable, attribute[@options][:escaped]]
+          buffer_eval "else"
+        end
+
+        # Check if the set attribute is a simple string. If it is, freeze it or
+        # escape it. Otherwise, evaluate and initialize the type check.
+        if attribute[@value] =~ Tokens[:exp_string]
+          buffer_freeze " #{key}=\""
+          buffer_split_by_interpolation attribute[@value][1..-2]
+          buffer_freeze "\""
+        else
+          # Evaluate and type check
+          variable = buffer_set_variable :local, attribute[@value]
+          buffer_data_attribute_type_check[key, variable, attribute[@options][:escaped]]
+        end
+
+        # Extension end
+        if extension
+          buffer_eval "end"
+        end
+      end
+
+      # Process the remaining, non-class related attributes
+      attributes.each do |key, attribute|
+        next if key == :class
+        buffer_data_attribute[key, attribute]
+      end
+
+      # Process remaining extension keys if there are any
+      if extension
+        buffer_eval "#{extension}.each do |ext#{OpulentKey}, ext#{OpulentValue}|"
+        buffer_data_attribute_type_check["\#{ext#{OpulentKey}}", "ext#{OpulentValue}", true, true]
+        buffer_eval "end"
+      end
+    end
+
+    # Transform buffer array into a reusable template
+    #
+    def templatize
+      separator = DEBUG ? "\n" : "; " # Readablity during development
+      @template.inject("") do |buffer, input|
+        buffer += case input[0]
+        when :preamble
+          "#{Buffer} = []#{separator}"
+        when :buffer
+          "#{Buffer} << (#{input[1]})#{separator}"
+        when :escape
+          "#{Buffer} << (::Opulent::Utils::escape(#{input[1]}))#{separator}"
+        when :freeze
+          "#{Buffer} << (#{input[1].inspect}.freeze)#{separator}"
+        when :eval
+          "#{input[1]}#{separator}"
+        when :postamble
+          "#{Buffer}.join"
+        end
+      end
+    end
+
+    # Split a string by its interpolation, then check if it really needs to be
+    # escaped or not. Huge performance boost!
+    #
+    # @param string [String] Input string
+    # @param escape [Boolean] Escape string
+    #
+    def buffer_split_by_interpolation(string, escape = true)
+      string.split(Utils::InterpolationPattern).each_with_index do |input, index|
+        if index % 2 == 0
+          escape ? (input =~ Utils::EscapeHTMLPattern ? buffer_escape(input.inspect) : buffer_freeze(input)) : buffer_freeze(input)
+        else
+          escape ? buffer_escape(input) : buffer(input)
+        end
+      end
+    end
+  end
+end