protobuf-activerecord 1.0.5 → 1.1.0

data/Rakefile

@@ -1,4 +1,4 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 desc "Run specs"
@@ -6,3 +6,15 @@ RSpec::Core::RakeTask.new(:spec)
 
 desc "Run specs (default)"
 task :default => :spec
+
+desc "Remove protobuf definitions that have been compiled"
+task :clean do
+  FileUtils.rm(Dir.glob("spec/support/protobuf/**/*.proto"))
+  puts "Cleaned"
+end
+
+desc "Compile spec/support protobuf definitions"
+task :compile, [] => :clean do
+  cmd = "rprotoc --ruby_out=spec/support/protobuf --proto_path=spec/support/definitions spec/support/definitions/*.proto"
+  sh(cmd)
+end

data/lib/protoable.rb

@@ -2,11 +2,13 @@ require 'protoable/convert'
 require 'protoable/errors'
 require 'protoable/fields'
 require 'protoable/persistence'
+require 'protoable/scope'
 require 'protoable/serialization'
 
 module Protoable
   def self.included(klass)
     klass.extend Protoable::Fields
+    klass.extend Protoable::Scope
 
     klass.__send__(:include, Protoable::Convert)
     klass.__send__(:include, Protoable::Persistence)

data/lib/protoable/convert.rb

@@ -17,10 +17,10 @@ module Protoable
         convert_int64_to_time(int64).to_datetime
       end
 
-      def _protobuf_convert_columns_to_fields(key, value)
+      def _protobuf_convert_attributes_to_fields(key, value)
         value = case
-                when _protobuf_column_converters.has_key?(key.to_sym) then
-                  _protobuf_column_converters[key.to_sym].call(value)
+                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

data/lib/protoable/errors.rb

@@ -6,18 +6,22 @@ module Protoable
   class ProtoableError < StandardError
   end
 
-  # Raised by Protoable.protobuf_column_convert when the convert method
-  # given is not defined, nil, or not callable.
-  class ColumnConverterError < ProtoableError
+  # Raised by Protoable.protoable_attribute when the convert method given is
+  # not callable.
+  class AttributeConverterError < ProtoableError
   end
 
-  # Raised by Protoable.protobuf_column_transform when the transformer method
-  # given is not defined, nil, or not callable.
-  class ColumnTransformerError < ProtoableError
+  # Raised by Protoable.attribute_from_proto when the transformer method
+  # given is not callable.
+  class AttributeTransformerError < ProtoableError
   end
-  
-  # Raised by Protoable.protobuf_field_convert when the convert method
-  # given is not defined, nil, or not callable.
+
+  # Raised by Protoable.convert_field when the convert method
+  # given not callable.
   class FieldConverterError < ProtoableError
   end
+
+  # Raised by Protoable.field_scope when given scope is not defined.
+  class SearchScopeError < ProtoableError
+  end
 end

data/lib/protoable/fields.rb

@@ -9,20 +9,17 @@ module Protoable
       klass.class_eval do
         class << self
           attr_accessor :_protobuf_columns, :_protobuf_column_types,
-            :_protobuf_column_transformers, :_protobuf_field_converters
-
-          alias_method :convert_field_to_column, :convert_field
-          alias_method :transform_column_from_proto, :transform_column
+            :_protobuf_attribute_transformers, :_protobuf_field_converters
         end
 
+        @_protobuf_attribute_transformers = {}
         @_protobuf_columns = {}
         @_protobuf_column_types = Hash.new { |h,k| h[k] = [] }
-        @_protobuf_column_transformers = {}
         @_protobuf_field_converters = {}
 
         # NOTE: Make sure each inherited object has the database layout
-        inheritable_attributes :_protobuf_columns, :_protobuf_column_types,
-          :_protobuf_field_converters, :_protobuf_column_transformers
+        inheritable_attributes :_protobuf_attribute_transformers, :_protobuf_columns,
+          :_protobuf_column_types, :_protobuf_field_converters
       end
 
       _protobuf_map_columns(klass)
@@ -39,39 +36,33 @@ module Protoable
     end
 
     module ClassMethods
-      # Define a field conversion from protobuf to db. Accepts a callable,
-      # Symbol, or Hash.
+      # Define a field conversion from protobuf to db. Accepts a Symbol,
+      # Hash, callable or block.
       #
-      # When given a callable, it is directly used to convert the field.
+      # 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,
-      # if any. When method is not available it is assumed as the "from"
-      # data type, and the "to" value is extracted based on the
-      # name of the column.
+      # When a symbol is given, it extracts the method with the same name.
       #
       # Examples:
-      #   convert_field :created_at, :int64
       #   convert_field :public_key, :extract_public_key_from_proto
-      #   convert_field :status, lambda { |proto_field| ... }
       #   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, transformer = nil, &blk)
-        transformer ||= blk
-        transformer = :"convert_#{transformer[:from]}_to_#{transformer[:to]}" if transformer.is_a?(Hash)
+      def convert_field(field, converter = nil, &blk)
+        converter ||= blk
+        converter = :"convert_#{converter[:from]}_to_#{converter[:to]}" if converter.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 = lambda { |value| self.__send__(transformer, value) }
+        if converter.is_a?(Symbol)
+          callable = lambda { |value| self.__send__(converter, value) }
         else
-          callable = transformer
+          callable = converter
         end
 
         unless callable.respond_to?(:call)
@@ -81,10 +72,10 @@ module Protoable
         _protobuf_field_converters[field.to_sym] = callable
       end
 
-      # Define a column transformation from protobuf to db. Accepts a callable,
-      # or Symbol.
+      # Define an attribute transformation from protobuf. Accepts a Symbol,
+      # callable, or block.
       #
-      # When given a callable, it is directly used to convert the field.
+      # 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.
       #
@@ -92,10 +83,13 @@ module Protoable
       # proto message.
       #
       # Examples:
-      #   transform_column :public_key, :extract_public_key_from_proto
-      #   transform_column :status, lambda { |proto_field| ... }
+      #   attribute_from_proto :public_key, :extract_public_key_from_proto
+      #   attribute_from_proto :status, lambda { |proto_field| # Do some stuff... }
+      #   attribute_from_proto :status do |proto_field|
+      #     # Do some blocky stuff...
+      #   end
       #
-      def transform_column(field, transformer = nil, &blk)
+      def attribute_from_proto(field, transformer = nil, &blk)
         transformer ||= blk
 
         if transformer.is_a?(Symbol)
@@ -105,10 +99,15 @@ module Protoable
         end
 
         unless callable.respond_to?(:call)
-          raise ColumnTransformerError, 'Protoable casting needs a callable or block!'
+          raise AttributeTransformerError, 'Attribute transformers need a callable or block!'
         end
 
-        _protobuf_column_transformers[field.to_sym] = callable
+        _protobuf_attribute_transformers[field.to_sym] = callable
+      end
+
+      def transform_column(field, transformer = nil, &blk)
+        warn "[DEPRECATION] `transform_column` is deprecated and will be removed in v1.2.  Please use `attribute_from_proto` instead."
+        attribute_from_proto(field, transformer, &blk)
       end
     end
   end

data/lib/protoable/persistence.rb

@@ -6,7 +6,7 @@ module Protoable
 
     module ClassMethods
       # Filters accessible attributes that exist in the given protobuf message's
-      # fields or have column transformers defined for them.
+      # fields or have attribute transformers defined for them.
       #
       # Returns a hash of attribute fields with their respective values.
       #
@@ -20,7 +20,7 @@ module Protoable
           symbolized_column = column_name.to_sym
 
           if fields.has_key?(symbolized_column) ||
-            _protobuf_column_transformers.has_key?(symbolized_column)
+            _protobuf_attribute_transformers.has_key?(symbolized_column)
             hash[symbolized_column] = fields[symbolized_column]
           end
 
@@ -33,14 +33,14 @@ module Protoable
       # Creates a hash of attributes from a given protobuf message.
       #
       # It converts and transforms field values using the field converters and
