bare-rb 0.0.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adea5476cd77af659cb3329602479f8b80b59d0b7459dc7cf343165b7096d871
-  data.tar.gz: 2e3f86206cc9519cd654dfcf28972a5c5c5b4fc5966143699d74f22209373088
+  metadata.gz: 1e8e36acbdcc47dc92e23a029edf5fac7001fbec9bd4948549cc0e682ea238b0
+  data.tar.gz: 86ffe342e8f2ec768b6fb222fe3575dd35eda7500ee88cff7111056a8bd422d5
 SHA512:
-  metadata.gz: e19625e2170ed457390a6f6d06d68a67443c91f057b5310363e49d6a8c5102bb41ae068fba67f3eaecbe11f2f984bc54eae81f02c39a5222f07887920e39f8af
-  data.tar.gz: 0e502b379a427ac5c493f0f02a8b17ab6821560adf248fccbcfac2dc31e406f08c1f29816970a50b5d82589ffdbb6f4fca2940b4e2eacda39633a95b50d58b69
+  metadata.gz: 555833846daa3aa6337fb836b3a7959d656dd329c3925bceb01ab27d6f873bde95e83bf965daea90f3429c73b8659b40929f6f9e1b138a631c85966910750ee2
+  data.tar.gz: 0f9b6ef29fd8731c688f8507d6b141e2bb0992b0074b7118cb8b13a9263b57aad9e30becbb990c94d6cc33792abad805a3cd4a44d8deab93ee3847a8de57e68a

data/lib/bare-rb.rb

@@ -1,13 +1,67 @@
 require 'set'
 require_relative "types"
+require_relative "lexer"
+require_relative "parser"
 
 class Bare
-  def self.encode(msg, schema)
-    return schema.encode(msg)
-  end
-
-  def self.decode(msg, schema)
-    return schema.decode(msg)[:value]
+  def self.encode(msg, schema, type=nil)
+    if schema.is_a?(Bare::Schema)
+      raise NoTypeProvided("To encode with a schema as opposed to a raw type you must specify which type in the schema you want to encode as a symbol.\nBare.encode(msg, schema, :Type)") if type.nil?
+      schema[type].encode(msg)
+    else
+      schema.encode(msg)
+    end
+  end
+
+  def self.decode(msg, schema, type=nil)
+    if schema.is_a?(Bare::Schema)
+      raise NoTypeProvided("To decode with a schema as opposed to a raw type you must specify which type in the same you want to encode as a symbol.\nBare.encode(msg, schema, :Type)") if type.nil?
+      value, rest = schema[type].decode(msg)
+      value
+    else
+      value, rest = schema.decode(msg)
+      return value
+    end
+  end
+
+  def self.parse_schema(path)
+    # Hash of class names to BARE ASTs
+    # Eg. types['Customer'] == Bare.i32
+    types = parser(lexer(path))
+    Bare.Schema(types)
+  end
+
+  def self.Schema(hash)
+    Bare::Schema.new(hash)
+  end
+
+  class Schema
+    def ==(otherSchema)
+      return false unless otherSchema.is_a?(Bare::Schema)
+      @types == otherSchema.types
+    end
+
+    def types
+      @types
+    end
+
+    def [](key)
+      return @types[key]
+    end
+
+    def initialize(types)
+      @types = types
+      @types.keys.each do |key|
+        if @types[key].is_a?(Symbol)
+          @types[key] = @types[@types[key]]
+        else
+          # Users may use symbols to reference not yet defined types
+          # here we recursively call our bare classes to finalize their types
+          # replacing Symbols like :SomeType with a reference to the other type
+          @types[key].finalize_references(@types)
+        end
+      end
+    end
   end
 
   # These classes are wrapped in methods for ergonomics.
@@ -108,5 +162,7 @@ class Bare
   def self.Enum(*opts)
     return BareTypes::Enum.new(*opts)
   end
+
+
 end
 

data/lib/exceptions.rb

@@ -1,9 +1,28 @@
+
 class BareException < StandardError
   def initialize(msg=nil)
     super
   end
 end
 
+class FixedDataSizeWrong < BareException
+  def initialize(msg=nil)
+    super
+  end
+end
+
+class NoTypeProvided < BareException
+  def initialize(msg = nil)
+    super
+  end
+end
+
+class SchemaParsingException < BareException
+  def initialize(msg=nil)
+    super
+  end
+end
+
 class VoidUsedOutsideTaggedSet < BareException
   def initialize(msg =  "Any type which is ultimately a void type (either directly or through user-defined types) may not be used as an optional type, struct member, array member, or map key or value. Void types may only be used as members of the set of types in a tagged union.")
     super

data/lib/lexer.rb

@@ -0,0 +1,62 @@
+require_relative './exceptions'
+
+def lexer(path)
+  tokens = []
+  line_num = 0
+  File.open(path).each do |line|
+    while line.size > 0
+      if /^#/.match(line)
+        break
+      elsif /^\n/.match(line)
+        break
+      elsif /^ /.match(line)
+        line = line[1..line.size]
+      elsif /^</.match(line)
+        line = line[1..line.size]
+        tokens << :less_than
+      elsif /^>/.match(line)
+        line = line[1..line.size]
+        tokens << :greater_than
+        next
+      elsif /^{/.match(line)
+        line = line[1..line.size]
+        tokens << :open_block
+      elsif /^=/.match(line)
+        line = line[1..line.size]
+        tokens << :equal
+      elsif /^}/.match(line)
+        line = line[1..line.size]
+        tokens << :close_block
+      elsif /^\[/.match(line)
+        line = line[1..line.size]
+        tokens << :open_brace
+      elsif /^\]/.match(line)
+        line = line[1..line.size]
+        tokens << :close_brace
+      elsif /^\(/.match(line)
+        line = line[1..line.size]
+        tokens << :open_paren
+      elsif /^\)/.match(line)
+        line = line[1..line.size]
+        tokens << :close_paren
+      elsif /^\|/.match(line)
+        line = line[1..line.size]
+        tokens << :bar
+      elsif match = /^([0-9]+)/.match(line)
+        tokens << match[0].to_i
+        line = line[(match[0].size)..line.size]
+        next
+      elsif match = /^[a-z,A-Z,_][_,a-z,A-Z,0-9]+/.match(line)
+        tokens << match[0]
+        line = line[(match[0].size)..line.size]
+      elsif /:/.match(line)
+        tokens << :colon
+        line = line[1..line.size]
+      else
+        raise SchemaParsingException.new("Unable to lex line #{line_num} near #{line.inspect}")
+      end
+    end
+    line_num += 1
+  end
+  return tokens
+end

data/lib/parser.rb

