wlang 0.8.4

data/test/wlang/buffering_ruleset_test.rb

@@ -0,0 +1,102 @@
+require 'test/unit'
+require 'wlang'
+require 'wlang/test_utils.rb'
+require 'wlang/rulesets/buffering_ruleset'
+
+# Tests the Scoping ruleset
+class WLang::BufferingRuleSetTest < Test::Unit::TestCase
+  include WLang::TestUtils
+  
+  # Installs a dialect on wlang
+  def setup
+    WLang::dialect "buffering-test" do 
+      rules WLang::RuleSet::Basic
+      rules WLang::RuleSet::Buffering
+      rule ';' do |parser, offset|
+        text, reached = parser.parse(offset)
+        [text.upcase, reached]
+      end
+    end
+  end
+  
+  # Tests input rule
+  def test_input
+    expected = read_relative_file("ruby_template.wrb", __FILE__)
+    template = relative_template("<<{ruby_template.wrb}", "buffering-test", __FILE__)
+    result = template.instantiate()
+    assert_equal(expected, result)
+  end
+    
+  # Tests that input rule allows creating file name in wlang
+  def test_input_accepts_injection
+    expected = read_relative_file("ruby_template.wrb", __FILE__)
+    template = relative_template("<<{ruby_template.wrb}", "buffering-test", __FILE__)
+    result = template.instantiate("", "ext" => "wrb")
+    assert_equal(expected, result)
+  end
+  
+  # Tests output rule
+  def test_output
+    output = relative_file("buffering_ruleset_test_output.txt", __FILE__)
+    File.delete(output) if File.exists?(output)
+    template = relative_template(">>{buffering_ruleset_test_output.txt}{an output}", "buffering-test", __FILE__)
+    assert_equal("", template.instantiate())
+    assert_equal("an output", File.read(output))
+    File.delete(output) if File.exists?(output)
+  end
+  
+  # Tests output rule allows creating file name in wlang
+  def test_output_accepts_injection
+    output = relative_file("buffering_ruleset_test_output.txt", __FILE__)
+    File.delete(output) if File.exists?(output)
+    template = relative_template(">>{buffering_ruleset_test_output.${ext}}{an output}", "buffering-test", __FILE__)
+    assert_equal("", template.instantiate("", "ext" => "txt"))
+    assert_equal("an output", File.read(output))
+    File.delete(output) if File.exists?(output)
+  end
+  
+  # Tests output rule parses the second block in same dialect
+  def test_output_stays_in_same_dialect
+    output = relative_file("buffering_ruleset_test_output.txt", __FILE__)
+    File.delete(output) if File.exists?(output)
+    template = relative_template(">>{buffering_ruleset_test_output.txt}{;{an output}}", "buffering-test", __FILE__)
+    assert_equal("", template.instantiate())
+    assert_equal("AN OUTPUT", File.read(output))
+    File.delete(output) if File.exists?(output)
+  end
+  
+  def test_output_created_dirs
+    output = relative_file("buffering_ruleset_output/buffering_ruleset_test_output.txt", __FILE__)
+    File.delete(output) if File.exists?(output)
+    template = relative_template(">>{buffering_ruleset_output/buffering_ruleset_test_output.txt}{an output}", "buffering-test", __FILE__)
+    assert_equal("", template.instantiate())
+    assert_equal("an output", File.read(output))
+    File.delete(output) if File.exists?(output)
+  end
+  
+  def test_output_multiple_created_dirs
+    output = relative_file("buffering_ruleset_output/subdir/subdir/buffering_ruleset_test_output.txt", __FILE__)
+    File.delete(output) if File.exists?(output)
+    template = relative_template(">>{buffering_ruleset_output/subdir/subdir/buffering_ruleset_test_output.txt}{an output}", "buffering-test", __FILE__)
+    assert_equal("", template.instantiate())
+    assert_equal("an output", File.read(output))
+    File.delete(output) if File.exists?(output)
+  end
+  
+  # Tests that an included template can include other thinks
+  def test_inclusion_in_include_template_works
+    expected = "template3"
+    file = relative_file("buffering_template1.wtpl", __FILE__)
+    result = WLang::file_instantiate(file) 
+    assert_equal(expected, result)
+  end
+  
+  # Tests that an included template can include other thinks
+  def test_with_works_in_inclusion
+    expected = "blambeau world"
+    file = relative_file("buffering_template4.wtpl", __FILE__)
+    result = WLang::file_instantiate(file, {"who" => "blambeau"}) 
+    assert_equal(expected, result)
+  end
+  
+end # class WLang::ScopingRuleSetTest