-      # column transformers, ignoring repeated and nil fields.
+      # 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_column_transformers.has_key?(key)
-            hash[key] = _protobuf_column_transformers[key].call(proto)
+          if _protobuf_attribute_transformers.has_key?(key)
+            hash[key] = _protobuf_attribute_transformers[key].call(proto)
           else
             hash[key] = _protobuf_convert_fields_to_columns(key, value)
           end

data/lib/protoable/scope.rb

@@ -0,0 +1,64 @@
+module Protoable
+  module Scope
+    def self.extended(klass)
+      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
+    end
+
+    # Define fields that should be searchable via `search_scope`. Accepts a
+    # protobuf field and an already defined scope.
+    #
+    # Examples:
+    #
+    #   class User < ActiveRecord::Base
+    #     scope :by_guid, lambda { |*guids| where(:guid => guids) }
+    #
+    #     field_scope :guid, :by_guid
+    #   end
+    #
+    def field_scope(field, scope_name)
+      unless self.respond_to?(scope_name)
+        raise Protoable::SearchScopeError, "Undefined scope :#{scope_name}. :#{scope_name} must be defined before it can be used as a field scope."
+      end
+
+      searchable_fields[field] = scope_name
+    end
+
+    # Builds and returns a Arel relation based on the fields that are present
+    # in the given protobuf message using the searchable fields to determine
+    # what scopes to use. Provides several aliases for variety.
+    #
+    # Examples:
+    #
+    #   # 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)
+      relation = scoped # Get an ARel relation to build off of
+
+      searchable_fields.each do |field, scope_name|
+        next unless proto.respond_to_and_has_and_present?(field)
+
+        values = [ proto.__send__(field) ].flatten
+        values.map!(&:to_i) if proto.get_field_by_name(field).enum?
+
+        relation = relation.__send__(scope_name, *values)
+      end
+
+      return relation
+    end
+
+    # :noapi:
+    def searchable_fields
+      @_searchable_fields ||= {}
+    end
+  end
+end

data/lib/protoable/serialization.rb

@@ -8,60 +8,56 @@ module Protoable
 
       klass.class_eval do
         class << self
-          attr_accessor :_protobuf_column_converters, :protobuf_fields
-
-          alias_method :convert_column_to_field, :convert_column
+          attr_accessor :_protobuf_attribute_converters, :protobuf_fields
         end
 
-        @_protobuf_column_converters = {}
+        @_protobuf_attribute_converters = {}
         @protobuf_fields = []
 
-        inheritable_attributes :_protobuf_column_converters, :protobuf_fields, :protobuf_message
+        inheritable_attributes :_protobuf_attribute_converters, :protobuf_fields, :protobuf_message
       end
     end
 
     module ClassMethods
-      # Define a column conversion from db to protobuf. Accepts a callable,
-      # Symbol, or Hash.
+      def convert_column(field, converter = nil, &blk)
+        warn "[DEPRECATION] `convert_column` is deprecated and will be removed in v1.2.  Please use `protoable_attribute` instead."
+        protoable_attribute(field, converter, &blk)
+      end
+
+      # Define a custom attribute conversion for serialization to protobuf.
+      # Accepts a Symbol, Hash, callable or block.
       #
-      # When given a callable, it is directly used to convert the field.
+      # 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,
-      # if any. When method is not available it is assumed as the "from"
-      # data type, and the "to" value is extracted based on the
-      # name of the column.
+      # When a symbol is given, it extracts the method with the same name.
       #
       # Examples:
-      #   convert_column :created_at, :int64
-      #   convert_column :public_key, :extract_public_key_from_proto
-      #   convert_column :public_key, method(:extract_public_key_from_proto)
-      #   convert_column :status, lambda { |proto_field| ... }
-      #   convert_column :symmetric_key, :from => :base64, :to => :raw_string
+      #   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 convert_column(field, converter = nil, &blk)
+      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)
-          unless self.respond_to?(converter, true)
-            column = _protobuf_columns[field.to_sym]
-            converter = :"convert_#{converter}_to_#{column.try(:type)}"
-          end
-
           callable = lambda { |value| __send__(converter, value) }
         else
           callable = converter
         end
 
         unless callable.respond_to?(:call)
-          raise ColumnConverterError, 'Column converters must be a callable or block!'
+          raise AttributeConverterError, 'Attribute converters must be a callable or block!'
         end
 
-        _protobuf_column_converters[field.to_sym] = callable
+        _protobuf_attribute_converters[field.to_sym] = callable
       end
 
       # Define the protobuf message class that should be used to serialize the
@@ -103,7 +99,7 @@ module Protoable
     def protoable_attributes
       protoable_attributes = protobuf_fields.inject({}) do |hash, field|
         value = respond_to?(field) ? __send__(field) : nil
-        hash[field] = _protobuf_convert_columns_to_fields(field, value)
+        hash[field] = _protobuf_convert_attributes_to_fields(field, value)
         hash
       end
 
@@ -112,8 +108,8 @@ module Protoable
 
   private
 
-    def _protobuf_convert_columns_to_fields(field, value)
-      self.class._protobuf_convert_columns_to_fields(field, value)
+    def _protobuf_convert_attributes_to_fields(field, value)
+      self.class._protobuf_convert_attributes_to_fields(field, value)
     end
 
     def protobuf_fields

data/lib/protobuf-activerecord.rb

@@ -1,3 +1,5 @@
+require 'protobuf_ext/message'
+
 require 'protoable'
 
 require 'protobuf/activerecord/version'

data/lib/protobuf/activerecord/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module ActiveRecord
-    VERSION = "1.0.5"
+    VERSION = "1.1.0"
   end
 end

data/lib/protobuf_ext/message.rb

@@ -0,0 +1,12 @@
+require 'protobuf'
+
+class Protobuf::Message
+  def respond_to_and_has?(key)
+    self.respond_to?(key) && self.has_field?(key)
+  end
+
+  def respond_to_and_has_and_present?(key)
+    self.respond_to_and_has?(key) &&
+      (self.__send__(key).present? || [true, false].include?(self.__send__(key)))
+  end
+end

data/spec/protoable/convert_spec.rb

@@ -34,24 +34,24 @@ describe Protoable::Convert do
     end
   end
 
-  describe "._protobuf_convert_columns_to_fields" do
-    context "when there is a column converter for the field" do
+  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_column_converters).and_return({ :email => email_converter }) }
+      before { User.stub(:_protobuf_attribute_converters).and_return({ :email => email_converter }) }
 
-      it "calls the column converter with the given value" do
+      it "calls the attribute converter with the given value" do
         email_converter.should_receive(:call).with(email_value)
-        User._protobuf_convert_columns_to_fields(:email, 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 column converter with the given value" do
+        it "calls the attribute converter with the given value" do
           email_converter.should_receive(:call).with(email_value)
-          User._protobuf_convert_columns_to_fields(:email, email_value)
+          User._protobuf_convert_attributes_to_fields(:email, email_value)
         end
       end
     end
@@ -63,7 +63,7 @@ describe Protoable::Convert do
       before { User.stub(:_protobuf_date_column?).and_return(true) }
 
       it "converts the given value to an integer" do
-        User._protobuf_convert_columns_to_fields(:foo_date, date).should eq integer
+        User._protobuf_convert_attributes_to_fields(:foo_date, date).should eq integer
       end
     end
 
@@ -74,7 +74,7 @@ describe Protoable::Convert do
       before { User.stub(:_protobuf_datetime_column?).and_return(true) }
 
       it "converts the given value to an integer" do
-        User._protobuf_convert_columns_to_fields(:foo_datetime, datetime).should eq integer
+        User._protobuf_convert_attributes_to_fields(:foo_datetime, datetime).should eq integer
       end
     end
 
@@ -85,7 +85,7 @@ describe Protoable::Convert do
       before { User.stub(:_protobuf_time_column?).and_return(true) }
 
       it "converts the given value to an integer" do
-        User._protobuf_convert_columns_to_fields(:foo_time, time).should eq integer
+        User._protobuf_convert_attributes_to_fields(:foo_time, time).should eq integer
       end
     end
 
@@ -96,7 +96,7 @@ describe Protoable::Convert do
       before { User.stub(:_protobuf_timestamp_column?).and_return(true) }
 
       it "converts the given value to an integer" do
-        User._protobuf_convert_columns_to_fields(:foo_timestamp, timestamp).should eq integer
+        User._protobuf_convert_attributes_to_fields(:foo_timestamp, timestamp).should eq integer
       end
     end
 
@@ -104,7 +104,7 @@ describe Protoable::Convert do
       let(:value) { "Foo" }
 
       it "returns the given value" do
-        User._protobuf_convert_columns_to_fields(:foo, value).should eq value
+        User._protobuf_convert_attributes_to_fields(:foo, value).should eq value
       end
     end
   end

data/spec/protoable/fields_spec.rb

@@ -68,21 +68,21 @@ describe Protoable::Fields do
     end
   end
 
-  describe ".transform_column" do
+  describe ".attribute_from_proto" do
     context "when the given converter is a symbol" do
       let(:callable) { lambda { |value| User.__send__(:extract_first_name) } }
 
-      before { User.transform_column :first_name, :extract_first_name }
+      before { User.attribute_from_proto :first_name, :extract_first_name }
 
       it "creates a callable method object from the converter" do
         User.should_receive(:extract_first_name)
-        User._protobuf_column_transformers[:first_name].call(1)
+        User._protobuf_attribute_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, nil }.to raise_exception(Protoable::ColumnTransformerError)
+        expect { User.attribute_from_proto :name, nil }.to raise_exception(Protoable::AttributeTransformerError)
       end
     end
 
@@ -90,12 +90,12 @@ describe Protoable::Fields do
       let(:callable) { lambda { |proto| nil } }
 
       before {
-        User.stub(:_protobuf_column_transformers).and_return(Hash.new)
-        User.transform_column :account_id, callable
+        User.stub(:_protobuf_attribute_transformers).and_return(Hash.new)
+        User.attribute_from_proto :account_id, callable
       }
 
       it "adds the given converter to the list of protobuf field transformers" do
-        User._protobuf_column_transformers[:account_id] = callable
+        User._protobuf_attribute_transformers[:account_id] = callable
       end
     end
   end

data/spec/protoable/persistence_spec.rb

@@ -4,7 +4,7 @@ describe Protoable::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' } }
-  let(:proto) { Proto::User.new(proto_hash) }
+  let(:proto) { UserMessage.new(proto_hash) }
 
   describe "._filter_attribute_fields" do
     it "includes fields that have values" do
@@ -23,22 +23,22 @@ describe Protoable::Persistence do
       attribute_fields.has_key?(:email).should be_false
     end
 
-    it "includes attributes that aren't fields, but have column transformers" do
-      User.stub(:_protobuf_column_transformers).and_return({ :account_id => :fetch_account_id })
+    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 column transformer is defined for the field" do
+    context "when a attribute transformer is defined for the field" 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 column transformer is not defined for the field" do
+    context "when attribute transformer is not defined for the field" do
       before {
         User.stub(:_protobuf_convert_fields_to_columns) do |key, value|
           value

data/spec/protoable/scope_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Protoable::Scope do
+  describe ".search_scope" do
+    let(:request) { UserSearchMessage.new(:guid => ["foo"], :email => ["foo@test.co"]) }
+
+    it "builds scopes for searchable fields" do
+      User.stub(:searchable_fields).and_return({ :email =>  :by_email })
+      User.search_scope(request).should eq User.by_email("foo@test.co")
+    end
+
+    it "is chainable" do
+      User.limit(1).search_scope(request).order(:email).should eq User.limit(1).order(:email)
+    end
+
+    context "when a searchable field does not have a value" do
+      let(:request) { UserSearchMessage.new(:email => ["foo@test.co"]) }
+
+      it "doesn't build a scope from that field" do
+        User.stub(:searchable_fields).and_return({ :email =>  :by_email })
+        User.search_scope(request).should eq User.by_email("foo@test.co")
+      end
+    end
+  end
+
+  describe ".field_scope" do
+    before { @fields = User.instance_variable_get("@_searchable_fields") }
+    after { User.instance_variable_set("@_searchable_fields", @fields) }
+
+    context "when given a search scope that is not defined" do
+      it "raises an exception" do
+        expect { User.field_scope :name, :foo }.to raise_exception(/Undefined scope :foo/)
+      end
+    end
+
+    it "stores the search scope in the searchable fields hash using the field as the key" do
+      User.field_scope :guid, :by_guid
+      User.searchable_fields[:guid].should eq :by_guid
+    end
+  end
+end

data/spec/protoable/serialization_spec.rb

@@ -1,44 +1,44 @@
 require 'spec_helper'
 
 describe Protoable::Serialization do
-  let(:protobuf_message) { ::Proto::User }
+  let(:protobuf_message) { UserMessage }
 
-  describe ".convert_column" do
+  describe ".protoable_attribute" do
     context "when the given converter is a hash" do
       let(:method) { lambda { |value| User.__send__(:convert_base64_to_string, value) } }
 
-      before { User.convert_column :public_key, :from => :base64, :to => :string }
+      before { User.protoable_attribute :public_key, :from => :base64, :to => :string }
 
       it "determines the method using the hash's :to and :from keys" do
         User.should_receive(:convert_base64_to_string)
-        User._protobuf_column_converters[:public_key].call(1)
+        User._protobuf_attribute_converters[:public_key].call(1)
       end
     end
 
     context "when the given converter is a symbol" do
       let(:callable) { lambda { |value| User.__send__(:convert_email_to_lowercase, value) } }
 
-      before { User.convert_column :email, :convert_email_to_lowercase }
+      before { User.protoable_attribute :email, :convert_email_to_lowercase }
 
       it "creates a callable method object from the converter" do
         User.should_receive(:convert_email_to_lowercase)
-        User._protobuf_column_converters[:email].call(1)
+        User._protobuf_attribute_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, nil }.to raise_exception(Protoable::ColumnConverterError)
+        expect { User.protoable_attribute :email, nil }.to raise_exception(Protoable::AttributeConverterError)
       end
     end
 
     context "when the given converter is callable" do
       let(:callable) { lambda { |value| value } }
 
-      before { User.convert_column :email, callable }
+      before { User.protoable_attribute :email, callable }
 
-      it "adds the given converter to list of column converters" do
-        User._protobuf_column_converters[:email].should eq callable
+      it "adds the given converter to list of attribute converters" do
+        User._protobuf_attribute_converters[:email].should eq callable
       end
     end
   end
@@ -47,7 +47,7 @@ describe Protoable::Serialization do
     before { User.protobuf_message(protobuf_message) }
 
     context "given a value" do
-      let(:protobuf_fields) { [ :name, :email, :tags ] }
+      let(:protobuf_fields) { [ :guid, :name, :email ] }
 
       it "sets .protobuf_fields" do
         User.protobuf_fields.should =~ protobuf_fields
@@ -76,19 +76,20 @@ describe Protoable::Serialization do
     describe "#protoable_attributes" do
       let(:attributes) {
         {
-          :first_name => "foo",
-          :last_name => "bar",
+          :guid => "foo",
+          :first_name => "bar",
+          :last_name => "baz",
           :email => "foo@test.co"
         }
       }
-      let(:protoable_attributes) { { :name => user.name, :email => user.email, :tags => nil } }
+      let(:protoable_attributes) { { :guid => user.guid, :name => user.name, :email => user.email } }
 
       it "returns a hash of protobuf fields that this object has getters for" do
         user.protoable_attributes.should eq protoable_attributes
       end
 
       it "converts attributes values for protobuf messages" do
-        user.should_receive(:_protobuf_convert_columns_to_fields).any_number_of_times
+        user.should_receive(:_protobuf_convert_attributes_to_fields).any_number_of_times
         user.protoable_attributes
       end
     end

data/spec/support/db/setup.rb

@@ -11,6 +11,7 @@ end
 
 ActiveRecord::Schema.define(:version => 1) do
   create_table :users do |t|
+    t.string :guid
     t.string :first_name
     t.string :last_name
     t.string :email

data/spec/support/definitions/user.proto

@@ -0,0 +1,10 @@
+message UserMessage {
+  optional string guid        = 1;
+  optional string name        = 2;
+  optional string email       = 3;
+}
+
+message UserSearchMessage {
+  repeated string guid = 1;
+  repeated string email = 2;
+}

data/spec/support/models/user.rb

@@ -1,6 +1,12 @@
 class User < ActiveRecord::Base
   include Protoable
 
+  scope :by_guid, lambda { |*guids| where(:guid => guids) }
+  scope :by_email, lambda { |*emails| where(:email => emails) }
+
+  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
@@ -17,7 +23,6 @@ class User < ActiveRecord::Base
 
     first_name
   end
-  transform_column :first_name, :extract_first_name
 
   def self.extract_last_name(proto)
     if proto.has_field?(:name)
@@ -28,7 +33,6 @@ class User < ActiveRecord::Base
 
     last_name
   end
-  transform_column :last_name, :extract_last_name
 
   def name
     "#{first_name} #{last_name}"

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

@@ -1,9 +1,26 @@
+##
+# This file is auto-generated. DO NOT EDIT!
+#
 require 'protobuf/message'
 
-module Proto
-  class User < ::Protobuf::Message
-    optional ::Protobuf::Field::StringField, :name, 1
-    optional ::Protobuf::Field::StringField, :email, 2
-    repeated ::Protobuf::Field::StringField, :tags, 3
-  end
+
+##
+# Message Classes
+#
+class UserMessage < ::Protobuf::Message; end
+class UserSearchMessage < ::Protobuf::Message; end
+
+##
+# Message Fields
+#
+class UserMessage
+  optional ::Protobuf::Field::StringField, :guid, 1
+  optional ::Protobuf::Field::StringField, :name, 2
+  optional ::Protobuf::Field::StringField, :email, 3
 end
+
+class UserSearchMessage
+  repeated ::Protobuf::Field::StringField, :guid, 1
+  repeated ::Protobuf::Field::StringField, :email, 2
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-activerecord
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-09 00:00:00.000000000 Z
+date: 2012-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -207,17 +207,21 @@ files:
 - lib/protoable/errors.rb
 - lib/protoable/fields.rb
 - lib/protoable/persistence.rb
+- lib/protoable/scope.rb
 - lib/protoable/serialization.rb
 - lib/protobuf-activerecord.rb
 - lib/protobuf/activerecord/version.rb
+- lib/protobuf_ext/message.rb
 - protobuf-activerecord.gemspec
 - spec/protoable/convert_spec.rb
 - spec/protoable/fields_spec.rb
 - spec/protoable/persistence_spec.rb
+- spec/protoable/scope_spec.rb
 - spec/protoable/serialization_spec.rb
 - spec/spec_helper.rb
 - spec/support/db.rb
 - spec/support/db/setup.rb
+- spec/support/definitions/user.proto
 - spec/support/models.rb
 - spec/support/models/user.rb
 - spec/support/protobuf.rb
@@ -236,7 +240,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2949215824244847758
+      hash: -185204863767589185
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -245,7 +249,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2949215824244847758
+      hash: -185204863767589185
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -256,10 +260,12 @@ test_files:
 - spec/protoable/convert_spec.rb
 - spec/protoable/fields_spec.rb
 - spec/protoable/persistence_spec.rb
+- spec/protoable/scope_spec.rb
 - spec/protoable/serialization_spec.rb
 - spec/spec_helper.rb
 - spec/support/db.rb
 - spec/support/db/setup.rb
+- spec/support/definitions/user.proto
 - spec/support/models.rb
 - spec/support/models/user.rb
 - spec/support/protobuf.rb