protostar 0.1.0.beta1

data/lib/protostar/schema/default_value.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Schema
+    # Parses `FieldDescriptorProto.default_value` text into Ruby values
+    # @api private
+    module DefaultValue
+      INTEGER_TYPES = %i[int32 int64 uint32 uint64 sint32 sint64 fixed32 fixed64 sfixed32 sfixed64].freeze
+      SIMPLE_ESCAPES = {
+        "a" => 7, "b" => 8, "f" => 12, "n" => 10, "r" => 13, "t" => 9, "v" => 11,
+        "\\" => 92, "'" => 39, "\"" => 34, "?" => 63
+      }.freeze
+
+      # protoc's SimpleDtoa: the shortest of %.15g and %.17g that reads back exactly
+      # @param value [Float]
+      # @return [String]
+      def self.simple_dtoa(value)
+        return "inf" if value == Float::INFINITY
+        return "-inf" if value == -Float::INFINITY
+        return "nan" if value.nan?
+        text = format("%.15g", value)
+        # the 15-digit form is kept only when it reads back as the very same double
+        text = format("%.17g", value) unless [Float(text)].pack("G") == [value].pack("G")
+        text
+      end
+
+      # @param text [String] as protoc writes it
+      # @param type [Symbol] the field's short type
+      # @param enum [Enum, nil] the field's enum type
+      # @return [Object]
+      def self.parse(text, type, enum)
+        case type
+        when *INTEGER_TYPES then parse_integer(text)
+        when :double then parse_float(text)
+        when :float then to_float32(parse_float(text))
+        when :bool
+          case text
+          when "true" then true
+          when "false" then false
+          else raise Error, "invalid bool default #{text.inspect}"
+          end
+        when :string then text
+        when :bytes then unescape_bytes(text)
+        when :enum
+          raise Error, "enum default #{text.inspect} is not a value of #{enum.full_name}" unless enum.value(text)
+          text.to_sym
+        else
+          raise Error, "a #{type} field cannot have a default value"
+        end
+      end
+
+      def self.parse_integer(text)
+        if text.match?(/\A-?0[xX]\h+\z/)
+          Integer(text, 16)
+        else
+          Integer(text, 10)
+        end
+      rescue ArgumentError
+        raise Error, "invalid integer default #{text.inspect}"
+      end
+
+      def self.parse_float(text)
+        case text
+        when "inf", "infinity" then Float::INFINITY
+        when "-inf", "-infinity" then -Float::INFINITY
+        when "nan", "-nan" then Float::NAN
+        else Float(text)
+        end
+      rescue ArgumentError
+        raise Error, "invalid floating point default #{text.inspect}"
+      end
+
+      # The value a float field actually holds: the nearest single-precision value
+      def self.to_float32(value)
+        return value if value.nan? || value.infinite?
+        [value].pack("e").unpack1("e")
+      end
+
+      # Undoes protoc's CEscape: simple escapes, 1-3 digit octal, \x hex
+      def self.unescape_bytes(text)
+        text = text.b
+        out = "".b
+        i = 0
+        n = text.bytesize
+        while i < n
+          byte = text.getbyte(i)
+          if byte != 92 || i + 1 >= n # backslash
+            out << byte
+            i += 1
+            next
+          end
+          c = text.byteslice(i + 1, 1)
+          if (simple = SIMPLE_ESCAPES[c])
+            out << simple
+            i += 2
+          elsif c.match?(/[0-7]/)
+            digits = text.byteslice(i + 1, 3)[/\A[0-7]{1,3}/]
+            out << (digits.to_i(8) & 0xFF)
+            i += 1 + digits.bytesize
+          elsif c == "x" || c == "X"
+            digits = text.byteslice(i + 2, 2).to_s[/\A\h{1,2}/]
+            raise Error, "invalid \\x escape in bytes default #{text.inspect}" unless digits
+            out << digits.to_i(16)
+            i += 2 + digits.bytesize
+          else
+            raise Error, "invalid escape \\#{c} in bytes default #{text.inspect}"
+          end
+        end
+        out
+      end
+    end
+  end
+end

data/lib/protostar/schema/descriptor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Schema
+    # What every descriptor has. Made by a {Draft}, frozen and shareable once it is finished.
+    class Descriptor
+      # @return [String] the simple name
+      attr_reader :name
+      # @return [String] the fully qualified name, without a leading dot
+      attr_reader :full_name
+      # @return [Integer] position among its siblings, in declaration order
+      attr_reader :index
+      # @return [Features] resolved features
+      attr_reader :features
+
+      # @return [Options] declared options; once resolved, also the resolved {Options#features}
+      def options
+        @options || Options::UNRESOLVED.fetch(self.class)
+      end
+
+      # Sets attributes that only become known while linking. Drafts are the
+      # callers; everything is frozen once the draft is finished.
+      # @api private
+      def __link(**attrs)
+        attrs.each { |key, value| instance_variable_set(:"@#{key}", value) }
+        self
+      end
+
+      def inspect
+        "#<#{self.class.name} #{full_name}>"
+      end
+      alias_method :to_s, :inspect
+
+      # `to_proto` as a Hash, for reading; nothing builds from it
+      # @return [Hash]
+      def to_h
+        to_proto.to_h
+      end
+    end
+  end
+end

