bare-rb 0.1.5 → 0.2.3

data/lib/types.rb

@@ -7,6 +7,128 @@ class BareTypes
       @finalized = false
       super
     end
+    def cycle_search(seen)
+    end
+  end
+
+  class Schema
+    attr_accessor :types
+
+    def initialize(types)
+      @types = types.map { |k, v| [k.to_sym, v] }.to_h
+      @types.each do |k, v|
+        unless k.is_a?(Symbol)
+          raise("Keys to a schema must be symbols")
+        end
+        if v.nil?
+          raise("Schema values cannot be nil")
+        end
+      end
+
+      # Resolve references in schema
+      # type A u8
+      # type B A
+      # type C B
+      # first  loop would find B and make it a reference to A
+      # second loop would find C and make it a reference to B
+      progress = true
+      remaining = @types.keys.to_a
+      while progress
+        progress = false
+        remaining.each do |key|
+          val = @types[key]
+          if val.is_a?(Symbol) && !@types[val].is_a?(Symbol)
+            @types[key.to_sym] = BareTypes::Reference.new(key, @types[val])
+            progress = true
+          else
+          end
+        end
+      end
+
+      @types.each do |key, val|
+        if val.is_a?(Symbol)
+          raise ReferenceException.new("Your types contain an unresolved reference '#{val}'.")
+        end
+      end
+
+      @types.values.each do |val|
+        val.finalize_references(@types)
+      end
+
+      @types.each do |key, val|
+        val.cycle_search(SeenList.new)
+      end
+    end
+
+    def ==(otherSchema)
+      return false unless otherSchema.is_a?(BareTypes::Schema)
+      @types == otherSchema.types
+    end
+
+    def to_s
+      buffer = ""
+      @types.each do |name, type|
+        if type.is_a?(BareTypes::Enum)
+          buffer << "enum #{name} "
+          type.to_schema(buffer)
+          buffer << "\n"
+        else
+          buffer << "type #{name} "
+          type.to_schema(buffer)
+          buffer << "\n"
+        end
+      end
+      buffer
+    end
+
+    def [](key)
+      return @types[key]
+    end
+  end
+
+  # Used to represent a Type reference in a schema.
+  # eg. test8.schema's  address field on Customer contains 'Address'
+  # a reference to the Address type defined earlier.
+  class Reference < BaseType
+    attr_accessor :name
+    attr_accessor :ref
+
+    def cycle_search(seen)
+      seen.add(self)
+      @ref.cycle_search(seen)
+      seen.pop
+    end
+
+    def ==(other)
+      other.is_a?(Reference) && @name == other.name && @ref == other.ref
+    end
+
+    def initialize(name, reference)
+      @name = name
+      @ref = reference
+      @finalized = false
+      unless reference.is_a?(BareTypes::BaseType)
+        raise ReferenceException.new("Reference must be to bare types")
+      end
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      self.ref.finalize_references(schema)
+    end
+
+    def encode(msg, buffer)
+      @ref.encode(msg, buffer)
+    end
+
+    def decode(msg)
+      @ref.decode(msg)
+    end
+
+    def to_schema(buffer)
+      buffer << @name.to_s
+    end
   end
 
   class BarePrimitive < BaseType
@@ -20,29 +142,33 @@ class BareTypes
       self.class == other.class
     end
 
-    def finalize_references(schema)
+    def finalize_references(schema) end
+
+    def to_schema(buffer)
+      buffer << self.class.name.split('::').last.downcase
     end
 
   end
 
+  #region Primitives
   class Int < BarePrimitive
     # https://developers.google.com/protocol-buffers/docs/encoding
     # Easy to just convert to signed and re-use uint code
-    def encode(msg)
+    def encode(msg, buffer)
       mappedInteger = msg < 0 ? -2 * msg - 1 : msg * 2
-      return Uint.new.encode(mappedInteger)
+      Uint.new.encode(mappedInteger, buffer)
     end
 
     def decode(msg)
       value, rest = Uint.new.decode(msg)
       value = value.odd? ? (value + 1) / -2 : value / 2
-      return  value, rest
+      return value, rest
     end
   end
 
   class Void < BarePrimitive
-    def encode(msg)
-      return "".b
+    def encode(msg, buffer)
+      buffer << "".b
     end
 
     def decode(msg)
@@ -51,8 +177,8 @@ class BareTypes
   end
 
   class F32 < BarePrimitive
-    def encode(msg)
-      [msg].pack("e")
+    def encode(msg, buffer)
+      buffer << [msg].pack("e")
     end
 
     def decode(msg)
@@ -61,8 +187,8 @@ class BareTypes
   end
 
   class F64 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("E")
+    def encode(msg, buffer)
+      buffer << [msg].pack("E")
     end
 
     def decode(msg)
@@ -71,16 +197,14 @@ class BareTypes
   end
 
   class String < BarePrimitive
-    def encode(msg)
-      encodedString = nil
+    def encode(msg, buffer)
       begin
         encodedString = msg.encode("UTF-8").b
       rescue Encoding::UndefinedConversionError => error
         raise error.class, "Unable to convert string to UTF-8=, BARE strings are encoded as UTF8. If you can't convert your string to UTF-8 you can encode it with binary data"
       end
-      bytes = Uint.new.encode(encodedString.size)
-      bytes << encodedString
-      return bytes
+      Uint.new.encode(encodedString.size, buffer)
+      buffer << encodedString
     end
 
     def decode(msg)
@@ -90,202 +214,45 @@ class BareTypes
     end
   end
 
-  class Optional < BaseType
-    def ==(otherType)
-      return otherType.class == BareTypes::Optional && otherType.optionalType == @optionalType
-    end
-
-    def finalize_references(schema)
-      return if @finalized
-      @finalized = true
-      if @optionalType.is_a?(Symbol)
-        @optionalType = schema[@optionalType]
-      else
-        @optionalType.finalize_references(schema)
-      end
-    end
-
-    def optionalType
-      @optionalType
-    end
-
-    def initialize(optionalType)
-      raise VoidUsedOutsideTaggedSet() if optionalType.class == BareTypes::Void
-      @optionalType = optionalType
-    end
-
-    def encode(msg)
-      if msg.nil?
-        return "\x00".b
-      else
-        bytes = "\x01".b
-        bytes << @optionalType.encode(msg)
-        return bytes
-      end
-    end
-
-    def decode(msg)
-      if msg.unpack("C")[0] == 0
-        return nil, msg[1..msg.size]
-      else
-        return @optionalType.decode(msg[1..msg.size])
-      end
-    end
-  end
-
-  class Map < BaseType
-    def ==(otherType)
-      return otherType.class == BareTypes::Map && otherType.from == @from && otherType.to == @to
-    end
-
-    def finalize_references(schema)
-      return if @finalized
-      @finalized = true
-      if @from.is_a?(Symbol)
-        @to = schema[@to]
-      else
-        @to.finalize_references(schema)
-      end
-    end
-
-    def initialize(fromType, toType)
-      raise VoidUsedOutsideTaggedSet if fromType.class == BareTypes::Void or toType.class == BareTypes::Void
-      if !fromType.class.ancestors.include?(BarePrimitive) ||
-          fromType.is_a?(BareTypes::Data) ||
-          fromType.is_a?(BareTypes::DataFixedLen)
-        raise MapKeyError("Map keys must use a primitive type which is not data or data<length>.")
-      end
-      @from = fromType
-      @to = toType
-    end
-
-    def from
-      @from
-    end
-
-    def to
-      @to
-    end
-
-    def encode(msg)
-      bytes = Uint.new.encode(msg.size)
-      msg.each do |from, to|
-        bytes << @from.encode(from)
-        bytes << @to.encode(to)
-      end
-      return bytes
-    end
-
-    def decode(msg)
-      hash = Hash.new
-      mapSize, rest = Uint.new.decode(msg)
-      (mapSize - 1).to_i.downto(0) do
-        key, rest = @from.decode(rest)
-        value, rest = @to.decode(rest)
-        hash[key] = value
-      end
-      return hash, rest
-    end
-  end
-
-  class Union < BarePrimitive
-
-    def intToType
-      @intToType
-    end
-
-    def finalize_references(schema)
-      return if @finalized
-      @finalized = true
-      @intToType.keys.each do |key|
-        if @intToType[key].is_a?(Symbol)
-          @intToType[key] = schema[@intToType[key]]
-        else
-          @intToType[key].finalize_references(schema)
-        end
-      end
-    end
-
-    def ==(otherType)
-      return false unless otherType.is_a?(BareTypes::Union)
-      @intToType.each do |int, type|
-        return false unless type == otherType.intToType[int]
-      end
-      return true
-    end
-
-    def initialize(intToType)
-      intToType.keys.each do |i|
-        raise MinimumSizeError("Union's integer representations must be > 0, instead got: #{i}") if i < 0 or !i.is_a?(Integer)
-      end
-      raise MinimumSizeError("Union must have at least one type") if intToType.keys.size < 1
-      @intToType = intToType
-    end
-
-    def encode(msg)
-      type = msg[:type]
-      value = msg[:value]
-      unionTypeInt = nil
-      unionType = nil
-      @intToType.each do |int, typ|
-        if type.class == typ.class
-          unionTypeInt = int
-          unionType = typ
-          break
-        end
-      end
-      raise SchemaMismatch("Unable to find given type in union: #{@intToType.inspect}, type: #{type}") if unionType.nil? || unionTypeInt.nil?
-      bytes = Uint.new.encode(unionTypeInt)
-      encoded = unionType.encode(value)
-      bytes << encoded
-    end
-
-    def decode(msg)
-      int, rest = Uint.new.decode(msg)
-      type = @intToType[int]
-      value, rest = type.decode(rest)
-      return {value: value, type: type}, rest
-    end
-  end
-
   class DataFixedLen < BaseType
     def ==(otherType)
       return otherType.class == BareTypes::DataFixedLen && otherType.length == self.length
     end
 
