protobuf-activerecord 1.2.6 → 2.0.0.beta

data/spec/support/definitions/user.proto

@@ -2,7 +2,7 @@ message UserMessage {
   optional string guid         = 1;
   optional string name         = 2;
   optional string email        = 3;
-  optional string email_domain = 4;
+  optional string email_domain = 4 [deprecated = true];
 }
 
 message UserSearchMessage {

data/spec/support/models/user.rb

@@ -7,14 +7,6 @@ class User < ActiveRecord::Base
   attribute_from_proto :first_name, :extract_first_name
   attribute_from_proto :last_name, :extract_last_name
 
-  def self.convert_base64_to_string(value)
-    value
-  end
-
-  def self.convert_email_to_lowercase(value)
-    value
-  end
-
   def self.extract_first_name(proto)
     if proto.has_field?(:name)
       names = proto.name.split(" ")
@@ -34,6 +26,10 @@ class User < ActiveRecord::Base
     last_name
   end
 
+  def token
+    "key"
+  end
+
   def name
     "#{first_name} #{last_name}"
   end

data/spec/support/protobuf/user.pb.rb

@@ -17,7 +17,7 @@ class UserMessage
   optional ::Protobuf::Field::StringField, :guid, 1
   optional ::Protobuf::Field::StringField, :name, 2
   optional ::Protobuf::Field::StringField, :email, 3
-  optional ::Protobuf::Field::StringField, :email_domain, 4
+  optional ::Protobuf::Field::StringField, :email_domain, 4, :deprecated => true
 end
 
 class UserSearchMessage

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-activerecord
 version: !ruby/object:Gem::Version
-  version: 1.2.6
-  prerelease: 
+  version: 2.0.0.beta
+  prerelease: 6
 platform: ruby
 authors:
 - Adam Hutchison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-11 00:00:00.000000000 Z
+date: 2013-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.1.3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -203,20 +203,20 @@ files:
 - Rakefile
 - lib/protobuf-activerecord.rb
 - lib/protobuf/activerecord/protoable.rb
-- lib/protobuf/activerecord/protoable/convert.rb
+- lib/protobuf/activerecord/protoable/columns.rb
 - lib/protobuf/activerecord/protoable/errors.rb
-- lib/protobuf/activerecord/protoable/fields.rb
 - lib/protobuf/activerecord/protoable/persistence.rb
 - lib/protobuf/activerecord/protoable/scope.rb
 - lib/protobuf/activerecord/protoable/serialization.rb
+- lib/protobuf/activerecord/protoable/transformation.rb
 - lib/protobuf/activerecord/protobuf_ext/message.rb
 - lib/protobuf/activerecord/version.rb
 - protobuf-activerecord.gemspec
-- spec/protoable/convert_spec.rb
-- spec/protoable/fields_spec.rb
+- spec/protoable/columns_spec.rb
 - spec/protoable/persistence_spec.rb
 - spec/protoable/scope_spec.rb
 - spec/protoable/serialization_spec.rb
+- spec/protoable/transformation_spec.rb
 - spec/spec_helper.rb
 - spec/support/db.rb
 - spec/support/db/setup.rb
@@ -239,28 +239,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3337264365514211016
+      hash: -908655066687931093
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 3337264365514211016
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Google Protocol Buffers integration for Active Record
 test_files:
-- spec/protoable/convert_spec.rb
-- spec/protoable/fields_spec.rb
+- spec/protoable/columns_spec.rb
 - spec/protoable/persistence_spec.rb
 - spec/protoable/scope_spec.rb
 - spec/protoable/serialization_spec.rb
+- spec/protoable/transformation_spec.rb
 - spec/spec_helper.rb
 - spec/support/db.rb
 - spec/support/db/setup.rb

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

@@ -1,79 +0,0 @@
-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).utc.to_date
-      end
-
-      def convert_int64_to_datetime(int64)
-        convert_int64_to_time(int64).to_datetime
-      end
-
-      def _protobuf_convert_attributes_to_fields(key, value)
-        return value if value.nil?
-
-        value = case
-                when _protobuf_attribute_converters.has_key?(key.to_sym) then
-                  _protobuf_attribute_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)
-        return value if value.nil?
-
-        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/protobuf/activerecord/protoable/fields.rb

@@ -1,109 +0,0 @@
-require 'heredity/inheritable_class_instance_variables'
-
-module Protoable
-  module Fields
-    def self.extended(klass)
-      klass.extend Protoable::Fields::ClassMethods
-      klass.__send__(:include, ::Heredity::InheritableClassInstanceVariables)
-
-      klass.class_eval do
-        class << self
-          attr_accessor :_protobuf_columns, :_protobuf_column_types,
-            :_protobuf_attribute_transformers, :_protobuf_field_converters
-        end
-
-        @_protobuf_attribute_transformers = {}
-        @_protobuf_columns = {}
-        @_protobuf_column_types = Hash.new { |h,k| h[k] = [] }
-        @_protobuf_field_converters = {}
-
-        # NOTE: Make sure each inherited object has the database layout
-        inheritable_attributes :_protobuf_attribute_transformers, :_protobuf_columns,
-          :_protobuf_column_types, :_protobuf_field_converters
-      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 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:
-      #   convert_field :public_key, :extract_public_key_from_proto
-      #   convert_field :symmetric_key, :from => :base64, :to => :encoded_string
-      #   convert_field :status, lambda { |proto_field| # Do some stuff... }
-      #   convert_field :status do |proto_field|
-      #     # Do some blocky stuff...
-      #   end
-      #
-      def convert_field(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| self.__send__(converter, value) }
-        else
-          callable = converter
-        end
-
-        unless callable.respond_to?(:call)
-          raise FieldConverterError, 'Field converters must be a callable or block!'
-        end
-
-        _protobuf_field_converters[field.to_sym] = callable
-      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, &blk)
-        transformer ||= blk
-
-        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
-    end
-  end
-end

data/spec/protoable/convert_spec.rb

@@ -1,265 +0,0 @@
-require 'spec_helper'
-
-describe Protoable::Convert do
-  describe ".convert_int64_to_date" do
-    let(:date) { Date.current }
-    let(:int64) { date.to_time.to_i }
-
-    it "initializes a new Date object from the value" do
-      Timecop.freeze(Date.current) do
-        User.convert_int64_to_date(int64).should eq date
-      end
-    end
-  end
-
-  describe ".convert_int64_to_datetime" do
-    let(:datetime) { DateTime.current }
-    let(:int64) { datetime.to_time.to_i }
-
-    it "initializes a new DateTime object from the value" do
-      Timecop.freeze(DateTime.current) do
-        User.convert_int64_to_datetime(int64).should eq datetime
-      end
-    end
-  end
-
-  describe ".convert_int64_to_time" do
-    let(:time) { Time.current }
-    let(:int64) { time.to_time.to_i }
-
-    it "initializes a new Time object from the value" do
-      Timecop.freeze(Time.current) do
-        User.convert_int64_to_time(int64).should be_within(1).of(time)
-      end
-    end
-  end
-
-  describe "._protobuf_convert_attributes_to_fields" do
-    context "when there is a attribute converter for the field" do
-      let(:email_value) { "foo@test.co" }
-      let(:email_converter) { User.method(:convert_email_to_lowercase) }
-
-      before { User.stub(:_protobuf_attribute_converters).and_return({ :email => email_converter }) }
-
-      it "calls the attribute converter with the given value" do
-        email_converter.should_receive(:call).with(email_value)
-        User._protobuf_convert_attributes_to_fields(:email, email_value)
-      end
-
-      context "and it's corresponding column type has a default converter" do
-        before { User.stub(:_protobuf_date_column?).and_return(true) }
-
-        it "calls the attribute converter with the given value" do
-          email_converter.should_receive(:call).with(email_value)
-          User._protobuf_convert_attributes_to_fields(:email, email_value)
-        end
-      end
-    end
-
-    context "when the column type is :date" do
-      let(:date) { Date.current }
-      let(:integer) { date.to_time.to_i }
-
-      before { User.stub(:_protobuf_date_column?).and_return(true) }
-
-      it "converts the given value to an integer" do
-        User._protobuf_convert_attributes_to_fields(:foo_date, date).should eq integer
-      end
-    end
-
-    context "when the column type is :datetime" do
-      let(:datetime) { DateTime.current }
-      let(:integer) { datetime.to_time.to_i }
-
-      before { User.stub(:_protobuf_datetime_column?).and_return(true) }
-
-      it "converts the given value to an integer" do
-        User._protobuf_convert_attributes_to_fields(:foo_datetime, datetime).should eq integer
-      end
-    end
-
-    context "when the column type is :time" do
-      let(:time) { Time.current }
-      let(:integer) { time.to_time.to_i }
-
-      before { User.stub(:_protobuf_time_column?).and_return(true) }
-
-      it "converts the given value to an integer" do
-        User._protobuf_convert_attributes_to_fields(:foo_time, time).should eq integer
-      end
-    end
-
-    context "when the column type is :timestamp" do
-      let(:timestamp) { Time.current }
-      let(:integer) { timestamp.to_time.to_i }
-
-      before { User.stub(:_protobuf_timestamp_column?).and_return(true) }
-
-      it "converts the given value to an integer" do
-        User._protobuf_convert_attributes_to_fields(:foo_timestamp, timestamp).should eq integer
-      end
-    end
-
-    context "when no conversion is necessary" do
-      let(:value) { "Foo" }
-
-      it "returns the given value" do
-        User._protobuf_convert_attributes_to_fields(:foo, value).should eq value
-      end
-    end
-  end
-
-  describe "._protobuf_convert_fields_to_columns" do
-    let(:email_value) { "foo@test.co" }
-    let(:email_converter) { lambda { |value| value } }
-
-    before { User.stub(:_protobuf_field_converters).and_return({ :email => email_converter }) }
-
-    it "calls the field converter with the given value" do
-      email_converter.should_receive(:call).with(email_value)
-      User._protobuf_convert_fields_to_columns(:email, email_value)
-    end
-
-    context "and it's corresponding column type has a default converter" do
-      before { User.stub(:_protobuf_date_column?).and_return(true) }
-
-      it "calls the field converter with the given value" do
-        email_converter.should_receive(:call).with(email_value)
-        User._protobuf_convert_fields_to_columns(:email, email_value)
-      end
-    end
-
-    context "when the given field's corresponding column type is :date" do
-      let(:date) { Date.current }
-      let(:value) { date.to_time.to_i }
-
-      before { User.stub(:_protobuf_date_column?).and_return(true) }
-
-      it "converts the given value to a Date object" do
-        User._protobuf_convert_fields_to_columns(:foo_date, value).should eq date
-      end
-    end
-
-    context "when given field's corresponding the column type is :datetime" do
-      let(:datetime) { DateTime.current }
-      let(:value) { datetime.to_i }
-
-      before { User.stub(:_protobuf_datetime_column?).and_return(true) }
-
-      it "converts the given value to a DateTime object" do
-        User._protobuf_convert_fields_to_columns(:foo_datetime, value).should be_a(DateTime)
-      end
-
-      it "converts the given value to a DateTime object of the same value" do
-        User._protobuf_convert_fields_to_columns(:foo_datetime, value).should be_within(1).of(datetime)
-      end
-    end
-
-    context "when given field's corresponding the column type is :time" do
-      let(:time) { Time.current }
-      let(:value) { time.to_i }
-
-      before { User.stub(:_protobuf_time_column?).and_return(true) }
-
-      it "converts the given value to a Time object" do
-        User._protobuf_convert_fields_to_columns(:foo_time, value).should be_a(Time)
-      end
-
-      it "converts the given value to a Time object of the same value" do
-        User._protobuf_convert_fields_to_columns(:foo_time, value).should be_within(1).of(time)
-      end
-    end
-
-    context "when given field's corresponding the column type is :timestamp" do
-      let(:time) { Time.current }
-      let(:value) { time.to_i }
-
-      before { User.stub(:_protobuf_timestamp_column?).and_return(true) }
-
-      it "converts the given value to a Time object" do
-        User._protobuf_convert_fields_to_columns(:foo_time, value).should be_a(Time)
-      end
-
-      it "converts the given value to a Time object of the same value" do
-        User._protobuf_convert_fields_to_columns(:foo_timestamp, value).should be_within(1).of(time)
-      end
-    end
-
-    context "when no conversion is necessary" do
-      let(:value) { "Foo" }
-
-      it "returns the given value" do
-        User._protobuf_convert_fields_to_columns(:foo, value).should eq value
-      end
-    end
-  end
-
-  context "column type predicates" do
-    before { User.stub(:_protobuf_column_types).and_return(Hash.new) }
-    after { User.unstub(:_protobuf_column_types) }
-
-    describe "._protobuf_date_column?" do
-      before { User._protobuf_column_types[:date] = [ :foo_date ] }
-
-      context "when the column type is :date" do
-        it "is true" do
-          User._protobuf_date_column?(:foo_date).should be_true
-        end
-      end
-
-      context "when the column type is not :date" do
-        it "is false" do
-          User._protobuf_date_column?(:bar_date).should be_false
-        end
-      end
-    end
-
-    describe "._protobuf_datetime_column?" do
-      before { User._protobuf_column_types[:datetime] = [ :foo_datetime ] }
-
-      context "when the column type is :datetime" do
-        it "is true" do
-          User._protobuf_datetime_column?(:foo_datetime).should be_true
-        end
-      end
-
-      context "when the column type is not :datetime" do
-        it "is false" do
-          User._protobuf_datetime_column?(:bar_datetime).should be_false
-        end
-      end
-    end
-
-    describe "._protobuf_time_column?" do
-      before { User._protobuf_column_types[:time] = [ :foo_time ] }
-
-      context "when the column type is :time" do
-        it "is true" do
-          User._protobuf_time_column?(:foo_time).should be_true
-        end
-      end
-
-      context "when the column type is not :time" do
-        it "is false" do
-          User._protobuf_time_column?(:bar_time).should be_false
-        end
-      end
-    end
-
-    describe "._protobuf_timestamp_column?" do
-      before { User._protobuf_column_types[:timestamp] = [ :foo_timestamp ] }
-
-      context "when the column type is :timestamp" do
-        it "is true" do
-          User._protobuf_timestamp_column?(:foo_timestamp).should be_true
-        end
-      end
-
-      context "when the column type is not :timestamp" do
-        it "is false" do
-          User._protobuf_timestamp_column?(:bar_timestamp).should be_false
-        end
-      end
-    end
-  end
-end