protostar 0.1.0.beta1

data/lib/protostar/google/protobuf/duration_pb.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Generated by protostar from google/protobuf/duration.proto. Do not edit.
+
+require "protostar"
+
+Protostar::DSL.file(
+  "google/protobuf/duration.proto",
+  package: "google.protobuf",
+  syntax: :proto3,
+  cc_enable_arenas: true,
+  go_package: "google.golang.org/protobuf/types/known/durationpb",
+  java_package: "com.google.protobuf",
+  java_outer_classname: "DurationProto",
+  java_multiple_files: true,
+  objc_class_prefix: "GPB",
+  csharp_namespace: "Google.Protobuf.WellKnownTypes"
+) do |f|
+  # A Duration represents a signed, fixed-length span of time represented
+  # as a count of seconds and fractions of seconds at nanosecond
+  # resolution. It is independent of any calendar and concepts like "day"
+  # or "month". It is related to Timestamp in that the difference between
+  # two Timestamp values is a Duration and it can be added or subtracted
+  # from a Timestamp. Range is approximately +-10,000 years.
+  #
+  # # Examples
+  #
+  # Example 1: Compute Duration from two Timestamps in pseudo code.
+  #
+  #     Timestamp start = ...;
+  #     Timestamp end = ...;
+  #     Duration duration = ...;
+  #
+  #     duration.seconds = end.seconds - start.seconds;
+  #     duration.nanos = end.nanos - start.nanos;
+  #
+  #     if (duration.seconds < 0 && duration.nanos > 0) {
+  #       duration.seconds += 1;
+  #       duration.nanos -= 1000000000;
+  #     } else if (duration.seconds > 0 && duration.nanos < 0) {
+  #       duration.seconds -= 1;
+  #       duration.nanos += 1000000000;
+  #     }
+  #
+  # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+  #
+  #     Timestamp start = ...;
+  #     Duration duration = ...;
+  #     Timestamp end = ...;
+  #
+  #     end.seconds = start.seconds + duration.seconds;
+  #     end.nanos = start.nanos + duration.nanos;
+  #
+  #     if (end.nanos < 0) {
+  #       end.seconds -= 1;
+  #       end.nanos += 1000000000;
+  #     } else if (end.nanos >= 1000000000) {
+  #       end.seconds += 1;
+  #       end.nanos -= 1000000000;
+  #     }
+  #
+  # Example 3: Compute Duration from datetime.timedelta in Python.
+  #
+  #     td = datetime.timedelta(days=3, minutes=10)
+  #     duration = Duration()
+  #     duration.FromTimedelta(td)
+  #
+  # # JSON Mapping
+  #
+  # In JSON format, the Duration type is encoded as a string rather than an
+  # object, where the string ends in the suffix "s" (indicating seconds) and
+  # is preceded by the number of seconds, with nanoseconds expressed as
+  # fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+  # encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+  # be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+  # microsecond should be expressed in JSON format as "3.000001s".
+  #
+  f.message "Duration" do |m|
+    # Signed seconds of the span of time. Must be from -315,576,000,000
+    # to +315,576,000,000 inclusive. Note: these bounds are computed from:
+    # 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+    m.field :seconds, 1, :int64
+    # Signed fractions of a second at nanosecond resolution of the span
+    # of time. Durations less than one second are represented with a 0
+    # `seconds` field and a positive or negative `nanos` field. For durations
+    # of one second or more, a non-zero value for the `nanos` field must be
+    # of the same sign as the `seconds` field. Must be from -999,999,999
+    # to +999,999,999 inclusive.
+    m.field :nanos, 2, :int32
+  end
+end
+
+module Protostar
+  module Google
+    module Protobuf
+      Duration = Protostar::DSL.message("google.protobuf.Duration")
+    end
+  end
+end

data/lib/protostar/google/protobuf/empty_pb.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Generated by protostar from google/protobuf/empty.proto. Do not edit.
+
+require "protostar"
+
+Protostar::DSL.file(
+  "google/protobuf/empty.proto",
+  package: "google.protobuf",
+  syntax: :proto3,
+  go_package: "google.golang.org/protobuf/types/known/emptypb",
+  java_package: "com.google.protobuf",
+  java_outer_classname: "EmptyProto",
+  java_multiple_files: true,
+  objc_class_prefix: "GPB",
+  csharp_namespace: "Google.Protobuf.WellKnownTypes",
+  cc_enable_arenas: true
+) do |f|
+  # A generic empty message that you can re-use to avoid defining duplicated
+  # empty messages in your APIs. A typical example is to use it as the request
+  # or the response type of an API method. For instance:
+  #
+  #     service Foo {
+  #       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+  #     }
+  #
+  f.message "Empty"
+end
+
+module Protostar
+  module Google
+    module Protobuf
+      Empty = Protostar::DSL.message("google.protobuf.Empty")
+    end
+  end
+end

data/lib/protostar/google/protobuf/field_mask_pb.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+# Generated by protostar from google/protobuf/field_mask.proto. Do not edit.
+
+require "protostar"
+
+Protostar::DSL.file(
+  "google/protobuf/field_mask.proto",
+  package: "google.protobuf",
+  syntax: :proto3,
+  java_package: "com.google.protobuf",
+  java_outer_classname: "FieldMaskProto",
+  java_multiple_files: true,
+  objc_class_prefix: "GPB",
+  csharp_namespace: "Google.Protobuf.WellKnownTypes",
+  go_package: "google.golang.org/protobuf/types/known/fieldmaskpb",
+  cc_enable_arenas: true
+) do |f|
+  # `FieldMask` represents a set of symbolic field paths, for example:
+  #
+  #     paths: "f.a"
+  #     paths: "f.b.d"
+  #
+  # Here `f` represents a field in some root message, `a` and `b`
+  # fields in the message found in `f`, and `d` a field found in the
+  # message in `f.b`.
+  #
+  # Field masks are used to specify a subset of fields that should be
+  # returned by a get operation or modified by an update operation.
+  # Field masks also have a custom JSON encoding (see below).
+  #
+  # # Field Masks in Projections
+  #
+  # When used in the context of a projection, a response message or
+  # sub-message is filtered by the API to only contain those fields as
+  # specified in the mask. For example, if the mask in the previous
+  # example is applied to a response message as follows:
+  #
+  #     f {
+  #       a : 22
+  #       b {
+  #         d : 1
+  #         x : 2
+  #       }
+  #       y : 13
+  #     }
+  #     z: 8
+  #
+  # The result will not contain specific values for fields x,y and z
+  # (their value will be set to the default, and omitted in proto text
+  # output):
+  #
+  #
+  #     f {
+  #       a : 22
+  #       b {
+  #         d : 1
+  #       }
+  #     }
+  #
+  # A repeated field is not allowed except at the last position of a
+  # paths string.
+  #
+  # If a FieldMask object is not present in a get operation, the
+  # operation applies to all fields (as if a FieldMask of all fields
+  # had been specified).
+  #
+  # Note that a field mask does not necessarily apply to the
+  # top-level response message. In case of a REST get operation, the
+  # field mask applies directly to the response, but in case of a REST
+  # list operation, the mask instead applies to each individual message
+  # in the returned resource list. In case of a REST custom method,
+  # other definitions may be used. Where the mask applies will be
+  # clearly documented together with its declaration in the API.  In
+  # any case, the effect on the returned resource/resources is required
+  # behavior for APIs.
+  #
+  # # Field Masks in Update Operations
+  #
+  # A field mask in update operations specifies which fields of the
+  # targeted resource are going to be updated. The API is required
+  # to only change the values of the fields as specified in the mask
+  # and leave the others untouched. If a resource is passed in to
+  # describe the updated values, the API ignores the values of all
+  # fields not covered by the mask.
+  #
+  # If a repeated field is specified for an update operation, new values will
+  # be appended to the existing repeated field in the target resource. Note that
+  # a repeated field is only allowed in the last position of a `paths` string.
+  #
+  # If a sub-message is specified in the last position of the field mask for an
+  # update operation, then new value will be merged into the existing sub-message
+  # in the target resource.
+  #
+  # For example, given the target message:
+  #
+  #     f {
+  #       b {
+  #         d: 1
+  #         x: 2
+  #       }
+  #       c: [1]
+  #     }
+  #
+  # And an update message:
+  #
+  #     f {
+  #       b {
+  #         d: 10
+  #       }
+  #       c: [2]
+  #     }
+  #
+  # then if the field mask is:
+  #
+  #  paths: ["f.b", "f.c"]
+  #
+  # then the result will be:
+  #
+  #     f {
+  #       b {
+  #         d: 10
+  #         x: 2
+  #       }
+  #       c: [1, 2]
+  #     }
+  #
+  # An implementation may provide options to override this default behavior for
+  # repeated and message fields.
+  #
+  # Note that libraries which implement FieldMask resolution have various
+  # different behaviors in the face of empty masks or the special "*" mask.
+  # When implementing a service you should confirm these cases have the
+  # appropriate behavior in the underlying FieldMask library that you desire,
+  # and you may need to special case those cases in your application code if
+  # the underlying field mask library behavior differs from your intended
+  # service semantics.
+  #
+  # Update methods implementing https://google.aip.dev/134
+  # - MUST support the special value * meaning "full replace"
+  # - MUST treat an omitted field mask as "replace fields which are present".
+  #
+  # Other methods implementing https://google.aip.dev/157
+  # - SHOULD support the special value "*" to mean "get all".
+  # - MUST treat an omitted field mask to mean "get all", unless otherwise
+  # documented.
+  #
+  # ## Considerations for HTTP REST
+  #
+  # The HTTP kind of an update operation which uses a field mask must
+  # be set to PATCH instead of PUT in order to satisfy HTTP semantics
+  # (PUT must only be used for full updates).
+  #
+  # # JSON Encoding of Field Masks
+  #
+  # In JSON, a field mask is encoded as a single string where paths are
+  # separated by a comma. Fields name in each path are converted
+  # to/from lower-camel naming conventions.
+  #
+  # As an example, consider the following message declarations:
+  #
+  #     message Profile {
+  #       User user = 1;
+  #       Photo photo = 2;
+  #     }
+  #     message User {
+  #       string display_name = 1;
+  #       string address = 2;
+  #     }
+  #
+  # In proto a field mask for `Profile` may look as such:
+  #
+  #     mask {
+  #       paths: "user.display_name"
+  #       paths: "photo"
+  #     }
+  #
+  # In JSON, the same mask is represented as below:
+  #
+  #     {
+  #       mask: "user.displayName,photo"
+  #     }
+  #
+  # # Field Masks and Oneof Fields
+  #
+  # Field masks treat fields in oneofs just as regular fields. Consider the
+  # following message:
+  #
+  #     message SampleMessage {
+  #       oneof test_oneof {
+  #         string name = 4;
+  #         SubMessage sub_message = 9;
+  #       }
+  #     }
+  #
+  # The field mask can be:
+  #
+  #     mask {
+  #       paths: "name"
+  #     }
+  #
+  # Or:
+  #
+  #     mask {
+  #       paths: "sub_message"
+  #     }
+  #
+  # Note that oneof type names ("test_oneof" in this case) cannot be used in
+  # paths.
+  #
+  # ## Field Mask Verification
+  #
+  # The implementation of any API method which has a FieldMask type field in the
+  # request should verify the included field paths, and return an
+  # `INVALID_ARGUMENT` error if any path is unmappable.
+  f.message "FieldMask" do |m|
+    # The set of field mask paths.
+    m.field :paths, 1, :string, label: :repeated
+  end
+end
+
+module Protostar
+  module Google
+    module Protobuf
+      FieldMask = Protostar::DSL.message("google.protobuf.FieldMask")
+    end
+  end
+end

data/lib/protostar/google/protobuf/source_context_pb.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Generated by protostar from google/protobuf/source_context.proto. Do not edit.
+
+require "protostar"
+
+Protostar::DSL.file(
+  "google/protobuf/source_context.proto",
+  package: "google.protobuf",
+  syntax: :proto3,
+  java_package: "com.google.protobuf",
+  java_outer_classname: "SourceContextProto",
+  java_multiple_files: true,
+  objc_class_prefix: "GPB",
+  csharp_namespace: "Google.Protobuf.WellKnownTypes",
+  go_package: "google.golang.org/protobuf/types/known/sourcecontextpb"
+) do |f|
+  # `SourceContext` represents information about the source of a
+  # protobuf element, like the file in which it is defined.
+  f.message "SourceContext" do |m|
+    # The path-qualified name of the .proto file that contained the associated
+    # protobuf element.  For example: `"google/protobuf/source_context.proto"`.
+    m.field :file_name, 1, :string
+  end
+end
+
+module Protostar
+  module Google
+    module Protobuf
+      SourceContext = Protostar::DSL.message("google.protobuf.SourceContext")
+    end
+  end
+end

data/lib/protostar/google/protobuf/struct_pb.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Generated by protostar from google/protobuf/struct.proto. Do not edit.
+
+require "protostar"
+
+Protostar::DSL.file(
+  "google/protobuf/struct.proto",
+  package: "google.protobuf",
+  syntax: :proto3,
+  cc_enable_arenas: true,
+  go_package: "google.golang.org/protobuf/types/known/structpb",
+  java_package: "com.google.protobuf",
+  java_outer_classname: "StructProto",
+  java_multiple_files: true,
+  objc_class_prefix: "GPB",
+  csharp_namespace: "Google.Protobuf.WellKnownTypes"
+) do |f|
+  # Represents a JSON object.
+  #
+  # An unordered key-value map, intending to perfectly capture the semantics of a
+  # JSON object. This enables parsing any arbitrary JSON payload as a message
+  # field in ProtoJSON format.
+  #
+  # This follows RFC 8259 guidelines for interoperable JSON: notably this type
+  # cannot represent large Int64 values or `NaN`/`Infinity` numbers,
+  # since the JSON format generally does not support those values in its number
+  # type.
+  #
+  # If you do not intend to parse arbitrary JSON into your message, a custom
+  # typed message should be preferred instead of using this type.
+  f.message "Struct" do |m|
+    # Unordered map of dynamically typed values.
+    m.map :fields, 1, :string, :message, ".google.protobuf.Value"
+  end
+  # Represents a JSON value.
+  #
+  # `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 is an invalid state.
+  f.message "Value" do |m|
+    # The kind of value.
+    m.oneof :kind do |o|
+      # Represents a JSON `null`.
+      o.field :null_value, 1, :enum, ".google.protobuf.NullValue"
+      # Represents a JSON number. Must not be `NaN`, `Infinity` or
+      # `-Infinity`, since those are not supported in JSON. This also cannot
+      # represent large Int64 values, since JSON format generally does not
+      # support them in its number type.
+      o.field :number_value, 2, :double
+      # Represents a JSON string.
+      o.field :string_value, 3, :string
+      # Represents a JSON boolean (`true` or `false` literal in JSON).
+      o.field :bool_value, 4, :bool
+      # Represents a JSON object.
+      o.field :struct_value, 5, :message, ".google.protobuf.Struct"
+      # Represents a JSON array.
+      o.field :list_value, 6, :message, ".google.protobuf.ListValue"
+    end
+  end
+  # Represents a JSON array.
+  f.message "ListValue" do |m|
+    # Repeated field of dynamically typed values.
+    m.field :values, 1, :message, ".google.protobuf.Value", label: :repeated
+  end
+  # Represents a JSON `null`.
+  #
+  # `NullValue` is a sentinel, using an enum with only one value to represent
+  # the null value for the `Value` type union.
+  #
+  # A field of type `NullValue` with any value other than `0` is considered
+  # invalid. Most ProtoJSON serializers will emit a `Value` with a `null_value`
+  # set as a JSON `null` regardless of the integer value, and so will round trip
+  # to a `0` value.
+  f.enum "NullValue" do |e|
+    # Null value.
+    e.value :NULL_VALUE, 0
+  end
+end
+
+module Protostar
+  module Google
+    module Protobuf
+      Struct = Protostar::DSL.message("google.protobuf.Struct")
+      Value = Protostar::DSL.message("google.protobuf.Value")
+      ListValue = Protostar::DSL.message("google.protobuf.ListValue")
+      NullValue = Protostar::DSL.enum("google.protobuf.NullValue")
+    end
+  end
+end

