party_foul 0.3.0 → 0.4.0

data/README.md

@@ -8,23 +8,23 @@ Rails exceptions automatically opened as issues on Github
 
 ## About ##
 
-`PartyFoul` will capture exceptions in your application and will do the
+`PartyFoul` captures exceptions in your application and does the
 following:
 
-1. Will attempt to find a matching issue in your Github repo
-2. If no matching issue is found an new issue will be created with a
-   unique title, session information, and stack trace. The issue will be
-tagged as a `bug`. A new comment will be added with relevant data on the
+1. Attempt to find a matching issue in your Github repo
+2. If no matching issue is found an new issue is created with a
+   unique title, session information, and stack trace. The issue is
+tagged as a `bug`. A new comment is added with relevant data on the
 application state.
-3. If an open issue is found the occurance count and time stamp will be
-   updated. A new comment will be added with relevant data on the
+3. If an open issue is found the occurance count and time stamp is
+   updated. A new comment is added with relevant data on the
 application state.
-4. If a closed issue is found the occurance count and time stamp will be
-   updated. The issue will be reopened and a `regression` tag will be
-added. A new comment will be added with relevant data on the
+4. If a closed issue is found the occurance count and time stamp is
+   updated. The issue is reopened and a `regression` tag is
+added. A new comment is added with relevant data on the
 application state.
 5. If the issue is marked as `wontfix` the issue is not updated nor is
-   a new issue created. No comments will be added.
+   a new issue created. No comments are added.
 
 ## Installation ##
 
@@ -32,7 +32,7 @@ application state.
 a collaborator on your repository. Use this new account's credentials
 for the installation below. If you use your own account you will
 not receive emails when issues are created, updated, reopened, etc...
-because all of the work will be done as your account.
+because all of the work is done as your account.
 
 In your Gemfile add the following:
 
@@ -47,8 +47,8 @@ If you are using Rails you can run the install generator.
 rails g party_foul:install
 ```
 
-This will prompt you for the Github credentials of the account that will
-be opening the issues. The OAuth token for that account will be stored
+This prompts you for the Github credentials of the account that is
+opening the issues. The OAuth token for that account is stored
 in `config/initializers/party_foul.rb`. You may want to remove the token
 string and store in an environment variable. It is best not to store the
 token in version control.
@@ -60,30 +60,33 @@ config.middleware.use('PartyFoul::Middleware')
 ```
 ### Other ###
 
-You will need to initialize `PartyFoul`, you can use the following to do
-so:
+You need to initialize `PartyFoul`, use the following:
 
 ```ruby
 PartyFoul.configure do |config|
   # the collection of exceptions to be ignored by PartyFoul
   # The constants here *must* be represented as strings
-  config.ignored_exceptions = ['ActiveRecord::RecordNotFound', 'ActionController::RoutingError']
+  config.ignored_exceptions    = ['ActiveRecord::RecordNotFound', 'ActionController::RoutingError']
 
   # The names of the HTTP headers to not report
   config.filtered_http_headers = ['Cookie']
 
-  # The OAuth token for the account that will be opening the issues on Github
-  config.oauth_token        = 'abcdefgh1234567890'
+  # The OAuth token for the account that is opening the issues on Github
+  config.oauth_token           = 'abcdefgh1234567890'
 
   # The API endpoint for Github. Unless you are hosting a private
   # instance of Enterprise Github you do not need to include this
-  config.endpoint           = 'https://api.github.com'
+  config.endpoint              = 'https://api.github.com'
+
+  # The Web URL for Github. Unless you are hosting a private
+  # instance of Enterprise Github you do not need to include this
+  config.web_url               = 'https://github.com'
 
   # The organization or user that owns the target repository
-  config.owner              = 'owner_name'
+  config.owner                 = 'owner_name'
 
   # The repository for this application
-  config.repo               = 'repo_name'
+  config.repo                  = 'repo_name'
 end
 ```
 
@@ -100,20 +103,20 @@ Add as the very last middleware in your production `Rack` stack.
 
 ## Customization ##
 
-### Async Adapters ###
+### Background Processing ###
 
 You can specify the adapter with which the exceptions should be
 handled. By default, PartyFoul includes the
 [`PartyFoul::SyncAdapter`](https://github.com/dockyard/party_foul/tree/master/lib/party_foul/sync_adapter.rb)
-which will handle the exception synchronously. To use your own adapter,
+which handles the exception synchronously. To use your own adapter,
 include the following in your `PartyFoul.configure` block:
 
 ```ruby
 PartyFoul.configure do |config|
-  config.adapter = MyAsyncAdatper
+  config.adapter = PartyFoul::Processors::MyBackgroundProcessor
 end
 
-class MyAsyncAdapter
+class PartyFoul::Processors::MyBackgroundProcessor
   def self.handle(exception, env)
     # Enqueue the exception, then in your worker, call
     # PartyFoul::ExceptionHandler.new(exception, env).run
@@ -122,7 +125,7 @@ end
 
 ```
 
-## Changing How Issues Are Reported ##
+### Changing How Issues Are Reported ###
 
 `PartyFoul` comes with default templates for what the body of issues and
 comments are. If you want to override these templates you simply need to
@@ -130,20 +133,17 @@ add them as an option in your initializer:
 
 ```ruby
 PartyFoul.configure do |config|
-  config.issue_body = <<-TEMPLATE
-:issue_title
-TEMPLATE
-
-  config.comment_body = <<-TEMPLATE
-:occurred_at
-TEMPLATE
+  config.issue_body   = ':issue_title'
+  config.comment_body = ':occurred_at'
+end
 ```
 
 In this over-simplistic example the words that start with `:` in the
-templates will be evaluated with the value of the corresponding named
-instance method on the instance of `PartyFoul::ExceptionHandler`. If you
+templates are evaluated with the value of the corresponding named
+instance method on the instance of `PartyFoul::IssueRenderer`. If you
 want to add additional values for replacement you should open that class
-to add the methods.
+to add the methods. Depending upon the data point you may want o make
+the change in one of the [different issue renderer adapters](https://github.com/dockyard/party_foul/tree/master/lib/party_foul/issue_renderers).
 
 ## Authors ##
 

data/lib/generators/party_foul/install_generator.rb

@@ -11,11 +11,12 @@ module PartyFoul
       password  = STDIN.noecho { ask 'Github password:' }
       @owner    = ask_with_default "\nRepository owner:", login
       @repo     = ask 'Repository name:'
-      @endpoint = ask_with_default 'Endpoint:', 'https://api.github.com'
+      @endpoint = ask_with_default 'Api Endpoint:', 'https://api.github.com'
+      @web_url  = ask_with_default 'Web URL:', 'https://github.com'
 
       begin
         github       = Github.new :login => login, :password => password, :endpoint => @endpoint
-        @oauth_token = github.oauth.create('scopes' => ['repo']).token
+        @oauth_token = github.oauth.create(scopes: ['repo'], note: "PartyFoul #{@owner}/#{@repo}", note_url: "#{@web_url}/#{@owner}/#{@repo}").token
         template 'party_foul.rb', 'config/initializers/party_foul.rb'
       rescue Github::Error::Unauthorized
         say 'There was an error retrieving your Github OAuth token'

data/lib/generators/party_foul/templates/party_foul.rb

@@ -6,13 +6,17 @@ PartyFoul.configure do |config|
   # The names of the HTTP headers to not report
   config.filtered_http_headers = ['Cookie']
 
-  # The OAuth token for the account that will be opening the issues on Github
+  # The OAuth token for the account that is opening the issues on Github
   config.oauth_token           = '<%= @oauth_token %>'
 
   # The API endpoint for Github. Unless you are hosting a private
   # instance of Enterprise Github you do not need to include this
   config.endpoint              = '<%= @endpoint %>'
 
+  # The Web URL for Github. Unless you are hosting a private
+  # instance of Enterprise Github you do not need to include this
+  config.web_url               = '<%= @web_url %>'
+
   # The organization or user that owns the target repository
   config.owner                 = '<%= @owner %>'
 

data/lib/party_foul/exception_handler.rb

@@ -1,13 +1,18 @@
 class PartyFoul::ExceptionHandler
-  attr_accessor :exception, :env
+  attr_accessor :rendered_issue
 
   def self.handle(exception, env)
-    PartyFoul.adapter.handle(exception, env)
+    PartyFoul.processor.handle(exception, env)
   end
 
   def initialize(exception, env)
-    self.exception = exception
-    self.env       = env
+    renderer_klass = if defined?(Rails)
+                       PartyFoul::RailsIssueRenderer
+                     else
+                       PartyFoul::RackIssueRenderer
+                     end
+
+    self.rendered_issue = renderer_klass.new(exception, env)
   end
 
   def run
@@ -26,121 +31,27 @@ class PartyFoul::ExceptionHandler
     issue
   end
 
-  def stack_trace
-    exception.backtrace.map do |line|
-      if matches = extract_file_name_and_line_number(line)
-        "<a href='../tree/master/#{matches[2]}#L#{matches[3]}'>#{line}</a>"
-      else
-        line
-      end
-    end.join("\n")
-  end
-
   def create_issue
-    issue = PartyFoul.github.issues.create(PartyFoul.owner, PartyFoul.repo, title: issue_title, body: issue_body, labels: ['bug'])
-    PartyFoul.github.issues.comments.create(PartyFoul.owner, PartyFoul.repo, issue['number'], body: comment_body)
+    issue = PartyFoul.github.issues.create(PartyFoul.owner, PartyFoul.repo, title: rendered_issue.title, body: rendered_issue.body, labels: ['bug'])
+    PartyFoul.github.issues.comments.create(PartyFoul.owner, PartyFoul.repo, issue['number'], body: rendered_issue.comment)
   end
 
   def update_issue(issue)
     unless issue.key?('labels') && issue['labels'].include?('wontfix')
-      params = {body: update_body(issue['body']), state: 'open'}
+      params = {body: rendered_issue.update_body(issue['body']), state: 'open'}
 
       if issue['state'] == 'closed'
         params[:labels] = ['bug', 'regression']
       end
 
       PartyFoul.github.issues.edit(PartyFoul.owner, PartyFoul.repo, issue['number'], params)
-      PartyFoul.github.issues.comments.create(PartyFoul.owner, PartyFoul.repo, issue['number'], body: comment_body)
-    end
-  end
-
-  def issue_title
-    line = exception.backtrace.select {|p| p =~ /#{app_root}/ }.first
-    name_and_number = extract_file_name_and_line_number(line)[1]
-    "#{exception} - #{name_and_number}"
-  end
-
-  def fingerprint
-    Digest::SHA1.hexdigest(issue_title)
-  end
-
-  def update_body(body)
-    begin
-      current_count = body.match(/<th>Count<\/th><td>(\d+)<\/td>/)[1].to_i
-      body.sub!("<th>Count</th><td>#{current_count}</td>", "<th>Count</th><td>#{current_count + 1}</td>")
-      body.sub!(/<th>Last Occurance<\/th><td>.+<\/td>/, "<th>Last Occurance</th><td>#{occurred_at}</td>")
-      body
-    rescue
-      issue_body
-    end
-  end
-
-  def params
-    if env["action_dispatch.parameter_filter"]
-      parameter_filter = ActionDispatch::Http::ParameterFilter.new(env["action_dispatch.parameter_filter"])
-      parameter_filter.filter(env['action_dispatch.request.path_parameters'])
-    else
-      env['QUERY_STRING']
-    end
-  end
-
-  def issue_body
-    compile_template(PartyFoul.issue_template)
-  end
-
-  def comment_body
-    compile_template(PartyFoul.comment_template)
-  end
-
-  def compile_template(template)
-    template.gsub(/:\w+/) do |method|
-      value = self.send(method.split(':').last)
-      if value.kind_of?(Hash)
-        hash_as_table(value)
-      else
-        value
-      end
-    end
-  end
-
-  def hash_as_table(value)
-    "<table>#{value.map {|key, value| "<tr><th>#{key}</th><td>#{value}</td></tr>"}.join}</table>"
-  end
-
-  def occurred_at
-    Time.now.strftime('%B %d, %Y %H:%M:%S %z')
-  end
-
-  def ip_address
-    env['REMOTE_ADDR']
-  end
-
-  def session
-    env['rack.session']
-  end
-
-  def http_headers
-    env.keys.select { |key| key =~ /^HTTP_(\w+)/ && !(PartyFoul.filtered_http_headers || []).include?($1.split('_').map(&:capitalize).join('-')) }.sort.inject({}) do |hash, key|
-      hash[key.split('HTTP_').last.split('_').map(&:capitalize).join('-')] = env[key]
-      hash
+      PartyFoul.github.issues.comments.create(PartyFoul.owner, PartyFoul.repo, issue['number'], body: rendered_issue.comment)
     end
   end
 
   private
 
-  def app_root
-    if defined?(Rails)
-      Rails.root
-    else
-      Dir.pwd
-    end
-  end
-
-  def file_and_line_regex
-    /#{app_root}\/((.+?):(\d+))/
-  end
-
-  def extract_file_name_and_line_number(backtrace_line)
-    backtrace_line.match(file_and_line_regex)
+  def fingerprint
+    rendered_issue.fingerprint
   end
 end

data/lib/party_foul/issue_renderer.rb

@@ -0,0 +1,96 @@
+class PartyFoul::IssueRenderer
+  attr_accessor :exception, :env
+
+  def initialize(exception, env)
+    self.exception = exception
+    self.env       = env
+  end
+
+  def title
+    raise NotImplementedError
+  end
+
+  def body
+    compile_template(PartyFoul.issue_template)
+  end
+
+  def comment
+    compile_template(PartyFoul.comment_template)
+  end
+
+  def stack_trace
+    exception.backtrace.map do |line|
+      if matches = extract_file_name_and_line_number(line)
+        "<a href='#{PartyFoul.repo_url}/tree/master/#{matches[2]}#L#{matches[3]}'>#{line}</a>"
+      else
+        line
+      end
+    end.join("\n")
+  end
+
+  def fingerprint
+    Digest::SHA1.hexdigest(title)
+  end
+
+  def update_body(old_body)
+    begin
+      current_count = old_body.match(/<th>Count<\/th><td>(\d+)<\/td>/)[1].to_i
+      old_body.sub!("<th>Count</th><td>#{current_count}</td>", "<th>Count</th><td>#{current_count + 1}</td>")
+      old_body.sub!(/<th>Last Occurance<\/th><td>.+<\/td>/, "<th>Last Occurance</th><td>#{occurred_at}</td>")
+      old_body
+    rescue
+      self.body
+    end
+  end
+
+  def params
+    raise NotImplementedError
+  end
+
+  def occurred_at
+    Time.now.strftime('%B %d, %Y %H:%M:%S %z')
+  end
+
+  def ip_address
+    env['REMOTE_ADDR']
+  end
+
+  def session
+    env['rack.session']
+  end
+
+  def http_headers
+    env.keys.select { |key| key =~ /^HTTP_(\w+)/ && !(PartyFoul.filtered_http_headers || []).include?($1.split('_').map(&:capitalize).join('-')) }.sort.inject({}) do |hash, key|
+      hash[key.split('HTTP_').last.split('_').map(&:capitalize).join('-')] = env[key]
+      hash
+    end
+  end
+
+  def compile_template(template)
+    template.gsub(/:\w+/) do |method|
+      value = self.send(method.split(':').last)
+      if value.kind_of?(Hash)
+        hash_as_table(value)
+      else
+        value
+      end
+    end
+  end
+
+  private
+
+  def hash_as_table(value)
+    "<table>#{value.map {|key, value| "<tr><th>#{key}</th><td>#{value}</td></tr>"}.join}</table>"
+  end
+
+  def app_root
+    Dir.pwd
+  end
+
+  def extract_file_name_and_line_number(backtrace_line)
+    backtrace_line.match(/#{app_root}\/((.+?):(\d+))/)
+  end
+end
+
+require 'party_foul/issue_renderers/rack'
+require 'party_foul/issue_renderers/rails'

data/lib/party_foul/issue_renderers/rack.rb

@@ -0,0 +1,13 @@
+require 'party_foul/issue_renderer'
+
+module PartyFoul
+  class RackIssueRenderer < IssueRenderer
+    def params
+      env['QUERY_STRING']
+    end
+
+    def title
+      %{(#{exception.class}) "#{exception.message}"}
+    end
+  end
+end

data/lib/party_foul/issue_renderers/rails.rb

@@ -0,0 +1,20 @@
+require 'party_foul/issue_renderer'
+
+module PartyFoul
+  class RailsIssueRenderer < IssueRenderer
+    def params
+      parameter_filter = ActionDispatch::Http::ParameterFilter.new(env["action_dispatch.parameter_filter"])
+      parameter_filter.filter(env['action_dispatch.request.path_parameters'])
+    end
+
+    def title
+      %{#{env['action_controller.instance'].class}##{env['action_dispatch.request.path_parameters']['action']} (#{exception.class}) "#{exception.message}"}
+    end
+
+    private
+
+    def app_root
+      Rails.root
+    end
+  end
+end

data/lib/party_foul/{sync_adapter.rb → processors/sync.rb}

@@ -1,4 +1,4 @@
-class PartyFoul::SyncAdapter
+class PartyFoul::Processors::Sync
   def self.handle(exception, env)
     PartyFoul::ExceptionHandler.new(exception, env).run
   end

data/lib/party_foul/processors.rb

@@ -0,0 +1,4 @@
+module PartyFoul::Processors
+end
+
+require 'party_foul/processors/sync'

data/lib/party_foul/version.rb

@@ -1,3 +1,3 @@
 module PartyFoul
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/party_foul.rb

@@ -2,7 +2,13 @@ require 'github_api'
 
 module PartyFoul
   class << self
-    attr_accessor :github, :oauth_token, :endpoint, :owner, :repo, :ignored_exceptions, :adapter, :issue_template, :comment_template, :filtered_http_headers
+    attr_accessor :github, :oauth_token, :endpoint, :owner, :repo,
+      :ignored_exceptions, :processor, :issue_template,
+      :comment_template, :filtered_http_headers, :web_url
+  end
+
+  def self.web_url
+    @web_url ||= 'https://github.com'
   end
 
   def self.issue_template
@@ -37,9 +43,13 @@ Fingerprint: `:fingerprint`
     @ignored_exceptions || []
   end
 
+  def self.repo_url
+    "#{web_url}/#{owner}/#{repo}"
+  end
+
   def self.configure(&block)
     yield self
-    self.adapter ||= SyncAdapter
+    self.processor ||= PartyFoul::Processors::Sync
     _self = self
     self.github ||= Github.new do |config|
       %w{endpoint oauth_token}.each do |option|
@@ -50,5 +60,6 @@ Fingerprint: `:fingerprint`
 end
 
 require 'party_foul/exception_handler'
+require 'party_foul/issue_renderer'
 require 'party_foul/middleware'
-require 'party_foul/sync_adapter'
+require 'party_foul/processors'

data/test/generator_test.rb

@@ -6,20 +6,23 @@ class PartyFoul::GeneratorTest < Rails::Generators::TestCase
   destination File.expand_path('../tmp', __FILE__)
   tests PartyFoul::InstallGenerator
   test 'it copies the initializer' do
+    owner = 'test_owner'
+    repo  = 'test_repo'
     oauth = mock('Oauth')
     oauth.stubs(:create)
-    oauth.expects(:create).with('scopes' => ['repo']).returns(Hashie::Mash.new(token: 'test_token'))
+    oauth.expects(:create).with(scopes: ['repo'], note: 'PartyFoul test_owner/test_repo', note_url: 'http://example.com/test_owner/test_repo').returns(Hashie::Mash.new(token: 'test_token'))
     github = mock('Github')
     github.stubs(:oauth).returns(oauth)
-    Github.stubs(:new).with(:login => 'test_login', :password => 'test_password', :endpoint => 'test_endpoint').returns(github)
-    $stdin.stubs(:gets).returns('test_login').then.returns('test_password').then.returns('').then.returns('test_repo').then.returns("test_endpoint").then.returns('')
+    Github.stubs(:new).with(:login => 'test_login', :password => 'test_password', :endpoint => 'http://api.example.com').returns(github)
+    $stdin.stubs(:gets).returns('test_login').then.returns('test_password').then.returns(owner).then.returns(repo).then.returns('http://api.example.com').then.returns('http://example.com').then.returns('')
     run_generator
 
     assert_file 'config/initializers/party_foul.rb' do |initializer|
-      assert_match(/config.endpoint\s+=\s'test_endpoint'/, initializer)
-      assert_match(/config.owner\s+=\s'test_login'/, initializer)
-      assert_match(/config.repo\s+=\s'test_repo'/, initializer)
-      assert_match(/config.oauth_token\s+=\s'test_token'/, initializer)
+      assert_match(/config\.endpoint\s+=\s'http:\/\/api\.example\.com'/, initializer)
+      assert_match(/config\.web_url\s+=\s'http:\/\/example\.com'/, initializer)
+      assert_match(/config\.owner\s+=\s'test_owner'/, initializer)
+      assert_match(/config\.repo\s+=\s'test_repo'/, initializer)
+      assert_match(/config\.oauth_token\s+=\s'test_token'/, initializer)
     end
   end
 end

data/test/party_foul/configure_test.rb

@@ -10,7 +10,8 @@ describe 'Party Foul Confg' do
     PartyFoul.configure do |config|
       config.ignored_exceptions = ['StandardError']
       config.oauth_token        = 'test_token'
-      config.endpoint           = 'test_endpoint'
+      config.web_url            = 'http://example.com'
+      config.endpoint           = 'http://api.example.com'
       config.owner              = 'test_owner'
       config.repo               = 'test_repo'
     end
@@ -18,8 +19,9 @@ describe 'Party Foul Confg' do
     PartyFoul.ignored_exceptions.must_equal ['StandardError']
     PartyFoul.github.must_be_instance_of Github::Client
     PartyFoul.github.oauth_token.must_equal 'test_token'
-    PartyFoul.github.endpoint.must_equal 'test_endpoint'
+    PartyFoul.github.endpoint.must_equal 'http://api.example.com'
     PartyFoul.owner.must_equal 'test_owner'
     PartyFoul.repo.must_equal 'test_repo'
+    PartyFoul.repo_url.must_equal 'http://example.com/test_owner/test_repo'
   end
 end

data/test/party_foul/exception_handler_test.rb

@@ -1,161 +1,70 @@
 require 'test_helper'
-require 'active_support/core_ext/object/blank'
-require 'action_dispatch/http/parameter_filter'
 
 describe 'Party Foul Exception Handler' do
   before do
-    Time.stubs(:now).returns(Time.new(1970, 1, 1, 0, 0, 0, '-05:00'))
-  end
-
-  after do
-    clean_up_party
-  end
-
-  describe '#body' do
-    describe 'updating issue body' do
-      before do
-        @handler = PartyFoul::ExceptionHandler.new(nil, nil)
-        @handler.stubs(:exception).returns('Test Exception')
-        @handler.stubs(:fingerprint).returns('abcdefg1234567890')
-        @handler.stubs(:stack_trace)
-      end
-
-      it 'updates count and timestamp' do
-        body = <<-BODY
-<table>
-<tr><th>Exception</th><td>Test Exception</td></tr>
-<tr><th>Count</th><td>1</td></tr>
-<tr><th>Last Occurance</th><td>January 01, 1970 00:00:00 -0500</td></tr>
-</table>
-
-## Stack Trace
-<pre></pre>
-Fingerprint: `abcdefg1234567890`
-    BODY
-
-        Time.stubs(:now).returns(Time.new(1985, 10, 25, 1, 22, 0, '-05:00'))
-
-        expected_body = <<-BODY
-<table>
-<tr><th>Exception</th><td>Test Exception</td></tr>
-<tr><th>Count</th><td>2</td></tr>
-<tr><th>Last Occurance</th><td>October 25, 1985 01:22:00 -0500</td></tr>
-</table>
-
-## Stack Trace
-<pre></pre>
-Fingerprint: `abcdefg1234567890`
-    BODY
-
-        @handler.update_body(body).must_equal expected_body
-      end
+    PartyFoul.configure do |config|
+      config.oauth_token = 'abcdefg1234567890'
+      config.owner       = 'test_owner'
+      config.repo        = 'test_repo'
     end
 
-    describe 'empty body' do
-      before do
-        @handler = PartyFoul::ExceptionHandler.new(nil, nil)
-        @handler.stubs(:exception).returns('Test Exception')
-        @handler.stubs(:fingerprint).returns('abcdefg1234567890')
-        @handler.stubs(:stack_trace)
-      end
-
-      it 'resets body' do
-        expected_body = <<-BODY
-<table>
-<tr><th>Exception</th><td>Test Exception</td></tr>
-<tr><th>Count</th><td>1</td></tr>
-<tr><th>Last Occurance</th><td>January 01, 1970 00:00:00 -0500</td></tr>
-</table>
-
-## Stack Trace
-<pre></pre>
-Fingerprint: `abcdefg1234567890`
-    BODY
-        @handler.update_body(nil).must_equal expected_body
-      end
-    end
+    PartyFoul.github.stubs(:issues).returns(mock('Issues'))
+    PartyFoul.github.stubs(:search).returns(mock('Search'))
+    PartyFoul.github.issues.stubs(:create)
+    PartyFoul.github.issues.stubs(:edit)
+    PartyFoul.github.issues.stubs(:comments).returns(mock('Comments'))
+    PartyFoul.github.issues.comments.stubs(:create)
+    PartyFoul::RailsIssueRenderer.any_instance.stubs(:title).returns('Test Title')
+    PartyFoul::RailsIssueRenderer.any_instance.stubs(:fingerprint).returns('test_fingerprint')
   end
 
-  describe '#params' do
-    context 'with Rails' do
-      before do
-        @handler = PartyFoul::ExceptionHandler.new(nil, {'action_dispatch.parameter_filter' => ['password'], 'action_dispatch.request.path_parameters' => { 'status' => 'ok', 'password' => 'test' }, 'QUERY_STRING' => { 'status' => 'fail' } })
-      end
-
-      it 'returns ok' do
-        @handler.params['status'].must_equal 'ok'
-        @handler.params['password'].must_equal '[FILTERED]'
-      end
-    end
-
-    context 'without Rails' do
-      before do
-        @handler = PartyFoul::ExceptionHandler.new(nil, {'QUERY_STRING' => { 'status' => 'ok' } })
-      end
-
-      it 'returns ok' do
-        @handler.params['status'].must_equal 'ok'
-      end
+  context 'when error is new' do
+    it 'will open a new error on Github' do
+      PartyFoul::RailsIssueRenderer.any_instance.stubs(:body).returns('Test Body')
+      PartyFoul::RailsIssueRenderer.any_instance.stubs(:comment).returns('Test Comment')
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: []))
+      PartyFoul.github.issues.expects(:create).with('test_owner', 'test_repo', title: 'Test Title', body: 'Test Body', :labels => ['bug']).returns(Hashie::Mash.new('number' => 1))
+      PartyFoul.github.issues.comments.expects(:create).with('test_owner', 'test_repo', 1, body: 'Test Comment')
+      PartyFoul::ExceptionHandler.new(nil, {}).run
     end
   end
 
-  describe '#issue_comment' do
+  context 'when error is not new' do
     before do
-      env = {
-        'REQUEST_URI' => 'http://example.com/',
-        'HTTP_USER_AGENT' => 'test_user_agent',
-        'REMOTE_ADDR' => '127.0.0.1',
-        'HTTP_HOST' => 'localhost:3000',
-        'QUERY_STRING' => { :controller => 'landing', :action => 'index' },
-        'rack.session' => { :id => 1 }
-      }
-      @handler = PartyFoul::ExceptionHandler.new(nil, env)
+      PartyFoul::RailsIssueRenderer.any_instance.stubs(:update_body).returns('New Body')
+      PartyFoul::RailsIssueRenderer.any_instance.stubs(:comment).returns('Test Comment')
     end
 
-    it 'renders a new comment' do
-      expected_comment = <<-COMMENT
-<table>
-<tr><th>Occurred at</th><td>January 01, 1970 00:00:00 -0500</td></tr>
-<tr><th>Params</th><td><table><tr><th>controller</th><td>landing</td></tr><tr><th>action</th><td>index</td></tr></table></td></tr>
-<tr><th>IP Address</th><td>127.0.0.1</td></tr>
-<tr><th>Session</th><td><table><tr><th>id</th><td>1</td></tr></table></td></tr>
-<tr><th>HTTP Headers</th><td><table><tr><th>Host</th><td>localhost:3000</td></tr><tr><th>User-Agent</th><td>test_user_agent</td></tr></table></td></tr>
-</table>
-COMMENT
-
-      @handler.comment_body.must_equal expected_comment
-    end
-  end
-
-  describe '#compile_template' do
-    it 'it parses the tags and inserts proper data' do
-      template = '<span>:data1</span><div>:data2</div>'
-      @handler = PartyFoul::ExceptionHandler.new(nil, nil)
-      @handler.stubs(:data1).returns('123')
-      @handler.stubs(:data2).returns('abc')
-      @handler.compile_template(template).must_equal '<span>123</span><div>abc</div>'
-    end
-  end
-
-  describe '#http_headers' do
-    before do
-      PartyFoul.filtered_http_headers = ['Cookie']
-      env = {
-        'HTTP_USER_AGENT' => 'test_user_agent',
-        'HTTP_COOKIE' => 'test_cookie',
-      }
-      @handler = PartyFoul::ExceptionHandler.new(nil, env)
+    context 'and open' do
+      it 'will update the issue' do
+        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'open', number: 1}]))
+        PartyFoul.github.issues.expects(:edit).with('test_owner', 'test_repo', 1, body: 'New Body', state: 'open')
+        PartyFoul.github.issues.comments.expects(:create).with('test_owner', 'test_repo', 1, body: 'Test Comment')
+        PartyFoul::ExceptionHandler.new(nil, {}).run
+      end
     end
 
-    it 'ignored Cookie' do
-      @handler.http_headers.must_equal('User-Agent' => 'test_user_agent')
+    context 'and closed' do
+      it 'will update the count on the body and re-open the issue' do
+        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
+        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'closed', number: 1}]))
+        PartyFoul.github.issues.expects(:edit).with('test_owner', 'test_repo', 1, body: 'New Body', state: 'open', labels: ['bug', 'regression'])
+        PartyFoul.github.issues.comments.expects(:create).with('test_owner', 'test_repo', 1, body: 'Test Comment')
+        PartyFoul::ExceptionHandler.new(nil, {}).run
+      end
     end
   end
 
-  describe '#hash_as_table' do
-    it 'renders as an HTML table' do
-      expected = '<table><tr><th>Value 1</th><td>A</td></tr><tr><th>Value B</th><td>2</td></tr></table>'
-      PartyFoul::ExceptionHandler.new(nil, nil).hash_as_table('Value 1' => 'A', 'Value B' => 2).must_equal expected
+  context 'when issue is marked as "wontfix"' do
+    it 'does nothing' do
+      PartyFoul::RailsIssueRenderer.any_instance.stubs(:body).returns('Test Body')
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'closed', number: 1, 'labels' => ['wontfix']}]))
+      PartyFoul.github.issues.expects(:create).never
+      PartyFoul.github.issues.expects(:edit).never
+      PartyFoul.github.issues.comments.expects(:create).never
+      PartyFoul::ExceptionHandler.new(nil, {}).run
     end
   end
 end

data/test/party_foul/issue_renderer_test.rb

@@ -0,0 +1,139 @@
+require 'test_helper'
+require 'active_support/core_ext/object/blank'
+require 'action_dispatch/http/parameter_filter'
+
+describe 'Party Foul Issue Renderer' do
+  before do
+    Time.stubs(:now).returns(Time.new(1970, 1, 1, 0, 0, 0, '-05:00'))
+  end
+
+  after do
+    clean_up_party
+  end
+
+  describe '#body' do
+    describe 'updating issue body' do
+      before do
+        @rendered_issue = PartyFoul::IssueRenderer.new(nil, nil)
+        @rendered_issue.stubs(:exception).returns('Test Exception')
+        @rendered_issue.stubs(:fingerprint).returns('abcdefg1234567890')
+        @rendered_issue.stubs(:stack_trace)
+      end
+
+      it 'updates count and timestamp' do
+        body = <<-BODY
+<table>
+<tr><th>Exception</th><td>Test Exception</td></tr>
+<tr><th>Count</th><td>1</td></tr>
+<tr><th>Last Occurance</th><td>January 01, 1970 00:00:00 -0500</td></tr>
+</table>
+
+## Stack Trace
+<pre></pre>
+Fingerprint: `abcdefg1234567890`
+    BODY
+
+        Time.stubs(:now).returns(Time.new(1985, 10, 25, 1, 22, 0, '-05:00'))
+
+        expected_body = <<-BODY
+<table>
+<tr><th>Exception</th><td>Test Exception</td></tr>
+<tr><th>Count</th><td>2</td></tr>
+<tr><th>Last Occurance</th><td>October 25, 1985 01:22:00 -0500</td></tr>
+</table>
+
+## Stack Trace
+<pre></pre>
+Fingerprint: `abcdefg1234567890`
+    BODY
+
+        @rendered_issue.update_body(body).must_equal expected_body
+      end
+    end
+
+    describe 'empty body' do
+      before do
+        @rendered_issue = PartyFoul::IssueRenderer.new(nil, nil)
+        @rendered_issue.stubs(:exception).returns('Test Exception')
+        @rendered_issue.stubs(:fingerprint).returns('abcdefg1234567890')
+        @rendered_issue.stubs(:stack_trace)
+      end
+
+      it 'resets body' do
+        expected_body = <<-BODY
+<table>
+<tr><th>Exception</th><td>Test Exception</td></tr>
+<tr><th>Count</th><td>1</td></tr>
+<tr><th>Last Occurance</th><td>January 01, 1970 00:00:00 -0500</td></tr>
+</table>
+
+## Stack Trace
+<pre></pre>
+Fingerprint: `abcdefg1234567890`
+    BODY
+        @rendered_issue.update_body(nil).must_equal expected_body
+      end
+    end
+  end
+
+  describe '#issue_comment' do
+    before do
+      env = {
+        'REQUEST_URI' => 'http://example.com/',
+        'HTTP_USER_AGENT' => 'test_user_agent',
+        'REMOTE_ADDR' => '127.0.0.1',
+        'HTTP_HOST' => 'localhost:3000',
+        'rack.session' => { :id => 1 }
+      }
+      @rendered_issue = PartyFoul::IssueRenderer.new(nil, env)
+      @rendered_issue.stubs(:params).returns({})
+    end
+
+    it 'renders a new comment' do
+      expected_comment = <<-COMMENT
+<table>
+<tr><th>Occurred at</th><td>January 01, 1970 00:00:00 -0500</td></tr>
+<tr><th>Params</th><td><table></table></td></tr>
+<tr><th>IP Address</th><td>127.0.0.1</td></tr>
+<tr><th>Session</th><td><table><tr><th>id</th><td>1</td></tr></table></td></tr>
+<tr><th>HTTP Headers</th><td><table><tr><th>Host</th><td>localhost:3000</td></tr><tr><th>User-Agent</th><td>test_user_agent</td></tr></table></td></tr>
+</table>
+COMMENT
+
+      @rendered_issue.comment.must_equal expected_comment
+    end
+  end
+
+  describe '#compile_template' do
+    it 'it parses the tags and inserts proper data' do
+      template = '<span>:data1</span><div>:data2</div>'
+      @rendered_issue = PartyFoul::IssueRenderer.new(nil, nil)
+      @rendered_issue.stubs(:data1).returns('123')
+      @rendered_issue.stubs(:data2).returns('abc')
+      @rendered_issue.compile_template(template).must_equal '<span>123</span><div>abc</div>'
+    end
+  end
+
+  describe '#http_headers' do
+    before do
+      PartyFoul.filtered_http_headers = ['Cookie']
+      env = {
+        'HTTP_USER_AGENT' => 'test_user_agent',
+        'HTTP_COOKIE' => 'test_cookie',
+      }
+      @rendered_issue = PartyFoul::IssueRenderer.new(nil, env)
+    end
+
+    it 'ignored Cookie' do
+      @rendered_issue.http_headers.must_equal('User-Agent' => 'test_user_agent')
+    end
+  end
+
+  describe '#fingerprint' do
+    it 'SHA1s the title' do
+      rendered_issue = PartyFoul::IssueRenderer.new(nil, nil)
+      rendered_issue.stubs(:title).returns('abcdefg1234567890')
+      rendered_issue.fingerprint.must_equal Digest::SHA1.hexdigest(rendered_issue.title)
+    end
+  end
+end

data/test/party_foul/issue_renderers/rack_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+describe 'Rack Issue Renderer' do
+  describe '#params' do
+    before do
+      @rendered_issue = PartyFoul::RackIssueRenderer.new(nil, {'QUERY_STRING' => { 'status' => 'ok' } })
+    end
+
+    it 'returns ok' do
+      @rendered_issue.params['status'].must_equal 'ok'
+    end
+  end
+
+  describe '#title' do
+    before do
+      @exception = Exception.new('message')
+    end
+
+    it 'constructs the title with the class and instance method' do
+      @rendered_issue = PartyFoul::RackIssueRenderer.new(@exception, {})
+      @rendered_issue.title.must_equal %{(Exception) "message"}
+    end
+  end
+end

data/test/party_foul/issue_renderers/rails_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+describe 'Rails Issue Renderer' do
+  describe '#params' do
+    before do
+      @rendered_issue = PartyFoul::RailsIssueRenderer.new(nil, {'action_dispatch.parameter_filter' => ['password'], 'action_dispatch.request.path_parameters' => { 'status' => 'ok', 'password' => 'test' }, 'QUERY_STRING' => { 'status' => 'fail' } })
+    end
+
+    it 'returns ok' do
+      @rendered_issue.params['status'].must_equal 'ok'
+      @rendered_issue.params['password'].must_equal '[FILTERED]'
+    end
+  end
+
+  describe '#title' do
+    before do
+      @exception = Exception.new('message')
+      controller_instance = mock('Controller')
+      controller_instance.stubs(:class).returns('LandingController')
+      env = {
+        'action_dispatch.request.path_parameters' => { 'controller' => 'landing', 'action' => 'index' },
+        'action_controller.instance' => controller_instance
+      }
+      @rendered_issue = PartyFoul::RailsIssueRenderer.new(@exception, env)
+    end
+
+    it 'constructs the title with the controller and action' do
+      @rendered_issue.title.must_equal %{LandingController#index (Exception) "message"}
+    end
+  end
+end

data/test/party_foul/middleware_test.rb

@@ -21,74 +21,10 @@ describe 'Party Foul Middleware' do
     }
   end
 
-  before do
-    PartyFoul.configure do |config|
-      config.oauth_token = 'abcdefg1234567890'
-      config.owner       = 'test_owner'
-      config.repo        = 'test_repo'
-    end
-    PartyFoul.github.stubs(:issues).returns(mock('Issues'))
-    PartyFoul.github.stubs(:search).returns(mock('Search'))
-    PartyFoul.github.issues.stubs(:create)
-    PartyFoul.github.issues.stubs(:edit)
-    PartyFoul.github.issues.stubs(:comments).returns(mock('Comments'))
-    PartyFoul.github.issues.comments.stubs(:create)
-    PartyFoul::ExceptionHandler.any_instance.stubs(:issue_title).returns('Test Title')
-    PartyFoul::ExceptionHandler.any_instance.stubs(:fingerprint).returns('test_fingerprint')
-  end
-
-  context 'when error is new' do
-    it 'will open a new error on Github' do
-      PartyFoul::ExceptionHandler.any_instance.stubs(:issue_body).returns('Test Body')
-      PartyFoul::ExceptionHandler.any_instance.stubs(:comment_body).returns('Test Comment')
-      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
-      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: []))
-      PartyFoul.github.issues.expects(:create).with('test_owner', 'test_repo', title: 'Test Title', body: 'Test Body', :labels => ['bug']).returns(Hashie::Mash.new('number' => 1))
-      PartyFoul.github.issues.comments.expects(:create).with('test_owner', 'test_repo', 1, body: 'Test Comment')
-      lambda {
-        get '/'
-      }.must_raise(Exception)
-    end
-  end
-
-  context 'when error is not new' do
-    before do
-      PartyFoul::ExceptionHandler.any_instance.stubs(:update_body).returns('New Body')
-      PartyFoul::ExceptionHandler.any_instance.stubs(:comment_body).returns('Test Comment')
-    end
-
-    context 'and open' do
-      it 'will update the issue' do
-        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'open', number: 1}]))
-        PartyFoul.github.issues.expects(:edit).with('test_owner', 'test_repo', 1, body: 'New Body', state: 'open')
-        PartyFoul.github.issues.comments.expects(:create).with('test_owner', 'test_repo', 1, body: 'Test Comment')
-        lambda {
-          get '/'
-        }.must_raise(Exception)
-      end
-    end
-
-    context 'and closed' do
-      it 'will update the count on the body and re-open the issue' do
-        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
-        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'closed', number: 1}]))
-        PartyFoul.github.issues.expects(:edit).with('test_owner', 'test_repo', 1, body: 'New Body', state: 'open', labels: ['bug', 'regression'])
-        PartyFoul.github.issues.comments.expects(:create).with('test_owner', 'test_repo', 1, body: 'Test Comment')
-        lambda {
-          get '/'
-        }.must_raise(Exception)
-      end
-    end
-  end
-
-  context 'when issue is marked as "wontfix"' do
-    it 'does nothing' do
-      PartyFoul::ExceptionHandler.any_instance.stubs(:issue_body).returns('Test Body')
-      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
-      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'closed', number: 1, 'labels' => ['wontfix']}]))
-      PartyFoul.github.issues.expects(:create).never
-      PartyFoul.github.issues.expects(:edit).never
-      PartyFoul.github.issues.comments.expects(:create).never
+  context 'handling an exception' do
+    it 'does not handle exception' do
+      PartyFoul::ExceptionHandler.stubs(:handle)
+      PartyFoul::ExceptionHandler.expects(:handle)
       lambda {
         get '/'
       }.must_raise(Exception)
@@ -102,11 +38,8 @@ describe 'Party Foul Middleware' do
     end
 
     it 'does not handle exception' do
-      PartyFoul::ExceptionHandler.any_instance.stubs(:issue_body).returns('Test Body')
-      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
-      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: []))
-      PartyFoul.github.issues.expects(:create).never
-      PartyFoul.github.issues.comments.expects(:create).never
+      PartyFoul::ExceptionHandler.stubs(:handle)
+      PartyFoul::ExceptionHandler.expects(:handle).never
       lambda {
         get '/'
       }.must_raise(StandardError)

data/test/test_helper.rb

@@ -21,7 +21,7 @@ module MiniTest::Expectations
 end
 
 def clean_up_party
-  %w{github oauth_token endpoint owner repo ignored_exceptions adapter issue_template comment_template filtered_http_headers}.each do |attr|
+  %w{github oauth_token endpoint owner repo ignored_exceptions processor issue_template comment_template filtered_http_headers web_url}.each do |attr|
     PartyFoul.send("#{attr}=", nil)
   end
 end

data/test/tmp/config/initializers/party_foul.rb

@@ -6,15 +6,19 @@ PartyFoul.configure do |config|
   # The names of the HTTP headers to not report
   config.filtered_http_headers = ['Cookie']
 
