third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/ruby/src/main/java/com/google/protobuf/jruby/RubyMessage.java

 /*
  * Protocol Buffers - Google's data interchange format
  * Copyright 2014 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
@@ skipping 23 matching lines @@
 
 import com.google.protobuf.*;
 import org.jruby.*;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.Helpers;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
 
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
 import java.util.HashMap;
 import java.util.Map;
 
 public class RubyMessage extends RubyObject {
     public RubyMessage(Ruby ruby, RubyClass klazz, Descriptors.Descriptor descriptor) {
         super(ruby, klazz);
         this.descriptor = descriptor;
     }
 
     /*
@@ skipping 103 matching lines @@
     }
 
     /*
      * call-seq:
      *     Message.hash => hash_value
      *
      * Returns a hash value that represents this message's field values.
      */
     @JRubyMethod
     public IRubyObject hash(ThreadContext context) {
-        int hashCode = System.identityHashCode(this);
-        return context.runtime.newFixnum(hashCode);
+        try {
+            MessageDigest digest = MessageDigest.getInstance("SHA-256");
+            for (RubyMap map : maps.values()) {
+                digest.update((byte) map.hashCode());
+            }
+            for (RubyRepeatedField repeatedField : repeatedFields.values()) {
+                digest.update((byte) repeatedFields.hashCode());
+            }
+            for (IRubyObject field : fields.values()) {
+                digest.update((byte) field.hashCode());
+            }
+            return context.runtime.newString(new ByteList(digest.digest()));
+        } catch (NoSuchAlgorithmException ignore) {
+            return context.runtime.newFixnum(System.identityHashCode(this));
+        }
     }
 
     /*
      * call-seq:
      *     Message.==(other) => boolean
      *
      * Performs a deep comparison of this message with another. Messages are equal
      * if they have the same type and if each field is equal according to the :==
      * method's semantics (a more efficient comparison may actually be done if the
      * field is of a primitive type).
@@ skipping 318 matching lines @@
                     throw runtime.newTypeError("Expected number type for double field.");
                 val = RubyNumeric.num2dbl(value);
                 break;
             case BOOL:
                 if (!(value instanceof RubyBoolean))
                     throw runtime.newTypeError("Invalid argument for boolean field.");
                 val = value.isTrue();
                 break;
             case BYTES:
             case STRING:
-                Utils.validateStringEncoding(context.runtime, fieldDescriptor.getType(), value);
+                Utils.validateStringEncoding(context, fieldDescriptor.getType(), value);
                 RubyString str = (RubyString) value;
                 switch (fieldDescriptor.getType()) {
                     case BYTES:
                         val = ByteString.copyFrom(str.getBytes());
                         break;
                     case STRING:
                         val = str.asJavaString();
                         break;
                     default:
                         break;
@@ skipping 67 matching lines @@
 
         } else if (type == Descriptors.FieldDescriptor.Type.ENUM) {
             typeClass = ((RubyEnumDescriptor) descriptor).enummodule(context);
         }
         return new RubyRepeatedField(context.runtime, cRepeatedField, type, typeClass);
     }
 
     protected IRubyObject getField(ThreadContext context, Descriptors.FieldDescriptor fieldDescriptor) {
         Descriptors.OneofDescriptor oneofDescriptor = fieldDescriptor.getContainingOneof();
         if (oneofDescriptor != null) {
-            if (oneofCases.containsKey(oneofDescriptor)) {
-                if (oneofCases.get(oneofDescriptor) != fieldDescriptor)
-                    return context.runtime.getNil();
+            if (oneofCases.get(oneofDescriptor) == fieldDescriptor) {
                 return fields.get(fieldDescriptor);
             } else {
                 Descriptors.FieldDescriptor oneofCase = builder.getOneofFieldDescriptor(oneofDescriptor);
-                if (oneofCase != fieldDescriptor) return context.runtime.getNil();
+                if (oneofCase != fieldDescriptor) {
+                  if (fieldDescriptor.getType() == Descriptors.FieldDescriptor.Type.MESSAGE) {
+                    return context.runtime.getNil();
+                  } else {
+                    return wrapField(context, fieldDescriptor, fieldDescriptor.getDefaultValue());
+                  }
+                }
                 IRubyObject value = wrapField(context, oneofCase, builder.getField(oneofCase));
                 fields.put(fieldDescriptor, value);
                 return value;
             }
         }
 
         if (Utils.isMapEntry(fieldDescriptor)) {
             RubyMap map = maps.get(fieldDescriptor);
             if (map == null) {
                 map = newMapForField(context, fieldDescriptor);
@@ skipping 72 matching lines @@
                 } else if (fieldType == Descriptors.FieldDescriptor.Type.ENUM) {
                     typeClass = ((RubyEnumDescriptor) getDescriptorForField(context, fieldDescriptor)).enummodule(context);
                     Descriptors.EnumDescriptor enumDescriptor = fieldDescriptor.getEnumType();
                     if (Utils.isRubyNum(value)) {
                         Descriptors.EnumValueDescriptor val =
                                 enumDescriptor.findValueByNumberCreatingIfUnknown(RubyNumeric.num2int(value));
                         if (val.getIndex() != -1) value = context.runtime.newSymbol(val.getName());
                     }
                 }
                 if (addValue) {
-                    Utils.checkType(context, fieldType, value, (RubyModule) typeClass);
+                    value = Utils.checkType(context, fieldType, value, (RubyModule) typeClass);
                     this.fields.put(fieldDescriptor, value);
                 } else {
                     this.fields.remove(fieldDescriptor);
                 }
             }
         }
         return context.runtime.getNil();
     }
 
     private String layoutInspect() {
@@ skipping 51 matching lines @@
     private DynamicMessage.Builder builder;
     private RubyClass cRepeatedField;
     private RubyClass cMap;
     private Map<Descriptors.FieldDescriptor, RubyRepeatedField> repeatedFields;
     private Map<Descriptors.FieldDescriptor, RubyMap> maps;
     private Map<Descriptors.FieldDescriptor, IRubyObject> fields;
     private Map<Descriptors.OneofDescriptor, Descriptors.FieldDescriptor> oneofCases;
 
     private static final int SINK_MAXIMUM_NESTING = 64;
 }