protobuf-activerecord 1.0.3 → 1.0.4

data/lib/protoable/fields.rb

@@ -55,29 +55,26 @@ module Protoable
       #
       # 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)}"
+      def convert_field(field, transformer = nil, &blk)
+        transformer ||= blk
+        transformer = :"convert_#{transformer[:from]}_to_#{transformer[:to]}" if transformer.is_a?(Hash)
+
+        if transformer.is_a?(Symbol)
+          unless self.respond_to?(transformer, true)
+          column = _protobuf_columns[field.to_sym]
+            transformer = :"convert_#{transformer}_to_#{column.try(:type)}"
           end
-          callable = method(callable) if self.respond_to?(callable)
+
+          callable = lambda { |value| self.__send__(transformer, value) }
+        else
+          callable = transformer
         end
 
-        if callable.nil? || !callable.respond_to?(:call)
+        unless callable.respond_to?(:call)
           raise FieldConverterError, 'Field converters must be a callable or block!'
         end
 
@@ -98,17 +95,16 @@ module Protoable
       #   transform_column :public_key, :extract_public_key_from_proto
       #   transform_column :status, lambda { |proto_field| ... }
       #
-      def transform_column(field, callable = nil, &blk)
-        callable ||= blk
+      def transform_column(field, transformer = nil, &blk)
+        transformer ||= 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)
+        if transformer.is_a?(Symbol)
+          callable = lambda { |value| self.__send__(transformer, value) }
+        else
+          callable = transformer
         end
 
-        if callable.nil? || !callable.respond_to?(:call)
+        unless callable.respond_to?(:call)
           raise ColumnTransformerError, 'Protoable casting needs a callable or block!'
         end
 

data/lib/protoable/serialization.rb

@@ -41,22 +41,22 @@ module Protoable
       #   convert_column :status, lambda { |proto_field| ... }
       #   convert_column :symmetric_key, :from => :base64, :to => :raw_string
       #
-      def convert_column(field, callable = nil, &blk)
-        callable ||= blk
+      def convert_column(field, converter = nil, &blk)
+        converter ||= blk
+        converter = :"convert_#{converter[:from]}_to_#{converter[:to]}" if converter.is_a?(Hash)
 
-        if callable.is_a?(Hash)
-          callable = :"convert_#{callable[:from]}_to_#{callable[:to]}"
-        end
-
-        if callable.is_a?(Symbol)
-          unless self.respond_to?(callable)
+        if converter.is_a?(Symbol)
+          unless self.respond_to?(converter, true)
             column = _protobuf_columns[field.to_sym]
-            callable = :"convert_#{callable}_to_#{column.try(:type)}"
+            converter = :"convert_#{converter}_to_#{column.try(:type)}"
           end
-          callable = method(callable) if self.respond_to?(callable)
+
+          callable = lambda { |value| __send__(converter, value) }
+        else
+          callable = converter
         end
 
-        if callable.nil? || !callable.respond_to?(:call)
+        unless callable.respond_to?(:call)
           raise ColumnConverterError, 'Column converters must be a callable or block!'
         end
 

data/lib/protobuf/activerecord/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module ActiveRecord
-    VERSION = "1.0.3"
+    VERSION = "1.0.4"
   end
-end
+end

data/spec/protoable/fields_spec.rb

@@ -30,46 +30,30 @@ describe Protoable::Fields do
 
   describe ".convert_field" do
     context "when the given converter is a hash" do
-      let(:method) { User.method(:convert_base64_to_string) }
+      let(:method) { lambda { User.__send__(:convert_base64_to_string, value) } }
 
       before { User.convert_field :public_key, :from => :base64, :to => :string }
 
       it "determines the method using the hash's :to and :from keys" do
-        User._protobuf_field_converters[:public_key].should eq method
+        User.should_receive(:convert_base64_to_string)
+        User._protobuf_field_converters[:public_key].call(1)
       end
     end
 
     context "when the given converter is a symbol" do
-      context "when the converter is not a defined method" do
-        let(:callable) { User.method(:convert_base64_to_string) }
+      let(:callable) { lambda { User.__send__(:convert_email_to_lowercase, value) } }
 
-        before { User.convert_field :email, :base64 }
+      before { User.convert_field :email, :convert_email_to_lowercase }
 