-  # The OAuth token for the account that will be opening the issues on Github
+  # The OAuth token for the account that is opening the issues on Github
   config.oauth_token           = 'test_token'
 
   # The API endpoint for Github. Unless you are hosting a private
   # instance of Enterprise Github you do not need to include this
-  config.endpoint              = 'test_endpoint'
+  config.endpoint              = 'http://api.example.com'
+
+  # The Web URL for Github. Unless you are hosting a private
+  # instance of Enterprise Github you do not need to include this
+  config.web_url               = 'http://example.com'
 
   # The organization or user that owns the target repository
-  config.owner                 = 'test_login'
+  config.owner                 = 'test_owner'
 
   # The repository for this application
   config.repo                  = 'test_repo'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: party_foul
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-25 00:00:00.000000000 Z
+date: 2013-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: github_api
@@ -167,8 +167,12 @@ files:
 - lib/generators/party_foul/install_generator.rb
 - lib/generators/party_foul/templates/party_foul.rb
 - lib/party_foul/exception_handler.rb
+- lib/party_foul/issue_renderer.rb
+- lib/party_foul/issue_renderers/rack.rb
+- lib/party_foul/issue_renderers/rails.rb
 - lib/party_foul/middleware.rb
-- lib/party_foul/sync_adapter.rb
+- lib/party_foul/processors/sync.rb
+- lib/party_foul/processors.rb
 - lib/party_foul/version.rb
 - lib/party_foul.rb
 - Rakefile
@@ -176,6 +180,9 @@ files:
 - test/generator_test.rb
 - test/party_foul/configure_test.rb
 - test/party_foul/exception_handler_test.rb
+- test/party_foul/issue_renderer_test.rb
+- test/party_foul/issue_renderers/rack_test.rb
+- test/party_foul/issue_renderers/rails_test.rb
 - test/party_foul/middleware_test.rb
 - test/test_helper.rb
 - test/tmp/config/initializers/party_foul.rb
@@ -193,7 +200,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3070115477891214928
+      hash: -3123915090860232817
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -202,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3070115477891214928
+      hash: -3123915090860232817
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -213,6 +220,9 @@ test_files:
 - test/generator_test.rb
 - test/party_foul/configure_test.rb
 - test/party_foul/exception_handler_test.rb
+- test/party_foul/issue_renderer_test.rb
+- test/party_foul/issue_renderers/rack_test.rb
+- test/party_foul/issue_renderers/rails_test.rb
 - test/party_foul/middleware_test.rb
 - test/test_helper.rb
 - test/tmp/config/initializers/party_foul.rb