cborb 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+ruby bin/generate_fixtures

data/cborb.gemspec

@@ -0,0 +1,27 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cborb/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cborb"
+  spec.version       = Cborb::VERSION
+  spec.authors       = ["murakmii"]
+  spec.email         = ["bonono.jp@gmail.com"]
+
+  spec.summary       = "Cborb is a pure ruby decoder for CBOR(RFC 7049)"
+  spec.description   = "Cborb is a pure ruby decoder for CBOR(RFC 7049)"
+  spec.homepage      = "https://github.com/murakmii/cborb"
+  spec.license       = "MIT"
+
+  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.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/cborb.rb

@@ -0,0 +1,52 @@
+require "forwardable"
+require "stringio"
+
+require "cborb/version"
+require "cborb/errors"
+
+require "cborb/decoding/types/type"
+require "cborb/decoding/types/unknown"
+require "cborb/decoding/types/root"
+require "cborb/decoding/types/integer_decodable"
+require "cborb/decoding/types/integer"
+require "cborb/decoding/types/negative_integer"
+require "cborb/decoding/types/byte_string"
+require "cborb/decoding/types/indefinite_byte_string"
+require "cborb/decoding/types/text_string"
+require "cborb/decoding/types/indefinite_text_string"
+require "cborb/decoding/types/array"
+require "cborb/decoding/types/indefinite_array"
+require "cborb/decoding/types/map"
+require "cborb/decoding/types/indefinite_map"
+require "cborb/decoding/types/tag"
+require "cborb/decoding/types/simple_value"
+require "cborb/decoding/types/unassigned_simple_value"
+require "cborb/decoding/types/half_precision_floating_point"
+require "cborb/decoding/types/floating_point"
+require "cborb/decoding/types/break"
+
+require "cborb/decoding/ib_jump_table"
+require "cborb/decoding/tagged_value"
+require "cborb/decoding/unassigned_simple_value"
+require "cborb/decoding/simple_buffer"
+require "cborb/decoding/state"
+require "cborb/decoding/decoder"
+
+module Cborb
+  # The shorthand to decode CBOR
+  #
+  # @param [String] cbor
+  # @return [Object] decoded data(Array, Hash, etc...)
+  def decode(cbor)
+    decoder = Decoding::Decoder.new
+    decoder.decode(cbor)
+
+    if decoder.finished?
+      decoder.result
+    else
+      raise Cborb::InvalidByteSequenceError
+    end
+  end
+
+  module_function :decode
+end

data/lib/cborb/decoding/decoder.rb

@@ -0,0 +1,19 @@
+module Cborb::Decoding
+  class Decoder
+    extend Forwardable
+
+    def_delegators :@state, :result, :finished?
+
+    def initialize
+      @state = Cborb::Decoding::State.new
+    end
+
+    def decode(cbor)
+      @state << cbor.to_s
+    end
+
+    def inspect
+      "#<#{self.class}:#{object_id} finished=#{finished?} result=#{finished? ? result : "nil"}>"
+    end
+  end
+end

data/lib/cborb/decoding/ib_jump_table.rb

@@ -0,0 +1,47 @@
+module Cborb::Decoding
+  # IB = Initial Byte
+  # @see https://tools.ietf.org/html/rfc7049#appendix-B
+  IB_JUMP_TABLE =
+    Array.new(256) do |ib|
+      case ib
+      when 0x00..0x1B
+        Types::Integer
+      when 0x20..0x3B
+        Types::NegativeInteger
+      when 0x40..0x5B
+        Types::ByteString
+      when 0x5F
+        Types::IndefiniteByteString
+      when 0x60..0x7B
+        Types::TextString
+      when 0x7F
+        Types::IndefiniteTextString
+      when 0x80..0x9B
+        Types::Array
+      when 0x9F
+        Types::IndefiniteArray
+      when 0xA0..0xBB
+        Types::Map
+      when 0xBF
+        Types::IndefiniteMap
+      when 0xC0..0xDB
+        Types::Tag
+      when 0xE0..0xF3
+        Types::UnassignedSimpleValue
+      when 0xF4..0xF7
+        Types::SimpleValue
+      when 0xF8
+        Types::UnassignedSimpleValue
+      when 0xF9
+        Types::HalfPrecisionFloatingPoint
+      when 0xFA, 0xFB
+        Types::FloatingPoint
+      when 0xFC..0xFE
+        Types::UnassignedSimpleValue
+      when 0xFF
+        Types::Break
+      else
+        Types::Unknown
+      end
+    end.freeze
+end

data/lib/cborb/decoding/simple_buffer.rb

@@ -0,0 +1,24 @@
+module Cborb::Decoding
+  class SimpleBuffer
+    extend Forwardable
+
+    def_delegators :@buffer, :read, :getbyte, :eof?
+
+    def initialize
+      @buffer = StringIO.new
+      @buffer.set_encoding(Encoding::ASCII_8BIT)
+    end
+
+    # @param [String] data
+    def write(data)
+      pos = @buffer.pos
+      @buffer << data
+      @buffer.pos = pos
+    end
+
+    def reset!
+      @buffer.rewind
+      @buffer.truncate(0)
+    end
+  end
+end

data/lib/cborb/decoding/state.rb

@@ -0,0 +1,130 @@
+module Cborb::Decoding
+  # State of processing to decode
+  class State
+    CONTINUE = Object.new
+    NO_RESULT = Object.new
+
+    def initialize
+      @buffer = Cborb::Decoding::SimpleBuffer.new
+      @stack = [[Cborb::Decoding::Types::Root, nil]]
+      @result = NO_RESULT
+
+      # This fiber decodes CBOR.
+      # If buffer becomes empty, this fiber is stopped(#consume)
+      # When new CBOR data is buffered(#<<), that is resumed.
+      @decoding_fiber = Fiber.new { loop_consuming }
+    end
+
+    # Buffering new CBOR data
+    #
+    # @param [String] cbor
+    def <<(cbor)
+      @buffer.write(cbor)
+      @decoding_fiber.resume
+
+    rescue FiberError => e
+      msg = e.message
+
+      # umm...
+      if msg.include?("dead")
+        raise Cborb::InvalidByteSequenceError
+      elsif msg.include?("threads")
+        raise Cborb::DecodingError, "Can't decode across threads"
+      else
+        raise
+      end
+    end
+
+    # Consume CBOR data.
+    # This method will be called only in fiber.
+    #
+    # @param [Integer] size Size to consume
+    # @return [String]
+    def consume(size)
+      data = @buffer.read(size).to_s
+
+      # If buffered data is not enought, yield fiber until new data will be buffered.
+      if data.size < size
+        @buffer.reset!
+
+        while data.size != size
+          Fiber.yield
+          data += @buffer.read(size - data.size)
+        end
+      end
+
+      data
+    end
+
+    # Consume 1 byte(uses #getbyte instead of #read)
+    #
+    # @return [Integer]
+    def consume_byte
+      ib = @buffer.getbyte
+
+      if ib.nil?
+        @buffer.reset!
+
+        while ib.nil?
+          Fiber.yield
+          ib = @buffer.getbyte
+        end
+      end
+
+      ib
+    end
+
+    # Push type that has following data(e.g. Array) to stack
+    #
+    # @param [Class] type Class constant that inherits Cborb::Decoding::Types::Type
+    # @param [Object] im_data depends on type
+    def push_stack(type, im_data = nil)
+      @stack << [type, im_data]
+    end
+
+    # @param [Class] type Class constant that inherits Cborb::Decoding::Types::Type
+    # @param [Object] value
+    def accept_value(type, value)
+      loop do
+        stacked_type, im_data = @stack.last
+        value = stacked_type.accept(im_data, type, value)
+        type = stacked_type
+
+        if value.eql?(CONTINUE)
+          break
+        else
+          @stack.pop
+          if @stack.empty?
+            raise Cborb::InvalidByteSequenceError unless @buffer.eof?
+            @result = value
+            break
+          end
+        end
+      end
+    end
+
+    # @return [Class] Class constant that inherits Cborb::Decoding::Types::Type on top of stack.
+    def stack_top
+      @stack.last.first
+    end
+
+    # @return [Boolean]
+    def finished?
+      !@result.eql?(NO_RESULT)
+    end
+
+    # @return [Object]
+    def result
+      finished? ? @result : nil
+    end
+
+    private
+
+    def loop_consuming
+      until finished? do
+        ib = consume_byte
+        Cborb::Decoding::IB_JUMP_TABLE[ib].decode(self, ib & 0x1F)
+      end
+    end
+  end
+end

data/lib/cborb/decoding/tagged_value.rb

@@ -0,0 +1,3 @@
+module Cborb::Decoding
+  TaggedValue = Struct.new(:tag, :value)
+end

data/lib/cborb/decoding/types/array.rb

@@ -0,0 +1,20 @@
+module Cborb::Decoding::Types
+  # To represent major type: 4(definite-length)
+  #
+  # @see https://tools.ietf.org/html/rfc7049#section-2.1
+  class Array < Type
+    extend Cborb::Decoding::Types::IntegerDecodable
+
+    Intermediate = Struct.new(:size, :array)
+
+    def self.decode(state, additional_info)
+      im = Intermediate.new(consume_as_integer(state, additional_info), [])
+      state.push_stack(self, im)
+    end
+
+    def self.accept(im_data, type, value)
+      im_data.array << value
+      im_data.size == im_data.array.size ? im_data.array : Cborb::Decoding::State::CONTINUE
+    end
+  end
+end

data/lib/cborb/decoding/types/break.rb

@@ -0,0 +1,12 @@
+module Cborb::Decoding::Types
+  # To represent "break" stop code
+  class Break < Type
+    def self.decode(state, additional_info)
+      unless state.stack_top.indefinite?
+        raise Cborb::DecodingError, 'Unexpected "break" stop code'
+      end
+
+      state.accept_value(self, self)
+    end
+  end
+end

data/lib/cborb/decoding/types/byte_string.rb

@@ -0,0 +1,12 @@
+module Cborb::Decoding::Types
+  # To represent major type: 2(definite-length)
+  #
+  # @see https://tools.ietf.org/html/rfc7049#section-2.1
+  class ByteString < Type
+    extend Cborb::Decoding::Types::IntegerDecodable
+
+    def self.decode(state, additional_info)
+      state.accept_value(self, state.consume(consume_as_integer(state, additional_info)))
+    end
+  end
+end

data/lib/cborb/decoding/types/floating_point.rb

@@ -0,0 +1,18 @@
+module Cborb::Decoding::Types
+  # To represent part of major type: 7
+  # 
+  # @see https://tools.ietf.org/html/rfc7049#section-2.3
+  class FloatingPoint < Type
+    UNPACK_TEMPLATES = [
+      "g".freeze,
+      "G".freeze,
+    ].freeze
+
+    def self.decode(state, additional_info)
+      index = additional_info - 26
+      bytesize = 4 * (index + 1)
+
+      state.accept_value(self, state.consume(bytesize).unpack(UNPACK_TEMPLATES[index]).first)
+    end
+  end
+end

data/lib/cborb/decoding/types/half_precision_floating_point.rb

@@ -0,0 +1,28 @@
+module Cborb::Decoding::Types
+  # To represent part of major type: 7
+  # 
+  # @see https://tools.ietf.org/html/rfc7049#section-2.3
+  # @see https://tools.ietf.org/html/rfc7049#appendix-D
+  class HalfPrecisionFloatingPoint < Type
+    class << self
+      def decode(state, additional_info)
+        bits = state.consume(2).unpack("n".freeze).first
+        bits = (bits & 0x7FFF) << 13 | (bits & 0x8000) << 16
+        fp = 
+          if (bits & 0x7C00) != 0x7C00
+            Math.ldexp(to_single(bits), 112)
+          else
+            to_single(bits | 0x7F800000)
+          end
+
+        state.accept_value(self, fp)
+      end
+
+      private
+
+      def to_single(bits)
+        [bits].pack("N".freeze).unpack("g".freeze).first
+      end
+    end
+  end
+end

data/lib/cborb/decoding/types/indefinite_array.rb

@@ -0,0 +1,23 @@
+module Cborb::Decoding::Types
+  # To represent major type: 4(indefinite-length)
+  #
+  # @see https://tools.ietf.org/html/rfc7049#section-2.2.1
+  class IndefiniteArray < Type
+    def self.indefinite?
+      true
+    end
+
+    def self.decode(state, additional_info)
+      state.push_stack(self, [])
+    end
+
+    def self.accept(im_data, type, value)
+      if type == Cborb::Decoding::Types::Break
+        im_data
+      else
+        im_data << value
+        Cborb::Decoding::State::CONTINUE
+      end
+    end
+  end
+end