third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/compiler/ruby/ruby_generator.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 30 matching lines @@
 
 using google::protobuf::internal::scoped_ptr;
 
 namespace google {
 namespace protobuf {
 namespace compiler {
 namespace ruby {
 
 // Forward decls.
 std::string IntToString(int32 value);
-std::string StripDotProto(const std::string& proto_file);
+std::string GetRequireName(const std::string& proto_file);
 std::string LabelForField(google::protobuf::FieldDescriptor* field);
 std::string TypeName(google::protobuf::FieldDescriptor* field);
 void GenerateMessage(const google::protobuf::Descriptor* message,
                      google::protobuf::io::Printer* printer);
 void GenerateEnum(const google::protobuf::EnumDescriptor* en,
                   google::protobuf::io::Printer* printer);
 void GenerateMessageAssignment(
     const std::string& prefix,
     const google::protobuf::Descriptor* message,
     google::protobuf::io::Printer* printer);
 void GenerateEnumAssignment(
     const std::string& prefix,
     const google::protobuf::EnumDescriptor* en,
     google::protobuf::io::Printer* printer);
 
 std::string IntToString(int32 value) {
   std::ostringstream os;
   os << value;
   return os.str();
 }
 
-std::string StripDotProto(const std::string& proto_file) {
+std::string GetRequireName(const std::string& proto_file) {
   int lastindex = proto_file.find_last_of(".");
-  return proto_file.substr(0, lastindex);
+  return proto_file.substr(0, lastindex) + "_pb";
 }
 
 std::string GetOutputFilename(const std::string& proto_file) {
-  return StripDotProto(proto_file) + ".rb";
+  return GetRequireName(proto_file) + ".rb";
 }
 
 std::string LabelForField(const google::protobuf::FieldDescriptor* field) {
   switch (field->label()) {
     case FieldDescriptor::LABEL_OPTIONAL: return "optional";
     case FieldDescriptor::LABEL_REQUIRED: return "required";
     case FieldDescriptor::LABEL_REPEATED: return "repeated";
     default: assert(false); return "";
   }
 }
@@ skipping 140 matching lines @@
       "value :$name$, $number$\n",
       "name", value->name(),
       "number", IntToString(value->number()));
   }
 
   printer->Outdent();
   printer->Print(
     "end\n");
 }
 
-// Module names, class names, and enum value names need to be Ruby constants,
-// which must start with a capital letter.
+// Locale-agnostic utility functions.
+bool IsLower(char ch) { return ch >= 'a' && ch <= 'z'; }
+
+bool IsUpper(char ch) { return ch >= 'A' && ch <= 'Z'; }
+
+bool IsAlpha(char ch) { return IsLower(ch) || IsUpper(ch); }
+
+char ToUpper(char ch) { return IsLower(ch) ? (ch - 'a' + 'A') : ch; }
+
+
+// Package names in protobuf are snake_case by convention, but Ruby module
+// names must be PascalCased.
+//
+//   foo_bar_baz -> FooBarBaz
+std::string PackageToModule(const std::string& name) {
+  bool next_upper = true;
+  std::string result;
+  result.reserve(name.size());
+
+  for (int i = 0; i < name.size(); i++) {
+    if (name[i] == '_') {
+      next_upper = true;
+    } else {
+      if (next_upper) {
+        result.push_back(ToUpper(name[i]));
+      } else {
+        result.push_back(name[i]);
+      }
+      next_upper = false;
+    }
+  }
+
+  return result;
+}
+
+// Class and enum names in protobuf should be PascalCased by convention, but
+// since there is nothing enforcing this we need to ensure that they are valid
+// Ruby constants.  That mainly means making sure that the first character is
+// an upper-case letter.
 std::string RubifyConstant(const std::string& name) {
   std::string ret = name;
   if (!ret.empty()) {
-    if (ret[0] >= 'a' && ret[0] <= 'z') {
+    if (IsLower(ret[0])) {
       // If it starts with a lowercase letter, capitalize it.
-      ret[0] = ret[0] - 'a' + 'A';
-    } else if (ret[0] < 'A' || ret[0] > 'Z') {
+      ret[0] = ToUpper(ret[0]);
+    } else if (!IsAlpha(ret[0])) {
       // Otherwise (e.g. if it begins with an underscore), we need to come up
       // with some prefix that starts with a capital letter. We could be smarter
       // here, e.g. try to strip leading underscores, but this may cause other
       // problems if the user really intended the name. So let's just prepend a
       // well-known suffix.
       ret = "PB_" + ret;
     }
   }
+
   return ret;
 }
 
 void GenerateMessageAssignment(
     const std::string& prefix,
     const google::protobuf::Descriptor* message,
     google::protobuf::io::Printer* printer) {
 
   // Don't generate MapEntry messages -- we use the Ruby extension's native
   // support for map fields instead.
@@ skipping 40 matching lines @@
   while (!package_name.empty()) {
     size_t dot_index = package_name.find(".");
     string component;
     if (dot_index == string::npos) {
       component = package_name;
       package_name = "";
     } else {
       component = package_name.substr(0, dot_index);
       package_name = package_name.substr(dot_index + 1);
     }
-    component = RubifyConstant(component);
+    component = PackageToModule(component);
     printer->Print(
       "module $name$\n",
       "name", component);
     printer->Indent();
     levels++;
   }
   return levels;
 }
 
 void EndPackageModules(
@@ skipping 56 matching lines @@
 
     // Ok to omit this proto2 dependency -- so we won't print anything.
     GOOGLE_LOG(WARNING) << "Omitting proto2 dependency '" << import->name()
                         << "' from proto3 output file '"
                         << GetOutputFilename(from->name())
                         << "' because we don't support proto2 and no proto2 "
                            "types from that file are being used.";
     return true;
   } else {
     printer->Print(
-      "require '$name$'\n", "name", StripDotProto(import->name()));
+      "require '$name$'\n", "name", GetRequireName(import->name()));
     return true;
   }
 }
 
 bool GenerateFile(const FileDescriptor* file, io::Printer* printer,
                   string* error) {
   printer->Print(
     "# Generated by the protocol buffer compiler.  DO NOT EDIT!\n"
     "# source: $filename$\n"
     "\n",
@@ skipping 49 matching lines @@
       generator_context->Open(GetOutputFilename(file->name())));
   io::Printer printer(output.get(), '$');
 
   return GenerateFile(file, &printer, error);
 }
 
 }  // namespace ruby
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google