asciipack 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f5ab153658fcc0d6bf96fc72ba0b3f19923a888
-  data.tar.gz: 58520e74b5d6aa9dd8d6ed8b42dc8a8a77b012ab
+  metadata.gz: 2ed12a4882ea2f096a50dba7dd1832324432d90d
+  data.tar.gz: 4437fc5441e2c033a8201a135bff2738f522c320
 SHA512:
-  metadata.gz: f9983cc226fd9edb1a150f0c47a0dd3bc5f7ee93dd61040f55ec85f9047dcf85b6c3fe49b61783c5818080b1dc883687fb814f45fee36d5d402d8ad8e0968011
-  data.tar.gz: 5784d28550c7844af1fc747b8a7f44a05f08493cc37a3206f7397ac3ed89a05d0fa1a50d1947076b2feff3681c242dab5d82a10a6913404d45940d21b874905b
+  metadata.gz: 79fe2fde39fc99168eb2ce30db2b9078102414af5154ad98d4193917df1f3ef9de7e8a31c33625e77a072a54e729aac8a44730a33320f29b4f36a9d4084b100f
+  data.tar.gz: 451a0f8d12f1928f1057d8b60aebc74abfc5c5739ce7aa1e9fd95f1933b1c03b3238f32299f4b373eee1c60b50ea9c487b63e62ef83981dc1799ee744d13e08b

data/README.md

@@ -1,14 +1,16 @@
 # AsciiPack
 
+[![Gem Version](https://badge.fury.io/rb/asciipack.png)](http://badge.fury.io/rb/asciipack)
+
 ## Synopsis
 
 ```ruby
 demo = {"compact"=>true,"binary"=>0}
 ap = AsciiPack.pack demo
-p ap //=> "q2m7compactum6binaryf0"
+p ap #=> "r2NcompactYMschema0"
 
 unpacked = AsciiPack.unpack ap
-p unpacked //=> {"compact"=>true,"binary"=>0}
+p unpacked #=> {"compact"=>true,"binary"=>0}
 ```
 
 ## Install

data/asciipack.gemspec

@@ -1,4 +1,4 @@
-# coding: utf-8
+# encoding: ascii-8bit
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'asciipack/version'

data/lib/asciipack.rb

@@ -1,3 +1,3 @@
 require "asciipack/version"
-require 'asciipack/pack.rb'
-require 'asciipack/unpack.rb'
+require 'asciipack/packer.rb'
+require 'asciipack/unpacker.rb'

data/lib/asciipack/{pack.rb → packer.rb}

@@ -13,7 +13,7 @@ module AsciiPack
           if obj.kind_of?(Integer)
             if 0 <= obj
               if obj < 0x10
-                uint4 obj
+                positive_fixint obj
               elsif obj < 0x100
                 uint8 obj
               elsif obj < 0x10000
@@ -44,13 +44,13 @@ module AsciiPack
         when obj.kind_of?(String)
           case obj.length
           when 0...0x10
-            str4 obj
+            fixbin obj
           when 0x10...0x100
-            str8 obj
+            bin8 obj
           when 0x100...0x10000
-            str16 obj
+            bin16 obj
           when 0x10000...0x100000000
-            str32 obj
+            bin32 obj
           else
             raise "pack size limit over"
           end
@@ -89,8 +89,8 @@ module AsciiPack
         TypeMap.int64 + ((obj & 0xffffffffffffffff).to_s(16))
       end
 
-      def uint4 (obj)
-        format_uint(TypeMap.uint4, 1, obj)
+      def positive_fixint (obj)
+        obj.to_s(16).upcase
       end
 
       def uint8 (obj)
@@ -134,28 +134,39 @@ module AsciiPack
         ])
       end
 
-      def str4 (obj)
-        format_str TypeMap.str4, 1, obj
+      def fixbin (obj)
+        (obj.length + 71).chr + obj
       end
 