@@ -0,0 +1,150 @@
+require_relative './exceptions'
+
+
+# enum, struct, array, fixedlenarray, data<length>
+class Parser
+
+  def initialize
+    @definitions = {}
+    @primitives = {
+        "uint" => Bare.Uint,
+        "int" => Bare.Int,
+        "u8" => Bare.U8,
+        "u16" => Bare.U16,
+        "u32" => Bare.U32,
+        "u64" => Bare.U64,
+        "i8" => Bare.I8,
+        "i16" => Bare.I16,
+        "i32" => Bare.I32,
+        "i64" => Bare.I64,
+        "f32" => Bare.F32,
+        "f64" => Bare.F64,
+        "bool" => Bare.Bool,
+        "string" => Bare.String,
+        "data" => Bare.Data,
+        "void" => Bare.Void,
+    }
+  end
+
+  def definitions
+    @definitions
+  end
+
+  def parse_enum(tokens)
+    enum_hash = {} # {1 => "abc", 5 => :cow, 16382 => 123}
+    count = 0
+    while tokens[0] != :close_block
+      if tokens[1] == :equal
+        name = tokens[0]
+        int_repr = tokens[2]
+        enum_hash[int_repr] = name
+        tokens = tokens[3..tokens.size]
+      else
+        enum_hash[count] = tokens[0]
+        count += 1
+        tokens = tokens[1..tokens.size]
+      end
+    end
+    enum = Bare.Enum(enum_hash)
+    return tokens[1..tokens.size], enum
+  end
+
+  def parse_union(tokens)
+    count = 0
+    union_hash = {}
+    # type A_UNION ( int | uint | data = 7 | f32 )
+    while tokens[0] != :close_paren
+      if tokens[0] == :bar
+        tokens = tokens[1..tokens.size]
+      else
+        if tokens[1] == :equal
+          raise SchemaParsingException.new("Equals sign in union must be followed by a number") unless tokens[2].is_a?(Numeric)
+          count = tokens[2]
+          tokens, type = self.parse(tokens)
+          tokens = tokens[2..tokens.size]
+          union_hash[count] = type
+          count += 1
+        else
+          tokens, type = self.parse(tokens)
+          union_hash[count] = type
+          count += 1
+        end
+      end
+    end
+    return tokens, union_hash
+  end
+
+  def parse_struct(tokens)
+    struct_fields = {}
+    while tokens.size >= 2 and tokens[1] == :colon
+      name = tokens[0]
+      tokens, type = self.parse(tokens[2..tokens.size])
+      struct_fields[name.to_sym] = type
+    end
+    return tokens[1..tokens.size], struct_fields
+  end
+
+  def parse(tokens)
+    while tokens.size > 0
+      if tokens[0] == "type"
+        name = tokens[1]
+        tokens, type = self.parse(tokens[2..tokens.size])
+        @definitions[name.to_sym] = type
+      elsif tokens[0] == "map"
+        raise SchemaParsingException.new("Map must be followed by a '[' eg. map[string]data") if tokens[1] != :open_brace
+        tokens, map_from_type = parse(tokens[2..tokens.size])
+        raise SchemaParsingException.new("Map to type must be followed by a ']' eg. map[string]data") if tokens[0] != :close_brace
+        tokens, map_to_type = parse(tokens[1..tokens.size])
+        return tokens, Bare.Map(map_from_type, map_to_type)
+      elsif tokens[0] == "data" && tokens.size > 3 && tokens[1] == :less_than
+        raise SchemaParsingException.new("data< must be followed by a number for a fixed sized bare data") unless tokens[2].is_a?(Numeric)
+        raise SchemaParsingException.new("data<# must be followed by a >") unless tokens[3] == :greater_than
+        return tokens[4..tokens.size], Bare.DataFixedLen(tokens[2])
+      elsif tokens[0] == "enum"
+        name = tokens[1]
+        raise SchemaParsingException.new("Enum must be followed by a '{'") if tokens[2] != :open_block
+        tokens, enum = parse_enum(tokens[3..tokens.size])
+        @definitions[name.to_sym] = enum
+      elsif tokens[0] == "optional"
+        raise SchemaParsingException.new("Optional must be followed by a '< TYPE > you are missing the first <'") if tokens[1] != :less_than
+        tokens, optional_type = self.parse(tokens[2..tokens.size])
+        raise SchemaParsingException.new("Optional must be followed by a '< TYPE >' you are missing the last >") if tokens[0] != :greater_than
+        return tokens[1..tokens.size], Bare.Optional(optional_type)
+      elsif tokens[0] == :open_brace
+        if tokens[1].is_a?(Numeric)
+          size = tokens[1]
+          raise SchemaParsingException.new("Fixed Length Array size must be followed by a ']'") if tokens[2] != :close_brace
+          tokens, arr_type = parse(tokens[3..tokens.size])
+          return tokens, Bare.ArrayFixedLen(arr_type, size)
+        else
+          tokens, arr_type = parse(tokens[2..tokens.size])
+          return tokens, Bare.Array(arr_type)
+        end
+      elsif tokens[0] == :open_paren
+        tokens, union_hash = parse_union(tokens[1..tokens.size])
+        raise SchemaParsingException.new("Union must be followed by a ')'") if tokens[0] != :close_paren
+        return tokens[1..tokens.size], Bare.Union(union_hash)
+      elsif tokens[0] == :open_block
+        tokens, struct_fields = parse_struct(tokens[1..tokens.size])
+        strct = Bare.Struct(struct_fields)
+        return tokens, strct
+      elsif @primitives.include?(tokens[0])
+        type = @primitives[tokens[0]]
+        return tokens[1..tokens.size], type
+      elsif @definitions.keys.include?(tokens[0].to_sym) # User defined type
+        return tokens[1..tokens.size], @definitions[tokens[0].to_sym]
+      elsif tokens[0].is_a?(String) && tokens[0][0].upcase == tokens[0][0] # Not yet defined user type
+        return tokens[1..tokens.size], tokens[0].to_sym
+      else
+        raise SchemaParsingException.new("Unable to parse token: #{tokens[0]}")
+      end
+    end
+  end
+end
+
+
+def parser(tokens, definitions = {})
+  parser = Parser.new
+  parser.parse(tokens)
+  return parser.definitions
+end

data/lib/types.rb

@@ -3,16 +3,26 @@ require_relative './exceptions'
 class BareTypes
 
   class BaseType
+    def initialize
+      @finalized = false
+      super
+    end
   end
 
   class BarePrimitive < BaseType
+
     # Types which are always equivalent to another instantiation of themselves
     # Eg. Uint.new == Uint.new
     # But Union.new(types1) != Union.new(types2)
     #   since unions could have different sets of types
+
     def ==(other)
       self.class == other.class
     end
+
+    def finalize_references(schema)
+    end
+
   end
 
   class Int < BarePrimitive
@@ -22,11 +32,11 @@ class BareTypes
       mappedInteger = msg < 0 ? -2 * msg - 1 : msg * 2
       return Uint.new.encode(mappedInteger)
     end
+
     def decode(msg)
-      output = Uint.new.decode(msg)
-      unmapped = output[:value]
-      unmapped = unmapped.odd? ? (unmapped + 1) / - 2 : unmapped / 2
-      return { value: unmapped, rest: output[:rest] }
+      value, rest = Uint.new.decode(msg)
+      value = value.odd? ? (value + 1) / -2 : value / 2
+      return  value, rest
     end
   end
 
@@ -34,17 +44,19 @@ class BareTypes
     def encode(msg)
       return "".b
     end
+
     def decode(msg)
-      return {value: nil, rest: msg}
+      return nil, msg
     end
   end
 
   class F32 < BarePrimitive
     def encode(msg)
-      return [msg].pack("e")
+      [msg].pack("e")
     end
+
     def decode(msg)
-      return {value: msg.unpack("e")[0], rest: msg[4..msg.size]}
+      return msg.unpack("e")[0], msg[4..msg.size]
     end
   end
 
@@ -52,8 +64,9 @@ class BareTypes
     def encode(msg)
       return [msg].pack("E")
     end
+
     def decode(msg)
-      return {value: msg.unpack("E")[0], rest: msg[8..msg.size]}
+      return msg.unpack("E")[0], msg[8..msg.size]
     end
   end
 
@@ -69,11 +82,11 @@ class BareTypes
       bytes << encodedString
       return bytes
     end
+
     def decode(msg)
-      output = Uint.new.decode(msg)
-      strLen = output[:value]
-      string = output[:rest][0..strLen-1]
-      return {value: string.force_encoding("utf-8"), rest: output[:rest][strLen..output[:rest].size] }
+      strLen, rest = Uint.new.decode(msg)
+      string = rest[0..strLen - 1]
+      return string.force_encoding("utf-8"), rest[strLen..rest.size]
     end
   end
 
@@ -82,6 +95,16 @@ class BareTypes
       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
@@ -95,7 +118,7 @@ class BareTypes
       if msg.nil?
         return "\x00".b
       else
-        bytes = "\xFF".b
+        bytes = "\x01".b
         bytes << @optionalType.encode(msg)
         return bytes
       end
@@ -103,7 +126,7 @@ class BareTypes
 
     def decode(msg)
       if msg.unpack("C")[0] == 0
-        return {value: nil, rest: msg[1..msg.size]}
+        return nil, msg[1..msg.size]
       else
         return @optionalType.decode(msg[1..msg.size])
       end
@@ -115,9 +138,23 @@ class BareTypes
       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
-      raise MapKeyError("Map keys must use a primitive type which is not data or data<length>.") if !fromType.class.ancestors.include?(BarePrimitive) || fromType.is_a?(BareTypes::Data) || fromType.is_a?(BareTypes::DataFixedLen)
+      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
@@ -141,24 +178,34 @@ class BareTypes
 
     def decode(msg)
       hash = Hash.new
-      output = Uint.new.decode(msg)
-      mapSize = output[:value]
+      mapSize, rest = Uint.new.decode(msg)
       (mapSize - 1).to_i.downto(0) do
-        output = @from.decode(output[:rest])
-        key = output[:value]
-        output = @to.decode(output[:rest])
-        hash[key] = output[:value]
-        hash[key] = output[:value]
+        key, rest = @from.decode(rest)
+        value, rest = @to.decode(rest)
+        hash[key] = value
       end
-      return {value: hash, rest: output[:rest]}
+      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|
@@ -194,11 +241,10 @@ class BareTypes
     end
 
     def decode(msg)
-      unionTypeInt = Uint.new.decode(msg)
-      int = unionTypeInt[:value]
+      int, rest = Uint.new.decode(msg)
       type = @intToType[int]
-      value = type.decode(unionTypeInt[:rest])
-      return {value: {value: value[:value], type: type}, rest: value[:rest]}
+      value, rest = type.decode(rest)
+      return {value: value, type: type}, rest
     end
   end
 
@@ -211,21 +257,31 @@ class BareTypes
       return @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
       @length = length
     end
 
     def encode(msg)
-      return msg
+      if msg.size != @length
+        raise FixedDataSizeWrong.new("Message is not proper sized for DataFixedLen should have been #{@length} but was #{msg.size}")
+      end
+      msg
     end
 
     def decode(msg)
-      return {value: msg[0..@length], rest: msg[@length..msg.size]}
+      return msg[0..@length], msg[@length..msg.size]
     end
   end
 
   class Data < BarePrimitive
+
+    def finalize_references(schema)
+    end
+
     def encode(msg)
       bytes = Uint.new.encode(msg.size)
       bytes << msg
@@ -233,14 +289,16 @@ class BareTypes
     end
 
     def decode(msg)
-      output = Uint.new.decode(msg)
-      rest = output[:rest]
-      dataSize = output[:value]
-      return {value: rest[0..dataSize], rest: rest[dataSize..rest.size]}
+      dataSize, rest = Uint.new.decode(msg)
+      return rest[0..dataSize - 1], rest[dataSize..rest.size]
     end
   end
 
   class Uint < BarePrimitive
+
+    def finalize_references(schema)
+    end
+
     def encode(msg)
       bytes = "".b
       _get_next_7_bits_as_byte(msg, 128) do |byte|
@@ -259,7 +317,7 @@ class BareTypes
     end
 
     def decode(msg)
-      ints = msg.unpack("CCCCCCCCC")
+      ints = msg.unpack("CCCCCCCC")
       relevantInts = []
       i = 0
       while ints[i] & 0b10000000 == 128
@@ -271,7 +329,7 @@ class BareTypes
       relevantInts.each_with_index do |int, idx|
         sum += int << (idx * 7)
       end
-      return {value: sum, rest: msg[(i + 1)..msg.size]}
+      return sum, msg[(i + 1)..msg.size]
     end
   end
 
@@ -281,7 +339,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg[0].unpack("C")[0], rest: msg[1..msg.size]}
+      return msg[0].unpack("C")[0], msg[1..msg.size]
     end
   end
 
@@ -291,7 +349,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack("v")[0], rest: msg[2..msg.size]}
+      return msg.unpack("v")[0], msg[2..msg.size]
     end
   end
 
@@ -301,7 +359,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack("V")[0], rest: msg[4..msg.size]}
+      return msg.unpack("V")[0], msg[4..msg.size]
     end
   end
 
@@ -311,7 +369,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack("Q")[0], rest: [8..msg.size]}
+      return msg.unpack("Q")[0], msg[8..msg.size]
     end
   end
 
@@ -321,7 +379,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg[0].unpack("c")[0], rest: msg[1..msg.size]}
+      return msg[0].unpack("c")[0], msg[1..msg.size]
     end
   end
 
@@ -331,7 +389,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack('s<')[0], rest: msg[2..msg.size]}
+      return msg.unpack('s<')[0], msg[2..msg.size]
     end
   end
 
@@ -341,7 +399,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack('l<')[0], rest: msg[4..msg.size]}
+      return msg.unpack('l<')[0], msg[4..msg.size]
     end
   end
 
@@ -351,7 +409,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack('q<')[0], rest: msg[8..msg.size]}
+      return msg.unpack('q<')[0], msg[8..msg.size]
     end
   end
 
@@ -361,11 +419,16 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg == "\x00\x00" ? false : true, rest: msg[1..msg.size]}
+      return (msg == "\x00\x00" ? false : true), msg[1..msg.size]
     end
   end
 
   class Struct < BaseType
+
+    def [](key)
+      return @mapping[key]
+    end
+
     def ==(otherType)
       return false unless otherType.class == BareTypes::Struct
       @mapping.each do |k, v|
@@ -374,16 +437,31 @@ class BareTypes
       return true
     end
 
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      @mapping.each do |key, val|
+        if val.is_a?(Symbol)
+          @mapping[key] = schema[val]
+        else
+          val.finalize_references(schema)
+        end
+      end
+    end
+
     def mapping
       @mapping
     end
 
     def initialize(symbolToType)
-      # Mapping from symbols to Bare types
+      # Mapping from symbols to Bare types (or possibly symbols before finalizing)
       symbolToType.keys.each do |k|
-        raise BareException("Struct keys must be symbols") unless k.is_a?(Symbol)
-        raise BareException("Struct values must be a BareTypes::TYPE\nInstead got: #{symbolToType[k].inspect}") unless symbolToType[k].class.ancestors.include?(BaseType)
-        raise VoidUsedOutsideTaggedSet("Void types may only be used as members of the set of types in a tagged union. Void type used as struct key") if symbolToType.class == BareTypes::Void
+        raise BareException.new("Struct keys must be symbols") unless k.is_a?(Symbol)
+        if (!symbolToType[k].class.ancestors.include?(BaseType) && !symbolToType[k].is_a?(Symbol))
+          raise BareException.new("Struct values must be a BareTypes::TYPE or a symbol with the same
+                name as a user defined type\nInstead got: #{symbolToType[k].inspect}")
+        end
+        raise VoidUsedOutsideTaggedSet.new("Void types may only be used as members of the set of types in a tagged union. Void type used as struct key") if symbolToType.class == BareTypes::Void
       end
       raise("Struct must have at least one field") if symbolToType.keys.size == 0
       @mapping = symbolToType
@@ -392,7 +470,7 @@ class BareTypes
     def encode(msg)
       bytes = "".b
       @mapping.keys.each do |symbol|
-        raise SchemaMismatch("All struct fields must be specified, missing: #{symbol.inspect}") unless msg.keys.include?(symbol)
+        raise SchemaMismatch.new("All struct fields must be specified, missing: #{symbol.inspect}") unless msg.keys.include?(symbol)
         bytes << @mapping[symbol].encode(msg[symbol])
       end
       return bytes
@@ -402,11 +480,10 @@ class BareTypes
       hash = Hash.new
       rest = msg
       @mapping.keys.each do |symbol|
-        output = @mapping[symbol].decode(rest)
-        hash[symbol] = output[:value]
-        rest = output[:rest]
+        value, rest = @mapping[symbol].decode(rest)
+        hash[symbol] = value
       end
-      return {value: hash, rest: rest}
+      return hash, rest
     end
   end
 
@@ -419,8 +496,18 @@ class BareTypes
       return @type
     end
 
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      if @type.is_a?(Symbol)
+        @type = schema[@type]
+      else
+        @type.finalize_references(schema)
+      end
+    end
+
     def initialize(type)
-      raise VoidUsedOutsideTaggedSet("Void types may only be used as members of the set of types in a tagged union.") if type.class == BareTypes::Void
+      raise VoidUsedOutsideTaggedSet.new("Void types may only be used as members of the set of types in a tagged union.") if type.class == BareTypes::Void
       @type = type
     end
 
@@ -433,17 +520,16 @@ class BareTypes
     end
 
     def decode(msg)
-      output = Uint.new.decode(msg)
       arr = []
-      arrayLen = output[:value]
+      arrayLen, rest = Uint.new.decode(msg)
       lastSize = msg.size + 1 # Make sure msg size monotonically decreasing
       (arrayLen - 1).downto(0) do
-        output = @type.decode(output[:rest])
-        arr << output[:value]
-        break if output[:rest].nil? || output[:rest].size == 0 || lastSize <= output[:rest].size
-        lastSize = output[:rest].size
+        arrVal, rest = @type.decode(rest)
+        arr << arrVal
+        break if rest.nil? || rest.size == 0 || lastSize <= rest.size
+        lastSize = rest.size
       end
-      return {value: arr, rest: output[:rest]}
+      return arr, rest
     end
   end
 
@@ -452,11 +538,21 @@ class BareTypes
       return otherType.class == BareTypes::ArrayFixedLen && otherType.type == @type && otherType.size == @size
     end
 
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      if @type.is_a?(Symbol)
+        @type = schema[@type]
+      else
+        @type.finalize_references(schema)
+      end
+    end
+
     def initialize(type, size)
       @type = type
       @size = size
-      raise VoidUsedOutsideTaggedSet("Void type may not be used as type of fixed length array.") if type.class == BareTypes::Void
-      raise MinimumSizeError("FixedLenArray size must be > 0") if size < 1
+      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
     end
 
     def type
@@ -468,7 +564,7 @@ class BareTypes
     end
 
     def encode(arr)
-      raise SchemaMismatch("This FixLenArray is of length #{@size.to_s} but you passed an array of length #{arr.size}") if arr.size != @size
+      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 = ""
       arr.each do |item|
         bytes << @type.encode(item)
@@ -476,15 +572,13 @@ class BareTypes
       return bytes
     end
 
-    def decode(msg)
+    def decode(rest)
       array = []
-      rest = msg
       @size.times do
-        output = @type.decode(rest)
-        rest = output[:rest]
-        array << output[:value]
+        arrVal, rest = @type.decode(rest)
+        array << arrVal
       end
-      return {value: array, rest: rest}
+      return array, rest
     end
   end
 
@@ -497,6 +591,10 @@ class BareTypes
       return true
     end
 
+
+    def finalize_references(schema)
+    end
+
     def intToVal
       @intToVal
     end
@@ -504,9 +602,9 @@ class BareTypes
     def initialize(source)
       @intToVal = {}
       @valToInt = {}
-      raise BareException("Enum must initialized with a hash from integers to anything") if !source.is_a?(Hash)
-      raise BareException("Enum must have unique positive integer assignments") if Set.new(source.keys).size != source.keys.size
-      raise BareException("Enum must have unique values") if source.values.to_set.size != source.values.size
+      raise BareException.new("Enum must initialized with a hash from integers to anything") if !source.is_a?(Hash)
+      raise BareException.new("Enum must have unique positive integer assignments") if Set.new(source.keys).size != source.keys.size
+      raise EnumValueError.new("Enum must have unique values") if source.values.to_set.size != source.values.size
       source.each do |k, v|
         raise("Enum keys must be positive integers") if k < 0
         @intToVal[k.to_i] = v
@@ -515,17 +613,15 @@ class BareTypes
     end
 
     def encode(msg)
-      raise SchemaMismatch("#{msg.inspect} is not part of this enum: #{@intToVal}") if !@valToInt.keys.include?(msg)
+      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
     end
 
     def decode(msg)
-      output = BareTypes::Uint.new.decode(msg)
-      value = output[:value]
-      rest = output[:rest]
-      return {value: @intToVal[value], rest: rest}
+      value, rest = BareTypes::Uint.new.decode(msg)
+      return @intToVal[value], rest
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bare-rb
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Nate Tracy-Amoroso
@@ -10,7 +10,8 @@ bindir: bin
 cert_chain: []
 date: 2020-10-13 00:00:00.000000000 Z
 dependencies: []
-description: Implements the bare message encoding and DSL in ruby
+description: The first implementation of the BARE (Binary Application Record Encoding)
+  in Ruby. Includes schema parsing and compatibility tests.
 email: n8@u.northwestern.edu
 executables: []
 extensions: []
@@ -18,8 +19,10 @@ extra_rdoc_files: []
 files:
 - "./lib/bare-rb.rb"
 - "./lib/exceptions.rb"
+- "./lib/lexer.rb"
+- "./lib/parser.rb"
 - "./lib/types.rb"
-homepage: https://none.none
+homepage: https://github.com/n8ta/bare-rb
 licenses:
 - MIT
 metadata: {}