RubyGems - tap-http - Versions diffs - 0.3.2 → 0.4.0 - Mend

tap-http 0.3.2 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

data/History +4 -4
data/README +17 -17
data/lib/tap/http/capture.rb +176 -0
data/lib/tap/http/get.rb +3 -9
data/lib/tap/http/submit.rb +84 -9
data/lib/tap/http/utils.rb +1 -11
data/lib/tap/test/http_test.rb +6 -4
data/tap-http.gemspec +41 -0
data/views/tap/http/capture/footer.erb +4 -0
data/views/tap/http/capture/header.erb +5 -0
data/views/tap/http/capture/http.erb +31 -0
data/views/tap/http/capture/index.erb +11 -0
data/views/tap/http/capture/redirect.css +42 -0
data/views/tap/http/capture/redirect.js +177 -0
data/views/{capture_controller → tap/http/capture}/tutorial.erb +17 -4
metadata +16 -10
data/controllers/capture_controller.rb +0 -82
data/lib/tap/http/request.rb +0 -263

data/History CHANGED

@@ -1,8 +1,8 @@
-== 0.3.2 / 2009-02-23
+== 0.4.0 / 2009-03-17
-Bug fix in handling of multipart/form data.
-* parse_rack_request now parses overloaded params
+Significant rewrite using an updated version of TapServer
+and Mechanize.  TapHttp now serves its own redirection
+commands via TapUbiquity.
 == 0.3.1 / 2009-02-19

data/README CHANGED

@@ -4,11 +4,11 @@ A task library for submitting http requests using {Tap}[http://tap.rubyforge.org
 == Description
-TapHttp provides modules to construct and submit HTTP requests from a hash
-that specifies the target url, headers, parameters, etc.  TapHttp is
-designed to work with a {Ubiquity}[http://labs.mozilla.com/2008/08/introducing-ubiquity/]
-command called {redirect-http}[http://gist.github.com/25932]; together
-they allow the capture and resubmission of web forms.
+TapHttp provides modules to capture and resubmit HTTP requests. TapHttp is
+designed to work with a
+{Ubiquity}[http://labs.mozilla.com/2008/08/introducing-ubiquity/] command
+called redirect-http; together they allow the capture and resubmission of web
+forms.
 * Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/9908-tap-task-application/tickets]
 * Github[http://github.com/bahuvrihi/tap-http/tree/master]
@@ -16,28 +16,28 @@ they allow the capture and resubmission of web forms.
 === Usage
-TapHttp submits http requests using the Tap::Http::Request module.  Headers,
-parameters, and other configurations may be specified, but only a request
-method and uri are required.
+TapHttp submits HTTP requests using
+Mechanize[http://mechanize.rubyforge.org/mechanize/], via the
+Tap::Http::Submit task. Headers and parameters may be specified, but only a
+uri is required.
-  include Tap::Http
-  res = Request.get('http://www.google.com/search')
-  res.body[0,80]  # => "<!doctype html><head><title>tap-http - Google Search</title><style>body{backgrou"
+  Tap::Http::Submit.new.process(:uri => 'http://www.google.com')[0, 80]
+  # => "<html><head><meta http-equiv=\"content-type\" content=\"text/html; charset=ISO-8859"
 === Submitting Web Forms
-Http requests from web forms may be captured and resubmitted using a combination
-of tools.  To do so start a tap server from the command line (of course tap-http
-must be installed):
+HTTP requests from web forms may be captured and resubmitted using a
+combination of tools. To learn how, install tap-http and start a tap server
+from the command line:
   % tap server
-Now open a browser and work through the {tutorial}[http://localhost:8080/capture].
+Now open a browser and work through the {tutorial}[http://localhost:8080/capture/tutorial].
 == Installation
-TapHttp is available as a gem on RubyForge[http://rubyforge.org/projects/tap].  Use:
+TapHttp is available as a gem on RubyForge[http://rubyforge.org/projects/tap].
+Use:
   % gem install tap-http

data/lib/tap/http/capture.rb ADDED

@@ -0,0 +1,176 @@
+require 'tap/controller'
+require 'tap/http/utils'
+require 'tap/ubiquity/utils'
+module Tap
+  module Http
+    # ::controller
+    # ::ubiquity
+    class Capture < Tap::Controller
+      include Tap::Http::Utils
+      include Tap::Ubiquity::Utils
+      PREFIX = '__redirect_http_'
+      REDIRECT_PARAMETER = '__redirect_http_original_action'
+      # Brings up the tutorial.
+      def index
+        render 'index.erb', :locals => {:captures => persistence.index }
+      end
+      def create(id)
+        persistence.create(id) do |io|
+          io << YAML.dump([parse_request])
+        end
+        download(id)
+      end
+      def show(id)
+        response['Content-Type'] = "text/plain"
+        persistence.read(id)
+      end
+      def download(id)
+        path = persistence.path(id)
+        filename = id
+        filename += ".yml" if File.extname(id) == ""
+        response['Content-Type'] = "text/plain"
+        response['Content-Disposition'] = "attachment; filename=#{filename};"
+        persistence.read(id)
+      end
+      def update(id="request")
+        path = persistence.path(id)
+        requests = File.exists?(path) ? YAML.load_file(path) : []
+        requests << parse_request
+        persistence.update(id) do |io|
+          io << YAML.dump(requests)
+        end
+        download(id)
+      end
+      def destroy(id)
+        persistence.destroy(id)
+        index
+      end
+      # Brings up a tutorial teaching how to capture and resubmit forms.
+      def tutorial
+        serve js_injection(:redirect_http) do |link|
+          content = render 'tutorial.erb'
+          content + link
+        end
+      end
+      # Say is the target of the tutorial.
+      def say
+        "<pre>#{request.params['words']}</pre>"
+      end
+      # Returns the redirection script.
+      def redirect_http
+        style = render 'redirect.css'
+        script = render 'redirect.js', :locals => {
+          :redirect_parameter => REDIRECT_PARAMETER,
+          :redirect_action => uri(:update),
+          :header => render('header.erb'),
+          :footer => render('footer.erb')
+        }
+        if request.get?
+          response['Content-Type'] = 'text/plain'
+          %Q{
+<style type="text/css">
+#{style.strip}
+</style>
+<script type="text/javascript">
+#{script.strip}
+</script>}
+        else
+          response['Content-Type'] = 'text/javascript'
+        %Q{
+var style = document.createElement("style");
+style.type = "text/css";
+style.innerHTML = #{style.to_json};
+document.body.appendChild(style);
+var script = document.createElement("script");
+script.type = "text/javascript";
+script.innerHTML = #{script.to_json};
+document.body.appendChild(script);
+}
+        end
+      end
+      # Parses HTTP request
+      def http
+        if request.get?
+          render 'http.erb'
+        else
+          keep_content = request.params['keep_content'] == "true"
+          hash = {}
+          parse_http_request(request.params['http'], keep_content).each_pair do |key, value|
+            hash[key.to_s] = value
+          end
+          # remove extranous data
+          hash.delete('headers')
+          hash.delete('version')
+          response['Content-Type'] = "text/plain"
+          YAML.dump(hash)
+        end
+      end
+      protected
+      def prefix
+        PREFIX
+      end
+      def capture_overloaded_parameters # :nodoc:
+        # perform the actions of Rack::Request::POST, but capture
+        # overloaded parameter names
+        env = request.env
+        env["rack.request.form_input"] = env["rack.input"]
+        unless env["rack.request.form_hash"] = Tap::Http::Utils.parse_multipart(env)
+          env["rack.request.form_vars"] = env["rack.input"].read
+          env["rack.request.form_hash"] = Rack::Utils.parse_query(env["rack.request.form_vars"])
+          env["rack.input"].rewind if env["rack.input"].respond_to?(:rewind)
+        end
+      end
+      # helper to parse the request into a request hash for
+      # use by a Tap::Http::Submit task
+      def parse_request(keep_content=true) # :nodoc:
+        capture_overloaded_parameters
+        hash = {}
+        parse_rack_request(request, keep_content).each_pair do |key, value|
+          hash[key.to_s] = value
+        end
+        action = hash['params'].delete(REDIRECT_PARAMETER)
+        hash['uri'] = if action =~ /^http/
+          # action is an href already
+          action
+        else
+          # make action relative to Referer
+          uri = URI.parse(hash['headers']['Referer'].to_s)
+          uri.path = action
+          uri.to_s
+        end
+        # remove extranous data
+        hash.delete('headers')
+        hash.delete('version')
+        hash
+      end
+    end
+  end
+end

data/lib/tap/http/get.rb CHANGED

@@ -1,19 +1,13 @@
-require 'tap/http/request'
+require 'tap/http/submit'
 module Tap
   module Http
     # Tap::Http::Get::manifest gets the uri
     # Submits an Http request to the specified uri and returns the message body.
-    class Get < Tap::Task
-      include Request
+    class Get < Submit
       def process(uri)
-        log :get, uri
-        res = Request.get(uri)
-        log(nil, res.message)
-        res.body
+        super(:uri => uri)
       end
     end
   end
 end

data/lib/tap/http/submit.rb CHANGED

@@ -1,20 +1,63 @@
-require 'tap/http/request'
+require 'mechanize'
 module Tap
   module Http
     # Tap::Http::Submit::manifest submits a captured http request
     class Submit < Tap::Task
+      Form = WWW::Mechanize::Form
-      def process(opts)
-        opts = symbolize(opts)
+      # mechanize agent configurations
+      nest :mechanize do
+        config :ca_file, nil
+        config :cert, nil
+        config :conditional_requests, true
+        config :follow_meta_refresh, false
+        config :keep_alive, true
+        config :keep_alive_time, 300
+        config :key, nil
+        config :open_timeout, nil
+        config :pass, nil
+        config :read_timeout, nil
+        config :redirect_ok, true
+        config :redirection_limit, 20
+        config :user_agent, "WWW-Mechanize/0.9.2 (http://rubyforge.org/projects/mechanize/)"
+        config :verify_callback, nil
+        config :watch_for_set, nil
+      end
+      def process(*requests)
+        # initialize mechanize agent
+        agent = WWW::Mechanize.new
+        agent.log = app.logger unless app.quiet
+        # reconfigures agent with mechanize config
+        mechanize.config.dup.bind(agent)
-        request_method = opts.delete(:request_method) || 'GET'
-        uri = opts.delete(:uri)
+        agent.pre_connect_hooks << lambda do |options|
+          connection = options[:connection]
+          unless connection.started?
+            log :mechanize, "#{connection.address}#{connection.use_ssl? ? ' (ssl)' : ''}"
+          end
+        end
-        log request_method, uri
-        res = Request.request(request_method, uri, opts)
-        log(nil, res.message)
-        res.body
+        # handle requests
+        requests.inject(nil) do |last_page, request|
+          request = symbolize(request)
+          # note get handles nil request methods (ie '') and has to
+          # reassign uri to url to make mechanize happy
+          page = case request[:request_method].to_s
+          when /get/i, '' then agent.get(request.merge(:url => request[:uri]))
+          when /post/i    then agent.submit(prepare_form(request), nil)
+          when /head/i    then agent.head(nil, nil, request)
+          when /put/i     then agent.put(nil, nil, request)
+          when /delete/i  then agent.delete(nil, nil, request)
+          else raise "unsupported request method: #{request.inspect}"
+          end
+          # process page results if desired
+          block_given? ? yield(page) : page.content
+        end
       end
       protected
@@ -26,6 +69,38 @@ module Tap
           options
         end
       end
+      # A subclass of Hash used exclusively as the node for a form.
+      # Evidently a search method is necessary.
+      class FormNode < Hash # :nodoc:
+        def search(*args); []; end
+      end
+      # prepares a Mechanize::Form for the request.  this method is patterned
+      # after what happens in Mechanize#post.
+      def prepare_form(request) # :nodoc:
+        node = FormNode.new
+        node['method'] = request[:request_method]
+        node['action'] = request[:uri]
+        node['enctype'] = request[:headers] ? request[:headers]['Content-Type'] : nil
+        form = Form.new(node)
+        request[:params].each_pair do |key, value|
+          case value
+          when IO
+            form.enctype = 'multipart/form-data'
+            upload = Form::FileUpload.new(key.to_s, ::File.basename(value.path))
+            upload.file_data = value.read
+            form.file_uploads << upload
+          when Array
+            fields = value.collect {|val| Form::Field.new(key.to_s, val)}
+            form.fields.concat fields
+          else
+            form.fields << Form::Field.new(key.to_s, value)
+          end
+        end
+        form
+      end
     end
   end
 end

data/lib/tap/http/utils.rb CHANGED

@@ -113,7 +113,7 @@ module Tap
           params[key] = splat(values)
         end if req.query
-        { :url => headers['Host'] ? File.join("http://", headers['Host'], req.path_info) : req.path_info,
+        { :uri => headers['Host'] ? File.join("http://", headers['Host'], req.path_info) : req.path_info,
           :request_method => req.request_method,
           :version => req.http_version.to_s,
           :headers => headers,
@@ -199,16 +199,6 @@ module Tap
           $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.
-      #
-      #--
-      # Utils.inflate(res.body) if res['content-encoding'] == 'gzip'
-      #
-      def inflate(str)
-        Zlib::GzipReader.new( StringIO.new( str ) ).read
-      end
       EOL = Rack::Utils::Multipart::EOL
       # Lifted from Rack::Utils::Multipart, and modified to collect

data/lib/tap/test/http_test.rb CHANGED

@@ -14,12 +14,14 @@ module Tap
     module HttpTest
       class MockServer
-        def initialize(body, status=200, headers={})
-          @response = [status, headers, [body]]
+        def initialize(status=200, headers={}, &block)
+          @status = status
+          @headers = headers
+          @block = block
         end
         def call(env)
-          @response
+          [@status, @headers, @block.call(env)]
         end
       end

data/tap-http.gemspec ADDED

@@ -0,0 +1,41 @@
+Gem::Specification.new do |s|
+  s.name = "tap-http"
+  s.version = "0.4.0"
+  s.author = "Simon Chiang"
+  s.email = "simon.a.chiang@gmail.com"
+  s.homepage = "http://tap.rubyforge.org/tap-http"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "A task library for submitting http requests using Tap."
+  s.require_path = "lib"
+  s.rubyforge_project = "tap"
+  s.add_dependency("tap-ubiquity", "= 0.2.0")
+  s.add_dependency("mechanize", ">= 0.9.2")
+  s.has_rdoc = true
+  s.rdoc_options.concat %W{--main README -S -N --title Tap\sHttp}
+  # list extra rdoc files like README here.
+  s.extra_rdoc_files = %W{
+    README
+    MIT-LICENSE
+    History
+  }
+  # list the files you want to include here. you can
+  # check this manifest using 'rake :print_manifest'
+  s.files = %W{
+    lib/tap/http/capture.rb
+    lib/tap/http/get.rb
+    lib/tap/http/submit.rb
+    lib/tap/http/utils.rb
+    lib/tap/test/http_test.rb
+    tap-http.gemspec
+    tap.yml
+    views/tap/http/capture/footer.erb
+    views/tap/http/capture/header.erb
+    views/tap/http/capture/index.erb
+    views/tap/http/capture/http.erb
+    views/tap/http/capture/redirect.css
+    views/tap/http/capture/redirect.js
+    views/tap/http/capture/tutorial.erb
+  }
+end

data/views/tap/http/capture/footer.erb ADDED

@@ -0,0 +1,4 @@
+<div class='<%= prefix %>message'>Redirecting HTTP Requests</div>
+<div class='<%= prefix %>revert'>
+  <a href='javascript:RedirectHttp.revert();'>close</a>
+</div>

data/views/tap/http/capture/header.erb ADDED

@@ -0,0 +1,5 @@
+<div class='<%= prefix %>controls'>
+  <input id='<%= prefix %>id' type='text' value=''>Name</input>
+  <input id='<%= prefix %>continue' type='checkbox'>continue</input>
+</div>
+<%= render 'footer.erb' %>

data/views/tap/http/capture/http.erb ADDED

@@ -0,0 +1,31 @@
+<h1>Parse HTTP Parameters</h1>
+<p>Enter an HTTP request, like the ones you can capture using the
+<a href='https://addons.mozilla.org/en-US/firefox/addon/3829'>LiveHTTPHeaders</a> addon for
+<a href='http://www.mozilla.com/en-US/firefox/'>Firefox</a>.
+</p>
+<form action='<%= uri(:http) %>' method='post'>
+<textarea rows='20' cols='60' name='http'></textarea>
+<br/>
+<input type='checkbox' name='keep_content' value='true' checked='true'> Keep File Content
+<input type='submit' value='Parse'>
+</form>
+<p>Note the request must be properly formated. For example:</p>
+<pre>
+GET / HTTP/1.1
+Host: tap.rubyforge.org
+User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.12) Gecko/20080201 Firefox/2.0.0.12
+Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
+Accept-Language: en-us,en;q=0.5
+Accept-Encoding: gzip,deflate
+Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
+Keep-Alive: 300
+Connection: keep-alive
+</pre>
+<p>Note that POST requests require an empty line between the headers and body.
+Without it you get a WEBrick::HTTPStatus::BadRequest error.</p>

data/views/tap/http/capture/index.erb ADDED

@@ -0,0 +1,11 @@
+<p>Captures:</p>
+<ul>
+<% if captures.empty? %>
+  <li>(none)</li>
+<% end %>
+<% captures.each do |capture| %>
+  <li><a href="<%= uri("show/#{capture}") %>"><%= capture %></a> (<a href="<%= uri("destroy/#{capture}") %>">x</a>)</li>
+<% end %>
+</ul>
+<p>See the <a href="<%= uri(:tutorial) %>">Tutorial</a> for help.</p>

data/views/tap/http/capture/redirect.css ADDED

@@ -0,0 +1,42 @@
+div.<%= prefix %>notification {
+  position:relative;
+  text-align:center;
+  background-color:#EFE3BC;
+  border: thin solid white;
+  font-family: arial;
+  font-size: 16;
+}
+div#<%= prefix %>header {
+  position:relative;
+  top:0;
+  left:0;
+  right:0;
+}
+div#<%= prefix %>footer {
+  position:relative;
+  bottom:0;
+  left:0;
+  right:0;
+}
+div.<%= prefix %>message {
+  display:inline;
+  font-weight:bold;
+}
+div.<%= prefix %>revert {
+  display:inline;
+  position:absolute;
+  right:0;
+  font-size:0.8em;
+  font-weight:normal;
+  text-decoration:none;
+}
+div.<%= prefix %>controls {
+  display:inline;
+  position:absolute;
+  left:0;
+}

data/views/tap/http/capture/redirect.js ADDED

@@ -0,0 +1,177 @@
+var RedirectHttp = {
+  active: function() {
+    var header = document.getElementById("<%= prefix %>header");
+    if(header) return true;
+    else return false;
+  },
+  follow_request: function() {
+    var checkbox = document.getElementById("<%= prefix %>continue");
+    if(checkbox && checkbox.checked) return true;
+    else return false;
+  },
+  redirect_uri: function(tag) {
+    var id = document.getElementById("<%= prefix %>id");
+    return '<%= redirect_action %>/' + escape(id.value);
+  },
+  redirect_form: function(form) {
+    if(RedirectHttp.active()) {
+      form.setAttribute('action', RedirectHttp.redirect_uri());
+      form.submit();
+      if(RedirectHttp.follow_request()) {
+        this.revert();
+        form.submit();
+      }
+      return false;
+    }
+    return true;
+  },
+  redirect_anchor: function(anchor) {
+    if(RedirectHttp.active()) {
+      var original_href = anchor.getAttribute('<%= prefix %>original_href');
+      location.href = RedirectHttp.redirect_uri() + '?<%= redirect_parameter %>=' + escape(original_href);
+      if(RedirectHttp.follow_request()) {
+        this.revert();
+        location.href = anchor.href;
+      }
+      return false;
+    }
+    return true;
+  },
+  // Redirects forms and links to '<%= redirect_action %>'
+  redirect: function() {
+    // Revert if forms have already been redirected
+    if(RedirectHttp.active()) {
+      RedirectHttp.revert();
+      return false;
+    }
+    try {
+      // redirect forms to the redirect_action
+      var forms = document.getElementsByTagName('form');
+      for(i=0; i<forms.length; i++) {
+        var form = forms[i];
+        // store the original action
+        var input = document.createElement("input");
+        input.setAttribute("id", '<%= redirect_parameter %>_' + i);
+        input.setAttribute("name", '<%= redirect_parameter %>');
+        input.setAttribute("type", 'hidden');
+        input.setAttribute("value", form.getAttribute('action'));
+        form.setAttribute('<%= prefix %>index', i);
+        form.appendChild(input);
+        // redirect onSubmit
+        var current_on_submit = '';
+        if(form.hasAttribute("onSubmit")) current_on_submit = form.getAttribute("onSubmit");
+        var on_submit = "return RedirectHttp.redirect_form(this);";
+        form.setAttribute("onSubmit", current_on_submit + ";" + on_submit);
+        form.setAttribute("<%= prefix %>original_callback", current_on_submit);
+      }
+      // redirect anchors to the redirect_action
+      var anchors = document.getElementsByTagName('a');
+      for(i=0; i<anchors.length; i++) {
+        var anchor = anchors[i];
+        // store the original href
+        anchor.setAttribute("<%= prefix %>original_href", anchor.href);
+        // redirect onClick
+        var current_on_click = '';
+        if(anchor.hasAttribute("onClick")) current_on_click = anchor.getAttribute("onClick");
+        var on_click = "return RedirectHttp.redirect_anchor(this);";
+        anchor.setAttribute("onClick", current_on_click + ";" + on_click);
+        anchor.setAttribute("<%= prefix %>original_callback", current_on_click);
+      }
+      // position and show notifications
+      var header = document.createElement("div");
+      header.setAttribute("id", "<%= prefix %>header");
+      header.setAttribute("class", "<%= prefix %>notification");
+      header.innerHTML = <%= header.to_json %>;
+      document.body.insertBefore(header, document.body.firstChild);
+      var footer = document.createElement("div");
+      footer.setAttribute("id", "<%= prefix %>footer");
+      footer.setAttribute("class", "<%= prefix %>notification");
+      footer.innerHTML = <%= footer.to_json %>;
+      document.body.appendChild(footer);
+    } catch(ex) {
+      alert_error(ex);
+    }
+  },
+  // Reverts redirection.
+  revert: function() {
+    try {
+      // redirect forms back to original actions
+      var forms = document.getElementsByTagName('form');
+      for(i=0; i<forms.length; i++) {
+        var form = forms[i];
+        // check in case the form is not redirected
+        if(form.hasAttribute('<%= prefix %>index')) {
+          var index = form.getAttribute('<%= prefix %>index');
+          var input = document.getElementById("<%= redirect_parameter %>_" + index);
+          form.setAttribute('action', input.value);
+          form.removeAttribute('<%= prefix %>index');
+          form.removeChild(input);
+          form.setAttribute('onSubmit', form.getAttribute('<%= prefix %>original_callback'));
+          form.removeAttribute('<%= prefix %>original_callback');
+        }
+      }
+      // redirect anchors back to original hrefs
+      var anchors = document.getElementsByTagName('a');
+      for(i=0; i<anchors.length; i++) {
+        var anchor = anchors[i];
+        // check in case the anchor is not redirected
+        if(anchor.hasAttribute('<%= prefix %>original_action')) {
+          anchor.setAttribute('href', anchor.getAttribute('<%= prefix %>original_href'));
+          anchor.removeAttribute('<%= prefix %>original_href');
+          anchor.setAttribute('onClick', anchor.getAttribute('<%= prefix %>original_callback'));
+          anchor.removeAttribute('<%= prefix %>original_callback');
+        }
+      }
+      // remove notifications
+      var header = document.getElementById("<%= prefix %>header");
+      if(header) document.body.removeChild(header);
+      var footer = document.getElementById("<%= prefix %>footer");
+      if(footer) document.body.removeChild(footer);
+    } catch(ex) {
+      alert_error(ex);
+    }
+  },
+  // Alerts of errors due to RedirectHttp
+  alert_error: function(ex) {
+    alert("Redirect HTTP Error: " + ex.message + "\n\n The webpage may have been corrupted; be sure to refresh.");
+  }
+};
+RedirectHttp.redirect();

data/views/{capture_controller → tap/http/capture}/tutorial.erb RENAMED

@@ -6,7 +6,7 @@ resubmission at a later date.  First, get the environment right:
 <ul>
 <li>Be sure you're viewing this in <a href="http://www.mozilla.com/en-US/firefox/">Firefox</a></li>
 <li>Install <a href="http://labs.mozilla.com/2008/08/introducing-ubiquity/">Ubiquity</a></li>
-<li>Subscribe to the <a href="http://gist.github.com/25932">redirect-http</a> command</li>
+<li>Subscribe to the redirect-http command on this page</li>
 </ul>
 <p>
@@ -16,7 +16,7 @@ else you need to capture the parameters of a form):
 <ul>
 <li>Bring up Ubiquity in Firefox by pressing 'option+space'</li>
-<li>Enter the command: redirect-http http://localhost:8080/capture/http_to_yaml</li>
+<li>Enter the command: redirect_http</li>
 </ul>
 <p>
@@ -34,7 +34,20 @@ body. To prove everything worked right, click the close link in the
 redirection bar and resubmit the form.
 </p>
+<a href="/capture/say?words=link+was+clicked">Link</a>
 <form action='/capture/say'>
-What you want to say: <input name='words' />
-<input type="submit" value="submit">
+Form: <input name='words' value="form was submitted"/>
+<input type="submit" value="submit" />
+</form>
+<p>
+Note that redirection occurs via the on-click and on-submit callbacks for
+links and forms, respectively.  The existing behavior is preserved, as can
+be demonstrated below:
+</p>
+<a href="/capture/say?words=link+was+clicked" onclick='alert("Link was clicked!")'>Link with OnClick</a>
+<form action='/capture/say' onsubmit='alert("Form was submitted!")'>
+Form with OnSubmit: <input name='words' value="form was submitted"/>
+<input type="submit" value="submit" />
 </form>

metadata CHANGED

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tap-http
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Simon Chiang
@@ -9,28 +9,28 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2009-02-23 00:00:00 -07:00
+date: 2009-03-17 00:00:00 -06:00
 default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: tap
+  name: tap-ubiquity
   type: :runtime
   version_requirement:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version
-        version: 0.12.2
+        version: 0.2.0
     version:
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: mechanize
   type: :runtime
   version_requirement:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.1
+        version: 0.9.2
     version:
 description:
 email: simon.a.chiang@gmail.com
@@ -43,14 +43,20 @@ extra_rdoc_files:
 - MIT-LICENSE
 - History
 files:
-- controllers/capture_controller.rb
+- lib/tap/http/capture.rb
 - lib/tap/http/get.rb
-- lib/tap/http/request.rb
 - lib/tap/http/submit.rb
 - lib/tap/http/utils.rb
 - lib/tap/test/http_test.rb
-- views/capture_controller/tutorial.erb
+- tap-http.gemspec
 - tap.yml
+- views/tap/http/capture/footer.erb
+- views/tap/http/capture/header.erb
+- views/tap/http/capture/index.erb
+- views/tap/http/capture/http.erb
+- views/tap/http/capture/redirect.css
+- views/tap/http/capture/redirect.js
+- views/tap/http/capture/tutorial.erb
 - README
 - MIT-LICENSE
 - History

data/controllers/capture_controller.rb DELETED

@@ -1,82 +0,0 @@
-require 'tap/controller'
-require 'tap/http/utils'
-class CaptureController < Tap::Controller
-  include Tap::Http::Utils
-  def index
-    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
-  # 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(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"
-    response['Content-Disposition'] = "attachment; filename=request.yml;"
-    YAML.dump(config)
-  end
-  # Echos back redirected HTTP requests formatted as YAML.
-  def echo
-    response['Content-Type'] = "text/plain"
-    YAML.dump(parse_request)
-  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:
-    # perform the actions of Rack::Request::POST, but capturing
-    # overloaded parameter names
-    env = request.env
-    env["rack.request.form_input"] = env["rack.input"]
-    unless env["rack.request.form_hash"] = Tap::Http::Utils.parse_multipart(env)
-      env["rack.request.form_vars"] = env["rack.input"].read
-      env["rack.request.form_hash"] = Rack::Utils.parse_query(env["rack.request.form_vars"])
-      env["rack.input"].rewind if env["rack.input"].respond_to?(:rewind)
-    end
-    config = {}
-    parse_rack_request(request, keep_content).each_pair do |key, value|
-      config[key.to_s] = value
-    end
-    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 DELETED

@@ -1,263 +0,0 @@
-require 'tap/http/utils'
-require 'net/http'
-require 'rack/utils'
-module Tap
-  module Http
-    # Request is a module for submitting HTTP requests.  Request take a request
-    # method, a uri, and an options hash allowing these parameters:
-    #
-    #   headers:: a hash of headers
-    #   params:: a hash of parameters, values may be arrays when multiple
-    #            values are assigned to a single key
-    #   version: the HTTP version, by default 1.1
-    #   redirection_limit:: the number of redirections allowed, by default 10
-    #
-    module Request
-      module_function
-      # Constructs and submits an http request to the uri using the specified
-      # request method and options (see above).  Currently only get and post
-      # are supported as request methods. A block may be given to receive the
-      # Net::HTTP and request just prior to submission.
-      #
-      # Returns the Net::HTTP response.
-      def request(request_method, uri, opts={})
-        uri = "http://#{uri}" unless uri.to_s =~ /^http/
-        uri = URI.parse(uri) unless uri.kind_of?(URI)
-        uri.path = "/" if uri.path.empty?
-        headers = opts[:headers] || {}
-        params = opts[:params] || {}
-        # construct the request
-        request = case request_method.to_s
-        when /^get$/i then construct_get(uri, headers, params)
-        when /^post$/i then construct_post(uri, headers, params)
-        else
-          raise ArgumentError, "unsupported request method: #{request_method}"
-        end
-        # set the http version
-        version = opts[:version] || 1.1
-        version_method = "version_#{version.to_s.gsub(".", "_")}".to_sym
-        if ::Net::HTTP.respond_to?(version_method)
-          ::Net::HTTP.send(version_method)
-        else
-          raise ArgumentError, "unsupported HTTP version: #{version}"
-        end
-        # submit the request
-        res = ::Net::HTTP.new(uri.host, uri.port).start do |http|
-          yield(http, request) if block_given?
-          http.request(request)
-        end
-        # fetch redirections
-        redirection_limit = opts[:redirection_limit] || 10
-        redirection_limit ? fetch_redirection(res, redirection_limit) : res
-      end
-      # Shortcut to submit a get request.
-      def get(uri, opts={})
-        request(:get, uri, opts)
-      end
-      # Shortcut to submit a post request.
-      def post(uri, opts={})
-        request(:post, uri, opts)
-      end
-      def escape(str)
-        Rack::Utils.escape(str)
-      end
-      # Constructs a Net::HTTP::Post query, setting headers and parameters.
-      #
-      # ==== Supported Content Types:
-      #
-      # - application/x-www-form-urlencoded (the default)
-      # - multipart/form-data
-      #
-      # The multipart/form-data content type may specify a boundary.  If no
-      # boundary is specified, a randomly generated boundary will be used
-      # to delimit the parameters.
-      #
-      #   post = construct_post(
-      #     URI.parse('http://some.url/'),
-      #     {:content_type => 'multipart/form-data; boundary=1234'},
-      #     {:key => 'value'})
-      #
-      #   post.body
-      #   # => %Q{--1234\r
-      #   # Content-Disposition: form-data; name="key"\r
-      #   # \r
-      #   # value\r
-      #   # --1234--\r
-      #   # }
-      #
-      # (Note the carriage returns are required in multipart content)
-      #
-      # The content-length header is determined automatically from the
-      # formatted request body; manually specified content-length headers
-      # will be overridden.
-      #
-      def construct_post(uri, headers, params)
-        req = ::Net::HTTP::Post.new( "#{uri.path}#{format_query(uri)}" )
-        headers = headerize_keys(headers)
-        content_type = headers['Content-Type']
-        case content_type
-        when nil, /^application\/x-www-form-urlencoded$/i
-          req.body = format_www_form_urlencoded(params)
-          headers['Content-Type'] ||= "application/x-www-form-urlencoded"
-          headers['Content-Length'] = req.body.length
-        when /^multipart\/form-data(;\s*boundary=(.*))?$/i
-          # extract the boundary if it exists
-          boundary = $2 || rand.to_s[2..20]
-          req.body = format_multipart_form_data(params, boundary)
-          headers['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
-          headers['Content-Length'] = req.body.length
-        else
-          raise ArgumentError, "unsupported Content-Type for POST: #{content_type}"
-        end
-        headers.each_pair {|key, value| req[key] = value }
-        req
-      end
-      # Constructs a Net::HTTP::Get query.  All parameters in uri and params are
-      # encoded and added to the request URI.
-      #
-      #   get = construct_get(URI.parse('http://some.url/path'), {}, {:key => 'value'})
-      #   get.path            # => "/path?key=value"
-      #
-      def construct_get(uri, headers, params)
-        req = ::Net::HTTP::Get.new( "#{uri.path}#{format_query(uri, params)}" )
-        headerize_keys(headers).each_pair {|key, value| req[key] = value }
-        req
-      end
-      # Checks the type of the response; if it is a redirection, fetches the
-      # redirection.  Otherwise return the response.
-      #
-      # Notes:
-      # - Fetch will recurse up to the input redirection limit (default 10)
-      # - Responses that are not Net::HTTPRedirection or Net::HTTPSuccess
-      #   raise an error.
-      def fetch_redirection(res, limit=10)
-        raise 'exceeded the redirection limit' if limit < 1
-        case res
-        when ::Net::HTTPRedirection
-          redirect = ::Net::HTTP.get_response( URI.parse(res['location']) )
-          fetch_redirection(redirect, limit - 1)
-        when ::Net::HTTPSuccess
-          res
-        else
-          raise StandardError, res.error!
-        end
-      end
-      # Constructs a URI query string from the uri and the input parameters.
-      # Multiple values for a parameter may be specified using an array.
-      #
-      #   format_query(URI.parse('http://some.url/path'), {:key => 'value'})
-      #   # => "?key=value"
-      #
-      #   format_query(URI.parse('http://some.url/path?one=1'), {:two => '2'})
-      #   # => "?one=1&two=2"
-      #
-      def format_query(uri, params={})
-        query = []
-        query << uri.query if uri.query
-        params.each_pair do |key, values|
-          values = [values] unless values.kind_of?(Array)
-          values.each { |value| query << "#{escape(key)}=#{escape(value)}" }
-        end
-        "#{query.empty? ? '' : '?'}#{query.join('&')}"
-      end
-      # Formats params as 'application/x-www-form-urlencoded' for use as the
-      # body of a post request.  Multiple values for a parameter may be
-      # specified using an array.  The result is obviously URI encoded.
-      #
-      #   format_www_form_urlencoded(:key => 'value with spaces')
-      #   # => "key=value+with+spaces"
-      #
-      def format_www_form_urlencoded(params={})
-        query = []
-        params.each_pair do |key, values|
-          values = [values] unless values.kind_of?(Array)
-          values.each { |value| query << "#{escape(key)}=#{escape(value)}" }
-        end
-        query.join('&')
-      end
-      # Formats params as 'multipart/form-data' using the specified boundary,
-      # for use as the body of a post request.  Multiple values for a parameter
-      # may be specified using an array.  All newlines include a carriage
-      # return for proper formatting.
-      #
-      #   format_multipart_form_data(:key => 'value')
-      #   # => %Q{--1234567890\r
-      #   # Content-Disposition: form-data; name="key"\r
-      #   # \r
-      #   # value\r
-      #   # --1234567890--\r
-      #   # }
-      #
-      # To specify a file, use a hash of file-related headers.
-      #
-      #   format_multipart_form_data(:key => {
-      #     'Content-Type' => 'text/plain',
-      #     'Filename' => "path/to/file.txt"}
-      #   )
-      #   # => %Q{--1234567890\r
-      #   # Content-Disposition: form-data; name="key"; filename="path/to/file.txt"\r
-      #   # Content-Type: text/plain\r
-      #   # \r
-      #   # \r
-      #   # --1234567890--\r
-      #   # }
-      #
-      def format_multipart_form_data(params, boundary="1234567890")
-        body = []
-        params.each_pair do |key, values|
-          values = [values] unless values.kind_of?(Array)
-          values.each do |value|
-            body << case value
-            when Hash
-              hash = headerize_keys(value)
-              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" }
-              "#{header}\r\n#{content}\r\n"
-            else
-              %Q{Content-Disposition: form-data; name="#{key.to_s}"\r\n\r\n#{value.to_s}\r\n}
-            end
-          end
-        end
-        body.collect {|p| "--#{boundary}\r\n#{p}" }.join('') + "--#{boundary}--\r\n"
-      end
-      # Helper to headerize the keys of a hash to headers.
-      # See Utils#headerize.
-      def headerize_keys(hash)
-        result = {}
-        hash.each_pair do |key, value|
-          result[Utils.headerize(key)] = value
-        end
-        result
-      end
-    end
-  end
-end