data/test/wlang/buffering_template1.wtpl

@@ -0,0 +1 @@
+<<+{buffering_template2.wtpl}

data/test/wlang/buffering_template2.wtpl

@@ -0,0 +1 @@
+<<+{buffering_template3.wtpl}

data/test/wlang/buffering_template3.wtpl

@@ -0,0 +1 @@
+template3

data/test/wlang/buffering_template4.wtpl

@@ -0,0 +1 @@
+<<+{buffering_template5.wtpl using self with who2: who, hello: 'world'}

data/test/wlang/buffering_template5.wtpl

@@ -0,0 +1 @@
++{who} +{hello}

data/test/wlang/context_ruleset_test.rb

@@ -0,0 +1,32 @@
+require 'test/unit/testcase'
+require 'wlang'
+require 'wlang/rulesets/basic_ruleset'
+require 'wlang/rulesets/context_ruleset'
+
+# Tests the Scoping ruleset
+class WLang::ContextRuleSetTest < Test::Unit::TestCase
+
+  # Installs a dialect on wlang
+  def setup
+    WLang::dialect "context-test" do 
+      rules WLang::RuleSet::Basic
+      rules WLang::RuleSet::Context
+    end
+  end
+  
+  # Tests the define decoder
+  def test_block_assignment
+    tests = [
+      ["#={code}{hello}+{code}", "hello"],
+      ["#={code}{hello}{+{code}}", "hello"],
+      ["#={code}{%{wlang/dummy}{hello}}{+{code}}", "hello"],
+      ["#={code}{%{wlang/dummy}{+{hello}}}{+{code}}", "+{hello}"]
+    ]
+    tests.each do |test|
+      template, expected = test
+      result = template.wlang(nil, "context-test")
+      assert_equal(expected, result)
+    end
+  end
+    
+end # class WLang::ScopingRuleSetTest

data/test/wlang/data.rb

@@ -0,0 +1,3 @@
+{"name"    => "O'Neil",
+ "author"  => "blambeau",
+ "authors" => ["blambeau", "llambeau", "ancailliau"]}

data/test/wlang/encoder_set_test.rb

@@ -0,0 +1,42 @@
+require 'test/unit/testcase'
+require 'wlang'
+module WLang
+
+# Tests Dialect class
+class EncoderSetTest < Test::Unit::TestCase
+  
+  # Installs a simple upcase/lowcase plain-text dialect
+  def setup
+    @plain = WLang::EncoderSet.new
+    @plain.add_encoder(:upcase)
+    @plain.add_encoder("downcase") {|src,options| src.downcase}
+    identity = Proc.new {|src, options| src}
+    @plain.add_encoder("identity", identity)
+  end
+  
+  # Tests has_encoder? method
+  def test_has_encoder
+    assert_equal(true, @plain.has_encoder?("upcase"))
+    assert_equal(true, @plain.has_encoder?("downcase"))
+    assert_equal(true, @plain.has_encoder?("identity"))
+    assert_equal(false, @plain.has_encoder?("encoding"))
+  end
+  
+  # Tests get_encoder method
+  def test_get_encoder
+    assert_equal(true, @plain.get_encoder("upcase").is_a?(Encoder))
+    assert_equal(true, @plain.get_encoder("downcase").is_a?(Encoder))
+    assert_equal(true, @plain.get_encoder("identity").is_a?(Encoder))
+    assert_nil(@plain.get_encoder("encoding"))
+  end
+  
+  # Tests the encode method
+  def test_encode
+    assert_equal("IN UPPER CASE", @plain.encode("upcase","in Upper Case"))
+    assert_equal("in lower case", @plain.encode("downcase","IN Lower CASE"))
+  end
+  
+    
+end # class TargetLanguageTest
+    
+end # module WLang

