radius19-radiant 1.0.0

data/test/dostruct_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestDOS
+  attr_accessor :name
+end
+
+class RadiusDelegatingOpenStructtTest < Test::Unit::TestCase
+  def new_dos(obj = nil)
+    Radius::DelegatingOpenStruct.new obj
+  end
+
+  def test_initialize_wo_object
+    o = new_dos nil
+    assert_nil o.object
+  end
+
+  def test_initialize_w_object
+    x = TestDOS.new
+    o = new_dos x
+    assert_equal o.object, x
+  end
+
+  def test_assign_and_read_vars
+    o = new_dos
+    o.age = 15
+    o.height = 3.5
+    assert_equal o.age, 15
+    assert_equal o.height, 3.5
+  end
+
+  def test_read_object
+    o = new_dos TestDOS.new
+    o.object.name = 'Peter'
+    assert_equal o.name, 'Peter'
+    assert_equal o.object.name, 'Peter'
+  end
+
+  def test_read_and_assign_mixed
+    o = new_dos TestDOS.new
+    o.object.name = 'Peter'
+    o.age = 15
+    assert_equal o.name, 'Peter'
+    assert_equal o.object.name, 'Peter'
+    assert_equal o.age, 15
+  end
+
+  def test_raise_on_unknown_method
+    o = new_dos TestDOS.new
+    assert_raise NoMethodError do
+      o.age
+    end
+  end
+end

data/test/parser_test.rb

@@ -0,0 +1,242 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RadiusParserTest < Test::Unit::TestCase
+  include RadiusTestHelper
+  
+  def setup
+    @context = new_context
+    @parser = Radius::Parser.new(@context, :tag_prefix => 'r')
+  end
+  
+  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
+    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_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_parse_quotes
+    assert_parse_output "test []", %{<r:echo value="test" /> <r:wrap attr="test"></r:wrap>}
+  end
+  
+  def test_things_that_should_be_left_alone
+    [
+      %{ test="2"="4" },
+      %{="2" } 
+    ].each do |middle|
+      assert_parsed_is_unchanged "<r:attr#{middle}/>"
+      assert_parsed_is_unchanged "<r:attr#{middle}>"
+    end
+  end
+    
+  def test_parse_result_is_always_a_string
+    define_tag("twelve") { 12 }
+    assert_parse_output "12", "<r:twelve />"
+  end
+  
+  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") { |tag| tag.nesting }
+    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_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_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
+    
+    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

data/test/tagbinding_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RadiusTagBindingTest < Test::Unit::TestCase
+  include RadiusTestHelper
+  
+  def new_tag_binding(opts = {})
+    opts = {
+      :cnx => new_context,
+      :locals => Radius::DelegatingOpenStruct.new,
+      :name => :test,
+      :attrs => {},
+      :blk => Proc.new { 'hello!'}
+    }.update(opts)
+    Radius::TagBinding.new opts[:cnx], opts[:locals], opts[:name], opts[:attrs], opts[:blk]
+  end
+
+  def test_initialize
+    nc = new_context
+    ls = Radius::DelegatingOpenStruct.new
+    nm = :xyz
+    as = { :a => 1, :b => 2 }
+    bk = Proc.new { 'hello!'}
+    tb = new_tag_binding :cnx => nc, :locals => ls, :name => nm, :attrs => as, :blk => bk
+    assert_equal tb.context, nc
+    assert_equal tb.locals, ls
+    assert_equal tb.name, nm
+    assert_equal tb.attributes, as
+    assert_equal tb.attr, as
+    assert_equal tb.block, bk
+  end
+
+  def test_expand
+    tb = new_tag_binding
+    assert_equal tb.expand, 'hello!'
+  end
+
+  def test_single_double
+    tb1 = new_tag_binding :blk => Proc.new{ 'hello!'}
+    assert_equal tb1.single?, false
+    assert_equal tb1.double?, true
+    tb2 = new_tag_binding :blk => nil
+    assert_equal tb2.single?, true
+    assert_equal tb2.double?, false
+  end
+
+  def test_globals
+    tb = new_tag_binding
+    assert_equal tb.globals, tb.context.globals
+  end
+end

data/test/tagdefs_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ARLike < Radius::DelegatingOpenStruct
+  def attributes
+    @hash
+  end
+end
+
+class RadiusTagDefinitionsTest < Test::Unit::TestCase
+  include RadiusTestHelper
+
+  def new_tag_factory
+    Radius::TagDefinitions::TagFactory.new new_context
+  end  
+
+  def test_initialize
+    new_tag_factory
+  end
+
+  def test_prepare_options_w_for
+    tf = new_tag_factory
+    ar = ARLike.new
+    ar.x, ar.y, ar.z = 1, 2, 3
+    res = tf.send :prepare_options, :test, { 'for' => ar, 'other' => 1, 'more' => 'mas' }
+    assert_equal res.keys.size, 5
+    assert_equal res[:for], ar
+    assert_equal res[:expose].size, 3
+    assert res[:expose].include?(:x)
+    assert res[:expose].include?(:y)
+    assert res[:expose].include?(:z)
+    assert_equal res[:attributes], true
+    assert_equal res[:other], 1
+    assert_equal res[:more], 'mas'
+  end
+
+  def test_prepare_options_wo_for
+    tf = new_tag_factory
+    res = tf.send :prepare_options, :test, { 'other' => 1, 'more' => 'mas' }
+    assert_equal res.keys.size, 4
+    assert_equal res[:expose], []
+    assert_equal res[:attributes], false
+    assert_equal res[:other], 1
+    assert_equal res[:more], 'mas'
+  end
+
+  def test_validate_params
+    tf = new_tag_factory
+    assert_raise(ArgumentError) { tf.send :validate_params, :echo, {} }
+    assert_raise(ArgumentError) { tf.send :validate_params, :echo, { :expose => [:x]} }
+  end
+
+  def test_expand_array_option
+    tf = new_tag_factory
+    assert_equal tf.send(:expand_array_option, ['a', 'b', nil, 'c']), [:a, :b, :c]
+  end
+
+  def test_last_part
+    tf = new_tag_factory
+    assert_equal tf.send(:last_part, 'a:b:c'), 'c'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/radius19'
+
+class Test::Unit::TestCase
+end
+
+module RadiusTestHelper
+  class TestContext < Radius::Context; end
+
+  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   }
+      c.define_tag("echo"      ) { |tag| tag.attr['value']  }
+      c.define_tag("wrap"      ) { |tag| "[#{tag.expand}]"  }
+    end
+  end
+
+  def define_tag(name, options = {}, &block)
+    @context.define_tag name, options, &block
+  end
+end
+

data/test/util_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RadiusUtilTest < Test::Unit::TestCase
+
+  def test_symbolize_keys
+    h = Radius::Util.symbolize_keys({ 'a' => 1, :b => 2 })
+    assert_equal h[:a], 1
+    assert_equal h[:b], 2
+  end
+
+  def test_impartial_hash_delete
+    h = { 'a' => 1, :b => 2 }
+    assert_equal Radius::Util.impartial_hash_delete(h, :a), 1
+    assert_equal Radius::Util.impartial_hash_delete(h, 'b'), 2
+    assert_equal h.empty?, true
+  end
+
+  def test_constantize
+    assert_equal Radius::Util.constantize('String'), String
+  end
+
+  def test_camelize
+    assert_equal Radius::Util.camelize('ab_cd_ef'), 'AbCdEf'
+  end
+end