announce 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fa794a66ef51e4014ed28023646ec8ffaed15c9
-  data.tar.gz: 5a1899a6b7e6437343e74a868839a5adaf19cb34
+  metadata.gz: 9789a278d07101dcd8a592549cd616a0d9792577
+  data.tar.gz: 9bdb61307e9b940ba340bd604a42acee381f0f26
 SHA512:
-  metadata.gz: f2267c7c79a58a538d23c532b6875019e2f7e7727c4b9858e61c3f5652f04a1f30c744d481d61c31c741ce3864dbc21a42f1bcfe4eb72a67603d8d6269aa79a7
-  data.tar.gz: 695a3865c7c7ccb7146dccf906f0afcdae2191666f530ae42936d180d467e63506bed3ad83fdaa3a4f4011d0efed1b6979e933989847b5d03d042eb18087c0cb
+  metadata.gz: 0422db42eed7b943f3fde2133ad9e6b67438eab02b874697d4b39b5cb54b65bda5470e5b262241dfeec49332a2db3d71d137915f78d54cbf44da88a9229130ef
+  data.tar.gz: 0689cc11bb610d00bbd074bf41924d589a3be572b75f167f1e2a1817b363b8bdcf3298cbfd772847b3b0a8aa328418938ef861e83373b283eaf1a01c211b0c03

data/.travis.yml

@@ -5,7 +5,3 @@ rvm:
 env:
   global:
     - TRAVIS=true
-    - CODECLIMATE_REPO_TOKEN=37c6f8d75bb1f20d34e79cab97e3ed0de6c9be552b15fbbbc4daf4f383c55ae4
-addons:
-  code_climate:
-    repo_token: 37c6f8d75bb1f20d34e79cab97e3ed0de6c9be552b15fbbbc4daf4f383c55ae4

data/Guardfile

@@ -26,7 +26,7 @@
 guard :minitest do
   # with Minitest::Unit
   watch(%r{^test/(.*)\/?test_(.*)\.rb$})
