radiantcms-couchrest_model 0.1.6 → 0.1.7

data/radiantcms-couchrest_model.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{radiantcms-couchrest_model}
-  s.version = "0.1.6"
+  s.version = "0.1.7"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["davide-malagoli"]
@@ -2858,10 +2858,16 @@ a general purpose content managment system--not merely a blogging engine.}
 "vendor/radius/ROADMAP",
 "vendor/radius/CHANGELOG",
 "vendor/radius/lib",
-"vendor/radius/lib/radius.rb",
+"vendor/radius/lib/radius19.rb",
 "vendor/radius/README",
 "vendor/radius/test",
-"vendor/radius/test/radius_test.rb",
+"vendor/radius/test/context_test.rb",
+"vendor/radius/test/dostruct_test.rb",
+"vendor/radius/test/parser_test.rb",
+"vendor/radius/test/tagbinding_test.rb",
+"vendor/radius/test/tagdefs_test.rb",
+"vendor/radius/test/util_test.rb",
+"vendor/radius/test/test_helper.rb",
 "vendor/radius/Rakefile",
 "vendor/radius/QUICKSTART",
 "vendor/rack-cache",

data/vendor/radius/CHANGELOG

@@ -1,25 +1,7 @@
 = Change Log
 
-=== 0.5.1
-* Fixed a problem with parsing quotes where a single tag preceding a double tag would consume the start
-  tag of the double tag if both contained attributes.
+=== 0.5.3
+* Patched to work under Ruby 1.9
 
-=== 0.5.0
-* Created a DSL for tag definitions (introducing a DSL makes this version of Radiant incompatible with
-  the last). The DSL has the following features:
-  - full support for nested tags
-  - global and local tag variables
-  - Contexts can now be defined dynamically (instead of being subclassed)
-  - see the QUICKSTART for more info
-* Many refactorings of the library and unit tests.
-* Changed the license to the MIT-LICENSE.
-* Updated documentation to reflect the changes.
-* Updated the version number to reflect the maturity of the code base.
-
-=== 0.0.2
-* Refactored Parser to use Context#render_tag instead of #send when rendering tags defined on a Context.
-* UndefinedTagError is now thrown when Parser tries to render a tag which doesn't exist on a Context.
-* Added Context#tag_missing which works like method_method missing on Object, but is tag specific.
-
-=== 0.0.1
-* First release.
+=== 0.5.2
+* Original import from Radius (Ruby 1.8)

data/vendor/radius/QUICKSTART

@@ -6,7 +6,7 @@
 Before you can parse a template with Radius you need to create a Context object which defines
 the tags that will be used in the template. This is actually quite simple:
 
-  require 'radius'
+  require 'radius19'
   
   context = Context.new
   context.define_tag "hello" do |tag|
@@ -320,4 +320,4 @@ A deep understanding of tag specificity is not necessary to be effective with
 Radius. For the most part you will find that Radius resolves tags precisely the
 way that you would expect. If you find this section confusing forget about it and
 refer back to it if you find that tags are resolving differently from the way that
-you expected.
+you expected.

data/vendor/radius/README

@@ -1,97 +1,5 @@
-= Radius -- Powerful Tag-Based Templates
+= Radius19 for radiantcms-couchrest_model
 
-Radius is a powerful tag-based template language for Ruby inspired by the template languages
-used in MovableType[http://www.movabletype.org] and TextPattern[http://www.textpattern.com].
-It uses tags similar to XML, but can be used to generate any form of plain text (HTML, e-mail,
-etc...).
+Based on the originalwork of Adrian Madrid (aemadrid@gmail.com)
 
-== Example
-
-With Radius, it is extremely easy to create custom tags and parse them. Here's a small
-example:
-
-  require 'radius'
-
-  # Define tags on a context that will be available to a template:
-  context = Radius::Context.new do |c|
-    c.define_tag 'hello' do
-      'Hello world'
-    end
-    c.define_tag 'repeat' do |tag|
-      number = (tag.attr['times'] || '1').to_i
-      result = ''
-      number.times { result << tag.expand }
-      result
-    end
-  end
-  
-  # Create a parser to parse tags that begin with 'r:'
-  parser = Radius::Parser.new(context, :tag_prefix => 'r')
-  
-  # Parse tags and output the result
-  puts parser.parse(%{A small example:\n<r:repeat times="3">* <r:hello />!\n</r:repeat>})
-  
-Output:
-
-  A small example:
-  * Hello world!
-  * Hello world!
-  * Hello world!
-
-
-= Quick Start
-
-Read the QUICKSTART[link:files/QUICKSTART.html] to get up and running fast with Radius.
-
-
-== Download
-
-The latest version of Radius can be found on RubyForge:
-
-http://rubyforge.org/projects/radius/
-
-
-== Installation
-
-It is recommended that you install Radius using the RubyGems packaging system:
-
-  % gem install --remote radius
-
-You can also install Radius by copying lib/radius.rb into the Ruby load path.
-
-
-== License
-
-Radius is free software and may be redistributed under the terms of the MIT-LICENSE:
-
-Copyright (c) 2006, John W. Long
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this
-software and associated documentation files (the "Software"), to deal in the Software
-without restriction, including without limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
-to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
-PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
-FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-
-== The Future
-
-Radius is nearing completion, but is still very much in the development stages. Take a look
-at the ROADMAP[link:files/ROADMAP.html] to see where we want to go.
-
-If you are interested in helping with the development of Radiant, contact me and we'll talk.
-
-Enjoy!
-
---
-John Long ::
-http://wiseheartdesign.com
+on https://github.com/aemadrid/radius19/

data/vendor/radius/Rakefile

@@ -1,86 +1,56 @@
 require 'rubygems'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-
-PKG_NAME = 'radius'
-PKG_VERSION = '0.5.1'
-PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
-RUBY_FORGE_PROJECT = PKG_NAME
-RUBY_FORGE_USER = 'jlong'
-
-RELEASE_NAME  = PKG_VERSION
-RUBY_FORGE_GROUPID = '1262'
-RUBY_FORGE_PACKAGEID = '1538'
-
-RDOC_TITLE = "Radius -- Powerful Tag-Based Templates"
-RDOC_EXTRAS = ["README", "QUICKSTART", "ROADMAP", "CHANGELOG"]
-
-task :default => :test
-
-Rake::TestTask.new do |t| 
-  t.pattern = 'test/**/*_test.rb'
-end
-
-Rake::RDocTask.new do |rd|
-  rd.title = 'Radius -- Powerful Tag-Based Templates'
-  rd.main = "README"
-  rd.rdoc_files.include("lib/**/*.rb")
-  rd.rdoc_files.include(RDOC_EXTRAS)
-  rd.rdoc_dir = 'doc'
-end
-
-spec = Gem::Specification.new do |s|
-  s.name = PKG_NAME
-  s.version = PKG_VERSION
-  s.summary = 'Powerful tag-based template system.'
-  s.description = "Radius is a small, but powerful tag-based template language for Ruby\nsimilar to the ones used in MovableType and TextPattern. It has tags\nsimilar to HTML or XML, but can be used to generate any form of plain\ntext (not just HTML)."
-  s.homepage = 'http://radius.rubyforge.org'
-  s.rubyforge_project = RUBY_FORGE_PROJECT
-  s.platform = Gem::Platform::RUBY
-  s.requirements << 'none'
-  s.require_path = 'lib'
-  s.autorequire = 'radius'
-  s.has_rdoc = true
-  s.rdoc_options << '--title' << RDOC_TITLE << '--line-numbers' << '--main' << 'README'
-  s.extra_rdoc_files = RDOC_EXTRAS
-  files = FileList['**/*']
-  files.exclude 'doc'
-  files.exclude '**/._*'
-  s.files = files.to_a
-end
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "radius19"
+    gem.summary = %Q{A small, but powerful tag-based template language for Ruby modeled after the ones used in MovableType and TextPattern. It has tags similar to XML, but can be used to generate any form of plain text (HTML, e-mail, etc...) adapted to work on Ruby 1.9.}
+    gem.email = "aemadrid@gmail.com"
+    gem.homepage = "http://github.com/aemadrid/radius19"
+    gem.authors = ["Adrian Madrid", "John W. Long"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_zip = true
-  pkg.need_tar = true
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-desc "Uninstall Gem"
-task :uninstall_gem do
-  sh "gem uninstall radius" rescue nil
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
 end
 
-desc "Build and install Gem from source"
-task :install_gem => [:package, :uninstall_gem] do
-  dir = File.join(File.dirname(__FILE__), 'pkg')
-  chdir(dir) do
-    latest = Dir['radius-*.gem'].last
-    sh "gem install #{latest}"
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
   end
 end
 
-# --- Ruby forge release manager by florian gross -------------------------------------------------
-#
-# task found in Tobias Luetke's library 'liquid'
-#
 
-desc "Publish the release files to RubyForge."
-task :release => [:gem, :package] do
-  files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+task :default => :test
 
-  system("rubyforge login --username #{RUBY_FORGE_USER}")
-  
-  files.each do |file|
-    system("rubyforge add_release #{RUBY_FORGE_GROUPID} #{RUBY_FORGE_PACKAGEID} \"#{RELEASE_NAME}\" #{file}")
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
   end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "radius19 #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end
+

data/vendor/radius/lib/radius19.rb

@@ -0,0 +1,24 @@
+#--
+# Copyright (c) 2006, John W. Long
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this
+# software and associated documentation files (the "Software"), to deal in the Software
+# without restriction, including without limitation the rights to use, copy, modify,
+# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to the following
+# conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies
+# or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+# OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+dir = File.join(File.dirname(__FILE__), 'radius')
+require_files = %w{errors tagdefs dostruct tagbinding context parsetag parser util}
+require_files.each {|f| require File.join(dir, f)}

data/vendor/radius/test/context_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RadiusContextTest < Test::Unit::TestCase
+  include RadiusTestHelper
+
+  def setup
+    @context = new_context
+  end
+
+  def test_initialize
+    @context = Radius::Context.new
+  end
+
+  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
+    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
+    e = assert_raises(Radius::UndefinedTagError) { @context.render_tag('undefined_tag') }
+    assert_equal "undefined tag `undefined_tag'", e.message
+  end
+
+  def test_tag_missing
+    class << @context
+      def tag_missing(tag, attr, &block)
+        "undefined tag `#{tag}' with attributes #{attr.inspect}"
+      end
+    end
+
+    text = ''
+    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

data/vendor/radius/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/vendor/radius/test/{radius_test.rb → parser_test.rb}

@@ -1,83 +1,4 @@
-require 'test/unit'
-require 'radius'
-
-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
-
-class RadiusContextTest < Test::Unit::TestCase
-  include RadiusTestHelper
-  
-  def setup
-    @context = new_context
-  end
-  
-  def test_initialize
-    @context = Radius::Context.new
-  end
-  
-  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
-    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
-    e = assert_raises(Radius::UndefinedTagError) { @context.render_tag('undefined_tag') }
-    assert_equal "undefined tag `undefined_tag'", e.message
-  end
-  
-  def test_tag_missing
-    class << @context
-      def tag_missing(tag, attr, &block)
-        "undefined tag `#{tag}' with attributes #{attr.inspect}"
-      end
-    end
-    
-    text = ''
-    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
+require File.dirname(__FILE__) + '/test_helper'
 
 class RadiusParserTest < Test::Unit::TestCase
   include RadiusTestHelper
@@ -197,12 +118,6 @@ class RadiusParserTest < Test::Unit::TestCase
     define_tag('hello') { |tag| tag.render('test', tag.attr) }
     assert_parse_output 'Hello John!', '<r:hello name="John" />'
   end
-  
-  def test_accessing_tag_attributes_through_tag_indexer
-    define_tag('test') { |tag| "Hello #{tag['name']}!" }
-    assert_parse_output 'Hello John!', '<r:test 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 } }
@@ -323,5 +238,5 @@ class RadiusParserTest < Test::Unit::TestCase
     def user_with_attributes
       UserWithAttributes.new('John', 25, 'test@johnwlong.com')
     end
-  
+
 end

data/vendor/radius/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/vendor/radius/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/vendor/radius/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/vendor/radius/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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 6
-  version: 0.1.6
+  - 7
+  version: 0.1.7
 platform: ruby
 authors: 
 - davide-malagoli
@@ -2387,9 +2387,15 @@ files:
 - vendor/rails/activeresource/Rakefile
 - vendor/radius/ROADMAP
 - vendor/radius/CHANGELOG
-- vendor/radius/lib/radius.rb
+- vendor/radius/lib/radius19.rb
 - vendor/radius/README
-- vendor/radius/test/radius_test.rb
+- vendor/radius/test/context_test.rb
+- vendor/radius/test/dostruct_test.rb
+- vendor/radius/test/parser_test.rb
+- vendor/radius/test/tagbinding_test.rb
+- vendor/radius/test/tagdefs_test.rb
+- vendor/radius/test/util_test.rb
+- vendor/radius/test/test_helper.rb
 - vendor/radius/Rakefile
 - vendor/radius/QUICKSTART
 - vendor/rack-cache/COPYING

data/vendor/radius/lib/radius.rb

@@ -1,502 +0,0 @@
-#--
-# Copyright (c) 2006, John W. Long
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this
-# software and associated documentation files (the "Software"), to deal in the Software
-# without restriction, including without limitation the rights to use, copy, modify,
-# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to the following
-# conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies
-# or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
-# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
-# OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
-module Radius
-  # Abstract base class for all parsing errors.
-  class ParseError < StandardError
-  end
-  
-  # Occurs when Parser cannot find an end tag for a given tag in a template or when
-  # tags are miss-matched in a template.
-  class MissingEndTagError < ParseError
-    # Create a new MissingEndTagError object for +tag_name+. 
-    def initialize(tag_name)
-      super("end tag not found for start tag `#{tag_name}'")
-    end
-  end
-  
-  # Occurs when Context#render_tag cannot find the specified tag on a Context.
-  class UndefinedTagError < ParseError
-    # Create a new UndefinedTagError object for +tag_name+. 
-    def initialize(tag_name)
-      super("undefined tag `#{tag_name}'")
-    end
-  end
-  
-  module TagDefinitions # :nodoc:
-    class TagFactory # :nodoc:
-      def initialize(context)
-        @context = context
-      end
-      
-      def define_tag(name, options, &block)
-        options = prepare_options(name, options)
-        validate_params(name, options, &block)
-        construct_tag_set(name, options, &block)
-        expose_methods_as_tags(name, options)
-      end
-      
-      protected
-
-        # Adds the tag definition to the context. Override in subclasses to add additional tags
-        # (child tags) when the tag is created.
-        def construct_tag_set(name, options, &block)
-          if block
-            @context.definitions[name.to_s] = block
-          else
-            lp = last_part(name)
-            @context.define_tag(name) do |tag|
-              if tag.single?
-                options[:for]
-              else
-                tag.locals.send("#{ lp }=", options[:for]) unless options[:for].nil?
-                tag.expand
-              end
-            end
-          end
-        end
-
-        # Normalizes options pased to tag definition. Override in decendants to preform
-        # additional normalization.
-        def prepare_options(name, options)
-          options = Util.symbolize_keys(options)
-          options[:expose] = expand_array_option(options[:expose])
-          object = options[:for]
-          options[:attributes] = object.respond_to?(:attributes) unless options.has_key? :attributes
-          options[:expose] += object.attributes.keys if options[:attributes]
-          options
-        end
-        
-        # Validates parameters passed to tag definition. Override in decendants to add custom
-        # validations.
-        def validate_params(name, options, &block)
-          unless options.has_key? :for
-            raise ArgumentError.new("tag definition must contain a :for option or a block") unless block
-            raise ArgumentError.new("tag definition must contain a :for option when used with the :expose option") unless options[:expose].empty?
-          end
-        end
-        
-        # Exposes the methods of an object as child tags.
-        def expose_methods_as_tags(name, options)
-          options[:expose].each do |method|
-            tag_name = "#{name}:#{method}"
-            lp = last_part(name)
-            @context.define_tag(tag_name) do |tag|
-              object = tag.locals.send(lp)
-              object.send(method)
-            end
-          end
-        end
-        
-      protected
-      
-        def expand_array_option(value)
-          [*value].compact.map { |m| m.to_s.intern }
-        end
-        
-        def last_part(name)
-          name.split(':').last
-        end
-    end
-  end
-    
-  class DelegatingOpenStruct # :nodoc:
-    attr_accessor :object
-    
-    def initialize(object = nil)
-      @object = object
-      @hash = {}
-    end
-    
-    def method_missing(method, *args, &block)
-      symbol = (method.to_s =~ /^(.*?)=$/) ? $1.intern : method
-      if (0..1).include?(args.size)
-        if args.size == 1
-          @hash[symbol] = args.first
-        else
-          if @hash.has_key?(symbol)
-            @hash[symbol]
-          else
-            unless object.nil?
-              @object.send(method, *args, &block)
-            else
-              nil
-            end
-          end
-        end
-      else
-        super
-      end
-    end
-  end
-  
-  #
-  # A tag binding is passed into each tag definition and contains helper methods for working
-  # with tags. Use it to gain access to the attributes that were passed to the tag, to
-  # render the tag contents, and to do other tasks.
-  #
-  class TagBinding
-    # The Context that the TagBinding is associated with. Used internally. Try not to use
-    # this object directly.
-    attr_reader :context
-    
-    # The locals object for the current tag.
-    attr_reader :locals
-    
-    # The name of the tag (as used in a template string).
-    attr_reader :name
-    
-    # The attributes of the tag. Also aliased as TagBinding#attr.
-    attr_reader :attributes
-    alias :attr :attributes
-    
-    # The render block. When called expands the contents of the tag. Use TagBinding#expand
-    # instead.
-    attr_reader :block
-    
-    # Creates a new TagBinding object.
-    def initialize(context, locals, name, attributes, block)
-      @context, @locals, @name, @attributes, @block = context, locals, name, attributes, block
-    end
-    
-    # Evaluates the current tag and returns the rendered contents.
-    def expand
-      double? ? block.call : ''
-    end
-
-    # Returns true if the current tag is a single tag.
-    def single?
-      block.nil?
-    end
-
-    # Returns true if the current tag is a container tag.
-    def double?
-      not single?
-    end
-    
-    # The globals object from which all locals objects ultimately inherit their values.
-    def globals
-      @context.globals
-    end
-    
-    # Returns a list of the way tags are nested around the current tag as a string.
-    def nesting
-      @context.current_nesting
-    end
-    
-    # Fires off Context#tag_missing for the current tag.
-    def missing!
-      @context.tag_missing(name, attributes, &block)
-    end
-    
-    # Renders the tag using the current context .
-    def render(tag, attributes = {}, &block)
-      @context.render_tag(tag, attributes, &block)
-    end
-    
-    # Shortcut for accessing tag.attr[key]
-    def [](key)
-      attr[key]
-    end
-  end
-  
-  #
-  # A context contains the tag definitions which are available for use in a template.
-  # See the QUICKSTART[link:files/QUICKSTART.html] for a detailed explaination its
-  # usage.
-  #
-  class Context
-    # A hash of tag definition blocks that define tags accessible on a Context.
-    attr_accessor :definitions # :nodoc:
-    attr_accessor :globals # :nodoc:
-    
-    # Creates a new Context object.
-    def initialize(&block)
-      @definitions = {}
-      @tag_binding_stack = []
-      @globals = DelegatingOpenStruct.new
-      with(&block) if block_given?
-    end
-    
-    # Yeild an instance of self for tag definitions:
-    #
-    #   context.with do |c|
-    #     c.define_tag 'test' do
-    #       'test'
-    #     end
-    #   end
-    #
-    def with
-      yield self
-      self
-    end
-    
-    # Creates a tag definition on a context. Several options are available to you
-    # when creating a tag:
-    # 
-    # +for+::             Specifies an object that the tag is in reference to. This is
-    #                     applicable when a block is not passed to the tag, or when the
-    #                     +expose+ option is also used.
-    #
-    # +expose+::          Specifies that child tags should be set for each of the methods
-    #                     contained in this option. May be either a single symbol/string or
-    #                     an array of symbols/strings.
-    #
-    # +attributes+::      Specifies whether or not attributes should be exposed
-    #                     automatically. Useful for ActiveRecord objects. Boolean. Defaults
-    #                     to +true+.
-    #
-    def define_tag(name, options = {}, &block)
-      type = Util.impartial_hash_delete(options, :type).to_s
-      klass = Util.constantize('Radius::TagDefinitions::' + Util.camelize(type) + 'TagFactory') rescue raise(ArgumentError.new("Undefined type `#{type}' in options hash"))
-      klass.new(self).define_tag(name, options, &block)
-    end
-
-    # Returns the value of a rendered tag. Used internally by Parser#parse.
-    def render_tag(name, attributes = {}, &block)
-      if name =~ /^(.+?):(.+)$/
-        render_tag($1) { render_tag($2, attributes, &block) }
-      else
-        tag_definition_block = @definitions[qualified_tag_name(name.to_s)]
-        if tag_definition_block
-          stack(name, attributes, block) do |tag|
-            tag_definition_block.call(tag).to_s
-          end
-        else
-          tag_missing(name, attributes, &block)
-        end
-      end
-    end
-
-    # Like method_missing for objects, but fired when a tag is undefined.
-    # Override in your own Context to change what happens when a tag is
-    # undefined. By default this method raises an UndefinedTagError.
-    def tag_missing(name, attributes, &block)
-      raise UndefinedTagError.new(name)
-    end
-
-    # Returns the state of the current render stack. Useful from inside
-    # a tag definition. Normally just use TagBinding#nesting.
-    def current_nesting
-      @tag_binding_stack.collect { |tag| tag.name }.join(':')
-    end
-
-    private
-
-      # A convienence method for managing the various parts of the
-      # tag binding stack.
-      def stack(name, attributes, block)
-        previous = @tag_binding_stack.last
-        previous_locals = previous.nil? ? @globals : previous.locals
-        locals = DelegatingOpenStruct.new(previous_locals)
-        binding = TagBinding.new(self, locals, name, attributes, block)
-        @tag_binding_stack.push(binding)
-        result = yield(binding)
-        @tag_binding_stack.pop
-        result
-      end
-
-      # Returns a fully qualified tag name based on state of the
-      # tag binding stack.
-      def qualified_tag_name(name)
-        nesting_parts = @tag_binding_stack.collect { |tag| tag.name }
-        nesting_parts << name unless nesting_parts.last == name
-        specific_name = nesting_parts.join(':') # specific_name always has the highest specificity
-        unless @definitions.has_key? specific_name
-          possible_matches = @definitions.keys.grep(/(^|:)#{name}$/)
-          specificity = possible_matches.inject({}) { |hash, tag| hash[numeric_specificity(tag, nesting_parts)] = tag; hash }
-          max = specificity.keys.max
-          if max != 0
-            specificity[max]
-          else
-            name
-          end
-        else
-          specific_name
-        end
-      end
-      
-      # Returns the specificity for +tag_name+ at nesting defined
-      # by +nesting_parts+ as a number.
-      def numeric_specificity(tag_name, nesting_parts)
-        nesting_parts = nesting_parts.dup
-        name_parts = tag_name.split(':')
-        specificity = 0
-        value = 1
-        if nesting_parts.last == name_parts.last
-          while nesting_parts.size > 0
-            if nesting_parts.last == name_parts.last
-              specificity += value
-              name_parts.pop
-            end
-            nesting_parts.pop
-            value *= 0.1
-          end
-          specificity = 0 if (name_parts.size > 0)
-        end
-        specificity
-      end
-  end
-
-  class ParseTag # :nodoc:
-    def initialize(&b)
-      @block = b
-    end
-
-    def on_parse(&b)
-      @block = b
-    end
-
-    def to_s
-      @block.call(self)
-    end
-  end
-
-  class ParseContainerTag < ParseTag # :nodoc:
-    attr_accessor :name, :attributes, :contents
-    
-    def initialize(name = "", attributes = {}, contents = [], &b)
-      @name, @attributes, @contents = name, attributes, contents
-      super(&b)
-    end
-  end
-
-  #
-  # The Radius parser. Initialize a parser with a Context object that
-  # defines how tags should be expanded. See the QUICKSTART[link:files/QUICKSTART.html]
-  # for a detailed explaination of its usage.
-  #
-  class Parser
-    # The Context object used to expand template tags.
-    attr_accessor :context
-    
-    # The string that prefixes all tags that are expanded by a parser
-    # (the part in the tag name before the first colon).
-    attr_accessor :tag_prefix
-    
-    # Creates a new parser object initialized with a Context.
-    def initialize(context = Context.new, options = {})
-      if context.kind_of?(Hash) and options.empty?
-        options = context
-        context = options[:context] || options['context'] || Context.new
-      end
-      options = Util.symbolize_keys(options)
-      @context = context
-      @tag_prefix = options[:tag_prefix]
-    end
-
-    # Parses string for tags, expands them, and returns the result.
-    def parse(string)
-      @stack = [ParseContainerTag.new { |t| t.contents.to_s }]
-      pre_parse(string)
-      @stack.last.to_s
-    end
-
-    protected
-
-      def pre_parse(text) # :nodoc:
-        re = %r{<#{@tag_prefix}:([\w:]+?)(\s+(?:\w+\s*=\s*(?:"[^"]*?"|'[^']*?')\s*)*|)>|</#{@tag_prefix}:([\w:]+?)\s*>}
-        if md = re.match(text)
-          start_tag, attr, end_tag = $1, $2, $3
-          @stack.last.contents << ParseTag.new { parse_individual(md.pre_match) }
-          remaining = md.post_match
-          if start_tag
-            parse_start_tag(start_tag, attr, remaining)
-          else
-            parse_end_tag(end_tag, remaining)
-          end
-        else
-          if @stack.length == 1
-            @stack.last.contents << ParseTag.new { parse_individual(text) }
-          else
-            raise MissingEndTagError.new(@stack.last.name)
-          end
-        end
-      end
-
-      def parse_start_tag(start_tag, attr, remaining) # :nodoc:
-        @stack.push(ParseContainerTag.new(start_tag, parse_attributes(attr)))
-        pre_parse(remaining)
-      end
-
-      def parse_end_tag(end_tag, remaining) # :nodoc:
-        popped = @stack.pop
-        if popped.name == end_tag
-          popped.on_parse { |t| @context.render_tag(popped.name, popped.attributes) { t.contents.to_s } }
-          tag = @stack.last
-          tag.contents << popped
-          pre_parse(remaining)
-        else
-          raise MissingEndTagError.new(popped.name)
-        end
-      end
-
-      def parse_individual(text) # :nodoc:
-        re = %r{<#{@tag_prefix}:([\w:]+?)(\s+(?:\w+\s*=\s*(?:"[^"]*?"|'[^']*?')\s*)*|)/>}
-        if md = re.match(text)
-          attr = parse_attributes($2)
-          replace = @context.render_tag($1, attr)
-          md.pre_match + replace + parse_individual(md.post_match)
-        else
-          text || ''
-        end
-      end
-
-      def parse_attributes(text) # :nodoc:
-        attr = {}
-        re = /(\w+?)\s*=\s*('|")(.*?)\2/
-        while md = re.match(text)
-          attr[$1] = $3
-          text = md.post_match
-        end
-        attr
-      end
-  end
-
-  module Util # :nodoc:
-    def self.symbolize_keys(hash)
-      new_hash = {}
-      hash.keys.each do |k|
-        new_hash[k.to_s.intern] = hash[k]
-      end
-      new_hash
-    end
-    
-    def self.impartial_hash_delete(hash, key)
-      string = key.to_s
-      symbol = string.intern
-      value1 = hash.delete(symbol)
-      value2 = hash.delete(string)
-      value1 || value2
-    end
-    
-    def self.constantize(camelized_string)
-      raise "invalid constant name `#{camelized_string}'" unless camelized_string.split('::').all? { |part| part =~ /^[A-Za-z]+$/ }
-      Object.module_eval(camelized_string)
-    end
-    
-    def self.camelize(underscored_string)
-      string = ''
-      underscored_string.split('_').each { |part| string << part.capitalize }
-      string
-    end
-  end
-  
-end