narf 0.6.3 → 0.7.1

data/lib/web/unit/domwalker.rb

@@ -1,187 +0,0 @@
-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

@@ -1,15 +0,0 @@
-=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

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

@@ -1,314 +0,0 @@
-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