wlang 0.10.2 → 2.0.0.beta

data/spec/integration/test_readme.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'wlang/mustang'
+module WLang
+  describe Mustang do
+
+    describe "The Highlighter example" do
+
+      class Highlighter < WLang::Dialect
+
+        def highlight(buf, fn)
+          var_name  = render(fn)
+          var_value = evaluate(var_name)
+          buf << var_value.to_s.upcase
+        end
+
+        tag '$', :highlight
+      end
+
+      it 'works as announced' do
+        expected = "Hello YOU & THE WORLD!"
+        got      = Highlighter.render "Hello ${who}!", :who => "you & the world"
+        got.should eq(expected)
+      end
+
+    end # Highlighter example
+
+    describe "the HighLevel example" do
+
+      class HighLevel < WLang::Dialect
+
+        def join(buf, expr, main, between)
+          evaluate(expr).each_with_index do |val,i|
+            buf << render(between, val) unless i==0
+            buf << render(main, val).strip
+          end
+        end
+
+        def print(buf, fn)
+          buf << evaluate(fn).to_s
+        end
+
+        tag '*', :join
+        tag '$', :print
+      end
+
+      it 'works as announced' do
+        expected = "Hello you and wlang and world !"
+        template = 'Hello *{ ${collection} }{ ${self} }{ and } !'
+        context  = {:collection => 'whos', :whos => [ "you", "wlang", "world" ] }
+        got = HighLevel.render template, context
+        got.should eq(expected)
+      end
+    end
+
+  end
+end

data/spec/integration/test_upcasing.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module WLang
+  describe Upcasing do
+
+  def upcasing(tpl, scope = {})
+    Upcasing.render(tpl, scope)
+  end
+
+  it 'upcases the string under $' do
+    upcasing("Hello ${world}!").should eq("Hello WORLD!")
+  end
+
+  it 'evaluates the string under #' do
+    upcasing('Hello #{who}!', :who => "World").should eq("Hello World!")
+  end
+
+  it 'raises when not found' do
+    lambda{ upcasing('Hello #{who}!') }.should raise_error(NameError)
+  end
+
+  end # describe Dummy
+end # module WLang

data/spec/spec_helper.rb

@@ -1,2 +1,63 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'epath'
+$root_folder ||= Path.backfind('.[Rakefile]')
+
+# Require wlang
+$LOAD_PATH.unshift(($root_folder/:lib).to_s)
 require 'wlang'
+
+# RSpec helpers
+require 'rspec'
+module Helpers
+  include WLang
+  extend(self)
+
+  def root_folder
+    $root_folder
+  end
+
+  def spec_folder
+    root_folder/:spec
+  end
+
+  def fixtures_folder
+    spec_folder/:fixtures
+  end
+
+  def tpl_path(what)
+    what = "#{what}.tpl" if what.is_a?(Symbol)
+    fixtures_folder/:templates/what
+  end
+
+  def tpl(what)
+    tpl_path(what).read
+  end
+
+  # Load fixture dialects
+  spec_folder.glob("fixtures/dialect/*.rb").each do |f|
+    require f.expand_path
+  end
+
+  # Install helper methods for templates
+  fixtures_folder.glob("templates/*.tpl").each do |f|
+    name = f.basename.without_extension
+    define_method(:"#{name}_path") do
+      fixtures_folder/:templates/f.basename
+    end
+    define_method(:"#{name}_tpl") do
+      send(:"#{name}_path").read
+    end
+    define_method(:"#{name}_io") do |&b|
+      send(:"#{name}_path").open("r") do |io|
+        b.call(io)
+      end
+    end
+  end
+
+end
+include Helpers
+
+# Configure rspec
+RSpec.configure do |c|
+  c.include Helpers
+  c.filter_run_excluding :hash_ordering => true if RUBY_VERSION < "1.9"
+end

