bare-rb 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdfcd51a2a757a2cb2c532d1281afe227150518a6feb625466a5f25fac16b84b
-  data.tar.gz: ca3ed0f25556c996c62ff70a31ef3c50d9a3e6cad0d712eb8e428013a5af0af3
+  metadata.gz: bbfb767287130c73249bf016a4bc3b4d9b6bd44e82ce8e7d9e3557ee6c58e7b3
+  data.tar.gz: aee2d8ab8457356c7e544dbd31c6f81d05c9655ab3138ddfe7315ab221d16ea0
 SHA512:
-  metadata.gz: 222f83030bee145a42b3ae2ef890316f4969502f3a8e9704e3b84ffadaab0866d71163bf97b0d3f90ec02a065336343b20149375b9e628c646d8b342d0e5b27d
-  data.tar.gz: e757dbf048dd0f65392561a9034b3407d2fe9e2e942bcf181b3c7a25847a03e9eb515b66ef74b23115b37a94751daeae04eb4190b218a0c2dcbe2ab988ca3256
+  metadata.gz: e1d6c44757bcdd9f6811bf0107e7b13d68703e6616faef2029b09f2273ae75168eff02091f13cddfd6c5e5b9499db5efe2d7cf72d88c3c0e001a0da00b4c602f
+  data.tar.gz: e38a97985800775f0aa995db17ad9b8ea6a1294e12f0e0fd5cc60008359d286af6ec173bad63d190436bbd0bea876ff590e0a1fcac6099bd394ce9790bac1798

data/lib/bare-rb.rb

@@ -2,22 +2,65 @@ require 'set'
 require_relative "types"
 require_relative "lexer"
 require_relative "parser"
+require_relative 'dfs'
+require_relative 'generative_testing/gen'
+require_relative 'generative_testing/monkey_patch'
 
 class Bare
