wlang 2.0.0.beta → 2.0.0

data/Gemfile

@@ -3,22 +3,16 @@ source 'http://rubygems.org'
 group :runtime do
   gem "citrus", "~> 2.4.1"
   gem "temple", "~> 0.4.0"
-  gem "backports", "~> 2.6.1", :platforms => ["ruby_18", "mri_18", "mingw_18", 'jruby']
   gem "quickl", "~> 0.4.3"
   gem "awesome_print", "~> 1.0.2"
-end
-
-group :profiling do
-  gem "ruby-prof", "~> 0.11.2"
-  gem "mustache", "~> 0.99.4"
-  #gem "viiite", :git => "git://github.com/blambeau/viiite.git"
+  gem "epath", ">= 0.2"
 end
 
 group :development do
+  gem "tilt", "~> 1.3"
   gem "rake", "~> 0.9.2"
   gem "bundler", "~> 1.0"
   gem "rspec", "~> 2.10.0"
-  gem "epath", "~> 0.1.0"
   gem "yard", "~> 0.8.1"
   gem "bluecloth", "~> 2.2.0"
 end

data/Gemfile.lock

@@ -2,12 +2,10 @@ GEM
   remote: http://rubygems.org/
   specs:
     awesome_print (1.0.2)
-    backports (2.6.1)
     bluecloth (2.2.0)
     citrus (2.4.1)
     diff-lcs (1.1.3)
-    epath (0.1.1)
-    mustache (0.99.4)
+    epath (0.2.0)
     quickl (0.4.3)
     rake (0.9.2.2)
     rspec (2.10.0)
@@ -18,8 +16,8 @@ GEM
     rspec-expectations (2.10.0)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.10.1)
-    ruby-prof (0.11.2)
     temple (0.4.0)
+    tilt (1.3.3)
     yard (0.8.1)
 
 PLATFORMS
@@ -27,15 +25,13 @@ PLATFORMS
 
 DEPENDENCIES
   awesome_print (~> 1.0.2)
-  backports (~> 2.6.1)
   bluecloth (~> 2.2.0)
   bundler (~> 1.0)
   citrus (~> 2.4.1)
-  epath (~> 0.1.0)
-  mustache (~> 0.99.4)
+  epath (>= 0.2)
   quickl (~> 0.4.3)
   rake (~> 0.9.2)
   rspec (~> 2.10.0)
-  ruby-prof (~> 0.11.2)
   temple (~> 0.4.0)
+  tilt (~> 1.3)
   yard (~> 0.8.1)

data/Manifest.txt

@@ -1,6 +1,5 @@
 wlang.gemspec
 wlang.noespec
-.gemtest
 CHANGELOG.md
 Gemfile
 Gemfile.lock
@@ -12,4 +11,3 @@ Rakefile
 README.md
 spec/**/*
 tasks/**/*
-test/**/*

data/README.md

@@ -2,11 +2,9 @@
 
 [![Build Status](https://secure.travis-ci.org/blambeau/wlang.png?branch=wlang2)](http://travis-ci.org/blambeau/wlang)
 
-WLang is a powerful code generation and templating engine.
+WLang is a powerful code generation and templating engine, implemented on top of [temple](https://github.com/judofyr/temple) and much inspired by the excellent [mustache](http://mustache.github.com/).
 
-This is the README of wlang2, a fresh new implementation of the [wlang templating language concept](http://revision-zero.org/wlang), this one implemented on top of [temple](https://github.com/judofyr/temple) and much inspired by the excellent [mustache](http://mustache.github.com/). (For users of wlang 1.0 (formaly 0.10.2), this rewrite cleans most concepts as well as the abstract wlang semantics; it also uses a simple compiler architecture to gain huge perfomance gains in comparison to early wlang days).
-
-**WLang2 is work in progress**. It does not support rubinius so far, due to an incompatibility with the Citrus parser generator. It also have some issues with spacing; not a big issue for HTML rendering but might prevent certain generation tasks.
+**WLang2 is still work in progress**.
 
 ## Links
 
@@ -15,7 +13,19 @@ This is the README of wlang2, a fresh new implementation of the [wlang templatin
 * http://rubygems.org/gems/wlang
 * http://revision-zero.org/wlang
 
-## A user-defined templating engine
+## Features
+
+* Tunable templating engine. You can define your own tags, and their behavior.
+* Powerful logic-less HTML concretization to render web pages à la Mustache with extra.
+* Compiled templates for speedy generation.
+* [Tilt](https://github.com/rtomayko/tilt) and [Sinatra](https://github.com/sinatra/sinatra) integration.
+
+WLang 2.0 also has a few remaining issues.
+
+* It does not support rubinius so far, due to an incompatibility with the Citrus parser generator.
+* It also have some issues with spacing; not a big issue for HTML rendering but might prevent certain generation tasks.
+
+## Tunable templating engine
 
 WLang is a templating engine, written in ruby. In that, it is similar to ERB, Mustache and the like:
 
@@ -43,7 +53,7 @@ Highlighter.render('Hello ${who}!'), who: 'you & the world'
 # => "Hello YOU & THE WORLD !"
 ```
 
-WLang already provides a few useful dialects, such as WLang::Mustang (mimicing mustache) and WLang::Html (a bit more powerful in my opinion). If they don't match your needs, it is up to you to define you own dialect for making your generation task easy. Have a look at the implementation of WLang's ones, it's pretty simple to get started!
+WLang already provides a few useful dialects, such as WLang::Html (inspired by Mustache but a bit more powerful in my opinion). If they don't match your needs, it is up to you to define you own dialect for making your generation task easy. Have a look at the implementation of WLang's ones, it's pretty simple to get started!
 
 ## Abstract semantics
 
@@ -97,4 +107,23 @@ class HighLevel < WLang::Dialect
 end
 ```
 
-Use at your own risk, though, as it might lead to dialects that are difficult to understand and/or use and present serious injections risks! Otherwise, higher-order constructions provides you with very powerful tools.
+Use at your own risk, though, as it might lead to dialects that are difficult to understand and/or use and present serious injections risks! Otherwise, higher-order constructions provides you with very powerful tools.
+
+# Tilt integration
+
+WLang 2.0 has built-in support for [Tilt](https://github.com/rtomayko/tilt) facade to templating engines. In order to use that API:
+
+```ruby
+require 'tilt'         # needed in your bundle, not a wlang dependency
+require 'wlang'        # loads Tilt support provided Tilt has already been required
+
+template = Tilt.new("path/to/a/template.wlang")   # suppose 'Hello ${who}!'
+template.render(:who => "world")
+# => Hello world!
+
+template = Tilt.new(hello_path.to_s, :dialect => Highlighter)
+template.render(:who => "world")
+# => Hello WORLD!
+```
+
+Please note that you should require tilt first, then wlang. Otherwise, you'll have to require `wlang/tilt` explicitely.

data/lib/wlang.rb

@@ -29,6 +29,9 @@ module WLang
 
 end # module WLang
 require 'wlang/compiler'
+require 'wlang/source'
 require 'wlang/template'
 require 'wlang/dialect'
 require 'wlang/scope'
+require 'wlang/html'
+require 'wlang/tilt' if defined?(::Tilt)

data/lib/wlang/command.rb

@@ -45,14 +45,13 @@ module WLang
     def execute(argv)
       install(argv)
 
-      compiler = @dialect.compiler(@compiling_options)
       if @ast
         require 'awesome_print'
-        ap compiler.ast(@template)
+        ap @template.to_ast
       end
 
       with_output do |output|
-        compiler.compile(@template).render(@context, output)
+        @template.render(@context, output)
       end
     end
 
@@ -71,15 +70,8 @@ module WLang
       @dialect       = WLang::Html
 
       # template and context
-      @template      = File.read(@tpl_file)
+      @template      = Template.new(File.read(@tpl_file), @compiling_options)
       @context       = {}
-
-      if @yaml_front_matter and
-         @template =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
-        require 'yaml'
-        @context.merge! YAML::load($1)
-        @template = $'
-      end
     end
 
     def with_output(&proc)

data/lib/wlang/compiler.rb

@@ -30,16 +30,12 @@ module WLang
       dialect.options
     end
 
-    def compile(source)
-      case source
-      when Template
-        source
-      when Proc
-        Template.new(@dialect, source)
+    def to_ruby_proc(source)
+      source = eval(to_ruby_code(source), TOPLEVEL_BINDING)
+      if String===source
+        Proc.new{|d,buf| buf << source}
       else
-        code = to_ruby_code(source)
-        proc = eval(code, TOPLEVEL_BINDING)
-        Template.new(@dialect, proc)
+        source
       end
     end
 
@@ -47,12 +43,12 @@ module WLang
       engine.call(source)
     end
 
-    def ast(source)
+    def to_ast(source)
       parser.new.call(source)
     end
 
-    def parser
-      Class.new(Temple::Engine).tap{|c|
+    def parser(engine = Class.new(Temple::Engine))
+      engine.tap{|c|
         c.use Parser
         c.use DialectEnforcer, :dialect => @dialect
         c.use Autospacing if options[:autospacing]
@@ -61,16 +57,11 @@ module WLang
       }
     end
 
-    def engine(gencode = true)
-      Class.new(Temple::Engine).tap{|c|
-        c.use Parser
-        c.use DialectEnforcer, :dialect => @dialect
-        c.use Autospacing if options[:autospacing]
-        c.use StrconcatFlattener
-        c.use StaticMerger
+    def engine(generate_code = true)
+      parser.tap{|c|
         c.use ProcCallRemoval
         c.use ToRubyAbstraction
-        c.use ToRubyCode if gencode
+        c.use ToRubyCode if generate_code
       }.new
     end
 

data/lib/wlang/compiler/autospacing.rb

@@ -15,8 +15,10 @@ module WLang
 
       def on_wlang(symbols, *fns)
         fns.inject [:wlang, symbols] do |rw,fn|
-          fn = Unindent.new.call(fn)
-          fn = RightStrip.new.call(fn)
+          if multiline?(fn)
+            fn = Unindent.new.call(fn)
+            fn = RightStrip.new.call(fn)
+          end
           rw << call(fn)
         end
       end

data/lib/wlang/compiler/dialect_enforcer.rb

@@ -28,7 +28,7 @@ module WLang
         ds = dialect.dialects_for(symbols) || []
         fns.zip(ds).inject [:wlang, symbols] do |rw, (fn, d)|
           if d
-            enforcer = DialectEnforcer.new(:dialect => d.factor)
+            enforcer = DialectEnforcer.new(:dialect => d.new)
             rw << [:modulo, d, enforcer.call(fn)]
           else
             rw << call(fn)

data/lib/wlang/compiler/to_ruby_code.rb

@@ -39,7 +39,7 @@ module WLang
         else
           id   = idgen.next
           code = call(fn)
-          "Proc.new{|d#{id},b#{id}| #{code}.call(#{dialect}.factor(d#{id}.options), b#{id}) }"
+          "Proc.new{|d#{id},b#{id}| #{code}.call(#{dialect}.new(d#{id}.options, d#{id}.template), b#{id}) }"
         end
       end
 

data/lib/wlang/dialect.rb

@@ -1,52 +1,192 @@
-require 'wlang/dialect/dispatching'
-require 'wlang/dialect/evaluation'
-require 'wlang/dialect/tags'
 module WLang
   class Dialect
-    include Dialect::Dispatching
-    include Dialect::Evaluation
-    include Dialect::Tags
 
     class << self
 
-      def factor(options = {})
-        new(default_options.merge(options))
-      end
+      # facade
 
       def default_options(options = {})
         @default_options ||= (superclass.default_options.dup rescue {})
         @default_options.merge!(options)
       end
 
-      def compiler(options = {})
-        factor(options).compiler
+      def compile(source, options = {})
+        Template.new source, :dialect => self
       end
 
-      def compile(source, options = {})
-        compiler(options).compile(source)
+      def render(source, scope = {}, buffer = "")
+        compile(source).call(scope, buffer)
       end
 
-      def to_ruby_code(source, options = {})
-        compiler(options).to_ruby_code(source)
+      # tag installation and dispatching
+
+      # Install a new tag on the dialect for `symbols`.
+      #
+      # Optional `dialects` can be passed if dialect modulation needs to occur for some
+      # blocks. The source code of the tag can either be passed as a `method` Symbol or
+      # as a block.
+      #
+      # Examples:
+      #
+      #   # A simple tag with explicit code as a block
+      #   tag('$') do |buf,fn| ... end
+      #
+      #   # A simple tag, reusing a method (better for testing the method easily)
+      #   tag('$', :some_existing_method)
+      #
+      #   # Specifying that the first block of #{...}{...} has to be parsed in the same
+      #   # dialect whereas the second has to be parsed in the dummy one.
+      #   tag('#', [self, WLang::Dummy], ::some_existing_method)
+      #
+      def tag(symbols, dialects = nil, method = nil, &block)
+        if block
+          tag(symbols, dialects, block)
+        else
+          dialects, method = nil, dialects if method.nil?
+          define_tag_method(symbols, dialects, method)
+        end
       end
 
-      def render(source, scope = {}, buffer = "")
-        compile(source).call(scope, buffer)
+      # Returns the dispatching method name for a given tag symbol and optional prefix
+      # (defaults to '_tag').
+      #
+      # Example:
+      #
+      #   Dialect.tag_dispatching_name('!$')
+      #   # => :_tag_33_36
+      #
+      #   Dialect.tag_dispatching_name('!$', "my_prefix")
+      #   # => :my_prefix_33_36
+      #
+      def tag_dispatching_name(symbols, prefix = "_tag")
+        symbols = symbols.chars unless symbols.is_a?(Array)
+        chars   = symbols.map{|s| s.ord}.join("_")
+        "#{prefix}_#{chars}".to_sym
       end
 
-    end
+      # Binds two methods for the given `symbols`:
+      #
+      # 1) _tag_xx_yy that executes `code`
+      # 2) _diatag_xx_yy that returns the dialect information of the tag blocks.
+      #
+      # `code` can either be a Symbol (existing method) or a Proc (some explicit code).
+      #
+      def define_tag_method(symbols, dialects, code)
+        rulename = tag_dispatching_name(symbols, "_tag")
+        case code
+        when Symbol
+          module_eval %Q{ alias :#{rulename} #{code} }
+        when Proc
+          define_method(rulename, code)
+        else
+          raise "Unable to use #{code} for a tag"
+        end
+        dialects_info_name = tag_dispatching_name(symbols, "_diatag")
+        define_method(dialects_info_name) do dialects end
+      end
 
+    end # class methods
+
+    # Set the default options, '{' and '}' for braces and no autospacing
     default_options :braces      => WLang::BRACES,
                     :autospacing => false
 
+    # All dialect options
     attr_reader :options
-    def braces; options[:braces]; end
 
-    attr_reader :compiler
+    # The template that uses this dialect instance to render
+    attr_reader :template
+
+    # Creates a dialect instance with options
+    def initialize(*args)
+      template, options = nil, {}
+      args.each do |arg|
+        options  = arg.to_hash if arg.respond_to?(:to_hash)
+        template = arg if Template===arg
+      end
+      @template = template
+      @options  = self.class.default_options.merge(options)
+    end
+
+    # meta information
 
-    def initialize(options = {})
-      @options  = options
-      @compiler = WLang::Compiler.new(self)
+    # Returns the braces to use, as set in the options
+    def braces
+      options[:braces]
+    end
+
+    # Returns the dialects used to parse the blocks associated with `symbols`, as
+    # previously installed by `define_tag_method`.
+    def dialects_for(symbols)
+      info = self.class.tag_dispatching_name(symbols, "_diatag")
+      raise ArgumentError, "No tag for #{symbols}" unless respond_to?(info)
+      send(info)
+    end
+
+    # rendering
+
+    # Renders `fn` to a `buffer`, optionally extending the current scope.
+    #
+    # `fn` can either be a String (immediately pushed on the buffer), a Proc (taken as a
+    # tag block to render further), or a Template (taken as a partial to render in the
+    # current scope).
+    #
+    # Is `scope` is specified, the current scope is first branched to use to new one in
+    # priority, then rendering applies and the newly created scope if then poped.
+    #
+    # Returns the buffer.
+    #
+    def render(fn, scope = nil, buffer = "")
+      if scope.nil?
+        case fn
+        when String
+          buffer << fn
+        when Proc
+          fn.call(self, buffer)
+        when Template
+          fn.call(@scope, buffer)
+        else
+          raise ArgumentError, "Unable to render `#{fn}`"
+        end
+        buffer
+      else
+        with_scope(scope){ render(fn, nil, buffer) }
+      end
+    end
+
+    # evaluation
+
+    # Returns the current rendering scope.
+    def scope
+      @scope ||= Scope.root
+    end
+
+    # Yields the block with a scope branched with a sub-scope `x`.
+    def with_scope(x)
+      @scope = scope.push(x)
+      res    = yield
+      @scope = scope.pop
+      res
+    end
+
+    # Evaluates `expr` in the current scope. `expr` can be either
+    #
+    # * a Symbol or a String, taken as a dot expression to evaluate
+    # * a Proc or a Template, first rendered and then evaluated
+    #
+    # Evaluation is delegated to the scope (@see Scope#evaluate) and the result returned
+    # by this method.
+    #
+    def evaluate(expr, *default)
+      case expr
+      when Symbol, String
+        catch(:fail) do
+          return scope.evaluate(expr, *default)
+        end
+        raise NameError, "Unable to find `#{expr}`"
+      else
+        evaluate(render(expr), *default)
+      end
     end
 
   end # class Dialect