errornot_notifier 0.1.0 → 1.0.0

data/lib/{hoptoad_notifier → errornot_notifier}/configuration.rb

@@ -1,4 +1,4 @@
-module HoptoadNotifier
+module ErrornotNotifier
   # Used to set up and modify settings for the notifier.
   class Configuration
 
@@ -12,11 +12,11 @@ module HoptoadNotifier
     # The API key for your project, found on the project edit form.
     attr_accessor :api_key
 
-    # The host to connect to (defaults to hoptoadapp.com).
+    # The host to connect, there are no default value
     attr_accessor :host
 
-    # The port on which your Hoptoad server runs (defaults to 443 for secure
-    # connections, 80 for insecure connections).
+    # The port on which your Errornot server runs we can advise to
+    # prefere 443 for a secure connection
     attr_accessor :port
 
     # +true+ for https connections, +false+ for http connections.
@@ -40,7 +40,7 @@ module HoptoadNotifier
     # The password to use when logging into your proxy server (if using a proxy)
     attr_accessor :proxy_pass
 
-    # A list of parameters that should be filtered out of what is sent to Hoptoad.
+    # A list of parameters that should be filtered out of what is sent to Errornot.
     # By default, all "password" attributes will have their contents replaced.
     attr_reader :params_filters
 
@@ -68,7 +68,7 @@ module HoptoadNotifier
     # The path to the project in which the error occurred, such as the RAILS_ROOT
     attr_accessor :project_root
 
-    # The name of the notifier library being used to send notifications (such as "Hoptoad Notifier")
+    # The name of the notifier library being used to send notifications (such as "Errornot Notifier")
     attr_accessor :notifier_name
 
     # The version of the notifier library being used to send notifications (such as "1.0.2")
@@ -77,18 +77,18 @@ module HoptoadNotifier
     # The url of the notifier library being used to send notifications
     attr_accessor :notifier_url
 
-    # The logger used by HoptoadNotifier
+    # The logger used by ErrornotNotifier
     attr_accessor :logger
 
-    # The framework HoptoadNotifier is configured to use
+    # The framework ErrornotNotifier is configured to use
     attr_accessor :framework
 
     DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
 
     DEFAULT_BACKTRACE_FILTERS = [
       lambda { |line|
-        if defined?(HoptoadNotifier.configuration.project_root) && HoptoadNotifier.configuration.project_root.to_s != '' 
-          line.gsub(/#{HoptoadNotifier.configuration.project_root}/, "[PROJECT_ROOT]")
+        if defined?(ErrornotNotifier.configuration.project_root) && ErrornotNotifier.configuration.project_root.to_s != ''
+          line.gsub(/#{ErrornotNotifier.configuration.project_root}/, "[PROJECT_ROOT]")
         else
           line
         end
@@ -101,7 +101,7 @@ module HoptoadNotifier
           end
         end
       },
-      lambda { |line| line if line !~ %r{lib/hoptoad_notifier} }
+      lambda { |line| line if line !~ %r{lib/errornot_notifier} }
     ].freeze
 
     IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
@@ -114,7 +114,6 @@ module HoptoadNotifier
 
     def initialize
       @secure                   = false
-      @host                     = 'hoptoadapp.com'
       @http_open_timeout        = 2
       @http_read_timeout        = 5
       @params_filters           = DEFAULT_PARAMS_FILTERS.dup
@@ -124,9 +123,8 @@ module HoptoadNotifier
       @ignore_user_agent        = []
       @development_environments = %w(development test cucumber)
       @development_lookup       = true
-      @notifier_name            = 'Hoptoad Notifier'
+      @notifier_name            = 'Errornot Notifier'
       @notifier_version         = VERSION
-      @notifier_url             = 'http://hoptoadapp.com'
       @framework                = 'Standalone'
     end
 
@@ -153,8 +151,8 @@ module HoptoadNotifier
     #   end
     #
     # @param [Proc] block The new ignore filter
-    # @yieldparam [Hash] data The exception data given to +HoptoadNotifier.notify+
-    # @yieldreturn [Boolean] If the block returns true the exception will be ignored, otherwise it will be processed by hoptoad.
+    # @yieldparam [Hash] data The exception data given to +ErrornotNotifier.notify+
+    # @yieldreturn [Boolean] If the block returns true the exception will be ignored, otherwise it will be processed by Errornot.
     def ignore_by_filter(&block)
       self.ignore_by_filters << block
     end

data/lib/{hoptoad_notifier → errornot_notifier}/notice.rb

@@ -1,4 +1,4 @@
-module HoptoadNotifier
+module ErrornotNotifier
   class Notice
 
     # The exception that caused this notice, if any
@@ -54,7 +54,7 @@ module HoptoadNotifier
     # See Configuration#ignore_by_filters
     attr_reader :ignore_by_filters
 
-    # The name of the notifier library sending this notice, such as "Hoptoad Notifier"
+    # The name of the notifier library sending this notice, such as "Errornot Notifier"
     attr_reader :notifier_name
 
     # The version number of the notifier library sending this notice, such as "2.1.3"

data/lib/{hoptoad_notifier → errornot_notifier}/rack.rb

@@ -1,22 +1,22 @@
-module HoptoadNotifier
+module ErrornotNotifier
   # Middleware for Rack applications. Any errors raised by the upstream
-  # application will be delivered to Hoptoad and re-raised.
+  # application will be delivered to Errornot and re-raised.
   #
   # Synopsis:
   #
   #   require 'rack'
-  #   require 'hoptoad_notifier'
+  #   require 'errornot_notifier'
   #
-  #   HoptoadNotifier.configure do |config|
+  #   ErrornotNotifier.configure do |config|
   #     config.api_key = 'my_api_key'
   #   end
   #
   #   app = Rack::Builder.app do
-  #     use HoptoadNotifier::Rack
+  #     use ErrornotNotifier::Rack
   #     run lambda { |env| raise "Rack down" }
   #   end
   #
-  # Use a standard HoptoadNotifier.configure call to configure your api key.
+  # Use a standard ErrornotNotifier.configure call to configure your api key.
   class Rack
     def initialize(app)
       @app = app
@@ -26,12 +26,12 @@ module HoptoadNotifier
       begin
         response = @app.call(env)
       rescue Exception => raised
-        HoptoadNotifier.notify_or_ignore(raised, :rack_env => env)
+        ErrornotNotifier.notify_or_ignore(raised, :rack_env => env)
         raise
       end
 
       if env['rack.exception']
-        HoptoadNotifier.notify_or_ignore(env['rack.exception'], :rack_env => env)
+        ErrornotNotifier.notify_or_ignore(env['rack.exception'], :rack_env => env)
       end
 
       response

data/lib/{hoptoad_notifier → errornot_notifier}/rails/action_controller_catcher.rb

@@ -1,28 +1,28 @@
-module HoptoadNotifier
+module ErrornotNotifier
   module Rails
     module ActionControllerCatcher
 
       # Sets up an alias chain to catch exceptions when Rails does
       def self.included(base) #:nodoc:
-        base.send(:alias_method, :rescue_action_in_public_without_hoptoad, :rescue_action_in_public)
-        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_hoptoad)
+        base.send(:alias_method, :rescue_action_in_public_without_errornot, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_errornot)
       end
 
       private
 
       # Overrides the rescue_action method in ActionController::Base, but does not inhibit
       # any custom processing that is defined with Rails 2's exception helpers.
-      def rescue_action_in_public_with_hoptoad(exception)
-        unless hoptoad_ignore_user_agent?
-          HoptoadNotifier.notify_or_ignore(exception, hoptoad_request_data)
+      def rescue_action_in_public_with_errornot(exception)
+        unless errornot_ignore_user_agent?
+          ErrornotNotifier.notify_or_ignore(exception, errornot_request_data)
         end
-        rescue_action_in_public_without_hoptoad(exception)
+        rescue_action_in_public_without_errornot(exception)
       end
 
-      def hoptoad_ignore_user_agent? #:nodoc:
+      def errornot_ignore_user_agent? #:nodoc:
         # Rails 1.2.6 doesn't have request.user_agent, so check for it here
         user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
-        HoptoadNotifier.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+        ErrornotNotifier.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
       end
     end
   end

data/lib/{hoptoad_notifier → errornot_notifier}/rails/controller_methods.rb

@@ -1,33 +1,33 @@
-module HoptoadNotifier
+module ErrornotNotifier
   module Rails
     module ControllerMethods
       private
 
       # This method should be used for sending manual notifications while you are still
-      # inside the controller. Otherwise it works like HoptoadNotifier.notify.
-      def notify_hoptoad(hash_or_exception)
+      # inside the controller. Otherwise it works like ErrornotNotifier.notify.
+      def notify_errornot(hash_or_exception)
         unless consider_all_requests_local || local_request?
-          HoptoadNotifier.notify(hash_or_exception, hoptoad_request_data)
+          ErrornotNotifier.notify(hash_or_exception, errornot_request_data)
         end
       end
 
-      def hoptoad_ignore_user_agent? #:nodoc:
+      def errornot_ignore_user_agent? #:nodoc:
         # Rails 1.2.6 doesn't have request.user_agent, so check for it here
         user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
-        HoptoadNotifier.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+        ErrornotNotifier.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
       end
 
-      def hoptoad_request_data
-        { :parameters       => hoptoad_filter_if_filtering(params.to_hash),
-          :session_data     => hoptoad_session_data,
+      def errornot_request_data
+        { :parameters       => errornot_filter_if_filtering(params.to_hash),
+          :session_data     => errornot_session_data,
           :controller       => params[:controller],
           :action           => params[:action],
-          :url              => hoptoad_request_url,
-          :cgi_data         => hoptoad_filter_if_filtering(request.env),
-          :environment_vars => hoptoad_filter_if_filtering(ENV) }
+          :url              => errornot_request_url,
+          :cgi_data         => errornot_filter_if_filtering(request.env),
+          :environment_vars => errornot_filter_if_filtering(ENV) }
       end
 
-      def hoptoad_filter_if_filtering(hash)
+      def errornot_filter_if_filtering(hash)
         if respond_to?(:filter_parameters)
           filter_parameters(hash) rescue hash
         else
@@ -35,7 +35,7 @@ module HoptoadNotifier
         end
       end
 
-      def hoptoad_session_data
+      def errornot_session_data
         if session.respond_to?(:to_hash)
           session.to_hash
         else
@@ -43,7 +43,7 @@ module HoptoadNotifier
         end
       end
 
-      def hoptoad_request_url
+      def errornot_request_url
         url = "#{request.protocol}#{request.host}"
 
         unless [80, 443].include?(request.port)

data/lib/{hoptoad_notifier → errornot_notifier}/rails/error_lookup.rb

@@ -1,27 +1,27 @@
-module HoptoadNotifier
+module ErrornotNotifier
   module Rails
     module ErrorLookup
 
       # Sets up an alias chain to catch exceptions when Rails does
       def self.included(base) #:nodoc:
-        base.send(:alias_method, :rescue_action_locally_without_hoptoad, :rescue_action_locally)
-        base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_hoptoad)
+        base.send(:alias_method, :rescue_action_locally_without_errornot, :rescue_action_locally)
+        base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_errornot)
       end
 
       private
 
-      def rescue_action_locally_with_hoptoad(exception)
-        result = rescue_action_locally_without_hoptoad(exception)
+      def rescue_action_locally_with_errornot(exception)
+        result = rescue_action_locally_without_errornot(exception)
 
-        if HoptoadNotifier.configuration.development_lookup
+        if ErrornotNotifier.configuration.development_lookup
           path   = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'rescue.erb')
-          notice = HoptoadNotifier.build_lookup_hash_for(exception, hoptoad_request_data)
+          notice = ErrornotNotifier.build_lookup_hash_for(exception, errornot_request_data)
 
           result << @template.render(
             :file          => path,
             :use_full_path => false,
-            :locals        => { :host    => HoptoadNotifier.configuration.host,
-                                :api_key => HoptoadNotifier.configuration.api_key,
+            :locals        => { :host    => ErrornotNotifier.configuration.host,
+                                :api_key => ErrornotNotifier.configuration.api_key,
                                 :notice  => notice })
         end
 

data/lib/{hoptoad_notifier → errornot_notifier}/rails.rb

@@ -1,15 +1,15 @@
-require 'hoptoad_notifier'
-require 'hoptoad_notifier/rails/controller_methods'
-require 'hoptoad_notifier/rails/action_controller_catcher'
-require 'hoptoad_notifier/rails/error_lookup'
+require 'errornot_notifier'
+require 'errornot_notifier/rails/controller_methods'
+require 'errornot_notifier/rails/action_controller_catcher'
+require 'errornot_notifier/rails/error_lookup'
 
-module HoptoadNotifier
+module ErrornotNotifier
   module Rails
     def self.initialize
       if defined?(ActionController::Base)
-        ActionController::Base.send(:include, HoptoadNotifier::Rails::ActionControllerCatcher)
-        ActionController::Base.send(:include, HoptoadNotifier::Rails::ErrorLookup)
-        ActionController::Base.send(:include, HoptoadNotifier::Rails::ControllerMethods)
+        ActionController::Base.send(:include, ErrornotNotifier::Rails::ActionControllerCatcher)
+        ActionController::Base.send(:include, ErrornotNotifier::Rails::ErrorLookup)
+        ActionController::Base.send(:include, ErrornotNotifier::Rails::ControllerMethods)
       end
 
       rails_logger = if defined?(::Rails.logger)
@@ -20,10 +20,10 @@ module HoptoadNotifier
 
       if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
         ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
-                                                      HoptoadNotifier::Rack
+                                                      ErrornotNotifier::Rack
       end
 
-      HoptoadNotifier.configure(true) do |config|
+      ErrornotNotifier.configure(true) do |config|
         config.logger = rails_logger
         config.environment_name = RAILS_ENV  if defined?(RAILS_ENV)
         config.project_root     = RAILS_ROOT if defined?(RAILS_ROOT)
@@ -33,5 +33,5 @@ module HoptoadNotifier
   end
 end
 
-HoptoadNotifier::Rails.initialize
+ErrornotNotifier::Rails.initialize
 

data/lib/{hoptoad_notifier → errornot_notifier}/sender.rb

@@ -1,5 +1,5 @@
-module HoptoadNotifier
-  # Sends out the notice to Hoptoad
+module ErrornotNotifier
+  # Sends out the notice to Errornot
   class Sender
 
     NOTICES_URI = '/errors'.freeze
@@ -30,10 +30,10 @@ module HoptoadNotifier
     end
 
 
-    # Sends the notice data off to Hoptoad for processing.
+    # Sends the notice data off to Errornot for processing.
     #
     # @param [String] data The XML notice to be sent off
-    def send_to_hoptoad(data)
+    def send_to_errornot(data)
       logger.debug { "Sending request to #{url.to_s}:\n#{data}" } if logger
 
       http =
@@ -50,7 +50,7 @@ module HoptoadNotifier
                    data = process_payload(data)
                    http.post(url.path, data, HEADERS)
                  rescue TimeoutError => e
-                   log :error, "Timeout while contacting the Hoptoad server."
+                   log :error, "Timeout while contacting the Errornot server."
                    nil
                  end
 
@@ -73,12 +73,12 @@ module HoptoadNotifier
 
     def log(level, message, response = nil)
       logger.send level, LOG_PREFIX + message if logger
-      HoptoadNotifier.report_environment_info
-      HoptoadNotifier.report_response_body(response.body) if response && response.respond_to?(:body)
+      ErrornotNotifier.report_environment_info
+      ErrornotNotifier.report_response_body(response.body) if response && response.respond_to?(:body)
     end
 
     def logger
-      HoptoadNotifier.logger
+      ErrornotNotifier.logger
     end
 
   end

data/lib/{hoptoad_notifier → errornot_notifier}/tasks.rb

@@ -1,10 +1,10 @@
-require 'hoptoad_notifier'
+require 'errornot_notifier'
 
-namespace :hoptoad do
-  desc "Notify Hoptoad of a new deploy."
+namespace :errornot do
+  desc "Notify Errornot of a new deploy."
   task :deploy => :environment do
-    require 'hoptoad_tasks'
-    HoptoadTasks.deploy(:rails_env      => ENV['TO'], 
+    require 'errornot_tasks'
+    ErrornotTasks.deploy(:rails_env      => ENV['TO'],
                         :scm_revision   => ENV['REVISION'],
                         :scm_repository => ENV['REPO'],
                         :local_username => ENV['USER'],
@@ -16,24 +16,24 @@ namespace :hoptoad do
     RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
   end
 
-  desc "Verify your gem installation by sending a test exception to the hoptoad service"
-  task :test => ['hoptoad:log_stdout', :environment] do
+  desc "Verify your gem installation by sending a test exception to the errornot service"
+  task :test => ['errornot:log_stdout', :environment] do
     RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
 
     require 'action_controller/test_process'
 
     Dir["app/controllers/application*.rb"].each { |file| require(file) }
 
-    class HoptoadTestingException < RuntimeError; end
+    class ErrornotTestingException < RuntimeError; end
 
-    unless HoptoadNotifier.configuration.api_key
-      puts "Hoptoad needs an API key configured! Check the README to see how to add it."
+    unless ErrornotNotifier.configuration.api_key
+      puts "Errornot needs an API key configured! Check the README to see how to add it."
       exit
     end
 
-    HoptoadNotifier.configuration.development_environments = []
+    ErrornotNotifier.configuration.development_environments = []
 
-    catcher = HoptoadNotifier::Rails::ActionControllerCatcher
+    catcher = ErrornotNotifier::Rails::ActionControllerCatcher
     in_controller = ApplicationController.included_modules.include?(catcher)
     in_base = ActionController::Base.included_modules.include?(catcher)
     if !in_controller || !in_base
@@ -42,7 +42,7 @@ namespace :hoptoad do
     end
 
     puts "Configuration:"
-    HoptoadNotifier.configuration.to_hash.each do |key, value|
+    ErrornotNotifier.configuration.to_hash.each do |key, value|
       puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
     end
 
@@ -54,10 +54,10 @@ namespace :hoptoad do
     puts 'Setting up the Controller.'
     class ApplicationController
       # This is to bypass any filters that may prevent access to the action.
-      prepend_before_filter :test_hoptoad
-      def test_hoptoad
+      prepend_before_filter :test_errornot
+      def test_errornot
         puts "Raising '#{exception_class.name}' to simulate application failure."
-        raise exception_class.new, 'Testing hoptoad via "rake hoptoad:test". If you can see this, it works.'
+        raise exception_class.new, 'Testing errornot via "rake errornot:test". If you can see this, it works.'
       end
 
       def rescue_action(exception)
@@ -76,7 +76,7 @@ namespace :hoptoad do
       end
 
       def exception_class
-        exception_name = ENV['EXCEPTION'] || "HoptoadTestingException"
+        exception_name = ENV['EXCEPTION'] || "ErrornotTestingException"
         Object.const_get(exception_name)
       rescue
         Object.const_set(exception_name, Class.new(Exception))
@@ -86,12 +86,12 @@ namespace :hoptoad do
         nil
       end
     end
-    class HoptoadVerificationController < ApplicationController; end
+    class ErrornotVerificationController < ApplicationController; end
 
     puts 'Processing request.'
     request = ActionController::TestRequest.new
     response = ActionController::TestResponse.new
-    HoptoadVerificationController.new.process(request, response)
+    ErrornotVerificationController.new.process(request, response)
   end
 end
 

data/lib/errornot_notifier/version.rb

@@ -0,0 +1,3 @@
+module ErrornotNotifier
+  VERSION = "1.0.0".freeze
+end

data/lib/{hoptoad_notifier.rb → errornot_notifier.rb}

@@ -2,15 +2,15 @@ require 'net/http'
 require 'net/https'
 require 'rubygems'
 require 'active_support'
-require 'hoptoad_notifier/version'
-require 'hoptoad_notifier/configuration'
-require 'hoptoad_notifier/notice'
-require 'hoptoad_notifier/sender'
-require 'hoptoad_notifier/backtrace'
-require 'hoptoad_notifier/rack'
+require 'errornot_notifier/version'
+require 'errornot_notifier/configuration'
+require 'errornot_notifier/notice'
+require 'errornot_notifier/sender'
+require 'errornot_notifier/backtrace'
+require 'errornot_notifier/rack'
 
-# Gem for applications to automatically post errors to the Hoptoad of their choice.
-module HoptoadNotifier
+# Gem for applications to automatically post errors to the Errornot of their choice.
+module ErrornotNotifier
 
   API_VERSION = "1.0"
   LOG_PREFIX = "** [ErrorNot Logger] "
@@ -21,12 +21,12 @@ module HoptoadNotifier
   }
 
   class << self
-    # The sender object is responsible for delivering formatted data to the Hoptoad server.
-    # Must respond to #send_to_hoptoad. See HoptoadNotifier::Sender.
+    # The sender object is responsible for delivering formatted data to the Errornot server.
+    # Must respond to #send_to_errornot. See ErrornotNotifier::Sender.
     attr_accessor :sender
 
-    # A Hoptoad configuration object. Must act like a hash and return sensible
-    # values for all Hoptoad configuration options. See HoptoadNotifier::Configuration.
+    # A Errornot configuration object. Must act like a hash and return sensible
+    # values for all Errornot configuration options. See ErrornotNotifier::Configuration.
     attr_accessor :configuration
 
     # Tell the log that the Notifier is good to go
@@ -39,9 +39,9 @@ module HoptoadNotifier
       write_verbose_log("Environment Info: #{environment_info}")
     end
 
-    # Prints out the response body from Hoptoad for debugging help
+    # Prints out the response body from Errornot for debugging help
     def report_response_body(response)
-      write_verbose_log("Response from Hoptoad: \n#{response}")
+      write_verbose_log("Response from Errornot: \n#{response}")
     end
 
     # Returns the Ruby version, Rails version, and current Rails environment
@@ -64,7 +64,7 @@ module HoptoadNotifier
     # Call this method to modify defaults in your initializers.
     #
     # @example
-    #   HoptoadNotifier.configure do |config|
+    #   ErrornotNotifier.configure do |config|
     #     config.api_key = '1234567890abcdef'
     #     config.secure  = false
     #   end
@@ -77,10 +77,10 @@ module HoptoadNotifier
 
     # Sends an exception manually using this method, even when you are not in a controller.
     #
-    # @param [Exception] exception The exception you want to notify Hoptoad about.
-    # @param [Hash] opts Data that will be sent to Hoptoad.
+    # @param [Exception] exception The exception you want to notify Errornot about.
+    # @param [Hash] opts Data that will be sent to Errornot.
     #
-    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Hoptoad uses for identification.
+    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Errornot uses for identification.
     # @option opts [String] :error_message The error returned by the exception (or the message you want to log).
     # @option opts [String] :backtrace A backtrace, usually obtained with +caller+.
     # @option opts [String] :request The controller's request object.
@@ -91,7 +91,7 @@ module HoptoadNotifier
     end
 
     # Sends the notice unless it is one of the default ignored exceptions
-    # @see HoptoadNotifier.notify
+    # @see ErrornotNotifier.notify
     def notify_or_ignore(exception, opts = {})
       notice = build_notice_for(exception, opts)
       send_notice(notice) unless notice.ignore?
@@ -118,7 +118,7 @@ module HoptoadNotifier
 
     def send_notice(notice)
       if configuration.public?
-        sender.send_to_hoptoad(notice.to_xml)
+        sender.send_to_errornot(notice.to_xml)
       end
     end
 

data/lib/{hoptoad_tasks.rb → errornot_tasks.rb}

@@ -2,19 +2,21 @@ require 'net/http'
 require 'uri'
 require 'active_support'
 
-# Capistrano tasks for notifying Hoptoad of deploys
-module HoptoadTasks
+# Capistrano tasks for notifying Errornot of deploys
+module ErrornotTasks
 
-  # Alerts Hoptoad of a deploy.
+  # Alerts Errornot of a deploy.
   #
-  # @param [Hash] opts Data about the deploy that is set to Hoptoad
+  # @param [Hash] opts Data about the deploy that is set to Errornot
   #
   # @option opts [String] :rails_env Environment of the deploy (production, staging)
   # @option opts [String] :scm_revision The given revision/sha that is being deployed
   # @option opts [String] :scm_repository Address of your repository to help with code lookups
   # @option opts [String] :local_username Who is deploying
   def self.deploy(opts = {})
-    if HoptoadNotifier.configuration.api_key.blank?
+    raise NotImplementedError.new("it's not implemented in errornot now")
+    # TODO: implement it in ErrorNot
+    if ErrornotNotifier.configuration.api_key.blank?
       puts "I don't seem to be configured with an API key.  Please check your configuration."
       return false
     end
@@ -25,10 +27,10 @@ module HoptoadTasks
     end
 
     params = {'api_key' => opts.delete(:api_key) ||
-                             HoptoadNotifier.configuration.api_key}
+                             ErrornotNotifier.configuration.api_key}
     opts.each {|k,v| params["deploy[#{k}]"] = v }
 
-    url = URI.parse("http://#{HoptoadNotifier.configuration.host || 'hoptoadapp.com'}/deploys.txt")
+    url = URI.parse("http://#{ErrornotNotifier.configuration.host}/deploys")
     response = Net::HTTP.post_form(url, params)
     puts response.body
     return Net::HTTPSuccess === response

data/lib/templates/rescue.erb

@@ -1,5 +1,5 @@
 <script type="text/javascript">
-var Hoptoad = {
+var Errornot = {
   host    : <%= host.to_json %>,
   api_key : <%= api_key.to_json %>,
   notice  : <%= notice.to_json %>,
@@ -19,7 +19,7 @@ var Hoptoad = {
     }
 
     data[data.length] = 'notice[api_key]=' + this.api_key;
-    data[data.length] = 'callback=Hoptoad.onSuccess';
+    data[data.length] = 'callback=Errornot.onSuccess';
     data[data.length] = '_=' + (new Date()).getTime();
 
     var head = document.getElementsByTagName('head')[0];
@@ -50,7 +50,7 @@ var Hoptoad = {
     var text    = document.createTextNode(this.message);
     var element = document.createElement('a');
 
-    element.id   = 'hoptoad';
+    element.id   = 'errornot';
     element.href = 'http://' + error.subdomain + '.' + this.host +
                    '/projects/' + error.project_id + '/errors/' + error.id;
     element.appendChild(text);
@@ -70,12 +70,12 @@ var Hoptoad = {
 };
 
 window.onload = function() {
-  Hoptoad.initialize.apply(Hoptoad);
+  Errornot.initialize.apply(Errornot);
 };
 </script>
 
 <style type="text/css">
-#hoptoad {
+#errornot {
   background: #FFF url(http://hoptoadapp.com/images/fell-off-the-toad.gif) no-repeat top right;
   color: #F00;
   padding: 45px 101px 45px 12px;