protip 0.13.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23c197f44c8f1c1812859e1e7567fb8d0dde9ffb
-  data.tar.gz: 45a759374549ebbe818e89fc958adaf47d199a8c
+  metadata.gz: 59a49ea006074b202ebfd0e2efff1c73aed317c9
+  data.tar.gz: fbd024d6595d62474d21154c00b9a91987ba3f6c
 SHA512:
-  metadata.gz: 7e384ce1be77a5c0eb22052762da2ae105f3b0748025017ed4045db83a663e8ec3620b473a7ca2176b82e1d18685d075d5145bb8d99f17e7705f9d01c0a63f0c
-  data.tar.gz: 1cd15cd584f2d42d8fd5f44205157a6e933dfebda42758ff8ea0c9e2892d2fdec147e397c007763474b9a3a73277a075a978a51e9ed7cef51a5810c4c73aec20
+  metadata.gz: 53ee5dabef500a1987f28573379483168fa1a2ebe1872fc2e5e4cce49be7d3ee867138bfe8076b4ab9ce28fd79c808b6680951fa602783973d8d149b153de9c0
+  data.tar.gz: 5ba932bebcb02f060babaaa8c4afe58e2e722a7f3816adddc61aeae93d632d0702f2e243f9ca0d98ea7b452fb49a0a1b5d088de67e98705bb2d00d58f7e936cc

data/lib/protip/resource.rb

@@ -24,111 +24,18 @@ require 'protip/wrapper'
 
 require 'protip/messages/array'
 
+require 'protip/resource/creatable'
+require 'protip/resource/updateable'
+require 'protip/resource/destroyable'
+require 'protip/resource/extra_methods'
+require 'protip/resource/search_methods'
+
 module Protip
   module Resource
-
-    # Internal handlers for index/show actions. Never use these directly; instead, use `.all` and
-    # `.find` on the resource you're working with, since those methods will adjust their
-    # signatures to correctly parse a set of query parameters if supported.
-    module SearchMethods
-      # Fetch a list from the server at the collection's base endpoint. Expects the server response
-      # to be an array containing encoded messages that can be used to instantiate our resource.
-      #
-      # @param resource_class [Class] The resource type that we're fetching.
-      # @param query [::Protobuf::Message|NilClass] An optional query to send along with the request.
-      # @return [Array] The array of resources (each is an instance of the resource class we were
-      #   initialized with).
-      def self.index(resource_class, query)
-        response = resource_class.client.request path: resource_class.base_path,
-          method: Net::HTTP::Get,
-          message: query,
-          response_type: Protip::Messages::Array
-        response.messages.map do |message|
-          resource_class.new resource_class.message.decode(message)
-        end
-      end
-
-      # Fetch a single resource from the server.
-      #
-      # @param resource_class [Class] The resource type that we're fetching.
-      # @param id [String] The ID to be used in the URL to fetch the resource.
-      # @param query [::Protobuf::Message|NilClass] An optional query to send along with the request.
-      # @return [Protip::Resource] An instance of our resource class, created from the server
-      #   response.
-      def self.show(resource_class, id, query)
-        response = resource_class.client.request path: "#{resource_class.base_path}/#{id}",
-          method: Net::HTTP::Get,
-          message: query,
-          response_type: resource_class.message
-        resource_class.new response
-      end
-    end
-
-    # Mixin for a resource that has an active `:create` action. Should be treated as private,
-    # and will be included automatically when appropriate.
-    module Creatable
-      private
-      # POST the resource to the server and update our internal message. Private, since
-      # we should generally do this through the `save` method.
-      def create!
-        raise RuntimeError.new("Can't re-create a persisted object") if persisted?
-        self.message = self.class.client.request path: self.class.base_path,
-          method: Net::HTTP::Post,
-          message: message,
-          response_type: self.class.message
-      end
-    end
-
-    # Mixin for a resource that has an active `:update` action. Should be treated as private,
-    # and will be included automatically when appropriate.
-    module Updatable
-      private
-      # PUT the resource on the server and update our internal message. Private, since
-      # we should generally do this through the `save` method.
-      def update!
-        raise RuntimeError.new("Can't update a non-persisted object") if !persisted?
-        self.message = self.class.client.request path: "#{self.class.base_path}/#{id}",
-          method: Net::HTTP::Put,
-          message: message,
-          response_type: self.class.message
-      end
-    end
-
-    # Mixin for a resource that has an active `:destroy` action. Should be treated as private,
-    # and will be included automatically when appropriate.
-    module Destroyable
-      def destroy
-        raise RuntimeError.new("Can't destroy a non-persisted object") if !persisted?
-        self.message = self.class.client.request path: "#{self.class.base_path}/#{id}",
-          method: Net::HTTP::Delete,
-          message: nil,
-          response_type: self.class.message
-      end
-    end
-
-    # Internal helpers for non-resourceful member/collection methods. Never use these directly;
-    # instead, use the instance/class methods which have been dynamically defined on the resource
-    # you're working with.
-    module ExtraMethods
-      def self.member(resource, action, method, message, response_type)
-        response = resource.class.client.request path: "#{resource.class.base_path}/#{resource.id}/#{action}",
-          method: method,
-          message: message,
-          response_type: response_type
-        nil == response ? nil : ::Protip::Wrapper.new(response, resource.class.converter)
-      end
-      def self.collection(resource_class, action, method, message, response_type)
-        response = resource_class.client.request path: "#{resource_class.base_path}/#{action}",
-          method: method,
-          message: message,
-          response_type: response_type
-        nil == response ? nil : ::Protip::Wrapper.new(response, resource_class.converter)
-      end
-    end
-
     extend ActiveSupport::Concern
 
-    # Backport the ActiveModel::Model functionality - https://github.com/rails/rails/blob/097ca3f1f84bb9a2d3cda3f2cce7974a874efdf4/activemodel/lib/active_model/model.rb#L95
+    # Backport the ActiveModel::Model functionality
+    # https://github.com/rails/rails/blob/097ca3f1f84bb9a2d3cda3f2cce7974a874efdf4/activemodel/lib/active_model/model.rb#L95
     include ActiveModel::Validations
     include ActiveModel::Conversion
 
@@ -142,18 +49,25 @@ module Protip
       def_delegator :@wrapper, :message
       def_delegator :@wrapper, :as_json
     end
+
     module ClassMethods
 
+      VALID_ACTIONS = %i(show index create update destroy)
+
       attr_accessor :client
 
-      attr_reader :message
+      attr_reader :message, :nested_resources
+
+      attr_writer :base_path, :converter
 
-      attr_writer :base_path
       def base_path
-        @base_path == nil ? raise(RuntimeError.new 'Base path not yet set') : @base_path.gsub(/\/$/, '')
+        if @base_path == nil
+          raise(RuntimeError.new 'Base path not yet set')
+        else
+          @base_path.gsub(/\/$/, '')
+        end
       end
 
-      attr_writer :converter
       def converter
         @converter || (@_standard_converter ||= Protip::StandardConverter.new)
       end
@@ -161,14 +75,51 @@ module Protip
       private
 
       # Primary entry point for defining resourceful behavior.
-      def resource(actions:, message:, query: nil)
-        if @message
-          raise RuntimeError.new('Only one call to `resource` is allowed')
-        end
+      def resource(actions:, message:, query: nil, nested_resources: {})
+        raise RuntimeError.new('Only one call to `resource` is allowed') if @message
+        validate_actions!(actions)
+        validate_nested_resources!(nested_resources)
 
-        # Define attribute readers/writers
         @message = message
-        @message.descriptor.each do |field|
+        @nested_resources = nested_resources
+
+        define_attribute_accessors(@message)
+        define_oneof_group_methods(@message)
+        define_resource_query_methods(query, actions)
+
+        include(::Protip::Resource::Creatable) if actions.include?(:create)
+        include(::Protip::Resource::Updatable) if actions.include?(:update)
+        include(::Protip::Resource::Destroyable) if actions.include?(:destroy)
+      end
+
+      def validate_nested_resources!(nested_resources)
+        nested_resources.each do |key, resource_klass|
+          unless key.is_a?(Symbol)
+            raise "#{key} must be a Symbol, but is a #{key.class}"
+          end
+          unless resource_klass < ::Protip::Resource
+            raise "#{resource_klass} is not a Protip::Resource"
+          end
+        end
+      end
+
+      def validate_actions!(actions)
+        actions.map!{|action| action.to_sym}
+        (actions - VALID_ACTIONS).each do |action|
+          raise ArgumentError.new("Unrecognized action: #{action}")
+        end
+      end
+
+      # Allow calls to oneof groups to get the set oneof field
+      def define_oneof_group_methods(message)
+        message.descriptor.each_oneof do |oneof_field|
+          def_delegator :@wrapper, :"#{oneof_field.name}"
+        end
+      end
+
+      # Define attribute readers/writers
+      def define_attribute_accessors(message)
+        message.descriptor.each do |field|
           def_delegator :@wrapper, :"#{field.name}"
           if ::Protip::Wrapper.matchable?(field)
             def_delegator :@wrapper, :"#{field.name}?"
@@ -182,25 +133,21 @@ module Protip
             # needed for ActiveModel::Dirty
             send("#{field.name}_will_change!") if new_wrapped_value != old_wrapped_value
           end
-        end
 
-        # needed for ActiveModel::Dirty
-        define_attribute_methods @message.descriptor.map(&:name)
-
-        # Validate arguments
-        actions.map!{|action| action.to_sym}
-        (actions - %i(show index create update destroy)).each do |action|
-          raise ArgumentError.new("Unrecognized action: #{action}")
+          # needed for ActiveModel::Dirty
+          define_attribute_method field.name
         end
+      end
 
-        # For index/show, we want a different number of method arguments
-        # depending on whehter a query message was provided.
+      # For index/show, we want a different number of method arguments
+      # depending on whether a query message was provided.
+      def define_resource_query_methods(query, actions)
         if query
           if actions.include?(:show)
             define_singleton_method :find do |id, query_params = {}|
               wrapper = ::Protip::Wrapper.new(query.new, converter)
               wrapper.assign_attributes query_params
-              SearchMethods.show(self, id, wrapper.message)
+              ::Protip::Resource::SearchMethods.show(self, id, wrapper.message)
             end
           end
 
@@ -208,26 +155,22 @@ module Protip
             define_singleton_method :all do |query_params = {}|
               wrapper = ::Protip::Wrapper.new(query.new, converter)
               wrapper.assign_attributes query_params
-              SearchMethods.index(self, wrapper.message)
+              ::Protip::Resource::SearchMethods.index(self, wrapper.message)
             end
           end
         else
           if actions.include?(:show)
             define_singleton_method :find do |id|
-              SearchMethods.show(self, id, nil)
+              ::Protip::Resource::SearchMethods.show(self, id, nil)
             end
           end
 
           if actions.include?(:index)
             define_singleton_method :all do
-              SearchMethods.index(self, nil)
+              ::Protip::Resource::SearchMethods.index(self, nil)
             end
           end
         end
-
-        include(Creatable) if actions.include?(:create)
-        include(Updatable) if actions.include?(:update)
-        include(Destroyable) if actions.include?(:destroy)
       end
 
       def member(action:, method:, request: nil, response: nil)
@@ -235,11 +178,11 @@ module Protip
           define_method action do |request_params = {}|
             wrapper = ::Protip::Wrapper.new(request.new, self.class.converter)
             wrapper.assign_attributes request_params
-            ExtraMethods.member self, action, method, wrapper.message, response
+            ::Protip::Resource::ExtraMethods.member self, action, method, wrapper.message, response
           end
         else
           define_method action do
-            ExtraMethods.member self, action, method, nil, response
+            ::Protip::Resource::ExtraMethods.member self, action, method, nil, response
           end
         end
       end
@@ -249,11 +192,15 @@ module Protip
           define_singleton_method action do |request_params = {}|
             wrapper = ::Protip::Wrapper.new(request.new, converter)
             wrapper.assign_attributes request_params
-            ExtraMethods.collection self, action, method, wrapper.message, response
+            ::Protip::Resource::ExtraMethods.collection self,
+                                                        action,
+                                                        method,
+                                                        wrapper.message,
+                                                        response
           end
         else
           define_singleton_method action do
-            ExtraMethods.collection self, action, method, nil, response
+            ::Protip::Resource::ExtraMethods.collection self, action, method, nil, response
           end
         end
       end
@@ -280,7 +227,7 @@ module Protip
     end
 
     def message=(message)
-      @wrapper = Protip::Wrapper.new(message, self.class.converter)
+      @wrapper = Protip::Wrapper.new(message, self.class.converter, self.class.nested_resources)
     end
 
     def save
@@ -328,5 +275,6 @@ module Protip
       @previously_changed = changes
       @changed_attributes.clear
     end
+
   end
 end

data/lib/protip/resource/creatable.rb

@@ -0,0 +1,18 @@
+module Protip
+  module Resource
+    # Mixin for a resource that has an active `:create` action. Should be treated as private,
+    # and will be included automatically when appropriate.
+    module Creatable
+      private
+      # POST the resource to the server and update our internal message. Private, since
+      # we should generally do this through the `save` method.
+      def create!
+        raise RuntimeError.new("Can't re-create a persisted object") if persisted?
+        self.message = self.class.client.request path: self.class.base_path,
+          method: Net::HTTP::Post,
+          message: message,
+          response_type: self.class.message
+      end
+    end
+  end
+end

data/lib/protip/resource/destroyable.rb

@@ -0,0 +1,15 @@
+module Protip
+  module Resource
+    # Mixin for a resource that has an active `:destroy` action. Should be treated as private,
+    # and will be included automatically when appropriate.
+    module Destroyable
+      def destroy
+        raise RuntimeError.new("Can't destroy a non-persisted object") if !persisted?
+        self.message = self.class.client.request path: "#{self.class.base_path}/#{id}",
+          method: Net::HTTP::Delete,
+          message: nil,
+          response_type: self.class.message
+      end
+    end
+  end
+end

data/lib/protip/resource/extra_methods.rb

@@ -0,0 +1,23 @@
+module Protip
+  module Resource
+    # Internal helpers for non-resourceful member/collection methods. Never use these directly;
+    # instead, use the instance/class methods which have been dynamically defined on the resource
+    # you're working with.
+    module ExtraMethods
+      def self.member(resource, action, method, message, response_type)
+        response = resource.class.client.request path: "#{resource.class.base_path}/#{resource.id}/#{action}",
+          method: method,
+          message: message,
+          response_type: response_type
+        nil == response ? nil : ::Protip::Wrapper.new(response, resource.class.converter)
+      end
+      def self.collection(resource_class, action, method, message, response_type)
+        response = resource_class.client.request path: "#{resource_class.base_path}/#{action}",
+          method: method,
+          message: message,
+          response_type: response_type
+        nil == response ? nil : ::Protip::Wrapper.new(response, resource_class.converter)
+      end
+    end
+  end
+end

data/lib/protip/resource/search_methods.rb

@@ -0,0 +1,40 @@
+module Protip
+  module Resource
+    # Internal handlers for index/show actions. Never use these directly; instead, use `.all` and
+    # `.find` on the resource you're working with, since those methods will adjust their
+    # signatures to correctly parse a set of query parameters if supported.
+    module SearchMethods
+      # Fetch a list from the server at the collection's base endpoint. Expects the server response
+      # to be an array containing encoded messages that can be used to instantiate our resource.
+      #
+      # @param resource_class [Class] The resource type that we're fetching.
+      # @param query [::Protobuf::Message|NilClass] An optional query to send along with the request.
+      # @return [Array] The array of resources (each is an instance of the resource class we were
+      #   initialized with).
+      def self.index(resource_class, query)
+        response = resource_class.client.request path: resource_class.base_path,
+          method: Net::HTTP::Get,
+          message: query,
+          response_type: Protip::Messages::Array
+        response.messages.map do |message|
+          resource_class.new resource_class.message.decode(message)
+        end
+      end
+
+      # Fetch a single resource from the server.
+      #
+      # @param resource_class [Class] The resource type that we're fetching.
+      # @param id [String] The ID to be used in the URL to fetch the resource.
+      # @param query [::Protobuf::Message|NilClass] An optional query to send along with the request.
+      # @return [Protip::Resource] An instance of our resource class, created from the server
+      #   response.
+      def self.show(resource_class, id, query)
+        response = resource_class.client.request path: "#{resource_class.base_path}/#{id}",
+          method: Net::HTTP::Get,
+          message: query,
+          response_type: resource_class.message
+        resource_class.new response
+      end
+    end
+  end
+end

data/lib/protip/resource/updateable.rb

@@ -0,0 +1,19 @@
+module Protip
+  module Resource
+    # Mixin for a resource that has an active `:update` action. Should be treated as private,
+    # and will be included automatically when appropriate.
+    module Updatable
+      private
+      # PUT the resource on the server and update our internal message. Private, since
+      # we should generally do this through the `save` method.
+      def update!
+        raise RuntimeError.new("Can't update a non-persisted object") if !persisted?
+        self.message = self.class.client.request path: "#{self.class.base_path}/#{id}",
+          method: Net::HTTP::Put,
+          message: message,
+          response_type: self.class.message
+      end
+    end
+
+  end
+end

data/lib/protip/wrapper.rb

@@ -7,18 +7,24 @@ module Protip
   # - mass assignment of attributes
   # - standardized creation of nested messages that can't be converted to/from Ruby objects
   class Wrapper
-    attr_reader :message, :converter
-    def initialize(message, converter)
+
+    attr_reader :message, :converter, :nested_resources
+
+    def initialize(message, converter, nested_resources={})
       @message = message
       @converter = converter
+      @nested_resources = nested_resources
     end
 
     def respond_to?(name)
       if super
         true
       else
+        # Responds to calls to oneof groups by name
+        return true if message.class.descriptor.lookup_oneof(name.to_s)
+
+        # Responds to field getters, setters, and in the scalar enum case, query methods
         message.class.descriptor.any? do |field|
-          # getter, setter, and in the scalar enum case, query method
           regex = /^#{field.name}[=#{self.class.matchable?(field) ? '\\?' : ''}]?$/
           name.to_s =~ regex
         end
@@ -26,27 +32,22 @@ module Protip
     end
 
     def method_missing(name, *args)
-      if (name =~ /=$/ && field = message.class.descriptor.detect{|field| :"#{field.name}=" == name})
-        raise ArgumentError unless args.length == 1
-        attributes = {}.tap { |hash| hash[field.name] = args[0] }
-        assign_attributes attributes
-        args[0] # return the input value (to match ActiveRecord behavior)
-      elsif (name =~ /\?$/ && field = message.class.descriptor.detect{|field| self.class.matchable?(field) && :"#{field.name}?" == name})
-        if args.length == 1
-          # this is an enum query, e.g. `state?(:CREATED)`
-          matches? field, args[0]
-        elsif args.length == 0
-          # this is a boolean query, e.g. `approved?`
-          get field
-        else
-          raise ArgumentError
-        end
-      elsif (field = message.class.descriptor.detect{|field| field.name.to_sym == name})
-        raise ArgumentError unless args.length == 0
-        get field
-      else
-        super
-      end
+      descriptor = message.class.descriptor
+
+      is_setter_method = name =~ /=$/
+      return method_missing_setter(name, *args) if is_setter_method
+
+      is_query_method = name =~ /\?$/
+      return method_missing_query(name, *args) if is_query_method
+
+      field = descriptor.detect{|field| field.name.to_sym == name}
+      return method_missing_field(field, *args) if field
+
+      oneof_descriptor = descriptor.lookup_oneof(name.to_s)
+      # For calls to a oneof group, return the active oneof field, or nil if there isn't one
+      return method_missing_oneof(oneof_descriptor) if oneof_descriptor
+
+      super
     end
 
     # Create a nested field on our message. For example, given the following definitions:
@@ -174,10 +175,14 @@ module Protip
     # Helper for getting values - converts the value for the given field to one that we can return to the user
     def to_ruby_value(field, value)
       if field.type == :message
+        field_name_sym = field.name.to_sym
         if nil == value
           nil
         elsif converter.convertible?(field.subtype.msgclass)
           converter.to_object value
+        elsif nested_resources.has_key?(field_name_sym)
+          resource_klass = nested_resources[field_name_sym]
+          resource_klass.new value
         else
           self.class.new value, converter
         end
@@ -199,10 +204,14 @@ module Protip
       if field.type == :message
         if nil == value
           nil
+        # This check must happen before the nested_resources check to ensure nested messages
+        # are set properly
         elsif value.is_a?(field.subtype.msgclass)
           value
         elsif converter.convertible?(field.subtype.msgclass)
           converter.to_message value, field.subtype.msgclass
+        elsif nested_resources.has_key?(field.name.to_sym)
+          value.message
         else
           raise ArgumentError.new "Cannot convert from Ruby object: \"#{field}\""
         end
@@ -225,5 +234,45 @@ module Protip
       get(field) == sym
 
     end
+
+    def method_missing_oneof(oneof_descriptor)
+      oneof_field_name = message.send(oneof_descriptor.name)
+      return if oneof_field_name.nil?
+      oneof_field_name = oneof_field_name.to_s
+      oneof_field = oneof_descriptor.detect {|field| field.name == oneof_field_name}
+      oneof_field ? get(oneof_field) : nil
+    end
+
+    def method_missing_field(field, *args)
+      if field
+        raise ArgumentError unless args.length == 0
+        get(field)
+      end
+    end
+
+    def method_missing_query(name, *args)
+      field = message.class.descriptor.detect do |field|
+        self.class.matchable?(field) && :"#{field.name}?" == name
+      end
+      if args.length == 1
+        # this is an enum query, e.g. `state?(:CREATED)`
+        matches? field, args[0]
+      elsif args.length == 0
+        # this is a boolean query, e.g. `approved?`
+        get field
+      else
+        raise ArgumentError
+      end
+    end
+
+    def method_missing_setter(name, *args)
+      field = message.class.descriptor.detect{|field| :"#{field.name}=" == name}
+      if field
+        raise ArgumentError unless args.length == 1
+        attributes = {}.tap { |hash| hash[field.name] = args[0] }
+        assign_attributes attributes
+        return args[0] # return the input value (to match ActiveRecord behavior)
+      end
+    end
   end
 end

data/test/unit/protip/resource_test.rb

@@ -7,6 +7,8 @@ require 'protip/resource'
 module Protip::ResourceTest # Namespace for internal constants
   describe Protip::Resource do
     let :pool do
+      # See https://github.com/google/protobuf/blob/master/ruby/tests/generated_code.rb for
+      # examples of field types you can add here
       pool = Google::Protobuf::DescriptorPool.new
       pool.build do
         add_enum 'number' do
@@ -30,6 +32,11 @@ module Protip::ResourceTest # Namespace for internal constants
           repeated :booleans, :bool, 9
           optional :google_bool_value, :message, 10, "google.protobuf.BoolValue"
           repeated :google_bool_values, :message, 11, "google.protobuf.BoolValue"
+
+          oneof :oneof_group do
+            optional :oneof_string1, :string, 12
+            optional :oneof_string2, :string, 13
+          end
         end
 
         add_message 'resource_query' do
@@ -81,95 +88,153 @@ module Protip::ResourceTest # Namespace for internal constants
           include Protip::Converter
         end.new
       end
+      describe 'with basic resource' do
+        before do
+          resource_class.class_exec(converter, resource_message_class) do |converter, message|
+            resource actions: [], message: message
+            self.converter = converter
+          end
+        end
 
-      before do
-        resource_class.class_exec(converter, resource_message_class) do |converter, message|
-          resource actions: [], message: message
-          self.converter = converter
+        it 'can only be invoked once' do
+          assert_raises RuntimeError do
+            resource_class.class_exec(resource_message_class) do |message|
+              resource actions: [], message: message
+            end
+          end
         end
-      end
 
-      it 'can only be invoked once' do
-        assert_raises RuntimeError do
-          resource_class.class_exec(resource_message_class) do |message|
-            resource actions: [], message: message
+        it 'defines accessors for the fields on its message' do
+          resource = resource_class.new
+          [:id, :string].each do |method|
+            assert_respond_to resource, method
           end
+          refute_respond_to resource, :foo
         end
-      end
 
-      it 'defines accessors for the fields on its message' do
-        resource = resource_class.new
-        [:id, :string].each do |method|
-          assert_respond_to resource, method
+        it 'defines accessors for oneof groups on its message' do
+          resource = resource_class.new
+          group_name = 'oneof_group'
+          assert resource.message.class.descriptor.lookup_oneof(group_name)
+          assert_respond_to resource, group_name
         end
-        refute_respond_to resource, :foo
-      end
 
-      it 'sets fields on the underlying message when simple setters are called' do
-        resource = resource_class.new
-        resource.string = 'intern'
-        assert_equal 'intern', resource.message.string
-        assert_equal 'intern', resource.string
-      end
+        it 'returns nil if the oneof group accessor called when the underlying fields are not set' do
+          resource = resource_class.new
+          assert_nil resource.oneof_group
+        end
 
-      it 'never checks with the converter when setting simple types' do
-        converter.expects(:convertible?).never
-        resource = resource_class.new
-        resource.string = 'intern'
-      end
+        it 'returns the active oneof field when a oneof group accessor is called' do
+          resource = resource_class.new
+          foo, bar = 'foo', 'bar'
+          resource.oneof_string1 = foo
+          assert_equal resource.oneof_string1, resource.oneof_group
+          resource.oneof_string2 = bar
+          assert_equal resource.oneof_string2, resource.oneof_group
+          resource.oneof_string2 = bar
+          resource.oneof_string1 = foo
+          assert_equal resource.oneof_string1, resource.oneof_group
+        end
 
-      it 'checks with the converter when setting message types' do
-        converter.expects(:convertible?).at_least_once.with(nested_message_class).returns(false)
-        resource = resource_class.new
-        assert_raises(ArgumentError) do
-          resource.nested_message = 5
+        it 'sets fields on the underlying message when simple setters are called' do
+          resource = resource_class.new
+          resource.string = 'intern'
+          assert_equal 'intern', resource.message.string
+          assert_equal 'intern', resource.string
         end
-      end
 
-      it 'converts message types to and from their Ruby values when the converter allows' do
-        converter.expects(:convertible?).at_least_once.with(nested_message_class).returns(true)
-        converter.expects(:to_message).once.with(6, nested_message_class).returns(nested_message_class.new number: 100)
-        converter.expects(:to_object).at_least_once.with(nested_message_class.new number: 100).returns 'intern'
+        it 'never checks with the converter when setting simple types' do
+          converter.expects(:convertible?).never
+          resource = resource_class.new
+          resource.string = 'intern'
+        end
 
-        resource = resource_class.new
-        resource.nested_message = 6
+        it 'checks with the converter when setting message types' do
+          converter.expects(:convertible?).at_least_once.with(nested_message_class).returns(false)
+          resource = resource_class.new
+          assert_raises(ArgumentError) do
+            resource.nested_message = 5
+          end
+        end
 
-        assert_equal nested_message_class.new(number: 100), resource.message.nested_message, 'object was not converted'
-        assert_equal 'intern', resource.nested_message, 'message was not converted'
-      end
+        it 'converts message types to and from their Ruby values when the converter allows' do
+          converter.expects(:convertible?).at_least_once.with(nested_message_class).returns(true)
+          converter.expects(:to_message).once.with(6, nested_message_class).returns(nested_message_class.new number: 100)
+          converter.expects(:to_object).at_least_once.with(nested_message_class.new number: 100).returns 'intern'
 
-      describe '(query methods)' do
-        let(:resource) { resource_class.new }
-        it 'defines query methods for the scalar enums on its message' do
-          assert_respond_to resource, :number?
-          assert resource.number?(:ZERO)
-          refute resource.number?(:ONE)
-        end
+          resource = resource_class.new
+          resource.nested_message = 6
 
-        it 'defines query methods for the booleans on its message' do
-          assert_respond_to resource, :boolean?
-          refute resource.boolean?
+          assert_equal nested_message_class.new(number: 100), resource.message.nested_message, 'object was not converted'
+          assert_equal 'intern', resource.nested_message, 'message was not converted'
         end
 
-        it 'defines query methods for the google.protobuf.BoolValues on its message' do
-          assert_respond_to resource, :google_bool_value?
-          refute resource.google_bool_value?
+        describe '(query methods)' do
+          let(:resource) { resource_class.new }
+          it 'defines query methods for the scalar enums on its message' do
+            assert_respond_to resource, :number?
+            assert resource.number?(:ZERO)
+            refute resource.number?(:ONE)
+          end
+
+          it 'defines query methods for the booleans on its message' do
+            assert_respond_to resource, :boolean?
+            refute resource.boolean?
+          end
+
+          it 'defines query methods for the google.protobuf.BoolValues on its message' do
+            assert_respond_to resource, :google_bool_value?
+            refute resource.google_bool_value?
+          end
+
+          it 'does not define query methods for repeated enums' do
+            refute_respond_to resource, :numbers?
+            assert_raises NoMethodError do
+              resource.numbers?(:ZERO)
+            end
+          end
+
+          it 'does not define query methods for non-enum fields' do
+            refute_respond_to resource, :inner?
+            assert_raises NoMethodError do
+              resource.inner?(:ZERO)
+            end
+          end
         end
+      end
+      describe 'with empty nested resources' do
+        it 'does not throw an error' do
+          resource_class.class_exec(converter, resource_message_class) do |converter, message|
+            resource actions: [], message: message, nested_resources: {}
+            self.converter = converter
+          end
+        end
+      end
 
-        it 'does not define query methods for repeated enums' do
-          refute_respond_to resource, :numbers?
-          assert_raises NoMethodError do
-            resource.numbers?(:ZERO)
+      describe 'with invalid nested resource key' do
+        it 'throws an error' do
+          assert_raises RuntimeError do
+            resource_class.class_exec(converter, resource_message_class) do |converter, message|
+              resource actions: [],
+                message: message,
+                nested_resources: {'snoop' => Protip::Resource}
+              self.converter = converter
+            end
           end
         end
+      end
 
-        it 'does not define query methods for non-enum fields' do
-          refute_respond_to resource, :inner?
-          assert_raises NoMethodError do
-            resource.inner?(:ZERO)
+      describe 'with invalid nested resource class' do
+        it 'throws an error' do
+          assert_raises RuntimeError do
+            resource_class.class_exec(converter, resource_message_class) do |converter, message|
+              resource actions: [], message: message, nested_resources: {dogg: Object}
+              self.converter = converter
+            end
           end
         end
       end
+
     end
 
     # index/find/member/collection actions should all convert more complex Ruby objects to submessages in their

data/test/unit/protip/wrapper_test.rb

@@ -1,8 +1,8 @@
 require 'test_helper'
 
 require 'google/protobuf'
-require 'protip/converter'
 require 'protip/wrapper'
+require 'protip/resource'
 
 module Protip::WrapperTest # namespace for internal constants
   describe Protip::Wrapper do
@@ -44,6 +44,11 @@ module Protip::WrapperTest # namespace for internal constants
 
           optional :google_bool_value, :message, 10, "google.protobuf.BoolValue"
           repeated :google_bool_values, :message, 11, "google.protobuf.BoolValue"
+
+          oneof :oneof_group do
+            optional :oneof_string1, :string, 12
+            optional :oneof_string2, :string, 13
+          end
         end
       end
       pool
@@ -55,6 +60,24 @@ module Protip::WrapperTest # namespace for internal constants
       end
     end
 
+    # Stubbed API client
+    let :client do
+      mock.responds_like_instance_of(Class.new { include Protip::Client })
+    end
+
+    # Call `resource_class` to get an empty resource type.
+    let :resource_class do
+      resource_class = Class.new do
+        include Protip::Resource
+        self.base_path = 'base_path'
+        class << self
+          attr_accessor :client
+        end
+      end
+      resource_class.client = client
+      resource_class
+    end
+
     let(:wrapped_message) do
       message_class.new(inner: inner_message_class.new(value: 25), string: 'test')
     end
@@ -74,6 +97,9 @@ module Protip::WrapperTest # namespace for internal constants
         assert_respond_to wrapper, :inner
         assert_respond_to wrapper, :inner_blank
       end
+      it 'adds accessors for oneof groups' do
+        assert_respond_to wrapper, :oneof_group
+      end
       it 'adds queries for scalar matchable fields' do
         assert_respond_to wrapper, :number?, 'enum field should respond to query'
         assert_respond_to wrapper, :boolean?, 'bool field should respond to query'
@@ -313,7 +339,9 @@ module Protip::WrapperTest # namespace for internal constants
         end
 
         it 'contains keys for all fields of the parent message' do
-          assert_equal %i(string strings inner inners inner_blank number numbers boolean booleans google_bool_value google_bool_values).sort, wrapper.to_h.keys.sort
+          keys = %i(string strings inner inners inner_blank number numbers boolean booleans
+                    google_bool_value google_bool_values oneof_string1 oneof_string2)
+          assert_equal keys.sort, wrapper.to_h.keys.sort
         end
         it 'assigns nil for missing nested messages' do
           hash = wrapper.to_h
@@ -336,6 +364,13 @@ module Protip::WrapperTest # namespace for internal constants
     end
 
     describe '#get' do
+      before do
+        resource_class.class_exec(converter, inner_message_class) do |converter, message|
+          resource actions: [], message: message
+          self.converter = converter
+        end
+      end
+
       it 'does not convert simple fields' do
         converter.expects(:convertible?).never
         converter.expects(:to_object).never
@@ -354,6 +389,14 @@ module Protip::WrapperTest # namespace for internal constants
         assert_equal Protip::Wrapper.new(inner_message_class.new(value: 25), converter), wrapper.inner
       end
 
+      it 'wraps nested resource messages in their defined resource' do
+        message = wrapped_message
+        klass = resource_class
+        wrapper = Protip::Wrapper.new(message, Protip::StandardConverter.new, {inner: klass})
+        assert_equal klass, wrapper.inner.class
+        assert_equal message.inner, wrapper.inner.message
+      end
+
       it 'returns nil for messages that have not been set' do
         converter.expects(:convertible?).never
         converter.expects(:to_object).never
@@ -362,6 +405,14 @@ module Protip::WrapperTest # namespace for internal constants
     end
 
     describe 'attribute writer' do # generated via method_missing?
+
+      before do
+        resource_class.class_exec(converter, inner_message_class) do |converter, message|
+          resource actions: [], message: message
+          self.converter = converter
+        end
+      end
+
       it 'does not convert simple fields' do
         converter.expects(:convertible?).never
         converter.expects(:to_message).never
@@ -404,6 +455,23 @@ module Protip::WrapperTest # namespace for internal constants
         assert_equal inner_message_class.new(value: 50), wrapper.message.inner
       end
 
+      it 'for nested resources, sets the resource\'s message' do
+        message = wrapped_message
+        klass = resource_class
+        new_inner_message = inner_message_class.new(value: 50)
+
+        resource = klass.new new_inner_message
+        wrapper = Protip::Wrapper.new(message, Protip::StandardConverter.new, {inner: klass})
+
+        resource.expects(:message).once.returns(new_inner_message)
+        wrapper.inner = resource
+
+        assert_equal new_inner_message,
+                     wrapper.message.inner,
+                     'Wrapper did not set its message\'s inner message value to the value of the '\
+                     'given resource\'s message'
+      end
+
       it 'raises an error when setting an enum field to an undefined value' do
         assert_raises RangeError do
           wrapper.number = :NAN

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protip
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.14.0
 platform: ruby
 authors:
 - AngelList
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-01 00:00:00.000000000 Z
+date: 2015-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -155,6 +155,11 @@ files:
 - lib/protip/messages/errors.rb
 - lib/protip/messages/types.rb
 - lib/protip/resource.rb
+- lib/protip/resource/creatable.rb
+- lib/protip/resource/destroyable.rb
+- lib/protip/resource/extra_methods.rb
+- lib/protip/resource/search_methods.rb
+- lib/protip/resource/updateable.rb
 - lib/protip/standard_converter.rb
 - lib/protip/wrapper.rb
 - test/functional/protip/resource_test.rb
@@ -182,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Resources backed by protobuf messages