data/lib/protostar/schema/draft/copy.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Schema
+    module Draft
+      # A copy of a built file for another pool, its imports taken from that
+      # pool, with each descriptor's options replaced by what the block
+      # returns (a MessageValue, or nil for none)
+      # @param file [Schema::File]
+      # @param pool [Pool] holds the copy's imports
+      # @param source_info [SourceInfo, nil]
+      # @yieldparam descriptor [Descriptor]
+      # @return [Schema::File] frozen; not added to the pool
+      def self.copy(file, pool:, source_info: file.source_info, &options)
+        Copy.new(file, options).call(pool, source_info)
+      end
+
+      # @api private
+      class Copy
+        def initialize(file, options)
+          @file = file
+          @options = options
+        end
+
+        def call(pool, source_info)
+          file = @file
+          syntax = file.proto_syntax&.to_sym
+          draft = Schema::File.draft(file.name, package: file.package, syntax: syntax, edition: file.edition,
+            dependencies: file.dependencies, public_dependencies: file.public_dependencies,
+            weak_dependencies: file.weak_dependencies, option_dependencies: file.option_dependencies,
+            options: options(file))
+          draft.source_info = source_info if source_info
+          file.messages.each { |m| message(draft, m) }
+          file.enums.each { |e| enum(draft, e) }
+          file.extensions.each { |f| field(draft, f, nil) }
+          file.services.each do |service|
+            draft.service(service.name, options: options(service)) do |s|
+              service.rpcs.each do |m|
+                s.rpc(m.name, ".#{m.input_type.full_name}", ".#{m.output_type.full_name}",
+                  client_streaming: m.client_streaming?, server_streaming: m.server_streaming?, options: options(m))
+              end
+            end
+          end
+          draft.resolve(pool).freeze!
+        end
+
+        private
+
+        def options(descriptor)
+          @options.call(descriptor)
+        end
+
+        def message(scope, message)
+          scope.message(message.name, visibility: message.visibility, options: options(message)) do |m|
+            oneofs = message.oneofs.map { |o| m.oneof(o.name, options: options(o)) }
+            message.fields.each { |f| field(m, f, f.oneof && oneofs[f.oneof.index]) }
+            message.nested_messages.each { |n| message(m, n) }
+            message.nested_enums.each { |e| enum(m, e) }
+            message.extensions.each { |f| field(m, f, nil) }
+            message.extension_range_descriptors.each { |r| m.extension_range(r.range, options: options(r)) }
+            message.reserved_ranges.each { |r| m.reserved(r) }
+            m.reserved(*message.reserved_names)
+          end
+        end
+
+        def field(scope, field, oneof)
+          type_name = field.type_name && ".#{field.type_name}"
+          kwargs = {label: field.declared_label, default: field.raw_default, json_name: field.json_name,
+                    optional: field.proto3_optional?, options: options(field)}
+          if field.extension?
+            scope.extension(field.name, field.number, field.declared_type, type_name,
+              extendee: ".#{field.extendee.full_name}", **kwargs)
+          else
+            scope.field(field.name, field.number, field.declared_type, type_name, oneof: oneof, **kwargs)
+          end
+        end
+
+        def enum(scope, enum)
+          scope.enum(enum.name, visibility: enum.visibility, options: options(enum)) do |e|
+            enum.values.each { |v| e.value(v.name, v.number, options: options(v)) }
+            enum.reserved_ranges.each { |r| e.reserved(r) }
+            e.reserved(*enum.reserved_names)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/schema/draft/resolution.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Schema
+    module Draft
+      # Options, features and defaults of a linked file, as protoc's
+      # DescriptorBuilder resolves them once options are known
+      # @api private
+      class Resolution
+        OPTIONS = {
+          Schema::File => FileOptions, Schema::Message => MessageOptions, Field => FieldOptions,
+          Schema::Oneof => OneofOptions, Schema::Enum => EnumOptions, EnumValue => EnumValueOptions,
+          Schema::Service => ServiceOptions, Schema::Method => MethodOptions,
+          ExtensionRange => ExtensionRangeOptions
+        }.freeze
+
+        def initialize(file, fields, specs, pool)
+          @file = file
+          @fields = fields
+          @specs = specs
+          @pool = pool
+          @features = {}
+          @empty = {}
+        end
+
+        def call
+          finder = extension_finder
+          @declared = {}.compare_by_identity
+          @specs.each do |descriptor, spec|
+            options = OPTIONS.fetch(descriptor.class).build(spec, finder, descriptor.full_name)
+            @declared[descriptor] = options if options
+          end
+          resolve_features
+          parse_defaults
+        end
+
+        private
+
+        # Custom options are extensions of this file, its imports and theirs,
+        # or else of whatever the pool holds (`import option` files)
+        def extension_finder
+          files = []
+          seen = {}
+          queue = [@file]
+          until queue.empty?
+            f = queue.shift
+            next if seen[f.name]
+            seen[f.name] = true
+            files << f
+            queue.concat(f.dependency_files)
+          end
+          lambda do |name|
+            files.each do |f|
+              found = f.find_extension(name)
+              return found if found
+            end
+            found = @pool&.find_symbol(name)
+            found if found.is_a?(Field) && found.extension?
+          end
+        end
+
+        def declared(descriptor)
+          @declared[descriptor]
+        end
+
+        # Options of this file's messages are bound in tree order, so a
+        # message type elsewhere in the file may not be bound yet
+        def map_entry?(message)
+          return message.map_entry? unless message.file.equal?(@file)
+          declared(message)&.[](:map_entry) == true
+        end
+
+        def bind(descriptor, features)
+          options = @declared[descriptor]
+          bound = if options
+            options.with_features(features)
+          else
+            klass = OPTIONS.fetch(descriptor.class)
+            (@empty[klass] ||= {})[features] ||= klass.new(features: features)
+          end
+          descriptor.__link(features: features, options: bound)
+        end
+
+        def resolve_features
+          file_features = intern(Features.defaults(@file.edition_number).merge(declared(@file)&.[](:features)))
+          bind(@file, file_features)
+          @file.messages.each { |m| resolve_message_features(m, file_features) }
+          @file.enums.each { |e| resolve_enum_features(e, file_features) }
+          @file.extensions.each { |f| resolve_field_features(f, file_features) }
+          @file.services.each do |service|
+            service_features = inherit(file_features, service)
+            service.rpcs.each { |m| inherit(service_features, m) }
+          end
+        end
+
+        def resolve_message_features(message, parent)
+          features = inherit(parent, message)
+          message.oneofs.each { |o| inherit(features, o) }
+          message.fields.each { |f| resolve_field_features(f, f.oneof ? f.oneof.features : features) }
+          message.extension_range_descriptors.each { |r| inherit(features, r) }
+          message.nested_messages.each { |m| resolve_message_features(m, features) }
+          message.nested_enums.each { |e| resolve_enum_features(e, features) }
+          message.extensions.each { |f| resolve_field_features(f, features) }
+        end
+
+        def resolve_enum_features(enum, parent)
+          features = inherit(parent, enum)
+          enum.values.each { |v| inherit(features, v) }
+        end
+
+        # protoc's InferLegacyProtoFeatures for proto2 and proto3 files, then the
+        # label and type adjustments of DescriptorBuilder::PostProcessFieldFeatures
+        def resolve_field_features(field, parent)
+          options = declared(field)
+          features = parent.merge(options&.[](:features))
+          if @file.syntax != :editions
+            legacy = nil
+            legacy = {field_presence: :LEGACY_REQUIRED} if field.declared_label == :required
+            (legacy ||= {})[:message_encoding] = :DELIMITED if field.declared_type == :group
+            if options&.key?(:packed)
+              (legacy ||= {})[:repeated_field_encoding] = options[:packed] ? :PACKED : :EXPANDED
+            end
+            (legacy ||= {})[:field_presence] = :EXPLICIT if field.proto3_optional?
+            features = features.with(**legacy) if legacy
+          end
+          features = intern(features)
+          label = field.declared_label
+          label = :required if label == :optional && features.field_presence == :LEGACY_REQUIRED
+          type = field.declared_type
+          if type == :message && features.message_encoding == :DELIMITED
+            holder = field.extension? ? field.extendee : field.containing_message
+            type = :group unless map_entry?(holder) || map_entry?(field.message_type)
+          end
+          bind(field, features)
+          field.__link(label: label, type: type)
+        end
+
+        def inherit(parent, descriptor)
+          features = intern(parent.merge(declared(descriptor)&.[](:features)))
+          bind(descriptor, features)
+          features
+        end
+
+        def intern(features)
+          @features[features] ||= features
+        end
+
+        def parse_defaults
+          @fields.each do |field, _scope|
+            value = nil
+            if (text = field.raw_default)
+              begin
+                value = DefaultValue.parse(text, field.type, field.enum_type)
+              rescue Error => e
+                raise Error, "#{@file.name}: #{field.full_name}: #{e.message}"
+              end
+            end
+            implicit = if !value.nil?
+              value
+            elsif field.type == :enum
+              field.enum_type.values.first&.name&.to_sym
+            else
+              Field::ZERO[field.type]
+            end
+            field.__link(default_value: value, default: implicit)
+          end
+        end
+      end
+    end
+
+    class Options
+      # What a descriptor answers before its options are resolved: an empty
+      # instance of its options class
+      UNRESOLVED = Draft::Resolution::OPTIONS.transform_values { |klass| klass.new.freeze }.freeze
+    end
+  end
+end