protobuf-activerecord 1.2.6 → 2.0.0.beta

data/Gemfile

@@ -6,7 +6,3 @@ gemspec
 gem 'builder', '~> 3.0.4' # Builder 3.1.x is not supported by Active Record
                           # and Bundler has trouble resolving the dependency
                           # with Geminabox.
-
-gem 'timecop', '~> 0.3.5', :group => :development # Timecop 0.4.x is has a bug
-                                                  # when dealing with timezones
-                                                  # on Time objects.

data/lib/protobuf/activerecord/protoable.rb

@@ -1,17 +1,17 @@
-require 'protobuf/activerecord/protoable/convert'
+require 'protobuf/activerecord/protoable/columns'
 require 'protobuf/activerecord/protoable/errors'
-require 'protobuf/activerecord/protoable/fields'
 require 'protobuf/activerecord/protoable/persistence'
 require 'protobuf/activerecord/protoable/scope'
 require 'protobuf/activerecord/protoable/serialization'
+require 'protobuf/activerecord/protoable/transformation'
 
 module Protoable
   def self.included(klass)
-    klass.extend Protoable::Fields
     klass.extend Protoable::Scope
 
-    klass.__send__(:include, Protoable::Convert)
+    klass.__send__(:include, Protoable::Columns)
     klass.__send__(:include, Protoable::Persistence)
     klass.__send__(:include, Protoable::Serialization)
+    klass.__send__(:include, Protoable::Transformation)
   end
 end

data/lib/protobuf/activerecord/protoable/columns.rb

@@ -0,0 +1,56 @@
+require 'heredity/inheritable_class_instance_variables'
+
+module Protoable
+  module Columns
+    def self.included(klass)
+      klass.extend Protoable::Columns::ClassMethods
+      klass.__send__(:include, ::Heredity::InheritableClassInstanceVariables)
+
+      klass.class_eval do
+        class << self
+          attr_accessor :_protobuf_columns, :_protobuf_column_types
+        end
+
+        @_protobuf_columns = {}
+        @_protobuf_column_types = Hash.new { |h,k| h[k] = [] }
+
+        # NOTE: Make sure each inherited object has the database layout
+        inheritable_attributes :_protobuf_columns, :_protobuf_column_types
+      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
+      # :nodoc:
+      def _protobuf_date_column?(key)
+        _protobuf_column_types.fetch(:date, false) && _protobuf_column_types[:date].include?(key)
+      end
+
+      # :nodoc:
+      def _protobuf_datetime_column?(key)
+        _protobuf_column_types.fetch(:datetime, false) && _protobuf_column_types[:datetime].include?(key)
+      end
+
+      # :nodoc:
+      def _protobuf_time_column?(key)
+        _protobuf_column_types.fetch(:time, false) && _protobuf_column_types[:time].include?(key)
+      end
+
+      # :nodoc:
+      def _protobuf_timestamp_column?(key)
+        _protobuf_column_types.fetch(:timestamp, false) && _protobuf_column_types[:timestamp].include?(key)
+      end
+    end
+  end
+end

data/lib/protobuf/activerecord/protoable/errors.rb

@@ -6,21 +6,11 @@ module Protoable
   class ProtoableError < StandardError
   end
 
-  # Raised by Protoable.protoable_attribute when the convert method given is
-  # not callable.
-  class AttributeConverterError < ProtoableError
-  end
-
   # Raised by Protoable.attribute_from_proto when the transformer method
   # given is not callable.
   class AttributeTransformerError < ProtoableError
   end
 
-  # Raised by Protoable.convert_field when the convert method
-  # given not callable.
-  class FieldConverterError < ProtoableError
-  end
-  
   # Raised by Protoable.field_from_record when the convert method
   # given not callable.
   class FieldTransformerError < ProtoableError

data/lib/protobuf/activerecord/protoable/persistence.rb

@@ -17,62 +17,6 @@ module Protoable
     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.
-      #
-      def _filter_attribute_fields(proto)
-        fields = proto.to_hash
-        fields.select! { |key, value| proto.has_field?(key) && !proto.get_field_by_name(key).repeated? }
-
-        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
-
-      # Filters protected attributes from the available attributes list. When
-      # set through accessible attributes, returns the accessible attributes.
-      # When set through protected attributes, returns the attributes minus any
-      # protected attributes.
-      #
-      def _filtered_attributes
-        return accessible_attributes.to_a if accessible_attributes.present?
-
-        return self.attribute_names - protected_attributes.to_a
-      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_columns(key, value)
-          end
-
-          hash
-        end
-
-        attributes
-      end
-
       # :nodoc:
       def create(attributes, options = {}, &block)
         attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
