cborb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a99e458cdc0e473306db192ae994eee3486b4a7368c4e61578e83b6050766786
+  data.tar.gz: 2524de034a4263811f61cb1bd9cfbbdd46c690da7e631d30e5b22f2ebd2f994c
+SHA512:
+  metadata.gz: 28aa0c323e37738493b08fd8d662293de6264d6c553e44e07d62091f0a1084755b4d8f86d2343414694fc78ae83fa37821c480bee8646952bc218fed1f6d8b24
+  data.tar.gz: bcd65e60a0eb7d3673455d51b513832849801fbc7ffe55a4009d9fe954dc46b8f6ad9a27560d671544449400e9cfe57e8ffab8a9dd47bc93f62e379a65743d35

data/.circleci/config.yml

@@ -0,0 +1,27 @@
+version: 2
+jobs:
+  build:
+    docker:
+       - image: circleci/ruby:2.4.1-node-browsers
+
+    working_directory: ~/cborb
+
+    steps:
+      - checkout
+
+      - restore_cache:
+          keys:
+          - v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+      - run:
+          name: setup
+          command: bin/setup
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+      - run:
+          name: run specs
+          command: bundle exec rspec

data/.editorconfig

@@ -0,0 +1,7 @@
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_size = 2
+
+[*.rb]
+trim_trailing_whitespace = true

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+/spec/fixtures/*.cbor
+/vendor

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in cborb.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    cborb (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  cborb!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 murakmii
+
+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,63 @@
+# Cborb
+
+[![CircleCI](https://circleci.com/gh/murakmii/cborb/tree/master.svg?style=svg)](https://circleci.com/gh/murakmii/cborb/tree/master)
+
+Cborb is a pure ruby decoder for CBOR([RFC 7049](https://tools.ietf.org/html/rfc7049))
+
+```rb
+require "cborb"
+
+decoder = Cborb::Decoding::Decoder.new
+
+decoder.decode("\x83\x01")
+decoder.finished? # => false
+
+decoder.decode("\x02\x03")
+decoder.finished? # => true
+
+decoder.result # => [1, 2, 3]
+
+# Shorthand
+Cborb.decode("\x83\x01\x02\x03") # => [1, 2, 3]
+```
+
+## Handling indefinite-length data
+
+Cborb can handle indefinite-length data(array, map, byte string, unicode string).
+
+```rb
+Cborb.decode("\x9F\x01\x82\x02\x03\x9F\x04\x05\xFF\xFF") # => [1, [2, 3], [4, 5]]
+```
+
+## Handling tags
+
+If Cborb encounters a tag, generates instance of `Cborb::Decoding::TaggedValue`.  
+That contains tag number and original value.
+
+```rb
+Cborb.decode "\xC0" + "\x71" + "1970-01-01T00:00Z"
+# => #<struct Cborb::Decoding::TaggedValue tag=0, value="1970-01-01T00:00Z">
+```
+
+## Handling simple values
+
+Cborb can handle simple values(true, false, nil, undefined).
+
+```rb
+Cborb.decode "\xF5" # => true
+```
+
+"Undefined" doesn't exist in Ruby.
+So, Cborb converts "undefined" to `nil`.
+
+```rb
+Cborb.decode "\xF7" # => nil
+```
+
+If Cborb encounters unassigned simple value, generates instance of `Cborb::Decoding::UnassignedSimpleValue`.  
+That contains simple value number.
+
+```rb
+Cborb.decode "\xEF"
+# => #<struct Cborb::Decoding::UnassignedSimpleValue number=15>
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cborb"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/generate_fixtures

@@ -0,0 +1,262 @@
+#!/usr/bin/env ruby
+
+def generate(name)
+  path = File.join(File.dirname(__FILE__), "../spec/fixtures/#{name}.cbor")
+  File.open(path, "wb") do |f|
+    yield f
+  end
+end
+
+def generate_definite_string(text, size_byte)
+  text = text.dup.force_encoding(Encoding::ASCII_8BIT)
+  ib = 
+    case size_byte
+    when 0
+      (0b01100000 | text.bytesize).chr
+    when 1
+      "\x78" + [text.bytesize].pack("C")
+    when 2
+      "\x79" + [text.bytesize].pack("S>")
+    when 4
+      "\x7A" + [text.bytesize].pack("I>")
+    when 8
+      "\x7B" + [text.bytesize].pack("Q>")
+    else
+      raise "invalid string size byte: #{size_byte}"
+    end
+
+  ib + text
+end
+
+# NOTE:
+#   0x83 = The initial byte of array that has 3 items
+
+# only unknown initial byte
+generate "001" do |out|
+  out << "\x1C"
+end
+
+# includes unknown initial byte
+generate "002" do |out|
+  out << "\x83\x01\x1C\x03"
+end
+
+# includes unnecessary data
+generate "003" do |out|
+  out << "\x83\x01\x02\x03\x04"
+end
+
+# lack data
+generate "004" do |out|
+  out << "\x83\x01\x02"
+end
+
+# correct array
+generate "005" do |out|
+  out << "\x83\x01\x02\x03"
+end
+
+# 100000 times nested array
+generate "006" do |out|
+  out << ("\x81" * 100000)
+  out << "\x18\x7B" # 123(Integer)
+end
+
+# includes all data
+generate "007" do |out|
+  out << "\x9F" # start indefinite array
+
+  # start map that contains 6 items
+  out << "\xA6" 
+
+  out << generate_definite_string("description", 0)
+  out << generate_definite_string("The map that contains positive integers", 1)
+
+  out << generate_definite_string("zero byte integer", 0)
+  out << "\x17" # 23
+
+  out << generate_definite_string("single byte integer", 1)
+  out << "\x18\x0F" # 15
+
+  out << generate_definite_string("2 byte integer", 2)
+  out << "\x19\x00\xFF" # 255
+
+  out << generate_definite_string("4 byte integer", 4)
+  out << "\x1A\x00\x00\xFF\xFF" # 65535
+
+  out << generate_definite_string("8 byte integer", 8)
+  out << "\x1B\x00\x00\x00\x00\xFF\xFF\xFF\xFF" # 4294967295
+
+  # start map that contains 6 items
+  out << "\xB8\x06"
+
+  out << generate_definite_string("description", 0)
+  out << generate_definite_string("The map that contains negative integers", 1)
+
+  out << generate_definite_string("zero byte integer", 0)
+  out << "\x37" # -24
+
+  out << generate_definite_string("single byte integer", 1)
+  out << "\x38\x0F" # -16
+
+  out << generate_definite_string("2 byte integer", 2)
+  out << "\x39\x00\xFF" # -256
+
+  out << generate_definite_string("4 byte integer", 4)
+  out << "\x3A\x00\x00\xFF\xFF" # -65536
+
+  out << generate_definite_string("8 byte integer", 8)
+  out << "\x3B\x00\x00\x00\x00\xFF\xFF\xFF\xFF" # -4294967296
+
+  # start map that contains 7 items
+  out << "\xB9\x00\x07" 
+
+  out << generate_definite_string("description", 0)
+  out << generate_definite_string("The map that contains byte strings", 1)
+
+  out << generate_definite_string("byte string(represented by 0 byte integer)", 1)
+  out << "\x43\x41\x42\x43"
+
+  out << generate_definite_string("byte string(represented by 1 byte integer)", 1)
+  out << "\x58\x03\x41\x42\x43"
+
+  out << generate_definite_string("byte string(represented by 2 byte integer)", 1)
+  out << "\x59\x00\x03\x41\x42\x43"
+
+  out << generate_definite_string("byte string(represented by 4 byte integer)", 1)
+  out << "\x5A\x00\x00\x00\x03\x41\x42\x43"
+
+
+  out << generate_definite_string("byte string(represented by 8 byte integer)", 1)
+  out << "\x5B\x00\x00\x00\x00\x00\x00\x00\x03\x41\x42\x43"
+
+  out << generate_definite_string("indefinite byte string", 1)
+  out << "\x5F"
+  out << "\x41\x41"
+  out << "\x41\x42"
+  out << "\x41\x43"
+  out << "\xFF"
+
+  # start map that contains 7 items
+  out << "\xBA\x00\x00\x00\x07" 
+
+  ustr = "おはよう".force_encoding("ASCII-8BIT") # 12 bytes
+
+  out << generate_definite_string("description", 0)
+  out << generate_definite_string("The map that contains unicode strings", 1)
+
+  out << generate_definite_string("unicode string(represented by 0 byte integer)", 1)
+  out << "\x6C" + ustr
+
+  out << generate_definite_string("unicode string(represented by 1 byte integer)", 1)
+  out << "\x78\x0C" + ustr
+
+  out << generate_definite_string("unicode string(represented by 2 byte integer)", 1)
+  out << "\x79\x00\x0C" + ustr
+
+  out << generate_definite_string("unicode string(represented by 4 byte integer)", 1)
+  out << "\x7A\x00\x00\x00\x0C" + ustr
+
+  out << generate_definite_string("unicode string(represented by 8 byte integer)", 1)
+  out << "\x7B\x00\x00\x00\x00\x00\x00\x00\x0C" + ustr
+
+  out << generate_definite_string("indefinite unicode string", 1)
+  out << "\x7F"
+  out << "\x66" + "おは".force_encoding("ASCII-8BIT")
+  out << "\x66" + "よう".force_encoding("ASCII-8BIT")
+  out << "\x6F" + "ございます".force_encoding("ASCII-8BIT")
+  out << "\xFF"
+
+  # start map that contains 7 items
+  out << "\xBB\x00\x00\x00\x00\x00\x00\x00\x07" 
+
+  out << generate_definite_string("description", 0)
+  out << generate_definite_string("The map that contains arrays", 1)
+
+  out << generate_definite_string("array(represented by 0 byte integer)", 1)
+  out << "\x83\x01\x02\x03" # [1, 2, 3]
+
+  out << generate_definite_string("array(represented by 1 byte integer)", 1)
+  out << "\x98\x03\x01\x02\x03"
+
+  out << generate_definite_string("array(represented by 2 byte integer)", 1)
+  out << "\x99\x00\x03\x01\x02\x03"
+
+  out << generate_definite_string("array(represented by 4 byte integer)", 1)
+  out << "\x9A\x00\x00\x00\x03\x01\x02\x03"
+
+  out << generate_definite_string("array(represented by 8 byte integer)", 1)
+  out << "\x9B\x00\x00\x00\x00\x00\x00\x00\x03\x01\x02\x03" # [1, 2, 3]
+
+  out << generate_definite_string("indefinite array", 1)
+  out << "\x9F"
+  out << "\x01\x02\x03"
+  out << "\x65" + "hello"
+  out << "\xFF"
+
+  # tag
+  out << "\xC0"
+  out << "\x71"
+  out << "1970-01-01T00:00Z"
+
+  out << "\xD8\x0F" # tag: 15
+  out << "\x18\x7B" # 123
+
+  out << "\xD9\x00\xFF" # tag: 255
+  out << "\x18\x7B"
+
+  out << "\xDA\x00\x00\xFF\xFF" # tag: 65535
+  out << "\x18\x7B"
+
+  out << "\xDB\x00\x00\x00\x00\xFF\xFF\xFF\xFF" # tag: 4294967295
+  out << "\x18\x7B"
+
+  # simple values
+  out << "\xF4\xF5\xF6\xF7"
+
+  # start map that contains 4 items
+  out << "\xA4" 
+
+  out << generate_definite_string("description", 0)
+  out << generate_definite_string("The map that contains floating point values", 1)
+
+  out << generate_definite_string("half precision float", 1)
+  out << "\xF9\x35\x55"
+
+  out << generate_definite_string("single precision float", 1)
+  out << "\xFA"
+  out << [1.23].pack("g")
+
+  out << generate_definite_string("double precision float", 1)
+  out << "\xFB"
+  out << [1.23].pack("G")
+
+  # unassigned simple values
+  out << "\xEF"
+  out << "\xF8\xFF"
+
+  # start indefinite-length map
+  out << "\xBF"
+  out << "\x63" + "abc"
+  out << "\x18\x7B"
+  out << "\x63" + "def"
+  out << "\x19\x01\xC8"
+  out << "\xFF"
+
+  out << "\xFF" # enf of indefinite array
+end
+
+# indefinite-length byte string that contains invalid chunk
+generate "008" do |out|
+  out << "\x5F\x01"
+end
+
+# indefinite-length unicode string that contains invalid chunk
+generate "009" do |out|
+  out << "\x7F\x01"
+end
+
+# nil only
+generate "010" do |out|
+  out << "\xF6"
+end