wlang 2.0.1 → 2.1.0

data/lib/wlang/scope/binding_scope.rb

@@ -2,10 +2,10 @@ module WLang
   class Scope
     class BindingScope < Scope
 
-      def fetch(k, &blk)
-        subject.eval(k.to_s)
+      def fetch(key, dialect = nil, unfound = nil)
+        subject.eval(key.to_s)
       rescue NameError
-        parent.fetch(k, &blk)
+        safe_parent.fetch(key, dialect, unfound)
       end
 
       def inspect

data/lib/wlang/scope/null_scope.rb

@@ -0,0 +1,34 @@
+module WLang
+  class Scope
+    class NullScope < Scope
+
+      def initialize
+        super(nil)
+      end
+
+      def fetch(key, dialect = nil, unfound = nil)
+        unfound ? unfound.call : throw(:fail)
+      end
+
+      def subjects
+        []
+      end
+
+      def inspect
+        "NullScope"
+      end
+      alias :to_s :inspect
+
+    protected
+
+      def append(x)
+        x
+      end
+
+      def prepend(x)
+        x
+      end
+
+    end # class NullScope
+  end # class Scope
+end # module WLang

data/lib/wlang/scope/object_scope.rb

@@ -2,17 +2,28 @@ module WLang
   class Scope
     class ObjectScope < Scope
 
-      def fetch(k, &blk)
+      def fetch(key, dialect = nil, unfound = nil)
         s = subject
-        return s if k == :self
+
+        # self special case
+        if key == :self
+          return s
+        end
+
+        # hash indirect access
         if s.respond_to?(:has_key?)
-          return s[k] if s.has_key?(k)
-          return s[k.to_s] if s.has_key?(k.to_s)
+          return s[key]      if s.has_key?(key)
+          return s[key.to_s] if s.has_key?(key.to_s)
         end
-        return s.send(k) if s.respond_to?(k)
-        parent.fetch(k, &blk)
+
+        # getter
+        if s.respond_to?(key)
+          return s.send(key)
+        end
+
+        safe_parent.fetch(key, dialect, unfound)
       rescue NameError
-        parent.fetch(k, &blk)
+        safe_parent.fetch(key, dialect, unfound)
       end
 
       def inspect

data/lib/wlang/scope/proc_scope.rb

@@ -2,10 +2,10 @@ module WLang
   class Scope
     class ProcScope < Scope
 
-      def fetch(key, &blk)
-        Scope.coerce(subject.call).fetch(key) do
-          parent.fetch(key, &blk)
-        end
+      def fetch(key, dialect = nil, unfound = nil)
+        scoped = Scope.coerce(subject.call)
+        fallbk = lambda{ safe_parent.fetch(key, dialect, unfound) }
+        scoped.fetch(key, dialect, fallbk)
       end
 
       def inspect

data/lib/wlang/scope/sinatra_scope.rb

@@ -0,0 +1,44 @@
+module WLang
+  class Scope
+    class SinatraScope < ObjectScope
+
+      def fetch(key, dialect = nil, unfound = nil)
+        find_partial(key, subject) || super
+      end
+
+      def inspect
+        "SinatraScope"
+      end
+      alias :to_s :inspect
+
+    private
+
+      def find_partial(key, app)
+        find_internal_partial(key, app) || find_external_partial(key, app)
+      end
+
+      def find_internal_partial(key, app)
+        return unless app.settings.templates[key]
+        app.send(:compile_template, :wlang, key, {}, app.settings.views)
+      end
+
+      def find_external_partial(key, app)
+        views = app.settings.views
+        find_files(views, key) do |file|
+          if engine = Tilt[file]
+            tpl = app.template_cache.fetch(file) do
+              engine.new(file.to_s, 1, {})
+            end
+            return tpl
+          end
+        end
+        nil
+      end
+
+      def find_files(folder, name, &bl)
+        Path(folder).glob("#{name}.*").each(&bl)
+      end
+
+    end # class SinatraScope
+  end # class Scope
+end # module WLang

data/lib/wlang/template.rb

@@ -44,8 +44,8 @@ module WLang
       compiler.to_ast(template_content)
     end
 
-    def call(locs = {}, buffer = '')
-      scope = WLang::Scope.chain([locals, locs])
+    def call(*args)
+      scope, buffer = call_args_conventions(args)
       dialect_instance.dup.render compiled, scope, buffer
     end
     alias :render :call
@@ -59,5 +59,13 @@ module WLang
         opt.nil? or opt
       end
 
+      def call_args_conventions(args)
+        args << '' unless args.last.respond_to?(:<<)
+        buffer = args.pop
+        args << self.locals unless self.locals.empty?
+        scope  = WLang::Scope.chain(args)
+        [scope, buffer]
+      end
+
   end # class Template
 end # module WLang

data/lib/wlang/tilt/wlang_template.rb

@@ -35,7 +35,7 @@ module Tilt
 
       def evaluate(scope, locals, &block)
         locals[:yield] = block if block
-        @engine.render WLang::Scope.chain([scope, locals])
+        @engine.render(scope, locals)
       end
 
   end

data/lib/wlang/version.rb

@@ -2,8 +2,8 @@ module WLang
   module Version
 
     MAJOR = 2
-    MINOR = 0
-    TINY  = 1
+    MINOR = 1
+    TINY  = 0
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

data/spec/assumptions/test_core.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+describe "Core assumptions" do
+
+  specify 'Hash does not respond to #<<' do
+    {}.should_not respond_to(:<<)
+  end
+
+end

data/spec/fixtures/templates/hello_from_sinatra.wlang

@@ -0,0 +1 @@
+Hello >{hello}!

data/spec/integration/html/test_greater.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'wlang/html'
 module WLang
   describe Html, ">{...}" do
 
@@ -13,11 +12,22 @@ module WLang
       render("Hello >{partial}", binding).should eq("Hello World")
     end
 
+    it 'recognizes a Tilt::WLangTemplate' do
+      who     = "World"
+      partial = Tilt::WLangTemplate.new{ "${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
 
+    it 'call a Proc as +{...} does' do
+      partial = Proc.new{ "World" }
+      render("Hello >{partial}", binding).should eq("Hello World")
+    end
+
   end
-end
+end

data/spec/integration/sinatra/test_partials.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'rack/test'
+describe 'Integration with Sinatra for partials' do
+  include Rack::Test::Methods
+
+  let(:app){ 
+    sinatra_app do
+      set :accessible, "world"
+      set :views, fixtures_folder/'templates'
+      template :internal_partial do
+        "Hello ${who}!"
+      end
+      helpers do
+        def accessible; settings.accessible; end
+      end
+      get '/external' do
+        wlang ">{hello}", :locals => {:who => "sinatra"}
+      end
+      get '/internal' do
+        wlang ">{internal_partial}", :locals => {:who => "sinatra"}
+      end
+    end
+  }
+
+  it 'renders external partials correcty' do
+    get '/external'
+    last_response.body.should eq("Hello sinatra!")
+  end
+
+  it 'renders internal partials correcty' do
+    get '/internal'
+    last_response.body.should eq("Hello sinatra!")
+  end
+
+end

data/spec/integration/test_examples.rb

@@ -3,7 +3,7 @@ require 'wlang/command'
 module WLang
   describe "The examples", :hash_ordering => true do
 
-    (root_folder/:examples).glob("**/*.*").each do |ex_file|
+    (root_folder/"examples/1-html-intro").glob("**/*.*").each do |ex_file|
       next if ex_file.basename.to_s == "README.md"
       describe "the example file #{ex_file}" do
 
@@ -27,4 +27,4 @@ module WLang
     end
 
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 require 'epath'
 $root_folder ||= Path.backfind('.[Rakefile]')
 
+require 'tilt'
+require 'sinatra/base'
+
 # Require wlang
 $LOAD_PATH.unshift(($root_folder/:lib).to_s)
 require 'wlang'
@@ -53,6 +56,10 @@ module Helpers
     end
   end
 
+  def sinatra_app(&block)
+    Sinatra.new(Sinatra::Base, &block).new!
+  end
+
 end
 include Helpers
 

data/spec/unit/compiler/test_grammar.rb

@@ -158,7 +158,7 @@ module WLang
       describe 'the block rule' do
         let(:rule){ :block }
         let(:text){ "{ world }" }
-        it{ should eq([:static, text]) }
+        it{ should eq([:strconcat, [:static, "{"], [:static, " world "], [:static, "}"]]) }
       end
 
       describe 'the wlang rule' do

data/spec/unit/compiler/test_parser.rb

@@ -43,6 +43,23 @@ module WLang
       parse("${first}{second}").should eq(expected)
     end
 
+    it 'should support wlang tags inside normal { ... }' do
+      expected = \
+      [:template,
+        [:fn,
+          [:strconcat,
+            [:static, "hello "],
+            [:strconcat,
+              [:static, "{"],
+              [:strconcat,
+                [:static, "bar "],
+                [:wlang, "$",
+                  [:fn,
+                    [:static, "second"]]]],
+                [:static, "}"]]]]]
+      parse("hello {bar ${second}}").should eq(expected)
+    end
+
     it 'is idempotent' do
       parse(parse(hello_tpl)).should eq(expected)
     end

data/spec/unit/dialect/test_context.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module WLang
+  describe Dialect, 'context' do
+
+    let(:dialect){ Dialect.new }
+
+    subject{ dialect.context }
+
+    it 'defaults to nil if no scope' do
+      subject.should be_nil
+    end
+
+    it "is the scope's subject when one scope" do
+      dialect.with_scope(:x) do
+        subject.should eq(:x)
+      end
+    end
+
+    it "is the root scope's subject when multiple scope" do
+      dialect.with_scope(:x) do
+        dialect.with_scope(:y) do
+          subject.should eq(:x)
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/dialect/test_evaluate.rb

@@ -40,6 +40,16 @@ module WLang
       end
     end
 
+    it 'supports a default value' do
+      evaluate("who", 12).should eq(12)
+      evaluate("who", nil).should be_nil
+    end
+
+    it 'supports a default value through a Proc' do
+      evaluate("who"){ 12  }.should eq(12)
+      evaluate("who"){ nil }.should be_nil
+    end
+
     it 'raises a NameError when not found' do
       lambda{ evaluate("who") }.should raise_error(NameError)
     end

data/spec/unit/dialect/test_render.rb

@@ -17,6 +17,10 @@ module WLang
       U.render(hello_tpl, {}).should eq(expected)
     end
 
+    it "accepts multiple scope objects" do
+      U.render(hello_tpl, 12, {}).should eq(expected)
+    end
+
     it 'accepts a :to_path object' do
       U.render(hello_path).should eq(expected)
     end

data/spec/unit/scope/sinatra_scope/test_fetch.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module WLang
+  class Scope
+    describe SinatraScope, 'fetch' do
+
+      let(:app){ 
+        sinatra_app do
+          set :accessible, "world"
+          set :views, fixtures_folder/'templates'
+          helpers do
+            def accessible; settings.accessible; end
+          end
+        end
+      }
+
+      let(:scope){ Scope::SinatraScope.new(app) }
+
+      it 'delegates to helpers correctly' do
+        scope.fetch(:accessible).should eq("world")
+      end
+
+      it 'returns Tilt templates on existing views' do
+        scope.fetch('hello', app).should be_a(Tilt::Template)
+      end
+
+    end
+  end
+end

data/spec/unit/scope/test_binding_scope.rb

@@ -10,7 +10,7 @@ module WLang
       end
 
       it 'delegates fetch to its parent when not found' do
-        scope = Scope.coerce(binding, Scope.coerce(:who => "World"))
+        scope = Scope.coerce(:who => "World").push(binding)
         scope.fetch(:who).should eq("World")
       end