wlang 0.10.2 → 2.0.0.beta

data/spec/integration/html/test_caret.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, "^{...}" do
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    [false, nil].each do |test|
+      context "when #{test.inspect}" do
+        it 'renders the then block' do
+          render("^{test}{hello}", binding).should eq("hello")
+        end
+        it 'does not render the else block' do
+          render("^{test}{hello}{otherwise}", binding).should eq("hello")
+        end
+      end
+    end
+
+    [true, "Something", []].each do |test|
+      context "when #{test.inspect}" do
+        it 'do not render the then block' do
+          render("^{test}{hello}", binding).should eq("")
+        end
+        it 'renders the else block if present' do
+          render("^{test}{hello}{otherwise}", binding).should eq("otherwise")
+        end
+      end
+    end
+
+  end
+end

data/spec/integration/html/test_dollar.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, "${...}" do
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    it 'escapes html' do
+      hello = "<script>"
+      render("${hello}", binding).should eq("&lt;script&gt;")
+    end
+
+  end
+end

data/spec/integration/html/test_greater.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, ">{...}" do
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    it 'renders a Template object by default' do
+      who     = "World"
+      partial = Html.compile("${who}")
+      render("Hello >{partial}", binding).should eq("Hello World")
+    end
+
+    it 'compiles a String to a Template' do
+      who     = "World"
+      partial = "${who}"
+      render("Hello >{partial}", binding).should eq("Hello World")
+    end
+
+  end
+end

data/spec/integration/html/test_modulo.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, "%{...}" do
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    it 'disables wlang inside the block' do
+      who = "World"
+      render("%{Hello ${who}!}", binding).should eq("Hello ${who}!")
+    end
+
+  end
+end

data/spec/integration/html/test_plus.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, "+{...}" do
+
+    ToHtml = Struct.new(:to_html)
+    ToS    = Struct.new(:to_s)
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    context "on an aribitraty object" do
+      it 'invokes to_html if it exists' do
+        hello = ToHtml.new("<h1>World</h1>")
+        render("+{hello}", binding).should eq("<h1>World</h1>")
+      end
+      it 'invokes to_s if to_html does not exists' do
+        hello = ToS.new("World")
+        render("+{hello}", binding).should eq("World")
+      end
+      it 'invokes to_s on the result of to_html' do
+        hello = ToHtml.new(ToS.new("<h1>World</h1>"))
+        render("+{hello}", binding).should eq("<h1>World</h1>")
+      end
+    end
+
+    context "on a Template" do
+      it 'renders as a partial' do
+        who   = "World"
+        hello = Html.compile("Hello +{who}")
+        render("+{hello}!", binding).should eq("Hello World!")
+      end
+    end
+
+    context "on a Proc" do
+      it 'calls it if of arity 0' do
+        hello = Proc.new{ "World" }
+        render("+{hello}!", binding).should eq("World!")
+      end
+      it 'it invokes to_html on the result' do
+        hello = Proc.new{ ToHtml.new("World") }
+        render("+{hello}!", binding).should eq("World!")
+      end
+    end
+
+  end
+end

data/spec/integration/html/test_question.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, "?{...}" do
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    [true, "Something", []].each do |test|
+      context "when #{test.inspect}" do
+        it 'renders the then block' do
+          render("?{test}{hello}", binding).should eq("hello")
+        end
+        it 'does not render the else block' do
+          render("?{test}{hello}{otherwise}", binding).should eq("hello")
+        end
+      end
+    end
+
+    [false, nil].each do |test|
+      context "when #{test.inspect}" do
+        it 'do not render the then block' do
+          render("?{test}{hello}", binding).should eq("")
+        end
+        it 'renders the else block if present' do
+          render("?{test}{hello}{otherwise}", binding).should eq("otherwise")
+        end
+      end
+    end
+
+  end
+end

data/spec/integration/html/test_sharp.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, '#{...}' do
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    it 'updates the current scope' do
+      scope = {:who => "World"}
+      render('Hello #{scope}{${who}}', binding).should eq("Hello World")
+    end
+
+    it 'does not follows empty arrays' do
+      scope = []
+      render('Hello #{scope}{${who}}', binding).should eq("Hello ")
+    end
+
+  end
+end

