narf 0.5.1

data/lib/web/formreader.rb

@@ -0,0 +1,317 @@
+class FormReader #:nodoc: all
+  attr_accessor :html
+  alias :body :html
+  attr_reader :url
+  attr_accessor :forms
+  def initialize( html )
+    @html = html
+    @parsed = nil
+    @url = ""
+  end
+
+  def get_content
+    html
+  end
+  
+  def forms
+    @forms ||= { }
+  end
+
+  def [] (key)
+    # ugly ugly ugly
+    form_elements( key )
+    forms[key]
+  end
+
+  def form_elements( name )
+    unless( forms[name] )
+      html_tree.get_elements("form").each{ |form|
+        if (name == form.attribute("name"))
+          forms[name] ||= FormElements.new
+
+          forms[name].action = form.attribute("action")
+
+          form.get_elements("input").each{ |e|
+            if ["text","hidden","submit","password","file"].include? e.attribute("type") or e.attribute("type").nil?
+              forms[name].push_text( e.attribute("name"),
+                                     Web.unescape(e.attribute("value")) || "" )
+            elsif e.attribute("type") == "checkbox"
+              # boolean checkboxes
+              #   - assumed if there is no value
+              if (e.attribute("value") == "" || e.attribute("value").nil?)
+                forms[name].push( e.attribute("name"),
+                                  if (e.attribute("checked"))
+                                    true
+                                  else
+                                    false
+                                  end )
+              else
+                # multi select checkboxes
+                select = forms[name].find_select( e.attribute("name") )
+                select.multiple = true
+                select.push_option(e)
+              end
+            elsif e.attribute("type") == "radio"
+              select = forms[name].find_select( e.attribute("name") )
+              select.multiple = false
+              select.push_option(e)
+            elsif e.attribute("type") == "file"
+            end
+          }
+          form.get_elements("textarea").each{ |e|
+            forms[name].push_text e.attribute("name"), e.content.to_s.strip
+          }
+          form.get_elements("select").each { |e|
+            select = Select.new
+            select.multiple = e.attribute("multiple") != nil
+            e.get_elements("option").each{ |option|
+              select.shift_option( option )
+            }
+            forms[name].push_select e.attribute("name"), select
+          }
+        end
+      }
+    end
+    forms[name]
+  end
+
+  def get_fields( name )
+    form_elements(name).get_fields
+  end
+
+  def get_options( name )
+    form_elements(name).get_options
+  end
+
+  def html_tree
+    unless (@html_tree)
+      p = HTMLTree::Parser.new(true, false)
+      p.feed get_content
+      @html_tree = p.tree
+    end
+    @html_tree
+  end
+  
+  
+  def merge_fields( name, edited_fields )
+    form_elements(name).merge_fields(edited_fields)
+  end
+
+  class Option
+    attr_accessor :value, :selected
+    def initialize( value, selected )
+      @value = value; @selected = selected
+    end
+  end
+
+  class Select
+    attr_accessor :options, :multiple
+    def initialize
+      @options = Array.new
+      @multiple = false
+    end
+    
+    def shift_option( option )
+      options.unshift(make_option_from_element(option))
+    end
+
+    def push_option( option )
+      options.push(make_option_from_element(option))
+    end
+
+    def make_option_from_element( element )
+      value = element.attribute("value")
+      unless value
+        value = element.content.to_s
+        value.gsub!( /<[^>]*>/, "" )
+        value.strip!
+      end
+      Option.new( value,
+                  element.attribute("selected") || \
+                  element.attribute("checked") )
+    end
+
+    def each
+      options.each{ |option|
+        yield option.value if option.selected
+      }
+    end
+
+    include Enumerable
+
+    def == other
+      if other.kind_of?(String) && self.to_a.length == 1
+        other == self.to_a[0]
+      else
+        other == self.to_a
+      end
+    end
+
+    # these functions are the interface for assert_includes
+    # we delegate to the array... but also answer to the options hash
+    def has_key?(index)
+      self.to_a.has_key?(index)
+    end
+
+    def __index(key)
+      self.to_a.__index(key)
+    end
+    
+    def compare_includes? haystack, prefix=[]
+      self.to_a.compare_includes? haystack, prefix
+    end
+
+  end
+
+  class FormElements
+    attr_reader :fields
+    attr_accessor :action
+
+    def initialize
+      @fields = {}
+    end
+    
+    def get_fields
+      crushedFields = { }
+      @fields.each{ |k,v|
+        v = v.collect { |v1|
+          if v1.kind_of? Select
+            v1.to_a.sort
+          else
+            v1
+          end
+        }.flatten
+        crushedFields[k] = v
+      }
+      Web::Testing::MultiHashTree.new(crushedFields).fields
+      #crushedFields
+    end
+    
+    def get_options
+      all_options = { }
+      @fields.each{ |k,v|
+        v.each { |field|
+          if (field.kind_of? Select)
+            all_options[k] = field.options.collect{ |o|
+              o.value
+            }
+          end
+        }
+      }
+      all_options
+    end
+
+    def merge_fields( edited_fields )
+      merged = Marshal.load( Marshal.dump( @fields ) )
+      
+      edited_fields.each{ |k,v|
+        # normalize inputs
+        k = k.to_s
+        v = [v] unless v.kind_of? Array
+
+        # guard against errors
+        if merged[k].nil?
+          raise Web::Testing::FieldNotFoundException.new( "Element named #{k} not present on form" )
+        end
+
+        if (v.size > merged[k].size)
+          raise FormMergeError.new( "Only #{merged[k].size} elements on form; " +
+                                            "Can't merge with #{v.size} new values" )
+        end
+
+        v.each_with_index{ |v, i|
+          pristine = @fields[k][i]
+          target   = merged[k][i]
+
+          if (pristine.kind_of? Select)
+            # guard against improperly submitted values
+            unless v.kind_of? Hash
+              raise FormMergeError.new( "Values for select elements must be merged in by using merge('#{k}'=>select('#{v}')" )
+            end
+
+            # guard against merging multiple
+            # values into single select
+            if (pristine.multiple == false) & (v.keys.length > 1 )
+              raise FormMergeError.new( "Trying to merge multiple [#{ v.inspect }] into single select[#{ k }]" )
+            end
+
+            # selects must be merged with a hash
+            v.each{ |value, flag|
+              # guard against merging nonexistent option
+              unless pristine.options.find{ |e|
+                  e.value == value
+                }
+                raise FormMergeError. \
+                new("Form doesn't have an option for #{value}")
+              end
+              
+              
+              # turn off everything else for single selects
+              
+              unless target.multiple || flag == false
+                target.options.each { |o|
+                  o.selected = false
+                }
+              end
+            
+              # merge select fields
+              target.options.find{ |e|
+                e.value == value
+              }.selected = flag
+            }
+            
+          else
+            merged[k][i] = v
+          end
+        }
+      }
+
+      # delete unchecked checkboxes
+      merged.delete_if{ |k,v|
+        v.delete_if{ |e|
+          e == false
+        }
+        v.size == 0
+      }
+
+
+
+      # flatten out select elements
+      merged.each{ |k,v|
+        merged[k] = v.collect{ |e|
+          if (e.kind_of? Select)
+            e.to_a
+          else
+            e
+          end
+        }.flatten
+      }
+      merged
+    end
+    
+    def push( name, value )
+      @fields[name] ||= []
+      @fields[name].push value
+    end
+
+    def find_select( name )
+      select = if (fields[name])
+                 fields[name].find{ |e|
+                   e.kind_of? Select
+                 }
+               end
+      unless select
+        select = Select.new
+        push name, select
+      end
+      select
+    end
+    
+    alias :push_text :push
+    alias :push_select :push
+    
+  end
+end
+
+class FormMergeError < Exception #:nodoc: all
+end