-  watch(%r{^lib/announce/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
   watch(%r{^test/test_helper\.rb$})      { 'test' }
 
   # with Minitest::Spec

data/README.md

@@ -8,32 +8,335 @@
 
 ### Announce lets your services know about events, and helps you process them.
 
-Announce is a gem to support using pub sub messages for events.
+It supports the publish/subscribe pattern, applied to sending out messages for events structed as `action`s that happen to `subject`s.
+
+Announce does not include its own job processor, as projects will likely already be running a process to handle asynchronous jobs. Instead, it is built to integrate with existing job processors, like `shoryuken`, so don't have workers written different ways or running in multiple processes.
+
+You can also write ActiveJob classes to process announce messages, further allowing a consistent abstraction of how asynchronous processing is handled.
+
+With announce, an application or service can send event messages out, but without knowing who will receive them or how they will be processed.  Other services and applications can pick and choose which events to receive by subscribing to them and process them appropriately, all without the publishing app having any awareness.
+
+Announce messages events are structured as a combination of `subject` and `action` to identify the type of message, and a message body containing the specific data about the event. All three required for sending a message:
+```ruby
+# You can send a message from the Announce module directly
+Announce.publish(:story, :publish, id: story.id)
+
+# There is also a module to make this slightly easier
+class SomeController
+  include Announce::Publisher
+
+  def create
+    publish(:some, :create, id: @some.id)
+  end
+end
+```
+
+When building a Ruby app or service to receive messages, subscribe a job class to announcements like this:
+```
+require 'announce'
+
+class SomeCreateJob < ActiveJob::Base
+  include Announce::Subscriber
+
+  subscribe_to :some, [:action]
+end
+```
+
+The `announce` gem uses adapters so different message brokers can be used, but currently only has `shoryuken` for production, an `inline` adapter where messages are only processed synchronously and within the existing app, and a `test` adapter useful for stubbing out messaging sending and receiving.
+
+The `shoryuken` adapter uses a combination of SNS and SQS for message handling, and includes a `rake` task to create the required SNS topics, SQS queues, and subscriptions between the two.
 
-It is built on top of other job processors, like shoryuken and ActiveJob to process the messages.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
+gem 'shoryuken'
 gem 'announce'
 ```
 
+(The only interesting adapter at the moment is shoryuken, so you'll probably want to use that.)
+
 And then execute:
 
     $ bundle
 
 Or install it yourself as:
 
-    $ gem install announce
+    $ gem install announce shoryuken
+
+## Configuration
+
+Announce is configured 3 ways:
+
+### Existing defaults are used if there is an ActiveJob configuration
+
+If you are using `announce` with Rails 4.2 and ActiveJob, add the following lines to your `config/application.rb` file:
+```ruby
+    config.active_job.queue_adapter = :shoryuken
+    config.active_job.queue_name_prefix = Rails.env
+    config.active_job.queue_name_delimiter = '_'
+```
+
+You can set these values in announce itself, but if they are already in your application configuration, there's no reason to duplicate.
+
+###  `subscribe_to` calls in your job classes
+
+These method calls are used to configure `shoryuken` in two ways.
+
+It adds the queues related to these subscriptions to the shoryuken worker process, so that process will request new messages for these subscriptions.
+
+It also registers that the class calling subscribe should receive the announcements for this subscription.
+
+
+### An `announce.yml` config file
+
+You can specify a different location, but by default `announce` will load a config file from `config/announce.yml`.
+
+This file allows you to set all the configuration for announce.
+The most important aspects are specifying what subjects and actions your app will send and receive, and the namespacing for your topics, queues, and subscriptions.
+
+This file is what is used for configuring SNS/SQS, it is not used to specify what queues shoryuken listens to, that is done with class methods in the jobs.
+
+Here is a documented example `announce.yml` file:
+```yaml
+################################################################################
+# `queue_name_prefix`
+# defaults to config.active_job.queue_name_prefix, RAILS_ENV or APP_ENV in ENV, or 'development'
+################################################################################
+queue_name_prefix: <%= Rails.env %>
+
+################################################################################
+# `queue_name_delimiter`
+# defaults to config.active_job.queue_name_delimiter or '_'
+################################################################################
+queue_name_delimiter: _
+
+################################################################################
+# `adapter`
+# which messaging adapter to use
+# based on config.active_job.queue_adapter or 'inline' if unspecified
+################################################################################
+adapter: shoryuken
+
+################################################################################
+# `namespace`
+# short name to relate all subjects for all subscribers and publishers
+# limit to characters friendly to SNS/SQS, used in topic and queue names
+# 'announce' is the default if unspecified
+################################################################################
+namespace: announce
+
+################################################################################
+# `app_name`
+# short name of this application or service, added to each published message
+# limit to characters friendly to SQS, used in making queue names
+# 'app' is the default if unspecified
+################################################################################
+app_name: app
+
+################################################################################
+# `publish`
+# subject keys with action list values for announcements this app will make
+# each subject must have at least one action.
+################################################################################
+publish:
+  foo:
+    - create
+
+################################################################################
+# `subscribe`
+# subject keys with action list values for announcements received by the app
+# each subject must have at least one action.
+################################################################################
+subscribe:
+  bar:
+    - delete
+
+################################################################################
+# `queues`
+# shoryuken adapter only, parameters SQS creating SQS queues
+# below are the default values for each parameter
+################################################################################
+queues:
+  VisibilityTimeout: 3600
+  DelaySeconds: 0
+  MaximumMessageSize: 262144
+  VisibilityTimeout: 3600
+  ReceiveMessageWaitTimeSeconds: 0
+  MessageRetentionPeriod: 604800
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+### Naming
+
+For the shoryuken adapter (and in the abstract base adapter), topics are named in the following way:
+```
+"#{prefix}_#{namespace}_#{subject}_#{action}"
+```
+
+Queues names also include the specific subscriber's app_name:
+```
+"#{prefix}_#{namespace}_#{app_name}_#{subject}_#{action}"
+```
+
+For example, for a production environment, with the app `cms` subscribing to the `story` subject and `update` action, the Topic will be:
+```
+production_announce_story_update
+```
+The cms's subscribing Queue will be named:
+```
+production_announce_cms_story_update
+```
+
+### Configuring the Broker
+
+To create the needed queues, topics, and subscriptions, first configure the `announce.yml` file, then run this rake task:
+```
+> bundle exec rake announce:configure_broker
+```
+
+If you are not using Rails, you can call the broker configuration from Ruby:
+```ruby
+Announce.configure(config_file: '/path/to/config/file/announce.yml')
+Announce.configure_broker
+```
+
+### Sending
+
+To send a message, the topics need to exists, so the broker must have been configured as per above.
+
+An announcement is made using the `publish` method (also aliased as `announce`).
+It take the 3 required params for `subject`, `action`, and the message `body`, and an optional `options` hash.
+
+```ruby
+# `publish` (or `announce`)
+# subject - the type of entity that this event relates to
+# action - the action that has occurred related to the entity
+# body - the message body that will be sent out
+# options (optional) - a hash of options to affect the publish, currently unused.
+#
+Announce.publish(:story, :publish, id: story.id, {})
+Announce.announce(:story, :publish, id: story.id, {})
+```
+
+There is also a module you can include to get `publish` and `announce` methods:
+```
+class SomeController
+  include Announce::Publisher
+
+  def create
+    @some = Some.new(some_params)
+    @some.save!
+
+    # announce it!
+    publish(:some, :create, id: @some.id)
+    respond_with(@some)
+  end
+end
+```
+
+The message `body` should be simple and serializable (json compatible), and something that any receiver could parse and understand, so don't include implementation details like specific Ruby classes.
+
+Unlike other job libraries which specify the Ruby `Class` for processing as part of the message, these announcements are meant to be decoupled - the sender should make no assumptions about the receiving application(s).
+
+
+### Processing
+
+To designate that a Ruby class will process a message, you must include the `Announce:Subscriber` module and call `subscribe_to` class method.
+
+```
+require 'announce'
+
+class SomeCreateJob < ActiveJob::Base
+  include Announce::Subscriber
+
+  subscribe_to :some, [:create]
+
+  def receive_some_create(body)
+    do_something(body[:id])
+  end
+end
+```
+
+This works because the `Announce::Subscriber` adds the `subscribe_to` class method, but also a default `perform(*args)` instance method that delegates message handling to a job instance method named `"receive_#{subject}_#{action}"`.
+
+This default `perform` method only passes the message `body` to `receive_subject_action` methods. The `subject`, but `action` and full `message` object are made available as instance properties of the subscriber.
+```
+require 'announce'
+
+class SomeCreateJob < ActiveJob::Base
+  include Announce::Subscriber
+
+  subscribe_to :some, [:create]
+
+  def receive_some_create(body)
+    puts "subject: #{subject} is some"
+    puts "action: #{action} is create"
+    puts "message: #{message.inspect}"
+  end
+end
+```
+
+The `message` includes the following standard attributes:
+- `message_id`: a uuid,
+- `app`: which app sent this message
+- `sent_at`: UTC timestamp of when the message was published
+
+along with the values from the publish call:
+- `subject`
+- `action`
+- `body`
+
+The `announce` gem relies on other libraries to actually receive messages and call workers to process them.
+
+For `shoryuken`, `subscribe_to` registers the worker for the appropriate queue, and also adds the queue to the list that will be polled by the shoryuken worker process (i.e. you don't need to add the queue to the `config/shoryuken.yml` file, or the command line call).  When starting up the shoryuken process, it should start retrieving messages on the appropriate queues without further shoryuken config.
+
+```
+# use -R to load the Rails application
+# use -r <path to load> to load your workers if not in a Rails app
+> bundle exec shoryuken -R
+```
 
 ## Development
 
+### Developing an Adapter Class
+
+Adapter classes should be named with the following module structure: `Announce::Adapters::SomeBrokerAdapter`
+For example, the above would work with the `adapter: some_broker` option in the ActiveJob or `announce.yml` config.
+
+There are only 2 methods required of an adapter class, `publish` and `subscribe`.
+(Optionally, the `configure_broker` method can be provided for the `rake announce:configure_broker` task.)
+
+```ruby
+module Announce
+  module Adapters
+    class SomeBroker
+      class << self
+
+        def publish(subject, action, body, options = {})
+        end
+
+        def subscribe(worker_class, subject, actions = [], options = {})
+        end
+
+        # optional
+        def configure_broker(options)
+        end
+
+      end
+    end
+  end
+end
+```
+
+There is also an abstract `BaseAdapter` which provides basic implementations of the required methods and supporting classes.
+This may or may not be helpful, but is currently used by the `ShoryukenAdapter`.
+
+### General
+
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

data/Rakefile

@@ -3,7 +3,7 @@ require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
+  t.pattern = 'test/**/test_*.rb'
 end
 
 task :default => :test
-

data/announce.gemspec

@@ -27,7 +27,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'guard'
   spec.add_development_dependency 'guard-minitest'
   spec.add_development_dependency 'dotenv'
-  spec.add_development_dependency 'codeclimate-test-reporter'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'coveralls'
 end

data/lib/announce.rb

@@ -6,6 +6,7 @@ require 'announce/message'
 require 'announce/publisher'
 require 'announce/subscriber'
 require 'announce/version'
+require 'announce/railtie' if defined?(Rails)
 
 module Announce
   class << self
@@ -14,6 +15,8 @@ module Announce
       adapter_class.publish(subject, action, message, options)
     end
 
+    alias announce publish
+
     def subscribe(worker_class, subject, actions = [], options = {})
       adapter_class.subscribe(worker_class, subject, actions, options)
     end
@@ -23,7 +26,7 @@ module Announce
     end
 
     def options
-      @options ||= default_options
+      @options ||= Announce::Configuration.default_options
     end
 
     def configure(opts = {})
@@ -31,24 +34,10 @@ module Announce
       yield @options if block_given?
     end
 
-    def default_options
-      {}.tap do |defaults|
-        if defined?(ActiveJob)
-          defaults[:name_prefix] = ::ActiveJob::Base.queue_name_prefix
-          defaults[:name_delimiter] = ::ActiveJob::Base.queue_name_delimiter
-          defaults[:adapter] = ::ActiveJob::Base.queue_adapter
-        else
-          defaults[:name_prefix] = ENV['RAILS_ENV'] || ENV['APP_ENV'] || 'development'
-          defaults[:name_delimiter] = '_'
-          defaults[:adapter] = :inline
-        end
-      end
-    end
-
     def adapter_class
-      adapter = Announce.options[:adapter]
-      require "announce/adapters/#{adapter}_adapter"
-      "::Announce::Adapters::#{adapter.to_s.camelize}Adapter".constantize
+      announce_adapter = Announce.options[:adapter]
+      require "announce/adapters/#{announce_adapter.to_s.downcase}_adapter"
+      "::Announce::Adapters::#{announce_adapter.to_s.camelize}Adapter".constantize
     end
 
     def logger

data/lib/announce/adapters/base_adapter.rb

@@ -63,7 +63,7 @@ module Announce
         end
 
         def self.name_for(subject, action)
-          [prefix, subject, action].join(delimiter)
+          [prefix, namespace, subject, action].join(delimiter)
         end
 
         def initialize(subject, action, options = {})
@@ -77,16 +77,20 @@ module Announce
         end
 
         def self.prefix
-          ::Announce.options[:name_prefix]
+          ::Announce.options[:queue_name_prefix]
         end
 
         def self.delimiter
-          ::Announce.options[:name_delimiter]
+          ::Announce.options[:queue_name_delimiter]
         end
 
         def self.app
           ::Announce.options[:app_name]
         end
+
+        def self.namespace
+          ::Announce.options[:namespace]
+        end
       end
 
       class Topic < Destination
@@ -94,7 +98,7 @@ module Announce
 
       class Queue < Destination
         def self.name_for(subject, action)
-          [prefix, app, subject, action].join(delimiter)
+          [prefix, namespace, app, subject, action].join(delimiter)
         end
       end
     end

data/lib/announce/adapters/shoryuken_adapter.rb

@@ -5,41 +5,75 @@ module Announce
   module Adapters
     class ShoryukenAdapter < BaseAdapter
 
+      class AnnounceWorker #:nodoc:
+        include Shoryuken::Worker
+
+        shoryuken_options body_parser: :json, auto_delete: true
+
+        # overriden in register_class
+        def job_class
+        end
+
+        def perform(sqs_msg, hash)
+          job = job_class.new(hash)
+          Base.execute(job.serialize)
+        end
+      end
+
       class Subscriber < BaseAdapter::Subscriber
+
         def subscribe(worker_class, subject, actions, options)
           Array(actions).each do |action|
             queue_name = Queue.name_for(subject, action)
-            Shoryuken.register_worker(queue_name, worker_class, true)
+            Shoryuken.register_worker(queue_name, register_class(worker_class))
+            Shoryuken.queues << queue_name
           end
         end
+
+        def register_class(worker_class)
+          if active_job?
+            Class.new(AnnounceWorker).tap do |jc|
+              jc.class_eval("def job_class; #{worker_class.name}; end")
+            end
+          else
+            worker_class
+          end
+        end
+
+        def active_job?
+          defined?(::ActiveJob) &&
+          defined?(ActiveJob::QueueAdapters::ShoryukenAdapter) &&
+          ActiveJob::Base.queue_adapter == ActiveJob::QueueAdapters::ShoryukenAdapter
+        end
       end
 
       class BrokerManager < BaseAdapter::BrokerManager
 
         # actually configure the broker queues, topics, and subscriptions
         def configure
-          configure_publishing
-          configure_subscribing
+          configure_publishing && configure_subscribing
         end
 
         def configure_publishing
           (options[:publish] || {}).each do |subject, actions|
             Array(actions).each do |action|
-              Announce::Adapter::ShoryukenAdapter::Topic(subject, action, options).create
+              ShoryukenAdapter::Topic.new(subject, action, options).create
             end
           end
+          true
         end
 
         def configure_subscribing
           (options[:subscribe] || {}).each do |subject, actions|
             Array(actions).each do |action|
-              topic = Announce::Adapter::ShoryukenAdapter::Topic(subject, action, options)
-              queue = Announce::Adapter::ShoryukenAdapter::Queue(subject, action, options)
+              topic = ShoryukenAdapter::Topic.new(subject, action, options)
+              queue = ShoryukenAdapter::Queue.new(subject, action, options)
               topic.create
               queue.create
               topic.subscribe(queue)
             end
           end
+          true
         end
       end
 
@@ -110,7 +144,7 @@ module Announce
           )
 
           attrs = sqs.get_queue_attributes(
-            queue_url: dlq.queue_url,
+            queue_url: dlq[:queue_url],
             attribute_names: ['QueueArn']
           )
 
@@ -157,58 +191,8 @@ module Announce
           Shoryuken::Client.sqs
         end
       end
-
-      class AnnounceWorker #:nodoc:
-        include Shoryuken::Worker
-
-        attr_accessor :job_class
-
-        shoryuken_options body_parser: :json, auto_delete: true
-
-        def perform(sqs_msg, hash)
-          job = job_class.new(hash)
-          Base.execute(job.serialize)
-        end
-      end
-
-      class AnnounceWorkerRegistry < Shoryuken::DefaultWorkerRegistry
-
-        attr_accessor :subscriptions
-
-        def initialize
-          super
-          @subscribers = {}
-        end
-
-        def clear
-          super
-          @subscribers.clear
-        end
-
-        def fetch_worker(queue, message)
-          super.tap do |worker|
-            if @subscribers[queue] && worker.respond_to?('job_class=')
-              worker.job_class = @subscribers[queue]
-            end
-          end
-        end
-
-        def register_worker(queue, clazz, subscription = false)
-          if subscription && active_job?
-            @subscribers[queue] = clazz
-            clazz = AnnounceWorker
-          end
-          super(queue, clazz)
-        end
-
-        def active_job?
-          defined?(::ActiveJob) && ::ActiveJob::Base.queue_adapter.to_s == 'shoryuken'
-        end
-      end
-
     end
   end
 end
 
-Shoryuken.worker_registry = Announce::Adapters::ShoryukenAdapter::AnnounceWorkerRegistry.new
 Shoryuken::Client.account_id = ENV['AWS_ACCOUNT_ID'] unless Shoryuken::Client.account_id

data/lib/announce/configuration.rb

@@ -5,27 +5,50 @@ module Announce
   class Configuration
     attr_reader :options
 
-    def self.configure(options={})
+    def self.configure(options = {})
       opts = new(options).configure
       Announce.options.merge!(opts)
     end
 
+    def self.default_options
+      {}.tap do |defaults|
+        if defined?(ActiveJob)
+          defaults[:queue_name_prefix] = ::ActiveJob::Base.queue_name_prefix
+          defaults[:queue_name_delimiter] = ::ActiveJob::Base.queue_name_delimiter
+          defaults[:adapter] = aj_queue_adapter_name
+        else
+          defaults[:queue_name_prefix] = ENV['RAILS_ENV'] || ENV['APP_ENV'] || 'development'
+          defaults[:queue_name_delimiter] = '_'
+          defaults[:adapter] = :inline
+        end
+
+        defaults[:app_name] = 'app'
+        defaults[:namespace] = 'announce'
+      end
+    end
+
+    def self.aj_queue_adapter_name
+      ajqa = ::ActiveJob::Base.queue_adapter.name
+      ajqa.match(/ActiveJob::QueueAdapters::(.*)Adapter/)[1].underscore
+    end
+
     def initialize(options)
       @options = options
       base = defined?(Rails) ? Rails.root : Dir.pwd
-      options[:pub_sub_file] ||= File.join(base, 'config', 'pub_sub.yml')
+      options[:config_file] ||= File.join(base, 'config', 'announce.yml')
     end
 
-    def pub_sub_file
-      options[:pub_sub_file]
+    def config_file
+      options[:config_file]
     end
 
     def configure
-      if File.exist?(pub_sub_file)
-        YAML.load(ERB.new(IO.read(pub_sub_file)).result).deep_symbolize_keys
+      defaults = self.class.default_options
+      if File.exist?(config_file)
+        defaults.merge(YAML.load(ERB.new(IO.read(config_file)).result).symbolize_keys)
       else
-        Announce.logger.warn "PubSub file #{pub_sub_file} does not exist"
-        {}
+        Announce.logger.warn "PubSub file #{config_file} does not exist"
+        defaults
       end
     end
   end

data/lib/announce/core_ext.rb

@@ -49,9 +49,7 @@ rescue LoadError
       end
       constant
     end
-  end if !"".respond_to?(:constantize)
 
-  class String
     def camelize
       string = self
       string = string.sub(/^[a-z\d]*/) { $&.capitalize }
@@ -59,5 +57,16 @@ rescue LoadError
       string.gsub!(/\//, '::')
       string
     end
-  end if !"".respond_to?(:camelize)
+
+    def underscore
+      camel_cased_word = self
+      return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+      word = camel_cased_word.to_s.gsub(/::/, '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end if !"".respond_to?(:constantize)
 end

data/lib/announce/publisher.rb

@@ -7,5 +7,7 @@ module Announce
     def publish(subject, action, body, options = {})
       Announce.publish(subject, action, body, options)
     end
+
+    alias announce publish
   end
 end

data/lib/announce/railtie.rb

@@ -0,0 +1,8 @@
+module Announce
+  class Railtie < Rails::Railtie
+
+    rake_tasks do
+      load "tasks/announce.rake"
+    end
+  end
+end

data/lib/announce/subscriber.rb

@@ -1,5 +1,3 @@
-# let's see if we can use active_job for this...
-
 module Announce
   module Subscriber
 

data/lib/announce/version.rb

@@ -1,3 +1,3 @@
 module Announce
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/tasks/announce.rake

@@ -0,0 +1,8 @@
+namespace :announce do
+
+  desc 'Configure the broker destinations'
+  task :configure_broker => [:environment] do |t, args|
+    Announce.configure
+    Announce.configure_broker
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: announce
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kuklewicz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-08 00:00:00.000000000 Z
+date: 2015-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoryuken
@@ -122,20 +122,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -193,8 +179,10 @@ files:
 - lib/announce/core_ext.rb
 - lib/announce/message.rb
 - lib/announce/publisher.rb
+- lib/announce/railtie.rb
 - lib/announce/subscriber.rb
 - lib/announce/version.rb
+- lib/tasks/announce.rake
 homepage: https://github.com/PRX/announce
 licenses:
 - MIT