protip 0.10.0 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1e044c1437371db39928f0e1ea08104e1a15554
-  data.tar.gz: 5672c792162be0304a20520d89d4f0a4a8cf1f4a
+  metadata.gz: f78ca1c3460fdd0b52a6c398e2837a0bb6d750fa
+  data.tar.gz: 5752105ecb4363cd8a681ea87008ed166c106018
 SHA512:
-  metadata.gz: 85bcbbde46db8f52a0b6e75f05b38192cbf1ca8be0c2c9ccd4eed63c3782cae17f09d290fd33a95590ce843c22c9ecd664b7965e07eee213b82a2015a251ca30
-  data.tar.gz: 0f7b09c74b2c57c16502083be6c0f5e5eeaffcb99fae9e474c6a785359ca8cdfbcc42ce80c052f1a46c566adf6ec97fb21a47d9f2de5fd93b023fed94c5f02e4
+  metadata.gz: 39c47fd2e35da1270a206c42785d8c7395f7402dc7c7f14064650970c3b9a1d2996b486c2fe92dc563911045b21484237764cb555bc0c8ed556d4e94db77af4e
+  data.tar.gz: f5bd09ed0b9dadff3f20a1723a7142c02588888316239373cd593d90623e558bca94245bc0de27780c517fc2757a97c1dc39ff492115e2382d623730949a7fd0

data/definitions/protip.proto

@@ -0,0 +1,2 @@
+import public "protip/messages/types.proto";
+import public "protip/messages/wrappers.proto";

data/definitions/protip/messages/array.proto

@@ -0,0 +1,6 @@
+// TODO: Move to plain protip namespace, use Any?
+package Protip.Messages;
+
+message Array {
+  repeated bytes messages = 1;
+}

data/definitions/protip/messages/errors.proto

@@ -0,0 +1,12 @@
+// TODO: move to plain protip namespace, use map type, change messages -> message
+package Protip.Messages;
+
+message Errors {
+  repeated string messages = 1;
+  repeated FieldError field_errors = 2;
+}
+
+message FieldError {
+  optional string field = 1;
+  optional string message = 2;
+}

data/definitions/protip/messages/types.proto

@@ -0,0 +1,7 @@
+package protip;
+
+message Date {
+  required int64 year = 1;
+  required uint32 month = 2;
+  required uint32 day = 3;
+}

data/definitions/protip/messages/wrappers.proto

@@ -0,0 +1,60 @@
+package protip;
+
+/////
+// Wrappers, copied from https://github.com/google/protobuf/blob/master/src/google/protobuf/wrappers.proto
+// These should exactly match the structure of those built-in types, so that users can safely swap them in
+// when upgrading to proto3.
+
+// Wrapper message for double.
+message DoubleValue {
+  // The double value.
+  required double value = 1;
+}
+
+// Wrapper message for float.
+message FloatValue {
+  // The float value.
+  required float value = 1;
+}
+
+// Wrapper message for int64.
+message Int64Value {
+  // The int64 value.
+  required int64 value = 1;
+}
+
+// Wrapper message for uint64.
+message UInt64Value {
+  // The uint64 value.
+  required uint64 value = 1;
+}
+
+// Wrapper message for int32.
+message Int32Value {
+  // The int32 value.
+  required int32 value = 1;
+}
+
+// Wrapper message for uint32.
+message UInt32Value {
+  // The uint32 value.
+  required uint32 value = 1;
+}
+
+// Wrapper message for bool.
+message BoolValue {
+  // The bool value.
+  required bool value = 1;
+}
+
+// Wrapper message for string.
+message StringValue {
+  // The string value.
+  required string value = 1;
+}
+
+// Wrapper message for bytes.
+message BytesValue {
+  // The bytes value.
+  required bytes value = 1;
+}

data/lib/protip/resource.rb

@@ -228,17 +228,15 @@ module Protip
       end
     end
 
-    def initialize(message_or_params = {})
+    def initialize(message_or_attributes = {})
       if self.class.message == nil
         raise RuntimeError.new('Must define a message class using `resource`')
       end
-      if message_or_params.is_a?(self.class.message)
-        self.message = message_or_params
+      if message_or_attributes.is_a?(self.class.message)
+        self.message = message_or_attributes
       else
         self.message = self.class.message.new
-        message_or_params.each do |field, value|
-          public_send :"#{field}=", value
-        end
+        @wrapper.assign_attributes message_or_attributes
       end
 
       super()

data/lib/protip/wrapper.rb

@@ -2,6 +2,11 @@ require 'active_support/concern'
 require 'protobuf'
 
 module Protip
+
+  # Wraps a protobuf message to allow:
+  # - getting/setting of certain 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
     attr_reader :message, :converter
     def initialize(message, converter)
@@ -33,6 +38,68 @@ module Protip
       end
     end
 
+    # Create a nested field on our message. For example, given the following definitions:
+    #
+    #   message Inner {
+    #     optional string str = 1;
+    #   }
+    #   message Outer {
+    #     optional Inner inner = 1;
+    #   }
+    #
+    # We could create an inner message using:
+    #
+    #   wrapper = Protip::Wrapper.new(Outer.new, converter)
+    #   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.
+    #
+    # @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
+    def build(field_name, attributes = {})
+
+      field = message.class.fields.detect{|field| field.name == field_name.to_sym}
+      if !field.is_a?(Protobuf::Field::MessageField)
+        raise "Not a message field: #{field_name}"
+      elsif converter.convertible?(field.type_class)
+        raise "Cannot build a convertible field: #{field.name}"
+      end
+
+      message[field_name] = field.type_class.new
+      wrapper = get(field)
+      wrapper.assign_attributes attributes
+      wrapper
+    end
+
+    # 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]
+    def assign_attributes(attributes)
+      attributes.each do |field_name, value|
+        field = message.class.fields.detect{|field| field.name == field_name.to_sym}
+
+        # For inconvertible nested messages, the value should be a hash - just pass it through to the nested message
+        if field.is_a?(Protobuf::Field::MessageField) && !converter.convertible?(field.type_class)
+          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 convertible message or a simple type, we set the value directly
+        else
+          set(field, value)
+        end
+      end
+
+      nil # Return nil to match ActiveRecord behavior
+    end
+
     def as_json
       json = {}
       message.class.fields.each do |name|

data/test/unit/protip/resource_test.rb

@@ -281,6 +281,42 @@ module Protip::ResourceTest # Namespace for internal constants
       end
     end
 
+    describe '#initialize' do
+      it 'fails if a resource definition has not yet been given' do
+        error = assert_raises RuntimeError do
+          resource_class.new
+        end
+        assert_equal 'Must define a message class using `resource`', error.message
+      end
+      describe 'when a message is given' do
+        before do
+          resource_class.class_eval do
+            resource actions: [], message: ResourceMessage
+          end
+        end
+
+        it 'creates a resource with an empty message if no attributes are provided' do
+          assert_equal ResourceMessage.new, resource_class.new.message
+        end
+
+        it 'allows a message to be provided directly' do
+          message = ResourceMessage.new(id: 1)
+          assert_equal message, resource_class.new(message).message
+        end
+
+        it 'sets attributes when a hash is given' do
+          attrs = {id: 2}
+          assert_equal ResourceMessage.new(attrs), resource_class.new(attrs).message
+        end
+
+        it 'delegates to `assign_attributes` on its wrapper object when a hash is given' do
+          attrs = {id: 3}
+          Protip::Wrapper.any_instance.expects(:assign_attributes).once.with({id: 3})
+          resource_class.new(attrs)
+        end
+      end
+    end
+
     describe '#save' do
       let :response do
         ResourceMessage.new(string: 'pit', string2: 'bull', id: 200)

data/test/unit/protip/wrapper_test.rb

@@ -12,6 +12,7 @@ module Protip::WrapperTest # namespace for internal constants
 
     class InnerMessage < ::Protobuf::Message
       required :int64, :value, 1
+      optional :string, :note, 2
     end
     class Message < ::Protobuf::Message
       optional InnerMessage, :inner, 1
@@ -44,6 +45,94 @@ module Protip::WrapperTest # namespace for internal constants
       end
     end
 
+    describe '#build' do
+      it 'raises an error when building a primitive field' do
+        assert_raises RuntimeError do
+          wrapper.build(:string)
+        end
+      end
+
+      it 'raises an error when building a convertible message' do
+        converter.stubs(:convertible?).with(InnerMessage).returns(true)
+        assert_raises RuntimeError do
+          wrapper.build(:inner)
+        end
+      end
+
+      describe 'with an inconvertible message field' do
+        let(:wrapped_message) { Message.new }
+
+        before do
+          converter.stubs(:convertible?).with(InnerMessage).returns(false)
+        end
+
+        it 'builds the message when no attributes are provided' do
+          assert_nil wrapped_message.inner # Sanity check
+          wrapper.build(:inner)
+          assert_equal InnerMessage.new, wrapped_message.inner
+        end
+
+        it 'overwrites the message if it exists' do
+          wrapped_message.inner = InnerMessage.new(value: 4)
+          wrapper.build(:inner)
+          assert_equal InnerMessage.new, wrapped_message.inner
+        end
+
+        it 'delegates to #assign_attributes if attributes are provided' do
+          Protip::Wrapper.any_instance.expects(:assign_attributes).once.with({value: 40})
+          wrapper.build(:inner, value: 40)
+        end
+
+        it 'returns the built message' do
+          built = wrapper.build(:inner)
+          assert_equal wrapper.inner, built
+        end
+      end
+    end
+
+    describe '#assign_attributes' do
+      it 'assigns primitive fields directly' do
+        wrapper.assign_attributes string: 'another thing'
+        assert_equal 'another thing', wrapped_message.string
+      end
+
+      it 'assigns convertible message fields directly' do
+        converter.stubs(:convertible?).with(InnerMessage).returns(true)
+        converter.expects(:to_message).once.with(45, InnerMessage).returns(InnerMessage.new(value: 43))
+        wrapper.assign_attributes inner: 45
+        assert_equal InnerMessage.new(value: 43), wrapped_message.inner
+      end
+
+      it 'returns nil' do
+        assert_nil wrapper.assign_attributes({})
+      end
+
+      describe 'when assigning inconvertible message fields' do
+        before do
+          converter.stubs(:convertible?).with(InnerMessage).returns(false)
+        end
+
+        it 'sets multiple attributes' do
+          wrapper.assign_attributes string: 'test2', inner: {value: 50}
+          assert_equal 'test2', wrapped_message.string
+          assert_equal InnerMessage.new(value: 50), wrapped_message.inner
+        end
+
+        it 'updates inconvertible message fields which have already been built' do
+          wrapped_message.inner = InnerMessage.new(value: 60)
+          wrapper.assign_attributes inner: {note: 'updated'}
+          assert_equal InnerMessage.new(value: 60, note: 'updated'), wrapped_message.inner
+        end
+
+        it 'delegates to itself when setting nested attributes on inconvertible message fields' do
+          inner = mock
+          wrapper.stubs(:get).with(wrapped_message.class.fields.detect{|f| f.name == :inner}).returns(inner)
+          inner.expects(:assign_attributes).once.with(value: 50, note: 'noted')
+          wrapper.assign_attributes inner: {value: 50, note: 'noted'}
+        end
+      end
+    end
+
     describe '#get' do
       it 'does not convert simple fields' do
         converter.expects(:convertible?).never

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protip
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.4
 platform: ruby
 authors:
 - AngelList
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-22 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -142,6 +142,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- definitions/protip.proto
+- definitions/protip/messages/array.proto
+- definitions/protip/messages/errors.proto
+- definitions/protip/messages/types.proto
+- definitions/protip/messages/wrappers.proto
 - lib/protip.rb
 - lib/protip/client.rb
 - lib/protip/converter.rb