narf 0.5.1

data/lib/web/unit/domwalker.rb

@@ -0,0 +1,187 @@
+require 'web/unit/converter'
+
+module Web
+  module Unit #:nodoc: all
+
+  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
+end

data/lib/web/unit/exception.rb

@@ -0,0 +1,15 @@
+=begin
+= WebUnit::exception
+  Copyright(C) 2001 yuichi TAKAHASHI
+  $Id: exception.rb,v 1.1.1.1 2003/01/21 11:50:40 yuichi Exp $
+=end
+
+module Web
+  module Unit #:nodoc: all
+
+  class HttpNotFound < StandardError; end
+  class ElemNotFound < StandardError; end
+  class BadHtmlTags  < StandardError; end
+  class BadOperation < StandardError; end
+  end
+end

data/lib/web/unit/form.rb

@@ -0,0 +1,118 @@
+=begin
+= Web::Unit::Form
+  Copyright(C) 2001 yuichi TAKAHASHI, Narushima Hironori.
+  $Id: form.rb,v 1.1.1.1 2003/01/21 11:50:40 yuichi Exp $
+=end
+module Web
+  module Unit #:nodoc: all
+
+  BOUNDARY = '--divider'
+
+  class Form < HtmlElem
+
+    attr_accessor :name, :action, :method, :encoding
+    attr_reader :parameters, :params
+
+    def initialize( ah )
+      super( 'form', ah )
+      @parameters = []    # index by int
+      @params = {}        # index by name
+      @action = ah["name"]
+      @action = ah["action"]
+      @method = ah["method"] == nil ? "GET" : ah["method"]
+      #print @action,":",method,"\n"
+    end
+
+    def add_param( param )
+      @parameters.push param
+      if @params.key?param.name then
+        @params[param.name].update( param )
+        param.update( @params[param.name] )
+      else
+        @params[param.name] = param
+      end
+    end
+
+    def freeze
+      @parameters.freeze
+      @params.freeze
+    end
+
+=begin
+--- Form#set_params( hash )
+      fill up each fields, by name.
+=end
+
+    def set_params( hash )
+      hash.each do |k,v|
+        raise ArgumentError.new("wrong key: " + k) unless self.params[k]
+        self.params[k].value = v
+      end
+      self
+    end
+
+=begin
+--- Form#set_parameters( array )
+      fill up each fields, by index.
+=end
+
+    def set_parameters( array )
+      array.each_index do |i|
+        self.parameters[i].value = array[i]
+      end
+      self
+    end
+
+=begin
+--- Form#store_test_data(fields,data,s=',',button=nil)
+      store data to backend ( Database, File, ... ).
+      input csv data to each fields, and submit.
+=end
+
+    def store_test_data( fields, data, s=',', button=nil )
+      data.split( "\n" ).collect{ |r| r.strip.split( s ) }.each do |r|
+        fields.each_index{ |i| @params[fields[i]].value = r[i] }
+        self.submit( button )
+      end
+    end
+
+=begin
+--- Form#submit(button=nil,x=nil,y=nil)
+      submit form, and return a Response.
+=end
+    def submit( button=nil, x=nil, y=nil )
+      data = []
+      matched = nil
+      multipart = (attrs['enctype'] == 'multipart/form-data')
+      # make data from params
+
+      @parameters.each do |p|
+        puts "#{p.class}/#{p.name}" if $DEBUG
+        if p.class == InputSubmit || p.class == InputImage
+          next unless p.name == button || p.value == button
+          matched = p
+          if p.class  == InputImage
+            p.x = x
+            p.y = y
+          end
+        end
+        
+        if multipart
+          data << p.multipart_query_data(BOUNDARY)
+          else
+          data << p.query_data
+        end
+      end
+      
+      if multipart
+        data = data.join('') + "--#{BOUNDARY}--\n"
+      else
+        data = data.compact.join('&')
+      end
+    
+      Response::new.init_http( @action, @method, data, false, multipart)
+    end
+  end
+
+end
+end

data/lib/web/unit/formatter.rb

@@ -0,0 +1,314 @@
+class NullFormatter #:nodoc: all
+  def initialize(writer=nil)
+    if not writer
+      writer = NullWriter.new
+    end
+    @writer = writer
+  end
+  def end_paragraph(blankline) end
+  def add_line_break() end
+  #def add_hor_rule(*args, **kw) end
+  def add_hor_rule() end
+  def add_label_data(format, counter, blankline=nil) end
+  def add_flowing_data(data) end
+  def add_literal_data(data) end
+  def flush_softspace() end
+  def push_alignment(align) end
+  def pop_alignment() end
+  def push_font(size, i, b, tt) end
+  def pop_font() end
+  def push_margin(margin) end
+  def pop_margin() end
+  def set_spacing(spacing) end
+  def push_style(*styles) end
+  def pop_style(n=1) end
+  def assert_line_data(flag=1) end
+end
+
+class AbstractFormatter < NullFormatter #:nodoc: all
+
+  def initialize(writer)
+    @writer = writer
+    @align = nil
+    @align_stack = []
+    @font_stack = []
+    @margin_stack = []
+    @spacing = nil
+    @style_stack = []
+    @nospace = true
+    @softspace = false
+    @para_end = true
+    @parskip = 0
+    @hard_break = true
+    @have_label = false
+  end
+
+  def end_paragraph(blankline)
+    if not @hard_break
+      @writer.send_line_break
+      @have_label = false
+    end
+    if (@parskip < blankline) and !@have_label
+      @writer.send_paragraph(blankline - @parskip)
+      @parskip = blankline
+      @have_label = 0
+    end
+    @hard_break = true
+    @nospace = true
+    @para_end = true
+    @softspace = false
+  end
+
+  def add_line_break
+    if not (@hard_break or @para_end)
+      @writer.send_line_break
+      @have_label = false
+      @parskip = 0
+    end
+    @hard_break = true
+    @nospace = true
+    @softspace = false
+  end
+
+  def add_hor_rule
+    if not @hard_break
+      @writer.send_line_break
+    end
+    @writer.send_hor_rule #(args, kw)
+    @hard_break = true
+    @nospace = true
+    @have_label = false
+    @para_end = false
+    @softspace = false
+    @parskip = 0
+  end
+
+  def add_label_data(format, counter, blankline = nil)
+    if @have_label or !@hard_break
+      @writer.send_line_break
+    end
+    if not @para_end
+      @writer.send_paragraph(1)  #((blankline and 1) or 0)
+    end
+    if format.kind_of? String
+      #@writer.send_label_data(format_counter(format, counter))
+    else
+      @writer.send_label_data(format)
+    end
+    @nospace = @have_label = @hard_break = @para_end = 1
+    @softspace = @parskip = 0
+  end
+
+  def add_flowing_data(data)
+    return if not data
+    prespace = (/^\s/ =~ data)
+    postspace = (/\s$/ =~ data)
+    data = data.split.join(" ")
+    if @nospace and data.length < 1
+      return
+    elsif prespace or @softspace
+      if data.length == 0
+        if not @nospace
+          @softspace = true
+          @parskip = 0
+        end
+        return
+      end
+      if not @nospace
+        data = ' ' + data
+      end
+    end
+    @hard_break = @nospace = @para_end = false
+    @have_label = false
+    @parskip = 0
+    @softspace = postspace
+    @writer.send_flowing_data(data)
+  end
+
+  def add_literal_data(data)
+    return if not data
+    if @softspace
+      @writer.send_flowing_data("_")
+    end
+    @hard_break = (data[-1,1] == "\n")
+    @nospace = @para_end = @softspace = false
+    @have_label = false
+    @parskip = 0
+    @writer.send_literal_data(data)
+  end
+
+  def flush_softspace
+    if @softspace
+      @hard_break = false
+      @para_end = false
+      @have_label = false
+      @softspace = false
+      @parskip = 0
+      @nospace = true
+      @writer.send_flowing_data(' ')
+    end
+  end
+
+  def push_font(size, i, b, tt)
+    if @softspace
+      @hard_break = false
+      @para_end = false
+      @softspace = false
+      @nospace = true
+      @writer.send_flowing_data(' ')
+    end
+    if @font_stack.length > 0
+      csize, ci, cb, ctt = @font_stack[-1]
+      if size == nil
+        size = csize
+      end
+      if i == nil
+        i = ci
+      end
+      if b == nil
+        b = cb
+      end
+      if tt == nil
+        tt = ctt
+      end
+    end
+    font = [size, i, b, tt]
+    @font_stack << font
+    @writer.new_font(font)
+  end
+
+  def pop_font
+    if @font_stack.length > 0
+      @font_stack.pop
+    end
+    if @font_stack
+      font = @font_stack[-1]
+    else
+      font = nil
+    end
+    @writer.new_font(font)
+  end
+
+  def push_margin(margin)
+    @margin_stack << margin
+    fstack = @margin_stack.compact
+    if (!margin) && (fstack.length > 0)
+      margin = fstack[-1]
+    end
+    @writer.new_margin(margin, fstack.length)
+  end
+
+  def pop_margin
+    if @margin_stack
+      @margin_stack.pop
+    end
+    fstack = @margin_stack.compact
+    if fstack.length > 0
+      margin = fstack[-1]
+    else
+      margin = nil
+    end
+    @writer.new_margin(margin, fstack.length)
+  end
+
+  def set_spacing(spacing)
+    @spacing = spacing
+    @writer.new_spacing(spacing)
+  end
+
+  def assert_line_data(flag=true)
+    @nospace = !flag
+    @hard_break = !flag
+    @para_end = false
+    @have_label = false
+    @parskip = 0
+  end
+
+end
+
+class NullWriter #:nodoc: all
+  def initialize() end
+  def flush() end
+  def new_alignment(align) end
+  def new_font(font) end
+  def new_margin(margin, level) end
+  def new_spacing(spacing) end
+  def new_styles(styles) end
+  def send_paragraph(blankline) end
+  def send_line_break() end
+  def send_hor_rule() end
+  def send_label_data(data) end
+  def send_flowing_data(data) end
+  def send_literal_data(data) end
+end
+
+class DumbWriter < NullWriter #:nodoc: all
+
+  def initialize(file=STDOUT, maxcol=72)
+    @file = file
+    @maxcol = maxcol
+    super()
+    reset
+  end
+
+  def reset
+    @col = 0
+    @atbreak = false
+  end
+
+  def send_paragraph(blankline)
+    @file.write("\n" + "\n"*blankline)
+    @col = 0
+    @atbreak = false
+  end
+
+  def send_line_break
+    @file.write("\n")
+    @col = 0
+    @atbreak = false
+  end
+
+  def send_hor_rule #(*args, **kw)
+    @file.write("\n")
+    @file.write('-'*@maxcol)
+    @file.write("\n")
+    @col = 0
+    @atbreak = false
+  end
+
+  def send_literal_data(data)
+    @file.write(data)
+    i = data.rindex("\n")
+    if i
+      @col = 0
+      data = data[i+1..-1]
+      #data = string.expandtabs(data)
+      @col = @col + data.length
+      @atbreak = false
+    end
+  end
+
+  def send_flowing_data(data)
+    return if not data
+    atbreak = (@atbreak || (/^\s/ =~ data))
+    col = @col
+    maxcol = @maxcol
+    for word in data.split
+      if atbreak
+        if col + word.length >= maxcol
+          @file.write("\n")
+          col = 0
+        else
+          @file.write(' ')
+          col = col + 1
+        end
+      end
+      @file.write(word)
+      col = col + word.length
+      atbreak = true
+    end
+    @col = col
+    @atbreak = (/\s$/ =~ data)
+  end
+
+end