CHANGELOG.md

@@ -1,5 +1,4 @@
 # Changelog
-
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
@@ -7,24 +6,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.2.1] - 2020-09-29
-
-### Fixed
-
-- Bug when passing an `IO` to `to_cbor`
-
-## [0.2.0] - 2020-06-18
-
-### Changed
-
-- Upgraded to Crystal 0.35.0
-
-## [0.1.1] - 2020-06-02
-
-### Fixed
-
-- Fix encoding of CBOR tags and as a consequence, the encoding of `Time`
-
 ## [0.1.0] - 2020-06-01
 
-- Initial Release
+* Initial Release
+

shard.yml

@@ -1,14 +1,14 @@
 name: cbor
-version: 0.2.1
+version: 0.1.0
 
 authors:
   - Alberto Restifo <alberto@restifo.dev>
 
-description: "A CBOR library in pure Crystal, implementing RFC7049"
+description: "A CBOR library in pure Crystal, impleming RFC7049"
 
-crystal: 0.35.0
+crystal: 0.34.0
 
 license: MIT
 
 repository: https://git.sr.ht/~arestifo/crystal-cbor
-homepage: https://sr.ht/~arestifo/crystal-cbor/
+homepage: https://git.sr.ht/~arestifo/crystal-cbor

spec/cbor/encoder_spec.cr

@@ -71,7 +71,7 @@ describe CBOR::Encoder do
         bytes_arr = hex_string.split.map(&.to_u8(16))
         want_bytes = Bytes.new(bytes_arr.to_unsafe, bytes_arr.size)
 
-        it "encodes #{value} to #{want_bytes.hexstring}" do
+        it "econdes #{value.to_s} to #{want_bytes.hexstring}" do
           res = IO::Memory.new
 
           encoder = CBOR::Encoder.new(res)

spec/cbor/lexer_spec.cr

@@ -21,7 +21,7 @@ describe CBOR::Lexer do
       ]
 
       tests.each do |tt|
-        it "reads #{tt[:bytes].hexstring} as #{tt[:value]}" do
+        it "reads #{tt[:bytes].hexstring} as #{tt[:value].to_s}" do
           lexer = CBOR::Lexer.new(tt[:bytes])
 
           token = lexer.next_token

spec/cbor/serializable_spec.cr

@@ -66,7 +66,7 @@ end
 
 describe CBOR::Serializable do
   describe "rfc examples" do
-    describe %(example {"a": 1, "b": [2, 3]}) do
+    describe %(example {_ "a": 1, "b": [_ 2, 3]}) do
       it "decodes from cbor" do
         result = ExampleA.from_cbor(Bytes[0xbf, 0x61, 0x61, 0x01, 0x61, 0x62, 0x9f, 0x02, 0x03, 0xff, 0xff])
 
@@ -75,7 +75,7 @@ describe CBOR::Serializable do
       end
     end
 
-    describe %(example {"Fun": true, "Amt": -2}) do
+    describe %(example {_ "Fun": true, "Amt": -2}) do
       it "decodes from cbor" do
         result = ExampleB.from_cbor(Bytes[0xbf, 0x63, 0x46, 0x75, 0x6e, 0xf5, 0x63, 0x41, 0x6d, 0x74, 0x21, 0xff])
 
@@ -84,7 +84,7 @@ describe CBOR::Serializable do
       end
     end
 
-    describe %(example ["a", {"b": "c"}]) do
+    describe %(example ["a", {_ "b": "c"}]) do
       it "decodes from cbor" do
         result = Array(String | ExampleC).from_cbor(Bytes[0x82, 0x61, 0x61, 0xbf, 0x61, 0x62, 0x61, 0x63, 0xff])
 
@@ -137,7 +137,7 @@ describe CBOR::Serializable do
 
       it "encodes to CBOR" do
         cbor = House.from_cbor(bytes).to_cbor
-        CBOR::Diagnostic.to_s(cbor).should eq(%({"address": "Crystal Road 1234", "location": {"lat": 12.3, "lng": 34.5}}))
+        CBOR::Diagnostic.to_s(cbor).should eq(%({_ "address": "Crystal Road 1234", "location": {_ "lat": 12.3, "lng": 34.5}}))
       end
     end
 
@@ -168,7 +168,7 @@ describe CBOR::Serializable do
       it "encodes to CBOR" do
         cbor = Array(House).from_cbor(bytes).to_cbor
 
-        CBOR::Diagnostic.to_s(cbor).should eq(%([{"address": "Crystal Road 1234", "location": {"lat": 12.3, "lng": 34.5}}]))
+        CBOR::Diagnostic.to_s(cbor).should eq(%([{_ "address": "Crystal Road 1234", "location": {_ "lat": 12.3, "lng": 34.5}}]))
       end
     end
 
@@ -185,7 +185,7 @@ describe CBOR::Serializable do
         res.a.should eq(1)
         res.cbor_unmapped.should eq({"b" => 2})
 
-        CBOR::Diagnostic.to_s(res.to_cbor).should eq(%({"a": 1, "b": 2}))
+        CBOR::Diagnostic.to_s(res.to_cbor).should eq(%({_ "a": 1, "b": 2}))
       end
     end
   end

spec/cbor/to_cbor_spec.cr

@@ -41,7 +41,7 @@ describe "to_cbor" do
     tests.each do |tt|
       type, bytes, value = tt
 
-      it "encodes #{value.inspect} of type #{type}" do
+      it "encodes #{value.inspect} of type #{type.to_s}" do
         res = value.to_cbor
         res.hexdump.should eq(bytes.hexdump)
       end
@@ -58,13 +58,4 @@ describe "to_cbor" do
       encoder.to_slice.hexdump.should eq(Bytes[0xc1, 0x1a, 0x51, 0x4b, 0x67, 0xb0].hexdump)
     end
   end
-
-  describe "encodes to an IO" do
-    it "encodes a string" do
-      io = IO::Memory.new
-      "a".to_cbor(io)
-
-      io.to_slice.should eq(Bytes[0x61, 0x61])
-    end
-  end
 end

src/cbor/decoder.cr

@@ -2,11 +2,6 @@ class CBOR::Decoder
   @lexer : Lexer
   getter current_token : Token::T?
 
-  def reset
-    @lexer.reset
-    @current_token = @lexer.next_token
-  end
-
   def initialize(input)
     @lexer = Lexer.new(input)
     @current_token = @lexer.next_token

src/cbor/diagnostic.cr

@@ -1,5 +1,5 @@
 # Reads a CBOR input into a diagnostic string.
-# This consumes the IO and is mostly useful to tests again the example
+# This consumes the IO and is mostly usedful to tests again the example
 # provided in the RFC and ensuring a correct functioning of the `CBOR::Lexer`.
 class CBOR::Diagnostic
   @lexer : Lexer
@@ -63,7 +63,7 @@ class CBOR::Diagnostic
       when Tag::NegativeBigNum
         read_big_int(negative: true)
       else
-        "#{token.value.value}(#{next_value})"
+        "#{token.value.value.to_s}(#{next_value})"
       end
     when Token::FloatT
       return "NaN" if token.value.nan?

src/cbor/encoder.cr

@@ -48,7 +48,7 @@ class CBOR::Encoder
     return write(value.to_u64) if value >= 0
 
     # When it's negative, transform it into a positive value and write the
-    # resulting unsigned int with an offset
+    # resulting unsigled int with an offset
     positive_value = -(value + 1)
     write(positive_value.to_u64, 0x20)
   end

src/cbor/from_cbor.cr

@@ -3,10 +3,6 @@ def Object.from_cbor(string_or_io)
   new(parser)
 end
 
-def Object.from_cbor(parser : CBOR::Decoder)
-  new(parser)
-end
-
 def String.new(decoder : CBOR::Decoder)
   decoder.read_string
 end
@@ -184,7 +180,7 @@ def BigInt.new(decoder : CBOR::Decoder)
 end
 
 # Reads the CBOR value as a BigDecimal.
-# If the next token is a float, then it'll be transformed to a BigDecimal,
+# If the next token is a flaot, then it'll be transformed to a BigDecimal,
 # otherwhise the value must be correctly tagged with value 4 (decimal fraction)
 # or 5 (big float).
 def BigDecimal.new(decoder : CBOR::Decoder)
@@ -235,7 +231,7 @@ def Union.new(decoder : CBOR::Decoder)
       return {{type}}.new(decoder)
     {% end %}
     else