data/lib/web/forms.rb

@@ -0,0 +1,104 @@
+
+class Date # :nodoc: 
+  def _dump(limit) Marshal.dump([@rjd, @sg], -1) end
+  def self._load(str) new0(*Marshal.load(str)) end
+end    
+
+def encode64(bin) # :nodoc:
+   [bin].pack("m").gsub(/\n/,'').gsub(/=/,'.')
+end
+
+def decode64(str) # :nodoc:
+   str.gsub(/\./,'=').unpack("m")[0]
+end
+
+
+module Web
+    module Request         # :nodoc
+	def Request.typed_params params
+	    params2 = {}
+	    params.collect do |k,v|
+		if ! (k =~ /type/)
+		    if (atype = params["#{k}-type"][0]) 
+			begin
+			    params2[k] = eval(Web.unescape(atype)).unencode(v[0])
+			rescue
+			    params2[k] = eval(Web.unescape(atype)).unencode(Web.unescape(v[0]))
+			end
+		    else
+			if v[0].kind_of? String
+			    params2[k] = v[0]
+			else
+			    params2[k] = v[0]
+			end
+		    end
+		end
+	    end
+	    params2
+	end
+
+	def Request.parse_typed_params query_string
+	    Request.typed_params(Web::Request.parse_query_string(query_string))
+	end
+    end
+
+    class << self
+	def encode_objects hash
+	    newhash = {}
+	    hash.each do |k,v|
+		v = ([] << v).flatten
+		v.each { |v|
+		    if v.kind_of?(String)
+			newhash[k] = v
+		    elsif 
+			newhash[k] = Web.escape(v.encode)
+			newhash["#{k}-type"] = v.class.name
+		    end
+		}
+	    end
+	    newhash
+	end
+
+	def typed_params
+	    $__web__cgi.typed_params
+	end
+    end
+        
+    class CGI
+	def typed_params
+	    Request.typed_params multiple_params
+	end
+
+	def make_query_string params
+	    params.collect do |a,b|
+		"#{a}=#{Web.escape(b)}"
+	    end.join("&")
+	end
+	
+	def query
+	    if Web["__submitted"] != ""
+		aquery = {}
+		typed_params.each do |k,v|
+		    if k =~ /^__q\.(.+)/
+			aquery[$1] = v
+		    end
+		end
+		aquery
+	    else
+		typed_params
+	    end
+	end
+	
+	def reset_headers
+	    @headers_sent = false
+	end
+
+	def script_path
+	    if m = /(.*)\//.match(Web.get_cgi.script_name)
+		$1
+	    else
+		""
+	    end
+	end
+    end
+end

data/lib/web/htmlparser/html-parser.rb

@@ -0,0 +1,429 @@
+# HTML parser
+
+require 'sgml-parser'
+
+class HTMLParser < SGMLParser #:nodoc: all
+
+  def initialize(formatter, verbose=nil)
+    super(verbose)
+    @formatter = formatter
+    @savedata = nil
+    @isindex = 0
+    @title = nil
+    @base = nil
+    @anchor = nil
+    @anchorlist = []
+    @nofill = 0
+    @list_stack = []
+  end
+
+
+  def handle_data(data)
+    if @savedata
+      @savedata = @savedata + data
+    else
+      if @nofill != 0
+        @formatter.add_literal_data(data)
+      else
+        @formatter.add_flowing_data(data)
+      end
+    end
+  end
+
+  def save_bgn
+    @savedata = ''
+  end
+
+  def save_end
+    data = @savedata
+    @savedata = nil
+    data = '' if data == nil
+    if @nofill == 0
+      data = data.split.join(" ")
+    end
+    return data
+  end
+
+  def anchor_bgn(href, name, type)
+    @anchor = href
+    if @anchor
+      @anchorlist << href
+    end
+  end
+
+  def anchor_end
+    if @anchor
+      #handle_data(format "[%d]", @anchorlist.length)
+      @anchor = nil
+    end
+  end
+
+  def handle_image(src, alt, *args)
+    handle_data(alt)
+  end
+
+  def start_html(attrs) end
+  def end_html() end
+
+  def start_head(attrs) end
+  def end_head() end
+
+  def start_body(attrs) end
+  def end_body() end
+
+  def start_title(attrs)
+    save_bgn
+  end
+
+  def end_title
+    @title = save_end
+  end
+
+  def do_base(attrs)
+    for a, v in attrs
+      if a == 'href'
+        @base = v
+      end
+    end
+  end
+
+  def do_isindex(attrs)
+    @isindex = 1
+  end
+
+  def do_link(attrs)
+  end
+
+  def do_meta(attrs)
+  end
+
+  def do_nextid(attrs) # Deprecated
+  end
+
+
+  def start_h1(attrs)
+    @formatter.end_paragraph(1)
+    @formatter.push_font('h1', 0, 1, 0)
+  end
+
+  def end_h1
+    @formatter.end_paragraph(1)
+    @formatter.pop_font()
+  end
+
+  def start_h2(attrs)
+    @formatter.end_paragraph(1)
+    @formatter.push_font('h2', 0, 1, 0)
+  end
+
+  def end_h2
+    @formatter.end_paragraph(1)
+    @formatter.pop_font()
+  end
+
+  def start_h3(attrs)
+    @formatter.end_paragraph(1)
+    @formatter.push_font('h3', 0, 1, 0)
+  end
+
+  def end_h3
+    @formatter.end_paragraph(1)
+    @formatter.pop_font()
+  end
+
+  def start_h4(attrs)
+    @formatter.end_paragraph(1)
+    @formatter.push_font('h4', 0, 1, 0)
+  end
+
+  def end_h4
+    @formatter.end_paragraph(1)
+    @formatter.pop_font()
+  end
+
+  def start_h5(attrs)
+    @formatter.end_paragraph(1)
+    @formatter.push_font('h5', 0, 1, 0)
+  end
+
+  def end_h5
+    @formatter.end_paragraph(1)
+    @formatter.pop_font()
+  end
+
+  def start_h6(attrs)
+    @formatter.end_paragraph(1)
+    @formatter.push_font('h6', 0, 1, 0)
+  end
+
+  def end_h6
+    @formatter.end_paragraph(1)
+    @formatter.pop_font()
+  end
+
+  def do_p(attrs)
+    @formatter.end_paragraph(1)
+  end
+
+  def start_pre(attrs)
+    @formatter.end_paragraph(1)
+    @formatter.push_font(nil, nil, nil, 1)
+    @nofill = @nofill + 1
+  end
+
+  def end_pre
+    @formatter.end_paragraph(1)
+    @formatter.pop_font()
+    @nofill = @nofill - 1
+    if @nofill < 0 then @nofill = 0 end
+  end
+
+  def start_xmp(attrs)
+    start_pre(attrs)
+    setliteral('xmp') # Tell SGML parser
+  end
+
+  def end_xmp
+    end_pre
+  end
+
+  def start_listing(attrs)
+    start_pre(attrs)
+    setliteral('listing') # Tell SGML parser
+  end
+
+  def end_listing
+    end_pre
+  end
+
+  def start_address(attrs)
+    @formatter.end_paragraph(0)
+    @formatter.push_font(nil, 1, nil, nil)
+  end
+
+  def end_address
+    @formatter.end_paragraph(0)
+    @formatter.pop_font()
+  end
+
+  def start_blockquote(attrs)
+    @formatter.end_paragraph(1)
+    @formatter.push_margin('blockquote')
+  end
+
+  def end_blockquote
+    @formatter.end_paragraph(1)
+    @formatter.pop_margin()
+  end
+
+  def start_ul(attrs)
+    @formatter.end_paragraph(0)
+    @formatter.push_margin('ul')
+    @list_stack << ['ul', '*', 0]
+  end
+
+  def end_ul
+    if @list_stack
+      @list_stack.pop
+    end
+    @formatter.end_paragraph(0)
+    @formatter.pop_margin
+  end
+
+  def do_li(attrs)
+    @formatter.end_paragraph(0)
+    if @list_stack && @list_stack.size > 0
+      dummy, label, counter = top = @list_stack[-1]
+      top[2] = counter = counter+1
+    else
+      label, counter = '*', 0
+    end
+    @formatter.add_label_data(label, counter)
+  end
+
+  def start_ol(attrs)
+    @formatter.end_paragraph(0)
+    @formatter.push_margin('ol')
+    label = '1.'
+    for a, v in attrs
+      if a == 'type'
+        if v.length == 1
+          v = v + '.'
+          label = v
+        end
+      end
+    end
+    @list_stack << ['ol', label, 0]
+  end
+
+  def end_ol
+    if @list_stack
+      @list_stack.pop
+    end
+    @formatter.end_paragraph(0)
+    @formatter.pop_margin
+  end
+
+  def start_menu(attrs)
+    start_ul(attrs)
+  end
+
+  def end_menu
+    end_ul
+  end
+
+  def start_dir(attrs)
+    start_ul(attrs)
+  end
+
+  def end_dir
+    end_ul
+  end
+
+  def start_dl(attrs)
+    @formatter.end_paragraph(1)
+    @list_stack << ['dl', '', 0]
+  end
+
+  def end_dl
+    ddpop(1)
+    if @list_stack.length > 0
+      @list_stack.pop
+    end
+  end
+
+  def do_dt(attrs)
+    ddpop
+  end
+
+  def do_dd(attrs)
+    ddpop
+    @formatter.push_margin('dd')
+    @list_stack << ['dd', '', 0]
+  end
+
+  def ddpop(bl=0)
+    @formatter.end_paragraph(bl)
+    if @list_stack.length > 0
+      if @list_stack[-1][0] == 'dd'
+        @list_stack.pop
+        @formatter.pop_margin
+      end
+    end
+  end
+
+  def start_cite(attrs) start_i(attrs) end
+  def end_cite() end_i end
+
+  def start_code(attrs) start_tt(attrs) end
+  def end_code() end_tt end
+
+  def start_em(attrs) start_i(attrs) end
+  def end_em() end_i end
+
+  def start_kbd(attrs) start_tt(attrs) end
+  def end_kbd() end_tt end
+
+  def start_samp(attrs) start_tt(attrs) end
+  def end_samp() end_tt end
+
+  def start_strong(attrs) start_b(attrs) end
+  def end_strong() end_b end
+
+  def start_var(attrs) start_i(attrs) end
+  def end_var() end_i end
+
+  def start_i(attrs)
+    @formatter.push_font(nil, 1, nil, nil)
+  end
+  def end_i
+    @formatter.pop_font
+  end
+
+  def start_b(attrs)
+    @formatter.push_font(nil, nil, 1, nil)
+  end
+  def end_b
+    @formatter.pop_font
+  end
+
+  def start_tt(attrs)
+    @formatter.push_font(nil, nil, nil, 1)
+  end
+  def end_tt
+    @formatter.pop_font
+  end
+
+  def start_a(attrs)
+    href = nil
+    name = nil
+    type = nil
+    for attrname, value in attrs
+      value = value.strip
+      if attrname == 'href'
+        href = value
+      end
+      if attrname == 'name'
+        name = value
+      end
+      if attrname == 'type'
+        type = value.downcase
+      end
+    end
+    anchor_bgn(href, name, type)
+  end
+
+  def end_a
+    anchor_end
+  end
+
+  def do_br(attrs)
+    @formatter.add_line_break
+  end
+
+  def do_hr(attrs)
+    @formatter.add_hor_rule
+  end
+
+  def do_img(attrs)
+    align = nil
+    alt = '(image)'
+    ismap = nil
+    src = nil
+    width = 0
+    height = 0
+    for attrname, value in attrs
+      if attrname == 'align'
+        align = value
+      end
+      if attrname == 'alt'
+        alt = value
+      end
+      if attrname == 'ismap'
+        ismap = value
+      end
+      if attrname == 'src'
+        src = value
+      end
+      if attrname == 'width'
+        width = Integer(value)
+      end
+      if attrname == 'height'
+        height = Integer(value)
+      end
+    end
+    handle_image(src, alt, ismap, align, width, height)
+  end
+
+  def do_plaintext(attrs)
+    start_pre(attrs)
+    setnomoretags # Tell SGML parser
+  end
+
+  def unknown_starttag(tag, attrs)
+  end
+
+  def unknown_endtag(tag)
+  end
+
+end