asciipack 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 68234c0bbe69684169776ff05c4792716712ede4
+  data.tar.gz: 784a5ee093464b729d8d6f067db6d9614cdbd423
+SHA512:
+  metadata.gz: c6836d277b9b5a37539e839b7768e3cd618e40f1bef95d099573679f2def33579b058fee2e143a2006b57bb0be45a1249a20b4f712202e68000ab05d786d016e
+  data.tar.gz: 4b49fd6f986b0a5e7d2030499388a87ad8530b2fab0ba3d80682ca5c1628e0274e177bc38d06930f56639e0885798420932910acb1389a92ae99247c807f7e9f

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 ksss
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,20 @@
+# AsciiPack
+
+## Synopsis
+
+```ruby
+demo = {"compact"=>true,"binary"=>0}
+ap = AsciiPack.pack demo
+p ap //=> "q2m7compactum6binaryf0"
+
+unpacked = AsciiPack.unpack ap
+p unpacked //=> {"compact"=>true,"binary"=>0}
+```
+
+## Install
+
+```
+gem install asciipack
+```
+
+see also [https://github.com/ksss/AsciiPack/blob/master/README.md](https://github.com/ksss/AsciiPack/blob/master/README.md)

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-Ilib"]
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = true
+end
+

data/asciipack.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'asciipack/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "asciipack"
+  spec.version       = AsciiPack::VERSION
+  spec.author       = "ksss"
+  spec.email         = "co000ri@gmail.com"
+  spec.description   = %q{AsciiPack is an object serialization inspired by MessagePack.}
+  spec.summary       = %q{AsciiPack is an object serialization inspired by MessagePack.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ['~> 2.11']
+end

data/lib/asciipack.rb

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

data/lib/asciipack/pack.rb

@@ -0,0 +1,199 @@
+require 'asciipack/typemap.rb'
+
+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
+                uint4 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
+            str4 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?
+          TypeMap.nil
+        when obj == false
+          TypeMap.false
+        when obj == true
+          TypeMap.true
+        end
+      end
+
+      private
+
+      def int4 (obj)
+        TypeMap.int4 + ((obj & 0xf).to_s(16))
+      end
+
+      def int8 (obj)
+        TypeMap.int8 + ((obj & 0xff).to_s(16))
+      end
+
+      def int16 (obj)
+        TypeMap.int16 + ((obj & 0xffff).to_s(16))
+      end
+
+      def int16 (obj)
+        TypeMap.int16 + ((obj & 0xffff).to_s(16))
+      end
+
+      def int32 (obj)
+        TypeMap.int32 + ((obj & 0xffffffff).to_s(16))
+      end
+
+      def int64 (obj)
+        TypeMap.int64 + ((obj & 0xffffffffffffffff).to_s(16))
+      end
+
+      def uint4 (obj)
+        format_uint(TypeMap.uint4, 1, obj)
+      end
+
+      def uint8 (obj)
+        format_uint(TypeMap.uint8, 2, obj)
+      end
+
+      def uint16 (obj)
+        format_uint(TypeMap.uint16, 4, obj)
+      end
+
+      def uint32 (obj)
+        format_uint(TypeMap.uint32, 8, obj)
+      end
+
+      def uint64 (obj)
+        format_uint(TypeMap.uint64, 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
+          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)
+
+        TypeMap.float64 + 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 str4 (obj)
+        format_str TypeMap.str4, 1, obj
+      end
+
+      def str8 (obj)
+        format_str TypeMap.str8, 2, obj
+      end
+
+      def str16 (obj)
+        format_str TypeMap.str16, 4, obj
+      end
+
+      def str32 (obj)
+        format_str TypeMap.str32, 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('');
+      end
+
+      def array (obj)
+        keys = [];
+        obj.each { |value|
+          keys.push(pack(value));
+        }
+        TypeMap.array + keys.length.to_s + 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/typemap.rb

@@ -0,0 +1,35 @@
+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
+end

data/lib/asciipack/unpack.rb

@@ -0,0 +1,187 @@
+require 'asciipack/typemap.rb'
+
+module AsciiPack
+  class Unpacker
+    def initialize (ap)
+      @ap = ap
+      @ret = nil
+      @at = 0
+      @ch = @ap[0]
+    end
+
+    def unpack
+      move
+      case @ch
+      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.nil; nil
+      when TypeMap.false; false
+      when TypeMap.true; true
+      else raise "undefined type " + @ch.to_s
+      end
+    end
+
+private
+
+    def move
+      @ch = @ap[@at]
+      @at = @at + 1
+      @ch
+    end
+
+    def back
+      @ch = @ap[@at]
+      @at -= 1
+      @ch
+    end
+
+    def cut (len)
+      @ret = @ap[@at...(@at + len)]
+      @at += len
+      @ch = @ap[@at]
+      @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;
+    end
+
+    def int8
+      c = cut(2)
+      i = c.to_i(16)
+      return (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;
+    end
+
+    def int32
+      c = cut(8)
+      i = c.to_i(16)
+      return (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;
+    end
+
+    def uint4
+      move.to_i(16)
+    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
+      move
+      hash = {}
+      len = length()
+      len.times {
+        key = unpack
+        hash[key] = unpack
+      }
+      hash
+    end
+
+    def array
+      move
+      array = []
+      len = length()
+      len.times {
+        array << unpack
+      }
+      array
+    end
+
+    def str4
+      len = cut(1).to_i(16)
+      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

data/lib/asciipack/version.rb

@@ -0,0 +1,3 @@
+module AsciiPack
+  VERSION = "0.0.1"
+end

data/spec/bench.rb

@@ -0,0 +1,37 @@
+#! /usr/bin/env ruby
+
+lib = File.expand_path('../../lib', __FILE__)
+$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
+
+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 }}
+end
+

data/spec/format_spec.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe AsciiPack do
+  it "int 4" do
+    format -1, T.int4, 2
+    format -8, T.int4, 2
+  end
+
+  it "int 8" do
+    format -0x9,  T.int8, 3
+    format -0x80, T.int8, 3
+  end
+
+  it "int 16" do
+    format -0x81,   T.int16, 5
+    format -0x8000, T.int16, 5
+  end
+
+  it "int 32" do
+    format -0x8001,     T.int32, 9
+    format -0x80000000, T.int32, 9
+  end
+
+  it "int 64" do
+    format -0x80000001,         T.int64, 17
+    format -0x8000000000000000, T.int64, 17
+  end
+
+  it "uint 4" do
+    format 0x0, T.uint4, 2
+    format 0xf, T.uint4, 2
+  end
+
+  it "uint 8" do
+    format 0x10, T.uint8, 3
+    format 0xff, T.uint8, 3
+  end
+
+  it "uint 16" do
+    format 0x100,  T.uint16, 5
+    format 0xffff, T.uint16, 5
+  end
+
+  it "uint 32" do
+    format 0x10000,    T.uint32, 9
+    format 0xffffffff, T.uint32, 9
+  end
+
+  it "uint 64" do
+    format 0x100000000,        T.uint64, 17
+    format 0xffffffffffffffff, T.uint64, 17
+  end
+
+  it "float 64" do
+    format 1/3.0, T.float64, 17
+    format 1.0, T.float64, 17
+    format 0.1, T.float64, 17
+    format -0.1, T.float64, 17
+    expect(AsciiPack.pack(-0.1)).to eq(T.float64 + 'bfb999999999999a')
+    expect(AsciiPack.pack(1.0)).to eq(T.float64 + '3ff0000000000000')
+    expect(AsciiPack.pack(1.0000000000000002)).to eq(T.float64 + '3ff0000000000001')
+    expect(AsciiPack.pack(1.0000000000000004)).to eq(T.float64 + '3ff0000000000002')
+    expect(AsciiPack.pack(1/3.0)).to eq(T.float64 + '3fd5555555555555')
+    expect(AsciiPack.pack(Float::NAN)).to eq(T.float64 + '7fffffffffffffff')
+    expect(AsciiPack.pack(1 / 0.0)).to eq(T.float64 + '7ff0000000000000')
+    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
+  end
+
+  it "str 8" do
+    format "a" * 0x10, T.str8, 3 + 0x10
+    format "a" * 0xff, T.str8, 3 + 0xff
+  end
+
+  it "str 16" do
+    format "a" * 0x100, T.str16, 5 + 0x100
+    format "a" * 0xffff, T.str16, 5 + 0xffff
+  end
+
+  it "str 32" do
+    format "a" * 0x10000, T.str32, 9 + 0x10000
+    # too late
+    # format "a" * 0xffffffff, T.str32, 9 + 0xffffffff
+  end
+
+  it "map" do
+    format({}, T.map, 2)
+    format({"hash" => {}}, T.map, 10)
+    expect(AsciiPack.pack({})).to eq('q0')
+  end
+
+  it "array" do
+    format([], T.array, 2)
+    format([1,2,3], T.array, 8)
+    expect(AsciiPack.pack([])).to eq('r0')
+  end
+
+  it "nil" do
+    format nil, T.nil, 1
+  end
+
+  it "false" do
+    format false, T.false, 1
+  end
+
+  it "true" do
+    format true, T.true, 1
+  end
+end
+
+def format (object, first, length)
+  ap = AsciiPack.pack(object)
+  expect(ap[0]).to eq(first)
+  expect(ap.length).to eq(length)
+  expect(AsciiPack.unpack(ap)).to eq(object)
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'asciipack'
+
+T = AsciiPack::TypeMap

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: asciipack
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ksss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+description: AsciiPack is an object serialization inspired by MessagePack.
+email: co000ri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- asciipack.gemspec
+- lib/asciipack.rb
+- lib/asciipack/pack.rb
+- lib/asciipack/typemap.rb
+- lib/asciipack/unpack.rb
+- lib/asciipack/version.rb
+- spec/bench.rb
+- spec/format_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: AsciiPack is an object serialization inspired by MessagePack.
+test_files:
+- spec/bench.rb
+- spec/format_spec.rb
+- spec/spec_helper.rb