-      # This case check is non-exhaustive on purpose
+      # This case check is non-exaustive on purpose
     end
   {% end %}
 

src/cbor/lexer.cr

@@ -8,11 +8,6 @@ class CBOR::Lexer
   def initialize(@io : IO)
   end
 
-  def reset
-    @io.seek 0
-    @eof = false
-  end
-
   def next_token : Token::T?
     return nil if @eof
 
@@ -169,7 +164,7 @@ class CBOR::Lexer
   end
 
   private def consume_simple_value(id) : Token::SimpleValueT
-    raise ParseError.new("Invalid simple value #{id}") if id > 255
+    raise ParseError.new("Invalid simple value #{id.to_s}") if id > 255
     Token::SimpleValueT.new(value: SimpleValue.new(id.to_u8))
   end
 
@@ -181,7 +176,7 @@ class CBOR::Lexer
     {% conv = %w(to_i8 to_i16 to_i32 to_i64 to_i128) %}
 
     {% for uint, index in uints %}
-      # Reads the `{{uint.id}}` as a negative integer, returning the smallest
+      # Reads the `{{uint.id}}` as a negative integer, returning the samllest
       # integer capable of containing the value.
       def to_negative_int(value : {{uint.id}})
         int = begin

src/cbor/serializable.cr

@@ -136,7 +136,6 @@ module CBOR
       end
 
       private def self.new_from_cbor_decoder(decoder : ::CBOR::Decoder)
-        # puts "self.new_from_cbor_decoder"
         instance = allocate
         instance.initialize(__decoder_for_cbor_serializable: decoder)
         GC.add_finalizer(instance) if instance.responds_to?(:finalize)
@@ -144,7 +143,7 @@ module CBOR
       end
 
       # When the type is inherited, carry over the `new`
-      # so it can compete with other possible initializes
+      # so it can compete with other possible intializes
 
       macro inherited
         def self.new(decoder : ::CBOR::Decoder)
@@ -244,10 +243,6 @@ module CBOR
       raise ::CBOR::SerializationError.new("Unknown CBOR attribute: #{key}", self.class.to_s, nil)
     end
 
-    protected def get_cbor_unmapped
-      {} of String => ::CBOR::Type
-    end
-
     protected def on_to_cbor(cbor : ::CBOR::Encoder)
     end
 
@@ -273,28 +268,9 @@ module CBOR
           {% end %}
         {% end %}
 
-        # Compute the size of the final list of properties to serialize.
+        cbor.object do
-        # This allows a more compact encoding, and a faster decoding.
-        nb_properties_to_serialize = 0
-        {% for name, value in properties %}
-            _{{name}} = @{{name}}
-          {% unless value[:emit_null] %}
-            unless _{{name}}.nil?
-              nb_properties_to_serialize += 1
-            end
-          {% else %}
-            nb_properties_to_serialize += 1
-          {% end %} # macro unless value[:emit_null]
-        {% end %} # macro for properties
-
-        nb_properties_to_serialize += get_cbor_unmapped.size
-
-
-        {% if properties.size > 0 %}
-          cbor.write_object_start nb_properties_to_serialize
-
           {% for name, value in properties %}
-              _{{name}} = @{{name}}
+            _{{name}} = @{{name}}
 
             {% unless value[:emit_null] %}
               unless _{{name}}.nil?
@@ -303,23 +279,23 @@ module CBOR
               # Write the key of the map
               cbor.write({{value[:key]}})
 
-            {% if value[:converter] %}
+              {% if value[:converter] %}
-              if _{{name}}
+                if _{{name}}
-                {{ value[:converter] }}.to_cbor(_{{name}}, cbor)
+                  {{ value[:converter] }}.to_cbor(_{{name}}, cbor)
-              else
+                else
-                cbor.write(nil, use_undefined: value[:nil_as_undefined])
+                  cbor.write(nil, use_undefined: value[:nil_as_undefined])
-              end
+                end
-            {% else %} # macro if value[:converter]
+              {% else %}
-              _{{name}}.to_cbor(cbor)
+                _{{name}}.to_cbor(cbor)
-            {% end %} # macro if value[:converter]
+              {% end %}
 
             {% unless value[:emit_null] %}
-              end # unless _{{name}}.nil?
+              end
-            {% end %} # macro unless value[:emit_null]
+            {% end %}
-          {% end %} # macro for properties
+          {% end %}
           on_to_cbor(cbor)
-        {% end %} # macro if properties.size > 0
+        end
-      {% end %} # begin
+      {% end %}
     end
 
     module Unmapped
@@ -334,10 +310,6 @@ module CBOR
         end
       end
 
-      protected def get_cbor_unmapped
-        cbor_unmapped
-      end
-
       protected def on_to_cbor(cbor : ::CBOR::Encoder)
         cbor_unmapped.each do |key, value|
           cbor.write(key)
@@ -346,35 +318,6 @@ module CBOR
       end
     end
 
-    macro use_cbor_discriminator(field, mapping)
-      {% unless mapping.is_a?(HashLiteral) || mapping.is_a?(NamedTupleLiteral) %}
-        {% mapping.raise "mapping argument must be a HashLiteral or a NamedTupleLiteral, not #{mapping.class_name.id}" %}
-      {% end %}
-
-      # SLOW. Read everything, get the type, read everything again.
-      def self.new(decoder : ::CBOR::Decoder)
-        if v = decoder.read_value
-          decoder.reset
-          case v
-          when Hash(CBOR::Type, CBOR::Type)
-            discriminator_value = v[{{field.id.stringify}}]?
-            case discriminator_value
-            {% for key, value in mapping %}
-              when {{key.id.stringify}}
-                return {{value.id}}.from_cbor(decoder)
-            {% end %}
-            else
-              raise "Unknown '{{field.id}}' discriminator value: #{discriminator_value.inspect}"
-            end
-          else
-            raise "cannot get cbor discriminator #{ {{ field.id.stringify }} }"
-          end
-        else
-          raise "cannot decode cbor value"
-        end
-      end
-    end
-
     # Tells this class to decode CBOR by using a field as a discriminator.
     #
     # - *field* must be the field name to use as a discriminator

src/cbor/simple_value.cr

@@ -15,7 +15,7 @@ enum CBOR::SimpleValue : UInt8
     when Undefined
       "undefined"
     else
-      "simple(#{self.value})"
+      "simple(#{self.value.to_s})"
     end
   end
 

src/cbor/tag.cr

@@ -6,9 +6,9 @@ enum CBOR::Tag : UInt32
   Decimal
   BigFloat
 
-  COSE_Encrypt0 = 16 # COSE Single Recipient Encrypted Data Object
+  CSOEEnCrypt = 16
-  COSE_Mac0     = 17 # COSE Mac w/o Recipients Object
+  CSOEMac
-  COSE_Sign1    = 18 # COSE Single Signer Data Object
+  CSOESign
 
   ExpectBase64URL = 21
   ExpectBase64
@@ -26,9 +26,5 @@ enum CBOR::Tag : UInt32
 
   CBORWebToken = 61
 
-  COSE_Encrypt = 96 # COSE Encrypted Data Object
-  COSE_Mac     = 97 # COSE MACed Data Object
-  COSE_Sign    = 98 # COSE Signed Data Object
-
   SelfDescribeCBOR = 55799
 end

src/cbor/to_cbor.cr

@@ -6,7 +6,7 @@ class Object
   end
 
   def to_cbor(io : IO)
-    encoder = CBOR::Encoder.new(io)
+    encoder = CBOR::Encoder.new
     to_cbor(encoder)
     self
   end
@@ -79,7 +79,7 @@ module Time::Format::RFC_3339
 end
 
 module Time::EpochConverter
-  # Emits the time as a tagged unix timestamp, as specified by
+  # Emits the time as a tagged unix timestamp, asp specified by
   # [RFC 7049 section 2.4.1](https://tools.ietf.org/html/rfc7049#section-2.4.1).
   #
   def self.to_cbor(value : Time, encoder : CBOR::Encoder)
@@ -108,7 +108,7 @@ struct Time
 end
 
 # struct BigInt
-#   # Encodes the value a bytes array tagged with the CBOR tag 2 or 3, as specified
+#   # Encodes the value a bytes arrya tagged with the CBOR tag 2 or 3, as specified
 #   # in [RFC 7049 Section 2.4.2](https://tools.ietf.org/html/rfc7049#section-2.4.2).
 #   def to_cbor(encoder : CBOR::Encoder)
 #     encoded_value = BigInt.new(self)