leon 1.0.0

data/lib/buffer-iterator.rb

@@ -0,0 +1,68 @@
+require 'constants'
+
+module LEON
+  class BufferIterator
+    def initialize(buf)
+      @buffer = buf
+      @i = 0
+    end
+    def readUInt8()
+      @i += 1
+      return @buffer.readUInt8(@i - 1)
+    end
+    def readInt8()
+      @i += 1
+      return @buffer.readInt8(@i - 1)
+    end
+    def readUInt16()
+      @i += 2
+      return @buffer.readUInt16LE(@i - 2)
+    end
+    def readInt16()
+      @i += 2
+      return @buffer.readInt16LE(@i - 2)
+    end
+    def readUInt32()
+      @i += 4
+      return @buffer.readUInt32LE(@i - 4)
+    end
+    def readInt32()
+      @i += 4
+      return @buffer.readInt32LE(@i - 4)
+    end
+    def readFloat()
+      @i += 4
+      return @buffer.readFloatLE(@i - 4)
+    end
+    def readDouble()
+      @i += 8
+      return @buffer.readDoubleLE(@i - 8)
+    end
+    def readValue(type)
+      if type === Constants::UNSIGNED_CHAR
+        return readUInt8()
+      end
+      if type === Constants::CHAR
+        return readInt8()
+      end
+      if type === Constants::UNSIGNED_SHORT
+        return readUInt16()
+      end
+      if type === Constants::SHORT
+        return readInt16()
+      end
+      if type === Constants::UNSIGNED_INT
+        return readUInt32()
+      end
+      if type === Constants::INT
+        return readInt32()
+      end
+      if type === Constants::FLOAT
+        return readFloat()
+      end
+      if type === Constants::DOUBLE
+        return readDouble()
+      end
+    end
+  end
+end

data/lib/constants.rb

@@ -0,0 +1,22 @@
+module Constants  
+  UNSIGNED_CHAR = 0x00
+  CHAR = 0x01
+  UNSIGNED_SHORT = 0x02
+  SHORT = 0x03
+  UNSIGNED_INT = 0x04
+  INT = 0x05
+  FLOAT = 0x06
+  DOUBLE = 0x07
+  STRING = 0x10
+  BOOLEAN = 0x20
+  NULL = 0x40
+  UNDEFINED = 0x14
+  OBJECT = 0x09
+  ARRAY = 0x80
+  DATE = 0x15
+  BUFFER = 0x16
+  REGEXP = 0x17
+  NAN = 0x18
+  INFINITY = 0x19
+  MINUS_INFINITY = 0x1A
+end

data/lib/io.rb

