protostar 0.1.0.beta1

data/lib/protostar/schema/service.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Schema
+    # An RPC service. Its methods are exposed as {#rpcs} and {#rpc} so that
+    # Object#methods and Object#method keep working on a descriptor.
+    class Service < Descriptor
+      # @return [File]
+      attr_reader :file
+
+      # @api private
+      def initialize(name:, full_name:, file:, index:)
+        @name = name
+        @full_name = full_name
+        @file = file
+        @index = index
+        @rpcs = Freezer::EMPTY_ARRAY
+        @rpcs_by_name = Freezer::EMPTY_HASH
+      end
+
+      # @api private
+      def __rpcs(rpcs)
+        @rpcs = rpcs
+        @rpcs_by_name = rpcs.to_h { |m| [m.name, m] }.freeze
+        self
+      end
+
+      # @return [Array<Method>] declaration order
+      attr_reader :rpcs
+
+      # @param name [String, Symbol]
+      # @return [Method, nil]
+      def rpc(name)
+        @rpcs_by_name[name.to_s]
+      end
+
+      # @return [Protostar::Google::Protobuf::ServiceDescriptorProto]
+      def to_proto
+        Proto::Writer.service(self)
+      end
+    end
+
+    # One RPC of a {Service}
+    class Method < Descriptor
+      # @return [Service]
+      attr_reader :service
+      # @return [Message]
+      attr_reader :input_type
+      # @return [Message]
+      attr_reader :output_type
+
+      # @api private
+      attr_reader :input_type_name, :output_type_name
+
+      # @api private
+      def initialize(name:, full_name:, service:, index:, input_type_name:, output_type_name:,
+        client_streaming:, server_streaming:)
+        @name = name
+        @full_name = full_name
+        @service = service
+        @index = index
+        @input_type_name = input_type_name
+        @output_type_name = output_type_name
+        @client_streaming = client_streaming
+        @server_streaming = server_streaming
+      end
+
+      # @return [File]
+      def file
+        @service.file
+      end
+
+      # @return [Boolean]
+      def client_streaming?
+        @client_streaming
+      end
+
+      # @return [Boolean]
+      def server_streaming?
+        @server_streaming
+      end
+
+      # @return [Protostar::Google::Protobuf::MethodDescriptorProto]
+      def to_proto
+        Proto::Writer.rpc(self)
+      end
+    end
+  end
+end

data/lib/protostar/schema/source_info.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Schema
+    # A file's `source_code_info`, kept verbatim
+    class SourceInfo
+      # One `SourceCodeInfo.Location`
+      class Location
+        # @return [Array<Integer>] the descriptor path, e.g. [4, 0, 2, 1] for message 0, field 1
+        attr_reader :path
+        # @return [Array<Integer>] [start_line, start_column, (end_line,) end_column], zero-based
+        attr_reader :span
+        # @return [String, nil]
+        attr_reader :leading_comments
+        # @return [String, nil]
+        attr_reader :trailing_comments
+        # @return [Array<String>]
+        attr_reader :leading_detached_comments
+
+        # @param path [Array<Integer>]
+        # @param span [Array<Integer>]
+        # @param leading_comments [String, nil]
+        # @param trailing_comments [String, nil]
+        # @param leading_detached_comments [Array<String>]
+        def initialize(path:, span:, leading_comments: nil, trailing_comments: nil, leading_detached_comments: [])
+          @path = Freezer.call(path)
+          @span = Freezer.call(span)
+          @leading_comments = Freezer.call(leading_comments)
+          @trailing_comments = Freezer.call(trailing_comments)
+          @leading_detached_comments = Freezer.call(leading_detached_comments)
+          freeze
+        end
+      end
+
+      # @return [Array<Location>]
+      attr_reader :locations
+
+      # @param locations [Array<Location>] in protoc's order
+      def initialize(locations)
+        @locations = locations.dup.freeze
+        @by_path = {}
+        @locations.each { |loc| @by_path[loc.path] ||= loc }
+        @by_path.freeze
+      end
+
+      # @param path [Array<Integer>]
+      # @return [Location, nil] the first location recorded for the path
+      def location(path)
+        @by_path[path]
+      end
+    end
+  end
+end

data/lib/protostar/schema.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Protostar
+  # The descriptor model: an immutable, Ractor-shareable graph of files,
+  # messages, fields, enums and services. {File.draft} builds one;
+  # {File#to_proto} and {File.from_proto} translate to and from protoc's
+  # `FileDescriptorProto`.
+  module Schema
+    autoload :DefaultValue, ::File.expand_path("schema/default_value", __dir__)
+    autoload :Draft, ::File.expand_path("schema/draft", __dir__)
+    autoload :ExtensionRange, ::File.expand_path("schema/extension_range", __dir__)
+    autoload :Proto, ::File.expand_path("schema/proto", __dir__)
+    autoload :Resolver, ::File.expand_path("schema/resolver", __dir__)
+    autoload :SourceInfo, ::File.expand_path("schema/source_info", __dir__)
+
+    # Raised for malformed descriptors, missing dependencies and pool clashes
+    class Error < Protostar::Error; end
+
+    # The JSON name protoc derives from a field name: underscores dropped,
+    # the letter after each one upper-cased
+    # @param name [String]
+    # @return [String]
+    def self.json_name(name)
+      out = +""
+      upper = false
+      name.each_char do |c|
+        if c == "_"
+          upper = true
+        elsif upper
+          out << c.upcase(:ascii)
+          upper = false
+        else
+          out << c
+        end
+      end
+      out
+    end
+
+    # Raised when a type name, extendee or method type cannot be resolved
+    class ResolveError < Error
+      # @return [String, nil] the name as written
+      attr_reader :name
+      # @return [String, nil] the scope the lookup started from
+      attr_reader :scope
+
+      def initialize(message, name: nil, scope: nil)
+        @name = name
+        @scope = scope
+        super(message)
+      end
+    end
+  end
+end
+
+require_relative "schema/freezer"
+require_relative "schema/options"
+require_relative "schema/features"
+require_relative "schema/descriptor"
+require_relative "schema/file"
+require_relative "schema/message"
+require_relative "schema/oneof"
+require_relative "schema/field"
+require_relative "schema/enum"
+require_relative "schema/service"
+require_relative "schema/pool"

data/lib/protostar/short_names/any.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "../google/protobuf/any_pb"
+
+module Protostar
+  Any = Google::Protobuf::Any
+end

data/lib/protostar/short_names/duration.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "../google/protobuf/duration_pb"
+
+module Protostar
+  Duration = Google::Protobuf::Duration
+end

data/lib/protostar/short_names/empty.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "../google/protobuf/empty_pb"
+
+module Protostar
+  Empty = Google::Protobuf::Empty
+end

data/lib/protostar/short_names/field_mask.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "../google/protobuf/field_mask_pb"
+
+module Protostar
+  FieldMask = Google::Protobuf::FieldMask
+end

data/lib/protostar/short_names/struct.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../google/protobuf/struct_pb"
+
+module Protostar
+  Struct = Google::Protobuf::Struct
+  Value = Google::Protobuf::Value
+  ListValue = Google::Protobuf::ListValue
+end

data/lib/protostar/short_names/timestamp.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "../google/protobuf/timestamp_pb"
+
+module Protostar
+  Timestamp = Google::Protobuf::Timestamp
+end

data/lib/protostar/short_names/wrappers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../google/protobuf/wrappers_pb"
+
+module Protostar
+  DoubleValue = Google::Protobuf::DoubleValue
+  FloatValue = Google::Protobuf::FloatValue
+  Int64Value = Google::Protobuf::Int64Value
+  UInt64Value = Google::Protobuf::UInt64Value
+  Int32Value = Google::Protobuf::Int32Value
+  UInt32Value = Google::Protobuf::UInt32Value
+  BoolValue = Google::Protobuf::BoolValue
+  StringValue = Google::Protobuf::StringValue
+  BytesValue = Google::Protobuf::BytesValue
+end

data/lib/protostar/text/extensions.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Text
+    # Extensions seen through the unknown fields that hold them: finding the
+    # extensions of a message, reading their values out of unknown fields
+    # and writing values back into unknown fields.
+    # @api private
+    class Extensions
+      F = Message::FieldInfo
+
+      # @param registry [Types::Registry]
+      # @param pool [Schema::Pool, nil]
+      def initialize(registry, pool)
+        @registry = registry
+        @pool = pool
+        @by_extendee = {}
+        @infos = {}
+      end
+
+      # @param descriptor [Schema::Message]
+      # @return [Hash{Integer => Schema::Field}] extensions of the message by number
+      def of(descriptor)
+        @by_extendee[descriptor] ||= begin
+          fields = if @pool
+            @pool.extensions_of(descriptor.full_name)
+          else
+            files(descriptor.file).flat_map(&:all_extensions).select { |e| e.extendee.equal?(descriptor) }
+          end
+          fields.to_h { |f| [f.number, f] }
+        end
+      end
+
+      # @param descriptor [Schema::Message]
+      # @param name [String] the extension's full name
+      # @return [Schema::Field, nil]
+      def named(descriptor, name)
+        of(descriptor).each_value.find { |f| f.full_name == name }
+      end
+
+      # @param field [Schema::Field] an extension
+      # @return [Message::FieldInfo, nil] nil when its message or enum type has no class
+      def info(field)
+        return @infos[field] if @infos.key?(field)
+        @infos[field] = begin
+          Message::FieldInfo.new(field, nil, method(:resolve))
+        rescue KeyError
+          nil
+        end
+      end
+
+      # The values an extension holds in a message's unknown fields
+      # @param info [Message::FieldInfo]
+      # @param unknown [Array<UnknownField>] those with the extension's number
+      # @return [Array] values as the field's reader would give them, or nil
+      #   when the bytes do not read as the extension's type
+      def read(info, unknown)
+        values = []
+        unknown.each do |u|
+          if u.wire_type == Wire::LENGTH_DELIMITED && info.packable && !info.message? && info.kind != F::STRING && info.kind != F::BYTES
+            r = Wire::Reader.new(u.value)
+            values << scalar(info, r) until r.eof?
+          elsif u.wire_type != info.wire_type
+            return nil
+          elsif info.message?
+            values << info.message_class.decode(u.value)
+          else
+            values << scalar(info, Wire::Reader.new(u.bytes))
+          end
+        end
+        values
+      rescue DecodeError
+        nil
+      end
+
+      # @param info [Message::FieldInfo]
+      # @param values [Array]
+      # @return [Array<UnknownField>] the fields the binary codec would have kept
+      def write(info, values)
+        if info.packed && !values.empty?
+          w = Wire::Writer.new
+          Codec::Encoder.packed(info, values, w)
+          payload = w.string
+          return [UnknownField.new(info.number, Wire::LENGTH_DELIMITED, Wire.varint(payload.bytesize) + payload)]
+        end
+        values.map do |v|
+          w = Wire::Writer.new
+          sizes = {}.compare_by_identity
+          Codec::Sizer.value(info, v, sizes)
+          Codec::Encoder.value(info, v, w, sizes)
+          UnknownField.new(info.number, info.wire_type, w.string)
+        end
+      end
+
+      private
+
+      def scalar(info, r)
+        v = Codec::Decoder.scalar(r, info)
+        (info.kind == F::ENUM) ? (info.enum_names[v] || v) : v
+      end
+
+      def resolve(descriptor)
+        Types.find(descriptor.full_name, registry: @registry || Types.registry) || raise(KeyError, descriptor.full_name)
+      end
+
+      # The file and everything it imports, transitively
+      def files(file, seen = {})
+        return [] if seen[file]
+        seen[file] = true
+        [file] + file.dependency_files.flat_map { |d| files(d, seen) }
+      end
+    end
+  end
+end