wlang 2.0.0.beta → 2.0.0

data/lib/wlang/html.rb

@@ -5,8 +5,8 @@ module WLang
 
     module Helpers
 
-      def value_of(fn)
-        evaluate(render(fn).to_s.strip)
+      def value_of(fn, *defaults)
+        evaluate(render(fn).to_s.strip, *defaults)
       end
       private :value_of
 
@@ -56,13 +56,14 @@ module WLang
       end
 
       def question(buf, fn_if, fn_then, fn_else)
-        val = value_of(fn_if) ? fn_then : fn_else
-        render(val, nil, buf) if val
+        val   = value_of(fn_if)
+        val   = val.call if Proc===val
+        block = val ? fn_then : fn_else
+        render(block, nil, buf) if block
       end
 
       def caret(buf, fn_if, fn_then, fn_else)
-        val = value_of(fn_if) ? fn_else : fn_then
-        render(val, nil, buf) if val
+        question(buf, fn_if, fn_else, fn_then)
       end
 
       def star(buf, coll_fn, elm_fn, between_fn)
@@ -75,12 +76,12 @@ module WLang
 
       def greater(buf, fn)
         val = value_of(fn)
-        val = Html.compile(val) unless Template === val
+        val = Html.compile(val) if String === val
         render(val, nil, buf)
       end
 
       def sharp(buf, who_fn, then_fn)
-        val = value_of(who_fn)
+        val = value_of(who_fn, nil)
         if val and not(val.respond_to?(:empty?) and val.empty?)
           render(then_fn, val, buf)
         end

data/lib/wlang/loader.rb

@@ -1,6 +1,4 @@
 require "citrus"
 require "temple"
-if RUBY_VERSION < "1.9"
-  require 'backports'
-  require "backports/basic_object" unless defined?(BasicObject)
-end
+require "quickl"
+require "epath"

data/lib/wlang/scope.rb

@@ -12,18 +12,26 @@ module WLang
       @root ||= RootScope.new
     end
 
-    def self.coerce(arg, parent = root)
+    def self.coerce(arg, parent = nil)
+      return arg if Scope===arg && parent.nil?
+      parent ||= root
       clazz = case arg
-      when Binding
-        BindingScope
-      when Scope
-        ProxyScope
-      else
-        ObjectScope
-      end
+              when Binding
+                BindingScope
+              when Scope
+                ProxyScope
+              when Proc
+                ProcScope
+              else
+                ObjectScope
+              end
       clazz.new(arg, parent)
     end
 
+    def self.chain(scopes)
+      scopes.compact.inject(nil){|parent,child| Scope.coerce(child, parent)} || root
+    end
+
     def push(x)
       Scope.coerce(x, self)
     end
@@ -55,3 +63,4 @@ require 'wlang/scope/root_scope'
 require 'wlang/scope/proxy_scope'
 require 'wlang/scope/object_scope'
 require 'wlang/scope/binding_scope'
+require 'wlang/scope/proc_scope'

data/lib/wlang/scope/proc_scope.rb

@@ -0,0 +1,18 @@
+module WLang
+  class Scope
+    class ProcScope < Scope
+
+      def fetch(key, &blk)
+        Scope.coerce(subject.call).fetch(key) do
+          parent.fetch(key, &blk)
+        end
+      end
+
+      def inspect
+        subject.inspect
+      end
+      alias :to_s :inspect
+
+    end # class ProcScope
+  end # class Scope
+end # module WLang

data/lib/wlang/source.rb

@@ -0,0 +1,56 @@
+module WLang
+  class Source
+
+    attr_reader :subject
+    attr_reader :template
+
+    def initialize(subject, template = nil)
+      @subject  = subject
+      @template = template
+      @locals   = {}
+    end
+
+    def path
+      find_on_subject(:path, :to_path)
+    end
+    alias :to_path :path
+
+    def locals
+      @locals
+    end
+
+    def raw_content
+      find_on_subject(:read, :to_str){
+        raise ArgumentError, "Invalid template source `#{subject}`"
+      }
+    end
+
+    def template_content
+      raw_content
+    end
+
+    def to_str
+      template_content
+    end
+    alias :to_s :to_str
+
+    def with_front_matter(enabled = true)
+      enabled ? FrontMatter.new(self, template) : self
+    end
+
+    private
+
+      def find_on_subject(*methods)
+        s = subject
+        if meth = methods.find{|m| s.respond_to?(m) }
+          subject.send(meth)
+        elsif block_given?
+          yield
+        else
+          nil
+        end
+      end
+
+  end # class Source
+end # module WLang
+require 'wlang/source/front_matter'

data/lib/wlang/source/front_matter.rb

@@ -0,0 +1,51 @@
+module WLang
+  class Source
+    class FrontMatter < Source
+
+      def initialize(*args, &block)
+        super
+        compile
+      end
+
+      def locals
+        @locals
+      end
+
+      def template_content
+        @template_content
+      end
+
+      private
+
+        def compiler
+          template.compiler
+        end
+
+        def compile
+          raw = raw_content
+          if raw =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+            @locals, @template_content = {}, $'
+
+            require 'yaml'
+            yaml = YAML::load($1)
+
+            # append explicit locals
+            @locals.merge!(yaml.delete("locals") || {})
+
+            # compile explicit partials
+            partials = yaml.delete("partials") || {}
+            partials.each_pair do |k,tpl|
+              @locals[k] = compiler.to_ruby_proc(tpl)
+            end
+
+            # append remaining data
+            @locals.merge!(yaml) unless yaml.empty?
+          else
+            @locals = {}
+            @template_content = raw
+          end
+        end
+
+    end
+  end
+end

data/lib/wlang/template.rb

@@ -1,25 +1,63 @@
 module WLang
   class Template
 
-    attr_reader :dialect, :inner_proc
-
-    def initialize(dialect, inner_proc)
-      @dialect    = dialect
-      @inner_proc = inner_proc
-    end
-
-    def call(scope = {}, buffer = '')
-      case i = inner_proc
-      when String
-        buffer << i
-      else
-        @dialect.dup.tap do |d|
-          d.send(:render, i, scope, buffer)
-        end
-        buffer
-      end
+    # Compilation options for the template, as initially passed to `new`
+    attr_reader :options
+
+    # The dialect class to use
+    attr_reader :dialect
+
+    # The underlying template compiler
+    attr_reader :compiler
+
+    # Creates a template instance
+    def initialize(source, options = {})
+      @options          = options
+      @dialect          = @options.delete(:dialect) || WLang::Html
+      @dialect_instance = @dialect.new(options, self)
+      @compiler         = Compiler.new(dialect_instance)
+      @source           = Source.new(source, self).with_front_matter(yaml_front_matter?)
+      @compiled         = to_ruby_proc
+    end
+
+    def path
+      @options[:path] || @source.path
+    end
+
+    def locals
+      @source.locals
+    end
+
+    def template_content
+      @source.template_content
+    end
+
+    def to_ruby_proc
+      compiler.to_ruby_proc(template_content)
+    end
+
+    def to_ruby_code
+      compiler.to_ruby_code(template_content)
+    end
+
+    def to_ast
+      compiler.to_ast(template_content)
+    end
+
+    def call(locs = {}, buffer = '')
+      scope = WLang::Scope.chain([locals, locs])
+      dialect_instance.dup.render compiled, scope, buffer
     end
     alias :render :call
 
+    private
+
+      attr_reader :source, :compiled, :dialect_instance
+
+      def yaml_front_matter?
+        opt = options[:yaml_front_matter]
+        opt.nil? or opt
+      end
+
   end # class Template
 end # module WLang

data/lib/wlang/tilt.rb

@@ -0,0 +1,3 @@
+require 'wlang' unless defined?(WLang)
+require 'tilt'  unless defined?(Tilt)
+require 'wlang/tilt/wlang_template'

data/lib/wlang/tilt/wlang_template.rb

@@ -0,0 +1,43 @@
+module Tilt
+  class WLangTemplate < ::Tilt::Template
+
+    class << self
+
+      def engine_initialized?
+        defined? ::WLang
+      end
+
+      def with_options(options)
+        Class.new(WLangTemplate).tap{|c| c.default_options = options }
+      end
+
+      def default_options=(options)
+        @default_options = options
+      end
+
+      def default_options
+        (superclass.default_options rescue {}).merge(@default_options || {})
+      end
+
+    end
+
+    def initialize_engine
+      require_template_library('wlang')
+    end
+
+    protected
+
+      def prepare
+        opts = self.class.default_options.merge(self.options)
+        opts.merge!(:path => file) if file
+        @engine = WLang::Template.new(data, opts)
+      end
+
+      def evaluate(scope, locals, &block)
+        locals[:yield] = block if block
+        @engine.render WLang::Scope.chain([scope, locals])
+      end
+
+  end
+  register WLangTemplate, 'wlang'
+end

