wlang 0.10.2 → 2.0.0.beta

data/spec/unit/dialect/test_compile.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+module WLang
+  describe Dialect, ".compile" do
+
+    def compile(s, options = nil)
+      options.nil? ? Upcasing.compile(s) : Upcasing.compile(s, options)
+    end
+
+    it 'returns a Template' do
+      compile(hello_tpl).should be_a(Template)
+    end
+
+    it 'supports a path-like as input' do
+      compile(hello_path).should be_a(Template)
+    end
+
+    it 'supports an IO object as input' do
+      hello_io do |f|
+        compile(f).should be_a(Template)
+      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
+
+    specify 'returned template is renderable' do
+      compile(hello_tpl).render.should eq("Hello WHO!")
+    end
+
+    it 'returns a thread-safe template object' do
+      t = WLang.dialect{ tag('$'){|buf,fn|
+        raise if defined?(@somevar)
+        @somevar = "World"
+      } }.compile('${who}')
+      2.times do
+        lambda{ t.call }.should_not raise_error
+      end
+    end
+
+  end # describe Dialect
+end # module WLang

data/spec/unit/dialect/test_dispatching.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module WLang
+  describe Dialect::Dispatching do
+    include Dialect::Dispatching::ClassMethods
+
+    describe 'tag_dispatching_name' do
+      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
+
+  end # describe Dialect
+end # module WLang

data/spec/unit/dialect/test_evaluate.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module WLang
+  class Dialect
+    describe Evaluation, "evaluate" do
+      include Evaluation
+
+      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
+
+      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 'uses the hash in priority' do
+        with_scope({:keys => [1,2,3]}) do
+          evaluate("keys").should eq([1,2,3])
+        end
+      end
+
+      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 Evaluation, "evaluate"
+  end # class Dialect
+end # module WLang

data/spec/unit/dialect/test_render.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module WLang
+  describe Dialect, "render" do
+
+    U = Upcasing
+    let(:expected){ "Hello WHO!" }
+
+    it 'works as expected' do
+      U.render(hello_tpl).should eq(expected)
+    end
+
+    it 'do not eat extra blocks' do
+      U.render("Hello ${who}{world}").should eq("Hello WHO{world}")
+    end
+
+    it "accepts an optional scope" do
+      U.render(hello_tpl, {}).should eq(expected)
+    end
+
+    it 'accepts a :to_path object' do
+      U.render(hello_path).should eq(expected)
+    end
+
+    it 'accepts an IO instance' do
+      hello_io{|io| U.render(io)}.should eq(expected)
+    end
+
+    it 'supports specifying the buffer' do
+      U.render(hello_tpl, {}, []).should eq(["Hello ", "WHO", "!"])
+    end
+
+  end # describe Dialect
+end # module WLang

data/spec/unit/dialect/test_tags.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module WLang
+  describe Dialect::Tags do
+
+    describe 'tag' do
+      include Dialect::Tags::ClassMethods
+
+      def define_tag_method(*args)
+        args
+      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
+
+  end # describe Dialect
+end # module WLang

data/spec/unit/dialect/test_with_scope.rb

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

data/spec/unit/scope/test_binding_scope.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module WLang
+  class Scope
+    describe BindingScope do
+
+      it 'implements fetch through eval' do
+        who = "World"
+        scope = Scope.coerce(binding)
+        scope.fetch(:who).should eq("World")
+      end
+
+      it 'delegates fetch to its parent when not found' do
+        scope = Scope.coerce(binding, Scope.coerce(:who => "World"))
+        scope.fetch(:who).should eq("World")
+      end
+
+      it 'fetches `self` correctly' do
+        o = Object.new
+        x = o.instance_eval do
+          Scope.coerce(binding).fetch(:self)
+        end
+        x.should eq(o)
+      end
+
+    end # describe BindingScope
+  end # class Scope
+end # module WLang

data/spec/unit/scope/test_coerce.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module WLang
+  describe Scope, ".coerce" do
+
+    it 'recognizes Binding' do
+      Scope.coerce(binding).should be_a(Scope::BindingScope)
+    end
+
+    it 'recognizes Scopes' do
+      Scope.coerce(Scope.root).should be_a(Scope::ProxyScope)
+    end
+
+    it 'falls back to ObjectScope on Hash' do
+      Scope.coerce({}).should be_a(Scope::ObjectScope)
+    end
+
+    it 'falls back to ObjectScope' do
+      Scope.coerce(12).should be_a(Scope::ObjectScope)
+    end
+
+  end # describe Scope
+end # module WLang

data/spec/unit/scope/test_object_scope.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module WLang
+  class Scope
+    describe ObjectScope do
+
+      it 'implements fetch through [] if a Hash' do
+        scope = Scope.coerce(:who => "World")
+        scope.fetch(:who).should eq("World")
+      end
+
+      it 'supports any obj that responds to :has_key?' do
+        subj = Object.new.tap{|x|
+          def x.has_key?(k); true; end
+          def x.[](k); "World"; end
+        }
+        scope = Scope.coerce(subj)
+        scope.fetch(:who).should eq("World")
+      end
+
+      it 'falls back to send' do
+        subj = Struct.new(:who).new("World")
+        scope = Scope.coerce(subj)
+        scope.fetch(:who).should eq("World")
+      end
+
+      it 'delegates fetch to its parent when not found' do
+        scope = Scope.coerce(12, Scope.coerce({:who => "World"}))
+        scope.fetch(:who).should eq("World")
+      end
+
+      it 'fetches `self` correctly' do
+        scope = Scope.coerce(12)
+        scope.fetch(:self).should eq(12)
+      end
+
+    end # describe ObjectScope
+  end # class Scope
+end # module WLang

data/spec/unit/scope/test_proxy_scope.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module WLang
+  class Scope
+    describe ProxyScope do
+
+      it 'delegates fetch to its subject' do
+        proxy = Scope.coerce(Scope.coerce(:who => "World"))
+        proxy.fetch(:who).should eq("World")
+      end
+
+      it 'delegates fetch to its parent when not found' do
+        proxy  = Scope.coerce(Scope.root, Scope.coerce(:who => "World"))
+        proxy.fetch(:who).should eq("World")
+      end
+
+      it 'fetches `self` correctly' do
+        Scope.coerce(Scope.coerce(12)).fetch(:self).should eq(12)
+      end
+
+    end # describe ProxyScope
+  end # class Scope
+end # module WLang

data/spec/unit/scope/test_root_scope.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module WLang
+  class Scope
+    describe RootScope do
+
+      let(:scope){ RootScope.new }
+
+      it 'throws on fetch' do
+        lambda{ scope.fetch(:who) }.should throw_symbol(:fail)
+      end
+
+      it 'throws on fetch even on `self`' do
+        lambda{ scope.fetch(:self) }.should throw_symbol(:fail)
+      end
+
+      it 'raises on pop' do
+        lambda{ scope.pop }.should raise_error
+      end
+
+    end # describe ProxyScope
+  end # class Scope
+end # module WLang

data/spec/unit/test_assumptions.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+describe "ruby assumptions" do
+
+  def arity0();        end
+  def arity1(fn);      end
+  def arity2(fn1,fn2); end
+
+  it 'String#to_path does not exist' do
+    ''.should_not respond_to(:to_path)
+  end
+
+  it 'Pathname#to_path does exist' do
+    require 'pathname'
+    Pathname.new('.').should respond_to(:to_path) if RUBY_VERSION >= "1.9"
+  end
+
+  it 'method arity' do
+    self.class.instance_method(:arity0).arity.should eq(0)
+    self.class.instance_method(:arity1).arity.should eq(1)
+    self.class.instance_method(:arity2).arity.should eq(2)
+  end
+
+  it "lambda arity" do
+    lambda{|| }.arity.should eq(0)
+    lambda{|fn|}.arity.should eq(1)
+    lambda{|fn1,fn2|}.arity.should eq(2)
+  end
+
+end

data/spec/unit/test_scope.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+module WLang
+  describe Scope do
+
+    let(:scope){ Scope.coerce({:who => "World"}) }
+
+    it 'acts like a stack' do
+      s = scope
+      s.evaluate(:who).should eq("World")
+      lambda{ s.pop.evaluate(:who) }.should throw_symbol(:fail)
+      s = scope.push(:who => "World2")
+      s.evaluate(:who).should eq("World2")
+      s = s.pop
+      s.evaluate(:who).should eq("World")
+    end
+
+    it 'has a `with` helper' do
+      scope.with(:who => "World2") do |s|
+        s.evaluate(:who).should eq("World2")
+      end
+      scope.evaluate(:who).should eq("World")
+    end
+
+    it 'allows pushing scopes' do
+      scope.with Scope.coerce(:other => "World2") do |s|
+        s.evaluate(:other).should eq("World2")
+        s.evaluate(:who).should eq("World")
+      end
+    end
+
+    it 'evaluates `self` accurately' do
+      scope.evaluate(:self).should eq(:who => "World")
+    end
+
+    it 'evaluates dot expressions correctly' do
+      scope.evaluate("who.upcase").should eq("WORLD")
+    end
+
+    it 'strips strings before evaluation' do
+      scope.evaluate("  who  ").should eq("World")
+      scope.evaluate(" who.upcase ").should eq("WORLD")
+    end
+
+    it 'fails when not found' do
+      lambda{ scope.evaluate(:nosuchone) }.should throw_symbol(:fail)
+    end
+
+    it 'supports a default value instead of fail' do
+      scope.evaluate(:nosuchone, 12).should eq(12)
+    end
+
+    it 'supports nil as default value' do
+      scope.evaluate(:nosuchone, nil).should be_nil
+    end
+
+  end # describe Scope
+end # module WLang

data/tasks/debug_mail.rake

@@ -1,8 +1,8 @@
 # Installs a rake task for debuging the announcement mail.
 #
 # This file installs the 'rake debug_mail' that flushes an announcement mail
-# for your library on the standard output. It is automatically generated 
-# by Noe from your .noespec file, and should therefore be configured there, 
+# for your library on the standard output. It is automatically generated
+# by Noe from your .noespec file, and should therefore be configured there,
 # under the variables/rake_tasks/debug_mail entry, as illustrated below:
 #
 # variables:
@@ -12,9 +12,9 @@
 #       nb_changelog_sections: 1
 #       ...
 #
-# If you have specific needs requiring manual intervention on this file, 
+# If you have specific needs requiring manual intervention on this file,
 # don't forget to set safe-override to false in your noe specification:
-# 
+#
 # template-info:
 #   manifest:
 #     tasks/debug_mail.rake:
@@ -22,8 +22,8 @@
 #
 # The mail template used can be found in debug_mail.txt. That file may be
 # changed to tune the mail you want to send. If you do so, don't forget to
-# add a manifest entry in your .noespec file to avoid overriding you 
-# changes. The mail template uses wlang, with parentheses for block 
+# add a manifest entry in your .noespec file to avoid overriding you
+# changes. The mail template uses wlang, with parentheses for block
 # delimiters.
 #
 # template-info:
@@ -31,48 +31,45 @@
 #     tasks/debug_mail.txt:
 #       safe-override: false
 #
-begin
-  require 'wlang'
+desc "Debug the release announcement mail"
+task :debug_mail do
+  begin
+    require 'wlang'
+  rescue LoadError
+    abort "wlang is not available. Try 'gem install wlang'"
+  end
   require 'yaml'
-  
-  desc "Debug the release announcement mail"
-  task :debug_mail do 
-    # Check that a .noespec file exists
-    noespec_file = File.expand_path('../../wlang.noespec', __FILE__)
-    unless File.exists?(noespec_file)
-      raise "Unable to find .noespec project file, sorry."
-    end
-    
-    # Load it as well as variables and options
-    noespec = YAML::load(File.read(noespec_file))
-    vars = noespec['variables'] || {}
-
-    # Changes are taken from CHANGELOG 
-    logs = Dir[File.expand_path("../../CHANGELOG.*", __FILE__)]
-    unless logs.size == 1
-      abort "Unable to find a changelog file"
-    end
 
-    # Load interesting changesets
-    changes, end_found = [], 0
-    File.readlines(logs.first).select{|line|
-      if line =~ /^#/
-        break if end_found >= 2
-        end_found += 1
-      end
-      changes << line
-    }
-    vars['changes'] = changes.join
-    
-    # WLang template
-    template = File.expand_path('../debug_mail.txt', __FILE__)
-    
-    # Let's go!
-    $stdout << WLang::file_instantiate(template, vars, "wlang/active-text")
+  # Check that a .noespec file exists
+  noespec_file = File.expand_path('../../wlang.noespec', __FILE__)
+  unless File.exists?(noespec_file)
+    raise "Unable to find .noespec project file, sorry."
   end
 
-rescue LoadError 
-  task :debug_mail do
-    abort "wlang is not available. Try 'gem install wlang'"
+  # Load it as well as variables and options
+  noespec = YAML::load(File.read(noespec_file))
+  vars = noespec['variables'] || {}
+
+  # Changes are taken from CHANGELOG
+  logs = Dir[File.expand_path("../../CHANGELOG.*", __FILE__)]
+  unless logs.size == 1
+    abort "Unable to find a changelog file"
   end
+
+  # Load interesting changesets
+  changes, end_found = [], 0
+  File.readlines(logs.first).select{|line|
+    if line =~ /^# /
+      break if end_found >= 1
+      end_found += 1
+    end
+    changes << line
+  }
+  vars['changes'] = changes.join
+
+  # WLang template
+  template = File.expand_path('../debug_mail.txt', __FILE__)
+
+  # Let's go!
+  $stdout << WLang::file_instantiate(template, vars, "wlang/active-text")
 end