ruby-web 1.1.1

data/lib/webunit/converter.rb

@@ -0,0 +1,154 @@
+module WebUnit
+
+  # 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 WebUnit::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)
+              @_assertion_wrapped ||= nil
+              add_assertion if @_assertion_wrapped
+              #{testunit_method}(*args, &block)
+            end
+            EOS
+          end
+        end
+        
+        unless method_defined?('assert_equals')
+          def assert_equals(*args, &block)
+            @_assertion_wrapped ||= nil
+            add_assertion if @_assertion_wrapped
+            assert_equal(*args, &block)
+          end
+        end
+
+        unless method_defined?('assert_equals')
+          def assert_equals(*args, &block)
+            @_assertion_wrapped ||= nil
+            add_assertion if @_assertion_wrapped
+            assert_equal(*args, &block)
+          end
+        end
+
+        unless method_defined?('assert_equals')
+          def assert_equals(*args, &block)
+            @_assertion_wrapped ||= nil
+            add_assertion if @_assertion_wrapped
+            assert_equal(*args, &block)
+          end
+        end
+
+      end
+    end
+  end
+when 'RubyUnit'
+end
+
+module WebUnit
+  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
+        @_assertion_wrapped ||= nil
+        @_result ||= nil
+        @_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/webunit/cookie.rb

@@ -0,0 +1,118 @@
+=begin
+= WebUnit::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 WebUnit
+
+  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

data/lib/webunit/domwalker.rb

@@ -0,0 +1,185 @@
+require 'webunit/converter'
+
+module WebUnit
+
+  class DomWalkerError < RuntimeError
+  end
+
+  class BaseDomWalker
+    attr_reader :doc, :cur_path
+
+    def initialize()
+      @cur_path = '/'
+    end
+
+    def cur_value
+      cur_values.join
+    end
+
+  end
+
+  case USING_XMLPARSER
+  when 'REXML'
+    class REXMLDomWalker < BaseDomWalker
+      
+      ATTR_RS = %q|\s*(\w+)\s*=\s*(["'])(\w+)(['"])\s*|
+        
+      def initialize(xml)
+        super()
+        @doc = REXML::Document.new(xml)
+        @cur_node = @doc.root
+      end
+
+      def change_node(path)
+        xpath = path.dup
+        cur_path = @cur_path
+        if xpath =~ %r!^/!
+          xpath[1,0] = @doc.root.name + '/'
+          cur_path = '/'
+        end
+        xpath.gsub!(/(?!^\/)\//, '[0]/')
+        xpath.gsub!(/\[\s*(\d+)\s*\]/) {|str| "[#{$1.succ}]"}
+        xpath.gsub!(/\[#{ATTR_RS}(?:,#{ATTR_RS})*\]\z/) do |x|
+          res = []
+          attr_info = []
+          $~.to_a.compact[1..-1].each do |m|
+            attr_info << m
+            if attr_info.size == 4
+              raise DomWalkerError if attr_info[1] != attr_info[3]
+              res << "@#{attr_info[0]}=#{attr_info[1..3]}"
+              attr_info.clear
+            end
+          end
+          raise DomWalkerError unless attr_info.empty?
+          "[#{res.join(' and ')}]"
+        end
+        element = @cur_node.elements[xpath]
+        raise DomWalkerError if element.nil?
+        @cur_node = element
+        @cur_path = "#{cur_path}/#{path}".gsub( %r!//*!, '/' )
+      end
+      
+      def cur_values
+        @cur_node.texts.collect {|text| text.to_s}
+      end
+
+      def cur_attrs
+        @cur_node.attributes
+      end
+      
+      def cur_name
+        @cur_node.name
+      end
+      
+      def size(name='')
+        n = 0
+        @cur_node.each_element do |element|
+          n += 1 if name.empty? or name == element.name
+        end
+        n
+      end
+      
+    end
+
+    DomWalker = REXMLDomWalker
+
+  when 'NQXML'
+    class NQXMLDomWalker < BaseDomWalker
+      
+      def initialize(xml)
+        super()
+        @doc = NQXML::TreeParser.new( xml ).document
+        @cur_node = @doc.rootNode
+      end
+      
+      def change_node( path )
+        
+        if path =~ %r!^/!
+          @cur_node = @doc.rootNode
+          @cur_path = '/'
+          path = path[1..-1]
+        end
+        @cur_path = "#{@cur_path}/#{path}".gsub( %r!//*!, '/' )
+        
+        path.split( '/' ).each do |name|
+          
+          nth = 0
+          attrs = nil
+          
+          if name =~ %r!([^\[]*)\[([^\]]*)\]!
+            name = $1
+            if $2.to_i.to_s == $2
+              nth = $2.to_i 
+            else
+              attrs = {}
+              $2.split( ',' ).each do |pair|
+                key, val = pair.split( '=' )
+                val = val.split( '"' )[1]
+                attrs[key] = val;
+              end  
+            end
+          end
+          
+          changed = false
+          @cur_node.children.each do |node|
+            entity = node.entity
+            if entity.instance_of?(NQXML::Tag) && entity.name == name
+              if attrs
+                matched = true
+                attrs.each do |key,val|
+                  matched = false if val != node.entity.attrs[key]
+                end
+                next unless matched
+              end
+              if nth == 0
+                @cur_node = node
+                changed = true
+                break
+              end
+              nth -= 1
+            end
+          end
+          
+          raise DomWalkerError unless changed
+          
+        end
+        
+      end
+      
+      def cur_values
+        @cur_node.children.collect{ |node|
+          entity = node.entity
+          entity.text if entity.instance_of?(NQXML::Text)
+        }.compact
+      end
+      
+      def cur_value
+        cur_values.join
+      end
+      
+      def cur_attrs
+        @cur_node.entity.attrs
+      end
+      
+      def cur_name
+        @cur_node.entity.name
+      end
+
+      def size( name="" )
+        n = 0
+        @cur_node.children.each do |node|
+          entity = node.entity
+          if entity.instance_of?(NQXML::Tag)
+            n += 1 if name == "" || name == entity.name
+          end
+        end
+        return n
+      end
+
+    end
+
+    DomWalker = NQXMLDomWalker
+    
+  end
+
+end