narf 0.6.3 → 0.7.1

data/lib/web/buffer.rb

@@ -1,20 +0,0 @@
-module Web
-    class Buffer #:nodoc:
-	def initialize
-	    @buffer = ""
-	end
-
-	def flush
-	    temp = @buffer
-	    @buffer = ""
-	    temp
-	end
-
-	def << object
-	    @buffer << object
-	end
-    end
-end	
-
-
-

data/lib/web/unit.rb

@@ -1,27 +0,0 @@
-=begin
-= WebUnit
-  Copyright(C) 2001 yuichi TAKAHASHI
-  $Id: webunit.rb,v 1.1.1.1 2003/01/21 11:50:39 yuichi Exp $
-=end
-
-require 'web/unit/utils' #:nodoc: all
-require 'web/unit/exception' #:nodoc: all
-require 'web/unit/assert' #:nodoc: all
-require 'web/unit/htmlelem' #:nodoc: all
-require 'web/unit/link' #:nodoc: all
-require 'web/unit/frame' #:nodoc: all
-require 'web/unit/image' #:nodoc: all
-require 'web/unit/jscript' #:nodoc: all
-require 'web/unit/testcase' #:nodoc: all
-require 'web/unit/cookie' #:nodoc: all
-require 'web/unit/params' #:nodoc: all
-require 'web/unit/form' #:nodoc: all
-require 'web/unit/parser' #:nodoc: all
-require 'web/unit/response' #:nodoc: all
-require 'web/unit/table' #:nodoc: all
-begin
-  require 'web/unit/domwalker' #:nodoc: all
-rescue LoadError
-end
-
-#WebUnit::TestCase::new( 'nil?' ).setup

data/lib/web/unit/assert.rb

@@ -1,154 +0,0 @@
-=begin
-= WebUnit::assert
-  Copyright(C) 2001 yuichi TAKAHASHI
-  $Id: assert.rb,v 1.1.1.1 2003/01/21 11:50:39 yuichi Exp $
-=end
-
-require 'web/unit/converter'
-
-module Web
-  module Unit #:nodoc: all
-
-  include Utils
-
-=begin
---- Web::Unit#assert_urls(expected,actual,message='')
-      compare two URLs. raise AssertionFailedError, when these are diferent.
-=end
-
-  def assert_urls( expected, actual, message='' )
-    setup_assert
-    message << " " unless message == ""
-    if expected == nil || actual == nil
-      message << "expected:<nil> but was:<#{actual}>" if expected == nil
-      message << "expected:<#{expected}> but was:<nil>" if actual == nil
-      raise_assertion_error( message )
-    end
-
-    some_expected = [expected, $URLBASE + expected]
-    patterns = [actual, orthop_url(actual)]
-    for exp in some_expected
-      for e in [exp, orthop_url(exp)]
-        for pattern in patterns
-          return if e == pattern
-        end
-      end
-    end
-
-    message << "expected:<#{expected}> but was:<#{actual}>"
-    raise_assertion_error( message )
-  end
-
-=begin
---- Web::Unit#assert_input( name, type, value, actual, message="" )
-      check attribute of input field.
-
-
-=end
-
-  def assert_input( name, type, value, actual, message="" )
-    setup_assert
-    message << " " unless message == ""
-    unless name == actual.name
-      message << "expected:<name:#{name}> but was:<name:#{actual.name}>"
-      raise_assertion_error( message )
-    end
-    unless type == actual.type
-      message << "expected:<type:#{type}> but was:<type:#{actual.type}>"
-      raise_assertion_error( message )
-    end
-    unless value == actual.value
-      message << "expected:<value:#{value}> but was:<value:#{actual.value}>"
-      raise_assertion_error( message )
-    end
-  end
-
-=begin
---- Web::Unit#assert_select_option( value, data, selected, actual, message="" )
-
-
-=end
-
-  def assert_select_option( value, data, selected, actual, message="" )
-    setup_assert
-    message << " " unless message == ""
-    unless value == actual.value
-      message << "expected:<value:#{value}> but was:<value:#{actual.value}>"
-      raise_assertion_error( message )
-    end
-    data = value if data == nil
-    unless data == actual.data
-      message << "expected:<data:#{data}> but was:<data:#{actual.data}>"
-      raise_assertion_error( message )
-    end
-    unless selected == ( actual.stat == 'on' )
-    #unless selected == ( '' == actual.attrs['selected'] )
-      if selected
-        message << "expected:<selected> but was:<unselected>"
-      else
-        message << "expected:<unselected> but was:<selected>"
-      end
-      raise_assertion_error( message )
-    end
-  end
-
-=begin
---- Web::Unit#assert_attrs( expected, actual, message="" )
-      check attribute of input field.
-
-
-=end
-
-  def assert_attrs( expected, actual, message="" )
-    setup_assert
-    message << " " unless message == ""
-    expected.each do |k,v|
-      av = nil
-      if actual.respond_to?( "#{k}" )
-        av = actual.send( "#{k}" )
-      else
-        av = actual.attrs[k] if actual.attrs.key?( k )
-      end
-      unless av == v
-        message << "expected:<#{k}:#{v}> but was:<#{k}:#{av}>"
-        raise_assertion_error( message )
-      end
-    end
-  end
-
-=begin
---- Web::Unit#assert_include( expected, actual, message="" )
-      check ((|actual|)) has HtmlElems, which have ((|expected|)) as data
-
-
-=end
-
-  def assert_include( expected, actual, message="" )
-    setup_assert
-    message << " " unless message == ""
-    unless actual.has?( expected ) then
-      if actual.search( expected ) == []
-        message << "expected:<#{expected.inspect}> but not exist in <#{actual.inspect}>."
-        raise_assertion_error( message )
-      end
-    end
-  end
-
-=begin
---- Web::Unit#assert_title( expected, actual, message="" )
-      check title of ((|actual|)) and ((|expected|)) as string,
-      append formatted body to message, when both differ.
-=end
-
-  def assert_title( expected, actual, message="" )
-    setup_assert
-    message << " " unless message == ""
-    unless actual.title == expected then
-      message << "expected:<#{expected}> but not exist in <#{actual.title}>."
-      message << "\n#{'='*72}#{actual.format}\n#{'='*72}\n"
-      raise_assertion_error( message )
-    end
-  end
-
-end
-end

data/lib/web/unit/converter.rb

@@ -1,148 +0,0 @@
-module Web::Unit #:nodoc: all
-
-  # for Testing Framework
-  unless const_defined?('AVAILABLE_FRAMEWORKS')
-    AVAILABLE_FRAMEWORKS = []
-  end
-  
-  [
-    %w(Test::Unit test/unit/testcase),
-    %w(RubyUnit runit/testcase),
-  ].each do |framework|
-    AVAILABLE_FRAMEWORKS.push(framework)
-  end
-
-  AVAILABLE_FRAMEWORKS.each do |name, library|
-    begin
-      require library
-      USING_FRAMEWORK = name
-      break
-    rescue LoadError
-    end
-  end
-
-  unless const_defined?('USING_FRAMEWORK')
-    raise LoadError, 'require ' <<
-      AVAILABLE_FRAMEWORKS.collect{|name,| name}.join(', ') <<
-      "or #{AVAILABLE_FRAMEWORKS.last[0]}"
-  end
-
-
-  # for XML parser
-  unless const_defined?('AVAILABLE_XMLPARSERS')
-    AVAILABLE_XMLPARSERS = []
-  end
-  
-  [
-    %w(REXML rexml/document),
-    %w(NQXML nqxml/treeparser),
-  ].each do |xmlparser|
-    AVAILABLE_XMLPARSERS.push(xmlparser)
-  end
-
-  AVAILABLE_XMLPARSERS.each do |name, library|
-    begin
-      require library
-      USING_XMLPARSER = name
-      break
-    rescue LoadError
-    end
-  end
-
-  unless const_defined?('USING_XMLPARSER')
-    USING_XMLPARSER = 'none'
-  end
-end
-
-case Web::Unit::USING_FRAMEWORK
-when 'Test::Unit'
-  module Test
-    module Unit
-      module Assertions
-        
-        unless method_defined?('setup_assert')
-          def setup_assert() add_assertion() end
-        end
-
-        unless method_defined?('raise_assertion_error')
-          def raise_assertion_error(message)
-            raise AssertionFailedError.new(message.to_s)
-          end
-        end
-
-        [
-          %w(assert_exception assert_raises),
-          %w(assert_no_exception assert_nothing_raised),
-          %w(assert_equals assert_equal),
-          %w(assert_fail flunk),
-          %w(assert_not_match assert_no_match),
-          %w(assert_matches assert_match),
-          %w(assert_equal_float assert_in_delta),
-        ].each do |runit_method, testunit_method|
-          unless method_defined?(runit_method)
-            module_eval(<<-EOS)
-            def #{runit_method}(*args, &block)
-              add_assertion if @_assertion_wrapped
-              #{testunit_method}(*args, &block)
-            end
-            EOS
-          end
-        end
-        
-        unless method_defined?('assert_equals')
-          def assert_equals(*args, &block)
-            add_assertion if @_assertion_wrapped
-            assert_equal(*args, &block)
-          end
-        end
-
-        unless method_defined?('assert_equals')
-          def assert_equals(*args, &block)
-            add_assertion if @_assertion_wrapped
-            assert_equal(*args, &block)
-          end
-        end
-
-        unless method_defined?('assert_equals')
-          def assert_equals(*args, &block)
-            add_assertion if @_assertion_wrapped
-            assert_equal(*args, &block)
-          end
-        end
-
-      end
-    end
-  end
-when 'RubyUnit'
-end
-
-module Web::Unit
-  case USING_FRAMEWORK
-  when 'Test::Unit'
-    include Test::Unit::Assertions
-    AssertionFailedError = Test::Unit::AssertionFailedError
-    TestSuite = Test::Unit::TestSuite
-    class TestCase < Test::Unit::TestCase
-      private
-      def add_assertion
-        @_result.add_assertion if @_result
-      end
-    end
-  when 'RubyUnit'
-    include RUNIT::Assert
-    AssertionFailedError = RUNIT::AssertionFailedError
-    TestSuite = RUNIT::TestSuite
-    class TestCase < RUNIT::TestCase
-      class << self
-        def test_cases
-          if self == TestCase
-            TestSuite.new(*@@test_classes)
-          else
-            suite
-          end
-        end
-        alias all_suite test_cases
-      end
-    end
-  end
-end

data/lib/web/unit/cookie.rb

@@ -1,120 +0,0 @@
-=begin
-= Web::Unit::Cookies
-  Copyright(C) 2001 yuichi TAKAHASHI
-  $Id: cookie.rb,v 1.1.1.1 2003/01/21 11:50:40 yuichi Exp $
-=end
-
-require 'singleton'
-
-module Web
-  module Unit #:nodoc: all
-
-  class Cookies
-
-    include Singleton
-
-    def initialize
-      @cookies = {}
-    end
-
-=begin
---- Cookies.clear
-=end
-
-    def self::clear
-      self::instance.clear
-    end
-
-    def clear
-      @cookies = {}
-    end
-
-=begin
---- Cookies.add( name, value, path )
-=end
-
-    def self::add( n, v, p='/' )
-      self::instance.add( n, v, p )
-    end
-
-    def add( n, v, p )
-      h = {}
-      h["name"] = n
-      h["value"] = v
-      @cookies[[n,p]] = h
-    end
-
-=begin
---- Cookies.list
-=end
-
-    def self::list
-      self::instance.list
-    end
-
-    def list
-      @cookies.keys.collect{|x|x[0]}
-    end
-
-=begin
---- Cookies.has?
-=end
-
-    def self::has?( name )
-      self::instance.has?( name )
-    end
-
-    def has?( name )
-      @cookies.keys.collect{|x|x[0]}.include?( name )
-    end
-
-    def self::update( set_cookie_response )
-      self::instance.update( set_cookie_response )
-    end
-
-    def update( set_cookie_response )
-      if set_cookie_response != nil then
-        set_cookie_response.split(',').each do |e|
-          c = parse_cookie( e.strip )
-          @cookies[ [ c["name"], c["path"] ] ] = c
-        end
-      end
-    end
-
-    def self::header( target )
-      self::instance.header( target )
-    end
-
-    def header( target )
-      a = []
-      @cookies.keys.each do |name,path|
-        if path == nil || ( 'path=' + target ).index( path ) != nil then
-          a.push( name + '=' + @cookies[[name,path]]["value"] )
-        end
-      end
-      a.size == 0 ? {} : { "Cookie"=>( a.join( '; ' ) ) }
-    end
-
-    attr_reader :cookies
-
-    def cookies= ( hash )
-      raise ArgumentError unless hash.kind_of?( Hash )
-      @cookies = hash
-    end
-
-    private
-
-    def parse_cookie( line )
-      h = {}
-      attrs = line.split(';').collect{ |x| x.strip.split('=') }
-      h["name"], h["value"] = attrs.shift
-      attrs.each do |arr|
-        h[arr[0]] = arr[1]
-      end
-      h
-    end
-
-  end
-end
-
-end