bare-rb 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e8e36acbdcc47dc92e23a029edf5fac7001fbec9bd4948549cc0e682ea238b0
-  data.tar.gz: 86ffe342e8f2ec768b6fb222fe3575dd35eda7500ee88cff7111056a8bd422d5
+  metadata.gz: bbfb767287130c73249bf016a4bc3b4d9b6bd44e82ce8e7d9e3557ee6c58e7b3
+  data.tar.gz: aee2d8ab8457356c7e544dbd31c6f81d05c9655ab3138ddfe7315ab221d16ea0
 SHA512:
-  metadata.gz: 555833846daa3aa6337fb836b3a7959d656dd329c3925bceb01ab27d6f873bde95e83bf965daea90f3429c73b8659b40929f6f9e1b138a631c85966910750ee2
-  data.tar.gz: 0f9b6ef29fd8731c688f8507d6b141e2bb0992b0074b7118cb8b13a9263b57aad9e30becbb990c94d6cc33792abad805a3cd4a44d8deab93ee3847a8de57e68a
+  metadata.gz: e1d6c44757bcdd9f6811bf0107e7b13d68703e6616faef2029b09f2273ae75168eff02091f13cddfd6c5e5b9499db5efe2d7cf72d88c3c0e001a0da00b4c602f
+  data.tar.gz: e38a97985800775f0aa995db17ad9b8ea6a1294e12f0e0fd5cc60008359d286af6ec173bad63d190436bbd0bea876ff590e0a1fcac6099bd394ce9790bac1798

data/lib/bare-rb.rb

@@ -2,66 +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 schema you want to encode as a symbol.\nBare.encode(msg, schema, :Type)") if type.nil?
-      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?
-      value, rest = schema[type].decode(msg)
+  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, rest = schema.decode(msg)
-      return 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)
-      @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
+    BareTypes::Schema.new(hash)
   end
 
   # These classes are wrapped in methods for ergonomics.
@@ -162,7 +161,4 @@ class Bare
   def self.Enum(*opts)
     return BareTypes::Enum.new(*opts)
   end
-
-
 end
-

data/lib/exceptions.rb

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

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,7 +3,8 @@ 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
@@ -46,7 +47,7 @@ def lexer(path)
         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)
+      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)

data/lib/parser.rb

@@ -132,7 +132,7 @@ class Parser
         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]
+        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