depengine 0.0.31 → 3.0.0

data/etc/isolate/ruby-1.8/gems/ptools-1.1.9/test/test_touch.rb

@@ -1,55 +0,0 @@
-#####################################################################
-# tc_touch.rb
-#
-# Test case for the File.touch method. This test should be run
-# via the 'rake test_touch task'.
-#####################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
-require 'ptools'
-
-class TC_FileTouch < Test::Unit::TestCase
-   def self.startup
-      Dir.chdir('test') if File.exists?('test')
-      File.open('test_file1.txt', 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
-   end
-   
-   def setup   
-      @test_file = 'delete.this'
-      @xfile = 'test_file1.txt'
-   end
-
-   def test_touch_basic
-      assert_respond_to(File, :touch)
-      assert_nothing_raised{ File.touch(@test_file) }
-   end
-
-   def test_touch_expected_results
-      assert_equal(File, File.touch(@test_file))
-      assert_equal(true, File.exists?(@test_file))
-      assert_equal(0, File.size(@test_file))
-   end
-
-   def test_touch_existing_file
-      stat = File.stat(@xfile)
-      sleep 1
-      assert_nothing_raised{ File.touch(@xfile) }
-      assert_equal(true, File.size(@xfile) == stat.size)
-      assert_equal(false, File.mtime(@xfile) == stat.mtime)
-   end
-
-   def test_touch_expected_errors
-      assert_raises(ArgumentError){ File.touch }
-   end
-
-   def teardown
-      File.delete(@test_file) if File.exists?(@test_file)
-      @test_file = nil
-   end
-
-   def self.shutdown
-      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
-   end
-end

data/etc/isolate/ruby-1.8/gems/ptools-1.1.9/test/test_wc.rb

@@ -1,50 +0,0 @@
-#####################################################################
-# test_wc.rb
-#
-# Test case for the File.wc method. This test should be run via
-# the 'rake test_wc' task.
-#####################################################################
-require 'test/unit'
-require 'ptools'
-
-class TC_FileWC < Test::Unit::TestCase
-   def self.startup
-      Dir.chdir('test') if File.exists?('test')      
-      File.open('test_file1.txt', 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
-   end
-   
-   def setup     
-      @test_file = 'test_file1.txt'
-   end
-
-   def test_wc_basic
-      assert_respond_to(File, :wc)
-      assert_nothing_raised{ File.wc(@test_file) }
-      assert_nothing_raised{ File.wc(@test_file, 'bytes') }
-      assert_nothing_raised{ File.wc(@test_file, 'chars') }
-      assert_nothing_raised{ File.wc(@test_file, 'words') }
-      assert_nothing_raised{ File.wc(@test_file, 'LINES') }
-   end
-
-   def test_wc_results
-      assert_kind_of(Array, File.wc(@test_file))
-      assert_equal([166,166,25,25], File.wc(@test_file))
-      assert_equal(166, File.wc(@test_file,'bytes'), "Wrong number of bytes")
-      assert_equal(166, File.wc(@test_file,'chars'), "Wrong number of chars")
-      assert_equal(25,  File.wc(@test_file,'words'), "Wrong number of words")
-      assert_equal(25,  File.wc(@test_file,'lines'), "Wrong number of lines")
-   end
-
-   def test_wc_expected_errors
-      assert_raises(ArgumentError){ File.wc }
-      assert_raises(ArgumentError){ File.wc(@test_file, "bogus") }
-   end
-
-   def teardown
-      @test_file = nil
-   end
-
-   def self.shutdown
-      File.delete('test_file1.txt') if File.exists?('test_file1.txt')
-   end
-end

data/etc/isolate/ruby-1.8/gems/ptools-1.1.9/test/test_whereis.rb

@@ -1,98 +0,0 @@
-######################################################################
-# test_whereis.rb
-#
-# Tests for the File.whereis method.
-######################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
-require 'ptools'
-require 'rbconfig'
-include Config
-
-class TC_FileWhereis < Test::Unit::TestCase
-  def self.startup
-    @@windows = Config::CONFIG['host_os'] =~ /mswin|win32|msdos|cygwin|mingw/i
-  end
-
-  def setup
-    @expected_locs = [File.join(CONFIG['bindir'], 'ruby')]
-
-    if @@windows
-      @expected_locs[0] << '.exe'
-      @expected_locs[0].tr!("/", "\\")
-    end
-      
-    unless @@windows
-      @expected_locs << '/usr/local/bin/ruby'
-      @expected_locs << '/opt/sfw/bin/ruby'
-      @expected_locs << '/opt/bin/ruby'
-      @expected_locs << '/usr/bin/ruby'
-    end
-
-    @actual_locs = nil
-  end
-
-  test "whereis basic functionality" do
-    assert_respond_to(File, :whereis)
-    assert_nothing_raised{ File.whereis('ruby') }
-    assert_kind_of([Array, NilClass], File.whereis('ruby'))
-  end
-
-  test "whereis accepts an optional second argument" do
-    assert_nothing_raised{ File.whereis('ruby', '/usr/bin:/usr/local/bin') }
-  end
-
-  test "whereis returns expected values" do
-    assert_nothing_raised{ @actual_locs = File.whereis('ruby') }
-    assert_kind_of(Array, @actual_locs)
-    assert_true((@expected_locs & @actual_locs).size > 0)
-  end
-
-  test "whereis returns nil if program not found" do
-    assert_nil(File.whereis('xxxyyy'))
-  end
-
-  test "whereis returns nil if program cannot be found in provided path" do
-    assert_nil(File.whereis('ruby', '/foo/bar'))
-  end
-
-  test "whereis returns single element array or nil if absolute path is provided" do
-    absolute = File.join(CONFIG['bindir'], 'ruby')
-    absolute << '.exe' if @@windows
-    assert_equal([absolute], File.whereis(absolute))
-    assert_nil(File.whereis('/foo/bar/baz/ruby'))
-  end
-
-  test "whereis works with an explicit extension on ms windows" do
-    omit_unless(@@windows, 'test skipped except on MS Windows')
-    assert_not_nil(File.whereis('ruby.exe'))
-  end
-
-  test "whereis requires at least one argument" do
-    assert_raise(ArgumentError){ File.whereis }
-  end
-
-  test "whereis returns unique paths only" do
-    assert_true(File.whereis('ruby') == File.whereis('ruby').uniq)
-  end
-
-  test "whereis accepts a maximum of two arguments" do
-    assert_raise(ArgumentError){ File.whereis('ruby', 'foo', 'bar') }
-  end
-
-  test "the second argument to whereis cannot be nil or empty" do
-    assert_raise(ArgumentError){ File.whereis('ruby', nil) }
-    assert_raise(ArgumentError){ File.whereis('ruby', '') }
-  end
-
-  def teardown
-    @expected_locs = nil
-    @actual_locs = nil
-  end
-
-  def self.shutdown
-    @@windows = nil
-  end
-end

data/etc/isolate/ruby-1.8/gems/ptools-1.1.9/test/test_which.rb

@@ -1,109 +0,0 @@
-#####################################################################
-# test_which.rb
-#
-# Test case for the File.which method. You should run this test
-# via the 'rake test_which' rake task.
-#
-# NOTE: I make the assumption that Ruby (or JRuby) is in your
-# PATH for these tests.
-#####################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
-require 'rbconfig'
-require 'fileutils'
-require 'ptools'
-include Config
-
-class TC_FileWhich < Test::Unit::TestCase
-  def self.startup
-    @@windows = Config::CONFIG['host_os'] =~ /mswin|msdos|win32|cygwin|mingw/i
-    @@dir = File.join(Dir.pwd, 'tempdir')
-    @@non_exe = File.join(Dir.pwd, 'tempfile')
-
-    Dir.mkdir(@@dir) unless File.exists?(@@dir)
-    FileUtils.touch(@@non_exe)
-    File.chmod(775, @@dir)
-    File.chmod(644, @@non_exe)
-  end
-
-  def setup
-    @ruby = RUBY_PLATFORM.match('java') ? 'jruby' : 'ruby'
-    @exe = File.join(CONFIG['bindir'], CONFIG['ruby_install_name']) 
-
-    if @@windows
-      @exe.tr!('/','\\')
-      @exe << ".exe"
-    end
-  end
-
-  test "which basic functionality" do
-    assert_respond_to(File, :which)
-    assert_nothing_raised{ File.which(@ruby) }
-    assert_kind_of(String, File.which(@ruby))
-  end
-
-  test "which accepts an optional path to search" do
-    assert_nothing_raised{ File.which(@ruby, "/usr/bin:/usr/local/bin") }
-  end
-
-  test "which returns nil if not found" do
-    assert_equal(nil, File.which(@ruby, '/bogus/path'))
-    assert_equal(nil, File.which('blahblahblah'))
-  end
-
-  test "which handles executables without extensions on windows" do
-    omit_unless(@@windows, "test skipped unless MS Windows")
-    assert_not_nil(File.which('ruby'))
-    assert_not_nil(File.which('notepad'))
-  end
-
-  test "which handles executables that already contain extensions on windows" do
-    omit_unless(@@windows, "test skipped unless MS Windows")
-    assert_not_nil(File.which('ruby.exe'))
-    assert_not_nil(File.which('notepad.exe'))
-  end
-
-  test "which returns argument if an existent absolute path is provided" do
-    assert_equal(@exe, File.which(@ruby))
-  end
-
-  test "which returns nil if a non-existent absolute path is provided" do
-    assert_nil(File.which('/foo/bar/baz/ruby'))
-  end
-
-  test "which does not pickup files that are not executable" do
-    assert_nil(File.which(@@non_exe))
-  end
-
-  test "which does not pickup executable directories" do
-    assert_nil(File.which(@@dir))
-  end
-
-  test "which accepts a minimum of one argument" do
-    assert_raises(ArgumentError){ File.which }
-  end
-
-  test "which accepts a maximum of two arguments" do
-    assert_raises(ArgumentError){ File.which(@ruby, "foo", "bar") }
-  end
-
-  test "the second argument cannot be nil or empty" do
-    assert_raises(ArgumentError){ File.which(@ruby, nil) }
-    assert_raises(ArgumentError){ File.which(@ruby, '') }
-  end
-
-  def teardown
-    @exe  = nil
-    @ruby = nil
-  end
-
-  def self.shutdown
-    FileUtils.rm(@@non_exe)
-    FileUtils.rm_rf(@@dir)
-    @@windows = nil
-    @@dir = nil
-    @@non_exe = nil
-  end
-end

data/etc/isolate/ruby-1.8/gems/radius-0.6.1/CHANGELOG

@@ -1,42 +0,0 @@
-= Change Log
-
-== edge
-* Support for Rubinius [jlong]
-* Support for Ruby 1.9 [aemadrid]
-* More tests [aemadrid]
-* Fixed issue #5 - problem with other namespace tags [jemmyw]
-* Switched to Jeweler for better gem management [jlong]
-* Allow operation in a threaded environment (parser per-thread, shared context)
-* Allow switching scanners that tokenize templates.
-* Include SquiggleScanner to parse tags that look like "{ hello /}"
-
-== 0.6.1
-* Fixed a problem with non-tags that have no prefix or tag name (see test_parse_chirpy_bird)
-
-== 0.6.0 (private release)
-* Split radius.rb into multiple files.
-* Ported the really hairy regexes from Radius::Parser to a single Ragel machine.
-* Added and refactored tests.
-* Refactored Rakefile and other administrativia.
-
-== 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.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.

data/etc/isolate/ruby-1.8/gems/radius-0.6.1/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2006-2010, 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.

data/etc/isolate/ruby-1.8/gems/radius-0.6.1/QUICKSTART.rdoc

@@ -1,322 +0,0 @@
-= Radius Quick Start
-
-
-== Defining Tags
-
-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'
-  
-  context = Radius::Context.new
-  context.define_tag "hello" do |tag|
-    "Hello #{tag.attr['name'] || 'World'}!"
-  end
-
-Once you have defined a context you can easily create a Parser:
-
-  parser = Radius::Parser.new(context)
-  puts parser.parse('<p><radius:hello /></p>')
-  puts parser.parse('<p><radius:hello name="John" /></p>')
-
-This code will output:
-
-  <p>Hello World!</p>
-  <p>Hello John!</p>
-
-Note how you can pass attributes from the template to the context using the attributes hash.
-Above, the first tag that was parsed didn't have a name attribute so the code in the +hello+
-tag definition uses "World" instead. The second time the tag is parsed the name attribute is
-set to "John" which is used to create the string "Hello John!". Tags that do not follow this
-rule will be treated as if they were undefined (like normal methods).
-
-
-== Container Tags
-
-Radius also allows you to define "container" tags. That is, tags that contain content and
-that may optionally manipulate it in some way. For example, if you have RedCloth installed
-you could define another tag to parse and create Textile output:
-
-  require 'redcloth'
-  
-  context.define_tag "textile" do |tag|
-    contents = tag.expand
-    RedCloth.new(contents).to_html
-  end
-
-(The code <tt>tag.expand</tt> above returns the contents of the template between the start and end
-tags.)
-
-With the code above your parser can easily handle Textile:
-
-  parser.parse('<radius:textile>h1. Hello **World**!</radius:textile>')
-
-This code will output:
-
-  <h1>Hello <b>World</b>!</h1>
-
-
-== Nested Tags
-
-But wait!--it gets better. Because container tags can manipulate the content they contain
-you can use them to iterate over collections:
-
-  context = Radius::Context.new
-  
-  context.define_tag "stooge" do |tag|
-    content = ''
-    ["Larry", "Moe", "Curly"].each do |name|
-      tag.locals.name = name
-      content << tag.expand
-    end
-    content
-  end
-  
-  context.define_tag "stooge:name" do |tag|
-    tag.locals.name
-  end
-  
-  parser = Radius::Parser.new(context)
-  
-  template = <<-TEMPLATE
-  <ul>
-  <radius:stooge>
-    <li><radius:name /></li>
-  </radius:stooge>
-  </ul>
-  TEMPLATE
-  
-  puts parser.parse(template)
-  
-This code will output:
-
-  <ul>
-  
-    <li>Larry</li>
-  
-    <li>Moe</li>
-  
-    <li>Curly</li>
-  
-  </ul>
-
-Note how the definition for the +name+ tag is defined. Because "name" is prefixed
-with "stooge:" the +name+ tag cannot appear outside the +stooge+ tag. Had it been defined
-simply as "name" it would be valid anywhere, even outside the +stooge+ tag (which was
-not what we wanted). Using the colon operator you can define tags with any amount of
-nesting.
-
-
-== Exposing Objects to Templates
-
-During normal operation, you will often want to expose certain objects to your templates.
-Writing the tags to do this all by hand would be cumbersome of Radius did not provide
-several mechanisms to make this easier. The first is a way of exposing objects as tags
-on the context object. To expose an object simply call the +define_tag+
-method with the +for+ option:
-
-  context.define_tag "count", :for => 1
-
-This would expose the object <tt>1</tt> to the template as the +count+ tag. It's basically the
-equivalent of writing:
-
-  context.define_tag("count") { 1 }
-
-So far this doesn't save you a whole lot of typing, but suppose you want to expose certain
-methods that are on that object? You could do this:
-
-  context.define_tag "user", :for => user, :expose => [ :name, :age, :email ]
-
-This will add a total of four tags to the context. One for the <tt>user</tt> variable, and
-one for each of the three methods listed in the +expose+ clause. You could now get the user's
-name inside your template like this:
-
-  <radius:user><radius:name /></radius:user>
-
-If "John" was the value stored in <tt>user.name</tt> the template would render as "John".
-
-
-== Tag Shorthand
-
-In the example above we made reference to <tt>user.name</tt> in our template by using the
-following code:
-
-  <radius:user><radius:name /></radius:user>
-  
-There is a much easer way to refer to the <tt>user.name</tt> variable. Use the colon operator
-to "scope" the reference to <tt>name</tt>:
-
-  <radius:user:name />
-
-Radius allows you to use this shortcut for all tags.
-  
-
-== Changing the Tag Prefix
-
-By default, all Radius tags must begin with "radius". You can change this by altering the
-tag_prefix attribute on a Parser. For example:
-
-  parser = Radius::Parser.new(context, :tag_prefix => 'r')
-
-Now, when parsing templates with +parser+, Radius will require that every tag begin with "r"
-instead of "radius".
-
-
-== Custom Behavior for Undefined Tags
-
-Context#tag_missing behaves much like Object#method_missing only it allows you to define
-specific behavior for when a tag is not defined on a Context. For example:
-
-  class LazyContext < Radius::Context
-    def tag_missing(tag, attr, &block)
-      "<strong>ERROR: Undefined tag `#{tag}' with attributes #{attr.inspect}</strong>"
-    end
-  end
-  
-  parser = Radius::Parser.new(LazyContext.new, :tag_prefix => 'lazy')
-  puts parser.parse('<lazy:weird value="true" />')
-
-This will output:
-
-  <strong>ERROR: Undefined tag `weird' with attributes {"value"=>"true"}</strong>
-
-Normally, when the Radius Parser encounters an undefined tag for a Context it raises an
-UndefinedTagError, but since we have defined #tag_missing on LazyContext the Parser now
-outputs a nicely formated error message when we parse a string that does not contain a
-valid tag.
-
-
-== Tag Bindings
-
-Radius passes a TagBinding into the block of the Context#define_tag method. The tag
-binding is useful for a number of tasks. A tag binding has an #expand instance method
-which processes a tag's contents and returns the result. It also has a #attr method
-which returns a hash of the attributes that were passed into the tag. TagBinding also
-contains the TagBinding#single? and TagBinding#double? methods which return true or false
-based on wether the tag is a container tag or not. More about the methods which are
-available on tag bindings can be found on the Radius::TagBinding documentation page.
-
-
-== Tag Binding Locals, Globals, and Context Sensitive Tags
-
-A TagBinding also contains two OpenStruct-like objects which are useful when developing
-tags. TagBinding#globals is useful for storing variables which you would like to be
-accessible to all tags:
-
-  context.define_tag "inc" do |tag|
-    tag.globals.count ||= 0
-    tag.globals.count += 1
-    ""
-  end
-  
-  context.define_tag "count" do |tag|
-    tag.globals.count || 0
-  end
-
-TagBinding#locals mirrors the variables that are in TagBinding#globals, but allows child
-tags to redefine variables. This is valuable when defining context sensitive tags:
-
-  class Person
-    attr_accessor :name, :friend
-    def initialize(name)
-      @name = name
-    end
-  end
-  
-  jack = Person.new('Jack')
-  jill = Person.new('Jill')
-  jack.friend = jill
-  jill.friend = jack
-  
-  context = Radius::Context.new do |c|
-    c.define_tag "jack" do |tag|
-      tag.locals.person = jack
-      tag.expand
-    end
-    c.define_tag "jill" do |tag|
-      tag.locals.person = jill
-      tag.expand
-    end
-    c.define_tag "name" do |tag|
-      tag.locals.person.name rescue tag.missing!
-    end
-    c.define_tag "friend" do |tag|
-      tag.locals.person = tag.locals.person.friend rescue tag.missing!
-      tag.expand
-    end
-  end
-  
-  parser = Radius::Parser.new(context, :tag_prefix => 'r')
-  
-  parser.parse('<r:jack:name />') #=> "Jack"
-  parser.parse('<r:jill:name />') #=> "Jill"
-  parser.parse('<r:jill:friend:name />') #=> "Jack"
-  parser.parse('<r:jack:friend:friend:name />') #=> "Jack"
-  parser.parse('<r:jill><r:friend:name /> and <r:name /></r:jill>') #=> "Jack and Jill"
-  parser.parse('<r:name />') # raises a Radius::UndefinedTagError exception
-
-Notice how TagBinding#locals enables intelligent nesting. "<r:jill:name />" evaluates to
-"Jill", but "<r:jill:friend:name />" evaluates to "Jack". Locals lose scope as soon as
-the tag they were defined in closes. Globals on the other hand, never lose scope.
-
-The final line in the example above demonstrates that calling "<r:name />" raises a
-TagMissing error. This is because of the way the name tag was defined:
-
-  tag.locals.person.name rescue tag.missing!
-
-If person is not defined on locals it will return nil. Calling #name on nil would normally
-raise a NoMethodError exception, but because of the 'rescue' clause the TagBinding#missing!
-method is called which fires off Context#tag_missing. By default Context#tag_missing raises
-a UndefinedTagError exception. The 'rescue tag.missing!' idiom is extremly useful for adding
-simple error checking to context sensitive tags.
-
-
-== Tag Specificity
-
-When Radius is presented with two tags that have the same name, but different nesting
-Radius uses an algorithm similar to the way winning rules are calculated in Cascading Style
-Sheets (CSS) to determine which definition should be used. Each time a tag is encountered
-in a template potential tags are assigned specificity values and the tag with the highest
-specificity wins.
-
-For example, given the following tag definitions:
-
-  nesting
-  extra:nesting
-  parent:child:nesting
-
-And template:
-
-  <r:parent:extra:child:nesting />
-
-Radius will calculate specificity values like this:
-
-  nesting => 1.0.0.0
-  extra:nesting => 1.0.1.0
-  parent:child:nesting => 1.1.0.1
-
-Meaning that parent:child:nesting will win. If a template contained:
-
-  <r:parent:child:extra:nesting />
-
-The following specificity values would be assigned to each of the tag definitions:
-
-  nesting => 1.0.0.0
-  extra:nesting => 1.1.0.0
-  parent:child:nesting => 1.0.1.1
-
-Meaning that extra:nesting would win because it is more "specific".
-
-Values are assigned by assigning points to each of the tags from right to left.
-Given a tag found in a template with nesting four levels deep, the maximum
-specificity a tag could be assigned would be:
-
-  1.1.1.1
-
-One point for each of the levels.
-
-In practice, you don't need to understand this topic 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.