@@ -0,0 +1,525 @@
+require 'buffer-iterator'
+require 'string-buffer'
+require 'constants'
+require 'types'
+require 'date'
+require 'time'
+  
+module LEON
+  class Parser
+    def initialize(*args)
+      if args.length > 1
+        @spec = args[1]
+        @hasSpec = true
+      end
+      @buffer = BufferIterator.new(args[0])
+      @state = 0
+      @stringIndex = Array.new
+      @objectLayoutIndex = Array.new
+    end
+    def readString()
+      ret = ''
+      while (true) do
+        char = @buffer.readUInt8()
+        if char === 0
+          break
+        end
+        ret += char.chr
+      end
+      return ret
+    end
+    def readBuffer()
+      ret = StringBuffer.new
+      len = @buffer.readValue(@buffer.readUInt8())
+      for i in 0..(len - 1)
+        ret.writeUInt8(@buffer.readUInt8(), i)
+      end
+      return ret
+    end
+    def readRegExp()
+      return RegExp.new(readString(), readString())
+    end
+    def readDate()
+      return Time.at(@buffer.readUInt32())
+    end
+    def parseSI()
+      if (@state & 0x01) != 0
+        return
+      end
+      @stringIndexType = @buffer.readUInt8()
+      case @stringIndexType
+        when Constants::UNSIGNED_CHAR, Constants::UNSIGNED_SHORT, Constants::UNSIGNED_INT
+          stringCount = @buffer.readValue(@stringIndexType)
+        when 0xFF
+          stringCount = 0
+        else
+          return self
+      end
+      for i in (0..(stringCount - 1))
+        @stringIndex.push readString()
+      end
+      @state |= 0x01
+      return self
+    end
+    def parseOLI()
+      if (@state & 0x01) === 0
+        parseSI()
+      end
+      if @stringIndex.length === 0
+        return self
+      end
+      @OLItype = @buffer.readUInt8()
+      case @OLItype
+        when Constants::UNSIGNED_CHAR, Constants::UNSIGNED_SHORT, Constants::UNSIGNED_INT
+          count = @buffer.readValue(@OLItype)
+        when 0xFF
+          return self
+        else
+          return self
+      end
+      for i in 0..(count - 1)
+        @objectLayoutIndex.push Array.new
+        numFields = @buffer.readValue(@buffer.readUInt8())
+        for j in 0..(numFields - 1)
+          @objectLayoutIndex[i].push(@buffer.readValue(@stringIndexType))
+        end
+      end
+      return self
+    end
+    def parseValueWithSpec(*args)
+      if args.length === 0
+        spec = @spec
+      else
+        spec = args[0]
+      end
+      if spec === Constants::STRING
+        return readString()
+      elsif spec.kind_of?(Array)
+        ret = Array.new
+        spec = spec[0]
+        length = @buffer.readValue(@buffer.readUInt8())
+        for i in (0..(length - 1))
+          ret.push parseValueWithSpec(spec)
+        end
+        return ret
+      elsif spec.is_a?(Hash)
+        ret = Hash.new
+        spec.each do |k, v|
+          ret[k] = parseValueWithSpec(v)
+        end
+        return ret
+      elsif spec === Constants::BOOLEAN
+        return parseValue()
+      else
+        return parseValue(spec)
+      end
+    end
+    def parseValue(*args)
+      if args.length === 0
+        type = @buffer.readUInt8()
+      else
+        type = args[0]
+      end
+      if type < Constants::OBJECT
+        return @buffer.readValue(type)
+      elsif type === Constants::ARRAY
+        len = @buffer.readValue(@buffer.readUInt8())
+        ret = Array.new
+        for i in 0..(len - 1)
+          ret.push parseValue()
+        end
+        return ret
+      elsif type === Constants::OBJECT
+        index = @objectLayoutIndex[@buffer.readValue(@OLItype)]
+        ret = Hash.new
+        index.each_with_index { |val, idx|
+          ret[@stringIndex[val]] = parseValue()
+        }
+        return ret
+      elsif type === Constants::STRING
+        return @stringIndex[@buffer.readValue(@stringIndexType)]
+      elsif type === Constants::UNDEFINED
+        return LEON::Undefined.new
+      elsif type === Constants::BOOLEAN
+        return true
+      elsif type === Constants::BOOLEAN + 1
+        return false
+      elsif type === Constants::NULL
+        return nil
+      elsif type === Constants::NAN
+        return LEON::NaN.new
+      elsif type === Constants::DATE
+        return readDate()
+      elsif type === Constants::REGEXP
+        return readRegExp()
+      elsif type === Constants::BUFFER
+        return readBuffer()
+      elsif type === Constants::INFINITY
+        return Float::INFINITY
+      elsif type === Constants::MINUS_INFINITY
+        return -1/0.0
+      else
+        return
+      end
+    end
+  end
+  
+  def self.type_check(v)
+    if v === nil
+      return Constants::NULL
+    elsif v === true
+      return Constants::BOOLEAN
+    elsif v === false
+      return Constants::BOOLEAN + 1
+    elsif v.kind_of? LEON::NaN
+      return Constants::NAN
+    elsif v.kind_of? LEON::Undefined
+      return Constants::UNDEFINED
+    elsif v.kind_of? Date or v.kind_of? Time
+      return Constants::DATE
+    elsif v.kind_of? LEON::StringBuffer
+      return Constants::BUFFER
+    elsif v.kind_of? LEON::RegExp
+      return Constants::REGEXP
+    elsif v === Float::INFINITY
+      return Constants::INFINITY
+    elsif v === -1/0.0
+      return Constants::MINUS_INFINITY
+    elsif v.kind_of?(Array)
+      return Constants::ARRAY
+    elsif v.kind_of?(Hash)
+      return Constants::OBJECT
+    elsif v.is_a? String
+      return Constants::STRING
+    elsif v.kind_of? Symbol
+      return Constants::STRING
+    elsif v.is_a? Fixnum
+      if v < 0
+        v = v.abs
+        if v < (1 << 6)
+          return Constants::CHAR
+        elsif v < (1 << 14)
+          return Constants::SHORT
+        elsif v < (1 << 30)
+          return Constants::INT
+        end
+        return Constants::DOUBLE
+      end
+      if v < (1 << 7)
+        return Constants::UNSIGNED_CHAR
+      end
+      if v < (1 << 15)
+        return Constants::UNSIGNED_SHORT
+      end
+      if v < (1 << 31)
+        return Constants::UNSIGNED_INT
+      end
+      return Constants::DOUBLE
+    elsif v.is_a? Float
+      v = v.abs
+      log = Math::log(v)/Math::log(2)
+      if log < -128 or log > 127
+        return Constants::DOUBLE
+      end
+      if log < 0
+        log = log.ceil
+      else
+        log = log.floor
+      end
+      v *= 2**(-log + 23)
+      if v.floor != v
+        return Constants::DOUBLE
+      end
+      return Constants::FLOAT
+    end
+  end
+  
+  class Encoder
+    def initialize(*args)
+      if args.length > 1
+        @spec = args[1]
+        @hasSpec = true
+      else
+        @hasSpec = false
+      end
+      @payload = args[0]
+      @OLI = Array.new
+      @stringIndex = Array.new
+      @buffer = StringBuffer.new
+    end
+    def append(buf)
+      @buffer = StringBuffer.concat([@buffer, buf])
+    end
+    def writeData()
+      if @hasSpec
+        writeValueWithSpec(@payload)
+      else
+        writeValue(@payload, LEON::type_check(@payload))
+      end
+      return self
+    end
+    def export()
+      return @buffer.buffer
+    end
+    def writeValueWithSpec(*args)
+      if args.length > 1
+        spec = args[1]
+      else
+        spec = @spec
+      end
+      val = args[0]
+      if spec.kind_of? Array
+        writeValue(val.length, LEON::type_check(val.length))
+        val.each { |v|
+          writeValueWithSpec(v, spec[0])
+        }
+      elsif spec.kind_of? Hash
+        spec.each { |k, v|
+          writeValueWithSpec(val[k], v)
+        }
+      elsif spec === Constants::BOOLEAN
+        writeValue(val, LEON::type_check(val), true)
+      else
+        writeValue(val, spec, true)
+      end
+    end
+    def writeValue(*args)
+      val = args[0]
+      type = args[1]
+      if args.length > 2
+        implicit = args[2]
+      else
+        implicit = false
+      end
+      typeByte = StringBuffer.new
+      typeByte.writeUInt8(type, 0)
+      if type === Constants::UNDEFINED or type === Constants::BOOLEAN or type === Constants::BOOLEAN + 1 or type === Constants::NULL or type === Constants::NAN or type === Constants::MINUS_INFINITY or type === Constants::INFINITY
+        append(typeByte)
+        return 1
+      end
+      byteCount = 0
+      if !implicit
+        append(typeByte)
+        byteCount += 1
+      end
+      if type === Constants::STRING
+        if val.kind_of? Symbol
+          val = val.to_s
+        end
+        if @stringIndex.length === 0
+          writeString(val)
+          return 1 + byteCount + val.length
+        end
+        writeValue(@stringIndex.index(val), @stringIndexType, true)
+        return byteCount + 1
+      elsif type == Constants::CHAR
+        bytes = StringBuffer.new
+        bytes.writeInt8(val, 0)
+        append(bytes)
+        return byteCount + 1
+      elsif type == Constants::UNSIGNED_CHAR
+        bytes = StringBuffer.new
+        bytes.writeUInt8(val, 0)
+        append(bytes)
+        return byteCount + 1
+      elsif type === Constants::SHORT
+        bytes = StringBuffer.new
+        bytes.writeInt16LE(val, 0)
+        append(bytes)
+        return byteCount + 2
+      elsif type === Constants::UNSIGNED_SHORT
+        bytes = StringBuffer.new
+        bytes.writeUInt16LE(val, 0)
+        append(bytes)
+        return byteCount + 2
+      elsif type === Constants::INT
+        bytes = StringBuffer.new
+        bytes.writeInt32LE(val, 0)
+        append(bytes)
+        return byteCount + 4
+      elsif type === Constants::UNSIGNED_INT
+        bytes = StringBuffer.new
+        bytes.writeUInt32LE(val, 0)
+        append(bytes)
+        return byteCount + 4
+      elsif type === Constants::FLOAT
+        bytes = StringBuffer.new
+        bytes.writeFloatLE(val, 0)
+        append(bytes)
+        return byteCount + 4
+      elsif type === Constants::DOUBLE
+        bytes = StringBuffer.new
+        bytes.writeDoubleLE(val, 0)
+        append(bytes)
+        return byteCount + 8
+      elsif type === Constants::ARRAY
+        writeValue(val.length, LEON::type_check(val.length))
+        val.each { |v|
+          writeValue(v, LEON::type_check(v))
+        }
+        return
+      elsif type === Constants::OBJECT
+        index = LEON::match_layout(val, @stringIndex, @OLI)
+        writeValue(index, @OLItype, true)
+        for i in 0..(@OLI[index].length - 1)
+          key = @stringIndex[@OLI[index][i]]
+          if not val.has_key? key
+            key = key.to_sym
+          end
+          tmp = val[key]
+          writeValue(tmp, LEON::type_check(tmp))
+        end
+        return
+      elsif type === Constants::BUFFER
+        len = val.buffer.length
+        writeValue(len, LEON::type_check(len))
+        for i in 0..(len - 1)
+          writeValue(val.buffer[i].ord, Constants::UNSIGNED_CHAR, true)
+        end
+        return byteCount + val.buffer.length
+      elsif type === Constants::REGEXP
+        writeString(val.pattern)
+        writeString(val.modifier)
+        return byteCount + 2 + val.pattern.length + val.modifier.length
+      elsif type === Constants::DATE
+        if val.kind_of? Date 
+          val = Time.parse(val.to_s)
+        end
+        writeValue(val.to_i, Constants::UNSIGNED_INT, true)
+        return byteCount + 4
+      end
+    end
+    def writeString(str)
+      bytes = StringBuffer.new
+      len = str.length
+      for i in 0..(len - 1)
+        bytes.writeUInt8(str[i].ord, -1)
+      end
+      bytes.writeUInt8(0, -1)
+      append(bytes)
+      return len + 1
+    end
+    def writeOLI()
+      if @stringIndex.length === 0
+        return self
+      end
+      @OLI = LEON::gather_layouts(@payload, @stringIndex)
+      if @OLI.length === 0
+        writeValue(0xFF, Constants::UNSIGNED_CHAR, true)
+        return self
+      end
+      @OLItype = LEON::type_check(@OLI.length)
+      writeValue(@OLI.length, @OLItype)
+      @OLI.each { |v|
+        type = LEON::type_check(v.length)
+        writeValue(v.length, type)
+        v.each { |v|
+          writeValue(v, @stringIndexType, true)
+        }
+      }
+      return self
+    end
+    def writeSI()
+      @stringIndex = LEON::gather_strings(@payload)
+      if @stringIndex.length === 0
+        writeValue(0xFF, Constants::UNSIGNED_CHAR, true)
+        return self
+      end
+      @stringIndexType = LEON::type_check(@stringIndex.length)
+      writeValue(@stringIndex.length, @stringIndexType)
+      @stringIndex.each { |v|
+        writeString(v)
+      }
+      return self
+    end
+  end
+  def self.match_layout(val, stringIndex, oli)
+    keys = val.keys
+    layout = Array.new
+    for i in 0..(keys.length - 1)
+      if keys[i].kind_of? Symbol
+        keys[i] = keys[i].to_s
+      end
+      layout.push stringIndex.index(keys[i])
+    end
+    layout.sort! { |a, b|
+      a <=> b
+    }
+    i = 0
+    while i < oli.length
+      if layout.eql? oli[i].sort { |a, b| a <=> b }
+        return i
+      end
+      i += 1
+    end
+  end
+  def self.gather_layouts(*args)
+    if args.length > 3
+      branch = args[3]
+    else
+      branch = args[0]
+    end
+    if args.length > 2
+      ret = args[2]
+    else
+      ret = Array.new
+    end
+    val = args[0]
+    stringIndex = args[1]
+    if branch.kind_of? Array
+      branch.each { |v|
+        LEON::gather_layouts(val, stringIndex, ret, v)
+      }
+    elsif branch.kind_of? Hash
+      ret.push Array.new
+      branch.each { |k, v|
+        if k.kind_of? Symbol
+          k = k.to_s
+        end
+        ret[ret.length - 1].push stringIndex.index(k)
+      }
+      branch.each { |k, v|
+        LEON::gather_layouts(val, stringIndex, ret, v)
+      }
+    end
+    return ret
+  end
+  def self.gather_strings(*args)
+    if args.length > 2
+      branch = args[2]
+    else
+      branch = args[0]
+    end
+    if args.length > 1
+      ret = args[1]
+    else
+      ret = Array.new
+    end
+    val = args[0]
+    if branch.kind_of? Array
+      branch.each { |v|
+        LEON::gather_strings(val, ret, v)
+      }
+    elsif branch.kind_of? Hash
+      branch.each { |k, v|
+        if k.kind_of? Symbol
+          k = k.to_s
+        end
+        set_push(ret, k)
+      }
+      branch.each { |k, v|
+        LEON::gather_strings(val, ret, v)
+      }
+    elsif branch.kind_of? String
+      set_push(ret, branch)
+    elsif branch.kind_of? Symbol
+      set_push(ret, branch.to_s)
+    end
+    return ret
+  end
+  def self.set_push(arr, v)
+    if !arr.include? v
+      arr.push v
+    end
+  end
+end

data/lib/leon.rb

@@ -0,0 +1,28 @@
+require 'constants'
+require 'string-buffer'
+require 'io'
+module LEON
+  include Constants
+  class Channel
+    def initialize(spec)
+      @spec = spec
+    end
+    def generate(payload)
+      return Encoder.new(payload, @spec).writeData().export()
+    end
+    def parse(payload)
+      Parser.new(StringBuffer.new(payload), @spec).parseValueWithSpec()
+    end
+  end
+  def self.parse(str)
+    Parser.new(StringBuffer.new(str)).parseSI().parseOLI().parseValue()
+  end
+  def self.generate(payload)
+    Encoder.new(payload).writeSI().writeOLI().writeData().export()
+  end
+end
+class Object
+  def to_leon()
+    LEON::generate(self)
+  end
+end

data/lib/string-buffer.rb

@@ -0,0 +1,319 @@
+require 'constants'
+
+module LEON
+  class StringBuffer
+    attr_accessor :buffer
+    def self.bytes(v, type)
+      ret = Array.new
+      if type === Constants::UNSIGNED_CHAR
+        ret.push v
+        return ret
+      end
+      if type === Constants::CHAR
+        return v < 0 ? StringBuffer.bytes(complement(-v, 8), Constants::UNSIGNED_CHAR) : StringBuffer.bytes(v, Constants::UNSIGNED_CHAR)
+      end
+      if type === Constants::UNSIGNED_SHORT
+        ret.push(v >> 8)
+        ret.push(v & 0xFF)
+        return ret
+      end
+      if type === Constants::SHORT
+        return v < 0 ? StringBuffer.bytes(complement(-v, 16), Constants::UNSIGNED_SHORT) : StringBuffer.bytes(v, Constants::UNSIGNED_SHORT)
+      end
+      if type === Constants::UNSIGNED_INT
+        ret.push(v >> 24)
+        ret.push((v >> 16) & 0xFF)
+        ret.push((v >> 8) & 0xFF)
+        ret.push(v & 0xFF)
+        return ret
+      end
+      if type === Constants::INT
+        return v < 0 ? StringBuffer.bytes(complement(-v, 32), Constants::UNSIGNED_INT) : StringBuffer.bytes(v, Constants::UNSIGNED_INT)
+      end
+      if type === Constants::FLOAT
+        exp = 127
+        if v < 0
+          sign = 1
+        else
+          sign = 0
+        end
+        v = v.abs
+        log = Math::log(v)/Math::log(2)
+        if log < 0
+          log = log.ceil
+        else
+          log = log.floor
+        end
+        v *= 2**(-log + 23)
+        exp += log
+        v = v.round
+        v &= 0x7FFFFF
+        ret.push(sign << 7)
+        ret[0] |= ((exp & 0xFE) >> 1)
+        ret.push((exp & 0x01) << 7)
+        ret[1] |= ((v >> 16) & 0x7F)
+        ret.push((v >> 8) & 0xFF)
+        ret.push(v & 0xFF)
+        return ret
+      end
+      if type === Constants::DOUBLE
+        exp = 1023
+        if v < 0
+          sign = 1
+        else
+          sign = 0
+        end
+        v = v.abs
+        log = Math::log(v)/Math::log(2)
+        if log < 0
+          log = log.ceil
+        else
+          log = log.floor
+        end
+        v *= 2**(-log + 52)
+        exp += log
+        str = v.to_int.to_s(2)
+        v = str[1..-1].to_i(2)
+        ret.push(sign << 7)
+        ret[0] |= (exp >> 4)
+        ret.push((exp & 0x0F) << 4)
+        ret[1] |= ((v*2**(-48)).floor & 0x0F)
+        sh = 40
+        for i in 0..5
+          ret.push((v*2**(-sh)).floor & 0xFF)
+          sh -= 8
+        end
+        return ret
+      end
+    end
+    def self.bytes_to_float(bytes)
+      sign = (0x80 & bytes[0]) >> 7
+      exp = ((bytes[0] & 0x7F) << 1) | ((bytes[1] & 0x80) >> 7)
+      sig = 0
+      bytes[1] &= 0x7F
+      for i in 0..2
+        sig |= bytes[1 + i]*2**((2 - i)*8)
+      end
+      sig |= 0x800000
+      return ((sign === 1 ? -sig : sig)*2**(exp - (127 + 23))).to_f
+    end
+    def self.bytes_to_double(bytes)
+      sign = (0x80 & bytes[0]) >> 7
+      exp = ((bytes[0] & 0x7F) << 4) | ((bytes[1] & 0xF0) >> 4)
+      sig = 0
+      bytes[1] &= 0x0F
+      for i in 0..6
+        sig += bytes[i + 1]*2**((6 - i)*8)
+      end
+      sig += 0x10000000000000
+      return ((sign === 1 ? -sig : sig)*2**(exp - (1023 + 52))).to_f
+    end
+    def self.complement(v, bits)
+      return (v ^ ((1 << bits) - 1)) + 1
+    end
+    def initialize(*args)
+      if args.length > 0
+        @buffer = args[0]
+      else
+        @buffer = ''
+      end
+    end
+    def self.concat(arr)
+      return arr.reduce(self.new) { |r, v|
+        r.buffer += v.buffer
+        r
+      }
+    end
+    def writeUInt8(v, i)
+      if i === -1 or i >= @buffer.length
+        @buffer += v.chr
+      else
+        @buffer = @buffer[0..i] + v.chr + @buffer[(i+1)..-1]
+      end
+      return i + 1
+    end
+    def writeInt8(v, i)
+      v = (v < 0 ? complement(-v, 8) : v)
+      return writeUInt8(v, i)
+    end
+    def writeUInt16LE(v, i)
+      bytez = StringBuffer.bytes(v, Constants::UNSIGNED_SHORT)
+      add = ''
+      bytez.reverse_each { |v|
+        add += "#{v.chr}"
+      }
+      if i >= @buffer.length or i === -1
+        @buffer += add
+      else
+        @buffer = @buffer[0..i] + add + @buffer[(i + 2)..-1]
+      end
+      return i + 2
+    end
+    def writeUInt16BE(v, i)
+      bytez = StringBuffer.bytes(v, Constants::UNSIGNED_SHORT)
+      add = ''
+      bytez.each { |v|
+        add += "#{v.chr}"
+      }
+      if i >= @buffer.length or i === -1
+        @buffer += add
+      else
+        @buffer = @buffer[0..i] + add + @buffer[(i + 2)..-1]
+      end
+      return i + 2
+    end
+    def writeInt16LE(v, i)
+      v = (v < 0 ? complement(-v, 16) : v)
+      return writeUInt16LE(v)
+    end
+    def writeInt16BE(v, i)
+      v = (v < 0 ? complement(-v, 16) : v)
+      return writeUInt16BE(v)
+    end
+    def writeUInt32LE(v, i)
+      bytez = StringBuffer.bytes(v, Constants::UNSIGNED_INT)
+      add = ''
+      bytez.reverse_each { |v|
+        add += "#{v.chr}"
+      }
+      if i >= @buffer.length or i === -1
+        @buffer += add
+      else
+        @buffer = @buffer[0..i] + add + @buffer[(i + 4)..-1]
+      end
+      return i + 4
+    end
+    def writeUInt32BE(v, i)
+      bytez = StringBuffer.bytes(v, Constants::UNSIGNED_INT)
+      add = ''
+      bytez.each { |v|
+        add += "#{v.chr}"
+      }
+      if i >= @buffer.length or i === -1
+        @buffer += add
+      else
+        @buffer = @buffer[0..i] + add + @buffer[(i + 4)..-1]
+      end
+      return i + 4
+    end
+    def writeInt32LE(v, i)
+      v = (v < 0 ? complement(-v, i) : v)
+      return writeUInt32LE(v)
+    end
+    def writeInt32BE(v, i)
+      v = (v < 0 ? complement(-v, i) : v)
+      return writeUInt32BE(v)
+    end
+    def writeFloatLE(v, i)
+      bytez = StringBuffer.bytes(v, Constants::FLOAT)
+      bytez.to_enum.with_index.reverse_each { |v, idx|
+        writeUInt8(v, i + (3 - idx))
+      }
+      return i + 4
+    end
+    def writeFloatBE(v, i)
+      bytez = StringBuffer.bytes(v, Constants::FLOAT)
+      bytez.to_enum.with_index.each { |v, idx|
+        writeUInt8(v, i + idx)
+      }
+      return i + 4
+    end
+    def writeDoubleLE(v, i)
+      bytez = StringBuffer.bytes(v, Constants::DOUBLE)
+      bytez.to_enum.with_index.reverse_each { |v, idx|
+        writeUInt8(v, i + (7 - idx))
+      }
+      return i + 8
+    end
+    def writeDoubleBE(v, i)
+      bytez = StringBuffer.bytes(v, Constants::DOUBLE)
+      bytez.to_enum.with_index.each { |v, idx|
+        writeUInt8(v, i + idx)
+      }
+      return i + 8
+    end
+    def readUInt8(i)
+      return @buffer[i].ord
+    end
+    def readInt8(i)
+      v = readUInt8(i)
+      if (0x80 & v) != 0
+        return -complement(v, 8)
+      end
+      return v
+    end
+    def readUInt16LE(i)
+      return @buffer[i].ord | (@buffer[i + 1].ord << 8)
+    end
+    def readUInt16BE(i)
+      return (@buffer[i].ord << 8) | @buffer[i + 1].ord
+    end
+    def readInt16LE(i)
+      v = readUInt16LE(i)
+      if (v & 0x8000) != 0
+        return -complement(v, 16)
+      end
+      return v
+    end
+    def readInt16BE(i)
+      v = readUInt16BE(i)
+      if (v & 0x8000) != 0
+        return -complement(v, 16)
+      end
+      return v
+    end
+    def readUInt32LE(i)
+      return @buffer[i].ord | (@buffer[i + 1].ord << 8) | (@buffer[i + 2].ord << 16) | (@buffer[i + 3].ord << 24)
+    end
+    def readUInt32BE(i)
+      return (@buffer[i].ord << 24) | (@buffer[i + 1].ord << 16) | (@buffer[i + 2].ord << 8) | @buffer[i + 3].ord
+    end
+    def readInt32LE(i)
+      v = readUInt32LE(i)
+      if (v & 0x80000000) != 0
+        return -complement(v, 32)
+      end
+      return v
+    end
+    def readInt32BE(i)
+      v = readUInt32BE(i)
+      if (v & 0x80000000) != 0
+        return -complement(v, 32)
+      end
+      return v
+    end
+    def readFloatLE(i)
+      bytez = Array.new
+      for j in 0..3
+        bytez.push readUInt8(i + j)
+      end
+      bytez.reverse!
+      return StringBuffer.bytes_to_float(bytez)
+    end
+    def readFloatBE(i)
+      bytez = Array.new
+      for j in 0..3
+        bytez.push readUInt8(i + j)
+      end
+      return StringBuffer.bytes_to_float(bytez)
+    end
+    def readDoubleLE(i)
+      bytez = Array.new
+      for j in 0..7
+        bytez.push readUInt8(i + j)
+      end
+      bytez.reverse!
+      return StringBuffer.bytes_to_double(bytez)
+    end
+    def readDoubleBE(i)
+      bytez = Array.new
+      for j in 0..7
+        bytez.push readUInt8(i + j)
+      end
+      return StringBuffer.bytes_to_double(bytez)
+    end
+    def toString()
+      return @buffer
+    end
+  end
+end

data/lib/types.rb

@@ -0,0 +1,21 @@
+module LEON
+  class Undefined
+  end
+  class NaN
+  end
+  class RegExp
+    attr_accessor :pattern
+    attr_accessor :modifier
+    def initialize(*args)
+      if args.length > 1
+        @modifier = args[1]
+      else
+        @modifier = ''
+      end
+      @pattern = args[0]
+    end
+    def to_s()
+      return '/' + @pattern + '/' + @modifier
+    end
+  end
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: leon
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Raymond Pulver IV
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-19 00:00:00.000000000 Z
+dependencies: []
+description: Serialize and deserialize all JavaScript data types to a more compact
+  format than JSON that can be dealt with in the browser.
+email: raymond.pulver_iv@uconn.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/buffer-iterator.rb
+- lib/io.rb
+- lib/string-buffer.rb
+- lib/constants.rb
+- lib/leon.rb
+- lib/types.rb
+homepage: http://github.com/raypulver/ruby-leon
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: LEON serialization for Ruby.
+test_files: []