data/lib/protostar/google/protobuf/timestamp_pb.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Generated by protostar from google/protobuf/timestamp.proto. Do not edit.
+
+require "protostar"
+
+Protostar::DSL.file(
+  "google/protobuf/timestamp.proto",
+  package: "google.protobuf",
+  syntax: :proto3,
+  cc_enable_arenas: true,
+  go_package: "google.golang.org/protobuf/types/known/timestamppb",
+  java_package: "com.google.protobuf",
+  java_outer_classname: "TimestampProto",
+  java_multiple_files: true,
+  objc_class_prefix: "GPB",
+  csharp_namespace: "Google.Protobuf.WellKnownTypes"
+) do |f|
+  # 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 ProtoJSON serializer should always use UTC (as indicated by
+  # "Z") when printing the Timestamp type and a ProtoJSON 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.
+  #
+  f.message "Timestamp" do |m|
+    # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must
+    # be between -62135596800 and 253402300799 inclusive (which corresponds to
+    # 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).
+    m.field :seconds, 1, :int64
+    # Non-negative fractions of a second at nanosecond resolution. This field is
+    # the nanosecond portion of the duration, not an alternative to seconds.
+    # Negative second values with fractions must still have non-negative nanos
+    # values that count forward in time. Must be between 0 and 999,999,999
+    # inclusive.
+    m.field :nanos, 2, :int32
+  end
+end
+
+module Protostar
+  module Google
+    module Protobuf
+      Timestamp = Protostar::DSL.message("google.protobuf.Timestamp")
+    end
+  end
+end