data/spec/test_wlang.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../spec_helper', __FILE__)
+describe WLang do
+
+  it "has a version number" do
+    WLang.const_defined?(:VERSION).should be_true
+  end
+
+  let(:d){
+    WLang::dialect do
+      tag('$') do |buf, fn|
+        if x = evaluate(fn)
+          buf << x.to_s
+        end
+      end
+    end
+  }
+
+  it 'allows building on-the-fly dialects' do
+    d.render(hello_tpl, :who => "world").should eq("Hello world!")
+  end
+
+  ### overriding
+
+  it 'allows overriding super-dialect tags' do
+    e = WLang::dialect(d) do
+      tag('$') do |buf, fn1|
+        buf << render(fn1).capitalize
+      end
+    end
+    e.render(hello_tpl).should eq("Hello Who!")
+  end
+
+  it 'allows overriding super-dialect evaluation rules' do
+    e = WLang::dialect(d) do
+      def evaluate(expr); super rescue ""; end
+    end
+    e.render(hello_tpl).should eq("Hello !")
+  end
+
+  it 'does not override the super-dialect evaluation rules' do
+    e = WLang::dialect(d) do
+      def evaluate(expr); super rescue ""; end
+    end
+    lambda{ d.render(hello_tpl) }.should raise_error(NameError)
+  end
+
+  ### default scoping
+
+  it 'allows a hash for scoping by default' do
+    d.render(hello_tpl, :who => "World").should eq("Hello World!")
+  end
+
+  it 'allows binding for scoping by default' do
+    who = "World"
+    d.render(hello_tpl, binding).should eq("Hello World!")
+  end
+
+  ### high-order and multi-dialects
+
+  it 'allows high-order constructions' do
+    scope = {:who => :world, :world => "World"}
+    d.render('Hello ${${who}}!', scope).should eq("Hello World!")
+  end
+
+  it 'allows switching the current dialect' do
+    e = WLang::dialect do
+      tag '!', [Upcasing] do |buf,fn|
+        buf << evaluate(fn).to_s;
+      end
+    end
+    scope = {:WHO => "World"}
+    e.render('Hello !{${who}}!', scope).should eq("Hello World!")
+  end
+
+  ### autospacing
+
+  it 'handles magic spacing on a static block' do
+    e = WLang::dialect do
+      default_options :autospacing => true
+      tag '$' do |buf,fn| buf << render(fn) end
+    end
+    source   = "${\n  hello world\n}"
+    expected = "hello world"
+    pending{
+      e.render(source).should eq(expected)
+    }
+  end
+
+  it 'handles magic spacing on a wlang block' do
+    e = WLang::dialect do
+      default_options :autospacing => true
+      tag '$' do |buf,fn| buf << render(fn) end
+    end
+    source   = "${\n  ${name}\n  ${score}\n}"
+    expected = "name\nscore"
+    pending{
+      e.render(source).should eq(expected)
+    }
+  end
+
+end

data/spec/unit/compiler/autospacing/test_right_strip.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module WLang
+  class Compiler
+    describe Autospacing::RightStrip do
+
+      def optimize(source)
+        Autospacing::RightStrip.new.call(source)
+      end
+
+      it 'does not touch single line statics' do
+        source   = [:static, "Hello World"]
+        expected = [:static, "Hello World"]
+        optimize(source).should eq(expected)
+      end
+
+      it 'strips at right on :static' do
+        source   = [:static, "Hello World  \n  "]
+        expected = [:static, "Hello World"]
+        optimize(source).should eq(expected)
+      end
+
+      it 'strips the right-most :static on :strconcat' do
+        source   = [:strconcat, [:static, "Hello  \n"], [:static, "  World\n"]]
+        expected = [:strconcat, [:static, "Hello  \n"], [:static, "  World"]]
+        optimize(source).should eq(expected)
+      end
+
+    end # describe Autospacing::RightStrip
+  end # class Compiler
+end # module WLang

data/spec/unit/compiler/autospacing/test_unindent.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module WLang
+  class Compiler
+    describe Autospacing::Unindent do
+
+      def optimize(source)
+        Autospacing::Unindent.new.call(source)
+      end
+
+      it 'unindents :static' do
+        source   = [:static, "  Hello World"]
+        expected = [:static, "Hello World"]
+        optimize(source).should eq(expected)
+      end
+
+      it 'unindents :static when multiple lines' do
+        source   = [:static, "  Hello\n  World"]
+        expected = [:static, "Hello\nWorld"]
+        optimize(source).should eq(expected)
+      end
+
+      it 'recurses on :strconcat' do
+        source   = [:strconcat, [:static, "  Hello"], [:static, "  World"]]
+        expected = [:strconcat, [:static, "Hello"], [:static, "World"]]
+        optimize(source).should eq(expected)
+      end
+
+    end # describe Autospacing::Unindent
+  end # class Compiler
+end # module WLang

