wlang 0.10.2 → 2.0.0.beta

data/test/unit/wlang/intelligent_buffer_test.rb

@@ -1,194 +0,0 @@
-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

data/test/unit/wlang/othersymbols_test.rb

@@ -1,16 +0,0 @@
-require 'wlang'
-require 'test/unit'
-module WLang
-  class OtherSymbolsTest < Test::Unit::TestCase
-    
-    def test_on_parentheses
-      template = "+{who}"
-      assert_equal 'blambeau', WLang.instantiate(template, {'who' => 'blambeau'}, 'wlang/active-string', :braces).to_s
-      template = "+(who)"
-      assert_equal 'blambeau', WLang.instantiate(template, {'who' => 'blambeau'}, 'wlang/active-string', :parentheses).to_s
-      template = "+[who]"
-      assert_equal 'blambeau', WLang.instantiate(template, {'who' => 'blambeau'}, 'wlang/active-string', :brackets).to_s
-    end
-    
-  end
-end

data/test/unit/wlang/parser_test.rb

@@ -1,88 +0,0 @@
-require 'test/unit'
-require 'wlang'
-module WLang
-  
-class ParserTest < Test::Unit::TestCase
-
-  # Installs some dialects on wlang
-  def setup
-    # wlang dialect, empty by default
-    WLang::dialect "example" do 
-      rule '+' do |parser,offset|
-        parsed, reached = parser.parse(offset)
-        [parsed.upcase, reached]
-      end
-      rule '-' do |parser,offset|
-        parsed, reached = parser.parse(offset)
-        [parsed.downcase, reached]
-      end
-    end
-  end
-  
-  # Instantiate the given string as template
-  def instantiate_str(str)
-    WLang::template(str, "example").instantiate
-  end
-  
-  # Asserts the result of an instanciation
-  def assert_instantiation_equal(expected, template, msg=nil)
-    template = WLang::template(template, "example")
-    assert_equal(expected, template.instantiate)
-  end
-  
-  def test_parser_accepts_whole_tag
-    template, expected = "+{hello}", "HELLO"
-    assert_instantiation_equal(expected, template)
-    template, expected = " +{hello} ", " HELLO "
-    assert_instantiation_equal(expected, template)
-  end
-
-  def test_parser_accepts_whole_block
-    template, expected = "{hello}", "{hello}"
-    assert_instantiation_equal(expected, template)
-  end
-        
-  def test_parser_ignores_backslashed_tags
-    template, expected = "\\+{hello\\}", "+{hello}"
-    assert_instantiation_equal(expected, template)
-  end
-  
-  def test_parser_ignores_backslashed_blocks
-    template, expected = "\\{hello\\} world", "{hello} world"
-    assert_instantiation_equal(expected, template)
-  end
-  
-  def test_parser_on_a_complex_case
-    template = "Hello \\\\} world! -{ITEMS AS I}{do +{something} \\{with \\} i} here is my name:+{name} and { that's not -{COMMON} text } !\\{"
-    expected = "Hello \\} world! items as i{do SOMETHING {with } i} here is my name:NAME and { that's not common text } !\{"
-    assert_instantiation_equal(expected, template)
-  end
-  
-  def test_parser_raises_error
-    # Unclosed tag    
-    assert_raise(ParseError){instantiate_str("-{unclosedtag")}
-  end
-
-  def assert_error_at_line_column(template, line, column)
-    begin
-      instantiate_str(template)
-      assert(false)
-    rescue ParseError => ex
-      assert_equal ex.line, line, "Line matches"
-      assert_equal ex.column, column, "Column matches"
-    end
-  end
-  
-  def test_parser_error_find_line_and_column
-    assert_error_at_line_column("-{tag", 1, 5)
-    assert_error_at_line_column("-{tag with spaces   ", 1, 20)
-    assert_error_at_line_column("-{tag as i}{\n", 2, 0)
-    assert_error_at_line_column("-{tag as i}{\n\n", 3, 0)
-    assert_error_at_line_column("-{tag as i}{\ntext\n", 3, 0)
-    assert_error_at_line_column("-{tag as i}{\n\ntext\n", 4, 0)
-    assert_error_at_line_column("-{tag as i}{\n\n\ntext\n", 5, 0)
-  end
-  
-end # ParserTest
-
-end # WLang

data/test/unit/wlang/plain_text_dialect_test.rb

@@ -1,21 +0,0 @@
-require 'test/unit/testcase'
-require 'wlang'
-require 'wlang/dialects/plain_text_dialect'
-
-class WLang::PlainTestDialectTest < Test::Unit::TestCase
-  
-  # Tests the camel case function
-  def test_camel_case
-    tests = [
-      ["blambeau", "Blambeau"],
-      ["the world and the cat", "TheWorldAndTheCat"],
-      ["\nthe\t world   and-the_cat", "TheWorldAndTheCat"],
-      #["l'éléphant", "LElephant"],
-    ]
-    tests.each do |t|
-      src, expected = t
-      assert_equal(expected, WLang::EncoderSet::PlainText.camel_case(src, nil))
-    end
-  end
-  
-end

data/test/unit/wlang/ruby_dialect_test.rb

@@ -1,100 +0,0 @@
-require 'test/unit/testcase'
-require 'wlang'
-require 'wlang/dialects/standard_dialects'
-module WLang
-
-# Tests the ruby dialect
-class RubyDialectTest < Test::Unit::TestCase
-  
-  def get_file_contents(file)
-    file = File.join(File.dirname(__FILE__), file)
-    File.read(file)
-  end
-  
-  # Tests on template in HERE documents above 
-  def test_on_template 
-    $context = {"name" => "O'Neil"}
-    $template = get_file_contents('ruby_template.wrb')
-    $expected = get_file_contents('ruby_expected.rb')
-    result =  $template.wlang($context, "wlang/ruby")
-    # puts "\n--template--"
-    # puts $template
-    # puts "\n--expected--"
-    # puts $expected
-    # puts "\n--result--"
-    # puts result
-    assert_equal($expected,result)
-  end
-  
-  # Tests single quoting
-  def test_single_quoting
-    context = {}
-    tests = [
-      ["Hello world!", "Hello world!"],
-      ["Hello &'{world}!", "Hello world!"],
-      ["Hello &'{men's world}!", "Hello men\\'s world!"],
-      ["puts 'Hello &'{men's world}!'", "puts 'Hello men\\'s world!'"],
-      ["Hello O\'Neil", "Hello O\'Neil"],
-      ["Hello O\\'Neil", "Hello O\\'Neil"],
-      ["Hello O\\\\'Neil", "Hello O\\\\'Neil"],
-    ]
-    tests.each do |test|
-      expected = test[1]
-      result = test[0].wlang(context, "wlang/ruby")
-      assert_equal(expected, result)
-    end
-  
-    context = {"name" => %q{O\'Neil}}
-    template = %q{puts '{name}'}
-    expected = %q{puts 'O\'Neil'}
-    result = template.wlang(context, "wlang/ruby")
-    assert_equal(expected, result)
-  end
-  
-  # Tests double quoting
-  def test_double_quoting
-    context = {}
-    tests = [
-      ['Hello world!', 'Hello world!'],
-      ['Hello &"{world}!', 'Hello world!'],
-      ['Hello &"{men"s world}!', 'Hello men\\"s world!'],
-      ['puts "Hello &"{men"s world}!"', 'puts "Hello men\\"s world!"']
-    ]
-    tests.each do |test|
-      expected = test[1]
-      result = test[0].wlang(context, "wlang/ruby")
-      assert_equal(expected, result)
-    end
-  end
-  
-  # Tests single quoted
-  def test_single_quoted
-    context = {"name" => "blambeau", "mensworld" => "men's world"}
-    tests = [
-      ["puts '{name}'", "puts 'blambeau'"],
-      ["puts '{mensworld}'", "puts 'men\\'s world'"],
-    ]
-    tests.each do |test|
-      expected = test[1]
-      result = test[0].wlang(context, "wlang/ruby")
-      assert_equal(expected, result)
-    end
-  end
-
-  # Tests double quoted
-  def test_double_quoted
-    context = {"name" => "blambeau", "mensworld" => 'men"s world'}
-    tests = [
-      ['puts "{name}"', 'puts "blambeau"'],
-      ['puts "{mensworld}"', 'puts "men\\"s world"'],
-    ]
-    tests.each do |test|
-      expected = test[1]
-      result = test[0].wlang(context, "wlang/ruby")
-      assert_equal(expected, result)
-    end
-  end
-  
-end # class RubyDialectTest
-    
-end # module WLang

data/test/unit/wlang/ruby_expected.rb

@@ -1,3 +0,0 @@
-puts 'Hello world'
-puts 'Hello O\'Neil'
-puts 'O\'Neil'

data/test/unit/wlang/ruby_template.wrb

@@ -1,3 +0,0 @@
-puts '&'{Hello world}'
-puts '&'{Hello O'Neil}'
-puts '{name}'

data/test/unit/wlang/ruleset_utils_test.rb

@@ -1,245 +0,0 @@
-require 'test/unit'
-require 'wlang'
-require 'wlang/rulesets/ruleset_utils'
-
-# Tests the ruleset utilities.
-class WLang::RuleSetUtilsTest < Test::Unit::TestCase
-  include WLang::RuleSet::Utils
-  
-  # Tests decoding qdialects
-  def test_decode_qdialect()
-    tests = ["wlang", "xhtml", "\nxhtml  ", "plain-text", "wlang/plain-text", "  wlang/sql"]
-    tests.each do |t|
-      expected = {:qdialect => t.strip}
-      result = WLang::RuleSet::Utils.expr(:qdialect).decode(t) 
-      assert_equal(expected, result)
-    end
-  end
-  
-  # Tests decoding qdialects
-  def test_decode_qdialect_as()
-    tests = ["wlang as var", "xhtml as var", "\nxhtml   as var ", 
-             "plain-text as var", "wlang/plain-text\tas\tvar", "  wlang/sql as var"]
-    tests.each do |t|
-      /^\s*([^\s]+)\s+as\s+([^\s]+)\s*$/ =~ t
-      expected = {:qdialect => $1, :as => $2}
-      result = WLang::RuleSet::Utils.expr(:qdialect, ["as", :var]).decode(t) 
-      assert_equal(expected, result)
-    end
-  end
-  
-  # Tests decoding qdialects
-  def test_decode_qdialect_as_with_optional()
-    tests = ["wlang", "xhtml", "\nxhtml  ", "plain-text", "wlang/plain-text", "  wlang/sql"]
-    tests.each do |t|
-      expected = {:qdialect => t.strip, :as => nil}
-      result = WLang::RuleSet::Utils.expr(:qdialect, ["as", :var, false]).decode(t) 
-      assert_equal(expected, result)
-    end
-  end
-  
-  def test_decode_with_a_with
-    source = "/hello with who: 'blambeau'"
-    result = WLang::RuleSet::Utils.expr(:expr, ["using", :using, false], ["with", :with, false]).decode(source) 
-    assert_equal({:expr => '/hello', :with => {'who' => "'blambeau'"}, :using => nil}, result)
-
-    source = "/hello using self with who: 'blambeau'"
-    result = WLang::RuleSet::Utils.expr(:expr, ["using", :using, false], ["with", :with, false]).decode(source) 
-    assert_equal({:expr => '/hello', :with => {'who' => "'blambeau'"}, :using => ['self']}, result)
-    
-    source = "buffering_template5.wtpl using self with who2: who"
-    result = WLang::RuleSet::Utils.expr(:uri, ["using", :using, false], ["with", :with, false]).decode(source) 
-    assert_equal({:uri => 'buffering_template5.wtpl', :with => {'who2' => "who"}, :using => ['self']}, result)
-  end
-  
-  def test_DIALECT_regexp
-    assert_not_nil(RG_DIALECT =~ "wlang")
-    assert_not_nil(RG_DIALECT =~ "xhtml")
-    assert_not_nil(RG_DIALECT =~ "\nxhtml  ")
-    assert_not_nil(RG_DIALECT =~ "plain-text")
-    assert_nil(RG_DIALECT =~ "wlang/plain-text")
-    assert_nil(RG_DIALECT =~ "  wlang/sql  ")
-    assert_nil(RG_DIALECT =~ "WLang")
-  end
-  
-  def test_ENCODER_regexp
-    assert_not_nil(RG_ENCODER =~ "entities-encoding")
-    assert_not_nil(RG_ENCODER =~ "quoting")
-    assert_not_nil(RG_ENCODER =~ "\nquoting  ")
-    assert_nil(RG_ENCODER =~ "xhtml/entities-encoding")
-    assert_nil(RG_ENCODER =~ "  wlang/quoting  ")
-    assert_nil(RG_ENCODER =~ "ENCODING")
-  end
-  
-  def test_QDIALECT_regexp
-    assert_not_nil(RG_QDIALECT =~ "wlang")
-    assert_not_nil(RG_QDIALECT =~ "wlang/plain-text")
-    assert_not_nil(RG_QDIALECT =~ "wlang/xhtml")
-    assert_not_nil(RG_QDIALECT =~ "wlang/sql")
-    assert_not_nil(RG_QDIALECT =~ "  wlang/sql  ")
-    assert_not_nil(RG_QDIALECT =~ "wlang/sql/sybase")
-    assert_nil(RG_QDIALECT =~ "WLang")
-    assert_nil(RG_QDIALECT =~ "wlang/ sql")
-    assert_nil(RG_QDIALECT =~ "WLang/sql")
-    assert_nil(RG_QDIALECT =~ "wlang/sql/ sybase")
-  end
-  
-  def test_QENCODER_regexp
-    assert_not_nil(RG_QENCODER =~ "entities-encoding")
-    assert_not_nil(RG_QENCODER =~ "html/entities-encoding")
-    assert_not_nil(RG_QENCODER =~ "sql/back-quoting")
-    assert_not_nil(RG_QENCODER =~ "sql/back-quoting   ")
-    assert_not_nil(RG_QENCODER =~ "sql/sybase/back-quoting")
-    assert_nil(RG_QENCODER =~ "sql/ sybase/back-quoting")
-  end
-  
-  def test_VAR_regexp
-    assert_not_nil(RG_VAR =~ "name")
-    assert_not_nil(RG_VAR =~ "name_with_underscore")
-    assert_not_nil(RG_VAR =~ "\nname_with_underscore  \t")
-    assert_nil(RG_VAR =~ "\nname _with_underscore  \t")
-    tests = [
-      [{:variable =>"name"}, "name"],
-      [{:variable =>"name_with_underscore"}, "\nname_with_underscore  \t"],
-      [nil, "\nname _with_underscore  \t"],
-    ]
-    tests.each do |t|
-      expected, src = t
-      assert_equal(expected, WLang::RuleSet::Utils.decode_var(src))
-    end
-  end
-  
-  def test_EXPR_regexp
-    assert_not_nil(RG_EXPR =~ "name")
-    assert_not_nil(RG_EXPR =~ "[12, 13]")
-    assert_not_nil(RG_EXPR =~ "Kernel.eval('some expression')")
-  end
-  
-  def test_QDIALECT_AS_regexp
-    assert_not_nil(RG_QDIALECT_AS =~ "wlang as x")
-    assert_not_nil(RG_QDIALECT_AS =~ "wlang/xhtml as var")
-    assert_not_nil(RG_QDIALECT_AS =~ "  wlang/xhtml as var  ")
-    assert_nil(RG_QDIALECT_AS =~ "wlang/xhtml")
-    assert_nil(RG_QDIALECT_AS =~ "wlang/xhtml as ")
-    tests = [
-      [{:dialect =>"wlang", :variable => "x"}, "wlang as x"],
-      [{:dialect =>"wlang", :variable => "var"}, "  wlang  as  var"],
-      [{:dialect =>"wlang/xhtml", :variable => "var"}, "  wlang/xhtml  as  var"],
-      [nil, "  wlang  as  "],
-    ]
-    tests.each do |t|
-      expected, src = t
-      assert_equal(expected, WLang::RuleSet::Utils.decode_qdialect_as(src))
-    end
-  end
-     
-  def test_QENCODER_AS_regexp
-    assert_not_nil(RG_QENCODER_AS =~ "entities as x")
-    assert_not_nil(RG_QENCODER_AS =~ "html/entities-encoding as var")
-    assert_not_nil(RG_QENCODER_AS =~ "  wlang/xhtml/entities-encoding as var  ")
-    assert_nil(RG_QENCODER_AS =~ "wlang/entities")
-    assert_nil(RG_QENCODER_AS =~ "wlang/quoting as ")
-    tests = [
-      [{:encoder =>"entities", :variable => "x"}, "entities as x"],
-      [{:encoder =>"entities", :variable => "var"}, "  entities  as  var"],
-      [{:encoder =>"xhtml/entities-encoding", :variable => "var"}, "  xhtml/entities-encoding  as  var"],
-      [nil, "  wlang  as  "],
-    ]
-    tests.each do |t|
-      expected, src = t
-      assert_equal(expected, WLang::RuleSet::Utils.decode_qencoder_as(src))
-    end
-  end
-  
-  def test_EXPR_AS_regexp
-    assert_not_nil(RG_EXPR_AS =~ "name as n")
-    assert_not_nil(RG_EXPR_AS =~ "name.upcase as n")
-    assert_not_nil(RG_EXPR_AS =~ "[12,13,15] as n")
-    assert_not_nil(RG_EXPR_AS =~ "[12,13, 15] as n")
-    assert_nil(RG_EXPR_AS =~ "name.upcase")
-    tests = [
-      [{:expr =>"name", :variable => "n"}, "name as n"],
-      [{:expr =>"name.upcase", :variable => "n"}, "name.upcase as n"],
-      [{:expr =>"name.upcase", :variable => "n"}, " name.upcase  as  n  "],
-      [{:expr =>"name/upcase", :variable => "n"}, " name/upcase  as  n  "],
-      [{:expr =>"[12, 15, 276, 'blamebau']", :variable => "n"}, " [12, 15, 276, 'blamebau']  as  n  "],
-      [{:expr =>"'what if a as here'", :variable => "n"}, " 'what if a as here'  as  n  "],
-    ]
-    tests.each do |t|
-      expected, src = t
-      assert_equal(expected, WLang::RuleSet::Utils.decode_expr_as(src))
-    end
-  end
-  
-  def test_URI_AS_regexp
-    assert_not_nil(RG_URI_AS =~ "file as f")
-    assert_not_nil(RG_URI_AS =~ "file.yaml as f")
-    assert_not_nil(RG_URI_AS =~ "folder/folder/file.ext as data")
-    assert_not_nil(RG_URI_AS =~ "http://folder/folder/file.ext as data")
-    assert_not_nil(RG_URI_AS =~ "http://folder/folder/as/file.ext as data")
-    assert_nil(RG_URI_AS =~ "name.upcase")
-    tests = [
-      [{:uri =>"file", :variable => "f"}, "file as f"],
-      [{:uri =>"file.yaml", :variable => "f"}, "file.yaml as f"],
-      [{:uri =>"folder/folder/file.ext", :variable => "data"}, "folder/folder/file.ext as data"],
-      [{:uri =>"http://folder/folder/file.ext", :variable => "data"}, "http://folder/folder/file.ext as data"],
-      [{:uri =>"http://folder/folder/as/file.ext", :variable => "data"}, "http://folder/folder/as/file.ext as data"],
-    ]
-    tests.each do |t|
-      expected, src = t
-      assert_equal(expected, WLang::RuleSet::Utils.decode_uri_as(src))
-    end
-  end
-  
-  def test_URI_WITH_regexp
-    tests = [
-      [{:uri =>"folder/file.yaml", :with => {"spec" => "spec"}}, "folder/file.yaml with spec: spec"],
-      [{:uri =>"folder/file.yaml", :with => {"a" => "a", "b" => "b"}}, 
-        "folder/file.yaml with   a    :a  , b : b"],
-      [{:uri =>"folder/file.yaml", :with => {"spec" => "spec.reverse"}}, "folder/file.yaml with spec: spec.reverse"],
-      [{:uri =>"folder/file.yaml", :with => {"s" => "spec", "t" => "spec/rulesets", "xs" => "spec/uses"}}, 
-        "folder/file.yaml with s:spec, t:spec/rulesets, xs:spec/uses"],
-    ]
-    tests.each do |t|
-      expected, src = t
-      assert_equal(expected, WLang::RuleSet::Utils.decode_uri_with(src,nil))
-    end
-  end
-     
-  def test_URI_WITH_regexp_with_optional
-    tests = [
-      [{:uri =>"file.yaml", :with => nil}, "file.yaml"],
-      [{:uri =>"folder/file.yaml", :with => nil}, "folder/file.yaml"],
-      [{:uri =>"folder/folder/file.ext", :with => nil}, "folder/folder/file.ext"],
-      [{:uri =>"http://folder/folder/with/file.ext", :with => nil}, "http://folder/folder/with/file.ext"],
-    ]
-    tests.each do |t|
-      expected, src = t
-      assert_equal(expected, WLang::RuleSet::Utils.decode_uri_with(src,nil,true))
-    end
-  end
-  
-  def test_MULTI_AS
-    rx = Regexp.new(WLang::RuleSet::Utils::MULTI_AS)
-    assert_not_nil rx  =~ "a"
-    assert_not_nil rx  =~ "a, b"
-    assert_not_nil rx  =~ "a , b"
-    assert_not_nil rx  =~ "a,b"
-    assert_not_nil rx  =~ "a,b,c"
-    assert_not_nil rx  =~ "a, b, c"
-    assert_not_nil rx  =~ "a , b , c"
-  end
-  
-  def test_decode_multi_as
-    tests = [
-      [["a"], "a"],
-      [["a", "b"], "a, b"],
-      [["a", "b"], "a,b"],
-      [["a", "b"], "a , b"],
-    ]
-    tests.each do |test|
-      assert_equal(test[0], WLang::RuleSet::Utils.decode_multi_as(test[1], nil))
-    end
-  end
-     
-end