bare-rb 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdfcd51a2a757a2cb2c532d1281afe227150518a6feb625466a5f25fac16b84b
-  data.tar.gz: ca3ed0f25556c996c62ff70a31ef3c50d9a3e6cad0d712eb8e428013a5af0af3
+  metadata.gz: 5b1147744e8da154541d6591f1e78929ad90a57ba806541a03cc5e770b43af6b
+  data.tar.gz: 121a6ba57b86dc43f9e1b65145cc35e5c2174934e97bfdc142ddcd848f74deae
 SHA512:
-  metadata.gz: 222f83030bee145a42b3ae2ef890316f4969502f3a8e9704e3b84ffadaab0866d71163bf97b0d3f90ec02a065336343b20149375b9e628c646d8b342d0e5b27d
-  data.tar.gz: e757dbf048dd0f65392561a9034b3407d2fe9e2e942bcf181b3c7a25847a03e9eb515b66ef74b23115b37a94751daeae04eb4190b218a0c2dcbe2ab988ca3256
+  metadata.gz: 8490934a87328cf339307924d7268e71e0c4c58336021294c2e957d618ab871ecc1a7d05f07ae72025e214f0fab7b64df7d31d37c3b6cbea8687315a523cb7f0
+  data.tar.gz: d2930be08e535b50638eeda6814cd7d2e1544eead403a4f4efd81817cc54eb352a0e52575460f612ba9a5127949d61c6724c7a724e0feac3f7a2c9d54906da36

data/lib/bare-rb.rb

@@ -4,20 +4,62 @@ require_relative "lexer"
 require_relative "parser"
 
 class Bare
+  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 same you want to encode as a symbol.\nBare.encode(msg, schema, :Type)") if type.nil?
+      return 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?
+      return schema[type].decode(msg)[:value]
+    else
+      schema.decode(msg)[:value]
+    end
+  end
 
   def self.parse_schema(path)
     # Hash of class names to BARE ASTs
     # Eg. types['Customer'] == Bare.i32
     types = parser(lexer(path))
-    return types
+    Bare.Schema(types)
   end
 
-  def self.encode(msg, schema)
-    return schema.encode(msg)
+  def self.Schema(hash)
+    Bare::Schema.new(hash)
   end
 
-  def self.decode(msg, schema)
-    return schema.decode(msg)[:value]
+  class Schema
+
+    def ==(otherSchema)
+      return false unless otherSchema.is_a?(Bare::Schema)
+      return @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 user symbols to reference not yet defined types
+          # here we recursively call our bare classes to finalize their types
+          @types[key].finalize_references(@types)
+        end
+      end
+    end
   end
 
   # These classes are wrapped in methods for ergonomics.
@@ -118,5 +160,7 @@ class Bare
   def self.Enum(*opts)
     return BareTypes::Enum.new(*opts)
   end
+
+
 end
 

data/lib/exceptions.rb

@@ -5,6 +5,12 @@ class BareException < StandardError
   end
 end
 
+class NoTypeProvided < BareException
+  def initialize(msg = nil)
+    super
+  end
+end
+
 class SchemaParsingException < BareException
   def initialize(msg=nil)
     super

data/lib/lexer.rb

@@ -44,7 +44,7 @@ def lexer(path)
         tokens << :bar
       elsif match = /^([0-9]+)/.match(line)
         tokens << match[0].to_i
-        line = line[(match.size + 1)..]
+        line = line[(match[0].size)..]
         next
       elsif match = /^[a-z,A-Z,_][_,a-z,A-Z,0-9]+/.match(line)
         tokens << match[0]

data/lib/parser.rb

@@ -49,6 +49,31 @@ class Parser
     return tokens[1..], 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..]
+      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..]
+          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
@@ -66,20 +91,39 @@ class Parser
         tokens, type = self.parse(tokens[2..])
         @definitions[name.to_sym] = type
       elsif tokens[0] == "map"
-        raise SchemaParsingException("Map must be followed by a '[' eg. map[string]data") if tokens[1] != :open_brace
+        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..])
-        raise SchemaParsingException("Map to type must be followed by a ']' eg. map[string]data") if tokens[0] != :close_brace
+        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..])
-        return tokens, Bare.Map(map_from_type,map_to_type)
+        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..], Bare.DataFixedLen(tokens[2])
       elsif tokens[0] == "enum"
         name = tokens[1]
