CBOR -> Cbor and deserialize/serialize -> parse/build

Author: Matt Muller

gems/smithy-cbor/lib/smithy-cbor.rb

@@ -7,9 +7,9 @@
 require_relative 'smithy-cbor/encoder'
 
 module Smithy
-  # Smithy::CBOR is a purpose-built set of utilities for working with CBOR.
+  # Smithy::Cbor is a purpose-built set of utilities for working with CBOR.
   # It does not support all features of generic CBOR parsing and serialization.
-  module CBOR
+  module Cbor
     VERSION = File.read(File.expand_path('../VERSION', __dir__.to_s)).strip
 
     # CBOR Tagged data (Major type 6).

…mithy-cbor/lib/smithy-cbor/serializer.rb …s/smithy-cbor/lib/smithy-cbor/builder.rbgems/smithy-cbor/lib/smithy-cbor/serializer.rb renamed to gems/smithy-cbor/lib/smithy-cbor/builder.rb gems/smithy-cbor/lib/smithy-cbor/serializer.rb renamed to gems/smithy-cbor/lib/smithy-cbor/builder.rb

@@ -3,20 +3,20 @@
 require 'base64'
 
 module Smithy
-  module CBOR
+  module Cbor
     # @api private
-    class Serializer
+    class Builder
       include Schema::Shapes
 
       def initialize(options = {})
         @options = options
       end
 
-      def serialize(shape, data)
+      def build(shape, data)
         ref = shape.is_a?(ShapeRef) ? shape : ShapeRef.new(shape: shape)
         return if ref.shape == Prelude::Unit
 
-        CBOR.encode(shape(ref, data))
+        Cbor.encode(shape(ref, data))
       end
 
       private

gems/smithy-cbor/lib/smithy-cbor/codec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'deserializer'
-require_relative 'serializer'
+require_relative 'builder'
+require_relative 'parser'
 
 module Smithy
-  module CBOR
-    # Codec that serializes and deserializes in CBOR format.
+  module Cbor
+    # Codec that builds and parses in CBOR format.
     class Codec
       # @param [Hash] options
       def initialize(options = {})
@@ -15,16 +15,16 @@ def initialize(options = {})
       # @param [Shape] shape
       # @param [Object] data
       # @return [String, nil]
-      def serialize(shape, data)
-        Serializer.new(@options).serialize(shape, data)
+      def build(shape, data)
+        Builder.new(@options).build(shape, data)
       end
 
       # @param [Shape] shape
       # @param [String] bytes
       # @param [Object] target
       # @return [Object]
-      def deserialize(shape, bytes, target = nil)
-        Deserializer.new(@options).deserialize(shape, bytes, target)
+      def parse(shape, bytes, target = nil)
+        Parser.new(@options).parse(shape, bytes, target)
       end
     end
   end

gems/smithy-cbor/lib/smithy-cbor/decoder.rb

@@ -3,7 +3,7 @@
 require 'bigdecimal'
 
 module Smithy
-  module CBOR
+  module Cbor
     # @api private
     class Decoder # rubocop:disable Metrics/ClassLength
       FIVE_BIT_MASK = 0x1F

gems/smithy-cbor/lib/smithy-cbor/encoder.rb

@@ -3,7 +3,7 @@
 require 'bigdecimal'
 
 module Smithy
-  module CBOR
+  module Cbor
     # @api private
     class Encoder
       MAJOR_TYPE_UNSIGNED_INT = 0x00 # 000_00000 - Major Type 0 - unsigned int

…thy-cbor/lib/smithy-cbor/deserializer.rb …ms/smithy-cbor/lib/smithy-cbor/parser.rbgems/smithy-cbor/lib/smithy-cbor/deserializer.rb renamed to gems/smithy-cbor/lib/smithy-cbor/parser.rb gems/smithy-cbor/lib/smithy-cbor/deserializer.rb renamed to gems/smithy-cbor/lib/smithy-cbor/parser.rb

@@ -3,20 +3,20 @@
 require 'base64'
 
 module Smithy
-  module CBOR
+  module Cbor
     # @api private
-    class Deserializer
+    class Parser
       include Schema::Shapes
 
       def initialize(options = {})
         @options = options
       end
 
-      def deserialize(shape, bytes, target)
+      def parse(shape, bytes, target)
         return {} if bytes.empty?
 
         ref = shape.is_a?(ShapeRef) ? shape : ShapeRef.new(shape: shape)
-        shape(ref, CBOR.decode(bytes), target)
+        shape(ref, Cbor.decode(bytes), target)
       end
 
       private

gems/smithy-cbor/sig/smithy-cbor/codec.rbs

@@ -1,8 +1,8 @@
 module Smithy
-  module CBOR
+  module Cbor
     module Codec
-      def serialize: (Schema::Shapes::Shape shape, untyped data) -> (nil | String)
-      def deserialize: (Schema::Shapes::Shape shape, String bytes, ?Struct[untyped] target) -> (Hash[untyped, untyped] | ::Struct[untyped] | Schema::Union)
+      def build: (Schema::Shapes::Shape shape, untyped data) -> (nil | String)
+      def parse: (Schema::Shapes::Shape shape, String bytes, ?Struct[untyped] target) -> (Hash[untyped, untyped] | ::Struct[untyped] | Schema::Union)
     end
   end
 end

gems/smithy-cbor/spec/smithy-cbor/codec_spec.rb

@@ -3,23 +3,23 @@
 require_relative '../spec_helper'
 
 module Smithy
-  module CBOR
+  module Cbor
     describe Codec do
       let(:structure_shape) { SchemaHelper.sample_schema.const_get(:Structure) }
 
-      it 'serialize returns nil when given a unit shape' do
-        expect(subject.serialize(Schema::Shapes::Prelude::Unit, '')).to be_nil
+      it 'build returns nil when given a unit shape' do
+        expect(subject.build(Schema::Shapes::Prelude::Unit, '')).to be_nil
       end
 
-      it 'deserializes returns an empty hash when given bytes are empty' do
-        expect(subject.deserialize(Schema::Shapes::Prelude::String, '')).to be_empty
+      it 'parses returns an empty hash when given bytes are empty' do
+        expect(subject.parse(Schema::Shapes::Prelude::String, '')).to be_empty
       end
 
-      it 'deserializes returns an empty hash when given a unit shape' do
-        expect(subject.deserialize(Schema::Shapes::Prelude::Unit, '')).to be_empty
+      it 'parses returns an empty hash when given a unit shape' do
+        expect(subject.parse(Schema::Shapes::Prelude::Unit, '')).to be_empty
       end
 
-      it 'serializes and deserializes data' do
+      it 'builds and parses data' do
         time = Time.now
         allow(Time).to receive(:at).and_return(time)
         data = {
@@ -45,95 +45,95 @@ module CBOR
           union: { string: 'string' }
         }
         data = data.merge(structure: data)
-        bytes = subject.serialize(structure_shape, data)
-        expect(subject.deserialize(structure_shape, bytes).to_h).to eq(data)
+        bytes = subject.build(structure_shape, data)
+        expect(subject.parse(structure_shape, bytes).to_h).to eq(data)
       end
 
       context 'structures' do
-        it 'serializes and deserializes structures as a type' do
+        it 'builds and parses structures as a type' do
           type = structure_shape.type.new(string: 'string')
-          bytes = subject.serialize(structure_shape, type)
-          expect(subject.deserialize(structure_shape, bytes).string).to eq('string')
+          bytes = subject.build(structure_shape, type)
+          expect(subject.parse(structure_shape, bytes).string).to eq('string')
         end
 
-        it 'serializes and deserializes structures as a hash' do
+        it 'builds and parses structures as a hash' do
           data = { string: 'string' }
-          bytes = subject.serialize(structure_shape, data)
-          expect(subject.deserialize(structure_shape, bytes).to_h).to eq(data)
+          bytes = subject.build(structure_shape, data)
+          expect(subject.parse(structure_shape, bytes).to_h).to eq(data)
         end
       end
 
       context 'unions' do
-        it 'serializes and deserializes union as a type' do
+        it 'builds and parses union as a type' do
           union = structure_shape.member(:union).shape.member_type(:string).new(string: 'string')
           type = structure_shape.type.new(union: union)
-          bytes = subject.serialize(structure_shape, type)
-          expect(subject.deserialize(structure_shape, bytes).union).to eq(union)
+          bytes = subject.build(structure_shape, type)
+          expect(subject.parse(structure_shape, bytes).union).to eq(union)
         end
 
-        it 'serializes and deserializes union as a hash' do
+        it 'builds and parses union as a hash' do
           data = { union: { string: 'string' } }
-          bytes = subject.serialize(structure_shape, data)
-          expect(subject.deserialize(structure_shape, bytes).to_h).to eq(data)
+          bytes = subject.build(structure_shape, data)
+          expect(subject.parse(structure_shape, bytes).to_h).to eq(data)
         end
 