@@ -86,17 +30,6 @@ module Protoable
 
         super(attributes, options)
       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, options = {})
-        attributes = attributes_from_proto(proto)
-
-        yield(attributes) if block_given?
-
-        self.create(attributes, options)
-      end
     end
 
     # :nodoc:
@@ -106,19 +39,6 @@ module Protoable
       super(attributes, options)
     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
-
     # :nodoc:
     def update_attributes(attributes, options = {})
       attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
@@ -132,16 +52,5 @@ module Protoable
 
       super(attributes, options)
     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, options = {})
-      attributes = attributes_from_proto(proto)
-
-      yield(attributes) if block_given?
-
-      update_attributes(attributes, options)
-    end
   end
 end

data/lib/protobuf/activerecord/protoable/scope.rb

@@ -4,7 +4,6 @@ module Protoable
       klass.class_eval do
         class << self
           alias_method :by_fields, :search_scope
-          alias_method :from_proto, :search_scope
           alias_method :scope_from_proto, :search_scope
         end
       end
@@ -34,7 +33,6 @@ module Protoable
     #   # Search starting with the default scope and searchable fields
     #   User.search_scope(request)
     #   User.by_fields(request)
-    #   User.from_proto(request)
     #   User.scope_from_proto(request)
     #
     def search_scope(proto)

data/lib/protobuf/activerecord/protoable/serialization.rb

@@ -8,20 +8,38 @@ module Protoable
 
       klass.class_eval do
         class << self
-          attr_accessor :_protobuf_attribute_converters,
-            :_protobuf_field_transformers, :protobuf_fields
+          attr_accessor :_protobuf_field_transformers, :_protobuf_field_options
         end
 
-        @_protobuf_attribute_converters = {}
         @_protobuf_field_transformers = {}
-        @protobuf_fields = []
+        @_protobuf_field_options = {}
 
-        inheritable_attributes :_protobuf_attribute_converters,
-          :_protobuf_field_transformers, :protobuf_fields, :protobuf_message
+        inheritable_attributes :_protobuf_field_transformers, :_protobuf_field_options,
+          :protobuf_message
       end
     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.
       #
@@ -39,8 +57,8 @@ module Protoable
       #     # Do some blocky stuff...
       #   end
       #
-      def field_from_record(field, transformer = nil, &blk)
-        transformer ||= blk
+      def field_from_record(field, transformer = nil, &block)
+        transformer ||= block
 
         if transformer.is_a?(Symbol)
           callable = lambda { |value| self.__send__(transformer, value) }
@@ -55,68 +73,37 @@ module Protoable
         _protobuf_field_transformers[field.to_sym] = callable
       end
 
-      # Define a custom attribute conversion for serialization to protobuf.
-      # Accepts a Symbol, Hash, callable or block.
-      #
-      # When given a callable or block, 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.
-      #
-      # Examples:
-      #   protoable_attribute :public_key, :extract_public_key_from_proto
-      #   protoable_attribute :symmetric_key, :from => :base64, :to => :raw_string
-      #   protoable_attribute :status, lambda { |proto_field| # Do stuff... }
-      #   protoable_attribute :status do |proto_field|
-      #     # Do some blocky stuff...
-      #   end
-      #
-      def protoable_attribute(field, converter = nil, &blk)
-        converter ||= blk
-        converter = :"convert_#{converter[:from]}_to_#{converter[:to]}" if converter.is_a?(Hash)
-
-        if converter.is_a?(Symbol)
-          callable = lambda { |value| __send__(converter, value) }
-        else
-          callable = converter
-        end
-
-        unless callable.respond_to?(:call)
-          raise AttributeConverterError, 'Attribute converters must be a callable or block!'
-        end
-
-        _protobuf_attribute_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.
+      # 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 to_proto and to_proto_hash
-      # methods that serialize the object to protobuf.
+      # 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)
+      def protobuf_message(message = nil, options = {})
         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
+          self._protobuf_field_options = options
 
-          define_method(:to_proto_hash) do
-            protoable_attributes
+          define_method(:to_proto) do |options = {}|
+            self.class.protobuf_message.new(self.fields_from_record(options))
           end
         end
 
@@ -124,11 +111,51 @@ module Protoable
       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.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.
     #
-    def protoable_attributes
-      protoable_attributes = protobuf_fields.inject({}) do |hash, field|
+    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
@@ -138,7 +165,7 @@ module Protoable
         hash
       end
 
-      protoable_attributes
+      field_attributes
     end
 
   private
@@ -150,9 +177,5 @@ module Protoable
     def _protobuf_field_transformers
       self.class._protobuf_field_transformers
     end
-
-    def protobuf_fields
-      self.class.protobuf_fields
-    end
   end
 end