protostar 0.1.0.beta1

data/shims/google-protobuf/lib/google/protobuf/internal/convert.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Google
+  module Protobuf
+    module Internal
+      # Checks and converts Ruby values on their way into a field, a
+      # RepeatedField or a Map, with google-protobuf's rules and error
+      # messages, into what protostar stores: Integers, Floats (single
+      # precision for float), true/false, frozen Strings, enum Symbols (or
+      # Integers for numbers without a name) and message instances.
+      # @api private
+      module Convert
+        INTEGER_TYPES = {
+          int32: [32, false], sint32: [32, false], sfixed32: [32, false],
+          int64: [64, false], sint64: [64, false], sfixed64: [64, false],
+          uint32: [32, true], fixed32: [32, true],
+          uint64: [64, true], fixed64: [64, true]
+        }.freeze
+
+        FIXNUM = -(2**62)...(2**62)
+        LONG = -(2**63)...(2**63)
+
+        UTF_8 = Encoding::UTF_8
+        BINARY = Encoding::BINARY
+        TIMESTAMP = "google.protobuf.Timestamp"
+        DURATION = "google.protobuf.Duration"
+
+        module_function
+
+        # @param value [Object]
+        # @param type [Symbol] the field type as FieldDescriptor#type gives it
+        # @param sub [Descriptor, EnumDescriptor, nil] for message and enum types
+        # @param name [String] the field name, for error messages
+        # @return [Object] what protostar stores
+        def to_store(value, type, sub, name)
+          case type
+          when :double
+            raise TypeError, "Expected number type for double field '#{name}' (given #{value.class})." unless number?(value)
+            value.to_f
+          when :float
+            raise TypeError, "Expected number type for float field '#{name}' (given #{value.class})." unless number?(value)
+            Protostar::Message::Coercion.float32(value.to_f)
+          when :bool
+            return value if value == true || value == false
+            raise TypeError, "Invalid argument for boolean field '#{name}' (given #{value.class})."
+          when :string then string(value, name)
+          when :bytes then bytes(value, name)
+          when :enum then enum(value, sub, name)
+          when :message, :group then message(value, sub, name)
+          else integer(value, type, name)
+          end
+        end
+
+        def number?(value)
+          value.is_a?(Integer) || value.is_a?(Float)
+        end
+
+        def string(value, name)
+          if value.is_a?(Symbol)
+            value = value.to_s
+          elsif !value.is_a?(String)
+            raise TypeError, "Invalid argument for string field '#{name}' (given #{value.class})."
+          end
+          if value.encoding != UTF_8
+            value = value.encode(UTF_8)
+          elsif !value.valid_encoding?
+            raise Encoding::InvalidByteSequenceError, "String is invalid UTF-8"
+          end
+          value.frozen? ? value : value.dup.freeze
+        end
+
+        def bytes(value, name)
+          raise TypeError, "Invalid argument for bytes field '#{name}' (given #{value.class})." unless value.instance_of?(String)
+          value = value.encode(BINARY) if value.encoding != BINARY
+          value.frozen? ? value : value.dup.freeze
+        end
+
+        def integer(value, type, name)
+          given = value
+          if value.is_a?(Float)
+            if value.nan? || (value.finite? && value.floor != value)
+              raise RangeError, "Non-integral floating point value assigned to integer field '#{name}' (given Float)."
+            end
+            raise RangeError, out_of_range(given, type) if value.infinite?
+            value = value.to_i
+          elsif !value.is_a?(Integer)
+            raise TypeError, "Expected number type for integral field '#{name}' (given #{value.class})."
+          end
+          bits, unsigned = INTEGER_TYPES.fetch(type)
+          if unsigned
+            raise RangeError, "Assigning negative value to unsigned integer field '#{name}' (given #{given.class})." if value < 0
+            return value if value.bit_length <= bits
+          elsif value.bit_length < bits
+            return value
+          end
+          raise RangeError, out_of_range(given, type)
+        end
+
+        # The message Ruby's NUM2INT and friends give, which the gem lets through
+        def out_of_range(given, type)
+          bits, unsigned = INTEGER_TYPES.fetch(type)
+          if given.is_a?(Float)
+            if bits == 64 || !LONG.cover?(given)
+              target = if bits == 32 then "integer"
+              else
+                unsigned ? "unsigned long long" : "long long"
+              end
+              text = if given.infinite? then (given > 0) ? "Inf" : "-Inf"
+              else format("%-.10g", given)
+              end
+              return "float #{text} out of range of #{target}"
+            end
+            given = given.to_i
+          end
+          if bits == 32 && FIXNUM.cover?(given)
+            "integer #{given} too #{(given < 0) ? "small" : "big"} to convert to '#{unsigned ? "unsigned int" : "int"}'"
+          elsif bits == 32
+            "bignum too big to convert into '#{unsigned ? "unsigned long" : "long"}'"
+          else
+            "bignum too big to convert into '#{unsigned ? "unsigned long long" : "long long"}'"
+          end
+        end
+
+        def enum(value, sub, name)
+          case value
+          when Integer, Float
+            number = integer(value, :int32, name)
+            sub.__names[number] || number
+          when String, Symbol
+            number = sub.__numbers[value.to_sym]
+            raise RangeError, "Unknown symbol value for enum field '#{name}'." unless number
+            sub.__names.fetch(number)
+          else
+            raise TypeError, "Expected number or symbol type for enum field '#{name}'."
+          end
+        end
+
+        def message(value, sub, name)
+          klass = sub.msgclass
+          return value if value.instance_of?(klass)
+          raise TypeError, "nil message not allowed here." if value.nil?
+          case sub.name
+          when TIMESTAMP
+            return klass.new(seconds: value.to_i, nanos: value.nsec) if value.is_a?(::Time)
+          when DURATION
+            if value.is_a?(Numeric)
+              seconds = value.to_i
+              return klass.new(seconds: seconds, nanos: ((value.to_f - seconds) * 1_000_000_000).round)
+            end
+          end
+          raise TypeError, "Invalid type #{value.class} to assign to submessage field '#{name}'."
+        end
+
+        # A field's value from a Hash given to `new`: Hashes become messages, here and nested
+        # @return [Object] what protostar stores
+        def initial(value, type, sub, name)
+          if (type == :message || type == :group) && value.is_a?(Hash)
+            sub.msgclass.new(value)
+          else
+            to_store(value, type, sub, name)
+          end
+        end
+
+        # A stored value as the gem hands it out: enum values keep their Symbol
+        # or Integer, everything else is what is stored
+        def zero(type, sub)
+          case type
+          when :double, :float then 0.0
+          when :bool then false
+          when :string then ""
+          when :bytes then "".b.freeze
+          when :enum then sub.__names[0] || 0
+          when :message, :group then nil
+          else 0
+          end
+        end
+      end
+    end
+  end
+end

