protip 0.20.7 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c75d9159e3ac75fe200cd600f364dd4a7945602
-  data.tar.gz: d1f8c8d9e0f252d95bb50c77ea81777d9fbb7d6a
+  metadata.gz: 751ca27cb6c6edc2bb6e39614b7ad5dedf4509d4
+  data.tar.gz: 8f1fe4aa42f18348ed8f3edb7e886c045cf31dad
 SHA512:
-  metadata.gz: 53a4b29f3e11698dde0e177e3e3ef90d2b8d5152b7a82d31d40a5a0561ebc8066af8ced78d9d05fe8ccd18ad9354dd6ffecde4440d5a1fedbf1782790477c039
-  data.tar.gz: d6d0a6a04d041aa444d8d33f6675a47f4ac98c1bb9befa4754f1f6491a34e7d90c31e28e871686ad183ac2c0ed168bc7b61ddbb5dc3c34812d7035b0e75ceb2e
+  metadata.gz: 1bce93588ea39831f7ac6e548ee489863e2e590be4f138b9b0be0337a6c9290890edfb215f9f51e91b95d19fae0663869f076159c1541281e752ca3805770c66
+  data.tar.gz: 52960419aae018faf89f4fb572875d2b81f5f9286da4434a110d2ca826082eb95bb3ec1e6e34cca816bb36ceb721e54a5e8cc4d763f676d109dcff7f5c5510be

data/lib/protip.rb

@@ -5,3 +5,13 @@ require 'protip/resource'
 if defined?(Mime::Type)
   Mime::Type.register 'application/x-protobuf', :protobuf
 end
+
+module Protip
+  def self.default_transformer
+    @default_transformer ||= Protip::Transformers::DefaultTransformer.new
+  end
+
+  def self.decorate(message, transformer = Protip.default_transfomer)
+    Protip::Decorator.new(message, transformer)
+  end
+end

data/lib/protip/{wrapper.rb → decorator.rb}

@@ -1,39 +1,36 @@
 require 'active_support/concern'
 
+require 'protip/transformers/enum_transformer'
+
 module Protip
 
   # Wraps a protobuf message to allow:
-  # - getting/setting of certain message fields as if they were more complex Ruby objects
+  # - getting/setting of message fields as if they were more complex Ruby objects
   # - mass assignment of attributes
   # - standardized creation of nested messages that can't be converted to/from Ruby objects
-  class Wrapper
+  class Decorator
 
-    attr_reader :message, :converter, :nested_resources
+    attr_reader :message, :transformer, :nested_resources
 
-    def initialize(message, converter, nested_resources={})
+    def initialize(message, transformer, nested_resources={})
       @message = message
-      @converter = converter
+      @transformer = transformer
       @nested_resources = nested_resources
     end
 
     def respond_to?(name)
       if super
-        return true
+        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
+        # Responds to field getters, setters, and query methods for all fieldsfa
         field = message.class.descriptor.lookup(name.to_s.gsub(/[=?]$/, ''))
         return false if !field
-        if name[-1, 1] == '?'
-          # For query methods, only respond  if the field is matchable
-          return self.class.matchable?(field)
-        else
-          return true
-        end
+
+        true
       end
-      false
     end
 
     def method_missing(name, *args)
@@ -74,52 +71,69 @@ module Protip
     #
     # We could create an inner message using:
     #
-    #   wrapper = Protip::Wrapper.new(Outer.new, converter)
+    #   wrapper = Protip::Wrapper.new(Outer.new, transformer)
     #   wrapper.inner # => nil
     #   wrapper.build(:inner, str: 'example')
     #   wrapper.inner.str # => 'example'
     #
-    # Rebuilds the field if it's already present. Raises an error if the name of a primitive field
-    # or a convertible message field is given.
+    # Assigns values by decorating an instance of the inner message,
+    # passing in our transformer, and calling +assign_attributes+ on
+    # the created decorator object.
+    #
+    # Rebuilds the field if it's already present. Raises an error if
+    # the name of a primitive field is given.
+    #
+    # TODO: do we still need this or is it enough to just use
+    # +decorator.field_name = hash+?
     #
     # @param field_name [String|Symbol] The field name to build
-    # @param attributes [Hash] The initial attributes to set on the field (as parsed by +assign_attributes+)
-    # @return [Protip::Wrapper] The created field
+    # @param attributes [Hash] The initial attributes to set on the
+    #   field (as parsed by +assign_attributes+) @return
+    #   [Protip::Wrapper] The created field
     def build(field_name, attributes = {})
 
-      field = message.class.descriptor.detect{|field| field.name.to_sym == field_name.to_sym}
+      field = message.class.descriptor.detect do |f|
+        f.name.to_sym == field_name.to_sym
+      end
+
       if !field
         raise "No field named #{field_name}"
       elsif field.type != :message
         raise "Can only build message fields: #{field_name}"
-      elsif converter.convertible?(field.subtype.msgclass)
-        raise "Cannot build a convertible field: #{field.name}"
       end
 
-      message[field_name.to_s] = field.subtype.msgclass.new
-      wrapper = get(field)
-      wrapper.assign_attributes attributes
-      wrapper
+      built = field.subtype.msgclass.new
+      built_wrapper = self.class.new(built, transformer)
+      built_wrapper.assign_attributes attributes
+      message[field_name.to_s] = built_wrapper.message
+
+      get(field)
     end
 
-    # Mass assignment of message attributes. Nested messages will be built if necessary, but not overwritten
-    # if they already exist.
+    # Mass assignment of message attributes. Nested messages will be
+    # built if necessary, but not overwritten if they already exist.
     #
-    # @param attributes [Hash] The attributes to set. Keys are field names. For primitive fields and message fields
-    #   which are convertible to/from Ruby objects, values are the same as you'd pass to the field's setter
-    #   method. For nested message fields which can't be converted to/from Ruby objects, values are attribute
-    #   hashes which will be passed down to +assign_attributes+ on the nested field.
-    # @return [NilClass]
+    # @param attributes [Hash] The attributes to set. Keys are field
+    #   names. For primitive fields and message fields which are
+    #   convertible to/from Ruby objects, values are the same as you'd
+    #   pass to the field's setter method. For nested message fields
+    #   which can't be converted to/from Ruby objects, values are
+    #   attribute hashes which will be passed down to
+    #   +assign_attributes+ on the nested field.  @return [NilClass]
     def assign_attributes(attributes)
       attributes.each do |field_name, value|
         field = message.class.descriptor.lookup(field_name.to_s) ||
           (raise ArgumentError.new("Unrecognized field: #{field_name}"))
-
-        # For inconvertible nested messages, we allow a hash to be passed in with nested attributes
-        if field.type == :message && !converter.convertible?(field.subtype.msgclass) && value.is_a?(Hash)
-          wrapper = get(field) || build(field.name) # Create the field if it doesn't already exist
-          wrapper.assign_attributes value
-        # Otherwise, if the field is a message (convertible or not) or a simple type, we set the value directly
+        # Message fields can be set directly by Hash, which either
+        # builds or updates them as appropriate.
+        #
+        # TODO: This kind of oddly assumes that the built message
+        # responds to +assign_attributes+ (as it does when a
+        # +DecoratingTransformer+ is used for the transformation). Can
+        # be removed if we decide the update behavior is unnecessary,
+        # since +DecoratingTransformer+ supports assignment by hash.
+        if field.type == :message && value.is_a?(Hash)
+          (get(field) || build(field.name)).assign_attributes value
         else
           set(field, value)
         end
@@ -132,56 +146,52 @@ module Protip
       to_h.as_json
     end
 
-    # @return [Hash] A hash whose keys are the fields of our message, and whose values are the Ruby representations
-    #   (either nested hashes or converted messages) of the field values.
+    # @return [Hash] A hash whose keys are the fields of our message,
+    #   and whose values are the Ruby representations (either nested
+    #   hashes or transformed messages) of the field values.
     def to_h
       hash = {}
+
+      # Use nested +to_h+ on fields which are also decorated messages
+      transform = ->(v) { v.is_a?(self.class) ? v.to_h : v }
+
       message.class.descriptor.each do |field|
-        value = public_send(field.name)
+        value = get(field)
         if field.label == :repeated
-          value.map!{|v| v.is_a?(self.class) ? v.to_h : v}
+          value.map!{|v| transform[v]}
         else
-          value = (value.is_a?(self.class) ? value.to_h : value)
+          value = transform[value]
         end
         hash[field.name.to_sym] = value
       end
       hash
     end
 
-    def ==(wrapper)
-      wrapper.class == self.class &&
-        wrapper.message.class == message.class &&
-        message.class.encode(message) == wrapper.message.class.encode(wrapper.message) &&
-        converter == wrapper.converter
+    def ==(decorator)
+      decorator.class == self.class &&
+        decorator.message.class == message.class &&
+        message.class.encode(message) == decorator.message.class.encode(decorator.message) &&
+        transformer == decorator.transformer
     end
 
     class << self
-      # Whether the given field returns boolean values. When true, wrappers will respond to +field_name?+
-      # query methods.
-      def boolean?(field)
-        field.type == :bool || (field.type == :message && field.subtype.name == 'google.protobuf.BoolValue')
-      end
-
       def enum_for_field(field)
+        return nil if field.label == :repeated
         if field.type == :enum
           field.subtype
         elsif field.type == :message && field.subtype.name == 'protip.messages.EnumValue'
-          Protip::StandardConverter.enum_for_field(field)
+          Protip::Transformers::EnumTransformer.enum_for_field(field)
         else
           nil
         end
       end
-
-      # Semi-private check for whether a field should have an associated query method (e.g. +field_name?+).
-      # @return [Boolean] Whether the field should have an associated query method on wrappers.
-      def matchable?(field)
-        return false if field.label == :repeated
-        (nil != enum_for_field(field)) || boolean?(field)
-      end
     end
 
     private
 
+    # Get the transformed value of the given field on our message.
+    #
+    # @param field [::Google::Protobuf::FieldDescriptor]
     def get(field)
       if field.label == :repeated
         message[field.name].map{|value| to_ruby_value field, value}
@@ -190,19 +200,23 @@ module Protip
       end
     end
 
-    # Helper for getting values - converts the value for the given field to one that we can return to the user
+    # Helper for getting values - converts the value for the given
+    # field to one that we can return to the user
+    #
+    # @param field [::Google::Protobuf::FieldDescriptor] The
+    #   descriptor for the field we're fetching.
+    # @param value [Object] The message or primitive value of the
+    #   field.
     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, field
         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
+          transformer.to_object value, field
         end
       else
         value
@@ -217,21 +231,20 @@ module Protip
       end
     end
 
-    # Helper for setting values - converts the value for the given field to one that we can set directly
+    # Helper for setting values - converts the value for the given
+    # field to one that we can set directly
     def to_protobuf_value(field, value)
       if field.type == :message
         if nil == value
           nil
-        # This check must happen before the nested_resources check to ensure nested messages
-        # are set properly
+        # 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, field
         elsif nested_resources.has_key?(field.name.to_sym)
           value.message
         else
-          raise ArgumentError.new "Cannot convert from Ruby object: \"#{field.name}\""
+          transformer.to_message(value, field)
         end
       elsif field.type == :enum
         value.is_a?(Fixnum) ? value : value.to_sym
@@ -241,7 +254,7 @@ module Protip
     end
 
     def matches?(field, value)
-      enum = Protip::Wrapper.enum_for_field(field)
+      enum = Protip::Decorator.enum_for_field(field)
       if value.is_a?(Fixnum)
         sym = enum.lookup_value(value)
       else
@@ -250,7 +263,6 @@ module Protip
       end
       raise RangeError.new("#{field} has no value #{value}") if nil == sym
       get(field) == sym
-
     end
 
     def method_missing_oneof(oneof, *args)
@@ -267,14 +279,18 @@ module Protip
 
     def method_missing_query(name, *args)
       field = message.class.descriptor.lookup(name[0, name.length - 1])
-      raise NoMethodError if !field || !self.class.matchable?(field)
-      if nil != Protip::Wrapper.enum_for_field(field)
-        raise ArgumentError unless args.length == 1
-        return matches?(field, args[0])
-      elsif self.class.boolean?(field)
-        !!get(field)
+      raise NoMethodError unless field
+
+      if nil != Protip::Decorator.enum_for_field(field) && args.length == 1
+        matches?(field, args[0])
+      elsif args.length == 0
+        value = get(field)
+
+        # Copied in from ActiveSupport +.blank?+
+        blank = (value.respond_to?(:empty?) ? !!value.empty? : !value)
+        !blank
       else
-        raise NoMethodError
+        raise ArgumentError
       end
     end
 

data/lib/protip/extensions.rb

@@ -3,7 +3,6 @@
 
 require 'google/protobuf'
 
-require 'google/protobuf/descriptor'
 Google::Protobuf::DescriptorPool.generated_pool.build do
 end
 

data/lib/protip/resource.rb

@@ -18,9 +18,11 @@ require 'active_model/dirty'
 
 require 'forwardable'
 
+require 'protip'
+require 'protip/client'
 require 'protip/error'
-require 'protip/standard_converter'
-require 'protip/wrapper'
+require 'protip/decorator'
+require 'protip/transformers/default_transformer'
 
 require 'protip/messages/array'
 
@@ -48,8 +50,8 @@ module Protip
       extend ActiveModel::Translation
       extend Forwardable
 
-      def_delegator :@wrapper, :message
-      def_delegator :@wrapper, :as_json
+      def_delegator :@decorator, :message
+      def_delegator :@decorator, :as_json
 
       # Initialize housekeeping variables
       @belongs_to_associations = Set.new
@@ -64,7 +66,7 @@ module Protip
 
       attr_reader :message, :nested_resources, :belongs_to_associations, :belongs_to_polymorphic_associations
 
-      attr_writer :base_path, :converter
+      attr_writer :base_path, :transformer
 
       def base_path
         if @base_path == nil
@@ -74,8 +76,8 @@ module Protip
         end
       end
 
-      def converter
-        @converter || (@_standard_converter ||= Protip::StandardConverter.new)
+      def transformer
+        @transformer || ::Protip.default_transformer
       end
 
       private
@@ -119,21 +121,19 @@ module Protip
       # 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}"
+          def_delegator :@decorator, :"#{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}?"
-          end
+          def_delegator :@decorator, :"#{field.name}"
+          def_delegator :@decorator, :"#{field.name}?"
 
           define_method "#{field.name}=" do |new_value|
             old_value = self.message[field.name] # Only compare the raw values
-            @wrapper.send("#{field.name}=", new_value)
+            @decorator.send("#{field.name}=", new_value)
             new_value = self.message[field.name]
 
             # Need to check that types are the same first, otherwise protobuf gets mad comparing
@@ -152,17 +152,29 @@ module Protip
         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
-              ::Protip::Resource::SearchMethods.show(self, id, wrapper.message)
+              message = nil
+              if query_params.is_a?(query)
+                message = query_params
+              else
+                decorator = ::Protip::Decorator.new(query.new, transformer)
+                decorator.assign_attributes query_params
+                message = decorator.message
+              end
+              ::Protip::Resource::SearchMethods.show(self, id, message)
             end
           end
 
           if actions.include?(:index)
             define_singleton_method :all do |query_params = {}|
-              wrapper = ::Protip::Wrapper.new(query.new, converter)
-              wrapper.assign_attributes query_params
-              ::Protip::Resource::SearchMethods.index(self, wrapper.message)
+              message = nil
+              if query_params.is_a?(query)
+                message = query_params
+              else
+                decorator = ::Protip::Decorator.new(query.new, transformer)
+                decorator.assign_attributes query_params
+                message = decorator.message
+              end
+              ::Protip::Resource::SearchMethods.index(self, message)
             end
           end
         else
@@ -183,9 +195,16 @@ module Protip
       def member(action:, method:, request: nil, response: nil)
         if request
           define_method action do |request_params = {}|
-            wrapper = ::Protip::Wrapper.new(request.new, self.class.converter)
-            wrapper.assign_attributes request_params
-            ::Protip::Resource::ExtraMethods.member self, action, method, wrapper.message, response
+            message = nil
+            if request_params.is_a?(request) # Message provided directly
+              message = request_params
+            else # Parameters provided by hash
+              decorator = ::Protip::Decorator.new(request.new, self.class.transformer)
+              decorator.assign_attributes request_params
+              message = decorator.message
+            end
+            ::Protip::Resource::ExtraMethods.member self,
+              action, method, message, response
           end
         else
           define_method action do
@@ -197,13 +216,16 @@ module Protip
       def collection(action:, method:, request: nil, response: nil)
         if request
           define_singleton_method action do |request_params = {}|
-            wrapper = ::Protip::Wrapper.new(request.new, converter)
-            wrapper.assign_attributes request_params
+            message = nil
+            if request_params.is_a?(request) # Message provided directly
+              message = request_params
+            else # Parameters provided by hash
+              decorator = ::Protip::Decorator.new(request.new, transformer)
+              decorator.assign_attributes request_params
+              message = decorator.message
+            end
             ::Protip::Resource::ExtraMethods.collection self,
-                                                        action,
-                                                        method,
-                                                        wrapper.message,
-                                                        response
+              action, method, message, response
           end
         else
           define_singleton_method action do
@@ -220,8 +242,9 @@ module Protip
       end
 
       def belongs_to_polymorphic(association_name, options = {}, &block)
-        # We evaluate the block in the context of a wrapper that stores simple belongs-to associations
-        # as they're being created.
+        # We evaluate the block in the context of a wrapper that
+        # stores simple belongs-to associations as they're being
+        # created.
         nested_association_creator = Class.new do
           attr_reader :associations
           def initialize(resource_class)
@@ -274,7 +297,7 @@ module Protip
         # since we might just assign attributes to the current instance of the message directly
         old_attributes[key] = field && field.type == :message && value ? value.clone : value
       end
-      @wrapper.assign_attributes attributes
+      @decorator.assign_attributes attributes
       keys.each do |key|
         old_value = old_attributes[key]
         new_value = message[key]
@@ -286,7 +309,8 @@ module Protip
     end
 
     def message=(message)
-      @wrapper = Protip::Wrapper.new(message, self.class.converter, self.class.nested_resources)
+      @decorator = Protip::Decorator.new(message,
+        self.class.transformer, self.class.nested_resources)
     end
 
     def save