-        it "determines the method using the converter as the 'from' and the column type as the 'to'" do
-          User._protobuf_field_converters[:email].should eq callable
-        end
-      end
-
-      context "when the converter is a defined method" do
-        let(:callable) { User.method(:convert_email_to_lowercase) }
-
-        before { User.convert_field :email, :convert_email_to_lowercase }
-
-        it "creates a callable method object from the converter" do
-          User._protobuf_field_converters[:email].should eq callable
-        end
-      end
-    end
-
-    context "when the given converter is nil" do
-      it "raises an exception" do
-        expect { User.convert_field :email, nil }.to raise_exception(Protoable::FieldConverterError)
+      it "creates a callable method object from the converter" do
+        User.should_receive(:convert_email_to_lowercase)
+        User._protobuf_field_converters[:email].call(1)
       end
     end
 
     context "when the given converter is not callable" do
       it "raises an exception" do
-        expect { User.convert_field :email, :foo }.to raise_exception(Protoable::FieldConverterError)
+        expect { User.convert_field :email, nil }.to raise_exception(Protoable::FieldConverterError)
       end
     end
 
@@ -86,32 +70,19 @@ describe Protoable::Fields do
 
   describe ".transform_column" do
     context "when the given converter is a symbol" do
-      context "when the converter is not a defined method" do
-        it "raises an exception" do
-          expect { User.transform_column :name, :foo }.to raise_exception(Protoable::ColumnTransformerError)
-        end
-      end
+      let(:callable) { lambda { |value| User.__send__(:extract_first_name) } }
 
-      context "when the converter is a defined method" do
-        let(:callable) { User.method(:extract_first_name) }
+      before { User.transform_column :first_name, :extract_first_name }
 
-        before { User.transform_column :first_name, :extract_first_name }
-
-        it "creates a callable method object from the converter" do
-          User._protobuf_column_transformers[:first_name].should eq callable
-        end
-      end
-    end
-
-    context "when the given converter is nil" do
-      it "raises an exception" do
-        expect { User.transform_column :name, nil }.to raise_exception(Protoable::ColumnTransformerError)
+      it "creates a callable method object from the converter" do
+        User.should_receive(:extract_first_name)
+        User._protobuf_column_transformers[:first_name].call(1)
       end
     end
 
     context "when the given converter is not callable" do
       it "raises an exception" do
-        expect { User.transform_column :name, double(:not_callable) }.to raise_exception(Protoable::ColumnTransformerError)
+        expect { User.transform_column :name, nil }.to raise_exception(Protoable::ColumnTransformerError)
       end
     end
 

data/spec/protoable/serialization_spec.rb

@@ -5,46 +5,30 @@ describe Protoable::Serialization do
 
   describe ".convert_column" do
     context "when the given converter is a hash" do
-      let(:method) { User.method(:convert_base64_to_string) }
+      let(:method) { lambda { |value| User.__send__(:convert_base64_to_string, value) } }
 
       before { User.convert_column :public_key, :from => :base64, :to => :string }
 
       it "determines the method using the hash's :to and :from keys" do
-        User._protobuf_column_converters[:public_key].should eq method
+        User.should_receive(:convert_base64_to_string)
+        User._protobuf_column_converters[:public_key].call(1)
       end
     end
 
     context "when the given converter is a symbol" do
-      context "when the converter is not a defined method" do
-        let(:callable) { User.method(:convert_base64_to_string) }
+      let(:callable) { lambda { |value| User.__send__(:convert_email_to_lowercase, value) } }
 
-        before { User.convert_column :email, :base64 }
+      before { User.convert_column :email, :convert_email_to_lowercase }
 
-        it "determines the method using the converter as the 'from' and the column type as the 'to'" do
-          User._protobuf_column_converters[:email].should eq callable
-        end
-      end
-
-      context "when the converter is a defined method" do
-        let(:callable) { User.method(:convert_email_to_lowercase) }
-
-        before { User.convert_column :email, :convert_email_to_lowercase }
-
-        it "creates a callable method object from the converter" do
-          User._protobuf_column_converters[:email].should eq callable
-        end
-      end
-    end
-
-    context "when the given converter is nil" do
-      it "raises an exception" do
-        expect { User.convert_column :email, nil }.to raise_exception(Protoable::ColumnConverterError)
+      it "creates a callable method object from the converter" do
+        User.should_receive(:convert_email_to_lowercase)
+        User._protobuf_column_converters[:email].call(1)
       end
     end
 
     context "when the given converter is not callable" do
       it "raises an exception" do
-        expect { User.convert_column :email, :foo }.to raise_exception(Protoable::ColumnConverterError)
+        expect { User.convert_column :email, nil }.to raise_exception(Protoable::ColumnConverterError)
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-activerecord
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-05 00:00:00.000000000 Z
+date: 2012-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -222,7 +222,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 763481842519497626
+      hash: 3415879493130708479
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -231,7 +231,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 763481842519497626
+      hash: 3415879493130708479
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24