wlang 2.0.0.beta → 2.0.0

data/spec/integration/html/test_question.rb

@@ -3,11 +3,17 @@ 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
 
-    [true, "Something", []].each do |test|
+    [ true,
+      "Something",
+      [],
+      lambda{ true }.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 +24,11 @@ module WLang
       end
     end
 
-    [false, nil].each do |test|
+    [ false,
+      nil,
+      lambda{ false }.extend(debug),
+      lambda{ nil }.extend(debug)
+    ].each do |test|
       context "when #{test.inspect}" do
         it 'do not render the then block' do
           render("?{test}{hello}", binding).should eq("")

data/spec/integration/html/test_sharp.rb

@@ -17,5 +17,9 @@ module WLang
       render('Hello #{scope}{${who}}', binding).should eq("Hello ")
     end
 
+    it 'allows undefined variables' do
+      render('Hello #{scope}{${who}}', binding).should eq("Hello ")
+    end
+
   end
-end
+end

data/spec/integration/html/test_star.rb

@@ -18,9 +18,7 @@ module WLang
     end
 
     it 'preserves spacing in the third block' do
-      pending{
-        render("*{numbers}{+{self}}{, }", binding).should eq("1, 2, 3")
-      }
+      render("*{numbers}{+{self}}{, }", binding).should eq("1, 2, 3")
     end
 
     it 'renders nothing on empty collections' do

data/spec/integration/test_examples.rb

@@ -14,7 +14,8 @@ module WLang
         end
 
         let(:expected) do
-          Path.dir/:examples/ex_file.basename.sub_ext(".txt")
+          from, to = root_folder, Path.dir
+          (to/(ex_file % from)).rm_ext
         end
 
         it 'is instantiated as expected with autospacing' do

data/spec/integration/test_readme.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
-require 'wlang/mustang'
 module WLang
-  describe Mustang do
+  describe "Examples in README.md" do
 
     describe "The Highlighter example" do
 
@@ -52,5 +51,18 @@ module WLang
       end
     end
 
+    describe 'tilt integration' do
+      it 'works as announced' do
+        require 'tilt'         # needed in your bundle, not a wlang dependency
+        require 'wlang/tilt'   # load wlang integration specifycally
+
+        template = Tilt.new(hello_path.to_s)   # suppose 'Hello ${who}!'
+        template.render(:who => "world").should eq('Hello world!')
+
+        template = Tilt.new(hello_path.to_s, :dialect => Highlighter)
+        template.render(:who => "world").should eq('Hello WORLD!')
+      end
+    end
+
   end
 end

data/spec/integration/tilt/test_wlang_template.rb

@@ -0,0 +1,13 @@
+require 'tilt'
+require 'wlang/tilt'
+describe 'WLang integration with tilt' do
+
+  it 'allows invoking tilt directly' do
+    Tilt.new(hello_path.to_s).render(:who => "world").should eq("Hello world!")
+  end
+
+  it 'allows specifying the dialect' do
+    Tilt.new(hello_path.to_s, :dialect => Upcasing).render.should eq("Hello WHO!")
+  end
+
+end

data/spec/spec_helper.rb

@@ -24,7 +24,7 @@ module Helpers
   end
 
   def tpl_path(what)
-    what = "#{what}.tpl" if what.is_a?(Symbol)
+    what = "#{what}.wlang" if what.is_a?(Symbol)
     fixtures_folder/:templates/what
   end
 
@@ -38,7 +38,7 @@ module Helpers
   end
 
   # Install helper methods for templates
-  fixtures_folder.glob("templates/*.tpl").each do |f|
+  fixtures_folder.glob("templates/*.wlang").each do |f|
     name = f.basename.without_extension
     define_method(:"#{name}_path") do
       fixtures_folder/:templates/f.basename
@@ -59,5 +59,5 @@ include Helpers
 # Configure rspec
 RSpec.configure do |c|
   c.include Helpers
-  c.filter_run_excluding :hash_ordering => true if RUBY_VERSION < "1.9"
+  c.filter_run_excluding :hash_ordering => (RUBY_VERSION < "1.9")
 end

data/spec/unit/compiler/test_dialect_enforcer.rb

@@ -12,7 +12,7 @@ module WLang
           tag('!$') do |buf,fn| buf << "!$" end
           tag('*')  do |buf,fn1,fn2|        end
           tag('%', [WLang::Dummy]) do |buf, fn| end
-        }.factor
+        }.new
       }
 
       describe 'find_dispatching_method' do