data/lib/wlang/version.rb

@@ -4,10 +4,9 @@ module WLang
     MAJOR = 2
     MINOR = 0
     TINY  = 0
-    BETA  = "beta"
 
     def self.to_s
-      [ MAJOR, MINOR, TINY, BETA ].join('.')
+      [ MAJOR, MINOR, TINY ].join('.')
     end
 
   end

data/spec/fixtures/templates/hello_with_data.wlang

@@ -0,0 +1,4 @@
+---
+who: world
+---
+Hello ${who}!

data/spec/fixtures/templates/hello_with_explicit_locals.wlang

@@ -0,0 +1,6 @@
+---
+who: world
+locals:
+  who_else: wlang
+---
+Hello ${who} and ${who_else}!

data/spec/fixtures/templates/hello_with_partials.wlang

@@ -0,0 +1,7 @@
+---
+locals:
+  who_else: wlang
+partials:
+  who: world and ${who_else}
+---
+Hello >{who}!

data/spec/integration/examples/{1-basics.txt → 1-html-intro/1-basics.md}

@@ -60,6 +60,6 @@ The last useful tag allows you to simply disable wlang rendering in specific tem
 
 For instance, the following template renders the block text unchanged, even if it contains wlang tags:
 
-     Hello ${struct.name}, how are you?
+     Hello ${struct.name}, how are you? 
 
 This is especially useful for writing blog posts explaining wlang, using wlang itself. Therefore, it is a feature mostly needed by me ;-)

data/spec/integration/examples/{2-imperative.txt → 1-html-intro/2-imperative.md}

@@ -46,6 +46,6 @@ For instance,
 
 Renders an HTML list with the authors names. A separator can be specified through the third optional block:
 
-    Bernard,Louis
+    Bernard, Louis
 
 Will render 'Bernard, Louis'.

data/spec/integration/examples/{4-recursion.txt → 1-html-intro/4-recursion.md}

@@ -1,6 +1,6 @@
 Now that we know how to use partials, one might ask how to render a menu in a recursive way. For this, we only need another tag for explicitely manipulating the scope.
 
-* sharp (#) renders its second block, in the scope of the value evaluated in first block
+* sharp (#) renders its second block, in the scope of the value evaluated in first block, provided the later is not nil, undefined or empty
 
 For the example above, our menu rendering is initiated as follows:
     <ul>
@@ -13,4 +13,3 @@ For the example above, our menu rendering is initiated as follows:
 </ul>
 </ul>
 
-Note that it is important to keep empty menus in the source data to avoid infinite recursions due the parent scope that already binds a value under `menu`.

data/spec/integration/examples/1-html-intro/5-polymorphism.md

@@ -0,0 +1,17 @@
+Sometimes, you want to apply polymorphism to your templates; this it is really easy to do in wlang thanks to its high-order constructions.
+
+For example, assume that you iterate some data and want render a partial in a polymorphism way, that is, selecting the partial according to some type, here the shape of the current iterated component. This is really simple:
+
+    <ul>
+      <li> Hello [] of width 10cm </li>
+      <li> Hello () of diameter 25cm </li>
+    </ul>
+
+Which gives the following result:
+
+    <ul>
+      <li> Hello [] of width 10cm </li>
+      <li> Hello () of diameter 25cm <li>
+    </ul>
+
+Great, isn't?

data/spec/integration/html/test_caret.rb

@@ -3,11 +3,18 @@ require 'wlang/html'
 module WLang
   describe Html, "^{...}" do
 
+    debug = Module.new{ def inspect; "lambda{ #{call.inspect} }"; end }
+
     def render(tpl, scope = {})
       Html.render(tpl, scope, "")
     end
 
-    [false, nil].each do |test|
+    [
+      false,
+      nil,
+      lambda{ nil   }.extend(debug),
+      lambda{ false }.extend(debug)
+    ].each do |test|
       context "when #{test.inspect}" do
         it 'renders the then block' do
           render("^{test}{hello}", binding).should eq("hello")
@@ -18,7 +25,13 @@ module WLang
       end
     end
 
-    [true, "Something", []].each do |test|
+    [
+      true,
+      "Something",
+      [],
+      lambda{ true }.extend(debug),
+      lambda{ "something" }.extend(debug)
+    ].each do |test|
       context "when #{test.inspect}" do
         it 'do not render the then block' do
           render("^{test}{hello}", binding).should eq("")