protobuf-activerecord 2.1.0 → 3.0.0.pre

data/lib/protobuf/active_record/serialization.rb

@@ -0,0 +1,194 @@
+'active_support/concerns'
+'heredity'
+
+module Protobuf
+  module ActiveRecord
+    module Serialization
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::Heredity
+
+        class << self
+          attr_accessor :_protobuf_field_transformers, :_protobuf_field_options
+        end
+
+        @_protobuf_field_transformers = {}
+        @_protobuf_field_options = {}
+
+        inheritable_attributes :_protobuf_field_transformers,
+                               :_protobuf_field_options,
+                               :protobuf_message
+
+        private :_protobuf_convert_attributes_to_fields
+        private :_protobuf_field_transformers
+      end
+
+      module ClassMethods
+        # :nodoc:
+        def _protobuf_convert_attributes_to_fields(key, value)
+          return value if value.nil?
+
+          value = case
+                  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
+
+        # Define a field transformation from a record. Accepts a Symbol,
+        # callable, or block that is called with the record being serialized.
+        #
+        # When given a callable or block, 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:
+        #   field_from_record :public_key, :convert_public_key_to_proto
+        #   field_from_record :status, lambda { |record| # Do some stuff... }
+        #   field_from_record :status do |record|
+        #     # Do some blocky stuff...
+        #   end
+        #
+        def field_from_record(field, transformer = nil, &block)
+          transformer ||= block
+
+          if transformer.is_a?(Symbol)
+            callable = lambda { |value| self.__send__(transformer, value) }
+          else
+            callable = transformer
+          end
+
+          unless callable.respond_to?(:call)
+            raise FieldTransformerError, 'Attribute transformers need a callable or block!'
+          end
+
+          _protobuf_field_transformers[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 and an options hash.
+        #
+        # When protobuf_message is declared, Protoable automatically extracts the
+        # fields from the message and automatically adds a to_proto method that
+        # serializes the object to protobuf.
+        #
+        # The fields that will be automatically serialized can be configured by
+        # passing :only or :except in the options hash. If :only is specified, only
+        # the specified fields will be serialized. If :except is specified, all
+        # field except the specified fields will be serialized.
+        #
+        # By default, deprecated fields will be serialized. To exclude deprecated
+        # fields, pass :deprecated => false in the options hash.
+        #
+        # Examples:
+        #   protobuf_message :user_message
+        #   protobuf_message "UserMessage"
+        #   protobuf_message "Namespaced::UserMessage"
+        #   protobuf_message :user_message, :only => [ :guid, :name ]
+        #   protobuf_message :user_message, :except => :email_domain
+        #   protobuf_message :user_message, :except => :email_domain, :deprecated => false
+        #
+        def protobuf_message(message = nil, options = {})
+          unless message.nil?
+            @protobuf_message = message.to_s.classify.constantize
+
+            self._protobuf_field_options = options
+
+            define_method(:to_proto) do |options = {}|
+              self.class.protobuf_message.new(self.fields_from_record(options))
+            end
+          end
+
+          @protobuf_message
+        end
+      end
+
+      # :nodoc:
+      def _filter_field_attributes(options = {})
+        options = _normalize_options(options)
+
+        fields = _filtered_fields(options)
+        fields &= [ options[:only] ].flatten if options[:only].present?
+        fields -= [ options[:except] ].flatten if options[:except].present?
+
+        fields
+      end
+
+      # :nodoc:
+      def _filtered_fields(options = {})
+        exclude_deprecated = ! options.fetch(:deprecated, true)
+
+        fields = self.class.protobuf_message.all_fields.map do |field|
+          next if field.nil?
+          next if exclude_deprecated && field.deprecated?
+          field.name.to_sym
+        end
+        fields.compact!
+
+        fields
+      end
+
+      # :nodoc:
+      def _normalize_options(options)
+        options ||= {}
+        options[:only] ||= [] if options.fetch(:except, false)
+        options[:except] ||= [] if options.fetch(:only, false)
+
+        self.class._protobuf_field_options.merge(options)
+      end
+
+      # Extracts attributes that correspond to fields on the specified protobuf
+      # message, performing any necessary column conversions on them. Accepts a
+      # hash of options for specifying which fields should be serialized.
+      #
+      # Examples:
+      #   fields_from_record(:only => [ :guid, :name ])
+      #   fields_from_record(:except => :email_domain)
+      #   fields_from_record(:include => :email_domain)
+      #   fields_from_record(:except => :email_domain, :deprecated => false)
+      #
+      def fields_from_record(options = {})
+        field_attributes = _filter_field_attributes(options)
+        field_attributes += [ options.fetch(:include, []) ]
+        field_attributes.flatten!
+        field_attributes.compact!
+        field_attributes.uniq!
+
+        field_attributes = field_attributes.inject({}) do |hash, field|
+          if _protobuf_field_transformers.has_key?(field)
+            hash[field] = _protobuf_field_transformers[field].call(self)
+          else
+            value = respond_to?(field) ? __send__(field) : nil
+            hash[field] = _protobuf_convert_attributes_to_fields(field, value)
+          end
+          hash
+        end
+
+        field_attributes
+      end
+
+      # :nodoc:
+      def _protobuf_convert_attributes_to_fields(field, value)
+        self.class._protobuf_convert_attributes_to_fields(field, value)
+      end
+
+      # :nodoc:
+      def _protobuf_field_transformers
+        self.class._protobuf_field_transformers
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/transformation.rb

@@ -0,0 +1,155 @@
+require 'active_support/concern'
+require 'heredity/inheritable_class_instance_variables'
+
+module Protobuf
+  module ActiveRecord
+    module Transformation
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::Heredity::InheritableClassInstanceVariables
+
+        class << self
+          attr_accessor :_protobuf_attribute_transformers
+        end
+
+        @_protobuf_attribute_transformers = {}
+
+        inheritable_attributes :_protobuf_attribute_transformers
+      end
+
+      module ClassMethods
+        # Filters accessible attributes that exist in the given protobuf message's
+        # fields or have attribute transformers defined for them.
+        #
+        # Returns a hash of attribute fields with their respective values.
+        #
+        # :nodoc:
+        def _filter_attribute_fields(proto)
+          fields = proto.to_hash
+          fields.select! do |key, value|
+            field = proto.get_field_by_name(key) || proto.get_ext_field_by_name(key)
+            proto.has_field?(key) && !field.repeated?
+          end
+
+          attribute_fields = _filtered_attributes.inject({}) do |hash, column_name|
+            symbolized_column = column_name.to_sym
+
+            if fields.has_key?(symbolized_column) ||
+              _protobuf_attribute_transformers.has_key?(symbolized_column)
+              hash[symbolized_column] = fields[symbolized_column]
+            end
+
+            hash
+          end
+
+          attribute_fields
+        end
+
+        # Overidden by mass assignment security when protected attributes is loaded.
+        #
+        # :nodoc:
+        def _filtered_attributes
+          return self.attribute_names
+        end
+
+        # :nodoc:
+        def _protobuf_convert_fields_to_attributes(key, value)
+          return value if value.nil?
+
+          value = case
+                  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
+
+        # Define an attribute transformation from protobuf. Accepts a Symbol,
+        # callable, or block.
+        #
+        # When given a callable or block, 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:
+        #   attribute_from_proto :public_key, :extract_public_key_from_proto
+        #   attribute_from_proto :status, lambda { |proto| # Do some stuff... }
+        #   attribute_from_proto :status do |proto|
+        #     # Do some blocky stuff...
+        #   end
+        #
+        def attribute_from_proto(attribute, transformer = nil, &block)
+          transformer ||= block
+
+          if transformer.is_a?(Symbol)
+            callable = lambda { |value| self.__send__(transformer, value) }
+          else
+            callable = transformer
+          end
+
+          unless callable.respond_to?(:call)
+            raise AttributeTransformerError, 'Attribute transformers need a callable or block!'
+          end
+
+          _protobuf_attribute_transformers[attribute.to_sym] = callable
+        end
+
+
+        # Creates a hash of attributes from a given protobuf message.
+        #
+        # It converts and transforms field values using the field converters and
+        # attribute 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_attribute_transformers.has_key?(key)
+              attribute = _protobuf_attribute_transformers[key].call(proto)
+              hash[key] = attribute unless attribute.nil?
+            else
+              hash[key] = _protobuf_convert_fields_to_attributes(key, value)
+            end
+
+            hash
+          end
+
+          attributes
+        end
+
+        # :nodoc:
+        def convert_int64_to_time(int64)
+          Time.at(int64.to_i)
+        end
+
+        # :nodoc:
+        def convert_int64_to_date(int64)
+          convert_int64_to_time(int64).utc.to_date
+        end
+
+        # :nodoc:
+        def convert_int64_to_datetime(int64)
+          convert_int64_to_time(int64).to_datetime
+        end
+      end
+
+      # Calls up to the class version of the method.
+      #
+      def attributes_from_proto(proto)
+        self.class.attributes_from_proto(proto)
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/validations.rb

@@ -0,0 +1,43 @@
+require 'active_support/concern'
+
+module Protobuf
+  module ActiveRecord
+    module Validations
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        # Validates whether the value of the specified attribute is available in
+        # the given Protobuf Enum. The enumeration should be passed as a class
+        # that defines the enumeration:
+        #
+        # ```
+        # class User < ActiveRecord::Base
+        #   include ::Protoable
+        #
+        #   validates_enumeration_of :role_type, :with => RoleType, :allow_nil => true
+        # end
+        # ```
+        #
+        # In this example, RoleType is a defined as a protobuf enum.
+        #
+        # It accepts the same options as `validates_inclusion_of` (the :in option
+        # is automatically set and will be overwritten).
+        #
+        def validates_enumeration_of(*args)
+          options = args.extract_options!
+          enumerable = options.delete(:with)
+
+          raise ArgumentError, ":with must be specified" if enumerable.nil?
+
+          if enumerable < ::Protobuf::Enum
+            options[:in] = enumerable.values.values.map(&:value)
+          end
+
+          args << options
+
+          validates_inclusion_of(*args)
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/{activerecord → active_record}/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module ActiveRecord
-    VERSION = "2.1.0"
+    VERSION = "3.0.0.pre"
   end
 end

data/protobuf-activerecord.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'protobuf/activerecord/version'
+require 'protobuf/active_record/version'
 
 Gem::Specification.new do |gem|
   gem.name          = "protobuf-activerecord"
@@ -20,16 +20,15 @@ Gem::Specification.new do |gem|
   ##
   # Dependencies
   #
-  gem.add_dependency "activerecord", "~> 3.1"
-  gem.add_dependency "activesupport", "~> 3.1"
+  gem.add_dependency "activerecord", ">= 3.2.0"
+  gem.add_dependency "activesupport", ">= 3.2.0"
   gem.add_dependency "heredity"
-  gem.add_dependency "protobuf", ">= 2.1.3"
+  gem.add_dependency "protobuf", ">= 2.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"

data/spec/{protoable → protobuf/active_record}/columns_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Protoable::Columns do
+describe Protobuf::ActiveRecord::Columns do
   describe "._protobuf_map_columns" do
     context "when the class has a table" do
       let(:expected_column_names) {
@@ -27,7 +27,7 @@ describe Protoable::Columns do
       end
     end
   end
-  
+
   context "column type predicates" do
     before { User.stub(:_protobuf_column_types).and_return(Hash.new) }
     after { User.unstub(:_protobuf_column_types) }

data/spec/{protoable → protobuf/active_record}/persistence_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Protoable::Persistence do
+describe Protobuf::ActiveRecord::Persistence do
   let(:user) { User.new(user_attributes) }
   let(:user_attributes) { { :first_name => 'foo', :last_name => 'bar', :email => 'foo@test.co' } }
   let(:proto_hash) { { :name => 'foo bar', :email => 'foo@test.co' } }