-    def length
-      return @length
+    def to_schema(buffer)
+      buffer << "data<#{@length}>"
     end
 
-    def finalize_references(schema)
+    def length
+      @length
     end
 
+    def finalize_references(schema) end
+
     def initialize(length)
-      raise MinimumSizeError("DataFixedLen must have a length greater than 0, got: #{length.inspect}") if length < 1
+      raise MinimumSizeError.new("DataFixedLen must have a length greater than 0, got: #{length.inspect}") if length < 1
       @length = length
     end
 
-    def encode(msg)
+    def encode(msg, buffer)
       if msg.size != @length
         raise FixedDataSizeWrong.new("Message is not proper sized for DataFixedLen should have been #{@length} but was #{msg.size}")
       end
-      msg
+      buffer << msg
     end
 
     def decode(msg)
-      return msg[0..@length], msg[@length..msg.size]
+      return msg[0..@length-1], msg[@length..msg.size]
     end
   end
 
   class Data < BarePrimitive
 
-    def finalize_references(schema)
-    end
+    def finalize_references(schema) end
 
-    def encode(msg)
-      bytes = Uint.new.encode(msg.size)
-      bytes << msg
-      return bytes
+    def encode(msg, buffer)
+      Uint.new.encode(msg.size, buffer)
+      buffer << msg
     end
 
     def decode(msg)
@@ -296,10 +263,9 @@ class BareTypes
 
   class Uint < BarePrimitive
 
-    def finalize_references(schema)
-    end
+    def finalize_references(schema) end
 
-    def encode(msg)
+    def encode(msg, buffer)
       bytes = "".b
       _get_next_7_bits_as_byte(msg, 128) do |byte|
         bytes << byte
@@ -312,8 +278,8 @@ class BareTypes
         end
       end
       bytes[bytes.size - 1] = [bytes.bytes[bytes.size - 1] & 127].pack('C')[0]
-      raise MaximumSizeError("Maximum u/int allowed is 64 bit precision") if bytes.size > 9
-      return bytes
+      raise MaximumSizeError.new("Maximum u/int allowed is 64 bit precision") if bytes.size > 9
+      buffer << bytes
     end
 
     def decode(msg)
@@ -334,8 +300,8 @@ class BareTypes
   end
 
   class U8 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("C")
+    def encode(msg, buffer)
+      buffer << [msg].pack("C")
     end
 
     def decode(msg)
@@ -344,8 +310,8 @@ class BareTypes
   end
 
   class U16 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("v")
+    def encode(msg, buffer)
+      buffer << [msg].pack("v")
     end
 
     def decode(msg)
@@ -354,8 +320,8 @@ class BareTypes
   end
 
   class U32 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("V")
+    def encode(msg, buffer)
+      buffer << [msg].pack("V")
     end
 
     def decode(msg)
@@ -364,8 +330,8 @@ class BareTypes
   end
 
   class U64 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("Q")
