bare-rb 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f26e016e563ad7dbbd4770b7f9c01911f0388fc1c48f7d4b47f937cb8ce53d
-  data.tar.gz: 5f61e5e1ff4fec292475bbdf8d14163e8b32607e6ef707c562c9a0afd29ae772
+  metadata.gz: 1e8e36acbdcc47dc92e23a029edf5fac7001fbec9bd4948549cc0e682ea238b0
+  data.tar.gz: 86ffe342e8f2ec768b6fb222fe3575dd35eda7500ee88cff7111056a8bd422d5
 SHA512:
-  metadata.gz: f3313e886d04c612bf20b299f98c42b7e3a2f415d0db8aa502fe820f751def52e21ee1bd77e75e51bbdb687e3d7c4e01cac9c7f0350cad776c9a15e8e4ca1d25
-  data.tar.gz: e77051e381214e378e0f9140716da5ef02bcd0757834fc69a7362221107900ce9e96c0bfc31e0dabee23bd751d465ac236a7a103d0a2c744669184baaf2a72f6
+  metadata.gz: 555833846daa3aa6337fb836b3a7959d656dd329c3925bceb01ab27d6f873bde95e83bf965daea90f3429c73b8659b40929f6f9e1b138a631c85966910750ee2
+  data.tar.gz: 0f9b6ef29fd8731c688f8507d6b141e2bb0992b0074b7118cb8b13a9263b57aad9e30becbb990c94d6cc33792abad805a3cd4a44d8deab93ee3847a8de57e68a

data/lib/bare-rb.rb

@@ -6,8 +6,8 @@ require_relative "parser"
 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)
+      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)
     else
       schema.encode(msg)
     end
@@ -16,9 +16,11 @@ class Bare
   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]
+      value, rest = schema[type].decode(msg)
+      value
     else
-      schema.decode(msg)[:value]
+      value, rest = schema.decode(msg)
+      return value
     end
   end
 
@@ -34,10 +36,9 @@ class Bare
   end
 
   class Schema
-
     def ==(otherSchema)
       return false unless otherSchema.is_a?(Bare::Schema)
-      return @types == otherSchema.types
+      @types == otherSchema.types
     end
 
     def types
@@ -54,8 +55,9 @@ class Bare
         if @types[key].is_a?(Symbol)
           @types[key] = @types[@types[key]]
         else
-          # Users may user symbols to reference not yet defined types
+          # 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

data/lib/exceptions.rb

@@ -5,6 +5,12 @@ class BareException < StandardError
   end
 end
 
+class FixedDataSizeWrong < BareException
+  def initialize(msg=nil)
+    super
+  end
+end
+
 class NoTypeProvided < BareException
   def initialize(msg = nil)
     super

data/lib/lexer.rb

@@ -10,48 +10,48 @@ def lexer(path)
       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)
         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], @definitions[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

data/lib/types.rb

@@ -10,6 +10,7 @@ class BareTypes
   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)
@@ -33,10 +34,9 @@ class BareTypes
     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]}
+      value, rest = Uint.new.decode(msg)
+      value = value.odd? ? (value + 1) / -2 : value / 2
+      return  value, rest
     end
   end
 
@@ -46,17 +46,17 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: nil, rest: msg}
+      return nil, msg
     end
   end
 
   class F32 < BarePrimitive
     def encode(msg)
-      return [msg].pack("e")
+      [msg].pack("e")
     end
 
     def decode(msg)
-      return {value: msg.unpack("e")[0], rest: msg[4..msg.size]}
+      return msg.unpack("e")[0], msg[4..msg.size]
     end
   end
 
@@ -66,7 +66,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack("E")[0], rest: msg[8..msg.size]}
+      return msg.unpack("E")[0], msg[8..msg.size]
     end
   end
 
@@ -84,10 +84,9 @@ class BareTypes
     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]}
+      strLen, rest = Uint.new.decode(msg)
+      string = rest[0..strLen - 1]
+      return string.force_encoding("utf-8"), rest[strLen..rest.size]
     end
   end
 
@@ -119,7 +118,7 @@ class BareTypes
       if msg.nil?
         return "\x00".b
       else
-        bytes = "\xFF".b
+        bytes = "\x01".b
         bytes << @optionalType.encode(msg)
         return bytes
       end
@@ -127,7 +126,7 @@ class BareTypes
 
     def decode(msg)
       if msg.unpack("C")[0] == 0
-        return {value: nil, rest: msg[1..msg.size]}
+        return nil, msg[1..msg.size]
       else
         return @optionalType.decode(msg[1..msg.size])
       end
@@ -179,15 +178,13 @@ class BareTypes
 
     def decode(msg)
       hash = Hash.new
-      output = Uint.new.decode(msg)
-      mapSize = output[:value]
+      mapSize, rest = Uint.new.decode(msg)
       (mapSize - 1).to_i.downto(0) do
-        output = @from.decode(output[:rest])
-        key = output[:value]
-        output = @to.decode(output[:rest])
-        hash[key] = output[:value]
+        key, rest = @from.decode(rest)
+        value, rest = @to.decode(rest)
+        hash[key] = value
       end
-      return {value: hash, rest: output[:rest]}
+      return hash, rest
     end
   end
 
@@ -244,11 +241,10 @@ class BareTypes
     end
 
     def decode(msg)
-      unionTypeInt = Uint.new.decode(msg)
-      int = unionTypeInt[:value]
+      int, rest = Uint.new.decode(msg)
       type = @intToType[int]
