protobuf-activerecord 3.0.0.rc4 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7607179e8934a9674f488525de0ab8186f78907b
-  data.tar.gz: 7df784557494dcfaf362800e3ad71df46c556454
+  metadata.gz: a3d7459c7c110bd97134b19fcb6e03c50d703cf0
+  data.tar.gz: a9f5db72facad0d01bf4ef55ed1fd21a80f35ac0
 SHA512:
-  metadata.gz: d6b300dfc3aa2382b3daf8490619eb8313af9c7ac1b231527a814ab18926478c1db900bb4b024e2ff799cb6aa4679aada64a4851a0818bfb7c9292d0bdda8d9c
-  data.tar.gz: 0737fdd0bb4e2dd0b41fc0655361d7fdbc577190f58017d8b5d6a0ebae020ed4acd9e94bfc4fce63adc1b686957163dd0b8681364149341d6a9af955c99fdbae
+  metadata.gz: 9fadf115d0f333b94d6bee3940f23b1938ae0fa74ff16c3d1edda12acfcbac70f6c39717de88b716fbf3e51cbe2586ce98812c9a26c5a44abdaf241170a1e9d9
+  data.tar.gz: dfb1883e308d92f1b34cd1e038fbfeebf3b9594f1b35e2ba4a7a5130153c877a892e1d8d48bf9d77d8fb20e880d32e12b42b40e8fe283d6e4242e6c7fb7d2e04

data/README.md

@@ -18,22 +18,11 @@ Or install it yourself as:
 
 ## Usage
 
-Protobuf Active Record's functionality is contained within the `Protoable` module. To endow your Active Record models with the protoable behaviour, simply include it into your model:
-
-```Ruby
-class User < ActiveRecord::Base
-  include Protoable
-
-  # Your awesome methods...
-  #
-end
-```
-
-Now you can pass protobuf messages to your user model just like you would attributes. Protoable will take care of converting the protobuf message to attributes and continue on with Active Record's normal behavior.
+Protobuf Active Record is automatically available in any Active Record model. Once installed, you can pass protobuf messages to your user model just like you would attributes. It will take care of converting the protobuf message to attributes and continue on with Active Record's normal behavior.
 
 ### Field/Attribute mapping
 
-Just like Active Record maps database columns to your model's attributes, Protoable maps protobuf fields to your model's attributes.
+Just like Active Record maps database columns to your model's attributes, Protobuf Active Record maps protobuf fields to your model's attributes.
 
 Given a table that looks like this:
 
@@ -59,13 +48,13 @@ class UserMessage < ::Protobuf::Message
 end
 ```
 
-Protoable will map the `first_name`, `last_name`, `email`, & `account_id` columns, skipping the timestamp columns. Repeated fields and fields that are nil will not be mapped.
+Protobuf Active Record will map the `first_name`, `last_name`, `email`, & `account_id` columns, skipping the timestamp columns. Repeated fields and fields that are nil will not be mapped.
 
 **Dates**
 
-Since Protocol Buffer messages don't support sending date, time, or datetime fields, Protoable expects date, time, and datetime fields to be sent as integers. Just like Active Record handles translating Ruby dates, times, and datetimes into the proper database column types, Protoable will handle converting dates, times, and dateimes to and from integers mapping protobuf message fields.
+Since Protocol Buffer messages don't support sending date, time, or datetime fields, Protobuf Active Record expects date, time, and datetime fields to be sent as integers. Just like Active Record handles translating Ruby dates, times, and datetimes into the proper database column types, Protobuf Active Record will handle converting dates, times, and dateimes to and from integers mapping protobuf message fields.
 
-Picking up our users table example again, if you wanted to add a `created_at` field to your protobuf message, if you add it as an integer field, Protoable will handle the conversions for you:
+Picking up our users table example again, if you wanted to add a `created_at` field to your protobuf message, if you add it as an integer field, Protobuf Active Record will handle the conversions for you:
 
 ```Ruby
 class UserMessage < ::Protobuf::Message
@@ -74,39 +63,35 @@ class UserMessage < ::Protobuf::Message
   optional ::Protobuf::Field::StringField, :email, 3
   optional ::Protobuf::Field::IntegerField, :account_id, 4
 
-  # Add a datetime field as an integer and Protoable will map it for you
+  # Add a datetime field as an integer and Protobuf Active Record will map it for you
   optional ::Protobuf::Field::IntegerField, :created_at, 5
 end
 ```
 
 ### Creating/Updating
 
-Protoable doesn't alter Active Record's normal persistence methods. It simply adds to ability to pass protobuf messages to them in place of an attributes hash.
+Protobuf Active Record doesn't alter Active Record's normal persistence methods. It simply adds to ability to pass protobuf messages to them in place of an attributes hash.
 
 ### Serialization to protobuf
 
-In addition to mapping protobuf message fields to Active Record objects when creating or updating records, Protoable also provides the ability to serialize Active Record objects to protobuf messages. Simply tell Protoable the protobuf message that should be used and it will take care of the rest:
+In addition to mapping protobuf message fields to Active Record objects when creating or updating records, Active Record objects can also be serialized to protobuf messages. Simply specify the protobuf message that should be used and Protobuf Active Record will take care of the rest:
 
 ```Ruby
 class User < ActiveRecord::Base
-  include Protoable
-
-  # Configures Protoable to use the UserMessage class and adds :to_proto.
+  # Configures Protobuf Active Record to use the UserMessage class and adds :to_proto.
   protobuf_message :user_message
 end
 ```
 
-Once the desired protobuf message has been specified, Protoable adds a `to_proto` method to the model. Calling `to_proto` will automatically convert the model to the specified protobuf message using the same attribute to field mapping it uses to create and update objects from protobuf messages.
+Once the desired protobuf message has been specified, a `to_proto` method will be added to the model. Calling `to_proto` will automatically convert the model to the specified protobuf message using the same attribute to field mapping it uses to create and update objects from protobuf messages.
 
 ### Choosing serializable fields
 
-Protoable also provides a mechanism for choosing which fields should be included when serializing objects to protobuf messages by passing additional options to `protobuf_message`:
+Protobuf Active Record also provides a mechanism for choosing which fields should be included when serializing objects to protobuf messages by passing additional options to `protobuf_message`:
 
 ```Ruby
 class User < ActiveRecord::Base
-  include Protoable
-
-  # Passing :only => ... configures Protoable to only serialize the given fields
+  # Passing :only => ... configures Protobuf Active Record to only serialize the given fields
   protobuf_message :user_message, :only => [ :first_name, :last_name, :email ]
 end
 ```
@@ -117,9 +102,7 @@ Conversely, the `:except` option allows the fields that should be excluded to be
 
 ```Ruby
 class User < ActiveRecord::Base
-  include Protoable
-
-  # Passing :except => ... configures Protoable to serialize everything except the given fields
+  # Passing :except => ... configures Protobuf Active Record to serialize everything except the given fields
   protobuf_message :user_message, :except => [ :account_id, :created_at ]
 end
 ```
@@ -136,20 +119,18 @@ user.to_proto(:include => :email) # Start with the class-level settings, but add
 
 ### Serializing deprecated fields
 
-By default, Protoaable includes deprecated fields when mapping protobuf message to Active Record objects. To exclude deprecated fields, simply pass the `:deprecated` option:
+By default, deprecated fields are included when mapping protobuf message to Active Record objects. To exclude deprecated fields, simply pass the `:deprecated` option:
 
 ```Ruby
 class User < ActiveRecord::Base
-  include Protoable
-
-  # Passing :deprecated => false configures Protoable to exclude deprecated fields.
+  # Passing :deprecated => false configures Protobuf Active Record to exclude deprecated fields.
   protobuf_message :user_message, :deprecated => false
 end
 ```
 
 ### Field transformers
 
-Field transformers are used when serializing objects to protobuf messages. Protoable will handle regular field mapping and conversions out of the box, but for those times when fields don't map directly to attributes or custom behavior is needed, Protoable provides the `field_from_record` method.
+Field transformers are used when serializing objects to protobuf messages. Regular field mapping and conversions will be handled out of the box, but for those times when fields don't map directly to attributes or custom behavior is needed, use `field_from_record` method.
 
 `field_from_record` takes the name of the field being transformed and a method name or callable (lambda or proc). When transforming that field, it calls the given callable, passing it the object being serialized.
 
@@ -157,8 +138,6 @@ Field transformers are used when serializing objects to protobuf messages. Proto
 
 ```Ruby
 class User < ActiveRecord::Base
-  include Protoable
-
   # Calls the lambda when serializing objects to protobuf messages, passing it
   # the object being serialized.
   field_from_record :status, lambda { |object_being_serlialized| # Some custom behavior }
@@ -167,12 +146,10 @@ end
 
 ### Attribute transformers
 
-Protoable handles mapping protobuf message fields to object attributes, but what happens when an attribute doesn't have a matching field? Using the `attribute_from_proto` method, you can define custom attribute transformations. Simply call `attribute_from_prot`, passing it the name of the attribute and a method name or callable (lambda or proc). When creating or updating objects, Protoable will call the transformer, passing it the protobuf message.
+Protobuf Active Record handles mapping protobuf message fields to object attributes, but what happens when an attribute doesn't have a matching field? Using the `attribute_from_proto` method, you can define custom attribute transformations. Simply call `attribute_from_prot`, passing it the name of the attribute and a method name or callable (lambda or proc). When creating or updating objects, the transformer will be called and passed the protobuf message.
 
 ```Ruby
 class User < ActiveRecord::Base
-  include Protoable
-
   # Calls the lambda when creating/updating objects, passing it the protobuf
   # message.
   attribute_from_proto :account_id, lambda { |protobuf_message| # Some custom transformation... }
@@ -180,9 +157,9 @@ end
 ```
 #### Searching
 
-Protoable's `search_scope` method takes the protobuf message and builds ARel scopes from it.
+Protobuf Active Record's `search_scope` method takes the protobuf message and builds ARel scopes from it.
 
-Before you can use `search_scope`, you'll need to tell Protoable which fields should be searchable and what scope should be used to search with that field.
+Before you can use `search_scope`, you'll need to tell Protobuf Active Record which fields should be searchable and what scope should be used to search with that field.
 
 Consider this protobuf message:
 
@@ -198,29 +175,25 @@ To make the `name` field searchable, use the `field_scope` method:
 
 ```Ruby
 class User < ActiveRecord::Base
-  include Protoable
-
   scope :by_name, lambda { |*values| where(:name => values) }
 
   field_scope :name, :scope => :by_name
 end
 ```
 
-This tells Protoable that the name field should be searchable and that the :scope with the given name should be used to build the search scope.
+This tells Protobuf Active Record that the name field should be searchable and that the :scope with the given name should be used to build the search scope.
 
 `field_scope` can also be called with just a field name:
 
 ```Ruby
 class User < ActiveRecord::Base
-  include Protoable
-
   scope :by_name, lambda { |*values| where(:name => values) }
 
   field_scope :name
 end
 ```
 
-If no scope is given, Protoable assumes that a scope matching the given field prefixed with `by_`, in this case `by_name`.
+If no scope is given, Protobuf Active Record assumes that a scope matching the given field prefixed with `by_`, in this case `by_name`.
 
 Now that your class is configured with some searchable fields, you can use the `search_scope` method to build ARel scopes from a protobuf message.
 
@@ -236,7 +209,7 @@ User.search_scope(request)
 User.limit(10).search_scope(request)
 ```
 
-Protoable also provides some aliases for the `search_scope` method in the event that you'd like something a little more descriptive: `by_fields` and `scope_from_proto` are all aliases of `search_scope`.
+Protobuf Active Record also provides some aliases for the `search_scope` method in the event that you'd like something a little more descriptive: `by_fields` and `scope_from_proto` are all aliases of `search_scope`.
 
 ## Contributing
 

data/lib/protobuf/active_record/version.rb

@@ -1,5 +1,5 @@
 module Protobuf
   module ActiveRecord
-    VERSION = "3.0.0.rc4"
+    VERSION = "3.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-activerecord
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc4
+  version: 3.0.0
 platform: ruby
 authors:
 - Adam Hutchison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-08 00:00:00.000000000 Z
+date: 2013-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -223,9 +223,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.6