leon 1.0.3 → 1.0.6

data/lib/io.rb

@@ -19,12 +19,9 @@ module LEON
     end
     def readString()
       ret = ''
-      while (true) do
-        char = @buffer.readUInt8()
-        if char === 0
-          break
-        end
-        ret += char.chr
+      len = @buffer.readValue(@buffer.readUInt8())
+      for i in 0...len
+        ret += @buffer.readUInt8.chr
       end
       return ret
     end
@@ -104,7 +101,7 @@ module LEON
         return ret
       elsif spec.is_a?(Hash)
         ret = Hash.new
-        spec.each do |k, v|
+        Hash[spec.sort].each do |k, v|
           ret[k] = parseValueWithSpec(v)
         end
         return ret
@@ -276,9 +273,15 @@ module LEON
           writeValueWithSpec(v, spec[0])
         }
       elsif spec.kind_of? Hash
-        spec.each { |k, v|
-          writeValueWithSpec(val[k], v)
-        }
+        if val.kind_of? Hash
+          spec.sort.each { |k, v|
+            writeValueWithSpec(val[k], v)
+          }
+        else
+          spec.sort.each { |k, v|
+            writeValueWithSpec(val.send(k), v)
+          }
+        end
       elsif spec === Constants::BOOLEAN
         writeValue(val, LEON::type_check(val), true)
       else
@@ -409,14 +412,12 @@ module LEON
       end
     end
     def writeString(str)
-      bytes = StringBuffer.new
       len = str.length
-      for i in 0..(len - 1)
-        bytes.writeUInt8(str[i].ord, -1)
+      writeValue(len, LEON::type_check(len))
+      for i in 0...len
+        writeValue(str[i].ord, Constants::UNSIGNED_CHAR, true)
       end
-      bytes.writeUInt8(0, -1)
-      append(bytes)
-      return len + 1
+      return len + 2
     end
     def writeOLI()
       if @stringIndex.length === 0

data/lib/leon.rb

@@ -20,6 +20,162 @@ module LEON
   def self.generate(payload)
     Encoder.new(payload).writeSI().writeOLI().writeData().export()
   end
+  def self.type_to_str(type)
+    case type
+      when Constants::UNSIGNED_CHAR
+        return "unsigned char"
+      when Constants::CHAR
+        return "char"
+      when Constants::UNSIGNED_SHORT
+        return "unsigned short"
+      when Constants::SHORT
+        return "short"
+      when Constants::UNSIGNED_INT
+        return "unsigned int"
+      when Constants::INT
+        return "int"
+      when Constants::FLOAT
+        return "float"
+      when Constants::DOUBLE
+        return "double"
+      when Constants::STRING
+        return "string"
+      when Constants::BOOLEAN
+        return "boolean"
+      when Constants::NULL
+        return "null"
+      when Constants::UNDEFINED
+        return "undefined"
+      when Constants::OBJECT, Constants::NATIVE_OBJECT
+        return "object"
+      when Constants::ARRAY
+        return "array"
+      when Constants::DATE
+        return "date"
+      when Constants::BUFFER
+        return "buffer"
+      when Constants::REGEXP
+        return "RegExp"
+      when Constants::NAN
+        return "NaN"
+      when Constants::INFINITY
+        return "infinity"
+      when Constants::MINUS_INFINITY
+        return "minus infinity"
+    end
+  end
+  def self.type_gcd(arr)
+    type = LEON::type_check(arr[0])
+    if type === Constants::BOOLEAN + 1
+      type = Constants::BOOLEAN
+    end
+    case type
+      when Constants::ARRAY
+        return [ self.type_gcd(arr[0]) ]
+      when Constants::OBJECT
+        ret = Hash.new
+        arr[0].each { |k, v|
+          ret[k] = self.type_gcd(self.pluck(arr, k))
+        }
+        return ret
+      when Constants::NATIVE_OBJECT
+        ret = Hash.new
+        vars = arr[0].instance_variables.map { |v|
+          v.to_sym.sub("@", "")
+        }
+        vars.each { |v|
+          ret[v] = self.type_gcd(self.pluck(arr, v))
+        }
+        return ret
+      when Constants::UNSIGNED_CHAR, Constants::CHAR, Constants::UNSIGNED_SHORT, Constants::SHORT, Constants::UNSIGNED_INT, Constants::INT, Constants::FLOAT, Constants::DOUBLE
+        highestMagnitude = arr[0].abs
+        if arr[0] < 0
+          sign = 1
+        else
+          sign = 0
+        end
+        if type === Constants::FLOAT or type === Constants::DOUBLE
+          fp = 1
+        else
+          fp = 0
+        end
+        for i in 1...arr.length
+          type = LEON::type_check(arr[i])
+          if not arr[i].kind_of? Float and not arr[i].kind_of? Fixnum
+            raise "Expected a numerical value but got #{self.type_to_str(type)}."
+          end
+          if arr[i].abs > highestMagnitude
+            highestMagnitude = arr[1]
+          end
+          if arr[i].ceil != arr[i]
+            fp = 1
+          else
+            fp = 0
+          end
+        end
+        return self.type_check((fp ? Float((sign ? -highestMagnitude : highestMagnitude )) : (sign ? -highestMagnitude : highestMagnitude )))
+      else
+        for i in 1...(arr.length)
+          thisType = self.type_check(arr[i])
+          if thisType === Constants::BOOLEAN + 1
+            thisType = Constants::BOOLEAN
+          end
+          if type != thisType
+            raise "Was expecting a #{self.type_to_str(type)} but got a #{self.type_to_str(thisType)}."
+          end
+        end
+        return type
+    end
+    return type
+  end
+  def self.pluck(arr, prop)
+    ret = Array.new
+    if prop.kind_of? Symbol
+      prop = prop.to_s
+    end
+    for i in 0...(arr.length)
+      if arr[i].kind_of? Hash
+        if not arr[i].has_key? prop
+          if not arr[i].has_key? prop.to_sym
+            raise "Object #{i} in array has no such key \"#{prop}.\""
+          else
+            ret.push arr[i][prop.to_sym]
+          end
+        else
+          ret.push arr[i][prop]
+        end
+      elsif arr[i].kind_of? Object
+        begin
+          ret.push arr[i].send(prop)
+        rescue
+          raise "Object #{i} in array has no such property \"#{prop}.\""
+        end
+      end
+    end
+    return ret
+  end
+  def self.to_template(payload)
+    type = self.type_check(payload)
+    case type
+      when Constants::ARRAY
+        return [self.type_gcd(payload)]
+      when Constants::OBJECT
+        ret = Hash.new
+        payload.each { |k, v|
+          ret[k] = self.to_template(v)
+        }
+        return ret
+      when Constants::NATIVE_OBJECT
+        ret = Hash.new
+        payload.instance_variables.each { |k, v|
+          ret[k] = self.to_template(v)
+        }
+      when Constants::BOOLEAN + 1
+        return Constants::BOOLEAN
+      else
+        return type
+    end
+  end
 end
 class Object
   def to_leon()

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leon
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.6
   prerelease: 
 platform: ruby
 authors: