Merge pull request #438 from cedarcode/sr--add-json-serializer

Extract shared logic for serializing credential options into a new `JSONSerializer` module

lib/webauthn.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "webauthn/camelize_helper"
+require "webauthn/json_serializer"
 require "webauthn/configuration"
 require "webauthn/credential"
 require "webauthn/credential_creation_options"

lib/webauthn/json_serializer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module WebAuthn
+  module JSONSerializer
+    # Argument wildcard for Ruby on Rails controller automatic object JSON serialization
+    def as_json(*)
+      to_hash_with_camelized_keys
+    end
+
+    private
+
+    def to_hash_with_camelized_keys
+      attributes.each_with_object({}) do |attribute_name, hash|
+        value = send(attribute_name)
+
+        if value.respond_to?(:as_json)
+          hash[camelize(attribute_name)] = value.as_json
+        elsif value
+          hash[camelize(attribute_name)] = deep_camelize_keys(value)
+        end
+      end
+    end
+
+    def deep_camelize_keys(object)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[camelize(key)] = deep_camelize_keys(value)
+        end
+      when Array
+        object.map { |element| deep_camelize_keys(element) }
+      else
+        object
+      end
+    end
+
+    def camelize(term)
+      first_term, *rest = term.to_s.split('_')
+
+      [first_term, *rest.map(&:capitalize)].join.to_sym
+    end
+  end
+end

lib/webauthn/public_key_credential/entity.rb

@@ -3,38 +3,16 @@
 module WebAuthn
   class PublicKeyCredential
     class Entity
-      include CamelizeHelper
+      include JSONSerializer
 
       attr_reader :name
 
       def initialize(name:)
         @name = name
       end
 
-      def as_json
-        deep_camelize_keys(to_hash)
-      end
-
       private
 
-      def to_hash
-        hash = {}
-
-        attributes.each do |attribute_name|
-          value = send(attribute_name)
-
-          if value.respond_to?(:as_json)
-            value = value.as_json
-          end
-
-          if value
-            hash[attribute_name] = value
-          end
-        end
-
-        hash
-      end
-
       def attributes
         [:name]
       end

lib/webauthn/public_key_credential/options.rb

@@ -5,7 +5,7 @@
 module WebAuthn
   class PublicKeyCredential
     class Options
-      include CamelizeHelper
+      include JSONSerializer
 
       CHALLENGE_LENGTH = 32
 
@@ -21,31 +21,8 @@ def challenge
         encoder.encode(raw_challenge)
       end
 
-      # Argument wildcard for Ruby on Rails controller automatic object JSON serialization
-      def as_json(*)
-        deep_camelize_keys(to_hash)
-      end
-
       private
 
-      def to_hash
-        hash = {}
-
-        attributes.each do |attribute_name|
-          value = send(attribute_name)
-
-          if value.respond_to?(:as_json)
-            value = value.as_json
-          end
-
-          if value
-            hash[attribute_name] = value
-          end
-        end
-
-        hash
-      end
-
       def attributes
         [:challenge, :timeout, :extensions]
       end

spec/webauthn/public_key_credential/creation_options_spec.rb

@@ -130,6 +130,31 @@
     expect(hash[:challenge]).to be_truthy
   end
 
+  it "has minimum required" do
+    options = WebAuthn::PublicKeyCredential::CreationOptions.new(
+      user: {
+        id: "user-id",
+        name: "user-name",
+      }
+    )
+
+    hash = options.as_json
+
+    expect(hash[:rp]).to eq({})
+    expect(hash[:user]).to eq(
+      id: "user-id", name: "user-name", displayName: 'user-name'
+    )
+    expect(hash[:pubKeyCredParams]).to eq(
+      [{ type: "public-key", alg: -7 }, { type: "public-key", alg: -37 }, { type: "public-key", alg: -257 }]
+    )
+    expect(hash[:timeout]).to eq(120_000)
+    expect(hash[:excludeCredentials]).to be_nil
+    expect(hash[:authenticatorSelection]).to be_nil
+    expect(hash[:attestation]).to be_nil
+    expect(hash[:extensions]).to eq({})
+    expect(hash[:challenge]).to be_truthy
+  end
+
   it "accepts shorthand for exclude_credentials" do
     options = WebAuthn::PublicKeyCredential::CreationOptions.new(user: { id: "id", name: "name" }, exclude: "id")
 

spec/webauthn/public_key_credential/request_options_spec.rb

@@ -67,6 +67,19 @@
     expect(hash[:challenge]).to be_truthy
   end
 
+  it "has minimum required" do
+    options = WebAuthn::PublicKeyCredential::RequestOptions.new
+
+    hash = options.as_json
+
+    expect(hash[:rpId]).to be_nil
+    expect(hash[:timeout]).to eq(120_000)
+    expect(hash[:allowCredentials]).to eq([])
+    expect(hash[:userVerification]).to be_nil
+    expect(hash[:extensions]).to eq({})
+    expect(hash[:challenge]).to be_truthy
+  end
+
   it "accepts shorthand for allow_credentials" do
     options = WebAuthn::PublicKeyCredential::RequestOptions.new(allow: "id")