data/spec/integration/html/test_slash.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, '/{...}' do
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    it 'does not render anything' do
+      scope = {:who => "World"}
+      render('Hello /{ a comment } World!', binding).should eq("Hello  World!")
+    end
+
+  end
+end

data/spec/integration/html/test_star.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'wlang/html'
+module WLang
+  describe Html, "*{...}" do
+
+    def render(tpl, scope = {})
+      Html.render(tpl, scope, "")
+    end
+
+    let(:numbers){ [1, 2, 3] }
+
+    it 'renders the main block for each element' do
+      render("*{numbers}{+{self}}", binding).should eq("123")
+    end
+
+    it 'renders the between block if present' do
+      render("*{numbers}{+{self}}{,}", binding).should eq("1,2,3")
+    end
+
+    it 'preserves spacing in the third block' do
+      pending{
+        render("*{numbers}{+{self}}{, }", binding).should eq("1, 2, 3")
+      }
+    end
+
+    it 'renders nothing on empty collections' do
+      empty = []
+      render("*{empty}{+{self}}", binding).should eq("")
+    end
+
+    it 'supports any enumerable' do
+      elms = (1..5)
+      render("*{elms}{+{self}}{,}", binding).should eq("1,2,3,4,5")
+    end
+
+  end
+end

data/spec/integration/test_dummy.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'wlang/dummy'
+module WLang
+  describe Dummy do
+
+  def dummy(tpl, scope = {})
+    Dummy.render(tpl, scope)
+  end
+
+  it 'returns the string when no tag at all' do
+    dummy("Hello world!").should eq("Hello world!")
+  end
+
+  it 'does not evaluate tags' do
+    dummy("Hello ${who}!").should eq("Hello ${who}!")
+  end
+
+  it 'does not eat other blocks either' do
+    dummy("Hello ${who}{ and more}!").should eq("Hello ${who}{ and more}!")
+  end
+
+  it 'keep single braces in peace' do
+    dummy("Hello {who}!").should eq("Hello {who}!")
+  end
+
+  context "documentation" do
+    let(:d){
+      dialect do
+        def dollar(buf, fn)
+          buf << evaluate(fn)
+        end
+        def no_wlang(buf, fn)
+          buf << render(fn)
+        end
+        tag '$', :dollar
+        tag '%', [WLang::Dummy], :no_wlang
+      end
+    }
+    let(:tpl){%q{
+      Hello ${who}! This is wlang, a templating language which comes with
+      special tags such as %{${who}, +{who}, *{authors}{...}, etc.}
+    }.gsub(/^\s*/m,"").strip}
+    let(:expected){%q{
+      Hello world! This is wlang, a templating language which comes with
+      special tags such as ${who}, +{who}, *{authors}{...}, etc.
+    }.gsub(/^\s*/m,"").strip}
+    specify{ d.render(tpl, :who => "world").should eq(expected) }
+  end
+
+  end # describe Dummy
+end # module WLang

data/spec/integration/test_examples.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'wlang/command'
+module WLang
+  describe "The examples", :hash_ordering => true do
+
+    (root_folder/:examples).glob("**/*.*").each do |ex_file|
+      next if ex_file.basename.to_s == "README.md"
+      describe "the example file #{ex_file}" do
+
+        let(:command) do
+          cmd = WLang::Command.new
+          def cmd.with_output(&proc); proc.call(""); end
+          cmd
+        end
+
+        let(:expected) do
+          Path.dir/:examples/ex_file.basename.sub_ext(".txt")
+        end
+
+        it 'is instantiated as expected with autospacing' do
+          got = command.run ["--auto-spacing", ex_file]
+          got.should eq(expected.read)
+        end
+
+      end
+    end
+
+  end
+end

data/spec/integration/test_mustang.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'wlang/mustang'
+module WLang
+  describe Mustang do
+
+    def m(tpl, scope = {}, buffer = "")
+      Mustang.render(tpl, scope, buffer)
+    end
+
+    context '+{...} mimicing {{{ ... }}}' do
+      it "renders nothing on nil" do
+        m('Hello +{who}', :who => nil).should eq("Hello ")
+      end
+      it "renders nothing on unknown" do
+        m('Hello +{who}', {}).should eq("Hello ")
+      end
+      it "renders the variable if known" do
+        m('Hello +{who}', :who => "World").should eq("Hello World")
+      end
+      it "calls to_s on such variable" do
+        m('Hello +{who}', :who => 12).should eq("Hello 12")
+      end
+      it "does not escape html" do
+        m('Hello +{who}', :who => "<script>").should eq("Hello <script>")
+      end
+    end
+
+    context "${...} mimicing {{ ... }}" do
+      it "renders nothing on nil" do
+        m('Hello ${who}', :who => nil).should eq("Hello ")
+      end
+      it "renders nothing on unknown" do
+        m('Hello ${who}', {}).should eq("Hello ")
+      end
+      it "renders the variable if known" do
+        m('Hello ${who}', :who => "World").should eq("Hello World")
+      end
+      it "calls to_s on such variable" do
+        m('Hello ${who}', :who => 12).should eq("Hello 12")
+      end
+      it "does escape html" do
+        m('Hello ${who}', :who => "<script>").should eq("Hello &lt;script&gt;")
+      end
+    end
+
+    context '#{..1..}{..2..} mimicing {{#..1..}}..2..{{/..1..}} ' do
+      it 'skips the section on false' do
+        m('Hello #{present}{World}', :present => false).should eq("Hello ")
+      end
+      it 'skips the section on nil' do
+        m('Hello #{present}{World}', :present => nil).should eq("Hello ")
+      end
+      it 'skips the section on missing' do
+        m('Hello #{present}{World}').should eq("Hello ")
+      end
+      it 'skips the section on empty lists' do
+        m('Hello #{present}{World}', :present => []).should eq("Hello ")
+      end
+      it 'iterates on non-empty lists' do
+        repo = [{:name => "resque"},{:name => "hub"},{:name => "rip"}]
+        m('Hello #{repo}{<b>${name}</b>}', :repo => repo).should eq("Hello <b>resque</b><b>hub</b><b>rip</b>")
+      end
+      it 'iterates on ranges' do
+        m('Hello #{range}{.}', :range => 1..10).should eq("Hello ..........")
+      end
+      it 'passes the block to a lambda' do
+        wrapped = lambda{|fn| "<b>#{fn.call}</b>"}
+        scope   = {:wrapped => wrapped, :name => "World"}
+        m('#{wrapped}{Hello ${name}}', scope).should eq("<b>Hello World</b>")
+      end
+      it 'use a Hash a a new scope' do
+        m('Hello #{person}{${name}}', :person => {:name => "World"}).should eq("Hello World")
+      end
+      it 'use a Struct a a new scope' do
+        person = Struct.new(:name).new("World")
+        m('Hello #{person}{${name}}', :person => person).should eq("Hello World")
+      end
+      it 'outputs frequently when iterating' do
+        m('#{range}{.}', {:range => 1..10}, []).should eq(Array.new(10, '.'))
+      end
+    end
+
+    context "^{..1..}{..2..} mimicing {{^..1..}}..2..{{/..1..}}" do
+      it 'renders the section on false' do
+        m('Hello ^{missing}{World}', :missing => false).should eq("Hello World")
+      end
+      it 'renders the section on nil' do
+        m('Hello ^{missing}{World}', :missing => nil).should eq("Hello World")
+      end
+      it 'renders the section on missing' do
+        m('Hello ^{missing}{World}').should eq("Hello World")
+      end
+      it 'renders the section on empty lists' do
+        m('Hello ^{missing}{World}', :missing => []).should eq("Hello World")
+      end
+      it 'does not iterate lists' do
+        repo = [{:name => "resque"},{:name => "hub"},{:name => "rip"}]
+        m('Hello ^{repo}{<b>${name}</b>}', :repo => repo).should eq("Hello ")
+      end
+    end
+
+    context "!{...} mimicing {{!...}}" do
+      it 'skips the section altogether' do
+        m('Hello !{this is a comment} world').should eq("Hello  world")
+      end
+    end
+
+    context '>{...} mimicing {{>...}}' do
+      it 'renders the partial' do
+        scope = {:who => "<b>${name}</b>", :name => "World"}
+        m("Hello >{who}", scope).should eq("Hello <b>World</b>")
+      end
+      it 'supports a pre-compiled partial' do
+        scope = {:who => Mustang.compile("<b>${name}</b>"), :name => "World"}
+        m("Hello >{who}", scope).should eq("Hello <b>World</b>")
+      end
+    end
+
+  end # describe Mustang
+end # module WLang