msgpack-inspect 0.1.1 → 0.1.2

data/lib/msgpack/inspect/example.yml

@@ -0,0 +1,34 @@
+---
+- format: fixarray
+  header: "ff"
+  length: 3
+  children:
+    - format: string
+      header: "e0"
+      length: 10
+      data: "0102030405060708090a"
+      value: "aaaaaaaaaa"
+    - format: int
+      header: "10"
+      data: "10"
+      value: 10
+    - format: nil
+      header: "a0"
+      data: "a0"
+      value: null
+- format: fixmap
+  header: "ff"
+  length: 2
+  children:
+    - key:
+        format: nil
+        data: "a0"
+      value:
+        format: nil
+        data: "a0"
+    - key:
+        format: nil
+        data: "a0"
+      value:
+        format: nil
+        data: "a0"

data/lib/msgpack/inspect/inspector.rb

@@ -1,81 +1,69 @@
 module MessagePack
   module Inspect
-    # Node(Hash)
-    # header:  hex (binary)
-    # exttype: hex (value)
-    # length:  numeric
-    # data:    hex
-    # value:   object
-    # children: (array of Node for array, array of Hash, which has keys of :key and :value for map)
-
     class Inspector
-      FORMATS = [:yaml, :json]
-
-      attr_reader :data
+      FORMATS = [:yaml, :json, :jsonl, nil] # nil is for test (without stream dump)
 
-      def initialize(io)
+      def initialize(io, format = :yaml, opt)
+        # return_values: false, output_io: STDOUT
         @io = io
-        @data = [] # top level objects
-        until io.eof?
-          dig(io){|obj| @data << obj }
-        end
+        @format = format
+        @streamer = MessagePack::Inspect::Streamer.get(@format)
+        @return_values = opt.fetch(:return_values, false)
+        @output_io = opt.fetch(:output_io, STDOUT)
       end
 
-      def hex(str)
-        str.unpack("H*").first
-      end
-
-      def node(fmt, header)
-        case fmt
-        when :fixint, :uint8, :uint16, :uint32, :uint64, :int8, :int16, :int32, :int64
-          {format: fmt, header: hex(header), data: nil, value: nil}
-        when :fixmap, :map16, :map32
-          {format: fmt, header: hex(header), length: nil, children: []}
-        when :fixarray, :array16, :array32
-          {format: fmt, header: hex(header), length: nil, children: []}
-        when :fixstr, :str8, :str16, :str32
-          {format: fmt, header: hex(header), length: nil, data: nil, value: nil}
-        when :nil
-          {format: fmt, header: hex(header), data: hex(header), value: nil}
-        when :false
-          {format: fmt, header: hex(header), data: hex(header), value: false}
-        when :true
-          {format: fmt, header: hex(header), data: hex(header), value: true}
-        when :bin8, :bin16, :bin32
-          {format: fmt, header: hex(header), length: nil, data: nil, value: nil}
-        when :ext8, :ext16, :ext32, :fixext1, :fixext2, :fixext4, :fixext8, :fixext16
-          {format: fmt, header: hex(header), exttype: nil, length: nil, data: nil} # value will be set if MessagePack is installed
-        when :float32, :float64
-          {format: fmt, header: hex(header), data: nil, value: nil}
-        when :never_used
-          {format: fmt, header: hex(header), data: hex(header), error: "msgpack format 'NEVER USED' specified"}
-        else
-          raise "unknown format specifier: #{fmt}"
+      def inspect
+        data = []
+        @streamer.objects(@output_io, 0) do
+          i = 0
+          until @io.eof?
+            @streamer.object(@output_io, 1, i) do
+              obj = dig(1)
+              data << obj if @return_values
+            end
+            i += 1
+          end
         end
+        @return_values ? data : nil
       end
 
-      def dump(format)
-        case format
-        when :yaml
-          require 'yaml'
-          YAML.dump(@data)
-        when :json
-          begin
-            require 'yajl'
-            Yajl::Encoder.encode(@data)
-          rescue LoadError
-            require 'json'
-            JSON.dump(@data)
+      def dig(depth, heading = true)
+        header_byte = @io.read(1)
+        # TODO: error handling for header_byte:nil or raised exception
+        header = header_byte.b
+        fmt = parse_header(header)
+        node = MessagePack::Inspect::Node.new(fmt, header)
+        node.extend @streamer
+        node.io = @output_io
+        node.depth = depth # Streamer#depth=
+        node.heading = heading
+
+        node.attributes(@io)
+
+        if node.is_array?
+          node.elements do |i|
+            @streamer.object(@output_io, depth + 2, i) do
+              obj = dig(depth + 2) # children -> array
+              node << obj if @return_values
+            end
+          end
+        elsif node.is_map?
+          node.elements do |i|
+            key = node.element_key do
+              @streamer.object(@output_io, depth + 3, 0) do
+                dig(depth + 3, false) # chilren -> array -> key
+              end
+            end
+            value = node.element_value do
+              @streamer.object(@output_io, depth + 3, 0) do
+                dig(depth + 3, false) # children -> array -> value
+              end
+            end
+            node[key] = value if @return_values
           end
-        else
-          raise "unknown format: #{format}"
         end
-      end
 
-      def dig(io, &block)
-        header = io.read(1).b
-        fmt = parse_header(header)
-        yield generate(io, fmt, header, node(fmt, header))
+        node
       end
 
       HEADER_FIXINT_POSITIVE = Range.new(0x00, 0x7f)
@@ -159,228 +147,6 @@ module MessagePack
           raise "never reach here."
         end
       end
-
-      def generate_array(io, fmt, header, current)
-        length = case fmt
-                 when :fixarray
-                   header.unpack('C').first & 0x0f
-                 when :array16
-                   io.read(2).unpack('n').first
-                 when :array32
-                   io.read(4).unpack('N').first
-                 else
-                   raise "unknown array fmt #{fmt}"
-                 end
-        current[:length] = length
-        length.times do |i|
-          dig(io){|obj| current[:children] << obj }
-        end
-        current
-      end
-
-      def generate_map(io, fmt, header, current)
-        length = case fmt
-                 when :fixmap
-                   header.unpack('C').first & 0x0f
-                 when :map16
-                   io.read(2).unpack('n').first
-                 when :map32
-                   io.read(4).unpack('N').first
-                 else
-                   raise "unknown map fmt #{fmt}"
-                 end
-        current[:length] = length
-        length.times do |i|
-          pair = {}
-          dig(io){|key| pair[:key] = key }
-          dig(io){|value| pair[:value] = value }
-          current[:children] << pair
-        end
-        current
-      end
-
-      MAX_INT16 = 2 ** 16
-      MAX_INT32 = 2 ** 32
-      MAX_INT64 = 2 ** 64
-
-      def generate_int(io, fmt, header, current)
-        if fmt == :fixint
-          current[:data] = hex(header)
-          v = header.unpack('C').first
-          if v & 0b11100000 > 0 # negative fixint
-            current[:value] = header.unpack('c').first
-          else # positive fixint
-            current[:value] = header.unpack('C').first
-          end
-          return current
-        end
-
-        case fmt
-        when :uint8
-          v = io.read(1)
-          current[:data] = hex(v)
-          current[:value] = v.unpack('C').first
-        when :uint16
-          v = io.read(2)
-          current[:data] = hex(v)
-          current[:value] = v.unpack('n').first
-        when :uint32
-          v = io.read(4)
-          current[:data] = hex(v)
-          current[:value] = v.unpack('N').first
-        when :uint64
-          v1 = io.read(4)
-          v2 = io.read(4)
-          current[:data] = hex(v1) + hex(v2)
-          current[:value] = (v1.unpack('N').first << 32) | v2.unpack('N').first
-        when :int8
-          v = io.read(1)
-          current[:data] = hex(v)
-          current[:value] = v.unpack('c').first
-        when :int16
-          v = io.read(2)
-          current[:data] = hex(v)
-          n = v.unpack('n').first
-          if (n & 0x8000) > 0 # negative
-            current[:value] = n - MAX_INT16
-          else
-            current[:value] = n
-          end
-        when :int32
-          v = io.read(4)
-          current[:data] = hex(v)
-          n = v.unpack('N').first
-          if n & 0x80000000 > 0 # negative
-            current[:value] = n - MAX_INT32
-          else
-            current[:value] = n
-          end
-        when :int64
-          v1 = io.read(4)
-          v2 = io.read(4)
-          current[:data] = hex(v1) + hex(v2)
-          n = (v1.unpack('N').first << 32) | v2.unpack('N').first
-          if n & 0x8000_0000_0000_0000 > 0 # negative
-            current[:value] = n - MAX_INT64
-          else
-            current[:value] = n
-          end
-        else
-          raise "unknown int format #{fmt}"
-        end
-        current
-      end
-
-      def generate_float(io, fmt, header, current)
-        case fmt
-        when :float32
-          v = io.read(4)
-          current[:data] = hex(v)
-          current[:value] = v.unpack('g').first
-        when :float64
-          v = io.read(8)
-          current[:data] = hex(v)
-          current[:value] = v.unpack('G').first
-        else
-          raise "unknown float format #{fmt}"
-        end
-        current
-      end
-
-      def generate_string(io, fmt, header, current)
-        length = case fmt
-                 when :fixstr
-                   header.unpack('C').first & 0b00011111
-                 when :str8, :bin8
-                   io.read(1).unpack('C').first
-                 when :str16, :bin16
-                   io.read(2).unpack('n').first
-                 when :str32, :bin32
-                   io.read(4).unpack('N').first
-                 else
-                   raise "unknown string format #{fmt}"
-                 end
-        current[:length] = length
-        v = io.read(length)
-        current[:data] = hex(v)
-        if [:fixstr, :str8, :str16, :str32].include?(fmt)
-          begin
-            current[:value] = v.force_encoding('UTF-8')
-          rescue
-            current[:error] = $!.message
-          end
-        else
-          current[:value] = v.b
-        end
-        current
-      end
-
-      begin
-        require 'msgpack'
-      rescue LoadError
-        # ignore
-      end
-      MSGPACK_LOADED = MessagePack.const_defined?('Unpacker')
-
-      def generate_ext(io, fmt, header, current)
-        data = ''.b
-        length = case fmt
-                 when :fixext1 then 1
-                 when :fixext2 then 2
-                 when :fixext4 then 4
-                 when :fixext8 then 8
-                 when :fixext16 then 16
-                 when :ext8
-                   v = io.read(1)
-                   data << v
-                   v.unpack('C').first
-                 when :ext16
-                   v = io.read(2)
-                   data << v
-                   v.unpack('n').first
-                 when :ext32
-                   v = io.read(4)
-                   data << v
-                   v.unpack('N').first
-                 else
-                   raise "unknown ext format #{fmt}"
-                 end
-        v = io.read(1)
-        data << v
-        type = v.unpack('c').first
-        current[:length] = length
-        current[:exttype] = type
-        val = io.read(length)
-        data << val
-        current[:data] = hex(val)
-        if MSGPACK_LOADED
-          current[:value] = MessagePack.unpack(val)
-        end
-        current
-      end
-
-      def generate(io, fmt, header, current)
-        case fmt
-        when :fixarray, :array16, :array32
-          generate_array(io, fmt, header, current)
-        when :fixmap, :map16, :map32
-          generate_map(io, fmt, header, current)
-        when :nil, :false, :true, :never_used
-          # nothing to do...
-        when :fixint, :uint8, :uint16, :uint32, :uint64, :int8, :int16, :int32, :int64
-          generate_int(io, fmt, header, current)
-        when :float32, :float64
-          generate_float(io, fmt, header, current)
-        when :fixstr, :str8, :str16, :str32, :bin8, :bin16, :bin32
-          generate_string(io, fmt, header, current)
-        when :ext8, :ext16, :ext32, :fixext1, :fixext2, :fixext4, :fixext8, :fixext16
-          generate_ext(io, fmt, header, current)
-        else
-          raise "unknown format #{fmt}"
-        end
-
-        current
-      end
     end
   end
 end

data/lib/msgpack/inspect/node.rb

@@ -0,0 +1,286 @@
+module MessagePack
+  module Inspect
+    class Node
+      # header:  hex (binary)
+      # exttype: hex (value)
+      # length:  numeric
+      # data:    hex
+      # value:   object
+      # children: (array of Node for array, array of Hash, which has keys of :key and :value for map)
+      attr_accessor :format, :header, :length, :exttype, :data, :value, :children, :error
+      attr_accessor :io, :depth, :heading
+
+      FORMATS = [
+        :fixint, :uint8, :uint16, :uint32, :uint64, :int8, :int16, :int32, :int64,
+        :fixmap, :map16, :map32,
+        :fixarray, :array16, :array32,
+        :fixstr, :str8, :str16, :str32,
+        :nil, :false, :true,
+        :bin8, :bin16, :bin32,
+        :ext8, :ext16, :ext32, :fixext1, :fixext2, :fixext4, :fixext8, :fixext16,
+        :float32, :float64,
+        :never_used,
+      ]
+      ARRAYS = [:fixarray, :array16, :array32]
+      MAPS = [:fixmap, :map16, :map32]
+
+      def initialize(format, header)
+        raise "unknown format specifier: #{format}" unless FORMATS.include?(format)
+        @format = format
+        @header = header # call #hex to dump
+        @length = @exttype = @data = @value = @children = @error = nil
+
+        case @format
+        when :fixmap, :map16, :map32, :fixarray, :array16, :array32
+          @children = []
+        when :nil
+          @data = hex(header)
+          @value = nil
+        when :false
+          @data = hex(header)
+          @value = false
+        when :true
+          @data = hex(header)
+          @value = true
+        when :never_used
+          @data = hex(header)
+          @error = "msgpack format 'NEVER USED' specified"
+        end
+
+        @first_line = true
+        @first_obj = true
+        @first_kv_pair = true
+      end
+
+      def hex(str)
+        str.unpack("H*").first
+      end
+
+      def elements(&block)
+        @length.times do |i|
+          yield i
+        end
+      end
+
+      def element_key
+        yield
+      end
+
+      def element_value
+        yield
+      end
+
+      def attributes(io)
+        # read attributes from io
+        case @format
+        when :fixarray, :array16, :array32
+          attributes_array(io)
+        when :fixmap, :map16, :map32
+          attributes_map(io)
+        when :nil, :false, :true, :never_used
+          # nothing to do...
+        when :fixint, :uint8, :uint16, :uint32, :uint64, :int8, :int16, :int32, :int64
+          attributes_int(io)
+        when :float32, :float64
+          attributes_float(io)
+        when :fixstr, :str8, :str16, :str32, :bin8, :bin16, :bin32
+          attributes_string(io)
+        when :ext8, :ext16, :ext32, :fixext1, :fixext2, :fixext4, :fixext8, :fixext16
+          attributes_ext(io)
+        end
+      end
+
+      def attributes_array(io)
+        @length = case @format
+                  when :fixarray
+                    @header.unpack('C').first & 0x0f
+                  when :array16
+                    io.read(2).unpack('n').first
+                  when :array32
+                    io.read(4).unpack('N').first
+                  else
+                    raise "unknown array fmt #{@format}"
+                  end
+      end
+
+      def attributes_map(io)
+        @length = case @format
+                  when :fixmap
+                    @header.unpack('C').first & 0x0f
+                  when :map16
+                    io.read(2).unpack('n').first
+                  when :map32
+                    io.read(4).unpack('N').first
+                  else
+                    raise "unknown map fmt #{@format}"
+                  end
+      end
+
+      MAX_INT16 = 2 ** 16
+      MAX_INT32 = 2 ** 32
+      MAX_INT64 = 2 ** 64
+
+      def attributes_int(io)
+        if @format == :fixint
+          @data = hex(@header)
+          v = @header.unpack('C').first
+          @value = if v & 0b11100000 > 0 # negative fixint
+                     @header.unpack('c').first
+                   else # positive fixint
+                     @header.unpack('C').first
+                   end
+          return
+        end
+
+        case @format
+        when :uint8
+          v = io.read(1)
+          @data = hex(v)
+          @value = v.unpack('C').first
+        when :uint16
+          v = io.read(2)
+          @data = hex(v)
+          @value = v.unpack('n').first
+        when :uint32
+          v = io.read(4)
+          @data = hex(v)
+          @value = v.unpack('N').first
+        when :uint64
+          v1 = io.read(4)
+          v2 = io.read(4)
+          @data = hex(v1) + hex(v2)
+          @value = (v1.unpack('N').first << 32) | v2.unpack('N').first
+        when :int8
+          v = io.read(1)
+          @data = hex(v)
+          @value = v.unpack('c').first
+        when :int16
+          v = io.read(2)
+          @data = hex(v)
+          n = v.unpack('n').first
+          @value = if (n & 0x8000) > 0 # negative
+                     n - MAX_INT16
+                   else
+                     n
+                   end
+        when :int32
+          v = io.read(4)
+          @data = hex(v)
+          n = v.unpack('N').first
+          @value = if n & 0x80000000 > 0 # negative
+                     n - MAX_INT32
+                   else
+                     n
+                   end
+        when :int64
+          v1 = io.read(4)
+          v2 = io.read(4)
+          @data = hex(v1) + hex(v2)
+          n = (v1.unpack('N').first << 32) | v2.unpack('N').first
+          @value = if n & 0x8000_0000_0000_0000 > 0 # negative
+                     n - MAX_INT64
+                   else
+                     n
+                   end
+        else
+          raise "unknown int format #{@format}"
+        end
+      end
+
+      def attributes_float(io)
+        case @format
+        when :float32
+          v = io.read(4)
+          @data = hex(v)
+          @value = v.unpack('g').first
+        when :float64
+          v = io.read(8)
+          @data = hex(v)
+          @value = v.unpack('G').first
+        else
+          raise "unknown float format #{@format}"
+        end
+      end
+
+      def attributes_string(io)
+        @length = case @format
+                  when :fixstr
+                    @header.unpack('C').first & 0b00011111
+                  when :str8, :bin8
+                    io.read(1).unpack('C').first
+                  when :str16, :bin16
+                    io.read(2).unpack('n').first
+                  when :str32, :bin32
+                    io.read(4).unpack('N').first
+                  else
+                    raise "unknown string format #{@format}"
+                  end
+        v = io.read(@length)
+        @data = hex(v)
+        if [:fixstr, :str8, :str16, :str32].include?(@format)
+          begin
+            @value = v.force_encoding('UTF-8')
+          rescue
+            @error = $!.message
+          end
+        else
+          @value = v.b
+        end
+      end
+
+      MSGPACK_LOADED = MessagePack.const_defined?('Unpacker')
+
+      def attributes_ext(io)
+        data = ''.b
+        @length = case @format
+                  when :fixext1 then 1
+                  when :fixext2 then 2
+                  when :fixext4 then 4
+                  when :fixext8 then 8
+                  when :fixext16 then 16
+                  when :ext8
+                    v = io.read(1)
+                    data << v
+                    v.unpack('C').first
+                  when :ext16
+                    v = io.read(2)
+                    data << v
+                    v.unpack('n').first
+                  when :ext32
+                    v = io.read(4)
+                    data << v
+                    v.unpack('N').first
+                  else
+                    raise "unknown ext format #{@format}"
+                  end
+        v = io.read(1)
+        @exttype = v.unpack('c').first
+        val = io.read(@length)
+        @data = hex(val)
+        @value = if MSGPACK_LOADED
+                   MessagePack.unpack(val)
+                 else
+                   nil
+                 end
+      end
+
+      def is_array?
+        ARRAYS.include?(@format)
+      end
+
+      def is_map?
+        MAPS.include?(@format)
+      end
+
+      def <<(child)
+        raise "adding child object to non-array object" unless is_array?
+        @children << child
+      end
+
+      def []=(key, value)
+        raise "adding key-value objects to non-map object" unless is_map?
+        @children << {key => value}
+      end
+    end
+  end
+end