+    def encode(msg, buffer)
+      buffer << [msg].pack("Q")
     end
 
     def decode(msg)
@@ -374,8 +340,8 @@ class BareTypes
   end
 
   class I8 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("c")
+    def encode(msg, buffer)
+      buffer << [msg].pack("c")
     end
 
     def decode(msg)
@@ -384,8 +350,8 @@ class BareTypes
   end
 
   class I16 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("s<")
+    def encode(msg, buffer)
+      buffer << [msg].pack("s<")
     end
 
     def decode(msg)
@@ -394,8 +360,8 @@ class BareTypes
   end
 
   class I32 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("l<")
+    def encode(msg, buffer)
+      buffer << [msg].pack("l<")
     end
 
     def decode(msg)
@@ -404,8 +370,8 @@ class BareTypes
   end
 
   class I64 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("q<")
+    def encode(msg, buffer)
+      buffer << [msg].pack("q<")
     end
 
     def decode(msg)
@@ -414,19 +380,219 @@ class BareTypes
   end
 
   class Bool < BarePrimitive
-    def encode(msg)
-      return msg ? "\xFF\xFF".b : "\x00\x00".b
+    def encode(msg, buffer)
+      buffer << (msg ? "\x00".b : "\x01".b)
+    end
+
+    def decode(msg)
+      if msg != "\x00" && msg != "\x01"
+        raise InvalidBool.new("Expected a bool but found #{msg.inspect}. Standard requires bool to be 0x00 or 0x01")
+      end
+      return (msg == "\x00" ? true : false), msg[1..msg.size]
+    end
+  end
+  #endregion
+
+  class Optional < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::Optional && otherType.optionalType == @optionalType
+    end
+
+    def to_schema(buffer)
+      buffer << "optional<"
+      @optionalType.to_schema(buffer)
+      buffer << ">"
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      if @optionalType.is_a?(Symbol)
+        @optionalType = Reference.new(@optionalType, schema[@optionalType])
+      else
+        @optionalType.finalize_references(schema)
+      end
+    end
+
+    def optionalType
+      @optionalType
+    end
+
+    def initialize(optionalType)
+      raise VoidUsedOutsideTaggedSet() if optionalType.class == BareTypes::Void
+      @optionalType = optionalType
+    end
+
+    def encode(msg, buffer)
+      if msg.nil?
+        buffer << "\x00".b
+      else
+        buffer << "\x01".b
+        @optionalType.encode(msg, buffer)
+      end
+    end
+
+    def decode(msg)
+      if msg.unpack("C")[0] == 0
+        return nil, msg[1..msg.size]
+      else
+        return @optionalType.decode(msg[1..msg.size])
+      end
+    end
+  end
+
+  class Map < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::Map && otherType.from == @from && otherType.to == @to
+    end
+
+    def to_schema(buffer)
+      buffer << "map["
+      @from.to_schema(buffer)
+      buffer << "]"
+      @to.to_schema(buffer)
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      if @from.is_a?(Symbol)
+        @to = Reference.new(@from, schema[@to])
+      else
+        @to.finalize_references(schema)
+      end
+    end
+
+    def initialize(fromType, toType)
+      raise VoidUsedOutsideTaggedSet if fromType.class == BareTypes::Void or toType.class == BareTypes::Void
+      if !fromType.class.ancestors.include?(BarePrimitive) ||
+        fromType.is_a?(BareTypes::Data) ||
+        fromType.is_a?(BareTypes::DataFixedLen)
+        raise MapKeyError("Map keys must use a primitive type which is not data or data<length>.")
+      end
+      @from = fromType
+      @to = toType
+    end
+
+    def from
+      @from
+    end
+
+    def to
+      @to
+    end
+
+    def encode(msg, buffer)
+      Uint.new.encode(msg.size, buffer)
+      msg.each do |from, to|
+        @from.encode(from, buffer)
+        @to.encode(to, buffer)
+      end
+    end
+
+    def decode(msg)
+      hash = Hash.new
+      mapSize, rest = Uint.new.decode(msg)
+      # (0..mapSize).each do
+      (mapSize - 1).to_i.downto(0) do
+        key, rest = @from.decode(rest)
+        value, rest = @to.decode(rest)
+        hash[key] = value
+      end
+      return hash, rest
+    end
+  end
+
+  class Union < BaseType
+    attr_accessor :intToType
+
+    def cycle_search(seen)
+      if @intToType.size == 1
+        seen.add(self)
+        @intToType.values.each do |type|
+          type.cycle_search(seen)
+        end
+        seen.pop
+      end
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      @intToType.keys.each do |key|
+        if @intToType[key].is_a?(Symbol)
+          @intToType[key] = Reference.new(@intToType[key], schema[@intToType[key]])
+        else
+          @intToType[key].finalize_references(schema)
+        end
+      end
+    end
+
+    def ==(otherType)
+      return false unless otherType.is_a?(BareTypes::Union)
+      @intToType.each do |int, type|
+        return false unless type == otherType.intToType[int]
+      end
+      true
+    end
+
+    def initialize(intToType)
+      intToType.keys.each do |i|
+        raise MinimumSizeError("Union's integer representations must be > 0, instead got: #{i}") if i < 0 or !i.is_a?(Integer)
+      end
+      raise MinimumSizeError("Union must have at least one type") if intToType.keys.size < 1
+      @intToType = intToType
+    end
+
+    def to_schema(buffer)
+      buffer << "("
+      strs = []
+      @intToType.size.times do
+        strs << ""
+      end
+      @intToType.values.each_with_index.map { |type, i| type.to_schema(strs[i]) }
+      buffer << strs.join(" | ")
+      buffer << ")"
+    end
+
+    def encode(msg, buffer)
+      type = msg[:type]
+      value = msg[:value]
+      unionTypeInt = nil
+      unionType = nil
+      @intToType.each do |int, typ|
+        if type.class == typ.class
+          unionTypeInt = int
+          unionType = typ
+          break
+        end
+      end
+      raise SchemaMismatch("Unable to find given type in union: #{@intToType.inspect}, type: #{type}") if unionType.nil? || unionTypeInt.nil?
+      Uint.new.encode(unionTypeInt, buffer)
+      unionType.encode(value, buffer)
     end
 
     def decode(msg)
