zero_formatter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce0b71bd71b66c966b57ea8f569d94f8fd9edd99
+  data.tar.gz: 20c1425f252012ccfe9a19c320b948eeebbdadc6
+SHA512:
+  metadata.gz: d17bc2ae62ef26d739758a048af5cdf40d2afd14c8b5595bd9033b0954b2d22d04c8af433c2172d4a198ca446b4a91dd84d8f3f853453c3dace22edfecf77058
+  data.tar.gz: da46cc4176988bd8cd762e9969183b2e1994967244ed2395d2596d1f3d1bf93b30666f12598d6982f1f45abff1c6b42d7ba9abd4dfb6e074d28eb2d933d81ac5

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/coverage/
+/test/reports/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zero_formatter.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,21 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+#
+guard "minitest" do
+  watch %r{^test/.+\.rb}
+  watch(%r{^lib/(.+)\.rb}){|m| "test/#{m[1]}_test.rb" }
+end

data/README.md

@@ -0,0 +1,40 @@
+# ZeroFormatter
+
+[![CircleCI](https://circleci.com/gh/aki017/ZeroFormatter.rb.svg?style=svg)](https://circleci.com/gh/aki017/ZeroFormatter.rb)
+[![Code Climate](https://codeclimate.com/github/aki017/ZeroFormatter.rb/badges/gpa.svg)](https://codeclimate.com/github/aki017/ZeroFormatter.rb)
+[![Test Coverage](https://codeclimate.com/github/aki017/ZeroFormatter.rb/badges/coverage.svg)](https://codeclimate.com/github/aki017/ZeroFormatter.rb/coverage)
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/zero_formatter`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zero_formatter'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zero_formatter
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/aki017/ZeroFormatter.rb .
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "zero_formatter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,10 @@
+machine:
+  ruby:
+    version:
+      2.3.1
+test:
+  post:
+    - cp -r coverage "$CIRCLE_ARTIFACTS/coverage"
+    - cp -r test/reports "$CIRCLE_TEST_REPORTS/test"
+    - bundle exec codeclimate-test-reporter
+

data/lib/zero_formatter.rb

@@ -0,0 +1,18 @@
+require "zero_formatter/version"
+require "zero_formatter/utils"
+require "zero_formatter/serializer"
+require "zero_formatter/zero_formattable"
+
+module ZeroFormatter
+  def self.load(klass, bytes)
+    serializer.load(klass, bytes)
+  end
+
+  def self.dump(data)
+    serializer.dump(data)
+  end
+
+  def self.serializer
+    @serializer ||= Serializer.new
+  end
+end

data/lib/zero_formatter/serializer.rb

@@ -0,0 +1,111 @@
+require "zero_formatter/serializer/int"
+require "zero_formatter/serializer/uint"
+require "zero_formatter/serializer/fp"
+require "zero_formatter/serializer/bool"
+require "zero_formatter/serializer/string"
+require "zero_formatter/serializer/time"
+
+module ZeroFormatter
+  class Serializer
+    def initialize(*args)
+      add_implement Int8Serializer
+      add_implement Int16Serializer
+      add_implement Int32Serializer
+      add_implement Int64Serializer
+
+      add_implement UInt8Serializer
+      add_implement UInt16Serializer
+      add_implement UInt32Serializer
+      add_implement UInt64Serializer
+
+      add_implement FloatSerializer
+      add_implement DoubleSerializer
+
+      add_implement BoolSerializer
+
+      add_implement CharSerializer
+      add_implement StringSerializer
+
+      add_implement TimeSpanSerializer
+      add_implement TimeSerializer
+      add_implement TimeWithOffsetSerializer
+    end
+
+    def dump(value)
+      last_index = value.class.fields.last[:index]
+
+      data_headers = []
+      data_header = "".force_encoding("ASCII-8bit")
+      data = "".force_encoding("ASCII-8bit")
+      header_size = 4 + 4 + (last_index+1)*4
+      
+      value.class.fields.each do |field|
+        data_headers[field[:index]] = header_size + data.bytesize
+
+        v = value.send(field[:name])
+        if field[:options][:nullable]
+          data << Utils.write_u1(v.nil? ? 0 : 1)
+        end
+
+        data << get_serializer(field[:type]).serialize(v)
+      end
+
+      data_headers.each do |h|
+        data_header << Utils.write_s4(h || -1)
+      end
+
+      data_size = header_size + data.bytesize
+
+      response = "".force_encoding("ASCII-8bit")
+      response << Utils.write_s4(data_size)
+      response << Utils.write_s4(last_index)
+      response << data_header
+      response << data
+      response
+    end
+
+    def load(klass, bytes)
+      object_size = Utils.read_s4(bytes, 0)
+      raise "Object size missmatch, expected=#{object_size}, actual=#{bytes.bytesize}" if object_size != bytes.bytesize
+
+      last_index = Utils.read_s4(bytes, 4)
+      raise "Last index is negative, #{last_index}" if last_index < 0
+      raise "Last index is bigger, expected=#{klass.fields.last[:index]}, actual=#{last_index}" if klass.fields.last[:index] < last_index
+
+      result = klass.new
+
+      klass.fields.each do |field|
+        index = field[:index]
+        offset = Utils.read_s4(bytes, 8+4*index)
+        if field[:options][:nullable]
+          if Utils.read_u1(bytes, offset) == 0
+            result.send("#{field[:name]}=", nil)
+            next
+          end
+          offset += 1
+        end
+
+        value = get_serializer(field[:type]).deserialize(bytes, offset)
+        
+        result.send("#{field[:name]}=", value)
+      end
+      result
+    end
+    private
+    def add_implement(klass)
+      @implements ||= []
+      @implements << klass
+      gen_type_table
+    end
+
+    def get_serializer(type)
+      @type_table[type] || raise("Unknown type #{type}")
+    end
+
+    def gen_type_table
+      @type_table = Hash[@implements.flat_map{|klass|
+        klass::Alias.map{|a| [a, klass]}
+      }]
+    end
+  end
+end

data/lib/zero_formatter/serializer/bool.rb

@@ -0,0 +1,15 @@
+module ZeroFormatter
+  class Serializer
+    module BoolSerializer
+      extend self
+      Alias = %i(bool boolean)
+      def serialize(value)
+        Utils.write_u1(value ? 1 : 0)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_u1(bytes, offset)==1
+      end
+    end
+  end
+end

data/lib/zero_formatter/serializer/fp.rb

@@ -0,0 +1,27 @@
+module ZeroFormatter
+  class Serializer
+    module FloatSerializer
+      extend self
+      Alias = %i(single float)
+      def serialize(value)
+        Utils.write_f4(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_f4(bytes, offset)
+      end
+    end
+
+    module DoubleSerializer
+      extend self
+      Alias = %i(double)
+      def serialize(value)
+        Utils.write_d8(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_d8(bytes, offset)
+      end
+    end
+  end
+end

data/lib/zero_formatter/serializer/int.rb

@@ -0,0 +1,51 @@
+module ZeroFormatter
+  class Serializer
+    module Int8Serializer
+      extend self
+      Alias = %i(sbyte int8 int_8)
+      def serialize(value)
+        Utils.write_s1(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_s1(bytes, offset)
+      end
+    end
+
+    module Int16Serializer
+      extend self
+      Alias = %i(short int16 int_16)
+      def serialize(value)
+        Utils.write_s2(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_s2(bytes, offset)
+      end
+    end
+
+    module Int32Serializer
+      extend self
+      Alias = %i(int int32 int_32)
+      def serialize(value)
+        Utils.write_s4(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_s4(bytes, offset)
+      end
+    end
+
+    module Int64Serializer
+      extend self
+      Alias = %i(long int64 int_64)
+      def serialize(value)
+        Utils.write_s8(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_s8(bytes, offset)
+      end
+    end
+  end
+end

data/lib/zero_formatter/serializer/object.rb

@@ -0,0 +1,24 @@
+module ZeroFormatter
+  module Serializer
+    class ObjectSerializer
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def serialize(value)
+        ZeroFormatter.dump(klass, bytes)
+      end
+
+      def deserialize(bytes)
+        ZeroFormatter.parse(klass, bytes)
+        object_size = read_s4(bytes, 0)
+        raise "Object size missmatch, expected=#{object_size}, actual=#{bytes.bytesize}" if object_size != bytes.bytesize
+
+        field_num = read_s4(bytes, 4)
+        raise "Field count is negative, #{field_num}" if field_num < 0
+
+        field_map = 
+      end
+    end
+  end
+end

data/lib/zero_formatter/serializer/string.rb

@@ -0,0 +1,32 @@
+module ZeroFormatter
+  class Serializer
+    module CharSerializer
+      extend self
+      Alias = %i(char)
+      def serialize(value)
+        bytesize = (value || "").bytesize
+        result = value || ""
+        (result.encode("utf-16le").bytes + [0, 0]).pack("CC")
+      end
+
+      def deserialize(bytes, offset=0)
+        bytes.byteslice(offset, 2).force_encoding("utf-16le").encode(__ENCODING__)
+      end
+    end
+
+    module StringSerializer
+      extend self
+      Alias = %i(string str)
+      def serialize(value)
+        value ||= ""
+
+        Utils.write_s4(value.bytesize) << value
+      end
+
+      def deserialize(bytes, offset=0)
+        len = Utils.read_s4(bytes, offset)
+        bytes.byteslice(offset+4, len)
+      end
+    end
+  end
+end

data/lib/zero_formatter/serializer/time.rb

@@ -0,0 +1,51 @@
+module ZeroFormatter
+  class Serializer
+    module TimeSpanSerializer
+      extend self
+      Alias = %i(timespan duration)
+      def serialize(value)
+        value ||= { seconds: 0, nanos: 0 }
+        Utils.write_s8(value[:seconds]) + Utils.write_s4(value[:nanos])
+      end
+
+      def deserialize(bytes, offset=0)
+        value = {
+          seconds: Utils.read_s8(bytes, offset),
+          nanos: Utils.read_s4(bytes, offset+8)
+        }
+      end
+    end
+
+    module TimeSerializer
+      extend self
+      Alias = %i(datetime time)
+      def serialize(value)
+        value ||= Time.at(0)
+        Utils.write_s8(value.to_i) << Utils.write_s4(value.nsec)
+      end
+
+      def deserialize(bytes, offset=0)
+        value = Time.at(Utils.read_s8(bytes, offset), Utils.read_s4(bytes, offset+8)/1000.0)
+      end
+    end
+
+    module TimeWithOffsetSerializer
+      extend self
+      Alias = %i(datetime_with_offset time_with_offset)
+      def serialize(value)
+        value ||= {time: Time.at(0), time_offset: 0}
+        Utils.write_s8(value[:time].to_i + value[:time_offset]*60) << Utils.write_s4(value[:time].nsec) << Utils.write_s2(value[:time_offset])
+      end
+
+      def deserialize(bytes, offset=0)
+        time = Time.at(Utils.read_s8(bytes, offset), Utils.read_s4(bytes, offset+8)/1000.0)
+        time_offset = Utils.read_s2(bytes, offset+8+4)
+        time -= time_offset*60
+        {
+          time: time,
+          time_offset: time_offset
+        }
+      end
+    end
+  end
+end

data/lib/zero_formatter/serializer/uint.rb

@@ -0,0 +1,51 @@
+module ZeroFormatter
+  class Serializer
+    module UInt8Serializer
+      extend self
+      Alias = %i(byte uint8 uint_8)
+      def serialize(value)
+        Utils.write_u1(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_u1(bytes, offset)
+      end
+    end
+
+    module UInt16Serializer
+      extend self
+      Alias = %i(ushort uint16 uint_16)
+      def serialize(value)
+        Utils.write_u2(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_u2(bytes, offset)
+      end
+    end
+
+    module UInt32Serializer
+      extend self
+      Alias = %i(uint uint32 uint_32)
+      def serialize(value)
+        Utils.write_u4(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_u4(bytes, offset)
+      end
+    end
+
+    module UInt64Serializer
+      extend self
+      Alias = %i(ulong uint64 uint_64)
+      def serialize(value)
+        Utils.write_u8(value)
+      end
+
+      def deserialize(bytes, offset=0)
+        Utils.read_u8(bytes, offset)
+      end
+    end
+  end
+end

data/lib/zero_formatter/utils.rb

@@ -0,0 +1,104 @@
+module ZeroFormatter
+  class Utils
+    class << self
+      def read_s1(bytes, index)
+        to_signed(bytes.getbyte(index), 1 << (8 -1))
+      end
+
+      def read_u1(bytes, index)
+        bytes.getbyte(index)
+      end
+
+      def read_u2(bytes, index)
+        bytes.byteslice(index, 2).unpack('v')[0]
+      end
+
+      def read_s2(bytes, index)
+        to_signed(read_u2(bytes, index), 1 << (16 - 1))
+      end
+
+      def read_u4(bytes, index)
+        bytes.byteslice(index, 4).unpack('V')[0]
+      end
+
+      def read_s4(bytes, index)
+        to_signed(read_u4(bytes, index), 1 << (32 - 1))
+      end
+
+      def read_u8(bytes, index)
+        l, h = bytes.byteslice(index, 8).unpack('VV')
+        (h << 32) + l
+      end
+
+      def read_s8(bytes, index)
+        to_signed(read_u8(bytes, index), 1 << (64 - 1))
+      end
+
+      def read_f4(bytes, index)
+        bytes.byteslice(index, 4).unpack('e')[0]
+      end
+
+      def read_d8(bytes, index)
+        bytes.byteslice(index, 8).unpack('E')[0]
+      end
+
+      def to_signed(v, mask)
+        (v & ~mask) - (v & mask)
+      end
+
+
+
+
+      def write_u1(value)
+        value ||= 0
+        [value].pack("C")
+      end
+
+      def write_s1(value)
+        value ||= 0
+        [value].pack("c")
+      end
+
+      def write_u2(value)
+        value ||= 0
+        [value].pack('v')
+      end
+
+      def write_s2(value)
+        value ||= 0
+        [value].pack('v')
+      end
+
+      def write_u4(value)
+        value ||= 0
+        [value].pack('V')
+      end
+
+      def write_s4(value)
+        value ||= 0
+        [value].pack('V')
+      end
+
+      def write_u8(value)
+        value ||= 0
+        [value].pack('Q!<')
+      end
+
+      def write_s8(value)
+        value ||= 0
+        value += (2 ** 64) if value < 0
+        [value].pack('q!<')
+      end
+
+      def write_f4(value)
+        value ||= 0.0
+        [value].pack("e")
+      end
+
+      def write_d8(value)
+        value ||= 0.0
+        [value].pack("E")
+      end
+    end
+  end
+end

data/lib/zero_formatter/version.rb

@@ -0,0 +1,3 @@
+module ZeroFormatter
+  VERSION = "0.1.0"
+end

data/lib/zero_formatter/zero_formattable.rb

@@ -0,0 +1,27 @@
+module ZeroFormatter
+  module ZeroFormattable
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def fields
+        @fields || []
+      end
+
+      def field(name, type, options={})
+        @fields ||= []
+        index = options[:index] || @fields.size == 0 ? 0 : @fields.last[:index] + 1
+        @fields << {
+          index: index,
+          name: name,
+          type: type,
+          options: options,
+        }
+
+        attr_accessor name
+        return
+      end
+    end
+  end
+end

data/zero_formatter.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zero_formatter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zero_formatter"
+  spec.version       = ZeroFormatter::VERSION
+  spec.authors       = ["aki017"]
+  spec.email         = ["aki@aki017.info"]
+
+  spec.summary       = %q{ZeroFormatter ruby port}
+  spec.description   = %q{ZeroFormatter ruby port}
+  spec.homepage      = "https://github.com/aki017/zeroformatter.rb"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "guard", "~> 2.14.0"
+  spec.add_development_dependency "guard-minitest", "~> 2.4.6"
+  spec.add_development_dependency "simplecov", "~> 0.12.0"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 1.0.3"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1.12"
+
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: zero_formatter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- aki017
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.6
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.12
+description: ZeroFormatter ruby port
+email:
+- aki@aki017.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- circle.yml
+- lib/zero_formatter.rb
+- lib/zero_formatter/serializer.rb
+- lib/zero_formatter/serializer/bool.rb
+- lib/zero_formatter/serializer/fp.rb
+- lib/zero_formatter/serializer/int.rb
+- lib/zero_formatter/serializer/object.rb
+- lib/zero_formatter/serializer/string.rb
+- lib/zero_formatter/serializer/time.rb
+- lib/zero_formatter/serializer/uint.rb
+- lib/zero_formatter/utils.rb
+- lib/zero_formatter/version.rb
+- lib/zero_formatter/zero_formattable.rb
+- zero_formatter.gemspec
+homepage: https://github.com/aki017/zeroformatter.rb
+licenses: []
+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.5.1
+signing_key: 
+specification_version: 4
+summary: ZeroFormatter ruby port
+test_files: []