wlang 0.8.4

data/test/wlang/othersymbols_test.rb

@@ -0,0 +1,16 @@
+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/wlang/parser_context_test.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'wlang'
+require 'wlang/parser_context'
+module WLang
+
+#
+# Tests WLang::Parser::Context class
+#
+class ParserContextTest < Test::Unit::TestCase
+  
+  # Sets a context instance
+  def setup
+    customer = Struct.new(:name, :address)
+    hash = {"name" => "blambeau", "age" => 28,
+            "customer" => customer.new("Dave", "123 Main")}
+    @context = WLang::Parser::Context.new(hash)
+  end
+  
+  # Tests Context#evaluate
+  def test_evaluate
+    assert_equal("blambeau", @context.evaluate("name"))
+    assert_equal(28, @context.evaluate("age"))
+    assert_equal("123 Main", @context.evaluate("customer.address"))
+    assert_not_nil @context.evaluate("self")
+  end
+  
+end # class ParserContextTest
+    
+end # module WLang

data/test/wlang/parser_test.rb

@@ -0,0 +1,89 @@
+require 'test/unit/testcase'
+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)
+    Parser.instantiator(Template.new(str, "example")).instantiate()[0]
+  end
+  
+  # Asserts the result of an instanciation
+  def assert_instanciation_equal(expected, template, msg=nil)
+    template = Template.new(template, "example")
+    parser = Parser.instantiator(template)
+    assert_equal(expected, parser.instantiate()[0])
+  end
+  
+  def test_parser_accepts_whole_tag
+    template, expected = "+{hello}", "HELLO"
+    assert_instanciation_equal(expected, template)
+    template, expected = " +{hello} ", " HELLO "
+    assert_instanciation_equal(expected, template)
+  end
+
+  def test_parser_accepts_whole_block
+    template, expected = "{hello}", "{hello}"
+    assert_instanciation_equal(expected, template)
+  end
+        
+  def test_parser_ignores_backslashed_tags
+    template, expected = "\\+{hello\\}", "+{hello}"
+    assert_instanciation_equal(expected, template)
+  end
+  
+  def test_parser_ignores_backslashed_blocks
+    template, expected = "\\{hello\\} world", "{hello} world"
+    assert_instanciation_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_instanciation_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", 1, 12)
+    assert_error_at_line_column("-{tag as i}{\n\n", 1, 12)
+    assert_error_at_line_column("-{tag as i}{\ntext\n", 2, 4)
+    assert_error_at_line_column("-{tag as i}{\n\ntext\n", 3, 4)
+    assert_error_at_line_column("-{tag as i}{\n\n\ntext\n", 4, 4)
+  end
+  
+end # ParserTest
+
+end # WLang

data/test/wlang/plain_text_dialect_test.rb

@@ -0,0 +1,21 @@
+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/wlang/ruby_dialect_test.rb

@@ -0,0 +1,100 @@
+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/wlang/ruby_expected.rb

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

data/test/wlang/ruby_template.wrb

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

data/test/wlang/ruleset_utils_test.rb

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