data/test/wlang/imperative_ruleset_test.rb

@@ -0,0 +1,107 @@
+require 'test/unit'
+require "wlang"
+require 'wlang/rulesets/imperative_ruleset'
+module WLang
+  
+# Tests the Imperative rule set
+class ImperativeRuleSetTest < Test::Unit::TestCase
+  
+  # Installs some dialects on wlang
+  def setup
+    # wlang dialect, empty by default
+    WLang::dialect "imperative-test" do 
+      rules WLang::RuleSet::Basic
+      rules WLang::RuleSet::Imperative
+    end
+  end
+  
+  # Tests the each regexp
+  def test_decode_each
+    expr = WLang::RuleSet::Utils.expr(:expr,
+                                      ["using", :var, false],
+                                      ["as", :multi_as, false])
+    hash = expr.decode("items")
+    assert_equal({:expr => "items", :using => nil, :as => nil}, hash)
+    hash = expr.decode("the_items")
+    assert_equal({:expr => "the_items", :using => nil, :as => nil}, hash)
+    hash = expr.decode("items using each_with_index")
+    assert_equal({:expr => "items", :using => "each_with_index", :as => nil}, hash)
+    hash = expr.decode("items as x")
+    assert_equal({:expr => "items", :using => nil, :as => ["x"]}, hash)
+    hash = expr.decode("items using each_with_index as x, i")
+    assert_equal({:expr => "items", :using => "each_with_index", :as => ["x", "i"]}, hash)
+    hash = expr.decode("names using each_with_index as name, i")
+    assert_equal({:expr => "names", :using => "each_with_index", :as => ["name", "i"]}, hash)
+    text = "p.items.children   using   each_with_index     as  child,   i"
+    assert_not_nil(expr.decode(text))
+  end
+  
+  # Tests merging args
+  def test_merge_each_args
+    hash = WLang::RuleSet::Imperative.merge_each_args(["item", "index"], [1, 2])
+    assert_equal({"item" => 1, "index" => 2}, hash)
+    hash = WLang::RuleSet::Imperative.merge_each_args(["item", "index"], [1])
+    assert_equal({"item" => 1}, hash)
+    hash = WLang::RuleSet::Imperative.merge_each_args(["item"], [1, 2])
+    assert_equal({"item" => 1}, hash)
+  end
+  
+  # Tests conditional
+  def test_conditional
+    context = {"name" => "blambeau", "no" => false, "yes" => true}
+    tests = [
+      ["?{true}{then} after", "then after"],
+      ["?{true}{then}{else} after", "then after"],
+      ["?{false}{text} after", " after"],
+      ["?{false}{text}{else} after", "else after"],
+      ["before ?{true}{then} after", "before then after"],
+      ["before ?{true}{then}{else} after", "before then after"],
+      ["before ?{false}{text} after", "before  after"],
+      ["before ?{false}{text}{else} after", "before else after"],
+      ["?{name}{${name}}", "blambeau"],
+      ["?{nil}{${name}}{else}", "else"],
+      ["?{no}{${name}}", ""],
+      ["?{yes}{${name}}", "blambeau"],
+    ]
+    tests.each do |test|
+      result = test[0].wlang_instantiate(context, "imperative-test")
+      assert_equal(test[1], result)
+    end
+  end
+  
+  # Tests the enumration
+  def test_enumeration
+    context = {"names" => ["blambeau", "llambeau", "chl"], 
+               "empty" => [], 
+               "one" => ["blambeau"],
+               "two" => ["blambeau", "llambeau"]}
+    tests = [
+      ['*{["blambeau","llambeau","chl"] as x}{${x}}{, }', "blambeau, llambeau, chl"],
+      ["*{names as name}{${name}}", "blambeaullambeauchl"],
+      ["*{names as name}{${name}}{, }", "blambeau, llambeau, chl"],
+      ["*{names using each_with_index as name, i}{${i}:${name}}{, }", "0:blambeau, 1:llambeau, 2:chl"],
+      ["*{empty as e}{+{e}}", ""],
+      ["*{empty as e}{+{e}}{}", ""],
+      ["*{empty as e}{+{e}}{ }", ""],
+      ["*{one as e}{+{e}}", "blambeau"],
+      ["*{one as e}{+{e}}{}", "blambeau"],
+      ["*{one as e}{+{e}}{ }", "blambeau"],
+      ["*{two as t}{+{t}}", "blambeaullambeau"],
+      ["*{two as t}{+{t}}{ }", "blambeau llambeau"]
+    ]
+    tests.each do |test|
+      result = test[0].wlang_instantiate(context, "imperative-test")
+      assert_equal(test[1], result)
+    end
+  end
+  
+  def test_enumeration_bug
+    context = {"hello" => "world", "names" => ["blambeau", "llambeau", "chl"]}
+    expected = "worldworldworld"
+    template = "*{names as n}{+{hello}}"
+    assert_equal expected, template.wlang_instantiate(context, "imperative-test")
+  end
+  
+end # class ImperativeRuleSetTest
+
+end # module WLang

