asciipack 0.1.3 → 0.2.0

data/lib/asciipack/packer.rb

@@ -1,219 +0,0 @@
-module AsciiPack
-  class Packer
-    class << self
-      def pack (obj)
-        case
-        when obj.kind_of?(Hash)
-          map(obj);
-        when obj.kind_of?(Array)
-          array(obj);
-        when obj.kind_of?(Numeric)
-          if obj.kind_of?(Integer)
-            if 0 <= obj
-              if obj < 0x10
-                positive_fixint obj
-              elsif obj < 0x100
-                uint8 obj
-              elsif obj < 0x10000
-                uint16 obj
-              elsif obj < 0x100000000
-                uint32 obj
-              elsif obj < 0x10000000000000000
-                uint64 obj
-              end
-            else
-              if -0x8 <= obj
-                int4 obj
-              elsif -0x80 <= obj
-                int8 obj
-              elsif -0x8000 <= obj
-                int16 obj
-              elsif -0x80000000 <= obj
-                int32 obj
-              elsif -0x8000000000000000 <= obj
-                int64 obj
-              else
-                raise "pack size limit over"
-              end
-            end
-          else
-            float64 obj
-          end
-        when obj.kind_of?(String)
-          case obj.length
-          when 0...0x10
-            fixstr obj
-          when 0x10...0x100
-            str8 obj
-          when 0x100...0x10000
-            str16 obj
-          when 0x10000...0x100000000
-            str32 obj
-          else
-            raise "pack size limit over"
-          end
-        when obj.nil?
-          "W"
-        when obj == false
-          "X"
-        when obj == true
-          "Y"
-        end
-      end
-
-      private
-
-      def int4 (obj)
-        "a" + ((obj & 0xf).to_s(16))
-      end
-
-      def int8 (obj)
-        "b" + ((obj & 0xff).to_s(16))
-      end
-
-      def int16 (obj)
-        "c" + ((obj & 0xffff).to_s(16))
-      end
-
-      def int16 (obj)
-        "c" + ((obj & 0xffff).to_s(16))
-      end
-
-      def int32 (obj)
-        "d" + ((obj & 0xffffffff).to_s(16))
-      end
-
-      def int64 (obj)
-        "e" + ((obj & 0xffffffffffffffff).to_s(16))
-      end
-
-      def positive_fixint (obj)
-        obj.to_s(16).upcase
-      end
-
-      def uint8 (obj)
-        format_uint("g", 2, obj)
-      end
-
-      def uint16 (obj)
-        format_uint("h", 4, obj)
-      end
-
-      def uint32 (obj)
-        format_uint("i", 8, obj)
-      end
-
-      def uint64 (obj)
-        format_uint("j", 16, obj)
-      end
-
-      def float64 (obj)
-        unless obj.finite?
-          case obj.infinite?
-          when 1;  return "l" + '7ff0000000000000' # +∞
-          when -1; return "l" + 'fff0000000000000' # -∞
-          else;    return "l" + '7fffffffffffffff' # NAN
-          end
-        end
-
-        sign = obj < 0
-        obj *= -1 if sign
-        exp = ((Math.log(obj) / Math.log(2, Math::E)) + 1023).to_i
-        frac = obj * (2**(52 + 1023 - exp))
-        low = frac.to_i & 0xffffffff
-        exp |= 0x800 if sign
-        high = ((frac / 0x100000000).to_i & 0xfffff) | (exp << 20)
-
-        "l" + to_s16([
-          (high >> 24) & 0xff, (high >> 16) & 0xff,
-          (high >>  8) & 0xff, (high)       & 0xff,
-          (low  >> 24) & 0xff, (low  >> 16) & 0xff,
-          (low  >>  8) & 0xff, (low)        & 0xff
-        ])
-      end
-
-      def fixstr (obj)
-        (obj.length + 71).chr + obj
-      end
-
-      def str8 (obj)
-        format_str "n", 2, obj
-      end
-
-      def str16 (obj)
-        format_str "o", 4, obj
-      end
-
-      def str32 (obj)
-        format_str "p", 8, obj
-      end
-
-      def map (obj)
-      keys = [];
-      obj.each { |key, value|
-        keys.push(pack(key) + pack(value))
-      }
-      if keys.length < 0x10
-        f = ["r", 1]
-      elsif keys.length < 0x100
-        f = ["s", 2]
-      elsif keys.length < 0x10000
-        f = ["t", 4]
-      elsif keys.length < 0x100000000
-        f = ["u", 8]
-      else
-        raise "pack size limit over"
-      end
-      format_uint(f[0], f[1], keys.length) + keys.join('');
-      end
-
-      def array (obj)
-        keys = [];
-        obj.each { |value|
-          keys.push(pack(value));
-        }
-      if keys.length < 0x10
-        f = ["v", 1]
-      elsif keys.length < 0x100
-        f = ["w", 2]
-      elsif keys.length < 0x10000
-        f = ["x", 4]
-      elsif keys.length < 0x100000000
-        f = ["y", 8]
-      else
-        raise "pack size limit over"
-      end
-      format_uint(f[0], f[1], keys.length) + keys.join('');
-      end
-
-      def format_uint (type, length, num)
-        hex = num.to_s(16);
-        len = length - hex.length;
-        zero = '0' * len;
-        type + zero + hex;
-      end
-
-      def format_str (type, length, str)
-        hex = str.length.to_s(16);
-        len = length - hex.length;
-        zero = '0' * len;
-        type + zero + hex + str;
-      end
-
-      def to_s16 (a)
-        a.map { |i|
-          hex = i.to_s(16)
-          len = hex.length
-          i = 2 - len
-          ('0' * i) + hex
-        }.join('')
-      end
-    end
-  end
-
-  class << self
-    def pack (obj)
-      Packer.pack obj
-    end
-  end
-end

