protobuf-generate 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78cf665e01a339bcdf515cee143af388685ef34a
-  data.tar.gz: 268a8fa0d167f93f8c86ec0f4f9ad304bb4650d2
+  metadata.gz: a5a62cd275937980b1b0288c6c4c89ebae992616
+  data.tar.gz: 697457604b2bdf9f5f68618925df3091c1d3b137
 SHA512:
-  metadata.gz: 30773411e397dbb87a547de33809646493fd3350c83c2fca83c6a2f9e4ed7a64a792780aa626ee60c7febea25d16d973da8550c5a6b4034196f8c46cbdd7c56f
-  data.tar.gz: ca1613fe95fa0e2a3a02c2616f2b23c19089e7d71a8bc63caed895907a7d6f4d3ba67cdc2f159e411ffb1728e3ccb02eee4b08e154c3ea8087aee45d35855a7c
+  metadata.gz: 77564ae6657f10076c844674d118cb7693e7563c752505a0bf1b9f7d28500ac8c5e355238d31b60eabc0eada4c450bafcebc2b7da65cac667ecc2f052b4bd0b1
+  data.tar.gz: 7c74335a4d38437e6b64853dfb247140fdd60ed642e1818cb108f74417e1bc817bbee70cacb1561318fb5585c2b17976d4938a9c69aef751ae78e8aba5b5aabf

data/lib/protobuf/generate/language/c/c.erb

@@ -9,7 +9,7 @@ static int write_raw_byte(uint8_t value, uint8_t *buffer, int offset) {
   return ++offset;
 }
 
-static int write_raw_little_endian32(uint32_t value, uint8_t *buffer, int offset) {
+int write_raw_little_endian32(uint32_t value, uint8_t *buffer, int offset) {
   offset = write_raw_byte((uint8_t)((value      ) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >>  8) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >> 16) & 0xFF), buffer, offset);
@@ -17,7 +17,7 @@ static int write_raw_little_endian32(uint32_t value, uint8_t *buffer, int offset
   return offset;
 }
 
-static int write_raw_little_endian64(uint64_t value, uint8_t *buffer, int offset) {
+int write_raw_little_endian64(uint64_t value, uint8_t *buffer, int offset) {
   offset = write_raw_byte((uint8_t)((value      ) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >>  8) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >> 16) & 0xFF), buffer, offset);
@@ -29,7 +29,7 @@ static int write_raw_little_endian64(uint64_t value, uint8_t *buffer, int offset
   return offset;
 }
 
-static int write_raw_varint32(uint32_t value, uint8_t *buffer, int offset) {
+int write_raw_varint32(uint32_t value, uint8_t *buffer, int offset) {
   while (1) {
     if ((value & ~0x7F) == 0) {
       offset = write_raw_byte((uint8_t)value, buffer, offset);
@@ -42,7 +42,7 @@ static int write_raw_varint32(uint32_t value, uint8_t *buffer, int offset) {
   return offset;
 }
 
-static int write_raw_varint64(uint64_t value, uint8_t *buffer, int offset) {
+int write_raw_varint64(uint64_t value, uint8_t *buffer, int offset) {
   while (1) {
     if ((value & ~0x7FL) == 0) {
       offset = write_raw_byte((uint8_t)value, buffer, offset);
@@ -82,7 +82,7 @@ static inline int read_raw_byte(uint8_t *tag, const uint8_t *buffer, int offset)
   return ++offset;
 }
 
-static int read_raw_little_endian32(uint32_t *tag, const uint8_t *buffer, int offset) {
+int read_raw_little_endian32(uint32_t *tag, const uint8_t *buffer, int offset) {
   offset = read_raw_byte((uint8_t *)tag, buffer, offset);
   uint8_t b1 = (uint8_t)*tag;
   offset = read_raw_byte((uint8_t *)tag, buffer, offset);
@@ -99,7 +99,7 @@ static int read_raw_little_endian32(uint32_t *tag, const uint8_t *buffer, int of
   return offset;
 }
 
-static int read_raw_little_endian64(uint64_t *tag, const uint8_t *buffer, int offset) {
+int read_raw_little_endian64(uint64_t *tag, const uint8_t *buffer, int offset) {
   offset = read_raw_byte((uint8_t *)tag, buffer, offset);
   uint8_t b1 = (uint8_t)*tag;
   offset = read_raw_byte((uint8_t *)tag, buffer, offset);
@@ -129,7 +129,7 @@ static int read_raw_little_endian64(uint64_t *tag, const uint8_t *buffer, int of
   return offset;
 }
 
-static int read_raw_varint32(uint32_t *tag, const uint8_t *buffer, int offset) {
+int read_raw_varint32(uint32_t *tag, const uint8_t *buffer, int offset) {
   uint8_t result;
 
   offset = read_raw_byte(&result, buffer, offset);
@@ -172,7 +172,7 @@ static int read_raw_varint32(uint32_t *tag, const uint8_t *buffer, int offset) {
   return offset;
 }
 
-static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
+int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
   short shift = 0;
   uint8_t b;
   *tag = 0;
@@ -189,24 +189,19 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
 }
 
 <% each do |exp| %>
-  <%
-    if exp.kind_of?(Protobuf::Generate::Ast::Package)
-      package exp.name
-    elsif exp.kind_of?(Protobuf::Generate::Ast::Enum)
-  %>
-  <% elsif exp.kind_of?(Protobuf::Generate::Ast::Message) %>
-
-  void <%= namespaced_function exp.name, 'clear' %>(<%= namespaced_type exp.name %> *pb) {
+  <% if exp.kind_of?(Protobuf::Generate::Ast::Message) %>
+
+  void <%= function exp.package, exp.name, 'clear' %>(<%= type exp.package, exp.name %> *pb) {
     memset(pb, 0, sizeof(*pb));
   }
 
-  void <%= namespaced_function exp.name, 'init', 'optional', 'attributes' %>(<%= namespaced_type exp.name %> *pb) {
+  void <%= function exp.package, exp.name, 'init', 'optional', 'attributes' %>(<%= type exp.package, exp.name %> *pb) {
     <% exp.fields.each do |field| %>
       <% if field.optional? %>
         <% if type_message?(field.type) %>
-          <%= namespaced_function field.type, 'init', 'optional', 'attributes' %>(&pb-><%= field.name %>);
+          <%= function exp.package, field.type, 'init', 'optional', 'attributes' %>(&pb-><%= field.name %>);
         <% elsif type_enum?(field.type) %>
-          pb-><%= field.name %> = <%= namespaced_constant field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>;
+          pb-><%= field.name %> = <%= constant exp.package, field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>;
         <% elsif field.type =~ /bool/ %>
           pb-><%= field.name %> = <%= field.options.fetch(:default, 'false') %>;
         <% elsif field.type =~ /string/ %>
@@ -223,13 +218,13 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
     return;
   }
 
-  bool <%= namespaced_function exp.name, 'is', 'default', 'message' %>(const <%= namespaced_type exp.name %> *pb) {
+  bool <%= function exp.package, exp.name, 'is', 'default', 'message' %>(const <%= type exp.package, exp.name %> *pb) {
     return true
     <% exp.fields.each do |field| %>    // <%= field.name %>
       <% if type_message?(field.type) %>
-        && <%= namespaced_function field.type, 'is', 'default', 'message' %>(&pb-><%= field.name %>)
+        && <%= function exp.package, field.type, 'is', 'default', 'message' %>(&pb-><%= field.name %>)
       <% elsif type_enum?(field.type) %>
-        && pb-><%= field.name %> == <%= namespaced_constant field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>
+        && pb-><%= field.name %> == <%= constant exp.package, field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>
       <% elsif field.type =~ /string|bytes/ %>
         && memcmp(&pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.meta.fetch('size_max', field.options.fetch('default', '').bytesize) %>) == 0
         && pb-><%= field.name %>.size == <%= field.options.fetch('default', '').bytesize %>
@@ -239,15 +234,15 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
     <% end %>;
   }
 
-  int <%= namespaced_function exp.name, 'write' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *buffer, int offset) {
+  int <%= function exp.package, exp.name, 'write' %>(const <%= type exp.package, exp.name %> *pb, uint8_t *buffer, int offset) {
     <% exp.fields.each do |field| %>      // <%= field.name %>
       <% if field.optional? %>
         <% if type_message?(field.type) %>
-          if (!<%= namespaced_function field.type, 'is', 'default', 'message' %>(&pb-><%= field.name %>)) {
-            offset = <%= namespaced_function field.type, 'write', 'with', 'tag' %>(&pb-><%= field.name %>, buffer, offset, <%= field.tag %>);
+          if (!<%= function exp.package, field.type, 'is', 'default', 'message' %>(&pb-><%= field.name %>)) {
+            offset = <%= function exp.package, field.type, 'write', 'with', 'tag' %>(&pb-><%= field.name %>, buffer, offset, <%= field.tag %>);
           }
         <% elsif type_enum?(field.type) %>
-          if (pb-><%= field.name %> != <%= namespaced_constant field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>) {
+          if (pb-><%= field.name %> != <%= constant exp.package, field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+0, buffer, offset);
             offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
           }
@@ -264,7 +259,7 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
         <% elsif field.type =~ /int32/%>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
-            if (pb-><%= field.name %> >= 0) offset = write_raw_varin32(pb-><%= field.name %>, buffer, offset);
+            if (pb-><%= field.name %> >= 0) offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
             else offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
           }
         <% elsif field.type =~ /int64/ %>
@@ -322,7 +317,7 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
         <% end %>
       <% else %>
         <% if type_message?(field.type) %>
-          offset = <%= namespaced_function field.type, 'write', 'with', 'tag' %>(&pb-><%= field.name %>, buffer, offset, <%= field.tag %>);
+          offset = <%= function exp.package, field.type, 'write', 'with', 'tag' %>(&pb-><%= field.name %>, buffer, offset, <%= field.tag %>);
         <% elsif type_enum?(field.type) %>
           offset = write_raw_varint32((<%= field.tag %><<3)+0, buffer, offset);
           offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
@@ -334,7 +329,7 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
           offset = write_raw_little_endian32(*(uint32_t *)&pb-><%= field.name %>, buffer, offset);
         <% elsif field.type =~ /int32/ %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
-          if (pb-><%= field.name %> >= 0) offset = write_raw_varin32(pb-><%= field.name %>, buffer, offset);
+          if (pb-><%= field.name %> >= 0) offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
           else offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
         <% elsif field.type =~ /int64/ %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
@@ -374,10 +369,10 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
     return offset;
   }
 
-  int <%= namespaced_function exp.name, 'write', 'delimited', 'to' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *buffer, int offset) {
+  int <%= function exp.package, exp.name, 'write', 'delimited', 'to' %>(const <%= type exp.package, exp.name %> *pb, uint8_t *buffer, int offset) {
     int i, shift, new_offset, size;
 
-    new_offset = <%= namespaced_function exp.name, 'write' %>(pb, buffer, offset);
+    new_offset = <%= function exp.package, exp.name, 'write' %>(pb, buffer, offset);
     size       = new_offset - offset;
     shift      = (size > 127) ? 2 : 1;
     for (i = new_offset - 1; i >= offset; -- i)
@@ -387,22 +382,22 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
     return new_offset + shift;
   }
 
-  int <%= namespaced_function exp.name, 'write', 'with', 'tag' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *buffer, int offset, int tag) {
+  int <%= function exp.package, exp.name, 'write', 'with', 'tag' %>(const <%= type exp.package, exp.name %> *pb, uint8_t *buffer, int offset, int tag) {
       offset = write_raw_varint32((tag<<3)+2, buffer, offset);
-      offset = <%= namespaced_function exp.name, 'write', 'delimited', 'to' %>(pb, buffer, offset);
+      offset = <%= function exp.package, exp.name, 'write', 'delimited', 'to' %>(pb, buffer, offset);
       return offset;
   }
 
-  int <%= namespaced_function exp.name, 'encode' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *data, size_t data_size, size_t *encoded_size) {
-    *encoded_size = <%= namespaced_function exp.name, 'write', 'delimited', 'to' %>(pb, data, -1);
+  int <%= function exp.package, exp.name, 'encode' %>(const <%= type exp.package, exp.name %> *pb, uint8_t *data, size_t data_size, size_t *encoded_size) {
+    *encoded_size = <%= function exp.package, exp.name, 'write', 'delimited', 'to' %>(pb, data, -1);
     return 0; // TODO: Encoding errors.
   }
 
-  int <%= namespaced_function exp.name, 'read', 'delimited', 'from' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *buffer, int offset);
+  int <%= function exp.package, exp.name, 'read', 'delimited', 'from' %>(<%= type exp.package, exp.name %> *pb, const uint8_t *buffer, int offset);
 
-  int <%= namespaced_function exp.name, 'read' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *buffer, int offset, int limit) {
-    <%= namespaced_function exp.name, 'clear' %>(pb);
-    <%= namespaced_function exp.name, 'init', 'optional', 'attributes' %>(pb);
+  int <%= function exp.package, exp.name, 'read' %>(<%= type exp.package, exp.name %> *pb, const uint8_t *buffer, int offset, int limit) {
+    <%= function exp.package, exp.name, 'clear' %>(pb);
+    <%= function exp.package, exp.name, 'init', 'optional', 'attributes' %>(pb);
 
     uint32_t tag   = 0;
     while (offset < limit) {
@@ -413,7 +408,7 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
       case <%= field.tag %>:
           // <%= field.name %>
         <% if type_message?(field.type) %>
-          offset = <%= namespaced_function field.type, 'read', 'delimited', 'from' %>(&pb-><%= field.name %>, buffer, offset);
+          offset = <%= function exp.package, field.type, 'read', 'delimited', 'from' %>(&pb-><%= field.name %>, buffer, offset);
         <% elsif type_enum?(field.type) %>
           offset = read_raw_varint32(&tag, buffer, offset);
           pb-><%= field.name %> = tag;
@@ -487,15 +482,15 @@ static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
     return offset;
   }
 
-  int <%= namespaced_function exp.name, 'read', 'delimited', 'from' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *buffer, int offset) {
+  int <%= function exp.package, exp.name, 'read', 'delimited', 'from' %>(<%= type exp.package, exp.name %> *pb, const uint8_t *buffer, int offset) {
     uint32_t size;
     offset = read_raw_varint32(&size, buffer, offset);
-    <%= namespaced_function exp.name, 'read' %>(pb, buffer, offset, size + offset);
+    <%= function exp.package, exp.name, 'read' %>(pb, buffer, offset, size + offset);
     return offset + size;
   }
 
-  int <%= namespaced_function exp.name, 'decode' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *data, size_t data_size, size_t *encoded_size) {
-    *encoded_size = <%= namespaced_function exp.name, 'read' %>(pb, data, 0, data_size);
+  int <%= function exp.package, exp.name, 'decode' %>(<%= type exp.package, exp.name %> *pb, const uint8_t *data, size_t data_size, size_t *encoded_size) {
+    *encoded_size = <%= function exp.package, exp.name, 'read' %>(pb, data, 0, data_size);
     return 0; // TODO: Decoding errors.
   }
   <% end %>

data/lib/protobuf/generate/language/c/h.erb

@@ -7,28 +7,34 @@
 #ifdef __cplusplus
   extern "C" {
 #endif
-<%
-  each do |exp|
-    if exp.kind_of?(Protobuf::Generate::Ast::Package)
-      package exp.name
-    elsif exp.kind_of?(Protobuf::Generate::Ast::Enum)
-%>
+
+// TODO: Export to avoid unused function errors with -Werror.
+// Remove. Have parser count type usage and only include the code if required.
+int write_raw_little_endian32(uint32_t value, uint8_t *buffer, int offset);
+int write_raw_little_endian64(uint64_t value, uint8_t *buffer, int offset);
+int write_raw_varint32(uint32_t value, uint8_t *buffer, int offset);
+int write_raw_varint64(uint64_t value, uint8_t *buffer, int offset);
+int read_raw_little_endian32(uint32_t *tag, const uint8_t *buffer, int offset);
+int read_raw_little_endian64(uint64_t *tag, const uint8_t *buffer, int offset);
+int read_raw_varint32(uint32_t *tag, const uint8_t *buffer, int offset);
+int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset);
+
+<% each do |exp| %>
+  <% if exp.kind_of?(Protobuf::Generate::Ast::Enum) %>
 
   typedef enum {
     <% exp.fields.each do |field| %>
-      <%= namespaced_constant exp.name, field.name %> = <%= field.tag %>,
+      <%= constant exp.package, exp.name, field.name %> = <%= field.tag %>,
     <% end %>
-  } <%= namespaced_type exp.name %>;
-<%
-    elsif exp.kind_of?(Protobuf::Generate::Ast::Message)
-%>
+  } <%= type exp.package, exp.name %>;
+  <% elsif exp.kind_of?(Protobuf::Generate::Ast::Message) %>
 
-  typedef struct <%= namespaced_type exp.name %> {
+  typedef struct <%= type exp.package, exp.name %> {
     <% exp.fields.each do |field| %>
       <% if type_message?(field.type) %>
-        <%= namespaced_type field.type %> <%= field.name %>;
+        <%= type exp.package, field.type %> <%= field.name %>;
       <% elsif type_enum?(field.type) %>
-        <%= namespaced_type field.type %> <%= field.name %>;
+        <%= type exp.package, field.type %> <%= field.name %>;
       <% elsif field.type =~ /double/ %>
         double <%= field.name %>;
       <% elsif field.type =~ /float/ %>
@@ -55,16 +61,14 @@
         } <%= field.name %>;
       <% end %>
     <% end %>
-  } <%= namespaced_type exp.name %>;
+  } <%= type exp.package, exp.name %>;
 
   // TODO: Replace int with an protobuf_(encode|decode)_t type.
   // TODO: Move encode_size into result type.
-  int <%= namespaced_function exp.name, 'encode' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *data, size_t data_size, size_t *encoded_size);
-  int <%= namespaced_function exp.name, 'decode' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *data, size_t data_size, size_t *encoded_size);
-<%
-    end
-  end
-%>
+  int <%= function exp.package, exp.name, 'encode' %>(const <%= type exp.package, exp.name %> *pb, uint8_t *data, size_t data_size, size_t *encoded_size);
+  int <%= function exp.package, exp.name, 'decode' %>(<%= type exp.package, exp.name %> *pb, const uint8_t *data, size_t data_size, size_t *encoded_size);
+  <% end %>
+<% end %>
 
 #ifdef __cplusplus
   }

data/lib/protobuf/generate/language/c.rb

@@ -8,24 +8,14 @@ module Protobuf
         templates Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), 'c', '*.erb'))
 
         module Conventions
-          def package name = nil
-            @naming_namespace = name.to_s if name
-            (@naming_namespace ||= '').gsub('.', '_')
-          end
-
           def type     *name; snake_case *name, 't'    end
           def variable *name; snake_case *name         end
           def constant *name; snake_case(*name).upcase end
           def function *name; snake_case *name         end
 
-          def namespaced_type     *name; type     package, *name end
-          def namespaced_variable *name; variable package, *name end
-          def namespaced_constant *name; constant package, *name end
-          def namespaced_function *name; function package, *name end
-
           protected
             def snake_case *name
-              name.map(&:to_s).join('_').gsub(/([^A-Z_])([A-Z]+)/, '\1_\2').gsub(/_+/, '_').downcase
+              name.map(&:to_s).join('_').gsub(/([^A-Z_])([A-Z]+)/, '\1_\2').gsub(/[_.]+/, '_').downcase
             end
         end # Conventions
 

data/lib/protobuf/generate/parser.rb

@@ -51,19 +51,33 @@ module Protobuf
     end # Parser
 
     class Ast
-      class Package < Struct.new(:name); end
-      class Message < Struct.new(:name, :meta, :fields)
+      class Package < Struct.new(:name)
+        def to_s; name end
+      end
+      class Message < Struct.new(:package, :name, :meta, :fields)
+        def to_s; name end
         def empty?; fields.nil? or fields.empty? end
       end
       class MessageField < Struct.new(:label, :type, :name, :tag, :meta, :options)
         def required?; !!label.match(/required/) end
         def optional?; !required? end
       end
-      class Enum < Struct.new(:name, :fields); end
+      class Enum < Struct.new(:package, :name, :fields)
+        def to_s; name end
+      end
       class EnumField < Struct.new(:name, :tag); end
     end
 
     class Transform < Parslet::Transform
+      def apply slice, *args
+        slice = super
+        case slice
+          when Ast::Package            then @package = slice
+          when Ast::Message, Ast::Enum then slice.package = @package
+        end
+        slice
+      end
+
       rule(option:  {name: simple(:name), value: simple(:value)}){ [name.to_s, value.to_s] }
       rule(package: {name: simple(:name)}){ Ast::Package.new(name.to_s) }
 
@@ -77,6 +91,7 @@ module Protobuf
 
       rule(message: subtree(:message)) do
         Ast::Message.new(
+          nil,
           message[:name].to_s,
           # TODO: Parslet should return nil not "" when empty. Figure out what's going on.
           message[:comments].kind_of?(Array) ? Hash[*message[:comments].map{|c| c[:meta]}.flatten.compact] : {},
@@ -85,7 +100,7 @@ module Protobuf
       end
 
       rule(enum_field: {name: simple(:name), tag: simple(:tag)}){ Ast::EnumField.new(name.to_s, tag.to_s) }
-      rule(enum: subtree(:enum)){ Ast::Enum.new(enum[:name].to_s, enum[:fields]) }
+      rule(enum: subtree(:enum)){ Ast::Enum.new(nil, enum[:name].to_s, enum[:fields]) }
     end # Transform
   end # Generate
 end # Protobuf

data/protobuf-generate.gemspec

@@ -2,7 +2,7 @@ $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
 spec = Gem::Specification.new do |s|
   s.name        = 'protobuf-generate'
-  s.version     = '0.0.1'
+  s.version     = '0.1.0'
   s.summary     = 'A multi-language concrete protobuf code generator.'
   s.description = 'A simple PEG parser, AST and template based approach to code generation.'
   s.authors     = ['Shane Hanna']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-generate
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Shane Hanna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-09 00:00:00.000000000 Z
+date: 2013-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -83,4 +83,3 @@ signing_key:
 specification_version: 4
 summary: A multi-language concrete protobuf code generator.
 test_files: []
-has_rdoc: