tap-http 0.3.0 → 0.3.1

data/History

@@ -1,3 +1,9 @@
+== 0.3.1 / 2009-02-19
+
+Improved handling of multipart/form data.
+
+* http_to_yaml returns config file as an attachment.
+  
 == 0.3.0 / 2009-02-19
 
 Rework of cgi scripts a tap controllers.  Nearly complete

data/README

@@ -35,16 +35,6 @@ must be installed):
 
 Now open a browser and work through the {tutorial}[http://localhost:8080/capture].
 
-=== Bugs/Known Issues
-
-The Tap::Http::Utils#parse_cgi_request (used in parsing redirected requests
-into a YAML file) is currently untested because I can't figure a way to setup 
-the ENV variables in a standard way.  Of course I could set them up myself, but
-I can't be sure I'm setting up a realistic test environment.  
-
-The capture procedure seems to work in practice, but please report bugs and let
-me know if you know a way to setup a CGI environment for testing!
-
 == Installation
 
 TapHttp is available as a gem on RubyForge[http://rubyforge.org/projects/tap].  Use:

data/controllers/capture_controller.rb

@@ -2,54 +2,70 @@ require 'tap/controller'
 require 'tap/http/utils'
 
 class CaptureController < Tap::Controller
+  include Tap::Http::Utils
   
   def index
-    render 'index.erb'
+    tutorial
   end
   
+  # Brings up a tutorial teaching how to capture and resubmit forms.
+  def tutorial
+    render 'tutorial.erb'
+  end
+  
+  # Say is the target of the tutorial.
   def say
     "<pre>#{request.params['words']}</pre>"
   end
     
-  # Echos back redirected HTTP requests  as YAML, suitable for use with the
+  # Echos back redirected HTTP requests as YAML, suitable for use with the
   # Tap::Http::Submit task.  All HTTP parameters and headers are echoed back
   # directly, except for the '__original_action'  parameter which is used in
   # conjuction with the 'Referer' header to reconstruct the original url of
   # the request.  The '__original_action' parameter is not echoed.
-  def http_to_yaml
-    headers = {}
-    request.env.each_pair do |key, value| 
-      headers[key] = value unless key =~ /^(rack|tap)/
-    end
-    params = request.params
-    
-    original_action = params.delete("__original_action").to_s
-    referer = headers['Referer'].to_s
-    uri = Tap::Http::Utils.determine_url(original_action, referer)
-    headers['Host'] = URI.parse(uri).host
-    
-    config = {
-      'headers' => headers,
-      'params' => params,
-      'uri' => uri,
-      'request_method' => request.request_method
-    }
+  def http_to_yaml(keep_content='true')
+    keep_content = keep_content.to_s =~ /true/i
+    config = parse_request(keep_content)
+
+    original_action = config['params'].delete("__original_action").to_s
+    referer = config['headers']['Referer'].to_s
+    config['uri'] = determine_url(original_action, referer)
+    config['headers']['Host'] = URI.parse(config['uri']).host
     
     response['Content-Type'] = "text/plain"
-  %Q{# Save as a configuration file.  Resubmit using:
-#
-#  % rap load <config_file> --: submit --: dump --no-audit
-#
-#{YAML.dump(config)}
-}
+    response['Content-Disposition'] = "attachment; filename=request.yml;"
+    
+    YAML.dump(config)
   end
   
+  # Echos back redirected HTTP requests formatted as YAML.
   def echo
-    headers = {}
-    request.env.each_pair do |key, value| 
-      headers[key] = value unless key =~ /^(rack|tap)/
+    response['Content-Type'] = "text/plain"
+    YAML.dump(config)
+  end
+  
+  protected
+  
+  # helper to parse the request into a request hash for
+  # use by a Tap::Http::Submit task
+  def parse_request(keep_content=true) # :nodoc:
+    config = {}
+    parse_rack_request(request, keep_content).each_pair do |key, value| 
+      config[key.to_s] = value
     end
-    
-    "<pre>#{headers.to_yaml}#{request.params.to_yaml}</pre>"
+    config
+  end
+  
+  # helper to determine the url of a redirected action
+  def determine_url(action, referer) # :nodoc:
+    base = File.basename(referer)
+
+    case action
+    when /^https?:/ then action
+    when /\// 
+      # only use host of page_url
+      File.join(base, action)
+    else File.join(base, action)
+    end 
   end
 end

data/lib/tap/http/request.rb

@@ -234,8 +234,8 @@ module Tap
             body << case value
             when Hash
               hash = headerize_keys(value)
-              filename = hash.delete('Filename') || ""
-              content = File.exists?(filename) ? File.read(filename) : ""
+              filename = hash.delete('Filename')
+              content = hash.delete('Content') || (File.exists?(filename) ? File.read(filename) : "")
 
               header = "Content-Disposition: form-data; name=\"#{key.to_s}\"; filename=\"#{filename}\"\r\n"
               hash.each_pair { |key, value| header << "#{key}: #{value}\r\n" }

data/lib/tap/http/utils.rb

@@ -22,17 +22,6 @@ module Tap
       #   # :params => {},
       #   # }
       #
-      # If splat_values is specified, single-value headers and parameters
-      # will be hashed as single values.  Otherwise, all header and parameter
-      # values will be arrays.
-      #
-      #   str = "GET /path?one=a&one=b&two=c HTTP/1.1\n"
-      #   req = parse_http_request(str)
-      #   req[:params]     # => {'one' => ['a', 'b'], 'two' => 'c'}
-      #
-      #   req = parse_http_request(str, false)
-      #   req[:params]     # => {'one' => ['a', 'b'], 'two' => ['c']}
-      #
       # ==== WEBrick parsing of HTTP format
       #
       # WEBrick will parse headers then the body of a request, and currently
@@ -84,21 +73,21 @@ module Tap
       # TODO: check if there are other headers to capture from
       # a multipart/form file.  Currently only 
       # 'Filename' and 'Content-Type' are added
-      def parse_http_request(socket, splat_values=true)
+      def parse_http_request(socket, keep_content=true)
         socket = StringIO.new(socket) if socket.kind_of?(String)
         
         req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
         req.parse(socket)
 
-        parse_webrick_request(req, splat_values)
+        parse_webrick_request(req, keep_content)
       end
       
       # Parses a WEBrick::HTTPRequest, with the same activity as
       # parse_http_request.
-      def parse_webrick_request(req, splat_values=true)
+      def parse_webrick_request(req, keep_content=true)
         headers = {}
         req.header.each_pair do |key, values| 
-          headers[headerize(key)] = splat_values ? splat(values) : values
+          headers[headerize(key)] = splat(values)
         end if req.header
         
         params = {}
@@ -112,13 +101,15 @@ module Tap
           values = []
           value.each_data do |data|
             values << if data.filename
-              {'Filename' => data.filename, 'Content-Type' => data['Content-Type']}
+              hash = {'Filename' => data.filename, 'Content-Type' => data['Content-Type']}
+              hash['Content'] = data.to_a.join("\n") if keep_content
+              hash
             else
               data.to_s
             end
           end
      
-          params[key] = splat_values ? splat(values) : values
+          params[key] = splat(values)
         end if req.query
         
         { :url => headers['Host'] ? File.join("http://", headers['Host'], req.path_info) : req.path_info,
@@ -128,77 +119,57 @@ module Tap
           :params => params}
       end
       
-      # Parses the input CGI into a hash that may be resubmitted by Dispatch.
-      # To work properly, the standard CGI environmental variables must be
-      # set in ENV.
-      #
-      def parse_cgi_request(cgi, splat_values=true)
+      # Parses a Rack::Request, with the same activity as parse_http_request.
+      def parse_rack_request(request, keep_content=true)
         headers = {}
-        ENV.each_pair do |key, values|
+        request.env.each_pair do |key, value|
           key = case key
           when "HTTP_VERSION" then next
           when /^HTTP_(.*)/ then $1
           when 'CONTENT_TYPE' then key
           else next
           end
-          
-          headers[headerize(key)] = splat_values ? splat(values) : values
+
+          headers[headerize(key)] = value
         end
-        
+
         params = {}
-        cgi.params.each_pair do |key, values|
-          values = values.collect do |value|
-            case
-            when !value.respond_to?(:read)  
-              value
-            when value.original_filename.empty?
-              value.read
-            else
-              {'Filename' => value.original_filename, 'Content-Type' => value.content_type}
+        request.params.each_pair do |key, value|
+          params[key] = each_member(value) do |obj|
+            if obj.kind_of?(Hash)
+              file = {'Content-Type' => value[:type], 'Filename' => value[:filename]}
+              file['Content'] = value[:tempfile].read if keep_content
+              file
+            else value
             end
           end
-          
-          params[key] = splat_values ? splat(values) : values
         end
-        
-        { :url => File.join("http://", headers['Host'], ENV['PATH_INFO']), 
-          :request_method => ENV['REQUEST_METHOD'],
-          :version => ENV['HTTP_VERSION'] =~ /^HTTP\/(.*)$/ ? $1.to_f : ENV['HTTP_VERSION'],
+
+        { 
+          :uri => File.join("http://", headers['Host'], request.env['PATH_INFO']), 
+          :request_method => request.request_method,
+          :version => request.env['HTTP_VERSION'] =~ /^HTTP\/(.*)$/ ? $1.to_f : request.env['HTTP_VERSION'],
           :headers => headers, 
-          :params => params}
+          :params => params
+        }
       end
       
-      def determine_url(action, referer)
-        base = File.basename(referer)
-        
-        case action
-        when /^https?:/ then action
-        when /\// 
-          # only use host of page_url
-          File.join(base, action)
-        else File.join(base, action)
-        end 
-      end
-       
-      # Headerizes an underscored string.  The input is be converted to
-      # a string using to_s.
-      #
-      #   headerize('SOME_STRING')   # => 'Some-String'
-      #   headerize('some string')   # => 'Some-String'
-      #   headerize('Some-String')   # => 'Some-String'
-      #
-      def headerize(str)
-        str.to_s.gsub(/\s|-/, "_").split("_").collect do |s|
-          s =~ /^(.)(.*)/
-          $1.upcase + $2.downcase
-        end.join("-")
+      # Yields each member of an input array to the block and collects the
+      # result.  If obj is not an array, the value is simply yielded to the
+      # block.
+      def each_member(obj)
+        if obj.kind_of?(Array)
+          obj.collect {|value| yield(value) }
+        else
+          yield(obj)
+        end
       end
       
       # Returns the first member of arrays length <= 1, or the array in all
-      # other cases.  Splat is useful to simplify hashes of http headers
+      # other cases. Splat is useful to simplify hashes of http headers
       # and parameters that may have multiple values, but typically only
       # have one.
-      # 
+      #
       #   splat([])                  # => nil
       #   splat([:one])              # => :one
       #   splat([:one, :two])        # => [:one, :two]
@@ -212,6 +183,20 @@ module Tap
         else array
         end
       end
+      
+      # Headerizes an underscored string.  The input is be converted to
+      # a string using to_s.
+      #
+      #   headerize('SOME_STRING')   # => 'Some-String'
+      #   headerize('some string')   # => 'Some-String'
+      #   headerize('Some-String')   # => 'Some-String'
+      #
+      def headerize(str)
+        str.to_s.gsub(/\s|-/, "_").split("_").collect do |s|
+          s =~ /^(.)(.*)/
+          $1.upcase + $2.downcase
+        end.join("-")
+      end
 
       # Inflates (ie unzips) a gzip string, as may be returned by requests
       # that accept 'gzip' and 'deflate' content encoding.

data/views/capture_controller/{index.erb → tutorial.erb}

@@ -21,10 +21,20 @@ else you need to capture the parameters of a form):
 
 <p>
 You should now see some notification that you're redirecting this page.
-Write what you want to say, hit submit, then follow the instructions.
+Write what you want to say, hit submit, and you'll be asked to save a
+configuration file for the request.  Save it, then on the command line
+execute this:
 </p>
 
-<form action='say'>
+<pre><code>  % rap load &lt;config_file&gt; --: submit --: dump --no-audit</code></pre>
+
+<p>
+The request will be submitted and you'll get a printout of the response
+body. To prove everything worked right, click the close link in the
+redirection bar and resubmit the form.
+</p>
+
+<form action='/capture/say'>
 What you want to say: <input name='words' />
 <input type="submit" value="submit">
 </form>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tap-http
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Simon Chiang
@@ -49,7 +49,7 @@ files:
 - lib/tap/http/submit.rb
 - lib/tap/http/utils.rb
 - lib/tap/test/http_test.rb
-- views/capture_controller/index.erb
+- views/capture_controller/tutorial.erb
 - tap.yml
 - README
 - MIT-LICENSE