wlang 0.10.2 → 2.0.0.beta

data/test/standard_dialects/yaml/inclusion_1.tpl

@@ -1,2 +0,0 @@
----
-<<={data.rb as data}{+{data}}

data/test/standard_dialects/yaml/inclusion_2.exp

@@ -1,5 +0,0 @@
----
-authors: 
-  - blambeau
-  - llambeau
-  - ancailliau

data/test/standard_dialects/yaml/inclusion_2.tpl

@@ -1,3 +0,0 @@
----<<={data.rb as data}
-authors: 
-  +{data['authors']}

data/test/unit/test_all.rb

@@ -1,9 +0,0 @@
-$LOAD_PATH.unshift(File.expand_path('../../../', __FILE__))
-$LOAD_PATH.unshift(File.expand_path('../../../lib', __FILE__))
-require 'wlang'
-require 'test/unit'
-test_files = Dir[File.join(File.dirname(__FILE__), '**/*_test.rb')]
-test_files.each { |file|
-  require(file) 
-}
-

data/test/unit/wlang/anagram_bugs_test.rb

@@ -1,111 +0,0 @@
-# require 'test/unit'
-# require 'wlang'
-# module WLang
-# 
-#   # Tests the IntelligentBuffer class
-#   class AnagramBugsTest < Test::Unit::TestCase
-#     include IntelligentBuffer::Methods
-#    
-#     def test_on_anagram_spacing_policy
-#       WLang::dialect("anagram") do
-#         rule '=~' do |parser,offset|
-#           match, reached = parser.parse(offset, "wlang/dummy")
-#           block, reached = parser.parse_block(reached, "wlang/dummy")
-# 
-#           # puts "Here is the block ==="
-#           # puts "#{block.gsub(/ /, '.').gsub(/\n/, "\\n\n")}"
-#           # puts "=== Here is the block"
-# 
-#           [block, reached]
-#         end
-#       end
-#       template = %q{
-#         =~{String}{
-#           this is an anagram template
-#         }
-#       }.gsub(/^ {8}/, '').strip
-#       result = template.wlang_instantiate({}, "anagram")
-#       #assert IntelligentBuffer===result
-# #      assert_equal("this is an anagram template", result)
-# 
-#       template = %q{
-#         =~{String}{
-#           module MyModule
-#           end
-#         }
-#       }.gsub(/^ {8}/, '').strip
-#       result = template.wlang_instantiate({}, "anagram")
-#       #assert IntelligentBuffer===result
-#       assert_equal("module MyModule\nend\n", result)
-#     end
-#     
-#     def test_missing_end_bug
-#       WLang::dialect("anagram") do
-#         rules WLang::RuleSet::Basic
-#         rules WLang::RuleSet::Imperative
-#         rule '=~' do |parser,offset|
-#           match, reached = parser.parse(offset, "wlang/dummy")
-#           match = parser.evaluate(match)
-#           block, reached = parser.parse_block(reached, "wlang/dummy")
-#           block = block.strip_block(block)
-#           block = block.tabto(block,0)
-#           parser.evaluate("matching_rules") << [match, block]
-#     
-#           # puts "Here is the block ==="
-#           # puts "#{block.gsub(/ /, '.').gsub(/\n/, "\\n\n")}"
-#           # puts "=== Here is the block"
-#     
-#           ["", reached]
-#         end
-#         rule '+~' do |parser,offset|
-#           what, reached = parser.parse(offset, "wlang/dummy")
-#           evaluated = parser.evaluate(what)
-#           raise "Unexpected case, #{what} leads to nil" unless evaluated
-#     
-#           rules = parser.evaluate("matching_rules")
-#           found = rules.find {|r| r[0]===evaluated}
-#           raise "Unexpected case: no match for #{what.class}" unless found
-#     
-#           context = {"n" => evaluated, "matching_rules" => rules}
-#           inst = found[1].wlang_instantiate(context, "anagram")
-#           
-#           inst2 = inst.gsub(/ /, '.').gsub(/\n/, "\\n\n")
-#           # puts "Here is the inst ==="
-#           # puts "#{inst2}"
-#           # puts "=== Here is the inst"
-#           
-#           found = [inst, reached]
-#         end
-#       end
-#       template = %Q{
-#         =~{Array}{
-#           module MyModule
-#             *{n as c}{
-#               +~{c}
-#             }
-#           end
-#         }
-#         =~{Integer}{
-#           +{n}
-#         }
-#         +~{n}
-#       }.gsub(/ {8}/,'').strip
-#       context = {'n' => [10, 20, 30], 'matching_rules' => []}
-#       result = template.wlang_instantiate(context, "anagram")
-#     
-#       # template = template.gsub(/ /, '.').gsub(/\n/, "\\n\n")
-#       # puts "Here is the template ==="
-#       # puts "#{template}"
-#       # puts "=== Here is the template"
-#     
-#       # result = result.gsub(/ /, '.').gsub(/\n/, "\\n\n")
-#       # puts "Here is the result ==="
-#       # puts "#{result}"
-#       # puts "=== Here is the result"
-#       result = result.strip
-#       expected = "module MyModule\n  10\n  \n  20\n  \n  30\n\nend"
-#       assert_equal expected, result
-#     end
-#     
-#   end
-# end

data/test/unit/wlang/basic_ruleset_test.rb

@@ -1,52 +0,0 @@
-require 'test/unit'
-require 'wlang'
-require File.join(File.dirname(__FILE__), 'test_utils.rb')
-require 'wlang/rulesets/basic_ruleset'
-require 'wlang/rulesets/context_ruleset'
-require 'wlang/rulesets/buffering_ruleset'
-
-# Tests the Basic ruleset
-class WLang::BasicRuleSetTest < Test::Unit::TestCase
-  include WLang::TestUtils
-  
-  # Installs a dialect on wlang
-  def setup
-    WLang::dialect "basic-test" do 
-      rules WLang::RuleSet::Basic
-      rules WLang::RuleSet::Context
-      rules WLang::RuleSet::Buffering
-    end
-  end
-
-  # tests !{wlang/hosted} operator
-  def test_execution
-    tests = [
-      ["!{name}", "blambeau", {"name" => "blambeau"}],
-      ["!{!{var}}", "blambeau", {"var" => "name", "name" => "blambeau"}],
-      ["!{'hello'.upcase}", "HELLO", {}]
-    ]
-    tests.each do |t|
-      template, expected, context = t
-      result = template.wlang(context, "basic-test")
-      assert_equal(expected, result) 
-    end
-  end
-    
-  # Tests recursive_application rule
-  def test_recursive_application
-    tests = [
-      ["#={code}{%{wlang/dummy}{+{variable}}}"\
-       "%!{basic-test with variable: 'hello'}{+{code}}", "hello"],
-      ["<<={data.rb as context}"\
-       "#={code}{%{wlang/dummy}{+{author}}}"\
-       "%!{basic-test using context}{+{code}}", "blambeau"]
-    ]
-    tests.each do |test|
-      template, expected = test
-      template = relative_template(template, "basic-test", __FILE__)
-      result = template.instantiate()
-      assert_equal(expected, result)
-    end
-  end
-  
-end # class WLang::BasicRuleSetTest

data/test/unit/wlang/buffering_ruleset_test.rb

@@ -1,102 +0,0 @@
-require 'test/unit'
-require 'wlang'
-require File.join(File.dirname(__FILE__), '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/unit/wlang/buffering_template1.wtpl

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

data/test/unit/wlang/buffering_template2.wtpl

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

data/test/unit/wlang/buffering_template3.wtpl

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

data/test/unit/wlang/buffering_template4.wtpl

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

data/test/unit/wlang/buffering_template5.wtpl

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

data/test/unit/wlang/context_ruleset_test.rb

@@ -1,32 +0,0 @@
-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/unit/wlang/data.rb

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

data/test/unit/wlang/encoder_set_test.rb

@@ -1,42 +0,0 @@
-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/unit/wlang/imperative_ruleset_test.rb

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