-        it 'serializes and deserializes unit members as a type' do
+        it 'builds and parses unit members as a type' do
           union = structure_shape.member(:union).shape.member_type(:unit).new(unit: Schema::EmptyStructure.new)
           type = structure_shape.type.new(union: union)
-          bytes = subject.serialize(structure_shape, type)
-          expect(subject.deserialize(structure_shape, bytes).union).to eq(union)
+          bytes = subject.build(structure_shape, type)
+          expect(subject.parse(structure_shape, bytes).union).to eq(union)
         end
 
-        it 'serializes and deserializes unit members as a hash' do
+        it 'builds and parses unit members as a hash' do
           data = { union: { unit: {} } }
-          bytes = subject.serialize(structure_shape, data)
-          expect(subject.deserialize(structure_shape, bytes).to_h).to eq(data)
+          bytes = subject.build(structure_shape, data)
+          expect(subject.parse(structure_shape, bytes).to_h).to eq(data)
         end
 
-        it 'serializes a nil union' do
+        it 'builds a nil union' do
           data = { union: nil }
-          bytes = subject.serialize(structure_shape, data)
-          expect(subject.deserialize(structure_shape, bytes).union).to eq(nil)
+          bytes = subject.build(structure_shape, data)
+          expect(subject.parse(structure_shape, bytes).union).to eq(nil)
         end
 
-        it 'deserializes unknown union members' do
+        it 'parses unknown union members' do
           unknown_union_type = structure_shape.member(:union).shape.member_type(:unknown)
           data = { union: { 'someThing' => 'someValue' } }
-          deserialized = subject.deserialize(structure_shape, CBOR.encode(data))
-          expect(deserialized.union).to be_a(unknown_union_type)
-          expect(deserialized.union.to_h).to eq(unknown: { 'someThing' => 'someValue' })
+          parsed = subject.parse(structure_shape, Cbor.encode(data))
+          expect(parsed.union).to be_a(unknown_union_type)
+          expect(parsed.union.to_h).to eq(unknown: { 'someThing' => 'someValue' })
         end
       end
 
       context 'lists' do
-        it 'serializes and deserializes lists' do
+        it 'builds and parses lists' do
           data = { list: ['string'] }
-          bytes = subject.serialize(structure_shape, data)
-          expect(subject.deserialize(structure_shape, bytes).to_h).to eq(data)
+          bytes = subject.build(structure_shape, data)
+          expect(subject.parse(structure_shape, bytes).to_h).to eq(data)
         end
 
         it 'can handle sparse lists' do
           list_shape = structure_shape.member(:list).shape
           list_shape.traits.merge!('smithy.api#sparse' => {})
           data = { list: [nil] }
-          bytes = subject.serialize(structure_shape, data)
-          expect(subject.deserialize(structure_shape, bytes).to_h).to eq(data)
+          bytes = subject.build(structure_shape, data)
+          expect(subject.parse(structure_shape, bytes).to_h).to eq(data)
         end
       end
 
       context 'maps' do
-        it 'serializes and deserializes maps' do
+        it 'builds and parses maps' do
           data = { map: { 'key' => 'value' } }
-          bytes = subject.serialize(structure_shape, data)
-          expect(subject.deserialize(structure_shape, bytes).to_h).to eq(data)
+          bytes = subject.build(structure_shape, data)
+          expect(subject.parse(structure_shape, bytes).to_h).to eq(data)
         end
 
         it 'can handle sparse maps' do
           map_shape = structure_shape.member(:map).shape
           map_shape.traits.merge!('smithy.api#sparse' => {})
           data = { map: { 'key' => nil } }
-          bytes = subject.serialize(structure_shape, data)
-          expect(subject.deserialize(structure_shape, bytes).to_h).to eq(data)
+          bytes = subject.build(structure_shape, data)
+          expect(subject.parse(structure_shape, bytes).to_h).to eq(data)
         end
       end
     end

gems/smithy-cbor/spec/smithy-cbor/decoder_spec.rb

@@ -3,7 +3,7 @@
 require_relative '../spec_helper'
 
 module Smithy
-  module CBOR
+  module Cbor
     # covers cases not included in test suite from cbor_spec
     describe Decoder do
       def cbor64_decode(value)

gems/smithy-cbor/spec/smithy-cbor/encoder_spec.rb

@@ -3,7 +3,7 @@
 require_relative '../spec_helper'
 
 module Smithy
-  module CBOR
+  module Cbor
     describe Encoder do
       let(:time) { Time.parse('2020-01-01 12:21:42Z') }