protobuf-activerecord 1.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+*.db
+*.gem
+.DS_Store
+.bundle
+.config
+.yardoc
+Gemfile.lock
+coverage
+pkg/*
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--colour
+--format RSpec::Pride
+--order rand

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@protobuf-activerecord --create

data/Gemfile

@@ -0,0 +1,9 @@
+source 'http://gems.moneydesktop.com'
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in protobuf-activerecord.gemspec
+gemspec
+
+gem 'builder', '~> 3.0.3'
+
+gem 'timecop', '~> 0.3.5', :group => :development

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Adam Hutchison
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Protobuf ActiveRecord
+
+Protobuf Active Record provides the ability to create Active Record objects from Protocol Buffer messages and vice versa. It adds methods that allow you to create, update, and destroy Active Record objects from protobuf messages. It also provides methods to serialize Active Record objects to protobuf messages.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'protobuf-activerecord'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install protobuf-activerecord
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run specs (default)"
+task :default => :spec

data/lib/protoable/convert.rb

@@ -0,0 +1,75 @@
+module Protoable
+  module Convert
+    def self.included(klass)
+      klass.extend Protoable::Convert::ClassMethods
+    end
+
+    module ClassMethods
+      def convert_int64_to_time(int64)
+        Time.at(int64.to_i)
+      end
+
+      def convert_int64_to_date(int64)
+        convert_int64_to_time(int64).to_date
+      end
+
+      def convert_int64_to_datetime(int64)
+        convert_int64_to_time(int64).to_datetime
+      end
+
+      def _protobuf_convert_columns_to_fields(key, value)
+        value = case
+                when _protobuf_column_converters.has_key?(key.to_sym) then
+                  _protobuf_column_converters[key.to_sym].call(value)
+                when _protobuf_date_column?(key) then
+                  value.to_time.to_i
+                when _protobuf_datetime_column?(key) then
+                  value.to_i
+                when _protobuf_time_column?(key) then
+                  value.to_i
+                when _protobuf_timestamp_column?(key) then
+                  value.to_i
+                else
+                  value
+                end
+
+        return value
+      end
+
+      def _protobuf_convert_fields_to_columns(key, value)
+        value = case
+                when _protobuf_field_converters.has_key?(key.to_sym) then
+                  _protobuf_field_converters[key.to_sym].call(value)
+                when _protobuf_date_column?(key) then
+                  convert_int64_to_date(value)
+                when _protobuf_datetime_column?(key) then
+                  convert_int64_to_datetime(value)
+                when _protobuf_time_column?(key) then
+                  convert_int64_to_time(value)
+                when _protobuf_timestamp_column?(key) then
+                  convert_int64_to_time(value)
+                else
+                  value
+                end
+
+        return value
+      end
+
+      def _protobuf_date_column?(key)
+        _protobuf_column_types.fetch(:date, false) && _protobuf_column_types[:date].include?(key)
+      end
+
+      def _protobuf_datetime_column?(key)
+        _protobuf_column_types.fetch(:datetime, false) && _protobuf_column_types[:datetime].include?(key)
+      end
+
+      def _protobuf_time_column?(key)
+        _protobuf_column_types.fetch(:time, false) && _protobuf_column_types[:time].include?(key)
+      end
+
+      def _protobuf_timestamp_column?(key)
+        _protobuf_column_types.fetch(:timestamp, false) && _protobuf_column_types[:timestamp].include?(key)
+      end
+    end
+  end
+end

data/lib/protoable/errors.rb

@@ -0,0 +1,23 @@
+module Protoable
+
+  # = Protoable errors
+  #
+  # Generic Protoable exception class
+  class ProtoableError < StandardError
+  end
+
+  # Raised by Protoable.protobuf_column_convert when the convert method
+  # given is not defined, nil, or not callable.
+  class ColumnConverterError < ProtoableError
+  end
+
+  # Raised by Protoable.protobuf_column_transform when the transformer method
+  # given is not defined, nil, or not callable.
+  class ColumnTransformerError < ProtoableError
+  end
+  
+  # Raised by Protoable.protobuf_field_convert when the convert method
+  # given is not defined, nil, or not callable.
+  class FieldConverterError < ProtoableError
+  end
+end

data/lib/protoable/fields.rb

@@ -0,0 +1,116 @@
+require 'protoable/inheritable_class_instance_variables'
+
+module Protoable
+  module Fields
+    def self.extended(klass)
+      klass.extend Protoable::Fields::ClassMethods
+      klass.__send__(:include, Protoable::InheritableClassInstanceVariables)
+
+      klass.class_eval do
+        class << self
+          attr_accessor :_protobuf_columns, :_protobuf_column_types,
+            :_protobuf_column_transformers, :_protobuf_field_converters
+        end
+
+        @_protobuf_columns = {}
+        @_protobuf_column_types = Hash.new { |h,k| h[k] = [] }
+        @_protobuf_column_transformers = {}
+        @_protobuf_field_converters = {}
+
+        # NOTE: Make sure each inherited object has the database layout
+        inheritable_attributes :_protobuf_columns, :_protobuf_column_types,
+          :_protobuf_field_converters, :_protobuf_column_transformers
+      end
+
+      _protobuf_map_columns(klass)
+    end
+
+    # Map out the columns for future reference on type conversion
+    #
+    def self._protobuf_map_columns(klass)
+      return unless klass.table_exists?
+      klass.columns.map do |column|
+        klass._protobuf_columns[column.name.to_sym] = column
+        klass._protobuf_column_types[column.type.to_sym] << column.name.to_sym
+      end
+    end
+
+    module ClassMethods
+      # Define a field conversion from protobuf to db. Accepts a callable,
+      # Symbol, or Hash.
+      #
+      # When given a callable, it is directly used to convert the field.
+      #
+      # When a Hash is given, :from and :to keys are expected and expand
+      # to extracting a class method in the format of
+      # "convert_#{from}_to_#{to}".
+      #
+      # When a symbol is given, it extracts the method with the same name,
+      # if any. When method is not available it is assumed as the "from"
+      # data type, and the "to" value is extracted based on the
+      # name of the column.
+      #
+      # Examples:
+      #   convert_field :created_at, :int64
+      #   convert_field :public_key, method(:extract_public_key_from_proto)
+      #   convert_field :public_key, :extract_public_key_from_proto
+      #   convert_field :status, lambda { |proto_field| ... }
+      #   convert_field :symmetric_key, :base64
+      #   convert_field :symmetric_key, :from => :base64, :to => :encoded_string
+      #   convert_field :symmetric_key, :from => :base64, :to => :raw_string
+      #
+      def convert_field(field, callable = nil, &blk)
+        callable ||= blk
+
+        if callable.is_a?(Hash)
+          callable = :"convert_#{callable[:from]}_to_#{callable[:to]}"
+        end
+
+        if callable.is_a?(Symbol)
+          unless self.respond_to?(callable)
+            column = _protobuf_columns[field.to_sym]
+            callable = :"convert_#{callable}_to_#{column.try(:type)}"
+          end
+          callable = method(callable) if self.respond_to?(callable)
+        end
+
+        if callable.nil? || !callable.respond_to?(:call)
+          raise FieldConverterError, 'Field converters must be a callable or block!'
+        end
+
+        _protobuf_field_converters[field.to_sym] = callable
+      end
+
+      # Define a column transformation from protobuf to db. Accepts a callable,
+      # or Symbol.
+      #
+      # When given a callable, it is directly used to convert the field.
+      #
+      # When a symbol is given, it extracts the method with the same name.
+      #
+      # The callable or method must accept a single parameter, which is the
+      # proto message.
+      #
+      # Examples:
+      #   transform_column :public_key, :extract_public_key_from_proto
+      #   transform_column :status, lambda { |proto_field| ... }
+      #
+      def transform_column(field, callable = nil, &blk)
+        callable ||= blk
+
+        if callable.is_a?(Symbol)
+          unless self.respond_to?(callable)
+            raise ColumnTransformerError, "#{callable} is not defined!"
+          end
+          callable = method(callable) if self.respond_to?(callable)
+        end
+
+        if callable.nil? || !callable.respond_to?(:call)
+          raise ColumnTransformerError, 'Protoable casting needs a callable or block!'
+        end
+
+        _protobuf_column_transformers[field.to_sym] = callable
+      end
+    end
+  end
+end

data/lib/protoable/inheritable_class_instance_variables.rb

@@ -0,0 +1,54 @@
+require 'thread'
+
+module Protoable
+  module InheritableClassInstanceVariables
+    def self.included(klass)
+      Thread.exclusive do
+        klass.extend(Protoable::InheritableClassInstanceVariables::ClassMethods)
+
+        klass.class_eval do
+          @_inheritable_class_instance_variables = [ :_inheritable_class_instance_variables ]
+        end
+      end
+    end
+
+    module ClassMethods
+      def inheritable_attributes(*args)
+        Thread.exclusive do
+          args.flatten.compact.uniq.each do |class_instance_variable|
+            unless @_inheritable_class_instance_variables.include?(class_instance_variable)
+              @_inheritable_class_instance_variables << class_instance_variable
+            end
+          end
+
+          @_inheritable_class_instance_variables.each do |attr_symbol|
+            unless self.respond_to?("#{attr_symbol}")
+              class_eval %Q{
+                class << self; attr_reader :#{attr_symbol}; end
+              }
+            end
+
+            unless self.respond_to?("#{attr_symbol}=")
+              class_eval %Q{
+                class << self; attr_writer :#{attr_symbol}; end
+              }
+            end
+          end
+
+          @_inheritable_class_instance_variables
+        end
+      end
+
+      def inherited(klass)
+        super # ActiveRecord needs the inherited hook to setup fields
+
+        Thread.exclusive do
+          @_inheritable_class_instance_variables.each do |attribute|
+            attr_sym = :"@#{attribute}"
+            klass.instance_variable_set(attr_sym, self.instance_variable_get(attr_sym))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protoable/persistence.rb

@@ -0,0 +1,94 @@
+module Protoable
+  module Persistence
+    def self.included(klass)
+      klass.extend Protoable::Persistence::ClassMethods
+    end
+
+    module ClassMethods
+      # Filters accessible attributes that exist in the given protobuf message's
+      # fields or have column transformers defined for them.
+      #
+      # Returns a hash of attribute fields with their respective values.
+      #
+      def _filter_attribute_fields(proto)
+        fields = proto.to_hash
+        fields.select! { |key, value| proto.has_field?(key) && !proto.get_field_by_name(key).repeated? }
+
+        attributes = self.new.attributes.keys - protected_attributes.to_a
+
+        attribute_fields = attributes.inject({}) do |hash, column_name|
+          symbolized_column = column_name.to_sym
+
+          if fields.has_key?(symbolized_column) ||
+            _protobuf_column_transformers.has_key?(symbolized_column)
+            hash[symbolized_column] = fields[symbolized_column]
+          end
+
+          hash
+        end
+
+        attribute_fields
+      end
+
+      # Creates a hash of attributes from a given protobuf message.
+      #
+      # It converts and transforms field values using the field converters and
+      # column transformers, ignoring repeated and nil fields.
+      #
+      def attributes_from_proto(proto)
+        attribute_fields = _filter_attribute_fields(proto)
+
+        attributes = attribute_fields.inject({}) do |hash, (key, value)|
+          if _protobuf_column_transformers.has_key?(key)
+            hash[key] = _protobuf_column_transformers[key].call(proto)
+          else
+            hash[key] = _protobuf_convert_fields_to_columns(key, value)
+          end
+
+          hash
+        end
+
+        attributes
+      end
+
+      # Creates an object from the given protobuf message, if it's valid. The
+      # newly created object is returned if it was successfully saved or not.
+      #
+      def create_from_proto(proto)
+        attributes = attributes_from_proto(proto)
+
+        yield(attributes) if block_given?
+
+        record = self.new(attributes)
+
+        record.save! if record.valid?
+        return record
+      end
+    end
+
+    # Calls up to the class version of the method.
+    #
+    def attributes_from_proto(proto)
+      self.class.attributes_from_proto(proto)
+    end
+
+    # Destroys the record. Mainly wrapped to provide a consistent API and
+    # a convient way to override protobuf-specific destroy behavior.
+    #
+    def destroy_from_proto
+      destroy
+    end
+
+    # Update a record from a proto message. Accepts an optional block.
+    # If block is given, yields the attributes that would be updated.
+    #
+    def update_from_proto(proto)
+      attributes = attributes_from_proto(proto)
+
+      yield(attributes) if block_given?
+
+      assign_attributes(attributes)
+      return valid? ? save! : false
+    end
+  end
+end

data/lib/protoable/serialization.rb

@@ -0,0 +1,120 @@
+module Protoable
+  module Serialization
+    def self.included(klass)
+      klass.extend Protoable::Serialization::ClassMethods
+      klass.__send__(:include, Protoable::InheritableClassInstanceVariables)
+
+      klass.class_eval do
+        class << self
+          attr_accessor :_protobuf_column_converters, :protobuf_fields
+        end
+
+        @_protobuf_column_converters = {}
+        @protobuf_fields = []
+
+        # NOTE: Make sure each inherited object has the database layout
+        inheritable_attributes :protobuf_fields, :_protobuf_column_converters
+      end
+    end
+
+    module ClassMethods
+      # Define a column conversion from db to protobuf. Accepts a callable,
+      # Symbol, or Hash.
+      #
+      # When given a callable, it is directly used to convert the field.
+      #
+      # When a Hash is given, :from and :to keys are expected and expand
+      # to extracting a class method in the format of
+      # "convert_#{from}_to_#{to}".
+      #
+      # When a symbol is given, it extracts the method with the same name,
+      # if any. When method is not available it is assumed as the "from"
+      # data type, and the "to" value is extracted based on the
+      # name of the column.
+      #
+      # Examples:
+      #   convert_column :created_at, :int64
+      #   convert_column :public_key, :extract_public_key_from_proto
+      #   convert_column :public_key, method(:extract_public_key_from_proto)
+      #   convert_column :status, lambda { |proto_field| ... }
+      #   convert_column :symmetric_key, :from => :base64, :to => :raw_string
+      #
+      def convert_column(field, callable = nil, &blk)
+        callable ||= blk
+
+        if callable.is_a?(Hash)
+          callable = :"convert_#{callable[:from]}_to_#{callable[:to]}"
+        end
+
+        if callable.is_a?(Symbol)
+          unless self.respond_to?(callable)
+            column = _protobuf_columns[field.to_sym]
+            callable = :"convert_#{callable}_to_#{column.try(:type)}"
+          end
+          callable = method(callable) if self.respond_to?(callable)
+        end
+
+        if callable.nil? || !callable.respond_to?(:call)
+          raise ColumnConverterError, 'Column converters must be a callable or block!'
+        end
+
+        _protobuf_column_converters[field.to_sym] = callable
+      end
+
+      # Define the protobuf message class that should be used to serialize the
+      # object to protobuf. Accepts a string or symbol.
+      #
+      # When protobuf_message is declared, Protoable automatically extracts the
+      # fields from the message and automatically adds to_proto and to_proto_hash
+      # methods that serialize the object to protobuf.
+      #
+      # Examples:
+      #   protobuf_message :user_message
+      #   protobuf_message "UserMessage"
+      #   protobuf_message "Namespaced::UserMessage"
+      #
+      def protobuf_message(message = nil)
+        unless message.nil?
+          @_protobuf_message = message.to_s.classify.constantize
+
+          self.protobuf_fields = @_protobuf_message.fields.compact.map do |field|
+            field.name.to_sym
+          end
+
+          define_method(:to_proto) do
+            self.class.protobuf_message.new(self.to_proto_hash)
+          end
+
+          define_method(:to_proto_hash) do
+            protoable_attributes
+          end
+        end
+
+        @_protobuf_message
+      end
+    end
+
+    # Extracts attributes that correspond to fields on the specified protobuf
+    # message, performing any necessary column conversions on them.
+    #
+    def protoable_attributes
+      protoable_attributes = protobuf_fields.inject({}) do |hash, field|
+        value = respond_to?(field) ? __send__(field) : nil
+        hash[field] = _protobuf_convert_columns_to_fields(field, value)
+        hash
+      end
+
+      protoable_attributes
+    end
+
+  private
+
+    def _protobuf_convert_columns_to_fields(field, value)
+      self.class._protobuf_convert_columns_to_fields(field, value)
+    end
+
+    def protobuf_fields
+      self.class.protobuf_fields
+    end
+  end
+end

data/lib/protoable.rb

@@ -0,0 +1,15 @@
+require 'protoable/convert'
+require 'protoable/errors'
+require 'protoable/fields'
+require 'protoable/persistence'
+require 'protoable/serialization'
+
+module Protoable
+  def self.included(klass)
+    klass.extend Protoable::Fields
+
+    klass.__send__(:include, Protoable::Convert)
+    klass.__send__(:include, Protoable::Persistence)
+    klass.__send__(:include, Protoable::Serialization)
+  end
+end

data/lib/protobuf/activerecord/version.rb

@@ -0,0 +1,5 @@
+module Protobuf
+  module ActiveRecord
+    VERSION = "1.0.1"
+  end
+end

data/lib/protobuf-activerecord.rb

@@ -0,0 +1,3 @@
+require 'protoable'
+
+require 'protobuf/activerecord/version'

data/protobuf-activerecord.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'protobuf/activerecord/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "protobuf-activerecord"
+  gem.version       = Protobuf::ActiveRecord::VERSION
+  gem.authors       = ["Adam Hutchison"]
+  gem.email         = ["liveh2o@gmail.com"]
+  gem.homepage      = "http://github.com/liveh2o/protobuf-activerecord"
+  gem.summary       = %q{Google Protocol Buffers integration for Active Record}
+  gem.description   = %q{Provides the ability to create Active Record objects from Protocol Buffer messages and vice versa.}
+
+  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.require_paths = ["lib"]
+
+  ##
+  # Dependencies
+  #
+  gem.add_dependency "activerecord"
+  gem.add_dependency "protobuf", ">= 2.0"
+
+  ##
+  # Development dependencies
+  #
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "geminabox"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rspec-pride"
+  gem.add_development_dependency "pry-nav"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "timecop"
+end