-      value = type.decode(unionTypeInt[:rest])
-      return {value: {value: value[:value], type: type}, rest: value[:rest]}
+      value, rest = type.decode(rest)
+      return {value: value, type: type}, rest
     end
   end
 
@@ -270,11 +266,14 @@ class BareTypes
     end
 
     def encode(msg)
-      return msg
+      if msg.size != @length
+        raise FixedDataSizeWrong.new("Message is not proper sized for DataFixedLen should have been #{@length} but was #{msg.size}")
+      end
+      msg
     end
 
     def decode(msg)
-      return {value: msg[0..@length], rest: msg[@length..msg.size]}
+      return msg[0..@length], msg[@length..msg.size]
     end
   end
 
@@ -290,10 +289,8 @@ class BareTypes
     end
 
     def decode(msg)
-      output = Uint.new.decode(msg)
-      rest = output[:rest]
-      dataSize = output[:value]
-      return {value: rest[0..dataSize - 1], rest: rest[dataSize..]}
+      dataSize, rest = Uint.new.decode(msg)
+      return rest[0..dataSize - 1], rest[dataSize..rest.size]
     end
   end
 
@@ -320,7 +317,7 @@ class BareTypes
     end
 
     def decode(msg)
-      ints = msg.unpack("CCCCCCCCC")
+      ints = msg.unpack("CCCCCCCC")
       relevantInts = []
       i = 0
       while ints[i] & 0b10000000 == 128
@@ -332,7 +329,7 @@ class BareTypes
       relevantInts.each_with_index do |int, idx|
         sum += int << (idx * 7)
       end
-      return {value: sum, rest: msg[(i + 1)..msg.size]}
+      return sum, msg[(i + 1)..msg.size]
     end
   end
 
@@ -342,7 +339,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg[0].unpack("C")[0], rest: msg[1..msg.size]}
+      return msg[0].unpack("C")[0], msg[1..msg.size]
     end
   end
 
@@ -352,7 +349,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack("v")[0], rest: msg[2..msg.size]}
+      return msg.unpack("v")[0], msg[2..msg.size]
     end
   end
 
@@ -362,7 +359,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack("V")[0], rest: msg[4..msg.size]}
+      return msg.unpack("V")[0], msg[4..msg.size]
     end
   end
 
@@ -372,7 +369,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack("Q")[0], rest: [8..msg.size]}
+      return msg.unpack("Q")[0], msg[8..msg.size]
     end
   end
 
@@ -382,7 +379,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg[0].unpack("c")[0], rest: msg[1..msg.size]}
+      return msg[0].unpack("c")[0], msg[1..msg.size]
     end
   end
 
@@ -392,7 +389,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack('s<')[0], rest: msg[2..msg.size]}
+      return msg.unpack('s<')[0], msg[2..msg.size]
     end
   end
 
@@ -402,7 +399,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack('l<')[0], rest: msg[4..msg.size]}
+      return msg.unpack('l<')[0], msg[4..msg.size]
     end
   end
 
@@ -412,7 +409,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg.unpack('q<')[0], rest: msg[8..msg.size]}
+      return msg.unpack('q<')[0], msg[8..msg.size]
     end
   end
 
@@ -422,7 +419,7 @@ class BareTypes
     end
 
     def decode(msg)
-      return {value: msg == "\x00\x00" ? false : true, rest: msg[1..msg.size]}
+      return (msg == "\x00\x00" ? false : true), msg[1..msg.size]
     end
   end
 
@@ -483,11 +480,10 @@ class BareTypes
       hash = Hash.new
       rest = msg
       @mapping.keys.each do |symbol|
-        output = @mapping[symbol].decode(rest)
-        hash[symbol] = output[:value]
-        rest = output[:rest]
+        value, rest = @mapping[symbol].decode(rest)
+        hash[symbol] = value
       end
-      return {value: hash, rest: rest}
+      return hash, rest
     end
   end
 
@@ -524,17 +520,16 @@ class BareTypes
     end
 
     def decode(msg)
-      output = Uint.new.decode(msg)
       arr = []
-      arrayLen = output[:value]
+      arrayLen, rest = Uint.new.decode(msg)
       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
+        arrVal, rest = @type.decode(rest)
+        arr << arrVal
+        break if rest.nil? || rest.size == 0 || lastSize <= rest.size
+        lastSize = rest.size
       end
-      return {value: arr, rest: output[:rest]}
+      return arr, rest
     end
   end
 
@@ -577,15 +572,13 @@ class BareTypes
       return bytes
     end
 
-    def decode(msg)
+    def decode(rest)
       array = []
-      rest = msg
       @size.times do
-        output = @type.decode(rest)
-        rest = output[:rest]
-        array << output[:value]
+        arrVal, rest = @type.decode(rest)
+        array << arrVal
       end
-      return {value: array, rest: rest}
+      return array, rest
     end
   end
 
@@ -627,10 +620,8 @@ class BareTypes
     end
 
     def decode(msg)
-      output = BareTypes::Uint.new.decode(msg)
-      value = output[:value]
-      rest = output[:rest]
-      return {value: @intToVal[value], rest: rest}
+      value, rest = BareTypes::Uint.new.decode(msg)
+      return @intToVal[value], rest
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bare-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Nate Tracy-Amoroso
@@ -11,7 +11,7 @@ cert_chain: []
 date: 2020-10-13 00:00:00.000000000 Z
 dependencies: []
 description: The first implementation of the BARE (Binary Application Record Encoding)
-  in Ruby. Includes schema parsing!
+  in Ruby. Includes schema parsing and compatibility tests.
 email: n8@u.northwestern.edu
 executables: []
 extensions: []