mechanize 0.4.7 → 0.5.0

data/lib/mechanize/cookie.rb

@@ -1,175 +1,174 @@
-require 'date'
+require 'yaml'
+require 'time'
 
 module WWW
+  class Mechanize
   # This class is used to represent an HTTP Cookie.
-  class Cookie
-    attr_reader :name, :value, :path, :domain, :expires, :secure
-    def initialize(cookie)
-      @name     = cookie[:name]
-      @value    = cookie[:value]
-      @path     = cookie[:path]
-      @domain   = cookie[:domain]
-      @expires  = cookie[:expires]
-      @secure   = cookie[:secure]
-      @string   = "#{cookie[:name]}=#{cookie[:value]}"
-    end
-  
-    def Cookie::parse(uri, raw_cookie, &block)
-      esc = raw_cookie.gsub(/(expires=[^,]*),([^;]*(;|$))/i) { "#{$1}#{$2}" }
-      esc.split(/,/).each do |cookie_text|
-        cookie_values = Hash.new
-        cookie = Hash.new
-        cookie_text.split(/; ?/).each do |data|
-          name, value = data.split('=', 2)
-          next unless name
-          cookie[name.strip] = value
-        end
-  
-        cookie_values[:path] = cookie.delete(
-          cookie.keys.find { |k| k.downcase  == "path" }
-        ) || uri.path
+    class Cookie
+      attr_reader :name, :value, :path, :domain, :expires, :secure
+      def initialize(cookie)
+        @name     = cookie[:name]
+        @value    = cookie[:value]
+        @path     = cookie[:path]
+        @domain   = cookie[:domain]
+        @expires  = cookie[:expires]
+        @secure   = cookie[:secure]
+        @string   = "#{cookie[:name]}=#{cookie[:value]}"
+      end
+    
+      def Cookie::parse(uri, raw_cookie, &block)
+        esc = raw_cookie.gsub(/(expires=[^,]*),([^;]*(;|$))/i) { "#{$1}#{$2}" }
+        esc.split(/,/).each do |cookie_text|
+          cookie_values = Hash.new
+          cookie = Hash.new
+          cookie_text.split(/; ?/).each do |data|
+            name, value = data.split('=', 2)
+            next unless name
+            cookie[name.strip] = value
+          end
+    
+          cookie_values[:path] = cookie.delete(
+            cookie.keys.find { |k| k.downcase  == "path" } ) || uri.path
 
-        expires_key = cookie.keys.find { |k| k.downcase == "expires" }
-        if expires_key
-          time = nil
-          expires_val = cookie.delete(expires_key)
+          expires_key = cookie.keys.find { |k| k.downcase == "expires" }
+          if expires_key
+            time = nil
+            expires_val = cookie.delete(expires_key)
 
-          # First lets try dates with timezones
-          [ '%A %d-%b-%y %T %Z',
-            '%a %d-%b-%Y %T %Z',
-            '%a %d %b %Y %T %Z',
-            '%d %b %y %H:%M %Z',      # 14 Apr 89 03:20 GMT
-            '%a %d %b %y %H:%M %Z',   # Fri, 17 Mar 89 4:01 GMT
-            '%a %b %d %H:%M %Z %Y',   # Mon Jan 16 16:12 PDT 1989
-            '%d %b %Y %H:%M-%Z (%A)', # 6 May 1992 16:41-JST (Wednesday)
-            '%y-%m-%d %T %Z',         # 95-06-08 19:32:48 EDT
-          ].each { |fmt|
+            # If we can't parse the time, set it to the current time
             begin
-              time = DateTime.strptime(expires_val, fmt)
-            rescue ArgumentError => er
-            else
-              break
+              time = Time::parse(expires_val)
+            rescue
+              time = Time.now
             end
-          }
 
-          # If it didn't have a timezone, we'll assume GMT, like Mozilla does
-          if time.nil?
-            [
-              '%d %b %y %T %Z',            # 14 Apr 89 03:20:12
-              '%a %d %b %y %T %Z',         # Fri, 17 Mar 89 4:01:33
-              #'%d-%b-%Y %H:%M:%S.%N %Z',   # 22-AUG-1993 10:59:12.82
-              '%d-%b-%Y %H:%M%P %Z',       # 22-AUG-1993 10:59pm
-              '%d-%b-%Y %H:%M %p %Z',      # 22-AUG-1993 12:59 PM
-              #'%A %B %d %Y %H:%M %p',   # Friday, August 04, 1995 3:54 PM
-              '%x %I:%M:%S %p %Z',         # 06/21/95 04:24:34 PM
-              '%d/%m/%y %H:%M %Z',         # 20/06/95 21:07
-            ].each { |fmt|
-              begin
-                time = DateTime.strptime("#{expires_val} GMT", fmt)
-              rescue ArgumentError => er
-              else
-                break
-              end
-            }
+            # If we couldn't parse it, set it to the current time
+            time = Time.now if time == nil
+            cookie_values[:expires] = time
           end
 