-        raise SchemaParsingException("Enum must be followed by a '{'") if tokens[2] != :open_block
+        raise SchemaParsingException.new("Enum must be followed by a '{'") if tokens[2] != :open_block
         tokens, enum = parse_enum(tokens[3..])
         @definitions[name.to_sym] = enum
-        return tokens, 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..])
+        raise SchemaParsingException.new("Optional must be followed by a '< TYPE >' you are missing the last >") if tokens[0] != :greater_than
+        return tokens[1..], Bare.Optional(optional_type)
       elsif tokens[0] == :open_brace
-        tokens, arr_type = parse(tokens[2..])
-        return tokens, Bare.Array(arr_type)
+        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..])
+          return tokens, Bare.ArrayFixedLen(arr_type, size)
+        else
+          tokens, arr_type = parse(tokens[2..])
+          return tokens, Bare.Array(arr_type)
+        end
+      elsif tokens[0] == :open_paren
+        tokens, union_hash = parse_union(tokens[1..])
+        raise SchemaParsingException.new("Union must be followed by a ')'") if tokens[0] != :close_paren
+        return tokens[1..], Bare.Union(union_hash)
       elsif tokens[0] == :open_block
         tokens, struct_fields = parse_struct(tokens[1..])
         strct = Bare.Struct(struct_fields)
@@ -87,6 +131,10 @@ class Parser
       elsif @primitives.include?(tokens[0])
         type = @primitives[tokens[0]]
         return tokens[1..], type
+      elsif @definitions.keys.include?(tokens[0].to_sym) # User defined type
+        return tokens[1..], @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[0].to_sym
       else
         raise SchemaParsingException.new("Unable to parse token: #{tokens[0]}")
       end

data/lib/types.rb

@@ -3,6 +3,10 @@ require_relative './exceptions'
 class BareTypes
 
   class BaseType
+    def initialize
+      @finalized = false
+      super
+    end
   end
 
   class BarePrimitive < BaseType
@@ -10,9 +14,14 @@ class BareTypes
     # 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 +31,12 @@ 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] }
+      unmapped = unmapped.odd? ? (unmapped + 1) / -2 : unmapped / 2
+      return {value: unmapped, rest: output[:rest]}
     end
   end
 
@@ -34,6 +44,7 @@ class BareTypes
     def encode(msg)
       return "".b
     end
+
     def decode(msg)
       return {value: nil, rest: msg}
     end
@@ -43,6 +54,7 @@ class BareTypes
     def encode(msg)
       return [msg].pack("e")
     end
+
     def decode(msg)
       return {value: msg.unpack("e")[0], rest: msg[4..msg.size]}
     end
@@ -52,6 +64,7 @@ class BareTypes
     def encode(msg)
       return [msg].pack("E")
     end
+
     def decode(msg)
       return {value: msg.unpack("E")[0], rest: msg[8..msg.size]}
     end
@@ -69,11 +82,12 @@ 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] }
+      string = output[:rest][0..strLen - 1]
+      return {value: string.force_encoding("utf-8"), rest: output[:rest][strLen..output[:rest].size]}
     end
   end
 
@@ -82,6 +96,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
@@ -115,9 +139,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
@@ -154,10 +192,23 @@ class BareTypes
   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|
@@ -210,6 +261,9 @@ 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
@@ -225,6 +279,10 @@ class BareTypes
   end
 
   class Data < BarePrimitive
+
+    def finalize_references(schema)
+    end
+
     def encode(msg)
       bytes = Uint.new.encode(msg.size)
       bytes << msg
@@ -235,11 +293,15 @@ class BareTypes
       output = Uint.new.decode(msg)
       rest = output[:rest]
       dataSize = output[:value]
-      return {value: rest[0..dataSize-1], rest: rest[dataSize..]}
+      return {value: rest[0..dataSize - 1], rest: rest[dataSize..]}
     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|
@@ -365,6 +427,11 @@ class BareTypes
   end
 
   class Struct < BaseType
+
+    def [](key)
+      return @mapping[key]
+    end
+
     def ==(otherType)
       return false unless otherType.class == BareTypes::Struct
       @mapping.each do |k, v|
@@ -373,16 +440,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
@@ -391,7 +473,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
@@ -418,8 +500,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
 
@@ -451,11 +543,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
@@ -467,7 +569,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)
@@ -496,6 +598,10 @@ class BareTypes
       return true
     end
 
+
+    def finalize_references(schema)
+    end
+
     def intToVal
       @intToVal
     end
@@ -503,9 +609,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 EnumValueError("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
@@ -514,7 +620,7 @@ 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bare-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Nate Tracy-Amoroso