protobuf 2.1.3 → 2.2.0

data/lib/protobuf/field/bool_field.rb

@@ -16,6 +16,18 @@ module Protobuf
         value == 1
       end
 
+      def define_getter
+        super
+
+        field = self
+        @message_class.class_eval do
+          define_method("#{field.getter_method_name}?") do
+            field.warn_if_deprecated
+            @values.fetch(field.name, field.default_value)
+          end
+        end
+      end
+
       def encode(value)
         [value ? 1 : 0].pack('C')
       end

data/lib/protobuf/message.rb

@@ -6,11 +6,19 @@ require 'protobuf/message/encoder'
 
 module Protobuf
   class Message
-
+    ##
+    # Error Classes
+    #
     class FieldNotDefinedError < StandardError; end
 
+    ##
+    # Constants
+    #
     STRING_ENCODING = "ASCII-8BIT".freeze
 
+    ##
+    # Class Methods
+    #
     def self.all_fields
       @all_fields ||= begin
                         all_fields_array = []
@@ -23,26 +31,6 @@ module Protobuf
                       end
     end
 
-    # Reserve field numbers for extensions. Don't use this method directly.
-    def self.extensions(range)
-      extension_fields.add_range(range)
-    end
-
-    # Define a required field. Don't use this method directly.
-    def self.required(type, name, tag, options = {})
-      define_field(:required, type, name, tag, options)
-    end
-
-    # Define a optional field. Don't use this method directly.
-    def self.optional(type, name, tag, options = {})
-      define_field(:optional, type, name, tag, options)
-    end
-
-    # Define a repeated field. Don't use this method directly.
-    def self.repeated(type, name, tag, options = {})
-      define_field(:repeated, type, name, tag, options)
-    end
-
     # Define a field. Don't use this method directly.
     def self.define_field(rule, type, fname, tag, options)
       field_array = options[:extension] ? extension_fields : fields
@@ -57,8 +45,13 @@ module Protobuf
       field_array[tag] = field_definition
     end
 
-    def self.extension_tag?(tag)
-      extension_fields.include_tag?(tag)
+    # Reserve field numbers for extensions. Don't use this method directly.
+    def self.extensions(range)
+      extension_fields.add_range(range)
+    end
+    
+    def self.extension_field_name_to_tag
+      @extension_fields_by_name ||= {}
     end
 
     # An extension field object.
@@ -66,8 +59,8 @@ module Protobuf
       @extension_fields ||= ::Protobuf::Field::ExtensionFields.new
     end
 
-    def self.extension_field_name_to_tag
-      @extension_fields_by_name ||= {}
+    def self.extension_tag?(tag)
+      extension_fields.include_tag?(tag)
     end
 
     # A collection of field object.
@@ -79,6 +72,18 @@ module Protobuf
       @field_name_to_tag ||= {}
     end
 
+    def self.get_ext_field_by_name(name)
+      # Check if the name has been used before, if not then set it to the sym value
+      extension_fields[extension_field_name_to_tag[name.to_sym]]
+    rescue TypeError, NoMethodError => e
+      name = 'nil' if name.nil?
+      raise FieldNotDefinedError.new("Field '#{name}' is not defined on message '#{self.name}'")
+    end
+
+    def self.get_ext_field_by_tag(tag)
+      extension_fields[tag]
+    end
+
     # Find a field object by +name+.
     def self.get_field_by_name(name)
       # Check if the name has been used before, if not then set it to the sym value
@@ -96,16 +101,19 @@ module Protobuf
       raise FieldNotDefinedError.new("Tag '#{tag}' does not reference a message field for '#{self.name}'")
     end
 
-    def self.get_ext_field_by_name(name)
-      # Check if the name has been used before, if not then set it to the sym value
-      extension_fields[extension_field_name_to_tag[name.to_sym]]
-    rescue TypeError, NoMethodError => e
-      name = 'nil' if name.nil?
-      raise FieldNotDefinedError.new("Field '#{name}' is not defined on message '#{self.name}'")
+    # Define a optional field. Don't use this method directly.
+    def self.optional(type, name, tag, options = {})
+      define_field(:optional, type, name, tag, options)
     end
 
-    def self.get_ext_field_by_tag(tag)
-      extension_fields[tag]
+    # Define a repeated field. Don't use this method directly.
+    def self.repeated(type, name, tag, options = {})
+      define_field(:repeated, type, name, tag, options)
+    end
+
+    # Define a required field. Don't use this method directly.
+    def self.required(type, name, tag, options = {})
+      define_field(:required, type, name, tag, options)
     end
 
     ##
@@ -117,20 +125,11 @@ module Protobuf
       values.each { |name, val| self[name] = val unless val.nil? }
     end
 
-    def initialized?
-      all_fields.all? { |field| field.initialized?(self) }
-    end
-
-    def has_field?(name)
-      @values.has_key?(name)
-    end
-
-    def ==(obj)
-      return false unless obj.is_a?(self.class)
-      each_field do |field, value|
-        return false unless value == obj.__send__(field.name)
-      end
-      true
+    ##
+    # Public Instance Methods
+    #
+    def all_fields
+      self.class.all_fields
     end
 
     def clear!
@@ -145,121 +144,96 @@ module Protobuf
       self
     end
 
-    def dup
-      copy_to(super, :dup)
-    end
-
     def clone
       copy_to(super, :clone)
     end
 
-    def copy_to(object, method)
-      duplicate = proc { |obj|
-        case obj
-        when Message, String then obj.__send__(method)
-        else                      obj
-        end
-      }
+    def dup
+      copy_to(super, :dup)
+    end
 
-      object.__send__(:initialize)
-      @values.each do |name, value|
-        if value.is_a?(Field::FieldArray)
-          object.__send__(name).replace(value.map {|v| duplicate.call(v)})
-        else
-          object.__send__("#{name}=", duplicate.call(value))
-        end
+    # Iterate over a field collection.
+    #   message.each_field do |field_object, value|
+    #     # do something
+    #   end
+    def each_field
+      all_fields.each do |field|
+        value = __send__(field.name)
+        yield(field, value)
       end
-      object
     end
-    private :copy_to
 
-    def inspect
-      to_hash.inspect
+    # Returns extension fields. See Message#fields method.
+    def extension_fields
+      self.class.extension_fields
     end
 
-    def parse_from_string(string)
-      parse_from(StringIO.new(string))
+    def fields
+      self.class.fields
     end
 
-    def parse_from(stream)
-      Decoder.decode(stream, self)
+    def get_ext_field_by_name(name) # :nodoc:
+      self.class.get_ext_field_by_name(name)
     end
 
-    def serialize_to_string(string='')
-      io = StringIO.new(string)
-      serialize_to(io)
-      result = io.string
-      result.force_encoding(::Protobuf::Message::STRING_ENCODING) if result.respond_to?(:force_encoding)
-      result
+    def get_ext_field_by_tag(tag) # :nodoc:
+      self.class.get_ext_field_by_tag(tag)
     end
-    alias to_s serialize_to_string
 
-    def serialize_to(stream)
-      Encoder.encode(stream, self)
+    # Returns field object or +nil+.
+    def get_field_by_name(name)
+      self.class.get_field_by_name(name)
     end
 
-    def set_field(tag, bytes)
-      field = (get_field_by_tag(tag) || get_ext_field_by_tag(tag))
-      field.set(self, bytes) if field
+    # Returns field object or +nil+.
+    def get_field_by_tag(tag)
+      self.class.get_field_by_tag(tag)
     end
 
-    def [](name)
-      if field = get_field_by_name(name) || get_ext_field_by_name(name)
-        __send__(field.name)
-      else
-        raise NoMethodError, "No such field: #{name.inspect}"
-      end
+    def has_field?(name)
+      @values.has_key?(name)
     end
 
-    def []=(name, value)
-      if field = get_field_by_name(name) || get_ext_field_by_name(name)
-        __send__(field.setter_method_name, value)
-      else
-        raise NoMethodError, "No such field: #{name.inspect}"
-      end
+    def initialized?
+      all_fields.all? { |field| field.initialized?(self) }
     end
 
-    # Returns a hash; which key is a tag number, and value is a field object.
-    def all_fields
-      self.class.all_fields
+    def inspect
+      to_hash.inspect
     end
 
-    def fields
-      self.class.fields
+    def parse_from_string(string)
+      parse_from(StringIO.new(string))
     end
 
-    # Returns field object or +nil+.
-    def get_field_by_name(name)
-      self.class.get_field_by_name(name)
+    def parse_from(stream)
+      Decoder.decode(stream, self)
     end
 
-    # Returns field object or +nil+.
-    def get_field_by_tag(tag)
-      self.class.get_field_by_tag(tag)
+    def respond_to_has?(key)
+      self.respond_to?(key) && self.has_field?(key)
     end
 
-    # Returns extension fields. See Message#fields method.
-    def extension_fields
-      self.class.extension_fields
+    def respond_to_has_and_present?(key)
+      self.respond_to_has?(key) && 
+        (self.__send__(key).present? || [true, false].include?(self.__send__(key)))
     end
 
-    def get_ext_field_by_name(name) # :nodoc:
-      self.class.get_ext_field_by_name(name)
+    def serialize_to(stream)
+      Encoder.encode(stream, self)
     end
 
-    def get_ext_field_by_tag(tag) # :nodoc:
-      self.class.get_ext_field_by_tag(tag)
+    def serialize_to_string(string='')
+      io = StringIO.new(string)
+      serialize_to(io)
+      result = io.string
+      result.force_encoding(::Protobuf::Message::STRING_ENCODING) if result.respond_to?(:force_encoding)
+      result
     end
 
-    # Iterate over a field collection.
-    #   message.each_field do |field_object, value|
-    #     # do something
-    #   end
-    def each_field
-      all_fields.each do |field|
-        value = __send__(field.name)
-        yield(field, value)
-      end
+    def set_field(tag, bytes)
+      field = (get_field_by_tag(tag) || get_ext_field_by_tag(tag))
+      field.set(self, bytes) if field
     end
 
     # Return a hash-representation of the given fields for this message type.
@@ -274,11 +248,73 @@ module Protobuf
 
       return result
     end
-    alias_method :to_hash_value, :to_hash
 
     def to_json
       to_hash.to_json
     end
 
+    def ==(obj)
+      return false unless obj.is_a?(self.class)
+      each_field do |field, value|
+        return false unless value == obj.__send__(field.name)
+      end
+      true
+    end
+
+    def [](name)
+      if field = get_field_by_name(name) || get_ext_field_by_name(name)
+        __send__(field.name)
+      else
+        raise NoMethodError, "No such field: #{name.inspect}"
+      end
+    end
+
+    def []=(name, value)
+      if field = get_field_by_name(name) || get_ext_field_by_name(name)
+        __send__(field.setter_method_name, value)
+      else
+        raise NoMethodError, "No such field: #{name.inspect}"
+      end
+    end
+
+    ##
+    # Instance Aliases
+    #
+    alias_method :to_hash_value, :to_hash
+    alias_method :to_s, :serialize_to_string
+    alias_method :responds_to_has?, :respond_to_has?
+    alias_method :respond_to_and_has?, :respond_to_has?
+    alias_method :responds_to_and_has?, :respond_to_has?
+    alias_method :respond_to_has_present?, :respond_to_has_and_present?
+    alias_method :respond_to_and_has_present?, :respond_to_has_and_present?
+    alias_method :respond_to_and_has_and_present?, :respond_to_has_and_present?
+    alias_method :responds_to_has_present?, :respond_to_has_and_present?
+    alias_method :responds_to_and_has_present?, :respond_to_has_and_present?
+    alias_method :responds_to_and_has_and_present?, :respond_to_has_and_present?
+
+    ##
+    # Private Instance Methods
+    #
+    private
+
+    def copy_to(object, method)
+      duplicate = proc { |obj|
+        case obj
+        when Message, String then obj.__send__(method)
+        else                      obj
+        end
+      }
+
+      object.__send__(:initialize)
+      @values.each do |name, value|
+        if value.is_a?(Field::FieldArray)
+          object.__send__(name).replace(value.map {|v| duplicate.call(v)})
+        else
+          object.__send__("#{name}=", duplicate.call(value))
+        end
+      end
+      object
+    end
+
   end
 end

data/lib/protobuf/rpc/server.rb

@@ -22,7 +22,7 @@ module Protobuf
       end
 
       def enable_gc!
-        ::GC.enable if ::Protobuf.gc_pause_server_request?
+        ::GC.enable && ::GC.start if ::Protobuf.gc_pause_server_request?
       end
 
       # no-op, implemented by including class if desired.

data/lib/protobuf/rpc/service_filters.rb

@@ -26,6 +26,20 @@ module Protobuf
           @filters ||= Hash.new { |h,k| h[k] = [] }
         end
 
+        # Filters hash keyed based on filter type (e.g. :before, :after, :around),
+        # whose values are Sets.
+        #
+        def rescue_filters
+          @rescue_filters ||= {}
+        end
+
+        def rescue_from(*ex_klasses, &block)
+          options = ex_klasses.last.is_a?(Hash) ? ex_klasses.pop : {}
+          callable = options.delete(:with) { block }
+          raise ArgumentError, 'Option :with missing from rescue_from options' if callable.nil?
+          ex_klasses.each { |ex_klass| rescue_filters[ex_klass] = callable }
+        end
+
         private
 
         def define_filter(type, filter, options = {})
@@ -146,14 +160,18 @@ module Protobuf
           return ! skip_invoke
         end
 
+        def rescue_filters
+          self.class.rescue_filters
+        end
+
         # Loop over the unwrapped filters and invoke them. An unwrapped filter
         # is either a before or after filter, not an around filter.
         #
         def run_unwrapped_filters(unwrapped_filters, rpc_method, stop_on_false_return = false)
           unwrapped_filters.each do |filter|
             if invoke_filter?(rpc_method, filter)
-              rv = call_or_send(filter[:callable])
-              return false if stop_on_false_return && rv === false
+              return_value = call_or_send(filter[:callable])
+              return false if stop_on_false_return && return_value == false
             end
           end
 
@@ -205,35 +223,41 @@ module Protobuf
         # be used instead of the other run methods directly.
         #
         def run_filters(rpc_method)
-          continue = run_unwrapped_filters(filters[:before], rpc_method, true)
-          if continue
-            run_around_filters(rpc_method)
-            run_unwrapped_filters(filters[:after], rpc_method)
+          run_rescue_filters do
+            continue = run_unwrapped_filters(filters[:before], rpc_method, true)
+            if continue
+              run_around_filters(rpc_method)
+              run_unwrapped_filters(filters[:after], rpc_method)
+            end
+          end
+        end
+
+        def run_rescue_filters
+          if rescue_filters.keys.empty?
+            yield
+          else
+            begin
+              yield
+            rescue *rescue_filters.keys => ex
+              call_or_send(rescue_filters[ex.class], ex)
+            end
           end
         end
 
         # Call the object if it is callable, otherwise invoke the method using
         # __send__ assuming that we respond_to it. Return the call's return value.
         #
-        def call_or_send(callable, &block)
-          rv = case
-               when callable.respond_to?(:call) then
-                 if callable.arity == 1
-                   callable.call(self, &block)
-                 else
-                   callable.call(&block)
-                 end
-               when respond_to?(callable, true) then
-                 if method(callable).arity == 1
-                   __send__(callable, self, &block)
-                 else
-                   __send__(callable, &block)
-                 end
-               else
-                 raise "Object #{callable} is not callable"
-               end
-
-          return rv
+        def call_or_send(callable, *args, &block)
+          return_value = case
+                         when callable.respond_to?(:call) then
+                           callable.call(self, *args, &block)
+                         when respond_to?(callable, true) then
+                           __send__(callable, *args, &block)
+                         else
+                           raise "Object #{callable} is not callable"
+                         end
+
+          return return_value
         end
 
       end

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.1.3'
+  VERSION = '2.2.0'
   PROTOC_VERSION = '2.4.1'
 end

data/spec/lib/protobuf/message_spec.rb

@@ -20,6 +20,78 @@ describe Protobuf::Message do
     end
   end
 
+  describe "boolean predicate methods" do 
+    subject { Test::ResourceFindRequest.new(:name => "resource") }
+
+    it { should respond_to(:active?) }
+
+    it "sets the predicate to true when the boolean value is true" do 
+      subject.active = true
+      subject.active?.should be_true
+    end
+
+    it "sets the predicate to false when the boolean value is false" do 
+      subject.active = false
+      subject.active?.should be_false
+    end
+
+    it "does not put predicate methods on non-boolean fields" do 
+      Test::ResourceFindRequest.new(:name => "resource").should_not respond_to(:name?)
+    end
+  end
+
+  describe "#respond_to_and_has?" do 
+    subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+
+    it "is false when the message does not have the field" do 
+      subject.respond_to_and_has?(:other_field).should be_false
+    end
+
+    it "is true when the message has the field" do 
+      subject.respond_to_and_has?(:non_default_enum).should be_true
+    end
+  end
+
+  describe "#respond_to_has_and_present?" do 
+    subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+
+    it "is false when the message does not have the field" do 
+      subject.respond_to_and_has_and_present?(:other_field).should be_false
+    end
+
+    it "is false when the field is repeated and a value is not present" do 
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+    end
+
+    it "is false when the field is repeated and the value is empty array" do 
+      subject.repeated_enums = []
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+    end
+
+    it "is true when the field is repeated and a value is present" do 
+      subject.repeated_enums = [2]
+      subject.respond_to_and_has_and_present?(:repeated_enums).should be_true
+    end
+
+    it "is true when the message has the field" do 
+      subject.respond_to_and_has_and_present?(:non_default_enum).should be_true
+    end
+
+    context "#API" do 
+      subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
+        
+      it { should respond_to(:respond_to_and_has_and_present?) }
+      it { should respond_to(:responds_to_and_has_and_present?) }
+      it { should respond_to(:responds_to_has?) }
+      it { should respond_to(:respond_to_has?) }
+      it { should respond_to(:respond_to_has_present?) }
+      it { should respond_to(:responds_to_has_present?) }
+      it { should respond_to(:respond_to_and_has_present?) }
+      it { should respond_to(:responds_to_and_has_present?) }
+    end
+   
+  end
+
   describe '#to_hash' do
     context 'generating values for an ENUM field' do
       it 'converts the enum to its tag representation' do

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

@@ -23,10 +23,12 @@ class FilterTest
   def self.clear_filters!
     @defined_filters = nil
     @filters = nil
+    @rescue_filters = nil
   end
 end
 
 describe Protobuf::Rpc::ServiceFilters do
+  let(:params) { {} }
   subject { FilterTest.new(params) }
   after(:each) { FilterTest.clear_filters! }
 
@@ -353,4 +355,97 @@ describe Protobuf::Rpc::ServiceFilters do
     end
   end
 
+  describe '#rescue_from' do
+    before do
+      class CustomError1 < StandardError; end
+      class CustomError2 < StandardError; end
+      class CustomError3 < StandardError; end
+    end
+
+    before do
+      class FilterTest
+        private
+
+        def filter_with_error1
+          @called << :filter_with_error1
+          raise CustomError1, 'Filter 1 failed'
+        end
+
+        def filter_with_error2
+          @called << :filter_with_error2
+          raise CustomError1, 'Filter 2 failed'
+        end
+
+        def filter_with_error3
+          @called << :filter_with_error3
+          raise CustomError3, 'Filter 3 failed'
+        end
+
+        def custom_error_occurred(ex)
+          @ex_class = ex.class
+          @called << :custom_error_occurred
+        end
+      end
+    end
+
+    let(:params) { { :ex_class => nil } }
+
+    context 'when defining multiple errors with a given callback' do
+      before do
+        FilterTest.rescue_from(CustomError1, CustomError2, CustomError3, :with => :custom_error_occurred)
+      end
+      before { FilterTest.before_filter(:filter_with_error3) }
+
+      it 'short-circuits the call stack' do
+        expect {
+          subject.should_not_receive(:endpoint)
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq([ :filter_with_error3, :custom_error_occurred ])
+          subject.ex_class.should eq CustomError3
+        }.to_not raise_error(CustomError3)
+      end
+    end
+
+    context 'when defined with options' do
+      context 'when :with option is not given' do
+        specify do
+          expect { FilterTest.rescue_from(CustomError1) }.to raise_error(ArgumentError, /with/)
+        end
+      end
+
+      context 'when error occurs inside filter' do
+        before { FilterTest.rescue_from(CustomError1, :with => :custom_error_occurred) }
+        before { FilterTest.before_filter(:filter_with_error1) }
+
+        it 'short-circuits the call stack' do
+          expect {
+            subject.should_not_receive(:endpoint)
+            subject.__send__(:run_filters, :endpoint)
+            subject.called.should eq([ :filter_with_error1, :custom_error_occurred ])
+            subject.ex_class.should eq CustomError1
+          }.to_not raise_error(CustomError1)
+        end
+      end
+    end
+
+    context 'when defined with block' do
+      before do
+        FilterTest.rescue_from(CustomError1) do |service, ex|
+          service.ex_class = ex.class
+          service.called << :block_rescue_handler
+        end
+      end
+      before { FilterTest.before_filter(:filter_with_error1) }
+
+      it 'short-circuits the call stack' do
+        expect {
+          subject.should_not_receive(:endpoint)
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq([ :filter_with_error1, :block_rescue_handler ])
+          subject.ex_class.should eq CustomError1
+        }.to_not raise_error(CustomError1)
+      end
+    end
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-08 00:00:00.000000000 Z
+date: 2012-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -516,7 +516,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 324802600983446856
+      hash: 510252424392908935
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -525,7 +525,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 324802600983446856
+      hash: 510252424392908935
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24