data/lib/asciipack/unpacker.rb

@@ -1,201 +0,0 @@
-module AsciiPack
-  class Unpacker
-    @@fixmap = {
-      "0" => 0x0,
-      "1" => 0x1,
-      "2" => 0x2,
-      "3" => 0x3,
-      "4" => 0x4,
-      "5" => 0x5,
-      "6" => 0x6,
-      "7" => 0x7,
-      "8" => 0x8,
-      "9" => 0x9,
-      "A" => 0xa,
-      "B" => 0xb,
-      "C" => 0xc,
-      "D" => 0xd,
-      "E" => 0xe,
-      "F" => 0xf,
-      "W" => nil,
-      "X" => false,
-      "Y" => true,
-    }.freeze
-
-    def initialize (ap)
-      @ap = ap
-      @at = 0
-      @ch = @ap[0]
-    end
-
-    def unpack
-      move
-
-      if @@fixmap.key?(@ch)
-        return @@fixmap[@ch]
-      end
-
-      case @ch
-      when "a"; int4
-      when "b"; int8
-      when "c"; int16
-      when "d"; int32
-      when "e"; int64
-      when "g"; uint8
-      when "h"; uint16
-      when "i"; uint32
-      when "j"; uint64
-      when "l"; float64
-      when "n"; str8
-      when "o"; str16
-      when "p"; str32
-      when "r"; map4
-      when "s"; map8
-      when "t"; map16
-      when "u"; map32
-      when "v"; array4
-      when "w"; array8
-      when "x"; array16
-      when "y"; array32
-      when /[G-V]/; fixstr
-      else raise "undefined type " + @ch.to_s
-      end
-    end
-
-private
-
-    def move
-      @ch = @ap[@at]
-      @at += 1
-      @ch
-    end
-
-    def cut (len)
-      ret = @ap[@at...(@at + len)]
-      @at += len
-      @ch = @ap[@at]
-      ret
-    end
-
-    def int4
-      move
-      i = @ch.to_i(16)
-      (@ch[0].to_i(16) < 0x8) ? i : i - 0x10;
-    end
-
-    def int8
-      c = cut(2)
-      i = c.to_i(16)
-      (c[0].to_i(16) < 0x8) ? i : i - 0x100;
-    end
-
-    def int16
-      c = cut(4)
-      i = c.to_i(16)
-      (c[0].to_i(16) < 0x8) ? i : i - 0x10000;
-    end
-
-    def int32
-      c = cut(8)
-      i = c.to_i(16)
-      (c[0].to_i(16) < 0x8) ? i : i - 0x100000000;
-    end
-
-    def int64
-      c = cut(16)
-      i = c.to_i(16)
-      (c[0].to_i(16) < 0x8) ? i : i - 0x10000000000000000;
-    end
-
-    def uint8
-      cut(2).to_i(16)
-    end
-
-    def uint16
-      cut(4).to_i(16)
-    end
-
-    def uint32
-      cut(8).to_i(16)
-    end
-
-    def uint64
-      cut(16).to_i(16)
-    end
-
-    def float64
-      # IEEE 752 format
-      hex = cut(3)
-      num = hex.to_i(16)
-      sign = num & 0x800
-      exp = (num & 0x7ff) - 1023
-      frac = ('1' + cut(13)).to_i(16)
-
-      if hex == '7ff' && frac != 0
-        return Float.NAN
-      elsif hex == '7ff' && frac == 0
-        return Float.INFINITY
-      elsif hex == 'fff' && frac == 0
-        return -1 / 0.0
-      end
-
-      ((sign == 0 ? 1 : -1) * frac * (2**(exp - 52))).to_f
-    end
-
-    def map (length)
-      len = cut(length).to_i(16)
-      hash = {}
-      len.times {
-        key = unpack
-        hash[key] = unpack
-      }
-      hash
-    end
-
-    def map4; map(1) end
-    def map8; map(2) end
-    def map16; map(4) end
-    def map32; map(8) end
-
-    def array (length)
-      len = cut(length).to_i(16)
-      array = []
-      len.times {
-        array << unpack
-      }
-      array
-    end
-
-    def array4; array(1) end
-    def array8; array(2) end
-    def array16; array(4) end
-    def array32; array(8) end
-
-    def fixstr
-      len = @ch.ord - 71 # 71 = "G".ord
-      cut(len)
-    end
-
-    def str8
-      len = cut(2).to_i(16)
-      cut(len)
-    end
-
-    def str16
-      len = cut(4).to_i(16)
-      cut(len)
-    end
-
-    def str32
-      len = cut(8).to_i(16)
-      cut(len)
-    end
-  end
-
-  class << self
-    def unpack (obj)
-      unpacker = Unpacker.new obj
-      unpacker.unpack
-    end
-  end
-end