protobuf-activerecord 1.2.6 → 2.0.0.beta

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

@@ -0,0 +1,140 @@
+require 'heredity/inheritable_class_instance_variables'
+
+module Protoable
+  module Transformation
+    def self.included(klass)
+      klass.extend Protoable::Transformation::ClassMethods
+      klass.__send__(:include, ::Heredity::InheritableClassInstanceVariables)
+
+      klass.class_eval do
+        class << self
+          attr_accessor :_protobuf_attribute_transformers
+        end
+
+        @_protobuf_attribute_transformers = {}
+
+        inheritable_attributes :_protobuf_attribute_transformers
+      end
+    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! { |key, value| proto.has_field?(key) && !proto.get_field_by_name(key).repeated? }
+
+        attribute_fields = attribute_names.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
+
+      # :nodoc:
+      def _protobuf_convert_fields_to_columns(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_columns(key, value)
+          end
+
+          hash
+        end
+
+        attributes
+      end
+
+      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
+    end
+
+    # Calls up to the class version of the method.
+    #
+    def attributes_from_proto(proto)
+      self.class.attributes_from_proto(proto)
+    end
+  end
+end

data/lib/protobuf/activerecord/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module ActiveRecord
-    VERSION = "1.2.6"
+    VERSION = "2.0.0.beta"
   end
 end

data/protobuf-activerecord.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |gem|
   #
   gem.add_dependency "activerecord"
   gem.add_dependency "heredity"
-  gem.add_dependency "protobuf", ">= 2.0"
+  gem.add_dependency "protobuf", ">= 2.1.3"
 
   ##
   # Development dependencies

data/spec/protoable/columns_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Protoable::Columns do
+  describe "._protobuf_map_columns" do
+    context "when the class has a table" do
+      let(:expected_column_names) {
+        User.columns.inject({}) do |hash, column|
+          hash[column.name.to_sym] = column
+          hash
+        end
+      }
+
+      let(:expected_column_types) {
+        User.columns.inject({}) do |hash, column|
+          hash[column.type.to_sym] ||= []
+          hash[column.type.to_sym] << column.name.to_sym
+          hash
+        end
+      }
+
+      it "maps columns by name" do
+        User._protobuf_columns.should eq expected_column_names
+      end
+
+      it "maps column names by column type" do
+        User._protobuf_column_types.should eq expected_column_types
+      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

data/spec/protoable/persistence_spec.rb

@@ -6,80 +6,6 @@ describe Protoable::Persistence do
   let(:proto_hash) { { :name => 'foo bar', :email => 'foo@test.co' } }
   let(:proto) { UserMessage.new(proto_hash) }
 
-  describe "._filter_attribute_fields" do
-    it "includes fields that have values" do
-      attribute_fields = User._filter_attribute_fields(proto)
-      attribute_fields[:email].should eq proto_hash[:email]
-    end
-
-    it "filters repeated fields" do
-      attribute_fields = User._filter_attribute_fields(proto)
-      attribute_fields.has_key?(:tags).should be_false
-    end
-
-    it "filters fields that map to protected attributes" do
-      User.stub(:protected_attributes).and_return([ "email" ])
-      attribute_fields = User._filter_attribute_fields(proto)
-      attribute_fields.has_key?(:email).should be_false
-    end
-
-    it "includes attributes that aren't fields, but have attribute transformers" do
-      User.stub(:_protobuf_attribute_transformers).and_return({ :account_id => :fetch_account_id })
-      attribute_fields = User._filter_attribute_fields(proto)
-      attribute_fields.has_key?(:account_id).should be_true
-    end
-  end
-
-  describe ".attributes_from_proto" do
-    context "when a transformer is defined for the attribute" do
-      it "transforms the field value" do
-        attribute_fields = User.attributes_from_proto(proto)
-        attribute_fields[:first_name].should eq user_attributes[:first_name]
-      end
-    end
-
-    context "when a transformer is a callable that returns nil" do
-      before do
-        transformers = User._protobuf_attribute_transformers
-        User.stub(:_protobuf_attribute_transformers).and_return(
-          {:account_id => lambda { |proto| nil }}.merge(transformers)
-        )
-      end
-
-      it "does not set the attribute" do
-        attribute_fields = User.attributes_from_proto(proto)
-        attribute_fields.should eq user_attributes
-      end
-    end
-
-    context "when a transformer is a callable that returns a value" do
-      before do
-        transformers = User._protobuf_attribute_transformers
-        User.stub(:_protobuf_attribute_transformers).and_return(
-          {:account_id => lambda { |proto| 1 }}.merge(transformers)
-        )
-      end
-
-      it "sets the attribute" do
-        attribute_fields = User.attributes_from_proto(proto)
-        attribute_fields.should eq user_attributes.merge(:account_id => 1)
-      end
-    end
-
-    context "when a transformer is not defined for the attribute" do
-      before {
-        User.stub(:_protobuf_convert_fields_to_columns) do |key, value|
-          value
-        end
-      }
-
-      it "converts the field value" do
-        attribute_fields = User.attributes_from_proto(proto)
-        attribute_fields.should eq user_attributes
-      end
-    end
-  end
-
   describe ".create" do
     it "accepts a protobuf message" do
       User.any_instance.should_receive(:save)
@@ -104,65 +30,7 @@ describe Protoable::Persistence do
     end
   end
 
-  describe ".create_from_proto" do
-    it "initializes a new object with attributes from the given protobuf message" do
-      user = User.create_from_proto(proto)
-      attributes = user.attributes.slice("first_name", "last_name", "email")
-      attributes.should eq user_attributes.stringify_keys
-    end
-
-    context "when a block is given" do
-      it "yields to the block with attributes from the given protobuf message" do
-        yielded = nil
-
-        User.create_from_proto(proto) do |attributes|
-          yielded = "boom!"
-        end
-
-        yielded.should eq "boom!"
-      end
-    end
-
-    context "when the object is valid" do
-      it "saves the record" do
-        user = User.create_from_proto(proto)
-        user.persisted?.should be_true
-      end
-
-      context "when an error occurs while saving" do
-        before { User.any_instance.stub(:create).and_raise(RuntimeError) }
-
-        it "raises an exception" do
-          expect { User.create_from_proto(proto) }.to raise_exception
-        end
-      end
-    end
-
-    context "when the object is not valid" do
-      before { User.any_instance.stub(:valid?).and_return(false) }
-
-      it "returns the new object, unsaved" do
-        user = User.create_from_proto(proto)
-        user.persisted?.should be_false
-      end
-    end
-  end
-
-  describe "#attributes_from_proto" do
-    it "gets attributes from the given protobuf message" do
-      User.should_receive(:attributes_from_proto).with(proto)
-      user.attributes_from_proto(proto)
-    end
-  end
-
-  describe "#destroy_from_proto" do
-    it "destroys the object" do
-      user.should_receive(:destroy)
-      user.destroy_from_proto
-    end
-  end
-
-  describe ".update_attributes" do
+  describe "#update_attributes" do
     it "accepts a protobuf message" do
       User.any_instance.should_receive(:save)
       user.update_attributes(proto)
@@ -174,7 +42,7 @@ describe Protoable::Persistence do
     end
   end
 
-  describe ".update_attributes!" do
+  describe "#update_attributes!" do
     it "accepts a protobuf message" do
       User.any_instance.should_receive(:save!)
       user.update_attributes!(proto)
@@ -185,50 +53,4 @@ describe Protoable::Persistence do
       user.update_attributes!(user_attributes)
     end
   end
-
-  describe "#update_from_proto" do
-    it "updates the object with attributes from the given protobuf message" do
-      user.should_receive(:assign_attributes).with(user_attributes, {})
-      user.update_from_proto(proto)
-    end
-
-    context "when a block is given" do
-      it "yields to the block with attributes from the given protobuf message" do
-        yielded = nil
-
-        user.update_from_proto(proto) do |attributes|
-          yielded = "boom!"
-        end
-
-        yielded.should eq "boom!"
-      end
-    end
-
-    context "when the object is valid" do
-      before { user.stub(:valid?).and_return(true) }
-
-      context "when saving is successful" do
-        it "returns true" do
-          user.stub(:assign_attributes).and_return(true)
-          user.update_from_proto(proto).should be_true
-        end
-      end
-
-      context "when an error occurs while saving" do
-        before { user.stub(:assign_attributes).and_raise(RuntimeError) }
-
-        it "raises an exception" do
-          expect { user.update_from_proto }.to raise_exception
-        end
-      end
-    end
-
-    context "when the object is invalid" do
-      before { user.stub(:valid?).and_return(false) }
-
-      it "returns false" do
-        user.update_from_proto(proto).should be_false
-      end
-    end
-  end
 end