-          # If we couldn't parse it, set it to the current time
-          time = DateTime.now if time == nil
-          cookie_values[:expires] = time
-        end
-
-        secure_key = cookie.keys.find { |k| k.downcase == "secure" }
-        if secure_key
-          cookie_values[:secure] = true
-          cookie.delete(secure_key)
-        else
-          cookie_values[:secure] = false
-        end
-  
-        # Set the domain name of the cookie
-        domain_key = cookie.keys.find { |k| k.downcase == "domain" }
-        if domain_key
-          domain = cookie.delete(domain_key)
-          domain.sub!(/^\./, '')
+          secure_key = cookie.keys.find { |k| k.downcase == "secure" }
+          if secure_key
+            cookie_values[:secure] = true
+            cookie.delete(secure_key)
+          else
+            cookie_values[:secure] = false
+          end
+    
+          # Set the domain name of the cookie
+          domain_key = cookie.keys.find { |k| k.downcase == "domain" }
+          if domain_key
+            domain = cookie.delete(domain_key)
+            domain.sub!(/^\./, '')
 
-          # Reject cookies not for this domain
-          next unless uri.host =~ /#{domain}$/
-          cookie_values[:domain] = domain
-        else
-          cookie_values[:domain] = uri.host
-        end
+            # Reject cookies not for this domain
+            next unless uri.host =~ /#{domain}$/
+            cookie_values[:domain] = domain
+          else
+            cookie_values[:domain] = uri.host
+          end
 
-        # Delete the http only option
-        # http://msdn.microsoft.com/workshop/author/dhtml/httponly_cookies.asp
-        http_only = cookie.keys.find { |k| k.downcase == 'httponly' }
-        cookie.delete(http_only) if http_only
+          # Delete the http only option
+          # http://msdn.microsoft.com/workshop/author/dhtml/httponly_cookies.asp
+          http_only = cookie.keys.find { |k| k.downcase == 'httponly' }
+          cookie.delete(http_only) if http_only
 
-        cookie.each { |k,v|
-          cookie_values[:name] = k.strip
-          cookie_values[:value] = v.strip
-        }
-        yield Cookie.new(cookie_values)
+          cookie.each { |k,v|
+            cookie_values[:name] = k.strip
+            cookie_values[:value] = v.strip
+          }
+          yield Cookie.new(cookie_values)
+        end
+      end
+    
+      def to_s
+        @string
       end
     end
-  
-    def to_s
-      @string
-    end
-  end
 
-  # This class is used to manage the Cookies that have been returned from
-  # any particular website.
-  class CookieJar
-    attr_accessor :jar
-    def initialize
-      @jar = {}
-    end
-  
-    # Add a cookie to the Jar.
-    def add(cookie)
-      unless @jar.has_key?(cookie.domain)
-        @jar[cookie.domain] = Hash.new
+    # This class is used to manage the Cookies that have been returned from
+    # any particular website.
+    class CookieJar
+      attr_reader :jar
+
+      def initialize
+        @jar = {}
       end
-  
-      @jar[cookie.domain][cookie.name] = cookie
-      cleanup()
-      cookie
-    end
-  
-    # Fetch the cookies that should be used for the URI object passed in.
-    def cookies(url)
-      cleanup
-      cookies = []
-      @jar.each_key do |domain|
-        if url.host =~ /#{domain}$/
-          @jar[domain].each_key do |name|
-            if url.path =~ /^#{@jar[domain][name].path}/
-              if @jar[domain][name].expires.nil?
-                cookies << @jar[domain][name]
-              elsif DateTime.now < @jar[domain][name].expires
-                cookies << @jar[domain][name]
+    
+      # Add a cookie to the Jar.
+      def add(cookie)
+        unless @jar.has_key?(cookie.domain)
+          @jar[cookie.domain] = Hash.new
+        end
+    
+        @jar[cookie.domain][cookie.name] = cookie
+        cleanup()
+        cookie
+      end
+    
+      # Fetch the cookies that should be used for the URI object passed in.
+      def cookies(url)
+        cleanup
+        cookies = []
+        url.path = '/' if url.path.empty?
+        @jar.each_key do |domain|
+          if url.host =~ /#{domain}$/
+            @jar[domain].each_key do |name|
+              if url.path =~ /^#{@jar[domain][name].path}/
+                if @jar[domain][name].expires.nil?
+                  cookies << @jar[domain][name]
+                elsif Time.now < @jar[domain][name].expires
+                  cookies << @jar[domain][name]
+                end
               end
             end
           end
         end
+    
+        cookies
+      end
+    
+      def empty?(url)
+        cookies(url).length > 0 ? false : true
+      end
+
+      def to_a
+        cookies = []
+        @jar.each_key do |domain|
+          @jar[domain].each_key do |name|
+            cookies << @jar[domain][name]
+          end
+        end
+        cookies
+      end
+
+      # Save the cookie jar to a file as YAML
+      def save_as(file)
+        ::File.open(file, "w") { |f|
+          YAML::dump(@jar, f)
+        }
+      end
+
+      # Load cookie jar from a file stored as YAML
+      def load(file)
+        @jar = ::File.open(file) { |yf| YAML::load( yf ) }
       end
-  
-      cookies
-    end
-  
-    def empty?(url)
-      cookies(url).length > 0 ? false : true
-    end
 
-    private
+      # Clear the cookie jar
+      def clear!
+        @jar = {}
+      end
 
-    # Remove expired cookies
-    def cleanup
-      @jar.each_key do |domain|
-        @jar[domain].each_key do |name|
-          if ! @jar[domain][name].expires.nil? &&
-            DateTime.now > @jar[domain][name].expires
-              @jar[domain].delete(name)
+      private
+      # Remove expired cookies
+      def cleanup
+        @jar.each_key do |domain|
+          @jar[domain].each_key do |name|
+            unless @jar[domain][name].expires.nil?
+              if Time.now > @jar[domain][name].expires
+                @jar[domain].delete(name)
+              end
+            end
           end
         end
       end

data/lib/mechanize/cookie.rb.rej

@@ -0,0 +1,16 @@
+***************
+*** 140,145 ****
+      def cookies(url)
+        cleanup
+        cookies = []
+        @jar.each_key do |domain|
+          if url.host =~ /#{domain}$/
+            @jar[domain].each_key do |name|
+--- 140,146 ----
+      def cookies(url)
+        cleanup
+        cookies = []
++       url.path = '/' if url.path.empty?
+        @jar.each_key do |domain|
+          if url.host =~ /#{domain}$/
+            @jar[domain].each_key do |name|

data/lib/mechanize/errors.rb

@@ -0,0 +1,29 @@
+module WWW
+  class Mechanize
+    # =Synopsis
+    # This class contains an error for when a pluggable parser tries to
+    # parse a content type that it does not know how to handle.  For example
+    # if WWW::Mechanize::Page were to try to parse a PDF, a ContentTypeError
+    # would be thrown.
+    class ContentTypeError < RuntimeError
+      attr_reader :content_type
+    
+      def initialize(content_type)
+        @content_type = content_type
+      end
+    end
+
+    # =Synopsis
+    # This error is thrown when Mechanize encounters a response code it does
+    # not know how to handle.  Currently, this exception will be thrown
+    # if Mechanize encounters response codes other than 200, 301, or 302.
+    # Any other response code is up to the user to handle.
+    class ResponseCodeError < RuntimeError
+      attr_reader :response_code
+    
+      def initialize(response_code)
+        @response_code = response_code
+      end
+    end
+  end
+end

data/lib/mechanize/form.rb

@@ -1,203 +1,228 @@
 module WWW
-# Class Form does not work in the case there is some invalid (unbalanced) html
-# involved, such as: 
-#
-#   <td>
-#     <form>
-#   </td>
-#   <td>
-#     <input .../>
-#     </form>
-#   </td>
-# 
-# GlobalForm takes two nodes, the node where the form tag is located
-# (form_node), and another node, from which to start looking for form elements
-# (elements_node) like buttons and the like. For class Form both fall together
-# into one and the same node.
-  class GlobalForm
-    attr_reader :form_node, :elements_node
-    attr_accessor :method, :action, :name
-  
-    attr_finder :fields, :buttons, :file_uploads, :radiobuttons, :checkboxes
-    attr_reader :enctype
-  
-    def initialize(form_node, elements_node)
-      @form_node, @elements_node = form_node, elements_node
-  
-      @method = (@form_node.attributes['method'] || 'GET').upcase
-      @action = @form_node.attributes['action'] 
-      @name = @form_node.attributes['name']
-      @enctype = @form_node.attributes['enctype'] || 'application/x-www-form-urlencoded'
-      @clicked_buttons = []
-  
-      parse
-    end
-  
-    # In the case of malformed HTML, fields of multiple forms might occure in this forms'
-    # field array. If the fields have the same name, posterior fields overwrite former fields.
-    # To avoid this, this method rejects all posterior duplicate fields.
-  
-    def uniq_fields!
-      names_in = {}
-      fields.reject! {|f|
-        if names_in.include?(f.name)
-          true
-        else
-          names_in[f.name] = true
-          false
-        end
-      }
-    end
-  
-    def build_query(buttons = [])
-      query = []
-  
-      fields().each do |f|
-        next unless f.value
-        query << [f.name, f.value]
+  class Mechanize
+    # =Synopsis
+    # GlobalForm provides all access to form fields, such as the buttons,
+    # check boxes, and text input.
+    #
+    # GlobalForm takes two nodes, the node where the form tag is located
+    # (form_node), and another node, from which to start looking for form
+    # elements (elements_node) like buttons and the like. For class Form
+    # both fall together into one and the same node.
+    #
+    # Class Form does not work in the case there is some invalid (unbalanced)
+    # html involved, such as: 
+    #
+    #   <td>
+    #     <form>
+    #   </td>
+    #   <td>
+    #     <input .../>
+    #     </form>
+    #   </td>
+    # 
+    class GlobalForm
+      attr_reader :form_node, :elements_node
+      attr_accessor :method, :action, :name
+    
+      attr_finder :fields, :buttons, :file_uploads, :radiobuttons, :checkboxes
+      attr_reader :enctype
+    
+      def initialize(form_node, elements_node)
+        @form_node, @elements_node = form_node, elements_node
+    
+        @method = (@form_node.attributes['method'] || 'GET').upcase
+        @action = @form_node.attributes['action'] 
+        @name = @form_node.attributes['name']
+        @enctype = @form_node.attributes['enctype'] || 'application/x-www-form-urlencoded'
+        @clicked_buttons = []
+    
+        parse
       end
-  
-      checkboxes().each do |f|
-        query << [f.name, f.value || "on"] if f.checked
+    
+      # In the case of malformed HTML, fields of multiple forms might occure in this forms'
+      # field array. If the fields have the same name, posterior fields overwrite former fields.
+      # To avoid this, this method rejects all posterior duplicate fields.
+    
+      def uniq_fields!
+        names_in = {}
+        fields.reject! {|f|
+          if names_in.include?(f.name)
+            true
+          else
+            names_in[f.name] = true
+            false
+          end
+        }
+      end
+    
+      # This method builds an array of arrays that represent the query
+      # parameters to be used with this form.  The return value can then
+      # be used to create a query string for this form.
+      def build_query(buttons = [])
+        query = []
+    
+        fields().each do |f|
+          next unless f.value
+          query << [f.name, f.value]
+        end
+    
+        checkboxes().each do |f|
+          query << [f.name, f.value || "on"] if f.checked
+        end
+    
+        radio_groups = {}
+        radiobuttons().each do |f|
+          radio_groups[f.name] ||= []
+          radio_groups[f.name] << f 
+        end
+    
+        # take one radio button from each group
+        radio_groups.each_value do |g|
+          checked = g.select {|f| f.checked}
+    
+          if checked.size == 1
+            f = checked.first
+            query << [f.name, f.value || ""]
+          elsif checked.size > 1 
+            raise "multiple radiobuttons are checked in the same group!" 
+          end
+        end
+
+        @clicked_buttons.each { |b|
+          b.add_to_query(query)
+        }
+    
+        query
       end
-  
-      radio_groups = {}
-      radiobuttons().each do |f|
-        radio_groups[f.name] ||= []
-        radio_groups[f.name] << f 
+
+      # This method adds a button to the query.  If the form needs to be
+      # submitted with multiple buttons, pass each button to this method.
+      def add_button_to_query(button)
+        @clicked_buttons << button
       end
-  
-      # take one radio button from each group
-      radio_groups.each_value do |g|
-        checked = g.select {|f| f.checked}
-  
-        if checked.size == 1
-          f = checked.first
-          query << [f.name, f.value || ""]
-        elsif checked.size > 1 
-          raise "multiple radiobuttons are checked in the same group!" 
+    
+      # This method calculates the request data to be sent back to the server
+      # for this form, depending on if this is a regular post, get, or a
+      # multi-part post,
+      def request_data
+        query_params = build_query()
+        query = nil
+        case @enctype.downcase
+        when 'multipart/form-data'
+          boundary = rand_string(20)
+          @enctype << ", boundary=#{boundary}"
+          params = []
+          query_params.each { |k,v| params << param_to_multipart(k, v) }
+          @file_uploads.each { |f| params << file_to_multipart(f) }
+          query = params.collect { |p| "--#{boundary}\r\n#{p}" }.join('') +
+            "--#{boundary}--\r\n"
+        else
+          query = WWW::Mechanize.build_query_string(query_params)
         end
+    
+        query
+      end
+    
+      def inspect
+        "Form: ['#{@name}' #{@method} #{@action}]"
       end
 
-      @clicked_buttons.each { |b|
-        b.add_to_query(query)
-      }
-  
-      query
-    end
+      private
+      def parse
+        @fields       = WWW::Mechanize::List.new
+        @buttons      = WWW::Mechanize::List.new
+        @file_uploads = WWW::Mechanize::List.new
+        @radiobuttons = WWW::Mechanize::List.new
+        @checkboxes   = WWW::Mechanize::List.new
+    
+        @elements_node.each_recursive {|node|
+          case node.name.downcase
+          when 'input'
+            case (node.attributes['type'] || 'text').downcase
+            when 'text', 'password', 'hidden', 'int'
+              @fields << Field.new(node.attributes['name'], node.attributes['value'] || '') 
+            when 'radio'
+              @radiobuttons << RadioButton.new(node.attributes['name'], node.attributes['value'], node.attributes.has_key?('checked'))
+            when 'checkbox'
+              @checkboxes << CheckBox.new(node.attributes['name'], node.attributes['value'], node.attributes.has_key?('checked'))
+            when 'file'
+              @file_uploads << FileUpload.new(node.attributes['name'], node.attributes['value']) 
+            when 'submit'
+              @buttons << Button.new(node.attributes['name'], node.attributes['value'])
+            when 'image'
+              @buttons << ImageButton.new(node.attributes['name'], node.attributes['value'])
+            end
+          when 'textarea'
+            @fields << Field.new(node.attributes['name'], node.all_text)
+          when 'select'
+            @fields << SelectList.new(node.attributes['name'], node)
+          end
+        }
+      end
 
-    def add_button_to_query(button)
-      @clicked_buttons << button
-    end
-  
-    def request_data
-      query_params = build_query()
-      query = nil
-      case @enctype.downcase
-      when 'multipart/form-data'
-        boundary = rand_string(20)
-        @enctype << ", boundary=#{boundary}"
-        params = []
-        query_params.each { |k,v| params << param_to_multipart(k, v) }
-        @file_uploads.each { |f| params << file_to_multipart(f) }
-        query = params.collect { |p| "--#{boundary}\r\n#{p}" }.join('') +
-          "--#{boundary}--\r\n"
-      else
-        query = WWW::Mechanize.build_query_string(query_params)
+      def rand_string(len = 10)
+        chars = ("a".."z").to_a + ("A".."Z").to_a
+        string = ""
+        1.upto(len) { |i| string << chars[rand(chars.size-1)] }
+        string
+      end
+    
+      def mime_value_quote(str)
+        str.gsub(/(["\r\\])/){|s| '\\' + s}
       end
-  
-      query
-    end
-  
-    def parse
-      @fields       = WWW::Mechanize::List.new
-      @buttons      = WWW::Mechanize::List.new
-      @file_uploads = WWW::Mechanize::List.new
-      @radiobuttons = WWW::Mechanize::List.new
-      @checkboxes   = WWW::Mechanize::List.new
-  
-      @elements_node.each_recursive {|node|
-        case node.name.downcase
-        when 'input'
-          case (node.attributes['type'] || 'text').downcase
-          when 'text', 'password', 'hidden', 'int'
-            @fields << Field.new(node.attributes['name'], node.attributes['value'] || '') 
-          when 'radio'
-            @radiobuttons << RadioButton.new(node.attributes['name'], node.attributes['value'], node.attributes.has_key?('checked'))
-          when 'checkbox'
-            @checkboxes << CheckBox.new(node.attributes['name'], node.attributes['value'], node.attributes.has_key?('checked'))
-          when 'file'
-            @file_uploads << FileUpload.new(node.attributes['name'], node.attributes['value']) 
-          when 'submit'
-            @buttons << Button.new(node.attributes['name'], node.attributes['value'])
-          when 'image'
-            @buttons << ImageButton.new(node.attributes['name'], node.attributes['value'])
-          end
-        when 'textarea'
-          @fields << Field.new(node.attributes['name'], node.all_text)
-        when 'select'
-          @fields << SelectList.new(node.attributes['name'], node)
-        end
-      }
-    end
 
-    def inspect
-      string = "Form: ['#{@name}' -> #{@action}]\n"
-      string << "[radiobuttons]\n"
-      @radiobuttons.each { |f| string << f.inspect }
-      string << "[checkboxes]\n"
-      @checkboxes.each { |f| string << f.inspect }
-      string << "[fields]\n"
-      @fields.each { |f| string << f.inspect }
-      string << "[buttons]\n"
-      @buttons.each { |f| string << f.inspect }
-      string
-    end
-  
-    private
-    def rand_string(len = 10)
-      chars = ("a".."z").to_a + ("A".."Z").to_a
-      string = ""
-      1.upto(len) { |i| string << chars[rand(chars.size-1)] }
-      string
-    end
-  
-    def mime_value_quote(str)
-      str.gsub(/(["\r\\])/){|s| '\\' + s}
+      def param_to_multipart(name, value)
+        return "Content-Disposition: form-data; name=\"" +
+                "#{mime_value_quote(name)}\"\r\n" +
+                "\r\n#{value}\r\n"
+      end
+    
+      def file_to_multipart(file)
+        body =  "Content-Disposition: form-data; name=\"" +
+                "#{mime_value_quote(file.name)}\"; " +
+                "filename=\"#{mime_value_quote(file.file_name)}\"\r\n" +
+                "Content-Transfer-Encoding: binary\r\n"
+        if file.mime_type != nil
+          body << "Content-Type: #{file.mime_type}\r\n"
+        end
+    
+        body << "\r\n#{file.file_data}\r\n"
+    
+        body
+      end
     end
+    
+    # =Synopsis
+    # This class encapsulates a form parsed out of an HTML page.  Each type
+    # of input fields available in a form can be accessed through this object.
+    # See GlobalForm for more methods.
+    #
+    # ==Example
+    # Find a form and print out its fields
+    #  form = page.forms.first # => WWW::Mechanize::Form
+    #  form.fields.each { |f| puts f.name }
+    class Form < GlobalForm
+      attr_reader :node
+    
+      def initialize(node)
+        @node = node
+        super(@node, @node)
+      end
 
-    def param_to_multipart(name, value)
-      return "Content-Disposition: form-data; name=\"" +
-              "#{mime_value_quote(name)}\"\r\n" +
-              "\r\n#{value}\r\n"
-    end
-  
-    def file_to_multipart(file)
-      body =  "Content-Disposition: form-data; name=\"" +
-              "#{mime_value_quote(file.name)}\"; " +
-              "filename=\"#{mime_value_quote(file.file_name)}\"\r\n" +
-              "Content-Transfer-Encoding: binary\r\n"
-      if file.mime_type != nil
-        body << "Content-Type: #{file.mime_type}\r\n"
+      # Fetch the first field whose name is equal to field_name
+      def field(field_name)
+        fields.find { |f| f.name.eql? field_name }
       end
-  
-      body << "\r\n#{file.file_data}\r\n"
-  
-      body
-    end
-  end
-  
-  class Form < GlobalForm
-    attr_reader :node
-  
-    def initialize(node)
-      @node = node
-      super(@node, @node)
-    end
 
-    # Fetch the first field whose name is equal to field_name
-    def field(field_name)
-      fields.find { |f| f.name.eql? field_name }
+      # Treat form fields like accessors.
+      def method_missing(id,*args)
+        method = id.to_s.gsub(/=$/, '')
+        if field(method)
+          return field(method).value if args.empty?
+          return field(method).value = args[0]
+        end
+        super
+      end
     end
   end
 end