data/spec/unit/compiler/test_dialect_enforcer.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+module WLang
+  class Compiler
+    class DialectEnforcer
+      public :find_dispatching_method
+    end
+    describe DialectEnforcer do
+
+      let(:dialect){
+        WLang::dialect{
+          tag('$')  do |buf,fn| buf << "$"  end
+          tag('!$') do |buf,fn| buf << "!$" end
+          tag('*')  do |buf,fn1,fn2|        end
+          tag('%', [WLang::Dummy]) do |buf, fn| end
+        }.factor
+      }
+
+      describe 'find_dispatching_method' do
+        let(:e){ DialectEnforcer.new(:dialect => dialect) }
+        it 'works on exact matching' do
+          e.find_dispatching_method("$").should eq(['', :_tag_36])
+        end
+        it 'takes the most specific' do
+          e.find_dispatching_method("$").should eq(['', :_tag_36])
+          e.find_dispatching_method("!$").should eq(['', :_tag_33_36])
+        end
+        it 'recognizes extras' do
+          e.find_dispatching_method("@$").should eq(['@', :_tag_36])
+          e.find_dispatching_method("@!$").should eq(['@', :_tag_33_36])
+        end
+        it 'recognizes missings' do
+          e.find_dispatching_method("#").should eq(['#', nil])
+          e.find_dispatching_method("@#").should eq(['@#', nil])
+        end
+      end
+
+      def optimize(source)
+        DialectEnforcer.new(:dialect => dialect).call(source)
+      end
+
+      let(:unknown){[
+        [:wlang, '!', [:fn, [:static, "hello"]]],
+        [:strconcat, [:static, "!"], [:static, "{"], [:static, "hello"], [:static, "}"]]
+      ]}
+      let(:hello_fn){[
+        [:fn, unknown.first],
+        [:fn, unknown.last]
+      ]}
+      let(:hello_dollar){[
+        [:wlang, '$', hello_fn.first],
+        [:wlang, '$', hello_fn.last]
+      ]}
+
+      ### recursion rules
+
+      it 'recurses on template' do
+        source   = [:template, hello_dollar.first]
+        expected = [:template, hello_dollar.last]
+        optimize(source).should eq(expected)
+      end
+
+      it 'leaves [:static, ...] unchanged' do
+        source = [:static, "Hello world"]
+        optimize(source).should eq(source)
+      end
+
+      it 'leaves [:strconcat, ...] unchanged if no tag' do
+        source = [:strconcat, [:static, "Hello "], [:static, "world"]]
+        optimize(source).should eq(source)
+      end
+
+      it 'recurses on [:strconcat, ...] to optimize further' do
+        source   = [:strconcat, unknown.first]
+        expected = [:strconcat, unknown.last]
+        optimize(source).should eq(expected)
+      end
+
+      ### exact symbols
+
+      it 'optimizes on exact symbols' do
+        optimize(hello_dollar.first).should eq(hello_dollar.last)
+      end
+
+      it 'detects extra symbols' do
+        source   = [:wlang, '@$', hello_fn.first]
+        expected = [:strconcat, [:static, "@"], hello_dollar.last]
+        optimize(source).should eq(expected)
+      end
+
+      ### unknown tags
+
+      it 'recognizes unknown tags' do
+        optimize(unknown.first).should eq(unknown.last)
+      end
+
+      it 'recognizes unknown tags even if enclosed' do
+        source   = [:wlang, '$', [:fn, unknown.first]]
+        expected = [:wlang, '$', [:fn, unknown.last]]
+        optimize(source).should eq(expected)
+      end
+
+      ### high-order wlang
+
+      it 'applies dynamic dispatching on high-order wlang' do
+        source   = [:wlang, '$', [:fn, hello_dollar.first]]
+        expected = [:wlang, '$', [:fn, hello_dollar.last]]
+        optimize(source).should eq(expected)
+      end
+
+      ### arity 2
+
+      it 'supports tags of arity 2' do
+        source   = [:wlang, '*', hello_fn.first, hello_fn.first]
+        expected = [:wlang, '*', hello_fn.last, hello_fn.last]
+        optimize(source).should eq(expected)
+      end
+
+      ### missing blocks
+
+      it 'detects missing blocks on arity 1' do
+        source   = [:wlang, '$']
+        expected = [:wlang, '$', [:arg, nil]]
+        optimize(source).should eq(expected)
+      end
+
+      it 'detects missing blocks on arity 2' do
+        source   = [:wlang, '*', hello_fn.first]
+        expected = [:wlang, '*', hello_fn.last, [:arg, nil]]
+        optimize(source).should eq(expected)
+      end
+
+      ### trailing blocks
+
+      it 'detects trailing blocks' do
+        source   = [:wlang, '$', hello_fn.first, hello_fn.first]
+        expected = \
+          [:strconcat,
+            [:wlang, '$', hello_fn.last],
+            [:static, '{'],
+            hello_fn.last.last,
+            [:static, '}']
+          ]
+        optimize(source).should eq(expected)
+      end
+
+      it 'detects trailing blocks on arity 2' do
+        source   = [:wlang, '*', hello_fn.first, hello_fn.first, hello_fn.first]
+        expected = \
+          [:strconcat,
+            [:wlang, '*', hello_fn.last, hello_fn.last],
+            [:static, '{'],
+            hello_fn.last.last,
+            [:static, '}']
+          ]
+        optimize(source).should eq(expected)
+      end
+
+      ### dialect switching
+
+      it 'introduce dialect switching mechanism' do
+        source   = [:wlang, '%', hello_fn.first]
+        expected = [:wlang, '%', [:modulo, WLang::Dummy, hello_fn.last]]
+        optimize(source).should eq(expected)
+      end
+
+    end # describe DialectEnforcer
+  end # class Compiler
+end # module WLang