protip 0.20.7 → 0.30.0

data/lib/protip/resource/extra_methods.rb

@@ -1,3 +1,5 @@
+require 'protip/decorator'
+
 module Protip
   module Resource
     # Internal helpers for non-resourceful member/collection methods. Never use these directly;
@@ -9,15 +11,15 @@ module Protip
           method: method,
           message: message,
           response_type: response_type
-        nil == response ? nil : ::Protip::Wrapper.new(response, resource.class.converter)
+        nil == response ? nil : ::Protip::Decorator.new(response, resource.class.transformer)
       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)
+        nil == response ? nil : ::Protip::Decorator.new(response, resource_class.transformer)
       end
     end
   end
-end
+end

data/lib/protip/tasks/compile.rake

@@ -10,10 +10,10 @@ namespace :protip do
     filename = args[:filename] || raise(ArgumentError.new 'filename argument is required')
 
     command = "protoc #{proto_path.map{|p| "--proto_path=#{Shellwords.escape p}"}.join ' '} --ruby_out=#{Shellwords.escape ruby_path} #{Shellwords.escape filename}"
-    puts command # is there a better way to log this?
+    puts command
     system command
 
-    ## hack around missing options in Ruby, remove when https://github.com/google/protobuf/issues/1198 is resolved
+    ## ridiculous hack around missing options in Ruby, remove when https://github.com/google/protobuf/issues/1198 is resolved
     package_match = File.read(filename).match(/package "?([a-zA-Z0-9\.]+)"?;/)
     package = (package_match ? package_match[1] : nil)
     ruby_file = filename.gsub(/^#{proto_path.first}\/?/, "#{ruby_path}/").gsub(/proto$/, 'rb') # Relies on a relative filename and proto path, which protoc requires anyway at this point

data/lib/protip/transformer.rb

@@ -0,0 +1,14 @@
+module Protip
+  # Interface for an object that converts between messages and more complex Ruby types. Resources and wrapped
+  # messages store one of these to transparently allow getting/setting of message fields as if they were
+  # Ruby types.
+  module Transformer
+    def to_object(message, field)
+      raise NotImplementedError.new('Must convert a message into a Ruby object')
+    end
+
+    def to_message(object, field)
+      raise NotImplementedError.new('Must convert a Ruby object into a message of the given type')
+    end
+  end
+end

data/lib/protip/transformers/abstract_transformer.rb

@@ -0,0 +1,11 @@
+require 'protip/transformer'
+
+module Protip
+  module Transformers
+    # Instantiable version of the +::Protip::Transformer+ concern,
+    # for when we need a placeholder transformer object.
+    class AbstractTransformer
+      include ::Protip::Transformer
+    end
+  end
+end

data/lib/protip/transformers/active_support/time_with_zone_transformer.rb

@@ -0,0 +1,35 @@
+require 'protip/transformer'
+require 'protip/messages/active_support/time_with_zone'
+
+module Protip
+  module Transformers
+    module ActiveSupport
+      module TimeWithZoneTransformer
+        include Protip::Transformer
+
+        def transformable?(message_class)
+          message_class == ::Protip::Messages::ActiveSupport::TimeWithZone
+        end
+
+        def to_object(message)
+          ActiveSupport::TimeWithZone.new(
+            Time.at(message.utc_timestamp).utc,
+            ActiveSupport::TimeZone.new(message.time_zone_name)
+          )
+        end
+
+        def to_message(value, message_class)
+          if !value.is_a?(::ActiveSupport::TimeWithZone) && (value.is_a?(Time) || value.is_a?(DateTime))
+            value = ::ActiveSupport::TimeWithZone.new(value.to_time.utc, ::ActiveSupport::TimeZone.new('UTC'))
+          end
+          raise ArgumentError unless value.is_a?(::ActiveSupport::TimeWithZone)
+
+          message_class.new(
+            utc_timestamp: value.to_i,
+            time_zone_name: value.time_zone.name,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/protip/transformers/decorating_transformer.rb

@@ -0,0 +1,33 @@
+require 'protip/decorator'
+require 'protip/transformer'
+
+module Protip
+  module Transformers
+    # A transformer which decorates all messages, passing in another
+    # transformer (generally a "parent" delegating transformer with
+    # this as its fallback) to the generated decorators. Allows
+    # cascading message decoration.
+    class DecoratingTransformer
+      include Protip::Transformer
+      def initialize(transformer)
+        @transformer = transformer
+      end
+
+      def to_object(message, field)
+        Protip::Decorator.new(message, @transformer)
+      end
+
+      def to_message(object, field)
+        if object.is_a?(Protip::Decorator)
+          object.message
+        elsif object.is_a?(Hash)
+          decorator = Protip::Decorator.new(field.subtype.msgclass.new, @transformer)
+          decorator.assign_attributes(object)
+          decorator.message
+        else
+          raise ArgumentError
+        end
+      end
+    end
+  end
+end

data/lib/protip/transformers/default_transformer.rb

@@ -0,0 +1,22 @@
+require 'protip/transformers/decorating_transformer'
+require 'protip/transformers/delegating_transformer'
+require 'protip/transformers/deprecated_transformer'
+require 'protip/transformers/enum_transformer'
+require 'protip/transformers/primitives_transformer'
+
+module Protip
+  module Transformers
+    # A transformer for our built-in types.
+    class DefaultTransformer < DelegatingTransformer
+      def initialize
+        # For message types that we don't recognize, just wrap them and pass
+        # ourself in as the transformer for their submessages.
+        super Protip::Transformers::DecoratingTransformer.new(self)
+
+        merge! Protip::Transformers::PrimitivesTransformer.new
+        merge! Protip::Transformers::EnumTransformer.new
+        merge! Protip::Transformers::DeprecatedTransformer.new
+      end
+    end
+  end
+end

data/lib/protip/transformers/delegating_transformer.rb

@@ -0,0 +1,44 @@
+require 'protip/transformer'
+require 'protip/transformers/abstract_transformer'
+
+module Protip
+  module Transformers
+    # A transformer which forwards to other transformers based on the message type
+    # being converted.
+    class DelegatingTransformer
+      include Protip::Transformer
+      extend Forwardable
+
+      # @param [Protip::Transformer] fallback_transformer The transformer to use
+      #   for messages that don't have a registered transformer already.
+      # @param [Hash<String, Protip::Transformer>] transformers A message_name => transformer
+      #   hash specifying which transformers to use for which message types.
+      def initialize(fallback_transformer = AbstractTransformer.new, transformers = {})
+        @fallback_transformer = fallback_transformer
+        @transformers = transformers.dup
+      end
+
+      def_delegators :@transformers, :[]=, :[], :keys
+
+      def merge!(delegating_transformer)
+        delegating_transformer.keys.each do |key|
+          self[key] = delegating_transformer[key]
+        end
+      end
+
+      def to_object(message, field)
+        transformer_for(field.submsg_name).to_object(message, field)
+      end
+
+      def to_message(object, field)
+        transformer_for(field.submsg_name).to_message(object, field)
+      end
+
+      private
+
+      def transformer_for(message_name)
+        @transformers[message_name] || @fallback_transformer
+      end
+    end
+  end
+end

data/lib/protip/transformers/deprecated_transformer.rb

@@ -0,0 +1,90 @@
+require 'protip/transformer'
+require 'protip/transformers/delegating_transformer'
+
+require 'active_support/time_with_zone'
+require 'money'
+
+# Temporary transformer for types that will be moved out to
+# user extensions.
+module Protip
+  module Transformers
+    class DeprecatedTransformer < DelegatingTransformer
+
+      def initialize
+        super
+        self['protip.messages.Currency'] = CurrencyTransformer.new
+        self['protip.messages.Money'] = MoneyTransformer.new
+        self['protip.messages.Date'] = DateTransformer.new
+        self['protip.messages.Range'] = RangeTransformer.new
+        self['protip.messages.ActiveSupport.TimeWithZone'] = TimeWithZoneTransformer.new
+      end
+
+      class CurrencyTransformer
+        include Protip::Transformer
+        def to_object(message, field)
+          message.currency_code
+        end
+        def to_message(object, field)
+          field.subtype.msgclass.new(currency_code: object)
+        end
+      end
+
+      class MoneyTransformer
+        include Protip::Transformer
+        def to_object(message, field)
+          ::Money.new(message.amount_cents, message.currency.currency_code)
+        end
+        def to_message(object, field)
+          raise ArgumentError unless object.is_a?(::Money)
+          currency = Protip::Messages::Currency.new(currency_code: object.currency.iso_code.to_sym)
+          field.subtype.msgclass.new(
+            amount_cents: object.fractional,
+            currency: currency,
+          )
+        end
+      end
+
+      class DateTransformer
+        include Protip::Transformer
+        def to_object(message, field)
+          ::Date.new(message.year, message.month, message.day)
+        end
+        def to_message(object, field)
+          raise ArgumentError unless object.is_a?(::Date)
+          field.subtype.msgclass.new(year: object.year, month: object.month, day: object.day)
+        end
+      end
+
+      class RangeTransformer
+        include Protip::Transformer
+        def to_object(message, field)
+          message.begin..message.end
+        end
+        def to_message(object, field)
+          field.subtype.msgclass.new(begin: object.begin.to_i, end: object.end.to_i)
+        end
+      end
+
+      class TimeWithZoneTransformer
+        include Protip::Transformer
+        def to_object(message, field)
+          ActiveSupport::TimeWithZone.new(
+            Time.at(message.utc_timestamp).utc,
+            ActiveSupport::TimeZone.new(message.time_zone_name)
+          )
+        end
+        def to_message(object, field)
+          if !object.is_a?(::ActiveSupport::TimeWithZone) && (object.is_a?(Time) || object.is_a?(DateTime))
+            object = ::ActiveSupport::TimeWithZone.new(object.to_time.utc, ::ActiveSupport::TimeZone.new('UTC'))
+          end
+          raise ArgumentError unless object.is_a?(::ActiveSupport::TimeWithZone)
+
+          field.subtype.msgclass.new(
+            utc_timestamp: object.to_i,
+            time_zone_name: object.time_zone.name,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/protip/transformers/enum_transformer.rb

@@ -0,0 +1,93 @@
+require 'protip/transformers/delegating_transformer'
+
+module Protip
+  module Transformers
+    class EnumTransformer < DelegatingTransformer
+      def initialize
+        super
+        self['protip.messages.EnumValue'] = ScalarTransformer.new
+        self['protip.messages.RepeatedEnum'] = ArrayTransformer.new
+      end
+
+      def self.enum_for_field(field)
+        Google::Protobuf::DescriptorPool.generated_pool.lookup(field.instance_variable_get(:'@_protip_enum_value'))
+      end
+
+      # Internal helper classes - under the hood we use separate transformers for
+      # the scalar and repeated cases, and both of them share transformation logic
+      # by inheriting from +SingleMessageEnumTransformer+.
+      class SingleMessageEnumTransformer
+        include Protip::Transformer
+        private
+        # Instance-level cached version of the class method above
+        def enum_for_field(field)
+          @enum_for_field_cache ||= {}
+          name = EnumTransformer.enum_for_field(field)
+          @enum_for_field_cache[name] ||= EnumTransformer.enum_for_field(field)
+
+          @enum_for_field_cache[name] ||
+            raise("protip_enum missing or invalid for field '#{field.name}'")
+        end
+
+        # Matches the protobuf enum setter behavior.
+        # Convert +:VALUE+ or +5+ to their corresponding enum integer value.
+        # @example
+        #   // foo.proto
+        #   enum Foo {
+        #     BAR = 0;
+        #     BAZ = 1;
+        #   }
+        #   // ScalarTransformer.to_int(:BAZ) # => 1
+        #   // ScalarTransformer.to_int(4) # => 4
+        def to_int(symbol_or_int, field)
+          if symbol_or_int.is_a?(Fixnum)
+            symbol_or_int
+          else
+            # Convert +.to_sym+ explicitly to allow strings (or other
+            # symobolizable objects) to be passed in to setters.
+            enum_for_field(field).lookup_name(symbol_or_int.to_sym) ||
+              raise(RangeError.new "unknown symbol value for field '#{field.name}'")
+          end
+        end
+
+        # Matches the protobuf enum getter behavior.
+        # Convert integers to their associated enum symbol, or pass them
+        # through if the
+        def to_symbol_or_int(int, field)
+          enum = EnumTransformer.enum_for_field(field) ||
+            raise("protip_enum missing or invalid for field '#{field.name}'")
+          enum.lookup_value(int) || int
+        end
+      end
+      private_constant :SingleMessageEnumTransformer
+
+      # For +protip.messages.EnumValue+
+      class ScalarTransformer < SingleMessageEnumTransformer
+        def to_object(message, field)
+          to_symbol_or_int(message.value, field)
+        end
+        def to_message(object, field)
+          field.subtype.msgclass.new(value: to_int(object, field))
+        end
+      end
+      private_constant :ScalarTransformer
+
+      # For +protip.messages.RepeatedEnum+
+      class ArrayTransformer < SingleMessageEnumTransformer
+        def to_object(message, field)
+          message.values.map do |value|
+            to_symbol_or_int(value, field)
+          end
+        end
+
+        def to_message(object, field)
+          values = (object.is_a?(::Enumerable) ? object : [object]).map do |value|
+            to_int(value, field)
+          end
+          field.subtype.msgclass.new(values: values)
+        end
+      end
+      private_constant :ArrayTransformer
+    end
+  end
+end

data/lib/protip/transformers/primitives_transformer.rb

@@ -0,0 +1,78 @@
+require 'protip/transformer'
+
+require 'protip/transformers/delegating_transformer'
+
+module Protip
+  module Transformers
+    # Transforms ints, strings, booleans, floats, and bytes to/from their
+    # well-known types (for scalars) and Protip repeated types.
+    class PrimitivesTransformer < DelegatingTransformer
+      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON']
+      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF']
+
+      def initialize
+        super
+        {
+          Int64:   :to_i.to_proc,
+          Int32:   :to_i.to_proc,
+          UInt64:  :to_i.to_proc,
+          UInt32:  :to_i.to_proc,
+          Double:  :to_f.to_proc,
+          Float:   :to_f.to_proc,
+          String:  :to_s.to_proc,
+          Bool:    ->(object) { to_boolean(object) },
+          Bytes:   ->(object) { object },
+        }.each do |type, transform|
+          self["google.protobuf.#{type}Value"] = ScalarTransformer.new(transform)
+          self["protip.messages.Repeated#{type}"] = ArrayTransformer.new(transform)
+        end          
+      end
+
+      private
+      def to_boolean(object)
+        return true if TRUE_VALUES.include?(object)
+        return false if FALSE_VALUES.include?(object)
+
+        object
+      end
+
+      # Helper transfomer for scalar well-known types.
+      class ScalarTransformer
+        # @param [Proc] transform Proc to convert a Ruby object to the
+        #   primitive type that we're transforming to.
+        def initialize(transform)
+          @transform = transform
+        end
+
+        def to_object(message, field)
+          message.value
+        end
+
+        def to_message(object, field)
+          value = @transform[object]
+          field.subtype.msgclass.new(value: value)
+        end
+      end
+      private_constant :ScalarTransformer
+
+      # Helper transformer for repeated types.
+      class ArrayTransformer
+        def initialize(transform)
+          @transform = transform
+        end
+
+        def to_object(message, field)
+          message.values.to_a.freeze
+        end
+
+        def to_message(object, field)
+          values = (object.is_a?(::Enumerable) ? object : [object]).map do |value|
+            @transform[value]
+          end
+          field.subtype.msgclass.new(values: values)
+        end
+      end
+      private_constant :ArrayTransformer
+    end
+  end
+end