sequel-protobuf 0.2.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTVjMDc0ODk3ZGE3Mzk5MjU3YmFjYzM2OWE2OGRmYWRlOTlmN2YzNA==
+  data.tar.gz: !binary |-
+    MmI0YmE0ODFjNTUzNDc4MWQyMzcwNjlhNGVjNGUyYWI4MjMyZDU0MA==
+SHA512:
+  metadata.gz: !binary |-
+    N2Q4N2Y2YzgyYmZiNDE4YTRkMjk0NGIzYzcyYzQ0MDA5YWMxOTY2ZmM3OTk4
+    NDQ4YjYzMmUxYjg1Mzk0YjBhMWFiOThhODY2OTZiMTM2MDI2MWIzNDBkNzhj
+    ZDk0OGNmZmRmY2FlMDgzOTRjM2MwMzcxNzVlMGIwOWYxYTgzZTA=
+  data.tar.gz: !binary |-
+    OGE0MzcwMDdhMmM3MGM3ZjU1MGRkOTVhMjE0NjU3Njg2NTc3MTA3ZGYxNmQ3
+    MGIxYjlkM2FiZDdlMDk2ZWU1MjY3OTE5YjFhNDIzNDBkMTM4YTQ0ZTRjY2Mz
+    N2JlNmFjMmQ3M2VkNDQ5YjYwNTc4OTIwZjVjMGU4YTJjYjI1OGU=

data/.gitignore

@@ -0,0 +1,5 @@
+coverage
+Gemfile.lock
+*.gem
+doc
+.yardoc

data/Gemfile

@@ -0,0 +1,14 @@
+source 'http://rubygems.org'
+
+gem 'rake'
+gem 'sequel'
+
+group :development, :test do
+  gem 'minitest'
+  gem 'simplecov'
+  gem 'mocha'
+  gem 'yard'
+  gem 'redcarpet'
+
+  gem 'ruby-protocol-buffers'
+end

data/README.md

@@ -0,0 +1,95 @@
+#sequel-protobuf
+[![Build Status](https://drone.io/github.com/kellydunn/sequel-protobuf/status.png)](https://drone.io/github.com/kellydunn/sequel-protobuf/latest)
+
+##what 
+
+A plugin for the `sequel` database library that enables `Sequel::Model` classes to be serialized into protocol buffers.
+
+##documentation
+
+Documentation can be found [here](http://rubydoc.info/github/kellydunn/sequel-protobuf/master/frames).
+
+##installation
+
+There is an intent to have this gem available through rubygems eventually, but for now, it's easiest to require the gem through `bundler` by specifying it in your `Gemfile`:
+
+**Gemfile**
+```
+gem 'sequel-protobuf', :git => "git@github.com/kellydunn/sequel-protobuf"
+```
+
+##usage
+
+In your `Sequel::Model` definition, require `sequel`, `sequel-protobuf`, a protocol buffer utility library of your choice (like `ruby-protocol-buffers`), and the corresponding protocol buffer model definition (the `.pb.rb` file that `ruby-protoc` generates).  Next, specify that you want your `Sequel::Model` class to use the `protobuf` plugin along with the class name of the protobuf model definition, like so:
+
+```
+require 'sequel'
+require 'sequel/plugins/protobuf'
+require 'protocol_buffers'
+require 'your/protocol/buffer/definitions/my_model_definition'
+
+class MyModel < Sequel::Model
+  plugin :protobuf, :model => MyModelDefinition
+end
+```
+
+Now you can create a new instance of your record, and call `to_protobuf` or `from_protobuf` on it!
+
+Simple `Sequel::Dataset` operations will also work as well!
+
+```
+5.times do 
+  MyModel.create()
+end
+
+result = MyModel.all.to_protobuf
+# result is an array of protocol buffer representations of each instance of {MyModel}!
+```
+
+##configuration
+
+As of `0.2.0`, `sequel-protobuf` provides the ability to render nested protocol buffer models, re-format data-types on demand, and override default protocol buffer definitions while rendering.  To do this, you may supply an options hash to the `to_protobuf` and `as_protobuf` methods with any of the following keys:
+
+  - `:include`: specifies nested protocol buffer models to render
+  - `:as`: specifies a different protocol buffer model definition in which to render the current object as
+  - `:coerce`: specifies how to re-format a specific data column of the current `Sequel::Model` such that it can fit your protocol buffer definition.
+
+###Example
+```
+require 'sequel'
+require 'sequel/plugins/protobuf'
+require 'protocol_buffers'
+require 'your/protocol/buffer/definitions/my_model_definition'
+
+class MyModel < Sequel::Model
+  plugin :protobuf, :model => MyModelDefinition
+  one_to_many :nested
+
+  def app_specific_as_protobuf
+    config = {
+      :as => DifferentModelDefinition,
+      :include => {
+        :nested => {}
+      }
+      :coerce => {
+        # We coerce the creatd_at time since Protocol Buffers
+        # do not support Time types by default.
+        # The reccomended approach is to set the unix timestamp value
+        # as a int64 type.
+        :created_at => Proc.new { |created_at|
+          created_at.utc.to_i
+        }
+      }
+    }
+
+    return self.as_protobuf(config)
+  end
+end
+```
+
+##considerations
+
+  - This library currently only supports `ruby-protocol-buffers` as a serialization driver.  If you are interested in adding additional driver support, feel free to open a Pull Request!
+
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/kellydunn/sequel-protobuf/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+

data/Rakefile

@@ -0,0 +1,7 @@
+desc "Run tests"
+task :test do
+  puts `ruby -I lib test/test_helper.rb`
+end
+
+desc "Default task: Runs tests"
+task :default => :test

data/lib/sequel/plugins/protobuf.rb

@@ -0,0 +1,195 @@
+require 'sequel/plugins/protobuf/drivers'
+
+# This module contains all functionality for the Sequel library.
+module Sequel
+  
+  # This module contains all Sequel plugin definitions.
+  module Plugins
+
+    # This module defines the Protobuf plugin for the Sequel database library
+    module Protobuf
+
+      # This error message indicates that a {Sequel::Model} definition
+      # that has been required by the client is missing a protobuf model definition.
+      class MissingProtobufDefinitionError < StandardError
+
+        # Creates a new instance of {Sequel::Plugins::Protobuf::MissingProtobufDefinitionError}
+        def initialize
+          super("Protobuf model definition was not specified.")
+        end
+      end
+
+      # This constant lists all of the current compatible drivers in sequel-protobuf
+      DRIVERS = {
+        :ruby_protocol_buffers => Sequel::Plugins::Protobuf::Drivers::RubyProtocolBuffers
+      }
+
+      # This constant defines the default driver for sequel-protobuf
+      # If clients do not specify a driver, sequel-protobuf assumes they 
+      # will use this gem.
+      DEFAULT_DRIVER = :ruby_protocol_buffers
+      
+      # Initializes the sequel-protobuf the first time it is registered for a class.
+      #
+      # @param model {Sequel::Model}. The {Sequel::Model} in which to register the plugin.
+      # @param options {Hash}. A configuration hash that is used to help configure the application.
+      def self.apply(model, options={})
+        # TODO no-op
+      end
+      
+      # Initializes the sequel-protobuf plugin for the passed in model
+      # with the passed in options
+      #
+      # @param model {Sequel::Model}. The {Sequel::Model} in which to register the plugin
+      # @param options {Hash}. A configuration hash to configure the plugin
+      def self.configure(model, options = {})
+        model.instance_eval {
+          if !options[:model]
+            raise Sequel::Plugins::Protobuf::MissingProtobufDefinitionError.new
+          else
+            @protobuf_model = options[:model]
+          end
+          
+          driver = options[:driver] ? options[:driver] : DEFAULT_DRIVER
+          @protobuf_driver = DRIVERS[driver]
+        }
+      end
+      
+      # When mixed in, this module provides the ability for objects 
+      # to be serialized from protocol buffer strings
+      module ClassMethods
+        attr_reader :protobuf_driver, :protobuf_model
+
+        # Creates and returns a new instance of the current class
+        # from the passed in protobuf message
+        #
+        # @param protobuf {String}. The protobuf message to parse.
+        # @param options {Hash}. An options hash that will configure the parsing.
+        def from_protobuf(protobuf, options = {})
+          pb_model = @protobuf_driver.parse(@protobuf_model, protobuf, options)
+
+          # Coerce data from protobuf array to a new model
+          model = self.send(:new)
+          model.columns.each do |v|
+            if pb_model.respond_to?("#{v}=".to_sym)
+              model.send("#{v}=", pb_model.send(v.to_sym))
+            end
+          end
+          
+          return model
+        end
+      end
+
+      # When mixed in, this module provides various instance-level methods that
+      # allow sequel models to be rendered into protocol buffers
+      # or rendered into a driver-specific model 
+      module InstanceMethods
+
+        # Renders the current instance of the model to a protocol buffer message
+        # as it is defined in the configured protocol buffer model definition.
+        #
+        # @param options {Hash}. An options hash that is used to configure how 
+        #                        the rendering is performed.
+        # @return {String}. A protocol buffer representation of the current {Sequel::Model} instance.
+        def to_protobuf(options = {})
+          return self.render(self, options).to_s
+        end
+
+        # Renders the current instance of the model to an instance of {::ProtocolBuffers::Message}.
+        # 
+        # @param options {Hash}.  An options hash that is used to configure how
+        #                         The rendering is performed.
+        # @return {Object}.  A representation of the model as an instance of the protocol_buffer model class
+        #                    configured at the instance level.
+        def as_protobuf(options = {})
+          return self.render(self, options)
+        end
+
+        # Renders the passed in key ans the corresponding protocol buffer model.
+        # The passed in options specifies how to do this with the following rules:
+        #   - `:include`  This key specifies that the current protocol buffer model has a nested
+        #                 Protocol buffer model to be rendered inside of it.
+        #   - `:coerce`   This key specifies that the current model can override a specific data
+        #                 value of a particular database column.  This is useful fo re-formatting
+        #                 data from your db schema so that they adhere to your protocol 
+        #                 buffer definitions.
+        #   - `:as`       This key specifies a different protocol buffer model to render the
+        #                 current object.
+        #
+        # @param current {Object}.  The current seciton of the schema to render.
+        # @param options {Hash}.  An options hash to configure how to render the current object.
+        def render(current, options={})
+
+          # If the current element in the schema is an array, 
+          # then we need to render them in sequence and return the result.
+          if current.is_a?(Array)
+            collection = current.inject([]) do |acc, element|
+              acc << render(element, options) 
+              acc
+            end
+
+            return collection
+
+          # Otherwise, if the record isn't nil, 
+          # we get the current values of the object and process them accordingly.
+          elsif !current.nil?
+            values = current.values.dup
+            
+            # If the options do not specifiy a protobuf model, assume the one configured earlier
+            if options.has_key?(:as) 
+              model = options[:as]
+            else
+              model = current.class.protobuf_model
+            end
+            
+            options.each do |k, v|
+              
+              # If the current key is "include", then recursively render the model specified
+              if k == :include
+                v.each do |model, opts|
+                  values.merge!({model => render(current.send(model.to_sym), opts)})
+                end
+
+              # If the current key is "coerce", then call the corresponding proc
+              # for the desired attribute
+              elsif k == :coerce
+                v.each do |value, proc|
+                  values[value] = proc.call(values[value])
+                end
+              end
+            end
+            
+            # Finally, return the result of creating a new protobuf model
+            return current.class.protobuf_driver.create(model, values)
+          end
+        end
+
+      end
+
+      # When mixed in, this module provides the ability for Sequel datasets to 
+      # call `to_protobuf`, which will return an array of serialized protobuf strings.
+      module DatasetMethods
+
+        # Renders the current dataset of the model into a collection of 
+        # protocol buffer messages as they are defined in the configured
+        # protocol buffer model definition.
+        #
+        # @param options {Hash}.  An options hash that is used to configure how
+        #                         the rendering is preformed.
+        # @return {Array}.  An array of protocol buffer messages.  Each element
+        #                   In the array is a serialized version of the corresponding
+        #                   object in the original dataset.
+        def to_protobuf(options = {})
+
+          res = self.all.inject([]) do |acc, obj|
+            acc << obj.to_protobuf(options)
+            acc
+          end
+          
+          return res
+          
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/protobuf/drivers.rb

@@ -0,0 +1 @@
+require 'sequel/plugins/protobuf/drivers/ruby-protocol-buffers-driver'

data/lib/sequel/plugins/protobuf/drivers/ruby-protocol-buffers-driver.rb

@@ -0,0 +1,64 @@
+module Sequel
+  module Plugins
+    module Protobuf
+      
+      # This module contains all the driver definitions for the sequel-protobuf gem.
+      module Drivers
+        
+        # This driver definition provides a standard interface
+        # for protocol buffer serialization with the `ruby-protocol-buffers` gem.
+        module RubyProtocolBuffers
+          
+          # Parses the passed in protobuf message into 
+          # an instance of the corresponding protocol buffer model definition
+          #
+          # @param protobuf_model {Object}.  The class of the protocol buffer definition
+          # @param protobuf {String}.  The protocol buffer message to be parsed
+          # @param options {Hash}.  An options hash to help configure the parsing functionality.
+          def self.parse(protobuf_model, protobuf, options = {})
+            return protobuf_model.send(:parse, protobuf)
+          end
+
+          # Serializes the passed in attributes hash into an instance of the passed in
+          # protocol buffer model definition.
+          #
+          # @param protobuf_model {Object}. The class of the protocol buffer definition
+          # @param attributes {Hash}.  The attributes in which to be serialized into a protocol buffer message
+          # @param options {Hash}.  An options hash to help configure the serialization funcitonality.
+          # @return {::ProtocolBuffers::Message}.  A newly created protocol buffer message
+          def self.serialize(protobuf_model, attributes, options = {})
+            return self.create(protobuf_model, attributes, options).to_s
+          end
+
+          # Creates and returns a new instance of the specified protobuf model 
+          # initialized with the passed in attributes and configured by the passed in optoins.
+          # 
+          # @param protobuf_model {Object}.  The protobuf model in which to render.
+          # @param attributes {Hash}.  A hash of attributes in which to create the new protobuf model
+          # @param options {Hash}.  A configuration hash in which to configure the creation of the
+          #                         New protocol buffer object.
+          # @return {::ProtocolBuffers::Message}.  A newly created protocol buffer message.
+          def self.create(protobuf_model, attributes, options = {})
+            fields = protobuf_model.fields.inject([]) do |acc, (k, v)| 
+              acc << v.name
+              acc
+            end
+            
+            attributes = attributes.inject({}) do |acc, (k, v)| 
+              if fields.include?(k)
+                acc[k] = v
+              end
+
+              acc
+            end
+            
+            return protobuf_model.send(:new, attributes)
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/sequel/plugins/protobuf/version.rb

@@ -0,0 +1,12 @@
+module Sequel
+  module Plugins
+    module Protobuf
+
+      # This constant describes the current version of the sequel-protobuf gem
+      # It currently makes use of the semantic-versioning specification.
+      # To learn more about semantic verisoning, visit http://semver.org/
+      VERSION="0.2.2"
+
+    end
+  end
+end

data/sequel-protobuf.gemspec

@@ -0,0 +1,16 @@
+require File.expand_path("../lib/sequel/plugins/protobuf/version.rb", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["kellydunn"]
+  gem.email         = ["defaultstring+sequel-protobuf@gmail.com"]
+  gem.description   = %q{Sequel plugin for protocol buffer serialization}
+  gem.summary       = %q{Sequel plugin for protocol buffer serialization}
+  gem.homepage      = 'http://github.com/kellydunn/sequel-protobuf'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'sequel-protobuf'
+  gem.require_paths = ['lib']
+  gem.version       = Sequel::Plugins::Protobuf::VERSION
+end

data/test/helpers/definition_error_sequel_model.rb

@@ -0,0 +1,6 @@
+require 'sequel'
+require 'sequel/plugins/protobuf'
+
+class DefinitionErrorSequelModel < Sequel::Model
+  plugin :protobuf
+end

data/test/helpers/models/test.pb.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+module Test
+  # forward declarations
+  class MyMessage < ::ProtocolBuffers::Message; end
+  class MyMessageWithNested < ::ProtocolBuffers::Message; end
+  class Nested < ::ProtocolBuffers::Message; end
+
+  class MyMessage < ::ProtocolBuffers::Message
+    set_fully_qualified_name "Test.MyMessage"
+
+    required :int64, :id, 1
+    optional :string, :myField, 2
+  end
+
+  class MyMessageWithNested < ::ProtocolBuffers::Message
+    set_fully_qualified_name "Test.MyMessageWithNested"
+
+    required :int64, :id, 1
+    optional :string, :myField, 2
+    repeated ::Test::Nested, :nested, 3
+  end
+
+  class Nested < ::ProtocolBuffers::Message
+    set_fully_qualified_name "Test.Nested"
+
+    required :int64, :id, 1
+    optional :string, :nestedField, 2
+  end
+
+end

data/test/helpers/models/test.proto

@@ -0,0 +1,17 @@
+package Test;
+
+message MyMessage {
+  required int64 id = 1;
+  optional string myField = 2;
+}
+
+message MyMessageWithNested {
+  required int64 id = 1;
+  optional string myField = 2;
+  repeated Nested nested = 3;
+}
+
+message Nested {
+  required int64 id = 1;
+  optional string nestedField = 2;
+}

data/test/helpers/my_message_sequel_model.rb

@@ -0,0 +1,8 @@
+require 'sequel'
+require 'sequel/plugins/protobuf'
+require 'test/helpers/nested_sequel_model'
+
+class MyMessageSequelModel < Sequel::Model
+  plugin :protobuf, :model => ::Test::MyMessage
+  one_to_many :nested, :class => NestedSequelModel
+end

data/test/helpers/nested_sequel_model.rb

@@ -0,0 +1,6 @@
+require 'sequel'
+require 'sequel/plugins/protobuf'
+
+class NestedSequelModel < Sequel::Model
+  plugin :protobuf, :model => ::Test::Nested
+end

data/test/sequel/plugins/protobuf/drivers/ruby_protocol_buffers_test.rb

@@ -0,0 +1,62 @@
+require 'sequel/plugins/protobuf/drivers/ruby-protocol-buffers-driver'
+
+class RubyProtocolBuffersDriverTest < Minitest::Test
+  # Ensures that a protocol buffer defition can be serailized as expected
+  # with ruby-protocol-buffers as the driver
+  def test_serialize
+    d = Sequel::Plugins::Protobuf::DRIVERS[:ruby_protocol_buffers]
+    res = d.serialize(::Test::MyMessage, {:id => 1, :myField => "test"})
+    assert_equal("\b\x01\x12\x04test", res)
+  end
+
+  # Ensures that the return type of the create method is that of the passed in protobuf model
+  def test_create
+    d = Sequel::Plugins::Protobuf::DRIVERS[:ruby_protocol_buffers]
+    res = d.create(::Test::MyMessage, {:id => 1, :myField => "test"})
+    assert_equal(res.class, ::Test::MyMessage)
+  end
+
+  # Ensures that result of serialize can read with the driver's call to `parse`
+  # Also ensures that a successful parse will result in a new protobuf model
+  # with the expected fields
+  def test_parse
+    d = Sequel::Plugins::Protobuf::DRIVERS[:ruby_protocol_buffers]
+    msg = ::Test::MyMessage.new({:id => 1, :myField => "test"})
+    res = d.serialize(::Test::MyMessage, {:id => 1, :myField => "test"})
+    res2 = d.parse(::Test::MyMessage, res)
+    assert_equal(msg, res2)
+    assert_equal(res2.myField, "test")
+  end
+
+  # Ensures that passing an attributes hash that is mismatched with the 
+  # Protobuf definition will be coerced into an acceptable attributes hash 
+  # such that it can be serialized as defined
+  def test_serialize_with_mismatched_attributes
+    e = nil
+    begin
+      d = Sequel::Plugins::Protobuf::DRIVERS[:ruby_protocol_buffers]
+      res = d.serialize(::Test::MyMessage, {:id => 1, :myField => "test", :garbage => "garbage_data"})
+      assert_equal("\b\x01\x12\x04test", res)
+    rescue ::Exception => e
+      # No-op
+    end
+
+    assert e.nil?, "We should not encounter an error when attempting to serialize a model with mismatched attributes"
+  end
+
+  # Ensures that we do encounter an error when an insufficent attributes hash
+  # Is passed to a call to serialization
+  def test_serialize_with_mismatched_attributes_error
+    e = nil
+    begin
+      d = Sequel::Plugins::Protobuf::DRIVERS[:ruby_protocol_buffers]
+      res = d.serialize(::Test::MyMessage, {})
+    rescue ::Exception => e
+      # No-op
+    end
+
+    assert !e.nil?, "We should encounter an error when attempting to serialize a model with insufficient attributes"
+    assert_equal e.class, ::ProtocolBuffers::EncodeError
+  end
+
+end

data/test/sequel/plugins/protobuf_test.rb

@@ -0,0 +1,135 @@
+$LOAD_PATH.unshift(".")
+
+require 'sequel/plugins/protobuf'
+
+class ProtobufTest < Minitest::Test
+  def test_mixin
+    require 'test/helpers/my_message_sequel_model'
+
+    m = MyMessageSequelModel.create
+    assert m.respond_to?(:to_protobuf), "A new sequel model should respond to `to_protobuf`"
+    assert m.class.respond_to?(:from_protobuf), "The class of a new sequel model should respond to `from_protobuf`"
+  end
+
+  def test_mixin_error
+    begin
+      require 'test/helpers/definition_error_sequel_model'
+    rescue Exception => e
+      assert_equal e.class, Sequel::Plugins::Protobuf::MissingProtobufDefinitionError
+      assert_equal e.to_s, "Protobuf model definition was not specified."
+    end
+  end
+
+  def test_to_protobuf
+    require 'test/helpers/my_message_sequel_model'
+
+    m = MyMessageSequelModel.create({:myField => "test"})
+    res = m.to_protobuf
+
+    assert_equal res, "\b\x01\x12\x04test"
+  end
+
+  def test_from_protobuf
+    require 'test/helpers/my_message_sequel_model'
+
+    m = MyMessageSequelModel.from_protobuf("\b\x01\x12\x04test")
+    
+    assert_equal m.id, 1
+    assert_equal m.myField, "test"
+    assert_equal m.class, MyMessageSequelModel
+  end
+
+  def test_as_protobuf
+    require 'test/helpers/my_message_sequel_model'
+
+    attributes = {:myField => "test", :extraField => "extra"}
+    m = MyMessageSequelModel.create(attributes)
+    proto = m.as_protobuf
+
+    attributes.delete(:extraField)
+    expected = attributes.merge({:id => m.id})
+
+    res = proto.fields.inject([]) do |acc, (k, v)|
+      acc << v.name
+      acc
+    end
+
+    assert_equal 1, proto.id
+    assert_equal "test", proto.myField
+    assert !proto.respond_to?(:extraField), "Expects protobuf model to not respond to a field that is not defined"
+  end
+
+  def test_dataset_to_protobuf
+    require 'test/helpers/my_message_sequel_model'
+
+    m = MyMessageSequelModel.create({:myField => "test"})
+    collection = MyMessageSequelModel.where(:myField => "test")
+
+    res = collection.to_protobuf
+
+    assert_equal(res.length, 1)
+    assert_equal(res[0], "\b\x01\x12\x04test")    
+  end
+
+  def test_to_protobuf_nested_model
+    require 'test/helpers/my_message_sequel_model'
+    require 'test/helpers/nested_sequel_model'
+
+    m = MyMessageSequelModel.create({:myField => "test"})
+    m2 = NestedSequelModel.create({:my_message_id => m.id, :nestedField => "test-nested"})
+
+    m.reload
+    res = m.to_protobuf({ 
+                          :as => ::Test::MyMessageWithNested,
+                          :include => {
+                            :nested => {
+                              :as => ::Test::Nested
+                            }
+                          }
+                        })
+
+    assert_equal(res, "\b\x01\x12\x04test\x1A\x0F\b\x01\x12\vtest-nested")
+    
+  end
+
+  def test_to_protobuf_with_coerced_keys
+    require 'test/helpers/my_message_sequel_model'
+    require 'test/helpers/nested_sequel_model'
+
+    m = MyMessageSequelModel.create({:myField => "test"})
+    m.reload
+ 
+    res = m.to_protobuf({ 
+                          :coerce => {
+                            :myField => Proc.new { |value|
+                              "#{value}-coerced"
+                            }
+                          }
+                        })
+
+    assert_equal("\b\x01\x12\ftest-coerced", res)
+    
+  end
+
+  # Ensures that coercing the values of a sequel model
+  # does not mutate the values hash of that particular instance.
+  def test_values_retention_after_rendering_with_coercion
+    require 'test/helpers/my_message_sequel_model'
+    require 'test/helpers/nested_sequel_model'
+
+    m = MyMessageSequelModel.create({:myField => "test"})
+    m.reload
+ 
+    res = m.to_protobuf({ 
+                          :coerce => {
+                            :myField => Proc.new { |value|
+                              "#{value}-coerced"
+                            }
+                          }
+                        })
+
+    assert_equal("\b\x01\x12\ftest-coerced", res)    
+    assert_equal("test", m.values[:myField])
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+
+# Simplecov needs to be required before test/unit
+# in order for the test suite runner to be tracked during code-coverage generation
+require 'simplecov'
+SimpleCov.start 
+
+require 'minitest'
+require 'minitest/autorun'
+require 'mocha/setup'
+require 'sequel'
+
+Sequel.mock(:fetch => [{ :id => 1, 
+                         :myField => "test", 
+                         :extraField => "extra",
+                         :nestedField => "test-nested"}], 
+
+            :columns => [:id, 
+                         :myField, 
+                         :extraField,
+                         :my_message_id,
+                         :nestedField])
+
+# Require all protobuf definitions
+Dir["**/*.pb.rb"].each do |f|
+  require File.absolute_path(f)
+end
+
+# Require unit tests
+Dir["**/*_test.rb"].each do |f|
+  require File.absolute_path(f)
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: sequel-protobuf
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- kellydunn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-26 00:00:00.000000000 Z
+dependencies: []
+description: Sequel plugin for protocol buffer serialization
+email:
+- defaultstring+sequel-protobuf@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/sequel/plugins/protobuf.rb
+- lib/sequel/plugins/protobuf/drivers.rb
+- lib/sequel/plugins/protobuf/drivers/ruby-protocol-buffers-driver.rb
+- lib/sequel/plugins/protobuf/version.rb
+- sequel-protobuf.gemspec
+- test/helpers/definition_error_sequel_model.rb
+- test/helpers/models/test.pb.rb
+- test/helpers/models/test.proto
+- test/helpers/my_message_sequel_model.rb
+- test/helpers/nested_sequel_model.rb
+- test/sequel/plugins/protobuf/drivers/ruby_protocol_buffers_test.rb
+- test/sequel/plugins/protobuf_test.rb
+- test/test_helper.rb
+homepage: http://github.com/kellydunn/sequel-protobuf
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Sequel plugin for protocol buffer serialization
+test_files:
+- test/helpers/definition_error_sequel_model.rb
+- test/helpers/models/test.pb.rb
+- test/helpers/models/test.proto
+- test/helpers/my_message_sequel_model.rb
+- test/helpers/nested_sequel_model.rb
+- test/sequel/plugins/protobuf/drivers/ruby_protocol_buffers_test.rb
+- test/sequel/plugins/protobuf_test.rb
+- test/test_helper.rb
+has_rdoc: