bare-rb 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: adea5476cd77af659cb3329602479f8b80b59d0b7459dc7cf343165b7096d871
+  data.tar.gz: 2e3f86206cc9519cd654dfcf28972a5c5c5b4fc5966143699d74f22209373088
+SHA512:
+  metadata.gz: e19625e2170ed457390a6f6d06d68a67443c91f057b5310363e49d6a8c5102bb41ae068fba67f3eaecbe11f2f984bc54eae81f02c39a5222f07887920e39f8af
+  data.tar.gz: 0e502b379a427ac5c493f0f02a8b17ab6821560adf248fccbcfac2dc31e406f08c1f29816970a50b5d82589ffdbb6f4fca2940b4e2eacda39633a95b50d58b69

data/lib/bare-rb.rb

@@ -0,0 +1,112 @@
+require 'set'
+require_relative "types"
+
+class Bare
+  def self.encode(msg, schema)
+    return schema.encode(msg)
+  end
+
+  def self.decode(msg, schema)
+    return schema.decode(msg)[:value]
+  end
+
+  # These classes are wrapped in methods for ergonomics.
+  # Isn't Bare.Array(Bare.U8) nicer than Bare::Array.new(Bare::U8.new)?
+
+  def self.Int
+    return BareTypes::Int.new
+  end
+
+  def self.Void
+    return BareTypes::Void.new
+  end
+
+  def self.F32
+    return BareTypes::F32.new
+  end
+
+  def self.F64
+    return BareTypes::F64.new
+  end
+
+  def self.String
+    return BareTypes::String.new
+  end
+
+  def self.U8
+    return BareTypes::U8.new
+  end
+
+  def self.U16
+    return BareTypes::U16.new
+  end
+
+  def self.U32
+    return BareTypes::U32.new
+  end
+
+  def self.U64
+    return BareTypes::U64.new
+  end
+
+  def self.I8
+    return BareTypes::I8.new
+  end
+
+  def self.I16
+    return BareTypes::I16.new
+  end
+
+  def self.I32
+    return BareTypes::I32.new
+  end
+
+  def self.I64
+    return BareTypes::I64.new
+  end
+
+  def self.Optional(*opts)
+    return BareTypes::Optional.new(*opts)
+  end
+
+  def self.Map(*opts)
+    return BareTypes::Map.new(*opts)
+  end
+
+  def self.Union(*opts)
+    return BareTypes::Union.new(*opts)
+  end
+
+  def self.DataFixedLen(*opts)
+    return BareTypes::DataFixedLen.new(*opts)
+  end
+
+  def self.Data
+    return BareTypes::Data.new
+  end
+
+  def self.Uint
+    return BareTypes::Uint.new
+  end
+
+  def self.Bool
+    return BareTypes::Bool.new
+  end
+
+  def self.Struct(*opts)
+    return BareTypes::Struct.new(*opts)
+  end
+
+  def self.Array(*opts)
+    return BareTypes::Array.new(*opts)
+  end
+
+  def self.ArrayFixedLen(*opts)
+    return BareTypes::ArrayFixedLen.new(*opts)
+  end
+
+  def self.Enum(*opts)
+    return BareTypes::Enum.new(*opts)
+  end
+end
+

data/lib/exceptions.rb

@@ -0,0 +1,40 @@
+class BareException < StandardError
+  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
+  end
+end
+
+class MinimumSizeError < BareException
+  def initialize(msg = "Schema object has minimum size of 1")
+    super
+  end
+end
+class MaximumSizeError < BareException
+  def initialize(msg = "Object too large to encode as given type")
+    super
+  end
+end
+
+class MapKeyError < BareException
+  def initialize(msg = "Map keys must be a none data or data[len] primitive")
+    super
+  end
+end
+
+class EnumValueError < BareException
+  def initialize(msg = "Enums cannot have two identical values")
+    super
+  end
+end
+
+class SchemaMismatch < BareException
+  def initialize(msg = "Some mismatch between data and schema has occurred")
+    super
+  end
+end

data/lib/types.rb

@@ -0,0 +1,544 @@
+require_relative './exceptions'
+
+class BareTypes
+
+  class BaseType
+  end
+
+  class BarePrimitive < BaseType
+    # Types which are always equivalent to another instantiation of themselves
+    # 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
+  end
+
+  class Int < BarePrimitive
+    # https://developers.google.com/protocol-buffers/docs/encoding
+    # Easy to just convert to signed and re-use uint code
+    def encode(msg)
+      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] }
+    end
+  end
+
+  class Void < BarePrimitive
+    def encode(msg)
+      return "".b
+    end
+    def decode(msg)
+      return {value: nil, rest: msg}
+    end
+  end
+
+  class F32 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("e")
+    end
+    def decode(msg)
+      return {value: msg.unpack("e")[0], rest: msg[4..msg.size]}
+    end
+  end
+
+  class F64 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("E")
+    end
+    def decode(msg)
+      return {value: msg.unpack("E")[0], rest: msg[8..msg.size]}
+    end
+  end
+
+  class String < BarePrimitive
+    def encode(msg)
+      encodedString = nil
+      begin
+        encodedString = msg.encode("UTF-8").b
+      rescue Encoding::UndefinedConversionError => error
+        raise error.class, "Unable to convert string to UTF-8=, BARE strings are encoded as UTF8. If you can't convert your string to UTF-8 you can encode it with binary data"
+      end
+      bytes = Uint.new.encode(encodedString.size)
+      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] }
+    end
+  end
+
+  class Optional < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::Optional && otherType.optionalType == @optionalType
+    end
+
+    def optionalType
+      @optionalType
+    end
+
+    def initialize(optionalType)
+      raise VoidUsedOutsideTaggedSet() if optionalType.class == BareTypes::Void
+      @optionalType = optionalType
+    end
+
+    def encode(msg)
+      if msg.nil?
+        return "\x00".b
+      else
+        bytes = "\xFF".b
+        bytes << @optionalType.encode(msg)
+        return bytes
+      end
+    end
+
+    def decode(msg)
+      if msg.unpack("C")[0] == 0
+        return {value: nil, rest: msg[1..msg.size]}
+      else
+        return @optionalType.decode(msg[1..msg.size])
+      end
+    end
+  end
+
+  class Map < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::Map && otherType.from == @from && otherType.to == @to
+    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)
+      @from = fromType
+      @to = toType
+    end
+
+    def from
+      @from
+    end
+
+    def to
+      @to
+    end
+
+    def encode(msg)
+      bytes = Uint.new.encode(msg.size)
+      msg.each do |from, to|
+        bytes << @from.encode(from)
+        bytes << @to.encode(to)
+      end
+      return bytes
+    end
+
+    def decode(msg)
+      hash = Hash.new
+      output = Uint.new.decode(msg)
+      mapSize = output[:value]
+      (mapSize - 1).to_i.downto(0) do
+        output = @from.decode(output[:rest])
+        key = output[:value]
+        output = @to.decode(output[:rest])
+        hash[key] = output[:value]
+        hash[key] = output[:value]
+      end
+      return {value: hash, rest: output[:rest]}
+    end
+  end
+
+  class Union < BarePrimitive
+    def intToType
+      @intToType
+    end
+
+    def ==(otherType)
+      return false unless otherType.is_a?(BareTypes::Union)
+      @intToType.each do |int, type|
+        return false unless type == otherType.intToType[int]
+      end
+      return true
+    end
+
+    def initialize(intToType)
+      intToType.keys.each do |i|
+        raise MinimumSizeError("Union's integer representations must be > 0, instead got: #{i}") if i < 0 or !i.is_a?(Integer)
+      end
+      raise MinimumSizeError("Union must have at least one type") if intToType.keys.size < 1
+      @intToType = intToType
+    end
+
+    def encode(msg)
+      type = msg[:type]
+      value = msg[:value]
+      unionTypeInt = nil
+      unionType = nil
+      @intToType.each do |int, typ|
+        if type.class == typ.class
+          unionTypeInt = int
+          unionType = typ
+          break
+        end
+      end
+      raise SchemaMismatch("Unable to find given type in union: #{@intToType.inspect}, type: #{type}") if unionType.nil? || unionTypeInt.nil?
+      bytes = Uint.new.encode(unionTypeInt)
+      encoded = unionType.encode(value)
+      bytes << encoded
+    end
+
+    def decode(msg)
+      unionTypeInt = Uint.new.decode(msg)
+      int = unionTypeInt[:value]
+      type = @intToType[int]
+      value = type.decode(unionTypeInt[:rest])
+      return {value: {value: value[:value], type: type}, rest: value[:rest]}
+    end
+  end
+
+  class DataFixedLen < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::DataFixedLen && otherType.length == self.length
+    end
+
+    def length
+      return @length
+    end
+
+    def initialize(length)
+      raise MinimumSizeError("DataFixedLen must have a length greater than 0, got: #{length.inspect}") if length < 1
+      @length = length
+    end
+
+    def encode(msg)
+      return msg
+    end
+
+    def decode(msg)
+      return {value: msg[0..@length], rest: msg[@length..msg.size]}
+    end
+  end
+
+  class Data < BarePrimitive
+    def encode(msg)
+      bytes = Uint.new.encode(msg.size)
+      bytes << msg
+      return bytes
+    end
+
+    def decode(msg)
+      output = Uint.new.decode(msg)
+      rest = output[:rest]
+      dataSize = output[:value]
+      return {value: rest[0..dataSize], rest: rest[dataSize..rest.size]}
+    end
+  end
+
+  class Uint < BarePrimitive
+    def encode(msg)
+      bytes = "".b
+      _get_next_7_bits_as_byte(msg, 128) do |byte|
+        bytes << byte
+      end
+      (bytes.size - 1).downto(0) do |i|
+        if bytes.bytes[i] == 128 && bytes.size > 1
+          bytes = bytes.chop
+        else
+          break
+        end
+      end
+      bytes[bytes.size - 1] = [bytes.bytes[bytes.size - 1] & 127].pack('C')[0]
+      raise MaximumSizeError("Maximum u/int allowed is 64 bit precision") if bytes.size > 9
+      return bytes
+    end
+
+    def decode(msg)
+      ints = msg.unpack("CCCCCCCCC")
+      relevantInts = []
+      i = 0
+      while ints[i] & 0b10000000 == 128
+        relevantInts << ints[i] % 128
+        i += 1
+      end
+      relevantInts << ints[i]
+      sum = 0
+      relevantInts.each_with_index do |int, idx|
+        sum += int << (idx * 7)
+      end
+      return {value: sum, rest: msg[(i + 1)..msg.size]}
+    end
+  end
+
+  class U8 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("C")
+    end
+
+    def decode(msg)
+      return {value: msg[0].unpack("C")[0], rest: msg[1..msg.size]}
+    end
+  end
+
+  class U16 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("v")
+    end
+
+    def decode(msg)
+      return {value: msg.unpack("v")[0], rest: msg[2..msg.size]}
+    end
+  end
+
+  class U32 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("V")
+    end
+
+    def decode(msg)
+      return {value: msg.unpack("V")[0], rest: msg[4..msg.size]}
+    end
+  end
+
+  class U64 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("Q")
+    end
+
+    def decode(msg)
+      return {value: msg.unpack("Q")[0], rest: [8..msg.size]}
+    end
+  end
+
+  class I8 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("c")
+    end
+
+    def decode(msg)
+      return {value: msg[0].unpack("c")[0], rest: msg[1..msg.size]}
+    end
+  end
+
+  class I16 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("s<")
+    end
+
+    def decode(msg)
+      return {value: msg.unpack('s<')[0], rest: msg[2..msg.size]}
+    end
+  end
+
+  class I32 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("l<")
+    end
+
+    def decode(msg)
+      return {value: msg.unpack('l<')[0], rest: msg[4..msg.size]}
+    end
+  end
+
+  class I64 < BarePrimitive
+    def encode(msg)
+      return [msg].pack("q<")
+    end
+
+    def decode(msg)
+      return {value: msg.unpack('q<')[0], rest: msg[8..msg.size]}
+    end
+  end
+
+  class Bool < BarePrimitive
+    def encode(msg)
+      return msg ? "\xFF\xFF".b : "\x00\x00".b
+    end
+
+    def decode(msg)
+      return {value: msg == "\x00\x00" ? false : true, rest: msg[1..msg.size]}
+    end
+  end
+
+  class Struct < BaseType
+    def ==(otherType)
+      return false unless otherType.class == BareTypes::Struct
+      @mapping.each do |k, v|
+        return false unless otherType.mapping[k] == v
+      end
+      return true
+    end
+
+    def mapping
+      @mapping
+    end
+
+    def initialize(symbolToType)
+      # Mapping from symbols to Bare types
+      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
+      end
+      raise("Struct must have at least one field") if symbolToType.keys.size == 0
+      @mapping = symbolToType
+    end
+
+    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)
+        bytes << @mapping[symbol].encode(msg[symbol])
+      end
+      return bytes
+    end
+
+    def decode(msg)
+      hash = Hash.new
+      rest = msg
+      @mapping.keys.each do |symbol|
+        output = @mapping[symbol].decode(rest)
+        hash[symbol] = output[:value]
+        rest = output[:rest]
+      end
+      return {value: hash, rest: rest}
+    end
+  end
+
+  class Array < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::Array && otherType.type == self.type
+    end
+
+    def type
+      return @type
+    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
+      @type = type
+    end
+
+    def encode(msg)
+      bytes = Uint.new.encode(msg.size)
+      msg.each do |item|
+        bytes << @type.encode(item)
+      end
+      return bytes
+    end
+
+    def decode(msg)
+      output = Uint.new.decode(msg)
+      arr = []
+      arrayLen = output[:value]
+      lastSize = msg.size + 1 # Make sure msg size monotonically decreasing
+      (arrayLen - 1).downto(0) do
+        output = @type.decode(output[:rest])
+        arr << output[:value]
+        break if output[:rest].nil? || output[:rest].size == 0 || lastSize <= output[:rest].size
+        lastSize = output[:rest].size
+      end
+      return {value: arr, rest: output[:rest]}
+    end
+  end
+
+  class ArrayFixedLen < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::ArrayFixedLen && otherType.type == @type && otherType.size == @size
+    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
+    end
+
+    def type
+      @type
+    end
+
+    def size
+      @size
+    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
+      bytes = ""
+      arr.each do |item|
+        bytes << @type.encode(item)
+      end
+      return bytes
+    end
+
+    def decode(msg)
+      array = []
+      rest = msg
+      @size.times do
+        output = @type.decode(rest)
+        rest = output[:rest]
+        array << output[:value]
+      end
+      return {value: array, rest: rest}
+    end
+  end
+
+  class Enum < BaseType
+    def ==(otherType)
+      return false unless otherType.class == BareTypes::Enum
+      @intToVal.each do |int, val|
+        return false unless otherType.intToVal[int] == val
+      end
+      return true
+    end
+
+    def intToVal
+      @intToVal
+    end
+
+    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 BareException("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
+        @valToInt[v] = k.to_i
+      end
+    end
+
+    def encode(msg)
+      raise SchemaMismatch("#{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
+    end
+
+    def decode(msg)
+      output = BareTypes::Uint.new.decode(msg)
+      value = output[:value]
+      rest = output[:rest]
+      return {value: @intToVal[value], rest: rest}
+    end
+  end
+end
+
+def _get_next_7_bits_as_byte(integer, base = 128)
+  # Base is the initial value of the byte before
+  # before |'ing it with 7bits from the integer
+  groups_of_7 = (integer.size * 8) / 7 + (integer.size % 7 == 0 ? 0 : 1)
+  0.upto(groups_of_7 - 1) do |group_number|
+    byte = base
+    0.upto(7).each do |bit_number|
+      byte = byte | (integer[group_number * 7 + bit_number] << bit_number)
+    end
+    yield(byte)
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: bare-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Nate Tracy-Amoroso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-10-13 00:00:00.000000000 Z
+dependencies: []
+description: Implements the bare message encoding and DSL in ruby
+email: n8@u.northwestern.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/bare-rb.rb"
+- "./lib/exceptions.rb"
+- "./lib/types.rb"
+homepage: https://none.none
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Bare Message Encoding Implementation
+test_files: []