protobuf-activerecord 2.1.0.beta → 2.1.0.beta2

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

@@ -16,8 +16,15 @@ module Protoable
     #
     # Optionally, a parser can be provided that will be called, passing the
     # field value as an argument. This allows custom data parsers to be used
-    # so that they don't have to be handled by scopes. Parsers must respond
-    # to `call` and accept a single parameter.
+    # so that they don't have to be handled by scopes. Parsers can be procs,
+    # lambdas, or symbolized method names and must accept the value of the
+    # field as a parameter.
+    #
+    # > **Deprecated usage**: Previous versions required the scope to be passed
+    #   as a second argument. This has been replaced with the new hash-style
+    #   options or simply relying on the defaults. While it will still work
+    #   until v3.0 is released, it has been deprecated.
+    #
     #
     # Examples:
     #
@@ -29,24 +36,43 @@ module Protoable
     #     field_scope :guid
     #
     #     # With a custom scope
-    #     field_scope :guid, :custom_guid_scope
+    #     field_scope :guid, :scope => :custom_guid_scope
     #
     #     # With a custom parser that converts the value to an integer
-    #     field_scope :guid, :by_guid, lambda { |value| value.to_i }
+    #     field_scope :guid, :scope => :custom_guid_scope, :parser => lambda { |value| value.to_i }
     #   end
     #
-    def field_scope(field, scope_name = nil, parser = nil)
-      scope_name ||= :"by_#{field}"
+    def field_scope(field, *args)
+      # TODO: For backwards compatibility. Remove this in the next major release.
+      options = args.extract_options!
+
+      scope_name = case
+                   when args.present? then
+                     args.first
+                   when options.include?(:scope) then
+                     options[:scope]
+                   else
+                     # When no scope is defined, assume the scope is the field, prefixed with `by_`
+                     :"by_#{field}"
+                   end
       searchable_fields[field] = scope_name
 
-      # When no parser is defined, define one that simply returns the value
-      searchable_field_parsers[field] = parser || proc { |value| value }
+      searchable_field_parsers[field] = options[:parser] if options[:parser]
     end
 
     # :noapi:
     def parse_search_values(proto, field)
       value = proto.__send__(field)
-      value = searchable_field_parsers[field].call(value)
+
+      if searchable_field_parsers[field]
+        parser = searchable_field_parsers[field]
+
+        if parser.respond_to?(:to_sym)
+          value = self.__send__(parser.to_sym, value)
+        else
+          value = parser.call(value)
+        end
+      end
 
       values = [ value ].flatten
       values.map!(&:to_i) if proto.get_field_by_name(field).enum?

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

@@ -0,0 +1,39 @@
+module Protoable
+  module Validations
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      # Validates whether the value of the specified attribute is available in
+      # the given Protobuf Enum. The enumeration should be passed as a class
+      # that defines the enumeration:
+      #
+      # ```
+      # class User < ActiveRecord::Base
+      #   include ::Protoable
+      #
+      #   validates_enumeration_of :role_type, :with => RoleType, :allow_nil => true
+      # end
+      # ```
+      #
+      # In this example, RoleType is a defined as a protobuf enum.
+      #
+      # It accepts the same options as `validates_inclusion_of` (the :in option
+      # is automatically set and will be overwritten).
+      #
+      def validates_enumeration_of(*args)
+        options = args.extract_options!
+        enumerable = options.delete(:with)
+
+        raise ArgumentError, ":with must be specified" if enumerable.nil?
+
+        if enumerable < ::Protobuf::Enum
+          options[:in] = enumerable.values.values.map(&:value)
+        end
+
+        args << options
+
+        validates_inclusion_of(*args)
+      end
+    end
+  end
+end

data/lib/protobuf/activerecord/protoable.rb

@@ -4,6 +4,7 @@ require 'protobuf/activerecord/protoable/persistence'
 require 'protobuf/activerecord/protoable/scope'
 require 'protobuf/activerecord/protoable/serialization'
 require 'protobuf/activerecord/protoable/transformation'
+require 'protobuf/activerecord/protoable/validations'
 
 module Protoable
   def self.included(klass)
@@ -13,5 +14,6 @@ module Protoable
     klass.__send__(:include, Protoable::Persistence)
     klass.__send__(:include, Protoable::Serialization)
     klass.__send__(:include, Protoable::Transformation)
+    klass.__send__(:include, Protoable::Validations)
   end
 end

data/lib/protobuf/activerecord/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module ActiveRecord
-    VERSION = "2.1.0.beta"
+    VERSION = "2.1.0.beta2"
   end
 end

data/spec/protoable/scope_spec.rb

@@ -40,9 +40,60 @@ describe Protoable::Scope do
     before { @fields = User.instance_variable_get("@_searchable_fields") }
     after { User.instance_variable_set("@_searchable_fields", @fields) }
 
-    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
+    context "when scope is passed in the old style" do
+      it "defines the given field as searchable using the given scope" do
+        User.field_scope :guid, :by_guid
+        User.searchable_fields[:guid].should eq :by_guid
+      end
+    end
+
+    context "when :scope is not defined" do
+      it "defines the given field as searchable using the `by_[:field]` as the scope" do
+        User.field_scope :guid
+        User.searchable_fields[:guid].should eq :by_guid
+      end
+    end
+
+    context "when :scope is defined" do
+      it "defines the given field as searchable using the given :scope" do
+        User.field_scope :guid, :scope => :custom_scope
+        User.searchable_fields[:guid].should eq :custom_scope
+      end
+    end
+
+    context "when :parser is not defined" do
+      it "doesn't define the given field as parseable" do
+        User.field_scope :guid
+        User.searchable_field_parsers[:guid].should eq nil
+      end
+    end
+
+    context "when :parser is defined" do
+      before { @field_parsers = User.instance_variable_get("@_searchable_field_parsers") }
+      after { User.instance_variable_set("@_searchable_field_parsers", @field_parsers) }
+
+      it "defines the given field as parseable using the given :parser" do
+        User.field_scope :guid, :parser => :parser
+        User.searchable_field_parsers[:guid].should eq :parser
+      end
+    end
+  end
+
+  describe ".parse_search_values" do
+    it "converts single values to collections"
+
+    context "when a field parser is defined" do
+      context "and the parser responds to :to_sym" do
+        it "calls `send`, passing it the parser and value"
+      end
+
+      context "and the parser does not respond to :to_sym" do
+        it "calls the parser, passing it the value"
+      end
+    end
+
+    context "when the field is an enum" do
+      it "maps values to integers"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-activerecord
 version: !ruby/object:Gem::Version
-  version: 2.1.0.beta
+  version: 2.1.0.beta2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-21 00:00:00.000000000 Z
+date: 2013-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -209,6 +209,7 @@ files:
 - lib/protobuf/activerecord/protoable/scope.rb
 - lib/protobuf/activerecord/protoable/serialization.rb
 - lib/protobuf/activerecord/protoable/transformation.rb
+- lib/protobuf/activerecord/protoable/validations.rb
 - lib/protobuf/activerecord/protobuf_ext/message.rb
 - lib/protobuf/activerecord/version.rb
 - protobuf-activerecord.gemspec
@@ -239,7 +240,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2337364999688507357
+      hash: 1690905845490164908
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: