bare-rb 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b1147744e8da154541d6591f1e78929ad90a57ba806541a03cc5e770b43af6b
-  data.tar.gz: 121a6ba57b86dc43f9e1b65145cc35e5c2174934e97bfdc142ddcd848f74deae
+  metadata.gz: 0206b2d45e4ea60de2e60934cda498eac9fd03c627f01455e6eb0a2e59163af9
+  data.tar.gz: 2477608d876cae8e775575dbd8f1f39db985414249c55c2d94c1251a569bdab5
 SHA512:
-  metadata.gz: 8490934a87328cf339307924d7268e71e0c4c58336021294c2e957d618ab871ecc1a7d05f07ae72025e214f0fab7b64df7d31d37c3b6cbea8687315a523cb7f0
-  data.tar.gz: d2930be08e535b50638eeda6814cd7d2e1544eead403a4f4efd81817cc54eb352a0e52575460f612ba9a5127949d61c6724c7a724e0feac3f7a2c9d54906da36
+  metadata.gz: 9d7430875487bff66b60e21b1893ada24df12bad88661b3dc06b3f71ab0f88877e6a24a08381f8180398ada99a31b2fc319f8880f676758db9bd767ad3d7321e
+  data.tar.gz: d2765a0a51f394ee02070b4ab3ceb56ac6c38793d3ee8ce020256df69302af016fcb4c435436ef93b25057d842d281a0cb5d20c8cea14c0621963da661fccc47

data/lib/bare-rb.rb

@@ -2,64 +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)
-    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)
+  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)
+      schema.encode(msg, buffer)
     end
+    buffer
   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]
+  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
-      schema.decode(msg)[:value]
+      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))
-    Bare.Schema(types)
+    parsed = parser(lexer(path))
+    Bare.Schema(parsed)
   end
 
   def self.Schema(hash)
-    Bare::Schema.new(hash)
-  end
-
-  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
+    BareTypes::Schema.new(hash)
   end
 
   # These classes are wrapped in methods for ergonomics.
@@ -160,7 +161,4 @@ class Bare
   def self.Enum(*opts)
     return BareTypes::Enum.new(*opts)
   end
-
-
 end
-

data/lib/exceptions.rb

@@ -5,6 +5,30 @@ 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

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[0].size)..]
+        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,15 +38,15 @@ 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)
@@ -55,13 +55,13 @@ class Parser
     # type A_UNION ( int | uint | data = 7 | f32 )
     while tokens[0] != :close_paren
       if tokens[0] == :bar
-        tokens = tokens[1..]
+        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 = tokens[2..tokens.size]
           union_hash[count] = type
           count += 1
         else
@@ -78,63 +78,63 @@ class Parser
     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.new("Map must be followed by a '[' eg. map[string]data") if tokens[1] != :open_brace
-        tokens, map_from_type = parse(tokens[2..])
+        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, 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..], Bare.DataFixedLen(tokens[2])
+        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, 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, 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..], Bare.Optional(optional_type)
+        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, arr_type = parse(tokens[3..tokens.size])
           return tokens, Bare.ArrayFixedLen(arr_type, size)
         else
-          tokens, arr_type = parse(tokens[2..])
+          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, 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..], Bare.Union(union_hash)
+        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..], @definitions[tokens[0].to_sym]
+        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[0].to_sym
+        return tokens[1..tokens.size], tokens[0].to_sym
       else
         raise SchemaParsingException.new("Unable to parse token: #{tokens[0]}")
       end