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

tap-http 0.3.2 → 0.4.0

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