+  def self.encode(msg, schema, type = nil)
+    buffer = "".b
+    if schema.is_a?(BareTypes::Schema)
+      raise NoTypeProvided.new("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?
+      unless schema.types.include?(type)
+        raise("#{type} is not a type found in this schema. Choose from #{schema.types.keys}")
+      end
+      schema[type].encode(msg, buffer)
+    else
+      schema.encode(msg, buffer)
+    end
+    buffer
+  end
+
+  def self.decode(msg, schema, type = nil)
+    if schema.is_a?(BareTypes::Schema)
+      raise NoTypeProvided.new("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, _ = schema[type].decode(msg)
+      value
+    else
+      value, _ = schema.decode(msg)
+      value
+    end
+  end
+
+  # Returns a schema and a binary input
+  # optionally write these to files
+  def self.generative_test(schema_path=nil, binary_path=nil)
+    schema = BareTypes::Schema.make
+    input = schema.create_input
+    key = schema.types.keys[0]
+    binary = Bare.encode(input[key], schema, key)
+    unless binary_path.nil?
+      file = File.open(binary_path, 'wb+')
+      file.write(binary)
+      file.close
+    end
+    unless schema_path.nil?
+      file = File.open(schema_path, 'w+')
+      file.write(schema.to_s)
+      file.close
+    end
+    return schema, binary, key
+  end
 
   def self.parse_schema(path)
-    # Hash of class names to BARE ASTs
+    # Hash of class names to BARE types
     # Eg. types['Customer'] == Bare.i32
-    types = parser(lexer(path))
-    return types
-  end
-
-  def self.encode(msg, schema)
-    return schema.encode(msg)
+    parsed = parser(lexer(path))
+    Bare.Schema(parsed)
   end
 
-  def self.decode(msg, schema)
-    return schema.decode(msg)[:value]
+  def self.Schema(hash)
+    BareTypes::Schema.new(hash)
   end
 
   # These classes are wrapped in methods for ergonomics.
@@ -119,4 +162,3 @@ class Bare
     return BareTypes::Enum.new(*opts)
   end
 end
-

data/lib/exceptions.rb

@@ -5,6 +5,36 @@ class BareException < StandardError
   end
 end
 
+class InvalidBool < BareException
+  def initialize(msg = nil)
+    super
+  end
+end
+
+class CircularSchema < BareException
+  def initialize(msg = nil)
+    super
+  end
+end
+
+class ReferenceException < BareException
+  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

data/lib/generative_testing/gen.rb

@@ -0,0 +1,26 @@
+require_relative '../bare-rb'
+require_relative './monkey_patch'
+require_relative './grammar_util'
+
+def get_type(depth, names = [], can_be_symbol = true)
+  if names.size == 0
+    can_be_symbol = false
+  end
+  terminators = [BareTypes::Data, BareTypes::DataFixedLen,
+                 BareTypes::U8, BareTypes::U16, BareTypes::U32, BareTypes::U64,
+                 BareTypes::I8, BareTypes::I16, BareTypes::I32, BareTypes::I64,
+                 BareTypes::F32, BareTypes::F64]
+  aggregates = [BareTypes::Array, BareTypes::ArrayFixedLen,
+                BareTypes::Struct]
+
+  all = terminators + aggregates
+
+  # 1/5 changes of a reference
+  if rand(5) == 0 && names.size != 1 && can_be_symbol
+    names[rand(names.size)]
+  elsif depth >= 10 # if depth >= 10 only use terminating types
+    all[rand(terminators.size)].make(depth + 1, names)
+  else
+    all[rand(all.size)].make(depth + 1, names)
+  end
+end

data/lib/generative_testing/grammar_util.rb

@@ -0,0 +1,22 @@
+def create_user_type_name
+  upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  lower  = upper.downcase
+  digit = "0123456789"
+
+  name = upper[rand(upper.size)]
+  loop do
+    if rand(50) < 5
+      break
+    end
+    num = rand(3)
+    if num  == 0
+      name << upper[rand(upper.size)]
+    elsif num == 1
+      name << lower[rand(lower.size)]
+    else
+      name << digit[rand(digit.size)]
+    end
+  end
+  name.to_sym
+end
+

data/lib/generative_testing/monkey_patch.rb

@@ -0,0 +1,262 @@
+require_relative '../bare-rb'
+require_relative './grammar_util'
+
+# 10MB max data size
+DATA_MAX_SIZE = 30000
+ARRAY_MAX_SIZE = 40
+STRUCT_FIELDS_MAX = 5
+
+# Monkey patch every bare class to include make and create_input
+# make - a factory to create a random variant of the bare class
+# create_input - creates an input that could be used with Bare.Encode for this type
+
+class BareTypes::Reference
+  def create_input
+    self.ref.create_input
+  end
+
+  def self.make(depth, names)
+    self.ref.make(depth, names)
+  end
+end
+
+# region Integers
+class BareTypes::U8
+  def self.make(depth, names)
+    BareTypes::U8.new
+  end
+
+  def create_input
+    rand(256)
+  end
+end
+
+class BareTypes::U16
+  def self.make(depth, names)
+    BareTypes::U16.new
+  end
+
+  def create_input
+    rand(2 ** 16)
+  end
+end
+
+class BareTypes::U32
+  def self.make(depth, names)
+    BareTypes::U32.new
+  end
+
+  def create_input
+    rand(2 ** 32)
+  end
+end
+
+class BareTypes::U64
+  def self.make(depth, names)
+    BareTypes::U64.new
+  end
+
+  def create_input
+    rand(2 ** 64)
+  end
+end
+
+class BareTypes::I8
+  def self.make(depth, names)
+    BareTypes::I8.new
+  end
+
+  def create_input
+    rand(2 ** 8) - (2 ** 7)
+  end
+end
+
+class BareTypes::I16
+  def self.make(depth, names)
+    BareTypes::I16.new
+  end
+
+  def create_input
+    rand(2 ** 16) - (2 ** 15)
+  end
+end
+
+class BareTypes::I32
+  def self.make(depth, names)
+    BareTypes::I32.new
+  end
+
+  def create_input
+    rand(2 ** 32) - (2 ** 31)
+  end
+end
+
+class BareTypes::I64
+  def self.make(depth, names)
+    BareTypes::I64.new
+  end
+
+  def create_input
+    rand(2 ** 64) - (2 ** 63)
+  end
+end
+
+# endregion
+
+#region Floats
+class BareTypes::F32
+  def self.make(depth, names)
+    self.new
+  end
+
+  def create_input
+    float = nil
+    loop do
+      input = [rand(266), rand(266), rand(266), rand(266)]
+      float = input.pack("cccc").unpack('e')
+      if float[0] == float[0] && !float[0].nan?
+        break
+      end
+    end
+    float[0]
+  end
+end
+
+class BareTypes::F64
+  def self.make(depth, names)
+    self.new
+  end
+
+  def create_input
+    float = nil
+    loop do
+      input = [rand(266), rand(266), rand(266), rand(266), rand(266), rand(266), rand(266), rand(266)]
+      float = input.pack("cccccccc").unpack('E')
+      if float[0] == float[0] && !float[0].nan?
+        break
+      end
+    end
+    float[0]
+  end
+end
+
+#endregion
+
+#region Data
+class BareTypes::DataFixedLen
+  def self.make(depth, names)
+    length = rand(max = DATA_MAX_SIZE) + 1
+    self.new(length)
+  end
+
+  def create_input
+    # 100 random bytes
+    arr = []
+    0.upto(length - 1).each do |i|
+      arr << i % 256
+    end
+    arr.pack('c*')
+  end
+end
+
+class BareTypes::Data
+  def self.make(depth, names)
+    self.new
+  end
+
+  def create_input
+    arr = []
+    0.upto(rand(DATA_MAX_SIZE)).each do |i|
+      arr << i % 256
+    end
+    arr.pack('c*')
+  end
+end
+
+#endregion
+
+#region Array
+class BareTypes::Array
+  def self.make(depth, names)
+    BareTypes::Array.new(get_type(depth + 1, names))
+  end
+
+  def create_input
+    count = rand(ARRAY_MAX_SIZE) + 1
+    arr = []
+    0.upto(count) do
+      arr << @type.create_input
+    end
+    arr
+  end
+end
+
+class BareTypes::ArrayFixedLen
+  def self.make(depth, names)
+    self.new(get_type(depth + 1, names,), rand(ARRAY_MAX_SIZE) + 1)
+  end
+
+  def create_input
+    arr = []
+    0.upto(@size - 1) do
+      arr << @type.create_input
+    end
+    arr
+  end
+end
+
+#endregion
+
+#region Agg Types
+
+class BareTypes::Struct
+  def self.make(depth, names)
+    hash = {}
+    0.upto(rand(STRUCT_FIELDS_MAX) + 1) do
+      hash[create_user_type_name.to_sym] = get_type(depth + 1, names)
+    end
+    self.new(hash)
+  end
+
+  def create_input
+    input = {}
+    @mapping.keys.each do |name|
+      input[name] = @mapping[name].create_input
+    end
+    input
+  end
+end
+
+# endregion
+
+class BareTypes::Schema
+  def create_input
+    input = {}
+    @types.each do |key, type|
+      input[key] = type.create_input
+    end
+    input
+  end
+
+  def self.make
+    schema = nil
+    loop do
+      names = []
+      schema = {}
+      0.upto(rand(10)+1) do
+        names << create_user_type_name.to_sym
+      end
+      names.each do |name|
+        without_this_name = names.select { |n| n != name }
+        schema[name] = get_type(0, without_this_name, false)
+      end
+      begin
+        schema = Bare.Schema(schema)
+      rescue CircularSchema
+        next
+      end
+      break
+    end
+    schema
+  end
+end

data/lib/lexer.rb

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

data/lib/parser.rb

@@ -38,55 +38,103 @@ class Parser
         name = tokens[0]
         int_repr = tokens[2]
         enum_hash[int_repr] = name
-        tokens = tokens[3..]
+        tokens = tokens[3..tokens.size]
       else
         enum_hash[count] = tokens[0]
         count += 1
-        tokens = tokens[1..]
+        tokens = tokens[1..tokens.size]
       end
     end
     enum = Bare.Enum(enum_hash)
-    return tokens[1..], enum
+    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, type = self.parse(tokens[2..tokens.size])
       struct_fields[name.to_sym] = type
     end
-    return tokens[1..], struct_fields
+    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, type = self.parse(tokens[2..tokens.size])
         @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)
+        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("Enum must be followed by a '{'") if tokens[2] != :open_block
-        tokens, enum = parse_enum(tokens[3..])
+        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
-        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..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
-        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..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, 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..], type
+        return tokens[1..tokens.size], type
+      elsif @definitions.keys.include?(tokens[0].to_sym) # User defined type
+        return tokens[1..tokens.size], 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