-      def str8 (obj)
-        format_str TypeMap.str8, 2, obj
+      def bin8 (obj)
+        format_bin TypeMap.bin8, 2, obj
       end
 
-      def str16 (obj)
-        format_str TypeMap.str16, 4, obj
+      def bin16 (obj)
+        format_bin TypeMap.bin16, 4, obj
       end
 
-      def str32 (obj)
-        format_str TypeMap.str32, 8, obj
+      def bin32 (obj)
+        format_bin TypeMap.bin32, 8, obj
       end
 
       def map (obj)
-        keys = [];
-        obj.each { |key, value|
-          keys.push(pack(key.to_s) + pack(value));
-        }
-        TypeMap.map + keys.length.to_s + keys.join('');
+      keys = [];
+      obj.each { |key, value|
+        keys.push(pack(key) + pack(value))
+      }
+      if keys.length < 0x10
+        f = [TypeMap.map4, 1]
+      elsif keys.length < 0x100
+        f = [TypeMap.map8, 2]
+      elsif keys.length < 0x10000
+        f = [TypeMap.map16, 4]
+      elsif keys.length < 0x100000000
+        f = [TypeMap.map32, 8]
+      else
+        raise "pack size limit over"
+      end
+      format_uint(f[0], f[1], keys.length) + keys.join('');
       end
 
       def array (obj)
@@ -163,7 +174,18 @@ module AsciiPack
         obj.each { |value|
           keys.push(pack(value));
         }
-        TypeMap.array + keys.length.to_s + keys.join('');
+      if keys.length < 0x10
+        f = [TypeMap.array4, 1]
+      elsif keys.length < 0x100
+        f = [TypeMap.array8, 2]
+      elsif keys.length < 0x10000
+        f = [TypeMap.array16, 4]
+      elsif keys.length < 0x100000000
+        f = [TypeMap.array32, 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)
@@ -173,11 +195,11 @@ module AsciiPack
         type + zero + hex;
       end
 
-      def format_str (type, length, str)
-        hex = str.length.to_s(16);
+      def format_bin (type, length, bin)
+        hex = bin.length.to_s(16);
         len = length - hex.length;
         zero = '0' * len;
-        type + zero + hex + str;
+        type + zero + hex + bin;
       end
 
       def to_s16 (a)

data/lib/asciipack/typemap.rb

@@ -1,35 +1,68 @@
+require 'ostruct'
+
 module AsciiPack
-  class TypeMap
-    class << self
-      {
-        :int4 =>    'a',
-        :int8 =>    'b',
-        :int16 =>   'c',
-        :int32 =>   'd',
-        :int64 =>   'e',
-        :uint4 =>   'f',
-        :uint8 =>   'g',
-        :uint16 =>  'h',
-        :uint32 =>  'i',
-        :uint64 =>  'j',
-        :float32 => 'k',
-        :float64 => 'l',
-        :str4 =>    'm',
-        :str8 =>    'n',
-        :str16 =>   'o',
-        :str32 =>   'p',
-        :map =>     'q',
-        :array =>   'r',
-        :nil =>     's',
-        :false =>   't',
-        :true =>    'u',
-      }.each { |name, char|
-        module_eval %{
-          def #{name}
-            "#{char}"
-          end
-        }
-      }
-    end
-  end
+  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',
+    :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',
+  })
 end

data/lib/asciipack/{unpack.rb → unpacker.rb}

@@ -12,23 +12,29 @@ module AsciiPack
     def unpack
       move
       case @ch
+      when /[0-9A-F]/; positive_fixint
+      when /[G-V]/; fixbin
       when TypeMap.int4; int4
       when TypeMap.int8; int8
       when TypeMap.int16; int16
       when TypeMap.int32; int32
       when TypeMap.int64; int64
-      when TypeMap.uint4; uint4
       when TypeMap.uint8; uint8
       when TypeMap.uint16; uint16
       when TypeMap.uint32; uint32
       when TypeMap.uint64; uint64
       when TypeMap.float64; float64
-      when TypeMap.map; map
-      when TypeMap.array; array
-      when TypeMap.str4; str4
-      when TypeMap.str8; str8
-      when TypeMap.str16; str16
-      when TypeMap.str32; str32
+      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.bin8; bin8
+      when TypeMap.bin16; bin16
+      when TypeMap.bin32; bin32
       when TypeMap.nil; nil
       when TypeMap.false; false
       when TypeMap.true; true
@@ -40,13 +46,7 @@ private
 
     def move
       @ch = @ap[@at]
-      @at = @at + 1
-      @ch
-    end
-
-    def back
-      @ch = @ap[@at]
-      @at -= 1
+      @at += 1
       @ch
     end
 
@@ -57,48 +57,38 @@ private
       @ret
     end
 
-    def length
-      ret = []
-      while (/\d/ =~ @ch)
-        ret << @ch
-        move()
-      end
-      back()
-      ret.join('').to_i
-    end
-
     def int4
       move
       i = @ch.to_i(16)
-      return (@ch[0].to_i(16) < 0x8) ? i : i - 0x10;
+      (@ch[0].to_i(16) < 0x8) ? i : i - 0x10;
     end
 
     def int8
       c = cut(2)
       i = c.to_i(16)
-      return (c[0].to_i(16) < 0x8) ? i : i - 0x100;
+      (c[0].to_i(16) < 0x8) ? i : i - 0x100;
     end
 
     def int16
       c = cut(4)
       i = c.to_i(16)
-      return (c[0].to_i(16) < 0x8) ? i : i - 0x10000;
+      (c[0].to_i(16) < 0x8) ? i : i - 0x10000;
     end
 
     def int32
       c = cut(8)
       i = c.to_i(16)
-      return (c[0].to_i(16) < 0x8) ? i : i - 0x100000000;
+      (c[0].to_i(16) < 0x8) ? i : i - 0x100000000;
     end
 
     def int64
       c = cut(16)
       i = c.to_i(16)
-      return (c[0].to_i(16) < 0x8) ? i : i - 0x10000000000000000;
+      (c[0].to_i(16) < 0x8) ? i : i - 0x10000000000000000;
     end
 
-    def uint4
-      move.to_i(16)
+    def positive_fixint
+      @ch.to_i(16)
     end
 
     def uint8
@@ -136,10 +126,9 @@ private
       ((sign == 0 ? 1 : -1) * frac * (2**(exp - 52))).to_f
     end
 
-    def map
-      move
+    def map (length)
+      len = cut(length).to_i(16)
       hash = {}