data/shims/google-protobuf/lib/google/protobuf/internal/extensions.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Google
+  module Protobuf
+    module Internal
+      # Extension values live in a message's unknown fields, as protostar
+      # keeps them; these read them out and write them back by the
+      # extension's FieldDescriptor.
+      # @api private
+      module Extensions
+        ITEM = 1 # MessageSet item group
+        TYPE_ID = 2
+        MESSAGE = 3
+
+        module_function
+
+        # @return [Array] the extension's values on the message, as stored
+        def read(msg, fd)
+          info = info(fd)
+          if message_set?(msg)
+            items(msg).filter_map { |type_id, bytes| info.message_class.decode(bytes) if type_id == fd.number }
+          else
+            found = msg.unknown_fields.select { |u| u.number == fd.number }
+            codec(fd).read(info, found) || []
+          end
+        end
+
+        # Replaces the extension's values on the message
+        def write(msg, fd, values)
+          info = info(fd)
+          kept = msg.unknown_fields.reject { |u| holds?(msg, u, fd) }
+          added = if message_set?(msg)
+            values.map { |v| item(fd.number, v.encode) }
+          else
+            codec(fd).write(info, values)
+          end
+          msg.__greplace_unknown(kept + added)
+        end
+
+        def holds?(msg, unknown, fd)
+          if message_set?(msg)
+            unknown.number == ITEM && unknown.wire_type == Protostar::Wire::START_GROUP &&
+              item_type_id(unknown.bytes) == fd.number
+          else
+            unknown.number == fd.number
+          end
+        end
+
+        def message_set?(msg)
+          msg.class.descriptor.__schema.message_set_wire_format?
+        end
+
+        def info(fd)
+          codec(fd).info(fd.__schema) || raise(TypeError, "extension #{fd.name} has no class for its type")
+        end
+
+        def codec(fd)
+          fd.descriptor_pool.__extension_codec
+        end
+
+        # @return [Array<Array(Integer, String)>] each MessageSet item's type id and message bytes
+        def items(msg)
+          msg.unknown_fields.filter_map do |u|
+            next unless u.number == ITEM && u.wire_type == Protostar::Wire::START_GROUP
+            type_id = message = nil
+            r = Protostar::Wire::Reader.new(u.bytes)
+            until r.eof?
+              number, wire_type = r.read_tag
+              break if wire_type == Protostar::Wire::END_GROUP
+              if number == TYPE_ID && wire_type == Protostar::Wire::VARINT
+                type_id = r.read_varint
+              elsif number == MESSAGE && wire_type == Protostar::Wire::LENGTH_DELIMITED
+                message = r.read_bytes
+              else
+                r.skip_field(number, wire_type)
+              end
+            end
+            [type_id, message] if type_id && message
+          end
+        end
+
+        def item_type_id(bytes)
+          r = Protostar::Wire::Reader.new(bytes)
+          until r.eof?
+            number, wire_type = r.read_tag
+            return nil if wire_type == Protostar::Wire::END_GROUP
+            return r.read_varint if number == TYPE_ID && wire_type == Protostar::Wire::VARINT
+            r.skip_field(number, wire_type)
+          end
+          nil
+        end
+
+        def item(type_id, bytes)
+          w = Protostar::Wire::Writer.new
+          w.write_tag(TYPE_ID, Protostar::Wire::VARINT)
+          w.write_varint(type_id)
+          w.write_tag(MESSAGE, Protostar::Wire::LENGTH_DELIMITED)
+          w.write_bytes(bytes)
+          w.write_tag(ITEM, Protostar::Wire::END_GROUP)
+          Protostar::UnknownField.new(ITEM, Protostar::Wire::START_GROUP, w.string.b.freeze)
+        end
+      end
+
+      module MessageMethods
+        # @api private
+        def __greplace_unknown(fields)
+          @unknown = fields.empty? ? nil : fields.freeze
+        end
+
+        private
+
+        def __gext_get(fd)
+          values = Extensions.read(self, fd)
+          if fd.repeated?
+            RepeatedField.__for_field(fd, values)
+          elsif values.empty?
+            fd.default
+          else
+            values.last
+          end
+        end
+
+        def __gext_has?(fd)
+          !Extensions.read(self, fd).empty?
+        end
+
+        def __gext_set(fd, value)
+          values = if fd.repeated?
+            raise TypeError, "Expected repeated field array" unless value.is_a?(RepeatedField)
+            value.to_a
+          elsif value.nil?
+            []
+          else
+            [Convert.to_store(value, fd.type, fd.subtype, fd.name)]
+          end
+          Extensions.write(self, fd, values)
+          value
+        end
+
+        def __gext_clear(fd)
+          Extensions.write(self, fd, [])
+          nil
+        end
+      end
+    end
+
+    class DescriptorPool
+      # @api private
+      def __extension_codec
+        @extension_codec ||= Protostar::Text::Extensions.new(@registry, @schema_pool)
+      end
+    end
+  end
+end

