narf 0.6.3 → 0.7.1

data/lib/web/unit/runtest.rb

@@ -1,44 +0,0 @@
-module Web
-  module Unit #:nodoc: all
-    
-    def Unit.dispatch(args) #:nodoc: all
-      f_type = args.shift
-      case f_type
-      when '-fr'
-        ['AVAILABLE_FRAMEWORKS', %w(RubyUnit runit/testcase)]
-      when '-ft'
-        ['AVAILABLE_FRAMEWORKS', %w(Test::Unit test/unit/testcase)]
-      when '-xr'
-        ['AVAILABLE_XMLPARSERS', %w(REXML rexml/document)]
-      when '-xn'
-        ['AVAILABLE_XMLPARSERS', %w(NQXML nqxml/treeparser)]
-      else
-        args.unshift(f_type)
-        nil
-      end
-    end
-    
-    def Unit.runtest(args) #:nodoc: all
-      if args.size > 0
-        while res = dispatch(args)
-          next if Web::Unit.const_defined?(res[0])
-          Web::Unit.const_set(res[0], [res[1]])
-        end
-        require 'web/unit/ui/cui/testrunner'
-        test_runner = Web::Unit::UI::CUI::TestRunner.new
-        args.each {|f| require f}
-        test_runner.run
-      else
-        puts "#{File.basename($0)} [-fr|-ft|-xr|-xn] testfile1 [, testfile2, ...]"
-        puts "\t-fr : use RubyUnit as Testing Framework"
-        puts "\t-ft : use Test::Unit as Testing Framework(default)"
-        puts "\t-xr : use REXML as XML parser(default)"
-        puts "\t-xn : use NQXML as XML parser"
-      end
-    end
-  end
-end
-  
-if $0 == __FILE__
-  Web::Unit.runtest(ARGV)
-end

data/lib/web/unit/sgml-parser.rb

@@ -1,336 +0,0 @@
-module Web
-  module Unit  #:nodoc: all
-    
-    # A parser for SGML, using the derived class as static DTD.
-    class SGMLParser
-      
-      # Regular expressions used for parsing:
-      Interesting = /[&<]/
-      Incomplete = Regexp.compile('&([a-zA-Z][a-zA-Z0-9]*|#[0-9]*)?|' +
-                              '<([a-zA-Z][^<>]*|/([a-zA-Z][^<>]*)?|' +
-                                                                       '![^<>]*)?')
-      
-      Entityref = /&([a-zA-Z][-.a-zA-Z0-9]*)[^-.a-zA-Z0-9]/
-      Charref = /&#([0-9]+)[^0-9]/
-      
-      Starttagopen = /<[>a-zA-Z]/
-      Endtagopen = /<\/[<>a-zA-Z]/
-      Endbracket = /[<>]/
-      Special = /<![^<>]*>/
-      Commentopen = /<!--/
-      Commentclose = /--[ \t\n]*>/
-      Tagfind = /[a-zA-Z][a-zA-Z0-9.-]*/
-      Attrfind = Regexp.compile('[\s,]*([a-zA-Z_][a-zA-Z_0-9.-]*)' +
-                            '(\s*=\s*' +
-                                                                    "('[^']*'" +
-                                                                    '|"[^"]*"' +
-                                                                    '|[-~a-zA-Z0-9,./:+*%?!()_#=]*))?')
-      
-      Entitydefs =
-                  {'lt'=>'<', 'gt'=>'>', 'amp'=>'&', 'quot'=>'"', 'apos'=>'\''}
-      
-      def initialize(verbose=false)
-        @verbose = verbose
-        reset
-      end
-      
-      def reset
-        @rawdata = ''
-        @stack = []
-        @lasttag = '???'
-        @nomoretags = false
-        @literal = false
-      end
-      
-      def has_context(gi)
-        @stack.include? gi
-      end
-      
-      def setnomoretags
-        @nomoretags = true
-        @literal = true
-      end
-      
-      def setliteral(*args)
-        @literal = true
-      end
-      
-      def feed(data)
-        @rawdata << data
-        goahead(false)
-      end
-      
-      def close
-        goahead(true)
-      end
-      
-      def goahead(_end)
-        rawdata = @rawdata
-        i = 0
-        n = rawdata.length
-        while i < n
-          if @nomoretags
-            handle_data(rawdata[i..(n-1)])
-            i = n
-            break
-          end
-          j = rawdata.index(Interesting, i)
-          j = n unless j
-          if i < j
-            handle_data(rawdata[i..(j-1)])
-          end
-          i = j
-          break if (i == n)
-          if rawdata[i] == ?< #
-            if rawdata.index(Starttagopen, i) == i
-              if @literal
-                handle_data(rawdata[i, 1])
-                i += 1
-                next
-              end
-              k = parse_starttag(i)
-              break unless k
-              i = k
-              next
-            end
-            if rawdata.index(Endtagopen, i) == i
-              k = parse_endtag(i)
-              break unless k
-              i = k
-              @literal = false
-              next
-            end
-            if rawdata.index(Commentopen, i) == i
-              if @literal
-                handle_data(rawdata[i,1])
-                i += 1
-                next
-              end
-              k = parse_comment(i)
-              break unless k
-              i += k
-              next
-            end
-            if rawdata.index(Special, i) == i
-              if @literal
-                handle_data(rawdata[i, 1])
-                i += 1
-                next
-              end
-              k = parse_special(i)
-              break unless k
-              i += k
-              next
-            end
-          elsif rawdata[i] == ?& #
-            if rawdata.index(Charref, i) == i
-              i += $&.length
-              handle_charref($1)
-              i -= 1 unless rawdata[i-1] == ?;
-              next
-            end
-            if rawdata.index(Entityref, i) == i
-              i += $&.length
-              handle_entityref($1)
-              i -= 1 unless rawdata[i-1] == ?;
-              next
-            end
-          else
-            raise RuntimeError, 'neither < nor & ??'
-          end
-          # We get here only if incomplete matches but
-          # nothing else
-          match = rawdata.index(Incomplete, i)
-          unless match == i
-            handle_data(rawdata[i, 1])
-            i += 1
-            next
-          end
-          j = match + $&.length
-          break if j == n # Really incomplete
-          handle_data(rawdata[i..(j-1)])
-          i = j
-        end
-        # end while
-        if _end and i < n
-          handle_data(@rawdata[i..(n-1)])
-          i = n
-        end
-        @rawdata = rawdata[i..-1]
-      end
-
-      def parse_comment(i)
-        rawdata = @rawdata
-        if rawdata[i, 4] != '<!--'
-          raise RuntimeError, 'unexpected call to handle_comment'
-        end
-        match = rawdata.index(Commentclose, i)
-        return nil unless match
-        matched_length = $&.length
-        j = match
-        handle_comment(rawdata[i+4..(j-1)])
-        j = match + matched_length
-        return j-i
-      end
-
-      def parse_starttag(i)
-        rawdata = @rawdata
-        j = rawdata.index(Endbracket, i + 1)
-        return nil unless j
-        attrs = []
-        if rawdata[i+1] == ?> #
-          # SGML shorthand: <> == <last open tag seen>
-          k = j
-          tag = @lasttag
-        else
-          match = rawdata.index(Tagfind, i + 1)
-          unless match
-            raise RuntimeError, 'unexpected call to parse_starttag'
-          end
-          k = i + 1 + ($&.length)
-          tag = $&.downcase
-          @lasttag = tag
-        end
-        while k < j
-          break unless rawdata.index(Attrfind, k)
-          matched_length = $&.length
-          attrname, rest, attrvalue = $1, $2, $3
-          if not rest
-            attrvalue = '' # was: = attrname
-          elsif (attrvalue[0] == ?' && attrvalue[-1] == ?') or
-              (attrvalue[0] == ?" && attrvalue[-1,1] == ?")
-            attrvalue = attrvalue[1..-2]
-          end
-          attrs << [attrname.downcase, attrvalue]
-          k += matched_length
-        end
-        if rawdata[j] == ?> #
-          j += 1
-        end
-        finish_starttag(tag, attrs)
-        return j
-      end
-
-      def parse_endtag(i)
-        rawdata = @rawdata
-        j = rawdata.index(Endbracket, i + 1)
-        return nil unless j
-        tag = (rawdata[i+2..j-1].strip).downcase
-        if rawdata[j] == ?> #
-          j += 1
-        end
-        finish_endtag(tag)
-        return j
-      end
-
-      def finish_starttag(tag, attrs)
-        method = 'start_' + tag
-        if self.respond_to?(method)
-          @stack << tag
-          handle_starttag(tag, method, attrs)
-          return 1
-        else
-          method = 'do_' + tag
-          if self.respond_to?(method)
-            handle_starttag(tag, method, attrs)
-            return 0
-          else
-            unknown_starttag(tag, attrs)
-            return -1
-          end
-        end
-      end
-
-      def finish_endtag(tag)
-        if tag == ''
-          found = @stack.length - 1
-          if found < 0
-            unknown_endtag(tag)
-            return
-          end
-        else
-          unless @stack.include? tag
-            method = 'end_' + tag
-            unless self.respond_to?(method)
-              unknown_endtag(tag)
-            end
-            return
-          end
-          found = @stack.rindex(tag) #or @stack.length
-        end
-        while @stack.length > found
-          tag = @stack[-1]
-          method = 'end_' + tag
-          if respond_to?(method)
-            handle_endtag(tag, method)
-          else
-            unknown_endtag(tag)
-          end
-          @stack.pop
-        end
-      end
-
-      def parse_special(i)
-        rawdata = @rawdata
-        match = rawdata.index(Endbracket, i+1)
-        return nil unless match
-        matched_length = $&.length
-        handle_special(rawdata[i+1..(match-1)])
-        return match - i + matched_length
-      end
-
-      def handle_starttag(tag, method, attrs)
-        self.send(method, attrs)
-      end
-
-      def handle_endtag(tag, method)
-        self.send(method)
-      end
-
-      def report_unbalanced(tag)
-        if @verbose
-          print '*** Unbalanced </' + tag + '>', "\n"
-          print '*** Stack:', self.stack, "\n"
-        end
-      end
-
-      def handle_charref(name)
-        n = Integer(name)
-        if !(0 <= n && n <= 255)
-          unknown_charref(name)
-          return
-        end
-        handle_data(n.chr)
-      end
-
-      def handle_entityref(name)
-        table = Entitydefs
-        if table.include?(name)
-          handle_data(table[name])
-        else
-          unknown_entityref(name)
-          return
-        end
-      end
-
-      def handle_data(data)
-      end
-
-      def handle_comment(data)
-      end
-
-      def handle_special(data)
-      end
-
-      def unknown_starttag(tag, attrs)
-      end
-      def unknown_endtag(tag)
-      end
-      def unknown_charref(ref)
-      end
-      def unknown_entityref(ref)
-      end
-
-    end
-  end
-end

data/lib/web/unit/table.rb

@@ -1,150 +0,0 @@
-=begin
-= Web::Unit::Table/TableRow/TableCell/NilTableCell
-  Copyright(C) 2001 yuichi TAKAHASHI
-  $Id: table.rb,v 1.1.1.1 2003/01/21 11:50:40 yuichi Exp $
-=end
-
-module Web
-  module Unit #:nodoc: all
-
-  class Table < HtmlElem
-
-    attr_reader :rows
-
-    def initialize( ah )
-      super( 'table', ah )
-      @rows = []
-    end
-
-    def add_row( ah )
-      @rows.push( TableRow::new( ah ) )
-    end
-
-    def add_cell( cell )
-      p = @rows.last.size + 1
-      if @rows.size > 1 && @rows[-2].at(p) && @rows[-2].at(p).rs > 1 then
-        @rows.last.add( @rows[-2].at(p) )
-        @rows[-2].at(p).rs -= 1
-      end
-      @rows.last.add( cell )
-      while cell.cs > 1 do
-        @rows.last.add( cell )
-        cell.cs -= 1
-      end
-    end
-
-=begin
---- Table#at(r,c=nil)
-      return a TableCell, when two arguments(row,col) specified.
-      return a TableRow, when a argument(row) specified.
-      r and c is both beginning from 1.
-=end
-
-    def at( r, c=nil )
-      if r < 1
-        raise ArgumentError
-      end
-      if c == nil
-        if @rows == [] || @rows.size < r
-          raise
-        end
-        @rows[r-1]
-      else
-        if c < 1
-          raise ArgumentError
-        end
-        if @rows == [] || @rows.size < r || @rows[r-1].size < c
-          NilTableCell::new
-        else
-          @rows[r-1].at(c)
-        end
-      end
-    end
-
-=begin
---- Table#row_index( data, col=1 )
-=end
-
-    def row_index( data, col=1 )
-      row = nil
-      (1..@rows.size).each do |row|
-        break unless self.at(row,col).search( data ) == []
-      end
-      row
-    end
-
-=begin
---- Table#col_index( data, row=1 )
-=end
-    def col_index( data, row=1 )
-      col = nil
-      (1..(self.at(row).size)).each do |col|
-        break unless self.at(row,col).search( data ) == []
-      end
-      col
-    end
-
-  end
-
-  class TableRow < HtmlElem
-
-    def initialize( ah )
-      super( 'tr', ah )
-      @cols = []
-    end
-
-=begin
---- TableRow#size
-      return column number.
-=end
-
-    def size
-      @cols.size
-    end
-
-    def add( col )
-      @cols << col
-    end
-
-=begin
---- TableRow#at( c )
-      return TableCell, pointed by ((|c|)).
-      c is beginning from 1.
-=end
-
-    def at( c )
-      @cols[c-1]
-    end
-
-  end
-
-  class TableCell < HtmlElem
-
-    attr_reader :data, :colspan, :rowspan
-
-    attr_accessor :cs, :rs
-
-    def initialize( tag, ah )
-      super
-      @colspan = ah['colspan']
-      @rowspan = ah['rowspan']
-      @cs = @colspan.to_i || 1
-      @rs = @rowspan.to_i || 1
-    end
-
-  end
-
-  class NilTableCell < TableCell
-
-    def initialize
-      super( 'dummy', {} )
-    end
-
-    def data
-      nil
-    end
-
-  end
-
-end
-end