bare-rb 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c2f2e430da54e36517c4dafc490d8f7f74253da5ab94a51082c756ab839102d
-  data.tar.gz: 779417f3deccacd44d02d34725e77f257fad56d07f7d9fca7440faf9cd110138
+  metadata.gz: bdfcd51a2a757a2cb2c532d1281afe227150518a6feb625466a5f25fac16b84b
+  data.tar.gz: ca3ed0f25556c996c62ff70a31ef3c50d9a3e6cad0d712eb8e428013a5af0af3
 SHA512:
-  metadata.gz: 907dca97695a2b46770e931a07e3ed42ee87a7f502867bd73cac1402e259656790973f38b2a1880fd12e62ab612524e1e676364366cfe8508b0e64c484fd6b42
-  data.tar.gz: 485ec72d165baca3e683959336cc8b966b92eb378e7826a450b576ca56ad3b38e50950d77e2d64c15f7e983175bc3c2d5a6fbb4b11028f93ae04c173100decb4
+  metadata.gz: 222f83030bee145a42b3ae2ef890316f4969502f3a8e9704e3b84ffadaab0866d71163bf97b0d3f90ec02a065336343b20149375b9e628c646d8b342d0e5b27d
+  data.tar.gz: e757dbf048dd0f65392561a9034b3407d2fe9e2e942bcf181b3c7a25847a03e9eb515b66ef74b23115b37a94751daeae04eb4190b218a0c2dcbe2ab988ca3256

data/lib/bare-rb.rb

@@ -1,7 +1,17 @@
 require 'set'
 require_relative "types"
+require_relative "lexer"
+require_relative "parser"
 
 class Bare
+
+  def self.parse_schema(path)
+    # Hash of class names to BARE ASTs
+    # Eg. types['Customer'] == Bare.i32
+    types = parser(lexer(path))
+    return types
+  end
+
   def self.encode(msg, schema)
     return schema.encode(msg)
   end

data/lib/exceptions.rb

@@ -1,9 +1,16 @@
+
 class BareException < StandardError
   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..]
+      elsif /^</.match(line)
+        line = line[1..]
+        tokens << :less_than
+      elsif /^>/.match(line)
+        line = line[1..]
+        tokens << :greater_than
+        next
+      elsif /^{/.match(line)
+        line = line[1..]
+        tokens << :open_block
+      elsif /^=/.match(line)
+        line = line[1..]
+        tokens << :equal
+      elsif /^}/.match(line)
+        line = line[1..]
+        tokens << :close_block
+      elsif /^\[/.match(line)
+        line = line[1..]
+        tokens << :open_brace
+      elsif /^\]/.match(line)
+        line = line[1..]
+        tokens << :close_brace
+      elsif /^\(/.match(line)
+        line = line[1..]
+        tokens << :open_paren
+      elsif /^\)/.match(line)
+        line = line[1..]
+        tokens << :close_paren
+      elsif /^\|/.match(line)
+        line = line[1..]
+        tokens << :bar
+      elsif match = /^([0-9]+)/.match(line)
+        tokens << match[0].to_i
+        line = line[(match.size + 1)..]
+        next
+      elsif match = /^[a-z,A-Z,_][_,a-z,A-Z,0-9]+/.match(line)
+        tokens << match[0]
+        line = line[(match[0].size)..]
+      elsif /:/.match(line)
+        tokens << :colon
+        line = line[1..]
+      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,102 @@
+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..]
+      else
+        enum_hash[count] = tokens[0]
+        count += 1
+        tokens = tokens[1..]
+      end
+    end
+    enum = Bare.Enum(enum_hash)
+    return tokens[1..], enum
+  end
+
+  def parse_struct(tokens)
+    struct_fields = {}
+    while tokens.size >= 2 and tokens[1] == :colon
+      name = tokens[0]
+      tokens, type = self.parse(tokens[2..])
+      struct_fields[name.to_sym] = type
+    end
+    return tokens[1..], struct_fields
+  end
+
+  def parse(tokens)
+    while tokens.size > 0
+      if tokens[0] == "type"
+        name = tokens[1]
+        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
+        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
+        tokens, map_to_type = parse(tokens[1..])
+        return tokens, Bare.Map(map_from_type,map_to_type)
+      elsif tokens[0] == "enum"
+        name = tokens[1]
+        raise SchemaParsingException("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] == :open_brace
+        tokens, arr_type = parse(tokens[2..])
+        return tokens, Bare.Array(arr_type)
+      elsif tokens[0] == :open_block
+        tokens, struct_fields = parse_struct(tokens[1..])
+        strct = Bare.Struct(struct_fields)
+        return tokens, strct
+      elsif @primitives.include?(tokens[0])
+        type = @primitives[tokens[0]]
+        return tokens[1..], type
+      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

@@ -148,7 +148,6 @@ class BareTypes
         key = output[:value]
         output = @to.decode(output[:rest])
         hash[key] = output[:value]
-        hash[key] = output[:value]
       end
       return {value: hash, rest: output[:rest]}
     end
@@ -236,7 +235,7 @@ class BareTypes
       output = Uint.new.decode(msg)
       rest = output[:rest]
       dataSize = output[:value]
-      return {value: rest[0..dataSize], rest: rest[dataSize..rest.size]}
+      return {value: rest[0..dataSize-1], rest: rest[dataSize..]}
     end
   end
 
@@ -506,7 +505,7 @@ class BareTypes
       @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 EnumValueError("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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bare-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 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
+description: The first implementation of the BARE (Binary Application Record Encoding)
+  in Ruby. Includes schema parsing!
 email: n8@u.northwestern.edu
 executables: []
 extensions: []
@@ -18,6 +19,8 @@ extra_rdoc_files: []
 files:
 - "./lib/bare-rb.rb"
 - "./lib/exceptions.rb"
+- "./lib/lexer.rb"
+- "./lib/parser.rb"
 - "./lib/types.rb"
 homepage: https://github.com/n8ta/bare-rb
 licenses: