Protocol Buffers - Google's data interchange format (grpc依赖)
https://developers.google.com/protocol-buffers/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
114 lines
4.0 KiB
114 lines
4.0 KiB
This directory contains the Ruby extension that implements Protocol Buffers |
|
functionality in Ruby. |
|
|
|
The Ruby extension makes use of generated Ruby code that defines message and |
|
enum types in a Ruby DSL. You may write definitions in this DSL directly, but |
|
we recommend using protoc's Ruby generation support with .proto files. The |
|
build process in this directory only installs the extension; you need to |
|
install protoc as well to have Ruby code generation functionality. |
|
|
|
Installation from Gem |
|
--------------------- |
|
|
|
When we release a version of Protocol Buffers, we will upload a Gem to |
|
[RubyGems](https://www.rubygems.org/). To use this pre-packaged gem, simply |
|
install it as you would any other gem: |
|
|
|
$ gem install [--prerelease] google-protobuf |
|
|
|
The `--pre` flag is necessary if we have not yet made a non-alpha/beta release |
|
of the Ruby extension; it allows `gem` to consider these "pre-release" |
|
alpha/beta versions. |
|
|
|
Once the gem is installed, you may or may not need `protoc`. If you write your |
|
message type descriptions directly in the Ruby DSL, you do not need it. |
|
However, if you wish to generate the Ruby DSL from a `.proto` file, you will |
|
also want to install Protocol Buffers itself, as described in this repository's |
|
main `README` file. The version of `protoc` included in the latest release |
|
supports the `--ruby_out` option to generate Ruby code. |
|
|
|
A simple example of using the Ruby extension follows. More extensive |
|
documentation may be found in the RubyDoc comments (`call-seq` tags) in the |
|
source, and we plan to release separate, more detailed, documentation at a |
|
later date. |
|
|
|
```ruby |
|
require 'google/protobuf' |
|
|
|
# generated from my_proto_types.proto with protoc: |
|
# $ protoc --ruby_out=. my_proto_types.proto |
|
require 'my_proto_types' |
|
|
|
mymessage = MyTestMessage.new(:field1 => 42, :field2 => ["a", "b", "c"]) |
|
mymessage.field1 = 43 |
|
mymessage.field2.push("d") |
|
mymessage.field3 = SubMessage.new(:foo => 100) |
|
|
|
encoded_data = MyTestMessage.encode(mymessage) |
|
decoded = MyTestMessage.decode(encoded_data) |
|
assert decoded == mymessage |
|
|
|
puts "JSON:" |
|
puts MyTestMessage.encode_json(mymessage) |
|
``` |
|
|
|
Installation from Source (Building Gem) |
|
--------------------------------------- |
|
|
|
To build this Ruby extension, you will need: |
|
|
|
* Rake |
|
* Bundler |
|
* Ruby development headers |
|
* a C compiler |
|
|
|
To Build the JRuby extension, you will need: |
|
|
|
* Maven |
|
* The latest version of the protobuf java library (see ../java/README.md) |
|
* Install JRuby via rbenv or RVM |
|
|
|
First switch to the desired platform with rbenv or RVM. |
|
|
|
Then install the required Ruby gems: |
|
|
|
$ gem install bundler |
|
$ bundle |
|
|
|
Then build the Gem: |
|
|
|
$ rake |
|
$ rake clobber_package gem |
|
$ gem install `ls pkg/google-protobuf-*.gem` |
|
|
|
To run the specs: |
|
|
|
$ rake test |
|
|
|
This gem includes the upb parsing and serialization library as a single-file |
|
amalgamation. It is up-to-date with upb git commit |
|
`535bc2fe2f2b467f59347ffc9449e11e47791257`. |
|
|
|
Version Number Scheme |
|
--------------------- |
|
|
|
We are using a version number scheme that is a hybrid of Protocol Buffers' |
|
overall version number and some Ruby-specific rules. Gem does not allow |
|
re-uploads of a gem with the same version number, so we add a sequence number |
|
("upload version") to the version. We also format alphabetical tags (alpha, |
|
pre, ...) slightly differently, and we avoid hyphens. In more detail: |
|
|
|
* First, we determine the prefix: a Protocol Buffers version "3.0.0-alpha-2" |
|
becomes "3.0.0.alpha.2". When we release 3.0.0, this prefix will be simply |
|
"3.0.0". |
|
* We then append the upload version: "3.0.0.alpha.2.0" or "3.0.0.0". If we need |
|
to upload a new version of the gem to fix an issue, the version becomes |
|
"3.0.0.alpha.2.1" or "3.0.0.1". |
|
* If we are working on a prerelease version, we append a prerelease tag: |
|
"3.0.0.alpha.3.0.pre". The prerelease tag comes at the end so that when |
|
version numbers are sorted, any prerelease builds are ordered between the |
|
prior version and current version. |
|
|
|
These rules are designed to work with the sorting rules for |
|
[Gem::Version](http://ruby-doc.org/stdlib-2.0/libdoc/rubygems/rdoc/Gem/Version.html): |
|
release numbers should sort in actual release order.
|
|
|