protobuf 2.8.8 → 2.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f0351f3d7c48646bd2e1bba944dd1713c5c3363
-  data.tar.gz: 1981e09677be1653d8a9330ec4cdc3467212a9a7
+  metadata.gz: 730f8de122b9b6b07a5fcf1be77f6af48647279a
+  data.tar.gz: 5a0a5aacf4099da045ea560e538f45030f6dee78
 SHA512:
-  metadata.gz: 25dbafddcde80787c44fe38651fc499016310099aeaead2de6b018443390137dafb311b840318310ef117360e5086780aa93fa88f405793aa2edf21c9b8aa197
-  data.tar.gz: 520bb7c6ad6372c560c77d6f4ee9eebb4067b60955c152242527dd8c29e878a3cca29378afa4e10a93d69adab6121737b666b04bfd5538ac5239ec3ca4d1d23d
+  metadata.gz: 39211c5a2c882445549d99111dd4d50b3456221e752c5dfcffa2033e98e82b8564d543de452d0f9357efd941b22f846a6a6188e55b2129414d141faf4cf9058f
+  data.tar.gz: 38dd648c17492ffd2510c9cca5a96532d73f529271fe4e80f49605da652e9804f77c9594a6d5f8f3842091d27bc68c6ee80879822a89512f9ec6a0cd3de674c6

data/CHANGES.md

@@ -1,3 +1,10 @@
+2.8.9
+---------
+
+- Deprecated Protobuf::Lifecycle module in favor of using ActiveSupport::Notifications. [#139, @devin-c]
+- Modify `$LOAD_PATH` inside descriptors.rb to make it easier for other libraries to write their own compiler plugins using our pre-compiled descriptors. [#141, @localshred]
+- Add protobuf:clean and protobuf:compile rake tasks for use in external libraries to compile source definitions to a destination. [#142, @localshred]
+
 2.8.8
 ---------
 

data/README.md

@@ -2,468 +2,30 @@
 
 [![Gem Version](https://badge.fury.io/rb/protobuf.png)](http://badge.fury.io/rb/protobuf)
 [![Build Status](https://secure.travis-ci.org/localshred/protobuf.png?branch=master)](https://travis-ci.org/localshred/protobuf)
-
-___See [CHANGES.md](https://github.com/localshred/protobuf/blob/master/CHANGES.md) or [Release Notes](https://github.com/localshred/protobuf/releases) for significant version changes.___
+[![Gitter chat](https://badges.gitter.im/localshred/protobuf.png)](https://gitter.im/localshred/protobuf)
 
 Protobuf is an implementation of [Google's protocol buffers][google-pb] in ruby, version 2.5.0 is currently supported.
 
----
-
 ## Install
 
-You will need to install protobuf from your favorite package manager
-or from source. This gem currently supports protobuf <= 2.5.0.
-
-### OSX Install
-
-```shell
-$ brew install protobuf
-```
-
-### Ubuntu
-```shell
-$ sudo apt-get install -y protobuf
-```
-
-### Gem Install
-
-Once the protobuf package is installed, install this gem with rubygems/bundler.
-_Please note that this will void your warranty as it were. If you compiled with
-a custom protobuf package and are having issues it may be difficult to troubleshoot._
-
-```shell
-$ gem install protobuf
-```
-
-------
-
-## Generating ruby classes from `.proto` files
-
-Protocol Buffers are great because they allow you to clearly define data storage
-or data transfer packets. Google officially supports Java, C++, and Python for
-compilation and usage. Let's make it ruby aware!
-
-Let's say you have a `defs.proto` file that defines a User message.
-
-```protobuf
-package foo;
-message User {
-  optional string first_name = 1;
-  optional string last_name = 2;
-}
-```
-
-Now let's compile that definition to ruby:
-
-```shell
-$ protoc defs.proto --ruby_out ./lib
-```
-
-The previous line will take whatever is defined in `defs.proto` and
-output ruby classes to the `./lib` directory, obeying the package
-directive. Your `./lib` should now look like this:
-
-```
-- lib
-  |- foo
-      |- defs.pb.rb
-```
-
-The generated file `defs.pb.rb` should look something like this:
-
-```ruby
-module Foo
-  class User < ::Protobuf::Message; end
-
-  class User
-    optional ::Protobuf::Field::StringField, :first_name, 1
-    optional ::Protobuf::Field::StringField, :last_name, 2
-  end
-end
-```
-
-__Note:__ The generator will pre-define all message/enum classes empty and then
-re-open to apply the defined fields. This is to prevent field dependency errors.
-
-The generated class is now just a plain old ruby object. You can use it however you wish.
-
-```ruby
-require 'lib/foo/user.pb'
-
-# dot notation reading/writing fields
-user = Foo::User.new
-user.first_name = "Lloyd"
-user.last_name = "Christmas"
-user.first_name     # => "Lloyd"
-
-# or pass in the fields as a hash to the initializer
-user = Foo::User.new :first_name => "Lloyd", :last_name => "Christmas"
-user.first_name     # => Lloyd
-user.last_name     # => Christmas
-```
-
-### Message (de)serialization
-
-Every message object comes ready for serialization or deserialization.
-Use `serialize_to_string` to write out the byte-string for the message.
-Use `parse_from_string` on a new message instance to inflate the
-byte-string back to a message in ruby.
-
-```ruby
-user = Foo::User.new(:first_name => 'Bob')
-bytes = user.serialize_to_string
-puts bytes #=> binary representation of this message object
-
-inflated_user = Foo::User.new.parse_from_string(bytes)
-inflated_user == user #=> true
-```
-
-## Callings Services with RPC
-
-Google's Protocol Buffers provides support for Services with RPC.
-
-For our purposes, we'll talk about a `Client` (process that is calling
-the server/service), a `Service` (the remote procedure), and a `Server`
-(the process that manages one or more services). We'll start with the Service first.
-
-### Services
-
-Services are simply classes that have endpoint methods defined. Here's what
-one looks like in protobuf:
-
-```protobuf
-package foo;
-message UserRequest {
-  optional string email = 1;
-}
-message UserList {
-  repeated User users = 1;
-}
-service UserService {
-  rpc Find (UserRequest) returns (UserList);
-}
-```
-
-And the equivalent ruby stub for the service (generated with `rprotoc`):
-
-```ruby
-# lib/foo/user.pb.rb
-module Foo
-  # UserRequest and UserList Class definitions not shown (see above for generated output of classes).
-
-  class UserService < ::Protobuf::Rpc::Service
-    rpc :find, UserRequest, UserList
-  end
-end
-```
-
-__Important Note: The UserService class here is a *stub*. You should not
-provide your implementation in this generated file as subsequent generations
-will wipe out your implmentation. Read on to learn how to use this stub.__
-
-Now that you have a generated service stub, you'll want to require it
-from `lib` and provide the implementation. Create a service implementation file
-in your project. In rails I'd put this in `app/services/foo/user_service.rb`.
-
-```ruby
-# app/services/foo/user_service.rb
-require 'lib/foo/user.pb'
-
-# Reopen the class and provide the implementation for each rpc method defined.
-module Foo
-  class UserService
-
-    # request -> Foo::UserRequest
-    # response -> Foo::UserResponse
-    def find
-      # request.email will be the unpacked string that was sent by the client request
-      users = []
-      User.find_by_email(request.email).each do |user|
-        users << user.to_proto
-      end
-      
-      respond_with(:users => users)
-    end
-
-  end
-end
-```
-
-Simply implement the instance method for the defined rpc. You can provide
-any other methods in this class as helpers, but only those defined in the
-proto file will be callable by remote clients. Every request made by a client
-will provide a non-empty request of the defined type. The server creates a new
-service instance for every request, so you should not be constrained to just
-the endpoint method. This is similar to rails controllers where only methods
-defined by the routes file are hooked up to HTTP requests, but it's very common
-to implement private methods to aid in code quality and simpilicity.
-
-Every instance has a `request` and `response` object used for fulfilling the call,
-again, similar to a rails controller action. You should never attempt to modify the
-`request` object. The `response` object however should be modified or replaced
-entirely. If you need to create your own response object (a valid case), simply use
-`respond_with(new_response)`. The returned object should conform to one of three properties:
-
-1. Response should be of same type as defined by the rpc definition (in this case, `Foo::UserList`), or
-2. Response should be a hash, respond to `to_hash`, or respond to `to_proto_hash`. The hash will be used to construct an instance of the defined type and should therefore conform to the appropriate fields for that type.
-3. Response should respond to the `to_proto` method. The object returned by `to_proto` should be an instance of the defined response type.
-
-If at any time the implementation encounters an error, the client can be
-instructed of the error using `rpc_failed`:
-
-```ruby
-#...
-def find
-  if request.email.blank?
-    rpc_failed 'Unable to find user without an email'
-  else
-    # query/populate response
-  end
-end
-#...
-```
-
-This means that the client's `on_failure` callback will be invoked instead
-of the `on_success` callback. Read more below on client callbacks. One drawback
-to the `rpc_failed` approach is that it does not short-circuit the rest of
-the method. This means that you must explicitly return from the method if
-you do not wish the remainder to be executed.
-
-### Service Filters
-
-Service Filters provides ActionController-style filter support to service
-instances, specifically adding `before_filter`, `after_filter`, and `around_filter`.
-
-```ruby
-require 'lib/foo/user.pb'
-
-class Foo::UserService
-  before_filter :start_request_timer
-  after_filter :end_request_timer
-  around_filter :benchmark_request
-
-  # Provide a list of rpc methods to call (or exclude calling) for the given filter(s).
-  # The following two filters are essentially equivalent.
-  before_filter :verify_user_present, :only => [ :update, :delete ]
-  before_filter :verify_user_present, :except => [ :find, :create ]
-
-  # Using if/unless filters options to achieve the same goal, reporting a login after the login has been processed.
-  # Note that you can provide a method name or lambda, but you must return a boolean value.
-  after_filter :report_login, :only => :login, :if => :user_found?
-  after_filter :report_login, :only => :login, :if => lambda { |service| service.response.user_guid.present? }
-  after_filter :report_login, :only => :login, :unless => :user_missing?
-  after_filter :report_login, :only => :login, :unless => lambda { |service| service.response.user_guid.empty? }
-
-  #... rpc instance methods
-
-  private
-
-  def start_request_timer
-    @time_start = Time.now
-  end
-
-  def end_request_timer
-    @time_end = Time.now
-    log_info { ... }
-  end
-
-  def benchmark_request
-    Benchmark.benchmark do
-      yield
-    end
-  end
-end
-```
-
-#### Halting execution of rpc request inside a filter
-
-__Around Filters__ – Inside of an around filter, if you wish to halt
-request processing and return, simply do not `yield` the block. Since the
-filter is implemented as an instance method, you can use `rpc_failed`
-or `respond_with` just like you can in the endpoint methods.
-
-__Before Filters__ – Returning `false` from a before filter will cancel
-any other filter calls which would run afterwards, as well as canceling
-invocation of the service method. _Note: You must actually return `false`,
-not just a "falsey" value such as `nil`._
-
-__After Filters__ – No request shortcutting.
-
-#### Filter options
-
-The following options can be applied to any of the filters as the final
-argument in the filter configuration. (See example above).
-
-__:if__ – The object supplied to `:if` can either be a symbol/string
-indicating the instance method to call, or, an object that responds to `call`.
-The method or callable should return true or false indicating if the
-filter should be invoked or not. Akin to the `if` keyword.
-
-__:unless__ – The opposite of the `:if` option is `:unless`. Accepts
-the same object types. The method or callable should return true or
-false indicating if the filter should be invoked or not. Akin to the
-`unless` keyword.
-
-__:only__ – A string/symbol or Array of strings/symbols values that
-reference instance methods. The names of these methods should be the
-rpc method you wish to invoke the filter for. Methods not identified
-in this list would not have the filter applied.
-
-__:except__ – The opposite of the `:only` option. A string/symbol or
-Array of strings/symbols values that reference instance methods. The
-names of these methods should be the rpc method you wish to skip
-invokation of the given filter. Methods not identified in this list
-would have the filter applied.
-
-### Servers
-
-Services need to be hooked up to a socket to be called by clients.
-Use the provided program `rpc_server`:
-
-```
-$ rpc_server -o myserver.com -p 9399 -l ./log/protobuf.log ./config/environment.rb
-```
-
-The previous call will start a Socket server running on the given
-host and port which will load your application into memory. You
-certainly don't have to run rails or any other framework, just
-make sure you have some kind of file that will load your services
-all into memory. The server doesn't know where you put your code,
-so tell it.
-
-Be aware that the server needs to be able to translate the socket
-stream of bytes into an actual protobuf request object. If the
-definition for that request object aren't known to the server,
-you're going to have a long day getting this going. It's necessary
-to store all your definitions and their generated classes in a
-shared repository (read: gem) so that both client and server have
-access to the ruby classes in their respective load paths.
-
-Once the server starts, you should see it as a running process
-with `ps`. Sending a KILL, QUIT, or TERM signal to the pid will
-result in shutting the server down gracefully.
-
-```
-$ ps aux | grep rpc_server
-1234 ... rpc_server myserver.com:9399
-
-$ kill -QUIT 1234
-rpc_server shutdown
-```
-
-### Clients
-
-Calling a service with a clients feels very ajaxy. If you prefer
-a simpler syntax I highly recommend using [ActiveRemote](https://github.com/liveh2o/active_remote)
-which was developed in conjunction with this library to make 
-interacting with a remote service feel identical to using an
-ActiveRecord model. Seriously, it's wicked cool.
-
-```ruby
-# require the defs from the shared gem/repo
-require 'sharedgem/foo/user.pb'
-
-# Create a request object for the method we are invoking
-req = Foo::UserRequest.new(:email => 'jeff@gmail.com')
-
-# Use the UserService class to generate a client, invoke the rpc method
-# while passing the request object.
-# We could also simply pass a hash to find.
-Foo::UserService.client.find(req) do |client|
-  # This block will be executed (registering the callbacks)
-  # before the request actualy occurs.
-  # the `client` param in this block is the object
-  # that is created by `Foo::UserService.client`.
-
-  # Register a block for execution when the response
-  # is deemed successful from the service. Accepts
-  # the unpacked response as its only parameter.
-  c.on_success do |response|
-    response.users.each do |user|
-      puts user.inspect
-    end
-  end
-
-  # Register a block for execution when the response
-  # is deemed a failure. This can be either a client-side
-  # or server-side failure. The object passed to the
-  # block has a `message` and a `code` attribute
-  # to aid in logging/diagnosing the failure.
-  c.on_failure do |error|
-    puts 'It failed: ' + error.message
-  end
-end
-```
-
-Many different options can be passed to the `.client` call above
-(such as `:timeout => 600`). See the `lib/protobuf/rpc/client.rb`
-and `lib/protobuf/rpc/service.rb` files for more documentation.
-
-### Dynamic Service Discovery (ZMQ Only)
-It is possible to setup the RPC server and client in a way that
-allows servers/services to be dynamically discovered by client processes.
-
-#### In the client
-```ruby
-ServiceDirectory.start do |config|
-  config.port = 53000
-end
-
-# If your server also runs this code, it will default to the
-# given port when sending beacons and have its own service
-# directory. You can prevent this code from running on the
-# server if needed:
-unless defined?(::Protobuf::CLI)
-  ServiceDirectory.start do |config|
-    config.port = 53000
-  end
-end
-```
-
-#### Starting the server with dynamic discovery enabled
-```
-$ rpc_server --broadcast-beacons --beacon-port 53000 ...
-```
-
-The client will listen on the specified port for beacons broadcast
-by servers. Each beacon includes a list of services provided by the
-broadcasting server. The client randomly selects a server for the
-desired service each time a request is made.
-
-__CAUTION:__ When running multiple environments on a single network,
-e.g., qa and staging, be sure that each environment is setup with
-a unique beacon port; otherwise, clients in one environment ___will___
-make requests to servers in the other environment.
-
-Check out the source for Protobuf::ServiceDirectory for more details.
-
-## 3. RPC Interop
-
-The main reason I wrote this gem was to provide a ruby implementation
-to google's protobuf that worked on the RPC layer with a Java Service
-layer that was already running [protobuf-socket-rpc][], the supported
-socket rpc library for protobuf from Google. Other ruby protobuf
-implementations I've used did not provide this kind of support.
+See our [Installation Guide][] on the [wiki][].
 
-## Accreditation & Caveats
+## Usage
 
-It must be noted that this gem was started originally as a fork of
-the [ruby-protobuf][old gem] gem. Its authors and I were unable to
-reach a communication point to be able to merge all of my RPC updates
-in with their master. Unfortunately I just simply couldn't use their
-RPC code and so I forked the code. Myself and others have significantly
-changed the internals of the gem, including the rpc implementation, the
-message/field implementation, and the compiler implementation. These
-changes were made to address glaring performance and quality issues
-in the code. The code was initially diverged at their 0.4.0 version.
+The [wiki][] contains in-depth guides on the various ways to use this gem
+including [compiling defintions][], [object APIs][], [services][], [clients][], and even
+an [API roadmap][].
 
-It should also be noted that there are many more features I haven't
-really shown here, so please let me know if you have any questions
-on usage or support for various features. Happy protobufing.
+## Changelog
 
--- BJ Neilsen, [@localshred][]
+See recent changes in the [release notes][] or the [changelog][].
 
   [google-pb]: http://code.google.com/p/protobuf "Google Protocol Buffers"
-  [protobuf-socket-rpc]: http://code.google.com/p/protobuf-socket-rpc/ "Google's official Socket-RPC library for protobuf"
-  [old gem]: https://github.com/macks/ruby-protobuf "Macks ruby-protobuf on github"
-  [@localshred]: http://twitter.com/localshred "Follow on twitter @localshred"
+  [wiki]: https://github.com/localshred/protobuf/wiki/Protobuf-Wiki "Protobuf Wiki"
+  [compiling definitions]: https://github.com/localshred/protobuf/wiki/Compiling-Definitions "Compiling definitions"
+  [object APIs]: https://github.com/localshred/protobuf/wiki/Messages-&-Enums "Message & Enum object APIs"
+  [services]: https://github.com/localshred/protobuf/wiki/Services "Services object API"
+  [clients]: https://github.com/localshred/protobuf/wiki/Clients "Client object API"
+  [API roadmap]: https://github.com/localshred/protobuf/wiki/API-Roadmap "API Roadmap"
+  [release notes]: https://github.com/localshred/protobuf/releases "CHANGES.md"
+  [changelog]: https://github.com/localshred/protobuf/blob/master/CHANGES.md "CHANGES.md"

data/Rakefile

@@ -13,3 +13,10 @@ task :default => :spec
 
 desc "Run specs"
 RSpec::Core::RakeTask.new(:spec)
+
+task :console do
+  require 'pry'
+  require 'protobuf'
+  ARGV.clear
+  ::Pry.start
+end

data/bin/protoc-gen-ruby

@@ -7,16 +7,7 @@ ENV['PB_NO_NETWORKING'] = '1'
 
 $LOAD_PATH << ::File.expand_path("../../lib", __FILE__)
 require 'protobuf'
-
-# Setup the loadpath so that plugin.pb will
-# be able to require the descriptor.pb file.
-#
-$LOAD_PATH << ::File.expand_path("../../lib/protobuf/descriptors", __FILE__)
-require 'google/protobuf/compiler/plugin.pb'
-
-# Read the request bytes from STDIN, pass to the CodeGenerator, and
-# write to STDOUT the generated response_bytes.
-#
+require 'protobuf/descriptors'
 require 'protobuf/code_generator'
 
 request_bytes = STDIN.read

data/lib/protobuf.rb

@@ -4,6 +4,7 @@ require 'pp'
 require 'stringio'
 require 'active_support/core_ext/object/blank'
 require 'active_support/version'
+require 'active_support/notifications'
 
 if ActiveSupport::VERSION::MAJOR > 2
   require 'active_support/core_ext/object/try'

data/lib/protobuf/cli.rb

@@ -1,6 +1,5 @@
 require 'thor'
 require 'protobuf/version'
-require 'protobuf/lifecycle'
 require 'protobuf/logger'
 require 'protobuf/rpc/servers/evented_runner'
 require 'protobuf/rpc/servers/socket_runner'
@@ -244,7 +243,7 @@ module Protobuf
             "pid #{::Process.pid} -- #{@runner_mode} RPC Server listening at #{options.host}:#{options.port}"
           }
 
-          ::Protobuf::Lifecycle.trigger( "after_server_bind" )
+          ::ActiveSupport::Notifications.instrument("after_server_bind")
         end
       end
     end

data/lib/protobuf/descriptors.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH << ::File.expand_path("../descriptors", __FILE__)
+require 'google/protobuf/descriptor.pb'
+require 'google/protobuf/compiler/plugin.pb'

data/lib/protobuf/lifecycle.rb

@@ -1,26 +1,35 @@
 module Protobuf
   class Lifecycle
+    include ::Protobuf::Logger::LogMethods
 
     def self.register( event_name, &blk )
       raise "Lifecycle register must have a block" unless block_given?
+
       event_name = normalized_event_name( event_name )
 
-      lifecycle_events[ event_name ] ||= []
-      lifecycle_events[ event_name ] << blk
+      if ::Protobuf.print_deprecation_warnings?
+        $stderr.puts <<-ERROR
+            [DEPRECATED] ::Protobuf::Lifecycle has been deprecated and will be removed in a future version.
+                         Use ::ActiveSupport::Notifications.subscribe('#{event_name}')
+        ERROR
+      end
+
+      ::ActiveSupport::Notifications.subscribe(event_name) do |name, start, finish, id, args|
+        blk.call(*args)
+      end
     end
 
     def self.trigger( event_name, *args )
+      if ::Protobuf.print_deprecation_warnings?
+        $stderr.puts <<-ERROR
+            [DEPRECATED] ::Protobuf::Lifecycle has been deprecated and will be removed in a future version.
+                         Use ::ActiveSupport::Notifications.instrument(...)
+        ERROR
+      end
+
       event_name = normalized_event_name( event_name )
 
-      if lifecycle_events.has_key?( event_name )
-        lifecycle_events[ event_name ].each do |block|
-          if ! args.empty? && block.arity != 0
-            block.call(*args)
-          else
-            block.call
-          end
-        end
-      end
+      ::ActiveSupport::Notifications.instrument(event_name, args)
     end
 
     def self.normalized_event_name( event_name )

data/lib/protobuf/rpc/service_directory.rb

@@ -5,7 +5,6 @@ require 'set'
 require 'thread'
 require 'timeout'
 
-require 'protobuf/lifecycle'
 require 'protobuf/rpc/dynamic_discovery.pb'
 
 module Protobuf
@@ -239,7 +238,7 @@ module Protobuf
       end
 
       def trigger(action, listing)
-        ::Protobuf::Lifecycle.trigger("directory.listing.#{action}", listing)
+        ::ActiveSupport::Notifications.instrument("directory.listing.#{action}", :listing => listing)
       end
     end
   end

data/lib/protobuf/tasks.rb

@@ -0,0 +1 @@
+load 'protobuf/tasks/compile.rake'

data/lib/protobuf/tasks/compile.rake

@@ -0,0 +1,58 @@
+require 'fileutils'
+
+namespace :protobuf do
+
+  desc 'Clean & Compile the protobuf source to ruby classes. Pass PB_NO_CLEAN=1 if you do not want to force-clean first.'
+  task :compile, [ :package, :source, :destination, :plugin ] do |tasks, args|
+    args.with_defaults(:destination => 'lib')
+    args.with_defaults(:source => 'definitions')
+    args.with_defaults(:plugin => 'ruby')
+
+    unless do_not_clean?
+      force_clean!
+      ::Rake::Task[:clean].invoke(args[:package], args[:destination])
+    end
+
+    command = []
+    command << "protoc"
+    command << "--#{args[:plugin]}_out=#{args[:destination]}"
+    command << "-I #{args[:source]}"
+    command << "#{args[:source]}/#{args[:package]}/*.proto"
+    command << "#{args[:source]}/#{args[:package]}/**/*.proto"
+    full_command = command.join(' ')
+
+    puts full_command
+    exec(full_command)
+  end
+
+  desc 'Clean the generated *.pb.rb files from the destination package. Pass PB_FORCE_CLEAN=1 to skip confirmation step.'
+  task :clean, [ :package, :destination ] do |task, args|
+    args.with_defaults(:destination => 'lib')
+
+    files_to_clean = ::File.join(args[:destination], args[:package], '**', '*.pb.rb')
+
+    if force_clean? || permission_to_clean?(files_to_clean)
+      ::Dir.glob(files_to_clean).each do |file|
+        ::FileUtils.rm(file)
+      end
+    end
+  end
+
+  def do_not_clean?
+    ! ::ENV.key?('PB_NO_CLEAN')
+  end
+
+  def force_clean?
+    ::ENV.key?('PB_FORCE_CLEAN')
+  end
+
+  def force_clean!
+    ::ENV['PB_FORCE_CLEAN'] = '1'
+  end
+
+  def permission_to_clean?(files_to_clean)
+    puts "Do you really want to remove files matching pattern #{files_to_clean}? (y/n)"
+    ::STDIN.gets.chomp =~ /y(es)?/i
+  end
+
+end

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.8.8'
+  VERSION = '2.8.9'
   PROTOC_VERSION = '2.5.0'
 end

data/spec/lib/protobuf/cli_spec.rb

@@ -9,13 +9,13 @@ describe ::Protobuf::CLI do
 
   let(:sock_runner) { 
     runner = double("SocketRunner", :register_signals => nil)
-    runner.stub(:run) { ::Protobuf::Lifecycle.trigger( "after_server_bind" ) }
+    runner.stub(:run) { ::ActiveSupport::Notifications.publish( "after_server_bind" ) }
     runner
   }
 
   let(:zmq_runner) { 
     runner = double "ZmqRunner", register_signals: nil
-    runner.stub(:run) { ::Protobuf::Lifecycle.trigger( "after_server_bind" ) }
+    runner.stub(:run) { ::ActiveSupport::Notifications.publish( "after_server_bind" ) }
     runner
   }
 

data/spec/lib/protobuf/lifecycle_spec.rb

@@ -5,23 +5,12 @@ describe ::Protobuf::Lifecycle do
   subject { described_class }
 
   before(:each) do
-    described_class.lifecycle_events = {}
+    ::ActiveSupport::Notifications.notifier = ::ActiveSupport::Notifications::Fanout.new
   end
 
   it "registers a string as the event_name" do
-    expect {
-      subject.register("something") do
-        true
-      end
-    }.to change { subject.lifecycle_events.size }.by(1)
-  end
-
-  it "registers a symbol as the event_name" do
-    expect {
-      subject.register("something") do
-        true
-      end
-    }.to change { subject.lifecycle_events.size }.by(1)
+    ::ActiveSupport::Notifications.should_receive(:subscribe).with("something")
+      subject.register("something") { true }
   end
 
   it "only registers blocks for event callbacks" do

data/spec/lib/protobuf/rpc/service_directory_spec.rb

@@ -56,10 +56,9 @@ describe ::Protobuf::Rpc::ServiceDirectory do
   end
 
   def expect_event_trigger(event)
-    ::Protobuf::Lifecycle
-      .should_receive(:trigger)
-      .with(event,
-            an_instance_of(::Protobuf::Rpc::ServiceDirectory::Listing))
+    ::ActiveSupport::Notifications
+      .should_receive(:instrument)
+      .with(event, hash_including(:listing => an_instance_of(::Protobuf::Rpc::ServiceDirectory::Listing)))
       .once
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 2.8.8
+  version: 2.8.9
 platform: ruby
 authors:
 - BJ Neilsen
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-14 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -193,6 +193,7 @@ files:
 - lib/protobuf.rb
 - lib/protobuf/cli.rb
 - lib/protobuf/code_generator.rb
+- lib/protobuf/descriptors.rb
 - lib/protobuf/descriptors/google/protobuf/compiler/plugin.pb.rb
 - lib/protobuf/descriptors/google/protobuf/descriptor.pb.rb
 - lib/protobuf/enum.rb
@@ -269,6 +270,8 @@ files:
 - lib/protobuf/rpc/service_filters.rb
 - lib/protobuf/rpc/stat.rb
 - lib/protobuf/socket.rb
+- lib/protobuf/tasks.rb
+- lib/protobuf/tasks/compile.rake
 - lib/protobuf/version.rb
 - lib/protobuf/wire_type.rb
 - lib/protobuf/zmq.rb