data/spec/unit/compiler/test_to_ruby_proc.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module WLang
+  describe Compiler, 'to_ruby_proc' do
+
+    def to_ruby_proc(source)
+      Compiler.new(WLang::Dialect.new).to_ruby_proc(source)
+    end
+
+    it 'returns a proc even if no tag at all' do
+      source   = "Hello world!"
+      to_ruby_proc(source).should be_a(Proc)
+    end
+
+  end # describe Compiler, 'to_ruby_proc'
+end # module WLang

data/spec/unit/dialect/test_compile.rb

@@ -20,16 +20,6 @@ module WLang
       end
     end
 
-    it 'supports a no-op' do
-      t = compile(hello_tpl)
-      compile(t).should eq(t)
-    end
-
-    it 'supports a proc' do
-      proc = compile(hello_tpl).inner_proc
-      compile(proc).should be_a(Template)
-    end
-
     specify 'returned template is callable' do
       compile(hello_tpl).call.should eq("Hello WHO!")
     end

data/spec/unit/dialect/test_evaluate.rb

@@ -1,41 +1,49 @@
 require 'spec_helper'
 module WLang
-  class Dialect
-    describe Evaluation, "evaluate" do
-      include Evaluation
+  describe Dialect, 'evaluate' do
 
-      let(:struct){ Struct.new(:who) }
+    let(:struct){ Struct.new(:who) }
 
-      it 'works with a hash' do
-        with_scope({:who => "World"}) do
-          evaluate("who").should eq("World")
-          evaluate(:who).should eq("World")
-        end
-      end
+    let(:dialect){ Dialect.new }
+
+    def with_scope(*args, &bl)
+      dialect.with_scope(*args, &bl)
+    end
+
+    def evaluate(*args, &bl)
+      dialect.evaluate(*args, &bl)
+    end
 
-      it 'works with a struct' do
-        with_scope(struct.new("World")) do
-          evaluate("who").should eq("World")
-          evaluate(:who).should eq("World")
-        end
+    it 'works with a hash' do
+      with_scope({:who => "World"}) do
+        evaluate("who").should eq("World")
+        evaluate(:who).should eq("World")
       end
+    end
 
-      it 'uses the hash in priority' do
-        with_scope({:keys => [1,2,3]}) do
-          evaluate("keys").should eq([1,2,3])
-        end
+    it 'works with a struct' do
+      with_scope(struct.new("World")) do
+        evaluate("who").should eq("World")
+        evaluate(:who).should eq("World")
       end
+    end
 
-      it 'falls back to send' do
-        with_scope({:who => "World"}) do
-          evaluate("keys").should eq([:who])
-        end
+    it 'uses the hash in priority' do
+      with_scope({:keys => [1,2,3]}) do
+        evaluate("keys").should eq([1,2,3])
       end
+    end
 
-      it 'raises a NameError when not found' do
-        lambda{ evaluate("who") }.should raise_error(NameError)
+    it 'falls back to send' do
+      with_scope({:who => "World"}) do
+        evaluate("keys").should eq([:who])
       end
+    end
+
+    it 'raises a NameError when not found' do
+      lambda{ evaluate("who") }.should raise_error(NameError)
+    end
+
+  end # describe Dialect, 'evaluate'
+end # module WLang
 
-    end # describe Evaluation, "evaluate"
-  end # class Dialect
-end # module WLang

data/spec/unit/dialect/test_new.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+module WLang
+  describe Dialect, 'new' do
+
+    let(:base){ Dialect.default_options }
+    let(:template){ Template.new "blah" }
+
+    subject{ Dialect.new(*args) }
+
+    context 'with no arguments' do
+      let(:args){ [] }
+      it 'should have default options' do
+        subject.options.should eq(base)
+      end
+      it 'should not have a template' do
+        subject.template.should be_nil
+      end
+    end
+
+    context 'with only options' do
+      let(:args){ [{:foo => :bar}] }
+      it 'should have merged options' do
+        subject.options.should eq(base.merge(:foo => :bar))
+      end
+      it 'should not have a template' do
+        subject.template.should be_nil
+      end
+    end
+
+    context 'with only a template' do
+      let(:args){ [template] }
+      it 'should have default options' do
+        subject.options.should eq(base)
+      end
+      it 'should not have a template' do
+        subject.template.should eq(template)
+      end
+    end
+
+    context 'with options and a template' do
+      let(:args){ [{:foo => :bar}, template] }
+      it 'should have merged options' do
+        subject.options.should eq(base.merge(:foo => :bar))
+      end
+      it 'should not have a template' do
+        subject.template.should eq(template)
+      end
+    end
+
+    context 'with options and a template in reverse order' do
+      let(:args){ [template, {:foo => :bar}] }
+      it 'should have merged options' do
+        subject.options.should eq(base.merge(:foo => :bar))
+      end
+      it 'should not have a template' do
+        subject.template.should eq(template)
+      end
+    end
+
+  end # describe Dialect, 'new'
+end # module WLang

data/spec/unit/dialect/test_tag.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module WLang
+  describe Dialect, 'tag' do
+
+    let(:dialect){ Class.new(Dialect) }
+
+    before do
+      def dialect.define_tag_method(*args)
+        args
+      end
+    end
+
+    def tag(*args, &bl)
+      dialect.tag(*args, &bl)
+    end
+
+    it "works with a symbol" do
+      tag("$", :dollar).should eq(["$", nil, :dollar])
+    end
+
+    it "works with a single proc" do
+      proc = lambda{|buf,fn| }
+      tag("$", &proc).should eq(["$", nil, proc])
+    end
+
+    it "allows specifying dialects with a symbol" do
+      tag("$", [Foo], :dollar).should eq(["$", [Foo], :dollar])
+    end
+
+    it "allows specifying dialects with a proc" do
+      proc = lambda{|buf,fn| }
+      tag("$", [Foo], &proc).should eq(["$", [Foo], proc])
+    end
+
+  end # describe Dialect
+end # module WLang

data/spec/unit/dialect/test_tag_dispatching_name.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module WLang
+  describe Dialect, 'tag_dispatching_name' do
+
+    def tag_dispatching_name(symbol)
+      Dialect.tag_dispatching_name(symbol)
+    end
+
+    it "works with a single char" do
+      tag_dispatching_name("$").should eq(:_tag_36)
+    end
+
+    it "works with a multiple chars" do
+      tag_dispatching_name("!$").should eq(:_tag_33_36)
+    end
+
+    it "works with an array" do
+      tag_dispatching_name(['!', '$']).should eq(:_tag_33_36)
+    end
+
+  end # describe Dialect
+end # module WLang

data/spec/unit/dialect/test_with_scope.rb

@@ -1,18 +1,15 @@
 require 'spec_helper'
 module WLang
-  class Dialect
-    describe Evaluation, "with_scope" do
-      include Evaluation
+  describe Dialect, 'with_scope' do
 
-      let(:struct){ Struct.new(:who) }
+    let(:struct){ Struct.new(:who) }
 
-      it 'returns the block value' do
-        got = with_scope({:who => "World"}) do
-          12
-        end
-        got.should eq(12)
+    it 'returns the block value' do
+      got = Dialect.new.with_scope({:who => "World"}) do
+        12
       end
+      got.should eq(12)
+    end
 
-    end # describe Evaluation, "with_scope"
-  end # class Dialect
+  end # describe Dialect, 'with_scope'
 end # module WLang

data/spec/unit/scope/test_chain.rb

@@ -0,0 +1,29 @@
+module WLang
+  describe Scope, '.chain' do
+
+    it 'returns Scope.root on empty chain' do
+      Scope.chain([]).should eq(Scope.root)
+    end
+
+    it 'returns a single scope on singleton' do
+      s = Scope.chain([{:who => "World"}])
+      s.should be_a(Scope::ObjectScope)
+      s.parent.should eq(Scope.root)
+    end
+
+    it 'uses the last scope as most specific' do
+      s = Scope.chain([{:who => "World"}, lambda{}])
+      s.should be_a(Scope::ProcScope)
+      s.parent.should be_a(Scope::ObjectScope)
+      s.parent.parent.should eq(Scope.root)
+    end
+
+    it 'strips nils' do
+      s = Scope.chain([nil, {:who => "World"}, nil, lambda{}, nil])
+      s.should be_a(Scope::ProcScope)
+      s.parent.should be_a(Scope::ObjectScope)
+      s.parent.parent.should eq(Scope.root)
+    end
+
+  end
+end

data/spec/unit/scope/test_coerce.rb

@@ -6,8 +6,8 @@ module WLang
       Scope.coerce(binding).should be_a(Scope::BindingScope)
     end
 
-    it 'recognizes Scopes' do
-      Scope.coerce(Scope.root).should be_a(Scope::ProxyScope)
+    it 'recognizes Procs' do
+      Scope.coerce(lambda{}).should be_a(Scope::ProcScope)
     end
 
     it 'falls back to ObjectScope on Hash' do
@@ -18,5 +18,16 @@ module WLang
       Scope.coerce(12).should be_a(Scope::ObjectScope)
     end
 
+    it 'returns the Scope if nothing has to be done' do
+      Scope.coerce(Scope.root).should eq(Scope.root)
+      s = Scope.coerce({})
+      Scope.coerce(s).should eq(s)
+    end
+
+    it 'builds ProxyScope on Scopes' do
+      s = Scope.coerce({})
+      Scope.coerce(s, Scope.root).should be_a(Scope::ProxyScope)
+    end
+
   end # describe Scope
 end # module WLang