protobug_well_known_protos 0.1.0

data/lib/google/protobuf/struct_pb.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+# Code generated by protoc-gen-protobug. DO NOT EDIT.
+
+# source: google/protobuf/struct.proto
+# syntax: proto3
+# package: google.protobuf
+# options:
+#   java_package: "com.google.protobuf"
+#   java_outer_classname: "StructProto"
+#   java_multiple_files: true
+#   go_package: "google.golang.org/protobuf/types/known/structpb"
+#   cc_enable_arenas: true
+#   objc_class_prefix: "GPB"
+#   csharp_namespace: "Google.Protobuf.WellKnownTypes"
+
+# 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.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require "protobug"
+
+module Google
+  module Protobuf
+    # `Struct` represents a structured data value, consisting of fields
+    # which map to dynamically typed values. In some languages, `Struct`
+    # might be supported by a native representation. For example, in
+    # scripting languages like JS a struct is represented as an
+    # object. The details of that representation are described together
+    # with the proto support for the language.
+    #
+    # The JSON representation for `Struct` is JSON object.
+    class Struct
+      extend Protobug::Message
+
+      self.full_name = "google.protobuf.Struct"
+
+      # Unordered map of dynamically typed values.
+      map(
+        1,
+        "fields",
+        key_type: :string,
+        value_type: :message,
+        message_type: "google.protobuf.Value"
+      )
+    end
+
+    # `Value` represents a dynamically typed value which can be either
+    # null, a number, a string, a boolean, a recursive struct value, or a
+    # list of values. A producer of value is expected to set one of these
+    # variants. Absence of any variant indicates an error.
+    #
+    # The JSON representation for `Value` is JSON value.
+    class Value
+      extend Protobug::Message
+
+      self.full_name = "google.protobuf.Value"
+
+      # The kind of value.
+
+      # Represents a null value.
+      optional(
+        1,
+        "null_value",
+        type: :enum,
+        enum_type: "google.protobuf.NullValue",
+        json_name: "nullValue",
+        oneof: :kind,
+        proto3_optional: false
+      )
+      # Represents a double value.
+      optional(
+        2,
+        "number_value",
+        type: :double,
+        json_name: "numberValue",
+        oneof: :kind,
+        proto3_optional: false
+      )
+      # Represents a string value.
+      optional(
+        3,
+        "string_value",
+        type: :string,
+        json_name: "stringValue",
+        oneof: :kind,
+        proto3_optional: false
+      )
+      # Represents a boolean value.
+      optional(
+        4,
+        "bool_value",
+        type: :bool,
+        json_name: "boolValue",
+        oneof: :kind,
+        proto3_optional: false
+      )
+      # Represents a structured value.
+      optional(
+        5,
+        "struct_value",
+        type: :message,
+        message_type: "google.protobuf.Struct",
+        json_name: "structValue",
+        oneof: :kind,
+        proto3_optional: false
+      )
+      # Represents a repeated `Value`.
+      optional(
+        6,
+        "list_value",
+        type: :message,
+        message_type: "google.protobuf.ListValue",
+        json_name: "listValue",
+        oneof: :kind,
+        proto3_optional: false
+      )
+    end
+
+    # `NullValue` is a singleton enumeration to represent the null value for the
+    # `Value` type union.
+    #
+    # The JSON representation for `NullValue` is JSON `null`.
+    class NullValue
+      extend Protobug::Enum
+
+      self.full_name = "google.protobuf.NullValue"
+
+      # Null value.
+      NULL_VALUE = new("NULL_VALUE", 0).freeze
+    end
+
+    # `ListValue` is a wrapper around a repeated field of values.
+    #
+    # The JSON representation for `ListValue` is JSON array.
+    class ListValue
+      extend Protobug::Message
+
+      self.full_name = "google.protobuf.ListValue"
+
+      # Repeated field of dynamically typed values.
+      repeated(
+        1,
+        "values",
+        type: :message,
+        message_type: "google.protobuf.Value"
+      )
+    end
+
+    def self.register_struct_protos(registry)
+      registry.register(Google::Protobuf::Struct)
+      registry.register(Google::Protobuf::Value)
+      registry.register(Google::Protobuf::NullValue)
+      registry.register(Google::Protobuf::ListValue)
+    end
+  end
+end
+
+require_relative "struct_well_known"

data/lib/google/protobuf/struct_well_known.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+Google::Protobuf::Value.class_eval do
+  class self::UnexpectedStructType < Protobug::InvalidValueError # rubocop:disable Lint/ConstantDefinitionInBlock,Style/ClassAndModuleChildren
+  end
+
+  def to_ruby(recursive: false)
+    case kind
+    when :struct_value
+      if recursive
+        struct_value.to_h
+      else
+        struct_value
+      end
+    when :list_value
+      if recursive
+        list_value.to_a
+      else
+        list_value
+      end
+    when :null_value
+      nil
+    when :number_value
+      number_value
+    when :string_value
+      string_value
+    when :bool_value
+      bool_value
+    else
+      raise UnexpectedStructType
+    end
+  end
+
+  def self.from_ruby(value)
+    new.from_ruby(value)
+  end
+
+  def from_ruby(value)
+    case value
+    when NilClass
+      self.null_value = Google::Protobuf::NullValue::NULL_VALUE
+    when Numeric
+      self.number_value = value
+    when String
+      self.string_value = value
+    when TrueClass
+      self.bool_value = true
+    when FalseClass
+      self.bool_value = false
+    when Struct
+      self.struct_value = value
+    when Hash
+      self.struct_value = Struct.from_hash(value)
+    when ListValue
+      self.list_value = value
+    when Array
+      self.list_value = ListValue.from_a(value)
+    else
+      raise UnexpectedStructType
+    end
+
+    self
+  end
+
+  def self.decode_json_hash(json, registry:, ignore_unknown_fields: false)
+    case json
+    when NilClass
+      json = { "nullValue" => "NULL_VALUE" }
+    when Float, Integer
+      json = { "numberValue" => json.to_f }
+    when String
+      json = { "stringValue" => json }
+    when TrueClass, FalseClass
+      json = { "boolValue" => json }
+    when Hash
+      json = { "structValue" => json }
+    when Array
+      json = { "listValue" => json }
+    end
+
+    super
+  end
+
+  def as_json(print_unknown_fields: false)
+    case kind
+    when :null_value
+      nil
+    when :number_value
+      number_value
+    when :string_value
+      string_value
+    when :bool_value
+      bool_value
+    when :struct_value
+      struct_value.as_json(print_unknown_fields: print_unknown_fields)
+    when :list_value
+      list_value.values.map! { _1.as_json(print_unknown_fields: print_unknown_fields) }
+    else
+      raise Protobug::EncodeError, "unknown kind: #{kind.inspect}"
+    end
+  end
+end
+
+Google::Protobuf::Struct.class_eval do
+  def [](key)
+    fields[key]&.to_ruby
+  end
+
+  def []=(key, value)
+    raise ArgumentError, "Struct keys must be strings." unless key.is_a?(String)
+
+    fields[key] ||= Google::Protobuf::Value.new
+    fields[key].from_ruby(value)
+  end
+
+  def to_h
+    fields.transform_values { |val| val.to_ruby(true) }
+  end
+
+  def self.from_hash(hash)
+    hash.each_with_object(new) { |(key, val), ret| ret[key] = val }
+  end
+
+  def key?(key)
+    fields.key?(key)
+  end
+
+  def self.decode_json_hash(json, registry:, ignore_unknown_fields: false)
+    json = { "fields" => json }
+    super
+  end
+
+  def as_json(print_unknown_fields: false)
+    fields.transform_values { _1&.as_json(print_unknown_fields: print_unknown_fields) }
+  end
+end
+
+Google::Protobuf::ListValue.class_eval do
+  include Enumerable
+
+  def length
+    values.length
+  end
+
+  def [](index)
+    values[index].to_ruby
+  end
+
+  def []=(index, value)
+    values[index].from_ruby(value)
+  end
+
+  def <<(value)
+    values << Google::Protobuf::Value.from_ruby(value)
+  end
+
+  def each
+    return enum_for(__method__) unless block_given?
+
+    values.each { |x| yield(x.to_ruby) }
+  end
+
+  def to_a
+    values.map { |x| x.to_ruby(true) }
+  end
+
+  def self.from_a(arr)
+    arr.each_with_object(new) { |val, ret| ret << val }
+  end
+
+  def self.decode_json_hash(json, registry:, ignore_unknown_fields: false)
+    json = { "values" => json }
+    super
+  end
+
+  def as_json(print_unknown_fields: false)
+    values.map { _1.as_json(print_unknown_fields: print_unknown_fields) }
+  end
+end
+
+Google::Protobuf::NullValue.class_eval do
+  def self.decode_json_hash(json, registry:, ignore_unknown_fields: false)
+    return values.fetch(0) if json.nil?
+
+    super
+  end
+
+  def as_json(print_unknown_fields: false)
+    return if value.zero?
+
+    super
+  end
+end

data/lib/google/protobuf/timestamp_pb.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# Code generated by protoc-gen-protobug. DO NOT EDIT.
+
+# source: google/protobuf/timestamp.proto
+# syntax: proto3
+# package: google.protobuf
+# options:
+#   java_package: "com.google.protobuf"
+#   java_outer_classname: "TimestampProto"
+#   java_multiple_files: true
+#   go_package: "google.golang.org/protobuf/types/known/timestamppb"
+#   cc_enable_arenas: true
+#   objc_class_prefix: "GPB"
+#   csharp_namespace: "Google.Protobuf.WellKnownTypes"
+
+# 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.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require "protobug"
+
+module Google
+  module Protobuf
+    # A Timestamp represents a point in time independent of any time zone or local
+    # calendar, encoded as a count of seconds and fractions of seconds at
+    # nanosecond resolution. The count is relative to an epoch at UTC midnight on
+    # January 1, 1970, in the proleptic Gregorian calendar which extends the
+    # Gregorian calendar backwards to year one.
+    #
+    # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+    # second table is needed for interpretation, using a [24-hour linear
+    # smear](https://developers.google.com/time/smear).
+    #
+    # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+    # restricting to that range, we ensure that we can convert to and from [RFC
+    # 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+    #
+    # # Examples
+    #
+    # Example 1: Compute Timestamp from POSIX `time()`.
+    #
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds(time(NULL));
+    #     timestamp.set_nanos(0);
+    #
+    # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+    #
+    #     struct timeval tv;
+    #     gettimeofday(&tv, NULL);
+    #
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds(tv.tv_sec);
+    #     timestamp.set_nanos(tv.tv_usec * 1000);
+    #
+    # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+    #
+    #     FILETIME ft;
+    #     GetSystemTimeAsFileTime(&ft);
+    #     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+    #
+    #     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+    #     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+    #     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+    #
+    # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+    #
+    #     long millis = System.currentTimeMillis();
+    #
+    #     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+    #         .setNanos((int) ((millis % 1000) * 1000000)).build();
+    #
+    # Example 5: Compute Timestamp from Java `Instant.now()`.
+    #
+    #     Instant now = Instant.now();
+    #
+    #     Timestamp timestamp =
+    #         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+    #             .setNanos(now.getNano()).build();
+    #
+    # Example 6: Compute Timestamp from current time in Python.
+    #
+    #     timestamp = Timestamp()
+    #     timestamp.GetCurrentTime()
+    #
+    # # JSON Mapping
+    #
+    # In JSON format, the Timestamp type is encoded as a string in the
+    # [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+    # format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+    # where {year} is always expressed using four digits while {month}, {day},
+    # {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+    # seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+    # are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+    # is required. A proto3 JSON serializer should always use UTC (as indicated by
+    # "Z") when printing the Timestamp type and a proto3 JSON parser should be
+    # able to accept both UTC and other timezones (as indicated by an offset).
+    #
+    # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+    # 01:30 UTC on January 15, 2017.
+    #
+    # In JavaScript, one can convert a Date object to this format using the
+    # standard
+    # [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+    # method. In Python, a standard `datetime.datetime` object can be converted
+    # to this format using
+    # [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+    # the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+    # the Joda Time's [`ISODateTimeFormat.dateTime()`](
+    # http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+    # ) to obtain a formatter capable of generating timestamps in this format.
+    class Timestamp
+      extend Protobug::Message
+
+      self.full_name = "google.protobuf.Timestamp"
+
+      # Represents seconds of UTC time since Unix epoch
+      # 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+      # 9999-12-31T23:59:59Z inclusive.
+      optional(1, "seconds", type: :int64, proto3_optional: false)
+      # Non-negative fractions of a second at nanosecond resolution. Negative
+      # second values with fractions must still have non-negative nanos values
+      # that count forward in time. Must be from 0 to 999,999,999
+      # inclusive.
+      optional(2, "nanos", type: :int32, proto3_optional: false)
+    end
+
+    def self.register_timestamp_protos(registry)
+      registry.register(Google::Protobuf::Timestamp)
+    end
+  end
+end
+
+require_relative "timestamp_well_known"

data/lib/google/protobuf/timestamp_well_known.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+Google::Protobuf::Timestamp.class_eval do
+  def to_time
+    Time.at(seconds, nanos, :nanosecond, in: 0)
+  end
+
+  def self.from_time(time)
+    new.from_time(time)
+  end
+
+  def from_time(time)
+    self.seconds = time.to_i
+    self.nanos = time.nsec
+    self
+  end
+
+  def to_i
+    seconds
+  end
+
+  def to_f
+    seconds + nanos.quo(1_000_000_000)
+  end
+
+  def self.decode_json_hash(json, registry:, ignore_unknown_fields: false)
+    return Protobug::UNSET if json.nil?
+    raise Protobug::DecodeError, "expected string for #{full_name}, got #{json.inspect}" unless json.is_a? String
+
+    if /t|z/.match?(json)
+      raise Protobug::DecodeError, "json timestamp string has incorrect capitalization: #{json.inspect}"
+    elsif !json.include?("T")
+      raise Protobug::DecodeError, "json timestamp string missing T: #{json.inspect}"
+    end
+
+    begin
+      time = DateTime.rfc3339(json, Date::GREGORIAN).to_time
+    rescue Date::Error => e
+      raise Protobug::DecodeError, "json timestamp string invalid: #{json.inspect} (#{e})"
+    end
+    validate_json_range(Protobug::DecodeError, time)
+    json = {
+      "seconds" => time.to_i,
+      "nanos" => time.nsec
+    }
+    super
+  end
+
+  def as_json(print_unknown_fields: false) # rubocop:disable Lint/UnusedMethodArgument
+    time = Time.at(seconds, nanos, :nanosecond, in: 0)
+    self.class.validate_json_range(Protobug::EncodeError, time)
+
+    nanosecs = time.nsec
+
+    if nanosecs.positive?
+      nanosecs = nanosecs.to_s.rjust(9, "0")
+      nil while nanosecs.delete_suffix!("000")
+      digits = nanosecs.size
+      format = "%FT%H:%M:%S.%#{digits}NZ"
+    else
+      format = "%FT%H:%M:%SZ"
+    end
+
+    time.strftime(format)
+  end
+
+  def self.validate_json_range(err, time)
+    raise err, "time value too large #{time.inspect}" if time.year > 9999
+    raise err, "time value too small #{time.inspect}" if time.year <= 0
+  end
+end