data/test/wlang/intelligent_buffer_test.rb

@@ -0,0 +1,194 @@
+require 'test/unit'
+require 'wlang'
+module WLang
+
+  # Tests the IntelligentBuffer class
+  class IntelligentBufferTest < Test::Unit::TestCase
+    include IntelligentBuffer::Methods
+    
+    # Creates a buffer instance
+    def buffer(str)
+      IntelligentBuffer.new(str)
+    end
+    
+    def test_last_column
+      assert_equal(4, last_column('abc'))
+      assert_equal(4, last_column("\nabc"))
+      assert_equal(6, last_column("\nabc\nab cd"))
+      assert_equal(1, last_column("\n\n\n\n\n\n"))
+    end
+    
+    def test_ismultiline?
+      assert is_multiline?("\n")
+      assert is_multiline?("\nabc")
+      assert is_multiline?("\nabc\n")
+      assert_equal false, is_multiline?("abc")
+      assert_equal false, is_multiline?("abc\t")
+    end
+    
+    def test_tabto
+      template = <<-EOF
+        def +{d}
+          contents of the method here
+          and also here
+        end
+      EOF
+      template = tabto(template, 0).strip
+      assert_equal("def +{d}\n  contents of the method here\n  and also here\nend", template)
+      # check on normal multiline
+      template = %Q{
+        def +{d}
+          contents of the method here
+          and also here
+        end
+      }
+      stripped = strip_block(template)
+      expected = "    def +{d}\n      contents of the method here\n      and also here\n    end\n"
+      assert_equal(expected, tabto(stripped, 4))
+    end
+    
+    def test_strip_block
+      # check on non multiline
+      assert_equal 'abc', strip_block('abc')
+      
+      # check on normal multiline
+      template = %Q{
+        def +{d}
+          contents of the method here
+          and also here
+        end
+      }
+      expected = "        def +{d}\n          contents of the method here\n          and also here\n        end\n"
+      assert_equal(expected, strip_block(template))
+
+      # check that explicit carriage return are recognized
+      template = %Q{
+
+        def +{d}
+          contents of the method here
+          and also here
+        end
+      }
+      expected = "\n        def +{d}\n          contents of the method here\n          and also here\n        end\n"
+      assert_equal(expected, strip_block(template))
+
+      # check that no first carriage return is recognized as well
+      template = %Q{def +{d}
+  contents of the method here
+  and also here
+end
+      }
+      expected = "def +{d}\n  contents of the method here\n  and also here\nend\n"
+      assert_equal(expected, strip_block(template))
+      
+      # Check on push failure
+      template = %Q{
+
+    def hello()
+    end
+  }
+      assert_equal("\n    def hello()\n    end\n", strip_block(template))
+
+      # Tests on a missing end bug
+      mod = "module MyModule\n  10\n  20\n  30\n\nend"
+      assert_equal(mod, strip_block(mod))
+    end
+    
+    def test_missing_end_bug_reason
+      buf = IntelligentBuffer.new
+      mod = "module MyModule\n  10\n  20\n  30\n\nend"
+      assert_equal(mod, strip_block(mod))
+      buf.<<(mod, true)
+      assert_equal(mod, buf.to_s)
+    end
+    
+    def test_push
+      template = <<-EOF
+        module +{name}
+          
+          *{defs as d}{
+            
+            def +{d}
+            end
+          }
+          
+        end
+      EOF
+      #puts template.gsub(/ {8}/, '').strip
+      buf = buffer('')
+      buf.<<("module ", false)
+      buf.<<("MyModule", true)
+      buf.<<("\n\n  ", false)
+        bufit = buffer('')
+          buf2 = buffer('')
+          buf2.<<("\n\n    def ", false)
+            buf3 = buffer('')
+            buf3.<<('hello', true)
+          buf2.<<(buf3.to_s, true)
+          buf2.<<("()\n    end\n  ", false)
+          #puts "\nAppending on bufit, first iteration"
+          #puts "|#{buf2.to_s}|"
+        bufit.<<(buf2.to_s, true)
+          #puts "\nAfter append"
+          #puts "|#{bufit.to_s}|"
+          #puts "Last column is now #{last_column(bufit)}"
+          buf2 = buffer('')
+          buf2.<<("\n\n    def ", false)
+            buf3 = buffer('')
+            buf3.<<('strip', true)
+          buf2.<<(buf3.to_s, true)
+          buf2.<<("()\n    end\n  ", false)
+          #puts "\nAppending on bufit, second iteration"
+          #puts "|#{buf2.to_s}|"
+        bufit.<<(buf2.to_s, true)
+          #puts "\nAfter append"
+          #puts "|#{bufit.to_s}|"
+      #puts "\nAppending bufit on buf"
+      #puts "|#{buf.to_s}|"
+      buf.<<(bufit.to_s, true)
+      #puts "\nAfter append"
+      #puts "|#{buf.to_s}|"
+      buf.<<("\n\nend", false)
+      #puts "\nNow, we've done"
+      #puts buf
+      expected = "module MyModule\n\n  def hello()\n  end\n  \n  def strip()\n  end\n\n\nend"
+      assert_equal(expected, buf.to_s)
+    end
+    
+    def test_wlang_on_intelligent_buffer
+      template = <<-EOF
+        module +{name}
+          
+          *{defs as d}{
+            
+            def +{d}
+            end
+          }
+          
+        end
+      EOF
+      template = template.gsub(/ {8}/, '').strip
+      #puts template
+      context = {"name" => "MyModule", "defs" => ["hello", "strip", "toeol"]}
+      #puts template.wlang_instantiate(context, "wlang/ruby")
+    end
+    
+    def test_wlang_on_web_example
+      template = %q{
+        <table>
+          *{rows as r}{
+            <tr>
+              *{r as d}{
+                <td>+{d}</td>
+              }
+            </tr>
+          }
+        </table>
+      }.gsub(/^ {8}/, '').strip
+      #puts template
+      context = {"rows" => [[10, 11, 12], [20, 21, 22], [30, 31, 32]]}
+      #puts template.wlang_instantiate(context, "wlang/xhtml")
+    end    
+    
+  end # class IntelligentBufferTest
+end