-      return (msg == "\x00\x00" ? false : true), msg[1..msg.size]
+      int, rest = Uint.new.decode(msg)
+      type = @intToType[int]
+      value, rest = type.decode(rest)
+      return { value: value, type: type }, rest
     end
   end
 
   class Struct < BaseType
+    attr_accessor :mapping
+
+    def cycle_search(seen)
+      seen.add(self)
+      @mapping.values.each do |val|
+        val.cycle_search(seen)
+      end
+      seen.pop
+    end
 
     def [](key)
-      return @mapping[key]
+      @mapping[key]
     end
 
     def ==(otherType)
@@ -434,7 +600,7 @@ class BareTypes
       @mapping.each do |k, v|
         return false unless otherType.mapping[k] == v
       end
-      return true
+      true
     end
 
     def finalize_references(schema)
@@ -442,17 +608,18 @@ class BareTypes
       @finalized = true
       @mapping.each do |key, val|
         if val.is_a?(Symbol)
-          @mapping[key] = schema[val]
+          @mapping[key] = Reference.new(val, schema[val])
+          begin
+            @mapping[key].ref.finalize_references(schema)
+          rescue NoMethodError => e
+            puts "err"
+          end
         else
           val.finalize_references(schema)
         end
       end
     end
 
-    def mapping
-      @mapping
-    end
-
     def initialize(symbolToType)
       # Mapping from symbols to Bare types (or possibly symbols before finalizing)
       symbolToType.keys.each do |k|
@@ -467,13 +634,11 @@ class BareTypes
       @mapping = symbolToType
     end
 
-    def encode(msg)
-      bytes = "".b
+    def encode(msg, buffer)
       @mapping.keys.each do |symbol|
         raise SchemaMismatch.new("All struct fields must be specified, missing: #{symbol.inspect}") unless msg.keys.include?(symbol)
-        bytes << @mapping[symbol].encode(msg[symbol])
+        @mapping[symbol].encode(msg[symbol], buffer)
       end
-      return bytes
     end
 
     def decode(msg)
@@ -485,22 +650,43 @@ class BareTypes
       end
       return hash, rest
     end
+
+    def to_schema(buffer)
+      buffer << "{"
+      @mapping.each do |symbol, type|
+        buffer << "    #{symbol}: "
+        type.to_schema(buffer)
+        buffer << "\n"
+      end
+      buffer << "}"
+    end
   end
 
   class Array < BaseType
     def ==(otherType)
-      return otherType.class == BareTypes::Array && otherType.type == self.type
+      otherType.class == BareTypes::Array && otherType.type == self.type
+    end
+
+    def cycle_search(seen)
+      seen.add(self)
+      @type.cycle_search(seen)
+      seen.pop
     end
 
     def type
-      return @type
+      @type
+    end
+
+    def to_schema(buffer)
+      buffer << "[]"
+      @type.to_schema(buffer)
     end
 
     def finalize_references(schema)
       return if @finalized
       @finalized = true
       if @type.is_a?(Symbol)
-        @type = schema[@type]
+        @type = Reference.new(@type, schema[@type])
       else
         @type.finalize_references(schema)
       end
@@ -511,12 +697,11 @@ class BareTypes
       @type = type
     end
 
-    def encode(msg)
-      bytes = Uint.new.encode(msg.size)
+    def encode(msg, buffer)
+      Uint.new.encode(msg.size, buffer)
       msg.each do |item|
-        bytes << @type.encode(item)
+        @type.encode(item, buffer)
       end
-      return bytes
     end
 
     def decode(msg)
@@ -534,6 +719,14 @@ class BareTypes
   end
 
   class ArrayFixedLen < BaseType
+    attr_accessor :type, :size
+
+    def cycle_search(seen)
+      seen.add(self)
+      @type.cycle_search(seen)
+      seen.pop
+    end
+
     def ==(otherType)
       return otherType.class == BareTypes::ArrayFixedLen && otherType.type == @type && otherType.size == @size
     end
@@ -542,7 +735,7 @@ class BareTypes
       return if @finalized
       @finalized = true
       if @type.is_a?(Symbol)
-        @type = schema[@type]
+        @type = Reference.new(@type, schema[@type])
       else
         @type.finalize_references(schema)
       end
@@ -552,24 +745,14 @@ class BareTypes
       @type = type
       @size = size
       raise VoidUsedOutsideTaggedSet.new("Void type may not be used as type of fixed length array.") if type.class == BareTypes::Void
-      raise MinimumSizeError.new("FixedLenArray size must be > 0") if size < 1
+      raise MinimumSizeError.new("ArrayFixedLen size must be > 0") if size < 1
     end
 
-    def type
-      @type
-    end
-
-    def size
-      @size
-    end
-
-    def encode(arr)
-      raise SchemaMismatch.new("This FixLenArray is of length #{@size.to_s} but you passed an array of length #{arr.size}") if arr.size != @size
-      bytes = ""
+    def encode(arr, buffer)
+      raise SchemaMismatch.new("This ArrayFixedLen is of length #{@size.to_s} but you passed an array of length #{arr.size}") if arr.size != @size
       arr.each do |item|
-        bytes << @type.encode(item)
+        @type.encode(item, buffer)
       end
-      return bytes
     end
 
     def decode(rest)
@@ -580,6 +763,11 @@ class BareTypes
       end
       return array, rest
     end
+
+    def to_schema(buffer)
+      buffer << "[#{@size}]"
+      @type.to_schema(buffer)
+    end
   end
 
   class Enum < BaseType
@@ -591,10 +779,16 @@ class BareTypes
       return true
     end
 
-
-    def finalize_references(schema)
+    def to_schema(buffer)
+      buffer << "{\n"
+      @valToInt.each do |name, repr|
+        buffer << "   #{name} = #{repr}\n"
+      end
+      buffer << "}"
     end
 
+    def finalize_references(schema) end
+
     def intToVal
       @intToVal
     end
@@ -612,11 +806,10 @@ class BareTypes
       end
     end
 
-    def encode(msg)
+    def encode(msg, buffer)
       raise SchemaMismatch.new("#{msg.inspect} is not part of this enum: #{@intToVal}") if !@valToInt.keys.include?(msg)
       integerRep = @valToInt[msg]
-      encoded = BareTypes::Uint.new.encode(integerRep)
-      return encoded
+      BareTypes::Uint.new.encode(integerRep, buffer)
     end
 
     def decode(msg)
@@ -637,4 +830,4 @@ def _get_next_7_bits_as_byte(integer, base = 128)
     end
     yield(byte)
   end
-end
+end