asciipack 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57e17422c3a216d7f7c2309e41efd0ad6c7ab718
-  data.tar.gz: 6bb53b24982c3f537c6db9b644a0436c36a70639
+  metadata.gz: 12c016c4cbf6dc6932200cd28774219195a6897b
+  data.tar.gz: db20a4941ad342f86992244148e3fda496f32c5c
 SHA512:
-  metadata.gz: bc85c67d615ec94d27e0222e1b9ad74b1195a21abbecf48e5666376196f4d1fb8813fd97c1e463708003b5ed1c6c3f35c0c1f0d24a340f194b36b4e6435bb530
-  data.tar.gz: 7d398d537b5c390eebac442c7b329388184f7d5a84e38d9a53fb0096b0326b638aaf2d37c0ab369003d43b051be7eec5e72351f2da140c66547eadc9699b21c1
+  metadata.gz: cd8780bb46e2fa092cd8035efccd1174e6f8c7c659f2d3f2a702694e46f29d5dc78cd555e21678dbdadba2b63f2feef17e51d0ac8726b06f4a036d3758607282
+  data.tar.gz: f0a6ec0a80d7f49f28e5c08177323779e8c3491f0084d3742e09e596bb7311c59c214252e2957a9f2ccbe7da9063a9d8d71fd221ab207404c340fbc88fcbdd6f

data/lib/asciipack/packer.rb

@@ -1,5 +1,3 @@
-require 'asciipack/typemap.rb'
-
 module AsciiPack
   class Packer
     class << self
@@ -55,38 +53,38 @@ module AsciiPack
             raise "pack size limit over"
           end
         when obj.nil?
-          TypeMap.nil
+          "W"
         when obj == false
-          TypeMap.false
+          "X"
         when obj == true
-          TypeMap.true
+          "Y"
         end
       end
 
       private
 
       def int4 (obj)
-        TypeMap.int4 + ((obj & 0xf).to_s(16))
+        "a" + ((obj & 0xf).to_s(16))
       end
 
       def int8 (obj)
-        TypeMap.int8 + ((obj & 0xff).to_s(16))
+        "b" + ((obj & 0xff).to_s(16))
       end
 
       def int16 (obj)
-        TypeMap.int16 + ((obj & 0xffff).to_s(16))
+        "c" + ((obj & 0xffff).to_s(16))
       end
 
       def int16 (obj)
-        TypeMap.int16 + ((obj & 0xffff).to_s(16))
+        "c" + ((obj & 0xffff).to_s(16))
       end
 
       def int32 (obj)
-        TypeMap.int32 + ((obj & 0xffffffff).to_s(16))
+        "d" + ((obj & 0xffffffff).to_s(16))
       end
 
       def int64 (obj)
-        TypeMap.int64 + ((obj & 0xffffffffffffffff).to_s(16))
+        "e" + ((obj & 0xffffffffffffffff).to_s(16))
       end
 
       def positive_fixint (obj)
@@ -94,27 +92,27 @@ module AsciiPack
       end
 
       def uint8 (obj)
-        format_uint(TypeMap.uint8, 2, obj)
+        format_uint("g", 2, obj)
       end
 
       def uint16 (obj)
-        format_uint(TypeMap.uint16, 4, obj)
+        format_uint("h", 4, obj)
       end
 
       def uint32 (obj)
-        format_uint(TypeMap.uint32, 8, obj)
+        format_uint("i", 8, obj)
       end
 
       def uint64 (obj)
-        format_uint(TypeMap.uint64, 16, obj)
+        format_uint("j", 16, obj)
       end
 
       def float64 (obj)
         unless obj.finite?
           case obj.infinite?
-          when 1;  return TypeMap.float64 + '7ff0000000000000' # +∞
-          when -1; return TypeMap.float64 + 'fff0000000000000' # -∞
-          else;    return TypeMap.float64 + '7fffffffffffffff' # NAN
+          when 1;  return "l" + '7ff0000000000000' # +∞
+          when -1; return "l" + 'fff0000000000000' # -∞
+          else;    return "l" + '7fffffffffffffff' # NAN
           end
         end
 
@@ -126,7 +124,7 @@ module AsciiPack
         exp |= 0x800 if sign
         high = ((frac / 0x100000000).to_i & 0xfffff) | (exp << 20)
 
-        TypeMap.float64 + to_s16([
+        "l" + to_s16([
           (high >> 24) & 0xff, (high >> 16) & 0xff,
           (high >>  8) & 0xff, (high)       & 0xff,
           (low  >> 24) & 0xff, (low  >> 16) & 0xff,
@@ -139,15 +137,15 @@ module AsciiPack
       end
 
       def str8 (obj)
-        format_str TypeMap.str8, 2, obj
+        format_str "n", 2, obj
       end
 
       def str16 (obj)
-        format_str TypeMap.str16, 4, obj
+        format_str "o", 4, obj
       end
 
       def str32 (obj)
-        format_str TypeMap.str32, 8, obj
+        format_str "p", 8, obj
       end
 
       def map (obj)
@@ -156,13 +154,13 @@ module AsciiPack
         keys.push(pack(key) + pack(value))
       }
       if keys.length < 0x10
-        f = [TypeMap.map4, 1]
+        f = ["r", 1]
       elsif keys.length < 0x100
-        f = [TypeMap.map8, 2]
+        f = ["s", 2]
       elsif keys.length < 0x10000
-        f = [TypeMap.map16, 4]
+        f = ["t", 4]
       elsif keys.length < 0x100000000
-        f = [TypeMap.map32, 8]
+        f = ["u", 8]
       else
         raise "pack size limit over"
       end
@@ -175,13 +173,13 @@ module AsciiPack
           keys.push(pack(value));
         }
       if keys.length < 0x10
-        f = [TypeMap.array4, 1]
+        f = ["v", 1]
       elsif keys.length < 0x100
-        f = [TypeMap.array8, 2]
+        f = ["w", 2]
       elsif keys.length < 0x10000
-        f = [TypeMap.array16, 4]
+        f = ["x", 4]
       elsif keys.length < 0x100000000
-        f = [TypeMap.array32, 8]
+        f = ["y", 8]
       else
         raise "pack size limit over"
       end

data/lib/asciipack/unpacker.rb

@@ -1,43 +1,63 @@
-require 'asciipack/typemap.rb'
-
 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
-      @ret = nil
       @at = 0
       @ch = @ap[0]
     end
 
     def unpack
       move
+
+      if @@fixmap.key?(@ch)
+        return @@fixmap[@ch]
+      end
+
       case @ch
-      when /[0-9A-F]/; positive_fixint
+      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
-      when TypeMap.int4; int4
-      when TypeMap.int8; int8
-      when TypeMap.int16; int16
-      when TypeMap.int32; int32
-      when TypeMap.int64; int64
-      when TypeMap.uint8; uint8
-      when TypeMap.uint16; uint16
-      when TypeMap.uint32; uint32
-      when TypeMap.uint64; uint64
-      when TypeMap.float64; float64
-      when TypeMap.map4; map4
-      when TypeMap.map8; map8
-      when TypeMap.map16; map16
-      when TypeMap.map32; map32
-      when TypeMap.array4; array4
-      when TypeMap.array8; array8
-      when TypeMap.array16; array16
-      when TypeMap.array32; array32
-      when TypeMap.str8; str8
-      when TypeMap.str16; str16
-      when TypeMap.str32; str32
-      when TypeMap.nil; nil
-      when TypeMap.false; false
-      when TypeMap.true; true
       else raise "undefined type " + @ch.to_s
       end
     end
@@ -51,10 +71,10 @@ private
     end
 
     def cut (len)
-      @ret = @ap[@at...(@at + len)]
+      ret = @ap[@at...(@at + len)]
       @at += len
       @ch = @ap[@at]
-      @ret
+      ret
     end
 
     def int4
@@ -87,10 +107,6 @@ private
       (c[0].to_i(16) < 0x8) ? i : i - 0x10000000000000000;
     end
 
-    def positive_fixint
-      @ch.to_i(16)
-    end
-
     def uint8
       cut(2).to_i(16)
     end
@@ -156,7 +172,7 @@ private
     def array32; array(8) end
 
     def fixstr
-      len = @ch.ord - 71 # 71 = TypeMap.fixstr_0.ord
+      len = @ch.ord - 71 # 71 = "G".ord
       cut(len)
     end
 

data/lib/asciipack/version.rb

@@ -1,3 +1,3 @@
 module AsciiPack
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/spec/bench.rb

@@ -36,12 +36,14 @@ def bench(name)
   100000.times {
     yield
   }
-  p name + ': ' + (Time.now - t).to_s + 'ms'
+  p name + ': ' + (Time.now - t).to_s + 's'
 end
 
+tt = Time.now
 {
   "positive fixint" => 0,
   "uint 4" => 16,
+  "int 4" => -1,
   "fixstr" => "",
   "str 8" => '0123456789abcdef',
   "float 64" => 1/3,
@@ -52,4 +54,4 @@ end
   json_asciipack key, value
 }
 
-p AsciiPack.pack("あああ")
+p 'total: ' + (Time.now - tt).to_s + 's'

data/spec/format_spec.rb

@@ -74,29 +74,29 @@ describe AsciiPack do
     expect(AsciiPack.pack(-1 / 0.0)).to eq(T.float64 + 'fff0000000000000')
   end
 
-  it "fixstr" do
-    format "", T.fixstr_0, 1
-    format " ", T.fixstr_1, 2
-    format "あ", T.fixstr_1, 2
-    format "漢字", T.fixstr_2, 3
-    format " " * 0xe, T.fixstr_E, 15
-    format " " * 0xf, T.fixstr_F, 16
+  it "fixbin" do
+    format "", T.fixbin_0, 1
+    format " ", T.fixbin_1, 2
+    format "あ", T.fixbin_1, 2
+    format "漢字", T.fixbin_2, 3
+    format " " * 0xe, T.fixbin_E, 15
+    format " " * 0xf, T.fixbin_F, 16
   end
 
-  it "str 8" do
-    format "a" * 0x10, T.str8, 3 + 0x10
-    format "a" * 0xff, T.str8, 3 + 0xff
+  it "bin 8" do
+    format "a" * 0x10, T.bin8, 3 + 0x10
+    format "a" * 0xff, T.bin8, 3 + 0xff
   end
 
-  it "str 16" do
-    format "a" * 0x100, T.str16, 5 + 0x100
-    format "a" * 0xffff, T.str16, 5 + 0xffff
+  it "bin 16" do
+    format "a" * 0x100, T.bin16, 5 + 0x100
+    format "a" * 0xffff, T.bin16, 5 + 0xffff
   end
 
-  it "str 32" do
-    format "a" * 0x10000, T.str32, 9 + 0x10000
+  it "bin 32" do
+    format "a" * 0x10000, T.bin32, 9 + 0x10000
     # FIXME too late
-    # format "a" * 0xffffffff, T.str32, 9 + 0xffffffff
+    # format "a" * 0xffffffff, T.bin32, 9 + 0xffffffff
   end
 
   it "map 4" do

data/spec/spec_helper.rb

@@ -1,3 +1,67 @@
 require 'asciipack'
+require 'ostruct'
 
-T = AsciiPack::TypeMap
+T = OpenStruct.new({
+  :int4              => 'a',
+  :int8              => 'b',
+  :int16             => 'c',
+  :int32             => 'd',
+  :int64             => 'e',
+#   (blank)            => 'f',
+  :uint8             => 'g',
+  :uint16            => 'h',
+  :uint32            => 'i',
+  :uint64            => 'j',
+  :float32           => 'k',
+  :float64           => 'l',
+#   (blank)            => 'm',
+  :bin8              => 'n',
+  :bin16             => 'o',
+  :bin32             => 'p',
+#   (blank)            => 'q',
+  :map4              => 'r',
+  :map8              => 's',
+  :map16             => 't',
+  :map32             => 'u',
+  :array4            => 'v',
+  :array8            => 'w',
+  :array16           => 'x',
+  :array32           => 'y',
+#   (blank)            => 'z',
+  :positive_fixint_0 => '0',
+  :positive_fixint_1 => '1',
+  :positive_fixint_2 => '2',
+  :positive_fixint_3 => '3',
+  :positive_fixint_4 => '4',
+  :positive_fixint_5 => '5',
+  :positive_fixint_6 => '6',
+  :positive_fixint_7 => '7',
+  :positive_fixint_8 => '8',
+  :positive_fixint_9 => '9',
+  :positive_fixint_A => 'A',
+  :positive_fixint_B => 'B',
+  :positive_fixint_C => 'C',
+  :positive_fixint_D => 'D',
+  :positive_fixint_E => 'E',
+  :positive_fixint_F => 'F',
+  :fixbin_0          => 'G',
+  :fixbin_1          => 'H',
+  :fixbin_2          => 'I',
+  :fixbin_3          => 'J',
+  :fixbin_4          => 'K',
+  :fixbin_5          => 'L',
+  :fixbin_6          => 'M',
+  :fixbin_7          => 'N',
+  :fixbin_8          => 'O',
+  :fixbin_9          => 'P',
+  :fixbin_A          => 'Q',
+  :fixbin_B          => 'R',
+  :fixbin_C          => 'S',
+  :fixbin_D          => 'T',
+  :fixbin_E          => 'U',
+  :fixbin_F          => 'V',
+  :nil               => 'W',
+  :false             => 'X',
+  :true              => 'Y',
+#   (blank)            => 'Z',
+})

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: asciipack
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-13 00:00:00.000000000 Z
+date: 2013-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,7 +66,6 @@ files:
 - asciipack.gemspec
 - lib/asciipack.rb
 - lib/asciipack/packer.rb
-- lib/asciipack/typemap.rb
 - lib/asciipack/unpacker.rb
 - lib/asciipack/version.rb
 - spec/bench.rb

data/lib/asciipack/typemap.rb

@@ -1,68 +0,0 @@
-require 'ostruct'
-
-module AsciiPack
-  TypeMap = OpenStruct.new({
-    :int4              => 'a',
-    :int8              => 'b',
-    :int16             => 'c',
-    :int32             => 'd',
-    :int64             => 'e',
-#   (blank)            => 'f',
-    :uint8             => 'g',
-    :uint16            => 'h',
-    :uint32            => 'i',
-    :uint64            => 'j',
-    :float32           => 'k',
-    :float64           => 'l',
-#   (blank)            => 'm',
-    :str8              => 'n',
-    :str16             => 'o',
-    :str32             => 'p',
-#   (blank)            => 'q',
-    :map4              => 'r',
-    :map8              => 's',
-    :map16             => 't',
-    :map32             => 'u',
-    :array4            => 'v',
-    :array8            => 'w',
-    :array16           => 'x',
-    :array32           => 'y',
-#   (blank)            => 'z',
-    :positive_fixint_0 => '0',
-    :positive_fixint_1 => '1',
-    :positive_fixint_2 => '2',
-    :positive_fixint_3 => '3',
-    :positive_fixint_4 => '4',
-    :positive_fixint_5 => '5',
-    :positive_fixint_6 => '6',
-    :positive_fixint_7 => '7',
-    :positive_fixint_8 => '8',
-    :positive_fixint_9 => '9',
-    :positive_fixint_A => 'A',
-    :positive_fixint_B => 'B',
-    :positive_fixint_C => 'C',
-    :positive_fixint_D => 'D',
-    :positive_fixint_E => 'E',
-    :positive_fixint_F => 'F',
-    :fixstr_0          => 'G',
-    :fixstr_1          => 'H',
-    :fixstr_2          => 'I',
-    :fixstr_3          => 'J',
-    :fixstr_4          => 'K',
-    :fixstr_5          => 'L',
-    :fixstr_6          => 'M',
-    :fixstr_7          => 'N',
-    :fixstr_8          => 'O',
-    :fixstr_9          => 'P',
-    :fixstr_A          => 'Q',
-    :fixstr_B          => 'R',
-    :fixstr_C          => 'S',
-    :fixstr_D          => 'T',
-    :fixstr_E          => 'U',
-    :fixstr_F          => 'V',
-    :nil               => 'W',
-    :false             => 'X',
-    :true              => 'Y',
-#   (blank)            => 'Z',
-  })
-end