irwebmachine 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.pryrc

@@ -0,0 +1,5 @@
+require "webmachine"
+require "./lib/irwebmachine"
+require "./lib/irwebmachine/pry"
+require "./test/fixtures/resource.rb"
+IRWebmachine.app = Resource

data/.travis.yml

@@ -0,0 +1,8 @@
+rvm: 
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+
+notifications:
+  recipients:
+    - rob@flowof.info

data/.yardopts

@@ -0,0 +1,2 @@
+-m markdown
+-M redcarpet

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in irwebmachine.gemspec
+gem 'rake'
+gem 'webmachine', path: "../webmachine-ruby"
+gem 'pry'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Robert Gleeson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+__OVERVIEW__
+
+
+| Project         | IRWebmachine   
+|:----------------|:--------------------------------------------------
+| Homepage        | https://github.com/robgleeson/irwebmachine
+| Documentation   | http://rubydoc.info/gems/irwebmachine/frames
+| Author          | Robert Gleeson
+
+__DESCRIPTION__
+
+IRWebmachine is an interactive debugger you can use to make, trace & debug
+HTTP requests destined for a [webmachine-ruby](https://github.com/seancribbs/webmachine-ruby)
+resource. IRwebmachine is designed to be used inside a REPL such as Pry, but 
+there is very basic IRB support as well. I recommend Pry for now, as IRB support
+is unfinished & Pry offers some cool features for free.
+
+__CONFIGURATION__
+
+Copy the ruby code below into a project-local .pryrc file.
+'MyApp' can be an instance of Webmachine::Application, or a subclass of 
+Webmachine::Resource. It is used by irwebmachine when dispatching requests and 
+it can be changed to another application or resource while in the REPL.
+
+
+```ruby
+require 'myapp'
+require 'irwebmachine/pry'
+IRWebmachine.app = MyApp
+```
+
+__USAGE__
+
+- Making requests
+
+  The first thing you'll probably want to do is make a request to a resource.
+  GET, POST, DELETE & PUT requests can be made through the 'app' method.
+  The example illustrates how to make a GET request:
+
+        [1] pry(main)> app.get "/"
+        => #<Webmachine::Response:0x007faa44143980
+            @body="GET OK",
+            @code=200,
+            @headers=
+              {"Content-Type"=>"plain/text",
+              "Content-Length"=>"6",
+              "X-Request-Query"=>{},
+              "X-Request-Headers"=>{}},
+            @redirect=false,
+            @trace=[]
+            >
+
+- Tracing 
+
+  After you have made a request you can visualize what methods were called(and
+  in what order) through the `print-stack` command. The output can be filtered, 
+  see `print-stack -h` for more information.
+
+        [2] pry(main)> print-stack
+         0: #<Class:Webmachine::Resource>#new
+         1: Webmachine::Resource::Callbacks#service_available?
+         2: Webmachine::Resource::Callbacks#known_methods
+         3: Webmachine::Resource::Callbacks#uri_too_long?
+         4: Resource#allowed_methods
+         …
+        31: Resource#finish_request
+
+- Debugging
+
+  You can jump inside any method on the call stack through the 'enter-stack' 
+  command. It accepts a breakpoint as an argument, but it is optional. The stack 
+  can be navigated in 'real time' through the 'continue', 'next', and 
+  'previous' commands.
+      
+        [3] pry(main)> enter-stack
+        From: /Users/rob/.rbenv/… (shortened for README)
+        => 36: def self.new(request, response)
+           37:   instance = allocate
+           38:   instance.instance_variable_set(:@request, request)
+           39:   instance.instance_variable_set(:@response, response)
+           40:   instance.send :initialize
+           41:   instance
+           42: end
+        [4] pry(Resource)> 
+  
+
+
+__PLATFORM SUPPORT__
+
+  - CRuby 1.9+
+
+__INSTALL__
+
+    gem install irwebmachine
+
+__LICENSE__
+
+See LICENSE.txt

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+
+begin
+  require 'bundler/gem_tasks'
+rescue LoadError
+  require 'rubygems/package_task'
+  Gem::PackageTask.new Gem::Specification.load('irwebmachine.gemspec') do |pkg|
+    pkg.need_tar, pkg.need_zip = true, false
+  end
+end
+
+require 'rake/testtask'
+task :default => :test
+Rake::TestTask.new do |t|
+  t.name = "test"
+  t.test_files = Dir["test/*_test.rb"]
+end

data/irwebmachine.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/irwebmachine/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Rob Gleeson"]
+  gem.email         = ["rob@flowof.info"]
+  gem.description   = %q{IRWebmachine is an interactive debugger you can use to 
+                         make, trace & debug HTTP requests destined for a 
+                         webmachine-ruby resource.} 
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/robgleeson/irwebmachine"
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "irwebmachine"
+  gem.require_paths = ["lib"]
+  gem.version       = IRWebmachine::VERSION
+  gem.add_runtime_dependency "uri-query_params", "~> 0.7.0"
+end

data/lib/irwebmachine/application.rb

@@ -0,0 +1,41 @@
+class IRWebmachine::Application
+  def initialize(app)
+    @app = to_app app
+    @req = nil
+    @res = nil
+  end
+
+  def unbox
+    @app
+  end
+
+  def last_response
+    @res || raise(RuntimeError, "No active request.", [])
+  end
+
+  def last_request
+    @req || raise(RuntimeError, "No active request.", [])
+  end
+
+  %w(get post delete put).each do |type|
+    define_method(type) do |*args|
+      @req = IRWebmachine::TracedRequest.new @app
+      @res = @req.trace(*[type, *args])
+    end
+  end
+
+private
+  def to_app(obj)
+    is_module = obj.is_a? Module
+    is_resource = is_module && obj.ancestors.include?(Webmachine::Resource)
+    if is_resource
+      Webmachine::Application.new do |app|
+        app.routes do
+          add ["*"], obj
+        end
+      end
+    else
+      obj
+    end
+  end
+end

data/lib/irwebmachine/frame.rb

@@ -0,0 +1,26 @@
+class IRWebmachine::Frame
+  def initialize(binding,event)
+    @binding = binding
+    @event   = event
+    @file    = binding.eval "__FILE__"
+    @lineno  = binding.eval "__LINE__"
+    @method  = binding.eval "__method__"
+    @klass   = binding.eval("self").method(@method).owner
+  end
+
+  def ruby_call?
+    "call" == @event
+  end
+
+  def event?(type)
+    type.to_s == @event
+  end
+
+  def context
+    @binding
+  end
+
+  def to_s
+    "#{@klass}##{@method}"
+  end
+end

data/lib/irwebmachine/irb/bundle.rb

@@ -0,0 +1,20 @@
+module IRWebmachine::IRB::Bundle
+  def app
+    IRWebmachine.app || raise(RuntimeError, "No app set. Use IRWebmachine.app= to set one.", []) 
+  end
+
+  def show_stack(filter = //)
+    request = app.last_request 
+    request.stack.each_with_index do |trace, int|
+      puts "#{int}> #{trace}" if trace.to_s =~ filter
+    end
+    nil
+  end
+
+  def enter_stack(num) 
+    request = app.last_request
+    trace = request.stack[num]
+    puts "==> Entering #{trace.klass}##{trace.method}"
+    irb(trace.binding)
+  end
+end

data/lib/irwebmachine/irb.rb

@@ -0,0 +1,8 @@
+module IRWebmachine::IRB
+  require 'irb'
+  require_relative "irb/bundle"
+end
+
+module IRB::ExtendCommandBundle
+  include IRWebmachine::IRB::Bundle
+end

data/lib/irwebmachine/pry/enter_stack.rb

@@ -0,0 +1,58 @@
+class IRWebmachine::Pry::EnterStack < Pry::ClassCommand
+  match       'enter-stack'
+  group       'irwebmachine'
+  description 'Enters the context of a method on the call stack for a webmachine request.'
+  banner <<-BANNER
+    enter-stack BREAKPOINT
+
+    Enters into the context of a method on the call stack for a webmachine
+    request. BREAKPOINT can be retrieved from the print-stack command.
+  BANNER
+
+  def setup
+    @app = target.eval "app"
+    @pry = Pry.new :commands => IRWebmachine::Pry::Nav
+    @req = IRWebmachine::TracedRequest.new @app.unbox
+  end
+
+  def process
+    @req.trace! *@app.last_request
+    repl @req.stack.continue
+  end
+private
+  def repl(frame)
+    until hit?
+      if breakpoint =~ frame.to_s
+        @hit = true
+      else
+        if @req.stack.exhausted?
+          raise Pry::CommandError, 'No matching breakpoint.'
+        else
+          frame = @req.stack.continue
+        end
+      end
+    end
+    case @pry.repl(frame.context)
+    when nil
+      # no-op (exit).
+    when :next
+      repl @req.stack.next
+    when :continue
+      repl @req.stack.continue
+    when :previous
+      repl @req.stack.previous
+    end
+  end
+
+  def hit?
+    @hit
+  end
+
+  def breakpoint
+    @breakpoint ||= Regexp.new(args.first.to_s)
+  end
+end
+
+set = Pry::CommandSet.new
+set.commands["enter-stack"] = IRWebmachine::Pry::EnterStack
+Pry.commands.import(set)

data/lib/irwebmachine/pry/nav.rb

@@ -0,0 +1,14 @@
+module IRWebmachine::Pry
+  Nav = Pry::CommandSet.new do
+    command("continue") { throw(:breakout, :continue) }
+    alias_command "c", "continue"
+
+    command("next") { throw(:breakout, :next) }
+    alias_command "n", "next"
+
+    command("prev") { throw(:breakout, :previous) }
+    alias_command "p", "prev"
+  end
+end
+
+IRWebmachine::Pry::Nav.import(Pry.commands)

data/lib/irwebmachine/pry/print_stack.rb

@@ -0,0 +1,42 @@
+class IRWebmachine::Pry::PrintStack < Pry::ClassCommand
+
+  match       'print-stack'
+  description 'Prints the call stack for the previous webmachine request.'
+  group       'irwebmachine'
+  banner <<-BANNER
+    print-stack [OPTIONS]
+
+    Prints the stack of method calls(in order) made during the previous
+    webmachine request. The stack excludes calls that don't originate from
+    a subclass of Webmachine::Resource.
+  BANNER
+
+  def setup
+    @app = target.eval "app"
+  end
+
+  def options(opt)
+    opt.on :f, 'Filter the stack with a regular expression.', optional: true
+  end
+
+  def process
+    frames = stack.to_a.map do |frame|
+      if frame.ruby_call? && frame.to_s =~ filter
+        frame.to_s
+      end
+    end.compact.join "\n"
+    stagger_output text.with_line_numbers(frames, 0)
+  end
+
+private
+  def stack
+    @app.last_request.stack
+  end
+
+  def filter
+    Regexp.new(opts[:f].to_s)
+  end
+end
+set = Pry::CommandSet.new
+set.commands["print-stack"] = IRWebmachine::Pry::PrintStack
+Pry.commands.import(set)

data/lib/irwebmachine/pry.rb

@@ -0,0 +1,10 @@
+module IRWebmachine::Pry
+  require "pry"
+  require_relative "pry/print_stack"
+  require_relative "pry/enter_stack"
+  require_relative "pry/nav"
+end
+
+def app
+  IRWebmachine.app || raise(RuntimeError, "No app set. Use IRWebmachine.app= to set one.", []) 
+end

data/lib/irwebmachine/stack.rb

@@ -0,0 +1,58 @@
+class IRWebmachine::Stack
+  def initialize(stack = [])
+    @stack = stack
+    @index = -1
+    @tracer = IRWebmachine::Tracer.new
+    @tracer.events = ["call", "return"]
+    @tracer.targets =  [Webmachine::Resource::Callbacks]
+  end
+
+  def push(*args)
+    @stack.push(*args)
+  end
+  alias_method :<<, :push
+
+  def tracer
+    @tracer
+  end
+
+  def previous
+    @index -= 1 if @index > 0
+    @stack[@index]
+  end
+
+  def exhausted?
+    @tracer.finished?
+  end
+
+  def continue
+    if exhausted?
+      if !at_end_of_stack
+        @index += 1
+      end
+    else
+      if at_end_of_stack
+        @stack << tracer.continue
+      end
+      @index += 1
+    end
+    @stack[@index]
+  end
+
+  def next
+    if at_end_of_stack
+      @stack[@index]
+    else
+      frame = nil
+      until frame && frame.ruby_call?
+        frame = continue
+      end
+      frame
+    end
+  end
+
+private
+  def at_end_of_stack
+    @index + 1 > @stack.size - 1
+  end
+end

data/lib/irwebmachine/traced_request.rb

@@ -0,0 +1,55 @@
+class IRWebmachine::TracedRequest
+  #
+  # @param [Webmachine::Application] app
+  #   An instance of Webmachine::Application.
+  #
+  # @return [IRWebmachine::TracedRequest]
+  #   Returns an instance of IRWebmachine::TracedRequest.
+  #
+  def initialize(app)
+    @app = app
+    @req = nil
+    @res = nil
+    @stack = IRWebmachine::Stack.new
+  end
+
+  #
+  # @return [IRWebmachine::Stack]
+  #   Returns an instance of Webmachine::Stack.
+  #
+  def stack
+    @stack
+  end
+
+  def trace(*args)
+    trace!(*args)
+    while frame = @stack.tracer.continue
+      @stack << frame
+    end
+    @res
+  end
+
+  def trace!(type, path, params = {}, headers = {}, body = "")
+    uri = URI::HTTP.build(host: "localhost", path: path)
+    uri.query_params.merge!(params)
+    @req = Webmachine::Request.new type.upcase, uri, headers, body
+    @res = Webmachine::Response.new
+    @stack.tracer.trace do
+      @app.dispatcher.dispatch @req, @res
+    end
+    @res
+  end
+
+  #
+  # @return [Array]
+  #   Returns the arguments given to {#trace} or {#trace!}.
+  #
+  # @example
+  #
+  #   @req.trace "GET", "/"
+  #   @req.trace *@req # replay request.
+  #
+  def to_a
+    [@req.method, @req.uri.path, @req.query, @req.headers, @req.body]
+  end
+end

data/lib/irwebmachine/tracer.rb

@@ -0,0 +1,167 @@
+require 'thread'
+class IRWebmachine::Tracer
+  def initialize
+    @thread  = nil
+    @queue   = SizedQueue.new(1)
+    @targets = [BasicObject]
+    @events  = ["call", "c-call", "return", "c-return", "class", "end", "line",
+    "raise"]
+  end
+
+  #
+  # The [set\_trace\_func](http://apidock.com/ruby/Kernel/set_trace_func) API
+  # documentation has a list of possible events.
+  #
+  # @param [Array<String>] events
+  #   An array of events.
+  #
+  # @return [void]
+  #
+  # @example
+  #   #
+  #   # Push a frame onto the queue when the "call" or "return" event is
+  #   # emitted by set_trace_func. By default, all events push a frame
+  #   # onto the queue.
+  #   #
+  #   tracer.events = ["call", "return"]
+  #
+  def events=(events)
+    @events = events
+  end
+
+  #
+  # @param [Array<Module>] targets
+  #   An array of classes/modules.
+  #
+  # @return [void]
+  #
+  # @example
+  #   #
+  #   # Push a frame onto the queue when `binding.eval('self')` has
+  #   # Webmachine::Resource::Callbacks somewhere in its ancestry tree.
+  #   # By default, targets is equal to [BasicObject].
+  #   #
+  #   tracer.targets = [Webmachine::Resource::Callbacks]
+  #
+  def targets=(targets)
+    @targets = targets
+  end
+
+  #
+  # @return [Boolean]
+  #   Returns true when you cannot trace anymore(e.g: #continue returns nil).
+  #
+  def finished?
+    @queue.empty? && [false, nil].include?(@thread.status)
+  end
+
+  #
+  #
+  # @return [IRwebmachine::Frame]
+  #   Returns an instance of {IRWebmachine::Frame}.
+  #
+  # @return [nil]
+  #   Returns nil when the tracer has finished.
+  #
+  # @example
+  #   #
+  #   # Each call to continue resumes & then suspends the tracer.
+  #   # If you want to trace until there is no more code to trace you
+  #   # could wrap this method in a loop.
+  #   #
+  #   tracer.continue
+  #   tracer.continue
+  #
+  def continue
+    while @queue.empty?
+      sleep 0.01
+      return if finished?
+    end
+    @queue.deq
+  end
+
+  #
+  # @overload def trace(&block)
+  #
+  #   @param [Proc] block
+  #     A block to execute inside the tracer.
+  #
+  #   @return [void]
+  #
+  #   @see Tracer#continue
+  #
+  #   @example
+  #     tracer.trace do
+  #       …
+  #     end
+  #
+  def trace
+    @thread ||=
+    Thread.new do
+      Thread.current.set_trace_func method(:tracer).to_proc
+      yield
+      Thread.current.set_trace_func(nil)
+    end
+  end
+
+private
+
+  def tracer(event, file, lineno, id, binding, klass)
+    try do
+      has_ancestor = @targets.any? do |t|
+        # This says, "binding.eval('self') references a class or module,
+        # and the event(f. ex ':call') came from one of the iterated
+        # targets".
+        klass.is_a?(Module) && klass.ancestors.include?(t)
+      end
+      if has_ancestor && @events.include?(event)
+        frame = IRWebmachine::Frame.new(binding,event)
+        @queue.enq(frame)
+      end
+    end
+  end
+
+  def try
+    begin
+      yield
+    rescue SystemStackError => e
+      puts <<-CRASH
+
+       ----------------------
+        CRASH (IRWebmachine)
+       ----------------------
+
+       The tracer appears to be locked in infinite
+       recursion. This may be a bug in IRWebmachine,
+       but your own code may be the cause.
+
+       The tracer will stop execution now, but the
+       stack up to the point of infinite recursion
+       is retained for debugging.
+
+      CRASH
+      Thread.current.set_trace_func(nil)
+    rescue Exception => e
+      puts <<-CRASH
+
+       ----------------------
+        CRASH (IRWebmachine)
+       ----------------------
+
+       The tracer has crashed.
+       This is a bug in IRWebmachine.
+
+       EXCEPTION:
+       #{e.class}
+
+       MESSAGE:
+       #{e.message}
+
+       BACKTRACE:
+       #{e.backtrace.each { |line| puts(line) }}
+      CRASH
+      Thread.current.set_trace_func(nil)
+    end
+  end
+
+end

data/lib/irwebmachine/version.rb

@@ -0,0 +1,3 @@
+module IRWebmachine
+  VERSION = "0.1.0"
+end

data/lib/irwebmachine.rb

@@ -0,0 +1,17 @@
+module IRWebmachine
+  require "uri/query_params"
+  require_relative "irwebmachine/application"
+  require_relative "irwebmachine/traced_request"
+  require_relative "irwebmachine/frame"
+  require_relative "irwebmachine/tracer"
+  require_relative "irwebmachine/stack"
+  require_relative "irwebmachine/version"
+
+  def self.app=(app)
+    @app = Application.new app
+  end
+
+  def self.app
+    @app
+  end
+end

data/test/fixtures/resource.rb

@@ -0,0 +1,38 @@
+class Resource < Webmachine::Resource
+  def content_types_provided
+    [["plain/text", :to_text]]
+  end
+
+  def content_types_accepted
+    [["*/*", :accept]]
+  end
+
+  def allowed_methods
+    %w(GET POST DELETE PUT)
+  end
+
+  # POST
+  def process_post
+    response.body = "POST OK"
+  end
+
+  # GET
+  def to_text
+    response.body = "GET OK"
+  end
+
+  # PUT
+  def accept
+    response.body = "PUT OK"
+  end
+
+  # DELETE
+  def delete_resource
+    response.body = "DELETE OK"
+  end
+
+  def finish_request
+    response.headers['X-Request-Query'] = request.query
+    response.headers['X-Request-Headers'] = request.headers
+  end
+end

data/test/irwebmachine_application_test.rb

@@ -0,0 +1,50 @@
+require_relative "setup"
+class IRWebmachine::ApplicationTest < Test::Unit::TestCase
+  def setup
+    IRWebmachine.app = app
+    @app = IRWebmachine.app
+  end
+
+  def test_get
+    res = @app.get "/mock_application"
+    assert_equal "GET OK", res.body
+  end
+
+  def test_post
+    res = @app.post "/mock_application"
+    assert_equal "POST OK", res.body
+  end
+
+  def test_delete
+    res = @app.delete "/mock_application"
+    assert_equal "DELETE OK", res.body
+  end
+
+  def test_put
+    res = @app.put "/mock_application"
+    assert_equal "PUT OK", res.body
+  end
+
+  def test_query
+    %w(get post delete put).each do |verb|
+      res = @app.send(verb, "/mock_application", {"foo" => "bar"})
+      assert_equal({"foo" => "bar"}, res.headers['X-Request-Query'])
+    end
+  end
+
+  def test_headers
+    %w(get post delete put).each do |verb|
+      res = @app.send(verb, "/mock_application", {}, {'Answer' => '42'})
+      assert_equal({'Answer' => '42'}, res.headers['X-Request-Headers'])
+    end
+  end
+
+private
+  def app
+    Webmachine::Application.new do |app|
+      app.routes do
+        add ["mock_application"], Resource
+      end
+    end
+  end
+end

data/test/setup.rb

@@ -0,0 +1,8 @@
+require "bundler/setup"
+require "webmachine"
+require "irwebmachine"
+require "json"
+require "test/unit"
+Dir["test/fixtures/*.rb"].each do |file|
+  require "./#{file}"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: irwebmachine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Rob Gleeson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: uri-query_params
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+description: ! "IRWebmachine is an interactive debugger you can use to \n                         make,
+  trace & debug HTTP requests destined for a \n                         webmachine-ruby
+  resource."
+email:
+- rob@flowof.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .pryrc
+- .travis.yml
+- .yardopts
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- irwebmachine.gemspec
+- lib/irwebmachine.rb
+- lib/irwebmachine/application.rb
+- lib/irwebmachine/frame.rb
+- lib/irwebmachine/irb.rb
+- lib/irwebmachine/irb/bundle.rb
+- lib/irwebmachine/pry.rb
+- lib/irwebmachine/pry/enter_stack.rb
+- lib/irwebmachine/pry/nav.rb
+- lib/irwebmachine/pry/print_stack.rb
+- lib/irwebmachine/stack.rb
+- lib/irwebmachine/traced_request.rb
+- lib/irwebmachine/tracer.rb
+- lib/irwebmachine/version.rb
+- test/fixtures/resource.rb
+- test/irwebmachine_application_test.rb
+- test/setup.rb
+homepage: https://github.com/robgleeson/irwebmachine
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 541457732047797415
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 541457732047797415
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: IRWebmachine is an interactive debugger you can use to  make, trace & debug
+  HTTP requests destined for a  webmachine-ruby resource.
+test_files:
+- test/fixtures/resource.rb
+- test/irwebmachine_application_test.rb
+- test/setup.rb