-      len = length()
       len.times {
         key = unpack
         hash[key] = unpack
@@ -147,32 +136,41 @@ private
       hash
     end
 
-    def array
-      move
+    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 = length()
       len.times {
         array << unpack
       }
       array
     end
 
-    def str4
-      len = cut(1).to_i(16)
+    def array4; array(1) end
+    def array8; array(2) end
+    def array16; array(4) end
+    def array32; array(8) end
+
+    def fixbin
+      len = @ch.ord - 71 # 71 = TypeMap.fixbin_0.ord
       cut(len)
     end
 
-    def str8
+    def bin8
       len = cut(2).to_i(16)
       cut(len)
     end
 
-    def str16
+    def bin16
       len = cut(4).to_i(16)
       cut(len)
     end
 
-    def str32
+    def bin32
       len = cut(8).to_i(16)
       cut(len)
     end

data/lib/asciipack/version.rb

@@ -1,3 +1,3 @@
 module AsciiPack
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/bench.rb

@@ -6,32 +6,49 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'asciipack'
 require 'json'
 require 'msgpack'
-require 'benchmark'
 
-value = {}
-30.times { |i|
-  value[i] = case i % 5
-             when 0; 0xffffffff
-             when 1; " " * 0xffff
-             when 2; [1.1, -1.1, 1/3, 5]
-             when 3; JSON.parse(value.to_json)
-             when 4; nil
-             end
-}
-json = JSON.generate value
-ap = AsciiPack.pack value
-ms = Marshal.dump value
-msg = MessagePack.pack value
-n = 10
+def json_asciipack(name, obj)
+  obj = [obj]
+  json = obj.to_json
+  ap = AsciiPack.pack obj
+  ms = Marshal.dump obj
+  msg = MessagePack.pack obj
+
+  p '[' + name + ']'
+  bench "AsciiPack.pack" do AsciiPack.pack obj end
+  bench "AsciiPack.unpack" do AsciiPack.unpack ap end
+  bench "JSON.generate" do obj.to_json end
+  bench "JSON.parse" do JSON.parse json end
+  bench "Marshal.dump" do Marshal.dump obj end
+  bench "Marshal.load" do Marshal.load ms end
+  bench "MessagePack.pack" do MessagePack.pack obj end
+  bench "MessagePack.unpack" do MessagePack.unpack msg end
+  p({
+    :ap => ap.length,
+    :json => json.length,
+    :marshal => ms.length,
+    :msgpack => msg.length
+  })
+end
 
-Benchmark.bm do |x|
-  x.report("JSON.generate") {n.times{ JSON.generate value }}
-  x.report("JSON.parse") {n.times{ JSON.parse json }}
-  x.report("AsciiPack.pack") {n.times{ AsciiPack.pack value }}
-  x.report("AsciiPack.unpack") {n.times{ AsciiPack.unpack ap }}
-  x.report("Marshal.dump") {n.times{ Marshal.dump value }}
-  x.report("Marshal.load") {n.times{ Marshal.load ms }}
-  x.report("MessagePack.pack") {n.times{ MessagePack.pack value }}
-  x.report("MessagePack.unpack") {n.times{ MessagePack.unpack msg }}
+def bench(name)
+  t = Time.now
+  100000.times {
+    yield
+  }
+  p name + ': ' + (Time.now - t).to_s + 'ms'
 end
 
+{
+  "positive fixint" => 0,
+  "uint 4" => 16,
+  "fixbin" => "",
+  "bin 8" => '0123456789abcdef',
+  "float 64" => 1/3,
+  "map 4" => {},
+  "array 4" => [],
+  "nil" => nil,
+}.each { |key, value|
+  json_asciipack key, value
+}
+

data/spec/format_spec.rb

@@ -1,8 +1,11 @@
-# encoding: utf-8
+# encoding: ascii-8bit
 
 require 'spec_helper'
 
 describe AsciiPack do
+  it "intro" do
+    expect(AsciiPack.pack({"compact"=>true,"binary"=>0})).to eq('r2NcompactYMbinary0')
+  end
   it "int 4" do
     format -1, T.int4, 2
     format -8, T.int4, 2
@@ -28,9 +31,11 @@ describe AsciiPack do
     format -0x8000000000000000, T.int64, 17
   end
 
-  it "uint 4" do
-    format 0x0, T.uint4, 2
-    format 0xf, T.uint4, 2
+  it "positive fixint" do
+    format 0x0, T.positive_fixint_0, 1
+    format 0x1, T.positive_fixint_1, 1
+    format 0xe, T.positive_fixint_E, 1
+    format 0xf, T.positive_fixint_F, 1
   end
 
   it "uint 8" do
@@ -68,37 +73,69 @@ describe AsciiPack do
     expect(AsciiPack.pack(-1 / 0.0)).to eq(T.float64 + 'fff0000000000000')
   end
 
-  it "str 4" do
-    format "", T.str4, 2
-    format " " * 0xf, T.str4, 17
+  it "fixbin" do
+    format "", T.fixbin_0, 1
+    format " ", T.fixbin_1, 2
+    format " " * 0xe, T.fixbin_E, 15
+    format " " * 0xf, T.fixbin_F, 16
+  end
+
+  it "bin 8" do
+    format "a" * 0x10, T.bin8, 3 + 0x10
+    format "a" * 0xff, T.bin8, 3 + 0xff
+  end
+
+  it "bin 16" do
+    format "a" * 0x100, T.bin16, 5 + 0x100
+    format "a" * 0xffff, T.bin16, 5 + 0xffff
   end
 
-  it "str 8" do
-    format "a" * 0x10, T.str8, 3 + 0x10
-    format "a" * 0xff, T.str8, 3 + 0xff
+  it "bin 32" do
+    format "a" * 0x10000, T.bin32, 9 + 0x10000
+    # FIXME too late
+    # format "a" * 0xffffffff, T.bin32, 9 + 0xffffffff
   end
 
-  it "str 16" do
-    format "a" * 0x100, T.str16, 5 + 0x100
-    format "a" * 0xffff, T.str16, 5 + 0xffff
+  it "map 4" do
+    format_map 0, T.map4
+    format_map 0xf, T.map4
   end
 
-  it "str 32" do
-    format "a" * 0x10000, T.str32, 9 + 0x10000
-    # too late
-    # format "a" * 0xffffffff, T.str32, 9 + 0xffffffff
+  it "map 8" do
+    format_map 0x10, T.map8
+    format_map 0xff, T.map8
   end
 
-  it "map" do
-    format({}, T.map, 2)
-    format({"hash" => {}}, T.map, 10)
-    expect(AsciiPack.pack({})).to eq('q0')
+  it "map 16" do
+    format_map 0x100, T.map16
+    format_map 0xffff, T.map16
   end
 
-  it "array" do
-    format([], T.array, 2)
-    format([1,2,3], T.array, 8)
-    expect(AsciiPack.pack([])).to eq('r0')
+  it "map 32" do
+    format_map 0x10000, T.map32
+    # FIXME too late
+    # format_map 0xffffffff, T.map32
+  end
+
+  it "array 4" do
+    format_array 0, T.array4
+    format_array 0xf, T.array4
+  end
+
+  it "array 8" do
+    format_array 0x10, T.array8
+    format_array 0xff, T.array8
+  end
+
+  it "array 16" do
+    format_array 0x100, T.array16
+    format_array 0xffff, T.array16
+  end
+
+  it "array 32" do
+    format_array 0x10000, T.array32
+    # FIXME too late
+    # format_array 0xffffffff, T.array32
   end
 
   it "nil" do
@@ -120,3 +157,19 @@ def format (object, first, length)
   expect(ap.length).to eq(length)
   expect(AsciiPack.unpack(ap)).to eq(object)
 end
+
+def format_map (count, first)
+  map = {}
+  count.times{ |i| map[i] = 0 }
+  ap = AsciiPack.pack(map)
+  expect(ap[0]).to eq(first)
+  expect(AsciiPack.unpack(ap)).to eq(map)
+end
+
+def format_array (count, first)
+  array = []
+  count.times{ |i| array[i] = 0 }
+  ap = AsciiPack.pack(array)
+  expect(ap[0]).to eq(first)
+  expect(AsciiPack.unpack(ap)).to eq(array)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: asciipack
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-01 00:00:00.000000000 Z
+date: 2013-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,9 +65,9 @@ files:
 - Rakefile
 - asciipack.gemspec
 - lib/asciipack.rb
-- lib/asciipack/pack.rb
+- lib/asciipack/packer.rb
 - lib/asciipack/typemap.rb
-- lib/asciipack/unpack.rb
+- lib/asciipack/unpacker.rb
 - lib/asciipack/version.rb
 - spec/bench.rb
 - spec/format_spec.rb
@@ -100,3 +100,4 @@ test_files:
 - spec/bench.rb
 - spec/format_spec.rb
 - spec/spec_helper.rb
+has_rdoc: