whoops_logger 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+gem "json"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "ruby-debug"
+  gem "fakeweb"
+end

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    columnize (0.3.2)
+    diff-lcs (1.1.2)
+    fakeweb (1.3.0)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.5.1)
+    linecache (0.43)
+    rake (0.8.7)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  fakeweb
+  jeweler (~> 1.5.2)
+  json
+  rspec (~> 2.6.0)
+  ruby-debug

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Daniel Higginbotham
+
+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.rdoc

@@ -0,0 +1,19 @@
+= whoops_logger
+
+Description goes here.
+
+== Contributing to whoops_logger
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Daniel Higginbotham. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "whoops_logger"
+  gem.homepage = "http://github.com/flyingmachine/whoops_logger"
+  gem.license = "MIT"
+  gem.summary = %Q{Handles basic notification responsibilities and allows creation of message creation strategies}
+  gem.description = %Q{Handles basic notification responsibilities and allows creation of message creation strategies}
+  gem.email = "daniel@flyingmachinestudios.com"
+  gem.authors = ["Daniel Higginbotham"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "whoops_logger #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/whoops_logger/configuration.rb

@@ -0,0 +1,132 @@
+require 'yaml'
+
+# Borrows heavily from Hoptoad Notifier by Tammer Saleh
+module WhoopsLogger  
+  # Used to set up and modify settings for the notifier.
+  class Configuration
+    OPTIONS = [:host, :http_open_timeout, :http_read_timeout,
+        :port, :protocol, :proxy_host,
+        :proxy_pass, :proxy_port, :proxy_user, :secure].freeze
+
+    # The host to connect to
+    attr_accessor :host
+
+    # The port on which your Whoops server runs (defaults to 443 for secure
+    # connections, 80 for insecure connections).
+    attr_accessor :port
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    # The HTTP open timeout in seconds (defaults to 2).
+    attr_accessor :http_open_timeout
+
+    # The HTTP read timeout in seconds (defaults to 5).
+    attr_accessor :http_read_timeout
+
+    # The hostname of your proxy server (if using a proxy)
+    attr_accessor :proxy_host
+
+    # The port of your proxy server (if using a proxy)
+    attr_accessor :proxy_port
+
+    # The username to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_user
+
+    # The password to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_pass
+
+    # The logger used by WhoopsLogger
+    attr_accessor :logger
+
+
+    alias_method :secure?, :secure
+
+    def initialize
+      @secure                   = false
+      @host                     = nil
+      @http_open_timeout        = 2
+      @http_read_timeout        = 5
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash.merge(option.to_sym => send(option))
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    def port
+      @port || default_port
+    end
+
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def set(config)
+      case config
+      when Hash: set_with_hash(config)
+      when IO: set_with_io(config)
+      when String: set_with_string(config)
+      end
+    end
+    
+    def set_with_hash(config)
+      OPTIONS.each do |option|
+        next unless self.respond_to?("#{option}=")
+        if config.has_key?(option)
+          self.send("#{option}=", config[option])
+        elsif config.has_key?(option.to_s)
+          self.send("#{option}=", config[option.to_s])
+        end
+      end
+    end
+    
+    # String should be either a filename or YAML
+    def set_with_string(config)
+      if File.exists?(config)
+        set_with_yaml(File.read(config))
+      else
+        set_with_yaml(config)
+      end
+    end
+    
+    def set_with_io(config)
+      set_with_yaml(config)
+      config.close
+    end
+    
+    def set_with_yaml(config)
+      set_with_hash(YAML.load(config))
+    end
+
+    private
+
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+  end
+end

data/lib/whoops_logger/message.rb

@@ -0,0 +1,26 @@
+module WhoopsLogger
+  class Message
+    ATTRIBUTES = [:event_type, :service, :environment, :message, :event_group_identifier, :event_time, :details]
+    ATTRIBUTES.each do |attribute|
+      attr_accessor attribute
+    end
+    
+    attr_accessor :ignore
+    
+    def initialize
+      self.event_time = Time.now
+    end
+    
+    def to_hash
+      h = {}
+      ATTRIBUTES.each do |attribute|
+        h[attribute] = self.send(attribute)
+      end
+      h
+    end
+    
+    def ignore?
+      ignore
+    end
+  end
+end

data/lib/whoops_logger/message_creator.rb

@@ -0,0 +1,24 @@
+module WhoopsLogger
+  
+  # A "glue" class which coordinates message creation
+  class MessageCreator
+    # get data from raw_data using a strategy to create a message and decide whether it should be ignored
+    attr_accessor :strategy, :message, :raw_data
+
+    def initialize(strategy, raw_data)
+      raise ArgumentError, "strategy can not be nil" if strategy.nil?
+      raise ArgumentError, "strategy must respond to 'call'" unless strategy.respond_to?(:call)
+      self.strategy = strategy
+      self.raw_data = raw_data
+      self.message = Message.new
+    end
+    
+    def create!
+      strategy.call(message, raw_data)
+    end
+    
+    def ignore_message?
+      message.ignore?
+    end
+  end
+end

data/lib/whoops_logger/sender.rb

@@ -0,0 +1,83 @@
+module WhoopsLogger
+  class Sender
+    NOTICES_URI = '/events/'.freeze
+    HTTP_ERRORS = [Timeout::Error,
+                   Errno::EINVAL,
+                   Errno::ECONNRESET,
+                   EOFError,
+                   Net::HTTPBadResponse,
+                   Net::HTTPHeaderSyntaxError,
+                   Net::ProtocolError,
+                   Errno::ECONNREFUSED].freeze
+
+   HEADERS = {
+     'Content-type'             => 'application/json',
+     'Accept'                   => 'application/json'
+   }
+
+    def initialize(options = {})
+      [:proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+        :host, :port, :secure, :http_open_timeout, :http_read_timeout].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    # Sends the notice data off to Whoops for processing.
+    #
+    # @param [Hash] data The notice to be sent off
+    def send_message(data)
+      # TODO: format
+      # TODO: validation
+      data = prepare_data(data)
+      logger.debug { "Sending request to #{url.to_s}:\n#{data}" } if logger
+
+      http =
+        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
+        new(url.host, url.port)
+
+      http.read_timeout = http_read_timeout
+      http.open_timeout = http_open_timeout
+      http.use_ssl      = secure
+
+      response = begin
+                   http.post(url.path, data, HEADERS)
+                 rescue *HTTP_ERRORS => e
+                   log :error, "Timeout while contacting the Whoops server."
+                   nil
+                 end
+
+      case response
+      when Net::HTTPSuccess then
+        log :info, "Success: #{response.class}", response
+      else
+        log :error, "Failure: #{response.class}", response
+      end
+
+      if response && response.respond_to?(:body)
+        error_id = response.body.match(%r{<error-id[^>]*>(.*?)</error-id>})
+        error_id[1] if error_id
+      end
+    end
+    
+    def prepare_data(data)
+      {:event => data}.to_json
+    end
+
+    private
+
+    attr_reader :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+      :host, :port, :secure, :http_open_timeout, :http_read_timeout
+
+    def url
+      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    end
+
+    def log(level, message, response = nil)
+      logger.send level, message if logger
+    end
+
+    def logger
+      WhoopsLogger.config.logger
+    end 
+  end
+end

data/lib/whoops_logger/strategies/basic.rb

@@ -0,0 +1,11 @@
+strategy = WhoopsLogger::Strategy.new("default::basic")
+
+strategy.add_message_builder(:use_basic_hash) do |message, raw_data|
+  message.event_type             = raw_data[:event_type]
+  message.service                = raw_data[:service]
+  message.environment            = raw_data[:environment]
+  message.message                = raw_data[:message]
+  message.event_group_identifier = raw_data[:event_group_identifier]
+  message.event_time             = raw_data[:event_time] if raw_data[:event_time]
+  message.details                = raw_data[:details]
+end

data/lib/whoops_logger/strategy.rb

@@ -0,0 +1,67 @@
+module WhoopsLogger
+  
+  # Strategies are responsible for building messages and determining whether a
+  # a message should be ignored.
+  #
+  # Each strategy contains any number of message builders and ignore criteria.
+  # 
+  # Each message builder and ignore criteria takes a name. This makes adding a
+  # message builder or ignore criteria more like adding a method - the name 
+  # makes it easier to see the intention of the code. It also makes it easier
+  # to get useful info when you inspect the strategy.
+  #
+  # Strategies use call to actually apply modifiers and criteria for the same
+  # reason that Rack uses call. Conceivably, you could add a strategy to the
+  # notifier with 
+  # WhoopsLogger.strategies[:lambda_stragey] = lambda{ |message, raw_data| 
+  #   message.details = raw_data[:detail]
+  # }
+  # or something along those lines. 
+  class Strategy
+    attr_accessor :name, :ignore_criteria, :message_builders
+
+    def initialize(name)
+      self.name             = name
+      self.ignore_criteria  = []
+      self.message_builders = []
+      WhoopsLogger.strategies[name] = self
+    end
+    
+    def call(message, raw_data)
+      message_builders.each do |message_modifier|
+        message_modifier.call(message, raw_data)
+      end
+      
+      ignore_criteria.each do |ignore_criterion|
+        if ignore_criterion.call(message, raw_data)
+          message.ignore = true
+          break
+        end
+      end
+    end
+    
+    # block should take two params, the message and the raw_data
+    # use raw_data to build the message
+    def add_message_builder(name, &block)
+      give_name(name, block)
+      @message_builders << block
+    end
+    
+    # block takes one param, the message_creator's message
+    def add_ignore_criteria(name, &block)
+      give_name(name, block)
+      @ignore_criteria << block
+    end
+    
+    def give_name(name, block)
+      class << block
+        attr_accessor :name
+      end
+      block.name = name
+    end
+    
+    def inspect
+      "#{name}\nmessage builders: #{message_builders.collect{|r| r.name}.join(", ")}\nignore criteria: #{ignore_criteria.collect{|i| i.name}.join(", ")}"
+    end
+  end
+end

data/lib/whoops_logger.rb

@@ -0,0 +1,45 @@
+require 'net/http'
+require 'net/https'
+require 'json'
+
+module WhoopsLogger
+  autoload :Configuration,   'whoops_logger/configuration'
+  autoload :MessageCreator,  'whoops_logger/message_creator'
+  autoload :Message,         'whoops_logger/message'
+  autoload :Sender,          'whoops_logger/sender'
+  autoload :Strategy,        'whoops_logger/strategy'
+  
+  class << self
+    attr_accessor :strategies, :config
+    
+    # @overload notify(raw_data)
+    #   Notify using the default basic strategy
+    #   @param [Hash] raw_data the raw_data expected by the basic strategy, used by strategy to build message
+    # @overload notify(strategy_name, raw_data)
+    #   @param [Symbol, String] strategy_name
+    #   @param [Hash] raw_data same as above
+    def notify(strategy_name, raw_data = {})
+      if strategy_name.is_a? Hash
+        notify("default::basic", strategy_name)
+      else
+        message_creator = MessageCreator.new(strategies[strategy_name], raw_data)
+        message_creator.create!
+        send_message(message_creator.message) unless message_creator.ignore_message?
+      end
+    end
+    
+    def send_message(message)
+      Sender.new(WhoopsLogger.config.to_hash).send_message(message.to_hash)
+    end
+  end
+  
+  def self.config
+    @config ||= Configuration.new
+  end
+  
+  self.strategies = {}
+end
+
+Dir[File.join(File.dirname(__FILE__),"whoops_logger/strategies/*.rb")].each do |strategy_file|
+  require strategy_file
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,38 @@
+describe "WhoopsLogger::Configuration" do
+  describe "#set" do 
+    before(:each) {
+      @real_config = WhoopsLogger.config.to_hash
+      WhoopsLogger::Configuration::OPTIONS.each do |option|
+        WhoopsLogger.config.send("#{option}=", nil) if WhoopsLogger.config.respond_to?("#{option}=".to_sym)
+      end
+    }
+    after(:each) { 
+      WhoopsLogger.config.set(@real_config)
+    }
+    
+    let(:config_path) { File.join(File.dirname(__FILE__), "fixtures/whoops_logger.yml") }
+    it "should set the config from a yaml filename" do
+      WhoopsLogger.config.set(config_path)
+      WhoopsLogger.config.host.should == "whoops.com"
+    end
+
+    it "should set the config from a file" do
+      WhoopsLogger.config.set(File.open(config_path))
+      WhoopsLogger.config.host.should == "whoops.com"
+    end
+
+    it "should set the config from a hash" do
+      WhoopsLogger.config.set({
+        :host => "whoops.com",
+      })
+      WhoopsLogger.config.host.should == "whoops.com"
+    end
+    
+    it "should allow string keys" do
+      WhoopsLogger.config.set({
+        "host" => "whoops.com",
+      })
+      WhoopsLogger.config.host.should == "whoops.com"
+    end
+  end
+end

data/spec/fixtures/whoops_logger.yml

@@ -0,0 +1 @@
+:host: whoops.com

data/spec/message_creator_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "WhoopsLogger::MessageCreator" do
+  describe "#initialize" do
+    it "should raise an exception if strategy is nil" do
+      lambda{WhoopsLogger::MessageCreator.new(nil, {})}.should raise_exception(ArgumentError)
+    end
+    
+    it "should raise an exception if strategy argument does not respond to call" do
+      lambda{WhoopsLogger::MessageCreator.new(true, {})}.should raise_exception(ArgumentError)
+    end
+    
+    it "should not raise an exception if strategy argument responds to call" do
+      lambda{WhoopsLogger::MessageCreator.new(Proc.new{}, {})}.should_not raise_exception
+    end
+  end
+  
+  describe "#create!" do
+    it "should not send message if ignore_message? is true" do
+      strategy = lambda{}
+      message_creator = WhoopsLogger::MessageCreator.new(strategy, {})
+      message_creator.stub(:ignore_message?).and_return(true)
+      
+      message_creator.should_not_receive(:send_message)
+      
+      message_creator.create!
+    end
+  end  
+end

data/spec/sender_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe WhoopsLogger::Sender do
+  describe "#send_message" do
+    it "should send a message to the configured URL when given a config object" do
+      FakeWeb.register_uri(:post, "http://whoops.com/events/", :body => "success")
+      
+      sender = WhoopsLogger::Sender.new(WhoopsLogger.config)
+      sender.send_message({:test => true})
+
+      request = FakeWeb.last_request
+      request.body.should =~ /"test"/
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+rspec_dir = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift(File.join(rspec_dir, '..', 'lib'))
+$LOAD_PATH.unshift(rspec_dir)
+require 'rspec'
+require 'whoops_logger'
+require 'fakeweb'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{rspec_dir}/support/**/*.rb"].each {|f| require f}
+
+WhoopsLogger.config.set(File.join(rspec_dir, "fixtures", "whoops_logger.yml"))

data/spec/strategy_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "WhoopsLogger::Strategy" do
+  describe "#initialize" do
+    it "adds a strategy to WhoopsLogger.strategies" do
+      s = WhoopsLogger::Strategy.new(:test)
+      WhoopsLogger.strategies[:test].should == s
+    end
+    
+    it "creates empty arrays for ignore criteria and message_builders" do
+      s = WhoopsLogger::Strategy.new(:test)
+      s.ignore_criteria.should == []
+      s.message_builders.should == []
+    end
+  end
+  
+  describe "#add_message_builder" do
+    it "adds a named block" do
+      s = WhoopsLogger::Strategy.new(:test)
+      s.add_message_builder(:add_message) { |message, raw_data| }
+
+      s.message_builders.first.name.should == :add_message
+    end
+  end
+  
+  describe "#add_ignore_criteria" do
+    it "adds a named ignore criteria block" do
+      s = WhoopsLogger::Strategy.new(:test)
+      s.add_ignore_criteria(:ignore_if_empty) { |message| }
+
+      s.ignore_criteria.first.name.should == :ignore_if_empty
+    end
+  end
+  
+  describe "#call" do
+    it "should change the message_creator's 'ignore' attribute to true if any ignore criteria are true" do
+      strategy = WhoopsLogger::Strategy.new(:test)
+      message_creator = WhoopsLogger::MessageCreator.new(strategy, nil)
+      
+      strategy.add_ignore_criteria(:always_ignore) do |message|
+        true
+      end
+      
+      strategy.call(message_creator.message, message_creator.raw_data)
+      message_creator.ignore_message?.should == true
+    end
+    
+    it "should modify the message_creator's message according to the message modifiers" do
+      strategy = WhoopsLogger::Strategy.new(:test)
+      message_creator = WhoopsLogger::MessageCreator.new(strategy, {:service => "service"})
+      strategy.add_message_builder(:add_details){ |message, raw_data|
+        message.service = raw_data[:service] + " test"
+      }
+      
+      strategy.call(message_creator.message, message_creator.raw_data)
+      
+      message_creator.message.service.should == "service test"
+    end
+  end
+  
+  describe "#inspect" do
+    it "should list name, message modifier names, and ignore criteria names" do
+      strategy = WhoopsLogger::Strategy.new(:awesome_strategy)
+      message_creator = WhoopsLogger::MessageCreator.new(strategy, nil)
+      
+      strategy.add_message_builder(:message1){ }
+      strategy.add_message_builder(:message2){ }
+      
+      strategy.add_ignore_criteria(:ignore1){ true }
+      strategy.add_ignore_criteria(:ignore2){ true }
+      
+      strategy.inspect.should == "awesome_strategy
+message builders: message1, message2
+ignore criteria: ignore1, ignore2"
+      
+    end
+  end
+end

data/spec/whoops_logger_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "WhoopsLogger" do
+  before(:each) { FakeWeb.clean_registry }
+  
+  describe ".strategies" do
+    it "is a hash with keys of strategy names and values of strategy objects" do
+      WhoopsLogger.strategies.each do |key, value|
+        (key.instance_of?(Symbol) || key.instance_of?(String)).should be_true
+        value.should be_a WhoopsLogger::Strategy
+      end
+    end
+  end
+  
+  describe ".config" do
+    it "returns a WhoopsLogger::Configuration object" do
+      WhoopsLogger.config.should be_a(WhoopsLogger::Configuration)
+    end
+  end
+  
+  describe ".notify" do
+    let(:message_creator){ double(:message_creator, :create! => nil, :message => nil) }
+    
+    it "uses the basic strategy if no strategy name is provided" do
+      WhoopsLogger.stub(:send_message)
+      message_creator.stub(:ignore_message?).and_return(false)
+      WhoopsLogger::MessageCreator.should_receive(:new).with(WhoopsLogger.strategies["default::basic"], {}).and_return(message_creator)
+      WhoopsLogger.notify({})
+    end
+    
+    it "sends a message when the message_creator is not ignoring the event" do
+      message_creator.should_receive(:ignore_message?).and_return(false)
+      WhoopsLogger::MessageCreator.stub(:new).and_return(message_creator)
+      
+      WhoopsLogger.should_receive(:send_message)
+      WhoopsLogger.notify({})
+    end
+    
+    it "does not sned a request if the message_creator is ignoring the event" do
+      message_creator.should_receive(:ignore_message?).and_return(true)
+      WhoopsLogger::MessageCreator.stub(:new).and_return(message_creator)
+      
+      WhoopsLogger.should_not_receive(:send_message)
+      WhoopsLogger.notify({})
+    end
+  end
+  
+  describe ".send_message" do
+    it "should send a message to the configured URL" do
+      FakeWeb.register_uri(:post, "http://whoops.com/events/", :body => "success")
+      WhoopsLogger.notify({})
+      request = FakeWeb.last_request
+      request.body.should =~ /"event"/
+    end
+  end
+end

data/whoops_logger.gemspec

@@ -0,0 +1,86 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{whoops_logger}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Daniel Higginbotham"]
+  s.date = %q{2011-07-12}
+  s.description = %q{Handles basic notification responsibilities and allows creation of message creation strategies}
+  s.email = %q{daniel@flyingmachinestudios.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/whoops_logger.rb",
+    "lib/whoops_logger/configuration.rb",
+    "lib/whoops_logger/message.rb",
+    "lib/whoops_logger/message_creator.rb",
+    "lib/whoops_logger/sender.rb",
+    "lib/whoops_logger/strategies/basic.rb",
+    "lib/whoops_logger/strategy.rb",
+    "spec/configuration_spec.rb",
+    "spec/fixtures/whoops_logger.yml",
+    "spec/message_creator_spec.rb",
+    "spec/sender_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/strategy_spec.rb",
+    "spec/whoops_logger_spec.rb",
+    "whoops_logger.gemspec"
+  ]
+  s.homepage = %q{http://github.com/flyingmachine/whoops_logger}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Handles basic notification responsibilities and allows creation of message creation strategies}
+  s.test_files = [
+    "spec/configuration_spec.rb",
+    "spec/message_creator_spec.rb",
+    "spec/sender_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/strategy_spec.rb",
+    "spec/whoops_logger_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<ruby-debug>, [">= 0"])
+      s.add_development_dependency(%q<fakeweb>, [">= 0"])
+    else
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<ruby-debug>, [">= 0"])
+      s.add_dependency(%q<fakeweb>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.6.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<ruby-debug>, [">= 0"])
+    s.add_dependency(%q<fakeweb>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification 
+name: whoops_logger
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel Higginbotham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-12 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  name: json
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rspec
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: bundler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: jeweler
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: ruby-debug
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: fakeweb
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id006
+description: Handles basic notification responsibilities and allows creation of message creation strategies
+email: daniel@flyingmachinestudios.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/whoops_logger.rb
+- lib/whoops_logger/configuration.rb
+- lib/whoops_logger/message.rb
+- lib/whoops_logger/message_creator.rb
+- lib/whoops_logger/sender.rb
+- lib/whoops_logger/strategies/basic.rb
+- lib/whoops_logger/strategy.rb
+- spec/configuration_spec.rb
+- spec/fixtures/whoops_logger.yml
+- spec/message_creator_spec.rb
+- spec/sender_spec.rb
+- spec/spec_helper.rb
+- spec/strategy_spec.rb
+- spec/whoops_logger_spec.rb
+- whoops_logger.gemspec
+has_rdoc: true
+homepage: http://github.com/flyingmachine/whoops_logger
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Handles basic notification responsibilities and allows creation of message creation strategies
+test_files: 
+- spec/configuration_spec.rb
+- spec/message_creator_spec.rb
+- spec/sender_spec.rb
+- spec/spec_helper.rb
+- spec/strategy_spec.rb
+- spec/whoops_logger_spec.rb