radius 0.0.2 → 0.5.0

data/test/radius_test.rb

@@ -1,84 +1,54 @@
 require 'test/unit'
 require 'radius'
 
-class TestContext < Radius::Context
-  def initialize
-    @prefix = "test"
-    @items = ["Larry", "Moe", "Curly"]
-  end
-  
-  def echo(attr)
-    attr["text"]
-  end
-  
-  def add(attr)
-    (attr["param1"].to_i + attr["param2"].to_i).to_s
-  end
-  
-  def reverse(attr)
-    yield.reverse
-  end
+module RadiusTestHelper
+  class TestContext < Radius::Context; end
   
-  def capitalize(attr)
-    yield.upcase
-  end
-  
-  def count(attr)
-    case
-    when attr["set"]
-      @count = attr["set"].to_i
-      ""
-    when attr["inc"] == "true"
-      @count = (@count || 0) + 1
-      ""
-    else
-      @count.to_s       
+  def new_context
+    Radius::Context.new do |c|
+      c.define_tag("reverse"   ) { |tag| tag.expand.reverse }
+      c.define_tag("capitalize") { |tag| tag.expand.upcase  }
+      c.define_tag("attr")       { |tag| tag.attr.inspect }
     end
   end
   
-  def repeat(attr)
-    string = ''
-    (attr['count'] || '1').to_i.times { string << yield }
-    string
-  end
-  
-  def each_item(attr)
-    result = []
-    @items.each { |@item| result << yield }
-    @item = nil
-    result.join(attr["between"] || "")
-  end
-  
-  def item(attr)
-    @item
-  end
-  
-  def hello(attr)
-    "Hello #{attr['name'] || 'World'}!"
+  def define_tag(name, options = {}, &block)
+    @context.define_tag name, options, &block
   end
 end
 
 class RadiusContextTest < Test::Unit::TestCase
+  include RadiusTestHelper
+  
   def setup
-    @context = TestContext.new
+    @context = new_context
   end
   
   def test_initialize
     @context = Radius::Context.new
-    assert_equal 'radius', @context.prefix
   end
   
-  def test_render_tag__individual
-    text = @context.render_tag('hello')
-    assert_equal('Hello World!', text)
-
-    text = @context.render_tag('hello', 'name' => 'John')
-    assert_equal('Hello John!', text)
+  def test_initialize_with_block
+    @context = Radius::Context.new do |c|
+      assert_kind_of Radius::Context, c
+      c.define_tag('test') { 'just a test' }
+    end
+    assert_not_equal Hash.new, @context.definitions
+  end
+  
+  def test_with
+    got = @context.with do |c|
+      assert_equal @context, c
+    end
+    assert_equal @context, got
   end
   
-  def test_render_tag__container
-    text = @context.render_tag('repeat', 'count' => '5') { 'o' }
-    assert_equal('ooooo', text)
+  def test_render_tag
+    define_tag "hello" do |tag|
+      "Hello #{tag.attr['name'] || 'World'}!"
+    end
+    assert_render_tag_output 'Hello World!', 'hello'
+    assert_render_tag_output 'Hello John!', 'hello', 'name' => 'John'
   end
   
   def test_render_tag__undefined_tag
@@ -86,14 +56,6 @@ class RadiusContextTest < Test::Unit::TestCase
     assert_equal "undefined tag `undefined_tag'", e.message
   end
   
-  def test_render_tag__undefined_tag_with_wrong_signature
-    class << @context
-      def helper_method
-      end
-    end
-    assert_raises(Radius::UndefinedTagError) { @context.render_tag('helper_method') }
-  end
-  
   def test_tag_missing
     class << @context
       def tag_missing(tag, attr, &block)
@@ -102,68 +64,256 @@ class RadiusContextTest < Test::Unit::TestCase
     end
     
     text = ''
-    assert_nothing_raised { text = @context.render_tag('undefined_tag', 'cool' => 'beans') }
-    
     expected = %{undefined tag `undefined_tag' with attributes {"cool"=>"beans"}}
+    assert_nothing_raised { text = @context.render_tag('undefined_tag', 'cool' => 'beans') }
     assert_equal expected, text
   end
+  
+  private
+    
+    def assert_render_tag_output(output, *render_tag_params)
+      assert_equal output, @context.render_tag(*render_tag_params)
+    end
+  
 end
 
 class RadiusParserTest < Test::Unit::TestCase
+  include RadiusTestHelper
+  
   def setup
-    @t = Radius::Parser.new(TestContext.new )
+    @context = new_context
+    @parser = Radius::Parser.new(@context, :tag_prefix => 'r')
   end
   
-  def test_parse_individual
-    r = @t.parse_individual(%{<<test:echo text="hello world!" />>})
-    assert_equal("<hello world!>", r)
-
-    r = @t.parse_individual(%{<test:add param1="1" param2='2'/>})
-    assert_equal("3", r)
-
-    r = @t.parse_individual(%{a <test:echo text="3 + 1 =" /> <test:add param1="3" param2="1"/> b})
-    assert_equal("a 3 + 1 = 4 b", r)
+  def test_initialize
+    @parser = Radius::Parser.new
+    assert_kind_of Radius::Context, @parser.context
+  end
+  
+  def test_initialize_with_params
+    @parser = Radius::Parser.new(TestContext.new)
+    assert_kind_of TestContext, @parser.context
+    
+    @parser = Radius::Parser.new(:context => TestContext.new)
+    assert_kind_of TestContext, @parser.context
+    
+    @parser = Radius::Parser.new('context' => TestContext.new)
+    assert_kind_of TestContext, @parser.context
+    
+    @parser = Radius::Parser.new(:tag_prefix => 'r')
+    assert_kind_of Radius::Context, @parser.context
+    assert_equal 'r', @parser.tag_prefix
+    
+    @parser = Radius::Parser.new(TestContext.new, :tag_prefix => 'r')
+    assert_kind_of TestContext, @parser.context
+    assert_equal 'r', @parser.tag_prefix
+  end
+  
+  def test_parse_individual_tags_and_parameters
+    define_tag "add" do |tag|
+      tag.attr["param1"].to_i + tag.attr["param2"].to_i
+    end
+    assert_parse_output "<3>", %{<<r:add param1="1" param2='2'/>>}
   end
   
   def test_parse_attributes
-    r = @t.parse_attributes(%{ a="1" b='2'c="3"d="'" })
-    assert_equal({"a" => "1", "b" => "2", "c" => "3", "d" => "'"}, r)
+    attributes = %{{"a"=>"1", "b"=>"2", "c"=>"3", "d"=>"'"}}
+    assert_parse_output attributes, %{<r:attr a="1" b='2'c="3"d="'" />}
+    assert_parse_output attributes, %{<r:attr a="1" b='2'c="3"d="'"></r:attr>}
   end
   
-  def test_parse
-    r = @t.parse(%{<<test:echo text="hello world!" />>})
-    assert_equal("<hello world!>", r)
-
-    r = @t.parse("<test:reverse>test</test:reverse>")
-    assert_equal("test".reverse, r)
-
-    r = @t.parse("<test:reverse>test</test:reverse> <test:capitalize>test</test:capitalize>")
-    assert_equal("tset TEST", r)
-    
-    r = @t.parse("<test:echo text='hello world!' /> cool: <test:reverse>a <test:capitalize>test</test:capitalize> b</test:reverse> !")
-    assert_equal("hello world! cool: b TSET a !", r)
+  def test_parse_attributes_with_slashes_or_angle_brackets
+    slash = %{{"slash"=>"/"}}
+    angle = %{{"angle"=>">"}}
+    assert_parse_output slash, %{<r:attr slash="/"></r:attr>}
+    assert_parse_output slash, %{<r:attr slash="/"><r:attr /></r:attr>}
+    assert_parse_output angle, %{<r:attr angle=">"></r:attr>}
+  end
+  
+  def test_things_that_should_be_left_alone
+    # The parser currently fails on these assertions
+    #assert_parsed_either_way_is_unchanged %{ test="2"="4" }
+    #assert_parsed_either_way_is_unchanged %{="2" }
+  end
     
-    r = @t.parse("<test:reverse><test:echo text='hello world!' /></test:reverse>")
-    assert_equal("!dlrow olleh", r)
-
-    r = @t.parse("<test:reverse><test:capitalize>test</test:capitalize> <test:echo text='hello world!' /></test:reverse>")
-    assert_equal("!dlrow olleh TSET", r)
-
-    r = @t.parse("<test:reverse>12<test:capitalize>at</test:capitalize>34</test:reverse>")
-    assert_equal("43TA21", r)
+  def test_parse_result_is_always_a_string
+    define_tag("twelve") { 12 }
+    assert_parse_output "12", "<r:twelve />"
   end
-  def test_parse__looping
-    r = @t.parse(%{<test:count set="0" /><test:repeat count="5"><test:count inc="true" /><test:count /></test:repeat>})
-    assert_equal("12345", r)
-
-    r = @t.parse(%{Three Stooges: <test:each_item between=", ">"<test:item />"</test:each_item>})
-    assert_equal(%{Three Stooges: "Larry", "Moe", "Curly"}, r)
+  
+  def test_parse_double_tags
+    assert_parse_output "test".reverse, "<r:reverse>test</r:reverse>"
+    assert_parse_output "tset TEST", "<r:reverse>test</r:reverse> <r:capitalize>test</r:capitalize>"
+  end
+  
+  def test_parse_tag_nesting
+    define_tag("parent", :for => '')
+    define_tag("parent:child", :for => '')
+    define_tag("extra", :for => '')
+    define_tag("nesting") { |tag| tag.nesting }
+    define_tag("extra:nesting") { |tag| tag.nesting.gsub(':', ' > ') }
+    define_tag("parent:child:nesting") { |tag| tag.nesting.gsub(':', ' * ') }
+    assert_parse_output "nesting", "<r:nesting />"
+    assert_parse_output "parent:nesting", "<r:parent:nesting />"
+    assert_parse_output "extra > nesting", "<r:extra:nesting />"
+    assert_parse_output "parent * child * nesting", "<r:parent:child:nesting />"
+    assert_parse_output "parent > extra > nesting", "<r:parent:extra:nesting />"
+    assert_parse_output "parent > child > extra > nesting", "<r:parent:child:extra:nesting />"
+    assert_parse_output "parent * extra * child * nesting", "<r:parent:extra:child:nesting />"
+    assert_parse_output "parent > extra > child > extra > nesting", "<r:parent:extra:child:extra:nesting />"
+    assert_parse_output "parent > extra > child > extra > nesting", "<r:parent><r:extra><r:child><r:extra><r:nesting /></r:extra></r:child></r:extra></r:parent>"
+    assert_parse_output "extra * parent * child * nesting", "<r:extra:parent:child:nesting />"
+    assert_parse_output "extra > parent > nesting", "<r:extra><r:parent:nesting /></r:extra>"
+    assert_parse_output "extra * parent * child * nesting", "<r:extra:parent><r:child:nesting /></r:extra:parent>"
+    assert_raises(Radius::UndefinedTagError) { @parser.parse("<r:child />") }
+  end
+  
+  def test_parse_tag_nesting_2
+    define_tag("parent", :for => '')
+    define_tag("parent:child", :for => '')
+    define_tag "content" do |tag|
+      tag.nesting
+    end
+    assert_parse_output 'parent:child:content', '<r:parent><r:child:content /></r:parent>'
+  end
+  
+  def test_parse_tag__binding_do_missing
+    define_tag 'test' do |tag|
+      tag.missing!
+    end
+    e = assert_raises(Radius::UndefinedTagError) { @parser.parse("<r:test />") }
+    assert_equal "undefined tag `test'", e.message
+  end
+  
+  def test_parse_tag__binding_render_tag
+    define_tag('test') { |tag| "Hello #{tag.attr['name']}!" }
+    define_tag('hello') { |tag| tag.render('test', tag.attr) }
+    assert_parse_output 'Hello John!', '<r:hello name="John" />'
+  end
+  def test_parse_tag__binding_render_tag_with_block
+    define_tag('test') { |tag| "Hello #{tag.expand}!" }
+    define_tag('hello') { |tag| tag.render('test') { tag.expand } }
+    assert_parse_output 'Hello John!', '<r:hello>John</r:hello>'
+  end
+  
+  def test_tag_locals
+    define_tag "outer" do |tag|
+      tag.locals.var = 'outer'
+      tag.expand
+    end
+    define_tag "outer:inner" do |tag|
+      tag.locals.var = 'inner'
+      tag.expand
+    end
+    define_tag "outer:var" do |tag|
+      tag.locals.var
+    end
+    assert_parse_output 'outer', "<r:outer><r:var /></r:outer>"
+    assert_parse_output 'outer:inner:outer', "<r:outer><r:var />:<r:inner><r:var /></r:inner>:<r:var /></r:outer>"
+    assert_parse_output 'outer:inner:outer:inner:outer', "<r:outer><r:var />:<r:inner><r:var />:<r:outer><r:var /></r:outer>:<r:var /></r:inner>:<r:var /></r:outer>"
+    assert_parse_output 'outer', "<r:outer:var />"
+  end
+  
+  def test_tag_globals
+    define_tag "set" do |tag|
+      tag.globals.var = tag.attr['value']
+      ''
+    end
+    define_tag "var" do |tag|
+      tag.globals.var
+    end
+    assert_parse_output "  true  false", %{<r:var /> <r:set value="true" /> <r:var /> <r:set value="false" /> <r:var />}
   end
   
-  def test_parse__fail_on_no_end_tag
-    assert_raises(Radius::MissingEndTagError) { @t.parse("<test:reverse>") }
+  def test_parse_loops
+    @item = nil
+    define_tag "each" do |tag|
+      result = []
+      ["Larry", "Moe", "Curly"].each do |item|
+        tag.locals.item = item
+        result << tag.expand
+      end
+      result.join(tag.attr["between"] || "")
+    end
+    define_tag "each:item" do |tag|
+      tag.locals.item
+    end
+    assert_parse_output %{Three Stooges: "Larry", "Moe", "Curly"}, %{Three Stooges: <r:each between=", ">"<r:item />"</r:each>}
   end
-  def test_parse__fail_on_no_end_tag_2
-    assert_raises(Radius::MissingEndTagError) { @t.parse("<test:reverse><test:capitalize></test:reverse>") }
+  
+  def test_tag_option_for
+    define_tag 'fun', :for => 'just for kicks'
+    assert_parse_output 'just for kicks', '<r:fun />'
   end
+  
+  def test_tag_expose_option
+    define_tag 'user', :for => users.first, :expose => ['name', :age]
+    assert_parse_output 'John', '<r:user:name />'
+    assert_parse_output '25', '<r:user><r:age /></r:user>'
+    e = assert_raises(Radius::UndefinedTagError) { @parser.parse "<r:user:email />" }
+    assert_equal "undefined tag `email'", e.message
+  end
+  
+  def test_tag_expose_attributes_option_on_by_default
+    define_tag 'user', :for => user_with_attributes
+    assert_parse_output 'John', '<r:user:name />'
+  end
+  def test_tag_expose_attributes_set_to_false
+    define_tag 'user_without_attributes', :for => user_with_attributes, :attributes => false
+    assert_raises(Radius::UndefinedTagError) { @parser.parse "<r:user_without_attributes:name />" }
+  end
+  
+  def test_tag_options_must_contain_a_for_option_if_methods_are_exposed
+    e = assert_raises(ArgumentError) { define_tag('fun', :expose => :today) { 'test' } }
+    assert_equal "tag definition must contain a :for option when used with the :expose option", e.message
+  end
+  
+  def test_parse_fail_on_missing_end_tag
+    assert_raises(Radius::MissingEndTagError) { @parser.parse("<r:reverse>") }
+    assert_raises(Radius::MissingEndTagError) { @parser.parse("<r:reverse><r:capitalize></r:reverse>") }
+  end
+  
+  protected
+  
+    def assert_parse_output(output, input, message = nil)
+      r = @parser.parse(input)
+      assert_equal(output, r, message)
+    end
+    
+    def assert_parsed_is_unchanged(something)
+      assert_parse_output something, something
+    end
+    
+    def assert_parsed_either_way_is_unchanged(middle)
+      assert_parsed_is_unchanged %{<r:attr#{middle}/>}
+      assert_parsed_is_unchanged %{<r:attr#{middle}></r:attr>}
+    end
+    
+    class User
+      attr_accessor :name, :age, :email, :friend
+      def initialize(name, age, email)
+        @name, @age, @email = name, age, email
+      end
+      def <=>(other)
+        name <=> other.name
+      end
+    end
+    
+    class UserWithAttributes < User
+      def attributes
+        { :name => name, :age => age, :email => email }
+      end
+    end
+    
+    def users
+      [
+        User.new('John', 25, 'test@johnwlong.com'),
+        User.new('James', 27, 'test@jameslong.com')
+      ]
+    end
+    
+    def user_with_attributes
+      UserWithAttributes.new('John', 25, 'test@johnwlong.com')
+    end
+  
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: radius
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2006-02-14
+  version: 0.5.0
+date: 2006-05-01
 summary: Powerful tag-based template system.
 require_paths: 
   - lib
@@ -29,8 +29,8 @@ platform: ruby
 authors: []
 files: 
   - CHANGELOG
-  - DSL-SPEC
   - lib
+  - pkg
   - QUICKSTART
   - Rakefile
   - README
@@ -49,7 +49,6 @@ extra_rdoc_files:
   - README
   - QUICKSTART
   - ROADMAP
-  - DSL-SPEC
   - CHANGELOG
 executables: []
 extensions: []