wlang 2.0.0.beta → 2.0.0

data/spec/unit/scope/test_proc_scope.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module WLang
+  class Scope
+    describe ProcScope do
+
+      it 'implements fetch through call.xxx' do
+        scope = Scope.coerce(lambda{ {:who => "World"} })
+        scope.fetch(:who).should eq("World")
+      end
+
+      it 'delegates fetch to its parent when not found' do
+        scope = Scope.coerce(lambda{ nil }, Scope.coerce({:who => "World"}))
+        scope.fetch(:who).should eq("World")
+      end
+
+    end # describe ProcScope
+  end # class Scope
+end # module WLang

data/spec/unit/source/front_matter/test_locals.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module WLang
+  class Source
+    describe FrontMatter, "locals" do
+
+      let(:template){ nil }
+
+      subject{ FrontMatter.new(source, template).locals }
+
+      context 'without front matter' do
+        let(:source){ "Hello world!" }
+        it{ should eq({}) }
+      end
+
+      describe 'with a front matter' do
+        let(:source){ "---\nlocals:\n  x: 2\n---\nHello world!" }
+        specify 'it decode the YAML data' do
+          subject.should eq({"x" => 2})
+        end
+      end
+
+      describe 'with a front matter containing partials' do
+        let(:template){
+          tpl_class = Struct.new(:compiler)
+          tpl_class.new(Object.new.extend(Module.new{
+            def to_ruby_proc(tpl)
+              tpl.upcase
+            end
+          }))
+        }
+        let(:source){ "---\npartials:\n  x: abc\n---\nHello world!" }
+        specify 'it should have correct locals' do
+          subject.should eq({"x" => 'ABC'})
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/source/front_matter/test_template_content.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module WLang
+  class Source
+    describe FrontMatter, "template_content" do
+
+      subject{ FrontMatter.new(source).template_content }
+
+      context 'without front matter' do
+        let(:source){ "Hello world!" }
+        it{ should eq(source) }
+      end
+
+      describe 'with a front matter' do
+        let(:source){ "---\nlocals:\n  x: 2\n---\nHello world!" }
+        specify 'it should not return the front matter itself' do
+          subject.should eq("Hello world!")
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/source/test_locals.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module WLang
+  describe Source, 'locals' do
+
+    subject{ Source.new("Hello world").locals }
+
+    it 'is empty by default' do
+      subject.should eq({})
+    end
+
+  end
+end

data/spec/unit/source/test_path.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module WLang
+  describe Source, "path" do
+    
+    subject{ Source.new(source).path }
+
+    context 'on a pure string' do
+      let(:source){ "Hello world!" }
+      it{ should be_nil }
+    end
+
+    context 'on a Path' do
+      let(:source){ Path.here }
+      it{ should eq(source.to_s) }
+    end
+
+    context 'on a File' do
+      let(:source){ File.open(Path.here.to_s) }
+      it{ should eq(__FILE__) }
+    end
+
+    it 'is aliased as to_path' do
+      Source.new(Path.here).to_path.should eq(__FILE__)
+    end
+
+  end
+end

data/spec/unit/source/test_template_content.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module WLang
+  describe Source, "template_content" do
+    
+    subject{ Source.new(source).template_content }
+
+    context 'on a pure string' do
+      let(:source){ "Hello world!" }
+      it{ should eq(source) }
+    end
+
+    context 'on a Path' do
+      let(:source){ hello_path }
+      it{ should eq(hello_path.read) }
+    end
+
+    context 'on a File' do
+      let(:source){ File.open(Path.here.to_s) }
+      it{ should eq(File.read(__FILE__)) }
+    end
+
+    it 'also works on an IO' do
+      hello_io do |io|
+        Source.new(io).template_content.should eq(hello_path.read)
+      end
+    end
+
+    it 'is aliased as to_s' do
+      Source.new("raw text").to_s.should eq("raw text")
+    end
+
+    it 'is aliased as to_str' do
+      Source.new("raw text").to_str.should eq("raw text")
+    end
+
+  end
+end

data/spec/unit/source/test_with_front_matter.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module WLang
+  describe Source, "template_content" do
+
+    let(:source){ Source.new("Hello world") }
+    subject{ source.with_front_matter(enabled) }
+
+    context 'when enabled' do
+      let(:enabled){ true }
+      it { should be_a(Source::FrontMatter) }
+    end
+
+    context 'when disabled' do
+      let(:enabled){ false }
+      it { should eq(source) }
+    end
+
+  end
+end

data/spec/unit/template/test_call.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module WLang
+  describe Template, 'call' do
+
+    let(:template){ Template.new("Hello ${who}!") }
+
+    it 'renders the template to a string by default' do
+      template.render(:who => "world").should eq("Hello world!")
+    end
+
+    it 'allows specifying a buffer' do
+      template.render({:who => "world"}, "Hey, ").should eq("Hey, Hello world!")
+    end
+
+  end
+end

data/spec/unit/template/test_new.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module WLang
+  describe Template, '.new' do
+
+    it 'returns a Template instance' do
+      Template.new("Hello ${who}!").should be_a(Template)
+    end
+
+    it 'allows specifying the dialect to use' do
+      t = Template.new("Hello ${who}!", :dialect => Upcasing)
+      t.dialect.should eq(Upcasing)
+    end
+
+    it 'uses WLang::Html as default dialect' do
+      t = Template.new("Hello ${who}!")
+      t.dialect.should eq(Html)
+    end
+
+  end
+end

data/spec/unit/template/test_path.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module WLang
+  describe Template, 'path' do
+
+    subject{ template.path }
+
+    context 'when a string and no option' do
+      let(:template){ Template.new("Hello ${who}!") }
+      it{ should be_nil }
+    end
+
+    context 'when a Path and no option' do
+      let(:template){ Template.new(Path.here) }
+      it{ should eq(__FILE__) }
+    end
+
+    context 'when a string and an option' do
+      let(:template){ Template.new("Hello ${who}!", :path => __FILE__) }
+      it{ should eq(__FILE__) }
+    end
+
+    context 'when a path an an option' do
+      let(:template){ Template.new(Path.here, :path => __FILE__) }
+      it{ should eq(__FILE__) }
+    end
+
+  end
+end

data/spec/unit/template/test_render.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module WLang
+  describe Template, 'render' do
+
+    def template
+      Template.new(source, options)
+    end
+
+    let(:options){ {} }
+
+    subject{ template.render }
+
+    context 'with a single source String and no options' do
+      let(:source){ "Hello world!" }
+      it{ should eq("Hello world!") }
+    end
+
+    context 'with a yaml front matter and default options' do
+      let(:source){ hello_with_data_path }
+      it{ should eq("Hello world!") }
+    end
+
+    context 'with a yaml front matter and front matter disabled' do
+      let(:source){ hello_with_data_path }
+      let(:options){ {:yaml_front_matter => false} }
+      it 'should fail' do
+        lambda{
+          subject
+        }.should raise_error(NameError)
+      end
+    end
+
+    context 'with explicit locals' do
+      let(:source){ hello_with_explicit_locals_path }
+      it{ should eq("Hello world and wlang!") }
+    end
+
+    context 'with partials' do
+      let(:source){ hello_with_partials_path }
+      it{ should eq("Hello world and wlang!") }
+    end
+
+  end
+end

data/spec/unit/template/test_to_ast.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module WLang
+  describe Template, 'to_ast' do
+
+    let(:template){ Template.new("Hello ${who}!") }
+
+    it 'it returns an ast' do
+      template.to_ast.should be_a(Array)
+    end
+
+  end
+end

data/spec/unit/template/test_to_ruby_code.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+module WLang
+  describe Template, 'to_ruby_code' do
+
+    let(:template){ Template.new("Hello ${who}!") }
+
+    it 'it returns some ruby code' do
+      expected = %q{Proc.new{|d1,b1| b1 << ("Hello "); d1._tag_36(b1, "who"); b1 << ("!") }}
+      template.to_ruby_code.should eq(expected)
+    end
+
+  end
+end

data/spec/unit/template/test_to_ruby_proc.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module WLang
+  describe Template, 'to_ruby_proc' do
+
+    let(:template){ Template.new("Hello ${who}!") }
+
+    it 'returns a Proc instance' do
+      template.to_ruby_proc.should be_a(Proc)
+    end
+
+  end
+end

data/spec/unit/template/test_yaml_front_matter.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module WLang
+  describe Template, 'yaml_front_matter?' do
+
+    before do
+      class Template; public :yaml_front_matter?; end
+    end
+
+    it 'is true by default' do
+      Template.new("Hello ${who}!").should be_yaml_front_matter
+    end
+
+    it 'is can be explicitely enabled' do
+      Template.new("Hello ${who}!", :yaml_front_matter => true).should be_yaml_front_matter
+    end
+
+    it 'is can be explicitely disabled' do
+      Template.new("Hello ${who}!", :yaml_front_matter => false).should_not be_yaml_front_matter
+    end
+
+  end
+end

data/spec/unit/tilt/test_wlang_template.rb

@@ -0,0 +1,65 @@
+require 'tilt'
+require 'wlang/tilt'
+describe Tilt::WLangTemplate do
+
+  it 'is registered for .wlang files' do
+    Tilt.mappings['wlang'].should include(Tilt::WLangTemplate)
+  end
+
+  it 'supports basic rendering with no scope no locals' do
+    template = Tilt::WLangTemplate.new{ "Hello" }
+    template.render.should eq("Hello")
+  end
+
+  it 'supports a binding scope' do
+    template = Tilt::WLangTemplate.new{ "Hello ${who}" }
+    who = "world"
+    template.render(binding).should eq("Hello world")
+  end
+
+  it 'supports a Hash scope' do
+    template = Tilt::WLangTemplate.new{ "Hello ${who}" }
+    scope = {:who => "world"}
+    template.render(scope).should eq("Hello world")
+  end
+
+  it 'supports both a scope and locals' do
+    template = Tilt::WLangTemplate.new{ "Hello ${who} and ${who_else}" }
+    who = "world"
+    template.render(binding, :who_else => 'wlang').should eq("Hello world and wlang")
+  end
+
+  it 'supports being rendered multiple times' do
+    template = Tilt::WLangTemplate.new{ "Hello ${i}" }
+    3.times{|i| template.render(binding).should eq("Hello #{i}") }
+  end
+
+  it 'supports passing a block for yielding' do
+    template = Tilt::WLangTemplate.new{ "Hello ${yield}" }
+    template.render{ "world" }.should eq('Hello world')
+  end
+
+  it 'supports expressions on yield' do
+    template = Tilt::WLangTemplate.new{ "Hello ${yield.upcase}" }
+    template.render{ "world" }.should eq('Hello WORLD')
+  end
+
+  it 'passes :path option to the underlying template' do
+    tpl = Tilt::WLangTemplate.new(hello_path.to_s)
+    tpl = tpl.send(:prepare)
+    tpl.should be_a(WLang::Template)
+    tpl.path.should eq(hello_path.to_s)
+  end
+
+  it 'supports passing a dialect as options' do
+    template = Tilt::WLangTemplate.new(:dialect => Upcasing){ "Hello ${who}" }
+    template.render.should eq("Hello WHO")
+  end
+
+  it 'supports options through inheritance' do
+    tpl_class = Tilt::WLangTemplate.with_options(:dialect => Upcasing)
+    template  = tpl_class.new{ "Hello ${who}" }
+    template.render.should eq("Hello WHO")
+  end
+
+end

data/wlang.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |s|
   #
   # The description should be more detailed than the summary.  For example,
   # you might wish to copy the entire README into the description.
-  s.description = "WLang is a general-purpose *code generation*/*templating engine*. It's main aim is to help you generating\nweb pages, sql queries, ruby code (that is, generating code in general) without having to worry too much \nabout html entities encoding, sql back quoting, string escaping and the like. WLang proposes a generic \nengine that you can extend to fit your needs. It also proposes standard instantiations of this engine \nfor common tasks such as creating SQL queries, instantiating web pages, and so on."
+  s.description = "WLang is a general-purpose *code generation*/*templating engine*. It's main aim is to\nhelp you generating web pages, sql queries, ruby code (that is, generating text in\ngeneral) without having to worry too much about html entities encoding, sql back\nquoting, string escaping and the like. WLang proposes a generic engine that you can\neasily extend to fit your needs. It also proposes standard instantiations of this\nengine for common tasks such as rendering HTML web pages."
 
   # The URL of this gem home page (optional)
   s.homepage = "http://github.com/blambeau/wlang"
@@ -123,19 +123,17 @@ Gem::Specification.new do |s|
   # One call to add_development_dependency('gem_name', 'gem version requirement')
   # for each development dependency. These gems are required for developers
   #
-  s.add_development_dependency("ruby-prof", "~> 0.11.2")
-  s.add_development_dependency("mustache", "~> 0.99.4")
+  s.add_development_dependency("tilt", "~> 1.3")
   s.add_development_dependency("rake", "~> 0.9.2")
   s.add_development_dependency("bundler", "~> 1.0")
   s.add_development_dependency("rspec", "~> 2.10.0")
-  s.add_development_dependency("epath", "~> 0.1.0")
   s.add_development_dependency("yard", "~> 0.8.1")
   s.add_development_dependency("bluecloth", "~> 2.2.0")
   s.add_dependency("citrus", "~> 2.4.1")
   s.add_dependency("temple", "~> 0.4.0")
-  s.add_dependency("backports", "~> 2.6.1")
   s.add_dependency("quickl", "~> 0.4.3")
   s.add_dependency("awesome_print", "~> 1.0.2")
+  s.add_dependency("epath", ">= 0.2")
 
   # The version of ruby required by this gem
   #