beefcake 0.2.1 → 0.3.0

data/README.md

@@ -67,25 +67,14 @@ Any object responding to `<<` can accept encoding
   Ruby deserves and needs first-class ProtoBuf support.
   Other libs didn't feel very "Ruby" to me and were hard to parse.
 
-# Caveats
+# Generate code from `.proto` file
 
-  Currently Beefcake doesn't parse `.proto` files.  This is OK for now.
-  In the simple case, you can create message types by hand; This is Ruby
-  after all.
+    $ protoc --beefcake_out output/path -I path/to/proto/files/dir path/to/proto/file
 
-  Example (for the above):
+You can set the BEEFCAKE_NAMESPACE variable to generate the classes under a
+desired namespace. (i.e. App::Foo::Bar)
 
-    message Variety {
-      required int32 x = 1
-      required int32 y = 2
-      optional string tag = 3
-
-      ...
-    }
-
-  In the near future, a generator would be nice.  I welcome anyone willing
-  to work on it to submit patches.  The other ruby libs lacked things I would
-  like, such as an optional namespace param rather than installing on (main).
+# Misc
 
   This library was built with EventMachine in mind.  Not just blocking-IO.
 

data/bin/protoc-gen-beefcake

@@ -0,0 +1,258 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+
+require 'beefcake'
+require 'stringio'
+
+
+class CodeGeneratorRequest
+  include Beefcake::Message
+
+
+  class FieldDescriptorProto
+    include Beefcake::Message
+
+    module Type
+      ## 0 is reserved for errors.
+      ## Order is weird for historical reasons.
+      TYPE_DOUBLE         = 1
+      TYPE_FLOAT          = 2
+      TYPE_INT64          = 3   ## Not ZigZag encoded.  Negative numbers
+      ## take 10 bytes.  Use TYPE_SINT64 if negative
+      ## values are likely.
+      TYPE_UINT64         = 4
+      TYPE_INT32          = 5   ## Not ZigZag encoded.  Negative numbers
+      ## take 10 bytes.  Use TYPE_SINT32 if negative
+      ## values are likely.
+      TYPE_FIXED64        = 6
+      TYPE_FIXED32        = 7
+      TYPE_BOOL           = 8
+      TYPE_STRING         = 9
+      TYPE_GROUP          = 10 ## Tag-delimited aggregate.
+      TYPE_MESSAGE        = 11 ## Length-delimited aggregate.
+
+      ## New in version 2.
+      TYPE_BYTES          = 12
+      TYPE_UINT32         = 13
+      TYPE_ENUM           = 14
+      TYPE_SFIXED32       = 15
+      TYPE_SFIXED64       = 16
+      TYPE_SINT32         = 17 ## Uses ZigZag encoding.
+      TYPE_SINT64         = 18 ## Uses ZigZag encoding.
+    end
+
+    module Label
+      LABEL_OPTIONAL      = 1
+      LABEL_REQUIRED      = 2
+      LABEL_REPEATED      = 3
+    end
+
+    optional :name,   :string, 1
+    optional :number, :int32,  3
+    optional :label,  Label,  4
+
+    ## If type_name is set, this need not be set.  If both this and type_name
+    ## are set, this must be either TYPE_ENUM or TYPE_MESSAGE.
+    optional :type, Type, 5
+
+    ## For message and enum types, this is the name of the type.  If the name
+    ## starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+    ## rules are used to find the type (i.e. first the nested types within this
+    ## message are searched, then within the parent, on up to the root
+    ## namespace).
+    optional :type_name, :string, 6
+
+    ## For extensions, this is the name of the type being extended.  It is
+    ## resolved in the same manner as type_name.
+    optional :extended, :string, 2
+
+    ## For numeric types, contains the original text representation of the value.
+    ## For booleans, "true" or "false".
+    ## For strings, contains the default text contents (not escaped in any way).
+    ## For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+    optional :default_value, :string, 7
+  end
+
+
+  class EnumValueDescriptorProto
+    include Beefcake::Message
+
+    optional :name,   :string, 1
+    optional :number, :int32,  2
+    # optional EnumValueOptions options = 3;
+  end
+
+  class EnumDescriptorProto
+    include Beefcake::Message
+
+    optional :name, :string, 1
+    repeated :value, EnumValueDescriptorProto, 2
+    # optional :options, EnumOptions, 3
+  end
+
+  class DescriptorProto
+    include Beefcake::Message
+
+    optional :name, :string, 1
+
+    repeated :field,       FieldDescriptorProto, 2
+    repeated :extended,    FieldDescriptorProto, 6
+    repeated :nested_type, DescriptorProto,      3
+    repeated :enum_type,   EnumDescriptorProto,  4
+  end
+
+
+  class FileDescriptorProto
+    include Beefcake::Message
+
+    optional :name, :string, 1       # file name, relative to root of source tree
+    optional :package, :string, 2    # e.g. "foo", "foo.bar", etc.
+
+    repeated :message_type, DescriptorProto, 4;
+  end
+
+
+  repeated :file_to_generate, :string, 1
+  optional :parameter, :string, 2
+
+  repeated :proto_file, FileDescriptorProto, 15
+end
+
+class CodeGeneratorResponse
+  include Beefcake::Message
+
+  class File
+    include Beefcake::Message
+
+    optional :name,    :string, 1
+    optional :content, :string, 15
+  end
+
+  repeated :file, File, 15
+end
+
+
+module Beefcake
+  class Generator < Struct.new(:c)
+
+    L = CodeGeneratorRequest::FieldDescriptorProto::Label
+    T = CodeGeneratorRequest::FieldDescriptorProto::Type
+
+
+    def self.compile(ns, req)
+      file = req.proto_file.map do |file|
+        g = new(StringIO.new)
+        g.compile(ns, file)
+
+        g.c.rewind
+        CodeGeneratorResponse::File.new(
+          :name => File.basename(file.name, ".proto") + ".pb.rb",
+          :content => g.c.read
+        )
+      end
+
+      CodeGeneratorResponse.new(:file => file)
+    end
+
+    def file!(file)
+      c.puts "## Generated from #{file.name} for #{file.package}"
+
+      file.message_type.each do |mt|
+        message!(mt)
+      end
+    end
+
+    def message!(pkg, mt)
+      c.puts
+      c.puts "class #{mt.name}"
+      c.puts "  include Beefcake::Message"
+      c.puts
+
+      mt.enum_type.each do |et|
+        enum!(et)
+      end
+
+      ## Generate Types
+      (mt.nested_type || []).each do |nt|
+        message!(nt)
+      end
+      c.puts
+
+      ## Generate fields
+      (mt.field || []).each do |f|
+        field!(pkg, f)
+      end
+      c.puts
+
+      c.puts "end"
+    end
+
+    def enum!(et)
+      c.puts "  module #{et.name}"
+      et.value.each do |v|
+        c.puts "    %s = %d" % [v.name, v.number]
+      end
+      c.puts "  end"
+    end
+
+    def field!(pkg, f)
+      # Turn the label into Ruby
+      label = name_for(f, L, f.label)
+
+      # Turn the name into a Ruby
+      name = ":#{f.name}"
+
+      # Determine the type-name and convert to Ruby
+      type = if f.type_name
+        # We have a type_name so we will use it after converting to a
+        # Ruby friendly version
+        t = f.type_name
+        t = t.gsub(pkg, "") # Remove the leading package name
+        t = t.gsub(/^\.*/, "")       # Remove leading `.`s
+
+        t.gsub(".", "::")  # Convert to Ruby namespacing syntax
+      else
+        ":#{name_for(f, T, f.type)}"
+      end
+
+      # Finally, generate the declaration
+      c.print "  %s %s, %s, %d" % [label, name, type, f.number]
+
+      if f.default_value
+        c.print ", :default => #{f.default_value}"
+      end
+
+      c.puts
+    end
+
+    # Determines the name for a 
+    def name_for(b, mod, val)
+      b.name_for(mod, val).gsub(/.*_/, "").downcase
+    end
+
+    def compile(ns, file)
+      c.puts "## Generated from #{file.name} for #{file.package}"
+
+      ns.each do |name|
+        c.puts "module #{name}"
+      end
+
+      file.message_type.each do |mt|
+        message!(file.package, mt)
+      end
+
+      ns.each do |name|
+        c.puts "end"
+      end
+    end
+
+  end
+end
+
+ns = (ENV["BEEFCAKE_NAMESPACE"] || "").split("::")
+
+req = CodeGeneratorRequest.decode(STDIN.read)
+res = Beefcake::Generator.compile(ns, req)
+
+# Send it out!
+STDOUT.print(res.encode)

data/lib/beefcake.rb

@@ -84,7 +84,10 @@ module Beefcake
       end
 
       def encode!(buf, fld, fn)
-        Array(self[fld.name]).each do |val|
+        v = self[fld.name]
+        v = v.is_a?(Array) ? v : [v]
+
+        v.compact.each do |val|
           case fld.type
           when Class # encodable
             # TODO: raise error if type != val.class
@@ -208,6 +211,7 @@ module Beefcake
     end
 
     def ==(o)
+      return false if o == nil
       fields.values.all? {|fld| self[fld.name] == o[fld.name] }
     end
 
@@ -218,6 +222,8 @@ module Beefcake
         val = self[fld.name]
 
         case fld.type
+        when Class
+          "#{fld.name}: #{val.inspect}"
         when Module
           title = name_for(fld.type, val) || "-NA-"
           "#{fld.name}: #{title}(#{val.inspect})"

data/test/message_test.rb

@@ -120,11 +120,11 @@ class MessageTest < Test::Unit::TestCase
   def test_encode_strings
     buf = Beefcake::Buffer.new
 
-    buf.append(:string, "testing", 1)
+    buf.append(:string, "test\ning", 1)
     buf.append(:bytes, "unixisawesome", 2)
 
     msg = LendelsMessage.new({
-      :string => "testing",
+      :string => "test\ning",
       :bytes  => "unixisawesome"
     })
 
@@ -325,6 +325,11 @@ class MessageTest < Test::Unit::TestCase
     assert_equal "<EnumsMessage a: -NA-(2)>", msg.inspect
   end
 
+  def test_inspect_nested_types
+    msg = CompositeMessage.new(:encodable => SimpleMessage.new(:a => 1))
+    assert_equal "<CompositeMessage encodable: <SimpleMessage a: 1>>", msg.inspect
+  end
+
   def test_to_hash
     msg =  SimpleMessage.new :a => 1
     exp = { :a => 1 }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: beefcake
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 1
-  version: 0.2.1
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-15 00:00:00 -08:00
+date: 2011-03-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,8 +34,8 @@ dependencies:
   version_requirements: *id001
 description: A sane protobuf library for Ruby
 email: 
-executables: []
-
+executables: 
+- protoc-gen-beefcake
 extensions: []
 
 extra_rdoc_files: 
@@ -53,6 +53,7 @@ files:
 - test/buffer_encode_test.rb
 - test/buffer_test.rb
 - test/message_test.rb
+- bin/protoc-gen-beefcake
 has_rdoc: true
 homepage: http://github.com/bmizerany/beefcake
 licenses: []