data/shims/google-protobuf/lib/google/protobuf/internal/json.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Google
+  module Protobuf
+    module Internal
+      # JSON through protostar's encoder and parser, with the gem's options,
+      # errors, and extensions of the top-level message written as
+      # `"[full.name]": value`.
+      # @api private
+      module Json
+        INT64 = %i[int64 sint64 sfixed64 uint64 fixed64].to_h { |t| [t, true] }.freeze
+
+        module_function
+
+        def encode(message, options)
+          json = Protostar::JSON.encode(
+            message,
+            preserve_proto_field_names: options[:preserve_proto_fieldnames] ? true : false,
+            emit_defaults: options[:emit_defaults] ? true : false,
+            format_enums_as_integers: options[:format_enums_as_integers] ? true : false,
+            registry: message.class.__gpool.__registry
+          )
+          json = with_extensions(message, json, options) unless message.unknown_fields.empty?
+          json.force_encoding(Encoding::UTF_8)
+        rescue Protostar::JSON::Error, Protostar::Error => e
+          raise ParseError, "Error occurred during encoding: #{e.message}"
+        end
+
+        def decode(klass, json, options)
+          extensions = nil
+          if json.include?("\"[")
+            tree = ::JSON.parse(json)
+            if tree.is_a?(Hash)
+              extensions, rest = tree.partition { |k, _| k.start_with?("[") && k.end_with?("]") }
+              json = ::JSON.generate(rest.to_h) unless extensions.empty?
+            end
+          end
+          message = Protostar::JSON.decode(
+            klass, json,
+            ignore_unknown_fields: options[:ignore_unknown_fields] ? true : false,
+            registry: klass.__gpool.__registry
+          )
+          extensions&.each { |key, value| set_extension(klass, message, key[1..-2], value, options) }
+          message
+        rescue Protostar::JSON::Error, Protostar::Error, ::JSON::ParserError => e
+          # upb's wording, which callers match on
+          reason = e.message.sub(/\A\S+ has no field "(.*)"\z/) { "No such field: #{$1}" }
+          raise ParseError, "Error occurred during parsing: #{reason}"
+        end
+
+        def set_extension(klass, message, name, value, options)
+          fd = klass.__gpool.lookup(name)
+          unless fd.is_a?(FieldDescriptor) && fd.__owner.equal?(klass.descriptor)
+            return if options[:ignore_unknown_fields]
+            raise ParseError, "Error occurred during parsing: No such field: [#{name}]"
+          end
+          if fd.repeated?
+            list = RepeatedField.__for_field(fd, [])
+            value.each { |v| list << from_json(fd, v) }
+            fd.set(message, list)
+          else
+            fd.set(message, from_json(fd, value))
+          end
+        end
+
+        def from_json(fd, value)
+          case fd.type
+          when :message, :group then fd.subtype.msgclass.decode_json(::JSON.generate(value))
+          when :bytes then value.tr("-_", "+/").unpack1("m")
+          when :float, :double then value.is_a?(String) ? Float(value) : value
+          when :enum, :string, :bool then value
+          else value.is_a?(String) ? Integer(value, 10) : value
+          end
+        end
+
+        def to_json(fd, value, options)
+          case fd.type
+          when :message, :group then fd.subtype.msgclass.encode_json(value, options)
+          when :bytes then ::JSON.generate([value].pack("m0"))
+          when :enum
+            options[:format_enums_as_integers] ? fd.subtype.__numbers.fetch(value, value).to_s : ::JSON.generate(value.to_s)
+          else
+            INT64.key?(fd.type) ? ::JSON.generate(value.to_s) : ::JSON.generate(value)
+          end
+        end
+
+        def with_extensions(message, json, options)
+          pool = message.class.__gpool
+          parts = pool.__schema_pool.extensions_of(message.class.descriptor.__schema).filter_map do |ext|
+            fd = pool.__wrap(ext)
+            values = Extensions.read(message, fd)
+            next if values.empty?
+            value = fd.repeated? ? "[#{values.map { |v| to_json(fd, v, options) }.join(",")}]" : to_json(fd, values.last, options)
+            "#{::JSON.generate("[#{ext.full_name}]")}:#{value}"
+          end
+          return json if parts.empty?
+          (json == "{}") ? "{#{parts.join(",")}}" : "#{json[0..-2]},#{parts.join(",")}}"
+        end
+      end
+    end
+  end
+end

data/shims/google-protobuf/lib/google/protobuf/internal/well_known.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Google
+  module Protobuf
+    module Internal
+      # The Ruby helpers of google.protobuf.Struct, Value and ListValue as
+      # the gem's well_known_types.rb defines them. {MessageClass.setup}
+      # includes them after {MessageMethods}, so their `[]`, `[]=` and `to_h`
+      # win over the message methods of the same names, whether or not
+      # well_known_types is required.
+      # @api private
+      module WellKnown
+        module Value
+          module ClassMethods
+            # @return [Value] a new Value holding the Ruby value
+            def from_ruby(value)
+              new.from_ruby(value)
+            end
+          end
+
+          # @param recursive [Boolean] convert a Struct or ListValue to a Hash or Array as well
+          # @return [Object]
+          # @raise [UnexpectedStructType] when no kind is set
+          def to_ruby(recursive = false)
+            case kind
+            when :struct_value then recursive ? struct_value.to_h : struct_value
+            when :list_value then recursive ? list_value.to_a : list_value
+            when :null_value then nil
+            when :number_value then number_value
+            when :string_value then string_value
+            when :bool_value then bool_value
+            else raise UnexpectedStructType
+            end
+          end
+
+          # Sets the kind matching a Ruby value
+          # @return [self]
+          # @raise [UnexpectedStructType]
+          def from_ruby(value)
+            by_name = self.class.__by_name
+            struct = by_name.fetch("struct_value").message_class
+            list = by_name.fetch("list_value").message_class
+            case value
+            when NilClass then self.null_value = :NULL_VALUE
+            when Numeric then self.number_value = value
+            when String then self.string_value = value
+            when TrueClass then self.bool_value = true
+            when FalseClass then self.bool_value = false
+            when struct then self.struct_value = value
+            when Hash then self.struct_value = struct.from_hash(value)
+            when list then self.list_value = value
+            when Array then self.list_value = list.from_a(value)
+            else raise UnexpectedStructType
+            end
+            self
+          end
+        end
+
+        module Struct
+          module ClassMethods
+            # @return [Struct]
+            def from_hash(hash)
+              struct = new
+              hash.each { |key, value| struct[key] = value }
+              struct
+            end
+          end
+
+          # @return [Object, nil] the value as Ruby; nil for a missing key
+          def [](key)
+            fields[key].to_ruby
+          rescue NoMethodError
+            nil
+          end
+
+          # @raise [UnexpectedStructType] for a key that is not a String or a value Struct cannot hold
+          def []=(key, value)
+            raise UnexpectedStructType, "Struct keys must be strings." unless key.is_a?(String)
+            fields[key] ||= self.class.__by_name.fetch("fields").value.message_class.new
+            fields[key].from_ruby(value)
+          end
+
+          # @return [Hash] with nested Structs and ListValues converted too
+          def to_h
+            fields.each_with_object({}) { |(key, value), h| h[key] = value.to_ruby(true) }
+          end
+
+          def has_key?(key)
+            fields.has_key?(key)
+          end
+        end
+
+        module ListValue
+          include Enumerable
+
+          module ClassMethods
+            # @return [ListValue]
+            def from_a(array)
+              list = new
+              array.each { |v| list << v }
+              list
+            end
+          end
+
+          def length
+            values.length
+          end
+
+          def [](index)
+            values[index].to_ruby
+          end
+
+          def []=(index, value)
+            values[index].from_ruby(value)
+          end
+
+          def <<(value)
+            values << self.class.__by_name.fetch("values").message_class.new.from_ruby(value)
+          end
+
+          def each
+            values.each { |v| yield v.to_ruby }
+          end
+
+          # @return [Array] with nested Structs and ListValues converted too
+          def to_a
+            values.map { |v| v.to_ruby(true) }
+          end
+        end
+
+        # Full name to the module {MessageClass.setup} mixes in
+        MIXINS = {
+          "google.protobuf.Struct" => Struct,
+          "google.protobuf.Value" => Value,
+          "google.protobuf.ListValue" => ListValue
+        }.freeze
+      end
+    end
+  end
+end