airbrake 4.3.8 → 5.0.0.rc.1

data/features/step_definitions/rake_steps.rb

@@ -1,22 +0,0 @@
-Given /I've prepared the Rakefile/ do
-  rakefile = File.join(PROJECT_ROOT, 'features', 'support', 'rake', 'Rakefile')
-  target = File.join(TEMP_DIR, 'Rakefile')
-  FileUtils.cp(rakefile, target)
-end
-
-When /I run rake with (.+)/ do |command|
-  command = "rake #{command.gsub(' ','_')}"
-  step %{I run `#{command}`}
-end
-
-Then "Airbrake should not catch the exception" do
-  step %{I should not see "[airbrake]"}
-end
-
-Then "Airbrake should catch the exception" do
-  step %{I should see "[airbrake]"}
-end
-
-Then /^command "(.*?)" should be reported$/ do |command_name|
-  step %{the output should contain "[airbrake] rake #{command_name}"}
-end

data/features/support/airbrake_shim.rb.template

@@ -1,11 +0,0 @@
-require 'sham_rack'
-
-ShamRack.at("api.airbrake.io") do |env|
-  response = <<-end_xml
-<notice>
-<id>b6817316-9c45-ed26-45eb-780dbb86aadb</id>
-<url>http://airbrake.io/locate/b6817316-9c45-ed26-45eb-780dbb86aadb</url>
-</notice>
-  end_xml
-  ["200 OK", { "Content-type" => "text/xml" }, [response]]
-end

data/features/support/aruba.rb

@@ -1,5 +0,0 @@
-Before do
-  @aruba_timeout_seconds = 30
-  @aruba_io_wait_seconds = 5
-  @dirs = ["tmp"]
-end

data/features/support/env.rb

@@ -1,39 +0,0 @@
-require 'active_support'
-require 'nokogiri'
-require 'rspec'
-require 'aruba/cucumber'
-require 'pry'
-
-PROJECT_ROOT          = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
-TEMP_DIR              = File.join(PROJECT_ROOT, 'tmp').freeze
-LOCAL_RAILS_ROOT      = File.join(TEMP_DIR, 'rails_root').freeze
-RACK_FILE             = File.join(TEMP_DIR, 'rack_app.rb').freeze
-LAST_NOTICE           = File.join(PROJECT_ROOT, 'resources', 'notice.xml')
-ORIGINAL_RACK_FILTERS = File.join(PROJECT_ROOT, 'lib', 'airbrake', 'utils', 'rack_filters.rb')
-
-Before do
-  FileUtils.rm_rf(LOCAL_RAILS_ROOT)
-
-  reload_rack_filters
-end
-
-When /^I reset Bundler environment variable$/ do
-  BUNDLE_ENV_VARS.each do |key|
-    ENV[key] = nil
-  end
-end
-
-def prepend_path(path)
-  ENV['PATH'] = path + ":" + ENV['PATH']
-end
-
-def reload_rack_filters
-  original_filters = File.read(ORIGINAL_RACK_FILTERS)
-
-  Dir.mkdir(TEMP_DIR) unless Dir.exist?(TEMP_DIR)
-
-  File.write(File.join(TEMP_DIR, "rack_filters.rb"), 
-             original_filters.lines.to_a[1..-2].join("\n"))
-
-  require File.join(TEMP_DIR, "rack_filters.rb")
-end

data/features/support/matchers.rb

@@ -1,35 +0,0 @@
-RSpec::Matchers.define :have_content do |xpath, content|
-  match do |document|
-    @elements = document.search(xpath)
-
-    if @elements.empty?
-      false
-    else
-      element_with_content = document.at("#{xpath}[contains(.,'#{content}')]")
-
-      if element_with_content.nil?
-        @found = @elements.collect { |element| element.content }
-
-        false
-      else
-        true
-      end
-    end
-  end
-
-  failure_message_for_should do |document|
-    if @elements.empty?
-      "In XML:\n#{document}\nNo element at #{xpath}"
-    else
-      "In XML:\n#{document}\nGot content #{@found.inspect} at #{xpath} instead of #{content.inspect}"
-    end
-  end
-
-  failure_message_for_should_not do |document|
-    unless @elements.empty?
-      "In XML:\n#{document}\nExpcted no content #{content.inspect} at #{xpath}"
-    end
-  end
-end
-
-World(RSpec::Matchers)

data/features/support/rails.rb

@@ -1,156 +0,0 @@
-BUNDLE_ENV_VARS = %w(RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE)
-ORIGINAL_BUNDLE_VARS = Hash[ENV.select{ |key,value| BUNDLE_ENV_VARS.include?(key) }]
-
-ENV['RAILS_ENV'] = 'test'
-
-Before do
-  ENV['BUNDLE_GEMFILE'] = File.join(Dir.pwd, ENV['BUNDLE_GEMFILE']) unless ENV['BUNDLE_GEMFILE'].start_with?(Dir.pwd)
-  @framework_version = nil
-end
-
-After do |s|
-  ORIGINAL_BUNDLE_VARS.each_pair do |key, value|
-    ENV[key] = value
-  end
-  Cucumber.wants_to_quit = true if s.failed?
-end
-
-module RailsHelpers
-  def rails_root_exists?
-    File.exists?(environment_path)
-  end
-
-  def application_controller_filename
-    controller_filename = File.join(rails_root, 'app', 'controllers', "application_controller.rb")
-  end
-
-  def rails_3_or_4?
-    rails_version =~ /\A[34]/
-  end
-
-  def rails_root
-    LOCAL_RAILS_ROOT
-  end
-
-  def rails_uses_rack?
-    rails_3_or_4? || rails_version =~ /^2\.3/
-  end
-
-  def rails_version
-    @rails_version ||= begin
-      if ENV["RAILS_VERSION"]
-        ENV["RAILS_VERSION"]
-      elsif bundler_manages_gems?
-        rails_version = open(gemfile_path).read.match(/gem.*rails["'].*["'](.+)["']/)[1]
-      else
-        environment_file = File.join(rails_root, 'config', 'environment.rb')
-        rails_version = `grep RAILS_GEM_VERSION #{environment_file}`.match(/[\d.]+/)[0]
-      end
-    end
-  end
-
-  def bundler_manages_gems?
-    File.exists?(gemfile_path)
-  end
-
-  def gemfile_path
-    gemfile = File.join(rails_root, 'Gemfile')
-  end
-
-  def rails_manages_gems?
-    rails_version =~ /\A2\.[123]/
-  end
-
-  def rails_supports_initializers?
-    rails_3_or_4? || rails_version =~ /\A2\./
-  end
-
-  def rails_finds_generators_in_gems?
-    rails_3_or_4? || rails_version =~ /\A2\./
-  end
-
-  def version_string
-    ENV['RAILS_VERSION'] || `tail -n 1 SUPPORTED_RAILS_VERSIONS` # use latest version if ENV["RAILS_VERSION"] is undefined
-  end
-
-  def environment_path
-    File.join(rails_root, 'config', 'environment.rb')
-  end
-
-  def rakefile_path
-    File.join(rails_root, 'Rakefile')
-  end
-
-  def config_gem(gem_name, version = nil)
-    run     = "Rails::Initializer.run do |config|"
-    insert  = "  config.gem '#{gem_name}'"
-    insert += ", :version => '#{version}'" if version
-    content = File.read(environment_path)
-    content = "require 'thread'\n#{content}"
-    if content.sub!(run, "#{run}\n#{insert}")
-      File.open(environment_path, 'wb') { |file| file.write(content) }
-    else
-      raise "Couldn't find #{run.inspect} in #{environment_path}"
-    end
-  end
-
-  def config_gem_dependencies
-    insert = <<-END
-    if Gem::VERSION >= "1.3.6"
-      module Rails
-        class GemDependency
-          def requirement
-            r = super
-            (r == Gem::Requirement.default) ? nil : r
-          end
-        end
-      end
-    end
-    END
-    run     = "Rails::Initializer.run do |config|"
-    content = File.read(environment_path)
-    if content.sub!(run, "#{insert}\n#{run}")
-      File.open(environment_path, 'wb') { |file| file.write(content) }
-    else
-      raise "Couldn't find #{run.inspect} in #{environment_path}"
-    end
-  end
-
-  def require_thread
-    content = File.read(rakefile_path)
-    content = "require 'thread'\n#{content}"
-    File.open(rakefile_path, 'wb') { |file| file.write(content) }
-  end
-
-  def perform_request(uri, environment = 'production')
-    request_script = <<-SCRIPT
-require File.expand_path('../config/environment', __FILE__)
-
-env      = Rack::MockRequest.env_for(#{uri.inspect})
-response = RailsRoot::Application.call(env)
-
-response = response.last if response.last.is_a?(ActionDispatch::Response)
-
-if response.is_a?(Array)
-  puts "Status: " + response.first.to_s
-  puts "Headers: " + response.second.to_s
-  if response.last.respond_to?(:each)
-    # making it work even with Rack::BodyProxy
-    body = ""
-    response.last.each do |chunk|
-      body << chunk
-    end
-    response.pop
-    response << body
-  end
-  puts "Body: " + response.last.to_s
-else
-  puts response.body
-end
-    SCRIPT
-    File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
-  end
-
-end
-
-World(RailsHelpers)

data/features/support/rake/Rakefile

@@ -1,77 +0,0 @@
-# A test harness for RakeHandler
-#
-require 'rake'
-require 'rubygems'
-require 'airbrake'
-require 'airbrake/rake_handler'
-
-class IgnoredException < StandardError; end
-
-Airbrake.configure do |c|
-  c.ignore_rake_only = ["IgnoredException"]
-end
-
-# Should catch exception
-task :airbrake do
-  Airbrake.configuration.rescue_rake_exceptions = true
-  stub_tty_output(true)
-  raise_exception 
-end
-
-# Should not catch exception
-task :airbrake_disabled do
-  Airbrake.configuration.rescue_rake_exceptions = false
-  stub_tty_output(true)
-  raise_exception 
-end
-
-# Should ignore the exception
-task :airbrake_ignored do
-  Airbrake.configuration.rescue_rake_exceptions = true
-  stub_tty_output(true)
-  raise_exception(IgnoredException)
-end
-
-# Should not catch exception as tty_output is true
-task :airbrake_autodetect_from_terminal do
-  Airbrake.configuration.rescue_rake_exceptions = nil
-  stub_tty_output(true) 
-  raise_exception 
-end
-
-# Should catch exception as tty_output is false
-task :airbrake_autodetect_not_from_terminal do
-  Airbrake.configuration.rescue_rake_exceptions = nil
-  stub_tty_output(false) 
-  raise_exception 
-end
-
-task :airbrake_not_yet_configured do
-  Airbrake.configuration.rescue_rake_exceptions = true
-  stub_tty_output(true)
-  stub_empty_sender
-  raise_exception
-end
-
-module Airbrake
-  def self.send_notice(notice)
-    $stderr.puts "[airbrake] #{notice.component}"
-  end
-end
-
-def stub_empty_sender
-  Airbrake.sender = nil
-end
-
-def stub_tty_output(value)
-  Rake.application.instance_eval do
-    @tty_output_stub = value
-    def tty_output?
-      @tty_output_stub
-    end
-  end
-end
-
-def raise_exception(exception_class = StandardError)
-  raise exception_class.new('TEST')
-end

data/features/user_informer.feature

@@ -1,57 +0,0 @@
-Feature: Inform the user of the airbrake notice that was just created
-
-  Background:
-    Given I successfully run `rails new rails_root -O --skip-gemfile`
-    And I cd to "rails_root"
-    And I configure the Airbrake shim
-
-  Scenario: Rescue an exception in a controller
-    When I run `rails generate airbrake -k myapikey`
-    And I define a response for "TestController#index":
-      """
-      raise RuntimeError, "some message"
-      """
-    And the response page for a "500" error is
-      """
-      <!-- AIRBRAKE ERROR -->
-      """
-    And I route "/test/index" to "test#index"
-    And I perform a request to "http://example.com:123/test/index?param=value" in the "production" environment
-    Then I should see "Airbrake Error b6817316-9c45-ed26-45eb-780dbb86aadb"
-
-  Scenario: Rescue an exception in a controller with a custom error string
-    When I configure the notifier to use the following configuration lines:
-    """
-    config.api_key = "myapikey"
-    config.user_information = 'Error #{{ error_id }}'
-    """
-    And I run `rails generate airbrake -k myapikey`
-    And I define a response for "TestController#index":
-      """
-      raise RuntimeError, "some message"
-      """
-    And the response page for a "500" error is
-      """
-      <!-- AIRBRAKE ERROR -->
-      """
-    And I route "/test/index" to "test#index"
-    And I perform a request to "http://example.com:123/test/index?param=value" in the "production" environment
-    Then I should see "Error #b6817316-9c45-ed26-45eb-780dbb86aadb"
-
-  Scenario: Don't inform the user
-    When I configure the notifier to use the following configuration lines:
-    """
-    config.user_information = false
-    """
-    And I run `rails generate airbrake -k myapikey`
-    And I define a response for "TestController#index":
-      """
-      raise RuntimeError, "some message"
-      """
-    And the response page for a "500" error is
-      """
-      <!-- AIRBRAKE ERROR -->
-      """
-    And I route "/test/index" to "test#index"
-    And I perform a request to "http://example.com:123/test/index?param=value" in the "production" environment
-    Then I should not see "Airbrake Error b6817316-9c45-ed26-45eb-780dbb86aadb"

data/generators/airbrake/airbrake_generator.rb

@@ -1,94 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/lib/insert_commands.rb")
-require File.expand_path(File.dirname(__FILE__) + "/lib/rake_commands.rb")
-
-class AirbrakeGenerator < Rails::Generator::Base
-  def add_options!(opt)
-    opt.on('-k', '--api-key=key', String, "Your Airbrake API key")                                               { |v| options[:api_key] = v}
-    opt.on('-h', '--heroku',              "Use the Heroku addon to provide your Airbrake API key")               { |v| options[:heroku]  = v}
-    opt.on('-a', '--app=myapp', String,   "Your Heroku app name (only required if deploying to >1 Heroku app)") { |v| options[:app]     = v}
-  end
-
-  def manifest
-    if !api_key_configured? && !options[:api_key] && !options[:heroku]
-      puts "Must pass --api-key or --heroku or create config/initializers/airbrake.rb"
-      exit
-    end
-    if plugin_is_present?
-      puts "You must first remove the airbrake plugin. Please run: script/plugin remove airbrake"
-      exit
-    end
-    record do |m|
-      m.directory 'lib/tasks'
-      m.file 'airbrake_tasks.rake', 'lib/tasks/airbrake_tasks.rake'
-      if ['config/deploy.rb', 'Capfile'].all? { |file| File.exists?(file) }
-        m.append_to 'config/deploy.rb', capistrano_hook
-      end
-      if api_key_expression
-        if use_initializer?
-          m.template 'initializer.rb', 'config/initializers/airbrake.rb',
-            :assigns => {:api_key => api_key_expression}
-        else
-          m.template 'initializer.rb', 'config/airbrake.rb',
-            :assigns => {:api_key => api_key_expression}
-          m.append_to 'config/environment.rb', "require 'config/airbrake'"
-        end
-      end
-      determine_api_key if heroku?
-      m.rake "airbrake:test", :generate_only => true
-    end
-  end
-
-  def api_key_expression
-    s = if options[:api_key]
-      "'#{options[:api_key]}'"
-    elsif options[:heroku]
-      "ENV['HOPTOAD_API_KEY']"
-    end
-  end
-
-  def determine_api_key
-    puts "Attempting to determine your API Key from Heroku..."
-    ENV['HOPTOAD_API_KEY'] = heroku_api_key
-    if ENV['HOPTOAD_API_KEY'] =~ /\S/
-      puts "... Done."
-      puts "Heroku's Airbrake API Key is '#{ENV['HOPTOAD_API_KEY']}'"
-    else
-      puts "... Failed."
-      puts "WARNING: We were unable to detect the Airbrake API Key from your Heroku environment."
-      puts "Your Heroku application environment may not be configured correctly."
-      exit 1
-    end
-  end
-
-  def heroku_var(var,app_name = nil)
-    app = app_name ? "--app #{app_name}" : ''
-    `heroku config #{app} | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
-  end
-
-  def heroku_api_key
-    heroku_var("(hoptoad|airbrake)_api_key",options[:app]).split.find {|x| x =~ /\S/ }
-  end
-
-  def heroku?
-    options[:heroku] ||
-      system("grep HOPTOAD_API_KEY config/initializers/airbrake.rb") ||
-      system("grep HOPTOAD_API_KEY config/environment.rb")
-  end
-
-  def use_initializer?
-    ::Rails::VERSION::MAJOR > 1
-  end
-
-  def api_key_configured?
-    File.exists?('config/initializers/airbrake.rb') ||
-      system("grep Airbrake config/environment.rb")
-  end
-
-  def capistrano_hook
-    IO.read(source_path('capistrano_hook.rb'))
-  end
-
-  def plugin_is_present?
-    File.exists?('vendor/plugins/airbrake')
-  end
-end