carddb 0.4.1 → 0.4.5

data/lib/carddb/query_builder.rb

@@ -968,8 +968,8 @@ module CardDB
 
       def deck
         <<~GRAPHQL
-          query Deck($id: UUID!) {
-            deck(id: $id) {
+          query Deck($id: UUID!, $readState: DeckReadState!, $version: DeckPublishedVersionSelector) {
+            deck(id: $id, readState: $readState, version: $version) {
               #{deck_fields}
             }
           }
@@ -1021,8 +1021,8 @@ module CardDB
 
       def deck_by_external_ref
         <<~GRAPHQL
-          query DeckByExternalRef($externalRef: String!) {
-            deckByExternalRef(externalRef: $externalRef) {
+          query DeckByExternalRef($externalRef: String!, $readState: DeckReadState!, $version: DeckPublishedVersionSelector) {
+            deckByExternalRef(externalRef: $externalRef, readState: $readState, version: $version) {
               #{deck_fields}
             }
           }
@@ -1053,37 +1053,6 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a deckPreview query
-      def deck_preview
-        <<~GRAPHQL
-          query DeckPreview($token: String!) {
-            deckPreview(token: $token) {
-              #{deck_fields}
-            }
-          }
-        GRAPHQL
-      end
-
-      def deck_embed
-        <<~GRAPHQL
-          query DeckEmbed($token: String!) {
-            deckEmbed(token: $token) {
-              #{deck_fields}
-            }
-          }
-        GRAPHQL
-      end
-
-      def deck_access
-        <<~GRAPHQL
-          query DeckAccess($token: String!) {
-            deckAccess(token: $token) {
-              #{deck_fields}
-            }
-          }
-        GRAPHQL
-      end
-
       def deck_draft_diff
         <<~GRAPHQL
           query DeckDraftDiff($id: UUID!) {
@@ -1163,37 +1132,6 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokens query
-      def deck_preview_tokens
-        <<~GRAPHQL
-          query DeckPreviewTokens($deckId: UUID!) {
-            deckPreviewTokens(deckId: $deckId) {
-              #{deck_preview_token_fields}
-            }
-          }
-        GRAPHQL
-      end
-
-      def deck_embed_tokens
-        <<~GRAPHQL
-          query DeckEmbedTokens($deckId: UUID!) {
-            deckEmbedTokens(deckId: $deckId) {
-              #{deck_embed_token_fields}
-            }
-          }
-        GRAPHQL
-      end
-
-      def deck_access_token_issuers
-        <<~GRAPHQL
-          query DeckAccessTokenIssuers($deckId: UUID!) {
-            deckAccessTokenIssuers(deckId: $deckId) {
-              #{deck_access_token_issuer_fields}
-            }
-          }
-        GRAPHQL
-      end
-
       def deck_api_application_accesses
         <<~GRAPHQL
           query DeckApiApplicationAccesses($deckId: UUID!, $includeRevoked: Boolean) {
@@ -1485,119 +1423,51 @@ module CardDB
         GRAPHQL
       end
 
-      # Builds a deckPreviewTokenCreate mutation
-      def create_deck_preview_token
-        <<~GRAPHQL
-          mutation DeckPreviewTokenCreate($input: DeckPreviewTokenCreateInput!) {
-            deckPreviewTokenCreate(input: $input) {
-              token
-              previewToken {
-                #{deck_preview_token_fields}
-              }
-            }
-          }
-        GRAPHQL
-      end
-
-      # Builds a deckPreviewTokenRevoke mutation
-      def revoke_deck_preview_token
-        <<~GRAPHQL
-          mutation DeckPreviewTokenRevoke($id: UUID!) {
-            deckPreviewTokenRevoke(id: $id)
-          }
-        GRAPHQL
-      end
-
-      def create_deck_embed_token
-        <<~GRAPHQL
-          mutation DeckEmbedTokenCreate($input: DeckEmbedTokenCreateInput!) {
-            deckEmbedTokenCreate(input: $input) {
-              token
-              embedToken {
-                #{deck_embed_token_fields}
-              }
-            }
-          }
-        GRAPHQL
-      end
-
-      def revoke_deck_embed_token
-        <<~GRAPHQL
-          mutation DeckEmbedTokenRevoke($id: UUID!) {
-            deckEmbedTokenRevoke(id: $id)
-          }
-        GRAPHQL
-      end
-
-      def create_deck_access_token_issuer
+      def create_deck_token_issuer
         <<~GRAPHQL
-          mutation DeckAccessTokenIssuerCreate($input: DeckAccessTokenIssuerCreateInput!) {
-            deckAccessTokenIssuerCreate(input: $input) {
-              #{deck_access_token_issuer_fields}
+          mutation DeckTokenIssuerCreate($input: DeckTokenIssuerCreateInput!) {
+            deckTokenIssuerCreate(input: $input) {
+              #{deck_token_issuer_fields}
             }
           }
         GRAPHQL
       end
 
-      def revoke_deck_access_token_issuer
+      def revoke_deck_token_issuer
         <<~GRAPHQL
-          mutation DeckAccessTokenIssuerRevoke($id: UUID!) {
-            deckAccessTokenIssuerRevoke(id: $id)
+          mutation DeckTokenIssuerRevoke($id: UUID!) {
+            deckTokenIssuerRevoke(id: $id)
           }
         GRAPHQL
       end
 
-      def revoke_deck_access_token_issuer_signing_key
+      def revoke_deck_token_issuer_signing_key
         <<~GRAPHQL
-          mutation DeckAccessTokenIssuerSigningKeyRevoke($id: UUID!) {
-            deckAccessTokenIssuerSigningKeyRevoke(id: $id) {
-              #{deck_access_token_issuer_fields}
+          mutation DeckTokenIssuerSigningKeyRevoke($id: UUID!) {
+            deckTokenIssuerSigningKeyRevoke(id: $id) {
+              #{deck_token_issuer_fields}
             }
           }
         GRAPHQL
       end
 
-      def exchange_deck_access_token
+      def exchange_deck_token
         <<~GRAPHQL
-          mutation DeckAccessTokenExchange($input: DeckAccessTokenExchangeInput!) {
-            deckAccessTokenExchange(input: $input) {
+          mutation DeckTokenExchange($input: DeckTokenExchangeInput!) {
+            deckTokenExchange(input: $input) {
               token
-              accessToken {
-                #{deck_access_token_fields}
+              deckToken {
+                #{deck_token_fields}
               }
             }
           }
         GRAPHQL
       end
 
-      def exchange_deck_session_token
+      def revoke_deck_token
         <<~GRAPHQL
-          mutation DeckSessionTokenExchange($input: DeckSessionTokenExchangeInput!) {
-            deckSessionTokenExchange(input: $input) {
-              token
-              sessionToken {
-                id
-                accountId
-                apiApplicationId
-                gameId
-                environment
-                externalSubject
-                scopes
-                expiresAt
-                revokedAt
-                lastUsedAt
-                createdAt
-                updatedAt
-              }
-            }
-          }
-        GRAPHQL
-      end
-
-      def revoke_deck_access_token
-        <<~GRAPHQL
-          mutation DeckAccessTokenRevoke($id: UUID!) {
-            deckAccessTokenRevoke(id: $id)
+          mutation DeckTokenRevoke($id: UUID!) {
+            deckTokenRevoke(id: $id)
           }
         GRAPHQL
       end
@@ -2479,7 +2349,14 @@ module CardDB
           completedJobs
           failedJobs
           failureRate
+          noMatchCount
+          noMatchRate
           averageShortlistSize
+          vectorQueryCount
+          vectorFallbackCount
+          averageVectorCandidates
+          averageVectorQueryMs
+          averageEmbeddingMs
           confidenceDistribution
           feedback {
             total
@@ -2493,8 +2370,14 @@ module CardDB
             jobCount
             completedJobs
             failedJobs
+            noMatchCount
             averageConfidence
             averageShortlistSize
+            vectorQueryCount
+            vectorFallbackCount
+            averageVectorCandidates
+            averageVectorQueryMs
+            averageEmbeddingMs
             feedbackCount
             correctFeedback
             correctedFeedback
@@ -2925,43 +2808,13 @@ module CardDB
         FIELDS
       end
 
-      def deck_preview_token_fields
-        <<~FIELDS
-          id
-          deckId
-          label
-          expiresAt
-          revokedAt
-          lastUsedAt
-          createdAt
-          updatedAt
-        FIELDS
-      end
-
-      def deck_embed_token_fields
+      def deck_token_issuer_fields
         <<~FIELDS
           id
-          deckId
           apiApplicationId
           label
-          readMode
-          allowedOrigins
-          externalSubject
-          expiresAt
-          revokedAt
-          lastUsedAt
-          createdAt
-          updatedAt
-        FIELDS
-      end
-
-      def deck_access_token_issuer_fields
-        <<~FIELDS
-          id
-          deckId
-          apiApplicationId
-          label
-          readModes
+          allowedScopes
+          allowedRepresentations
           maxTokenLifetimeSeconds
           directSigningAlg
           directSigningKeyId
@@ -2973,14 +2826,16 @@ module CardDB
         FIELDS
       end
 
-      def deck_access_token_fields
+      def deck_token_fields
         <<~FIELDS
           id
-          deckId
           apiApplicationId
           issuerId
-          readMode
+          deckId
+          gameId
           externalSubject
+          scopes
+          representation
           expiresAt
           revokedAt
           lastUsedAt

data/lib/carddb/resources/decks.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module CardDB
   module Resources
     # Decks resource for hosted decks and external deck hydration.
     # rubocop:disable Metrics/ClassLength
     class Decks < Base
+      JSON_OBJECT_INPUT_KEYS = %w[metadata annotations].freeze
+
       # List decks owned by the current account or API application.
       def list_mine(first: nil, after: nil, include_archived: nil, cache: nil)
         query = QueryBuilder.list_my_decks(first: first, after: after, include_archived: include_archived)
@@ -91,14 +95,23 @@ module CardDB
       end
 
       # Fetch by UUID using the ownership-aware deck API.
-      def get(id, cache: nil)
-        key = cache_key('decks', 'get', id: id)
+      def get(id, read_state:, version: nil, cache: nil)
+        variables = build_variables(id: id, readState: read_state, version: version)
+        key = cache_key('decks', 'get', **variables)
         with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck, { id: id })
+          data = connection.execute(QueryBuilder.deck, variables)
           data['deck'] ? Deck.new(data['deck'], client: client) : nil
         end
       end
 
+      def get_draft(id, cache: nil)
+        get(id, read_state: 'DRAFT', cache: cache)
+      end
+
+      def get_published(id, version: nil, cache: nil)
+        get(id, read_state: 'PUBLISHED', version: version, cache: cache)
+      end
+
       # Fetch one deck owned by the current account or API application.
       def fetch_mine(id, cache: nil)
         key = cache_key('decks', 'fetch_mine', id: id)
@@ -150,14 +163,23 @@ module CardDB
       end
 
       # Fetch by external reference using the ownership-aware deckByExternalRef API.
-      def get_by_external_ref(external_ref:, cache: nil)
-        key = cache_key('decks', 'get_by_external_ref', external_ref: external_ref)
+      def get_by_external_ref(external_ref:, read_state:, version: nil, cache: nil)
+        variables = build_variables(externalRef: external_ref, readState: read_state, version: version)
+        key = cache_key('decks', 'get_by_external_ref', **variables)
         with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_by_external_ref, { externalRef: external_ref })
+          data = connection.execute(QueryBuilder.deck_by_external_ref, variables)
           data['deckByExternalRef'] ? Deck.new(data['deckByExternalRef'], client: client) : nil
         end
       end
 
+      def get_draft_by_external_ref(external_ref:, cache: nil)
+        get_by_external_ref(external_ref: external_ref, read_state: 'DRAFT', cache: cache)
+      end
+
+      def get_published_by_external_ref(external_ref:, version: nil, cache: nil)
+        get_by_external_ref(external_ref: external_ref, read_state: 'PUBLISHED', version: version, cache: cache)
+      end
+
       # Fetch one immutable published deck version.
       def fetch_version(id, cache: nil)
         key = cache_key('decks', 'fetch_version', id: id)
@@ -185,33 +207,6 @@ module CardDB
         )
       end
 
-      # Fetch current draft data using a revocable preview token.
-      def preview(token:, cache: nil)
-        key = cache_key('decks', 'preview', token: token)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_preview, { token: token })
-          data['deckPreview'] ? Deck.new(data['deckPreview'], client: client) : nil
-        end
-      end
-
-      # Fetch published embed data using a revocable embed token.
-      def embed(token:, cache: nil)
-        key = cache_key('decks', 'embed', token: token)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_embed, { token: token })
-          data['deckEmbed'] ? Deck.new(data['deckEmbed'], client: client) : nil
-        end
-      end
-
-      # Fetch token-authorized published data using an exchanged access token.
-      def access(token:, cache: nil)
-        key = cache_key('decks', 'access', token: token)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_access, { token: token })
-          data['deckAccess'] ? Deck.new(data['deckAccess'], client: client) : nil
-        end
-      end
-
       def draft_diff(id:, cache: nil)
         key = cache_key('decks', 'draft_diff', id: id)
         with_cache(key, resource: :decks, cache: cache) do
@@ -239,9 +234,10 @@ module CardDB
       end
 
       def hydrate_deck_entries(input:, cache: nil)
-        key = cache_key('decks', 'hydrate_deck_entries', input: input)
+        normalized_input = normalize_deck_json_input(input)
+        key = cache_key('decks', 'hydrate_deck_entries', input: normalized_input)
         with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_hydrate_entries, { input: input })
+          data = connection.execute(QueryBuilder.deck_hydrate_entries, { input: normalized_input })
           DeckHydrateEntriesPayload.new(data['deckHydrateEntries'], client: client)
         end
       end
@@ -293,31 +289,6 @@ module CardDB
         end
       end
 
-      # List draft preview tokens for a deck.
-      def preview_tokens(deck_id:, cache: nil)
-        key = cache_key('decks', 'preview_tokens', deck_id: deck_id)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_preview_tokens, { deckId: deck_id })
-          (data['deckPreviewTokens'] || []).map { |token| DeckPreviewToken.new(token, client: client) }
-        end
-      end
-
-      def embed_tokens(deck_id:, cache: nil)
-        key = cache_key('decks', 'embed_tokens', deck_id: deck_id)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_embed_tokens, { deckId: deck_id })
-          (data['deckEmbedTokens'] || []).map { |token| DeckEmbedToken.new(token, client: client) }
-        end
-      end
-
-      def access_token_issuers(deck_id:, cache: nil)
-        key = cache_key('decks', 'access_token_issuers', deck_id: deck_id)
-        with_cache(key, resource: :decks, cache: cache) do
-          data = connection.execute(QueryBuilder.deck_access_token_issuers, { deckId: deck_id })
-          (data['deckAccessTokenIssuers'] || []).map { |issuer| DeckAccessTokenIssuer.new(issuer, client: client) }
-        end
-      end
-
       def api_application_accesses(deck_id:, include_revoked: nil, cache: nil)
         variables = build_variables(deckId: deck_id, includeRevoked: include_revoked)
         key = cache_key('decks', 'api_application_accesses', **variables)
@@ -342,13 +313,13 @@ module CardDB
 
       # Create a hosted deck.
       def create(input:)
-        data = connection.execute(QueryBuilder.create_deck, { input: input })
+        data = connection.execute(QueryBuilder.create_deck, { input: normalize_deck_json_input(input) })
         Deck.new(data['deckCreate'], client: client)
       end
 
       # Update a hosted deck.
       def update(id:, input:)
-        data = connection.execute(QueryBuilder.update_deck, { id: id, input: input })
+        data = connection.execute(QueryBuilder.update_deck, { id: id, input: normalize_deck_json_input(input) })
         Deck.new(data['deckUpdate'], client: client)
       end
 
@@ -360,7 +331,7 @@ module CardDB
       def upsert_by_external_ref(input:)
         config.require_secret_credential!('decks.upsert_by_external_ref')
 
-        data = connection.execute(QueryBuilder.upsert_deck_by_external_ref, { input: input })
+        data = connection.execute(QueryBuilder.upsert_deck_by_external_ref, { input: normalize_deck_json_input(input) })
         DeckUpsertByExternalRefPayload.new(data['deckUpsertByExternalRef'], client: client)
       end
 
@@ -380,12 +351,12 @@ module CardDB
       end
 
       def add_entry(input:)
-        data = connection.execute(QueryBuilder.add_deck_entry, { input: input })
+        data = connection.execute(QueryBuilder.add_deck_entry, { input: normalize_deck_json_input(input) })
         DeckEntryMutationPayload.new(data['deckEntryAdd'], client: client)
       end
 
       def update_entry(id:, input:)
-        data = connection.execute(QueryBuilder.update_deck_entry, { id: id, input: input })
+        data = connection.execute(QueryBuilder.update_deck_entry, { id: id, input: normalize_deck_json_input(input) })
         DeckEntryMutationPayload.new(data['deckEntryUpdate'], client: client)
       end
 
@@ -403,7 +374,7 @@ module CardDB
       end
 
       def replace_entries(deck_id:, input:)
-        data = connection.execute(QueryBuilder.replace_deck_entries, { deckId: deck_id, input: input })
+        data = connection.execute(QueryBuilder.replace_deck_entries, { deckId: deck_id, input: normalize_deck_json_input(input) })
         DeckEntriesReplacePayload.new(data['deckEntriesReplace'], client: client)
       end
 
@@ -522,47 +493,27 @@ module CardDB
       end
       # rubocop:enable Naming/PredicateMethod
 
-      # Create a revocable draft preview token.
-      def create_preview_token(input:)
-        data = connection.execute(QueryBuilder.create_deck_preview_token, { input: input })
-        DeckPreviewTokenCreatePayload.new(data['deckPreviewTokenCreate'], client: client)
-      end
+      def create_token_issuer(input:)
+        config.require_secret_credential!('decks.create_token_issuer')
 
-      # Revoke a draft preview token.
-      # rubocop:disable Naming/PredicateMethod
-      def revoke_preview_token(id:)
-        data = connection.execute(QueryBuilder.revoke_deck_preview_token, { id: id })
-        !!data['deckPreviewTokenRevoke']
-      end
-      # rubocop:enable Naming/PredicateMethod
-
-      def create_embed_token(input:)
-        data = connection.execute(QueryBuilder.create_deck_embed_token, { input: input })
-        DeckEmbedTokenCreatePayload.new(data['deckEmbedTokenCreate'], client: client)
+        data = connection.execute(QueryBuilder.create_deck_token_issuer, { input: input })
+        DeckTokenIssuer.new(data['deckTokenIssuerCreate'], client: client)
       end
 
       # rubocop:disable Naming/PredicateMethod
-      def revoke_embed_token(id:)
-        data = connection.execute(QueryBuilder.revoke_deck_embed_token, { id: id })
-        !!data['deckEmbedTokenRevoke']
-      end
-      # rubocop:enable Naming/PredicateMethod
+      def revoke_token_issuer(id:)
+        config.require_secret_credential!('decks.revoke_token_issuer')
 
-      def create_access_token_issuer(input:)
-        data = connection.execute(QueryBuilder.create_deck_access_token_issuer, { input: input })
-        DeckAccessTokenIssuer.new(data['deckAccessTokenIssuerCreate'], client: client)
-      end
-
-      # rubocop:disable Naming/PredicateMethod
-      def revoke_access_token_issuer(id:)
-        data = connection.execute(QueryBuilder.revoke_deck_access_token_issuer, { id: id })
-        !!data['deckAccessTokenIssuerRevoke']
+        data = connection.execute(QueryBuilder.revoke_deck_token_issuer, { id: id })
+        !!data['deckTokenIssuerRevoke']
       end
       # rubocop:enable Naming/PredicateMethod
 
-      def revoke_access_token_issuer_signing_key(id:)
-        data = connection.execute(QueryBuilder.revoke_deck_access_token_issuer_signing_key, { id: id })
-        DeckAccessTokenIssuer.new(data['deckAccessTokenIssuerSigningKeyRevoke'], client: client)
+      def revoke_token_issuer_signing_key(id:)
+        config.require_secret_credential!('decks.revoke_token_issuer_signing_key')
+
+        data = connection.execute(QueryBuilder.revoke_deck_token_issuer_signing_key, { id: id })
+        DeckTokenIssuer.new(data['deckTokenIssuerSigningKeyRevoke'], client: client)
       end
 
       def grant_api_application_access(input:)
@@ -580,27 +531,19 @@ module CardDB
       end
       # rubocop:enable Naming/PredicateMethod
 
-      def exchange_access_token(input:)
-        config.require_secret_credential!('decks.exchange_access_token')
+      def exchange_token(input:)
+        config.require_secret_credential!('decks.exchange_token')
 
-        data = connection.execute(QueryBuilder.exchange_deck_access_token, { input: input })
-        DeckAccessTokenExchangePayload.new(data['deckAccessTokenExchange'], client: client)
-      end
-
-      # Exchange the current secret API application credential for an app-owned deck session token.
-      def exchange_session_token(input:)
-        config.require_secret_credential!('decks.exchange_session_token')
-
-        data = connection.execute(QueryBuilder.exchange_deck_session_token, { input: input })
-        DeckSessionTokenExchangePayload.new(data['deckSessionTokenExchange'], client: client)
+        data = connection.execute(QueryBuilder.exchange_deck_token, { input: input })
+        DeckTokenExchangePayload.new(data['deckTokenExchange'], client: client)
       end
 
       # rubocop:disable Naming/PredicateMethod
-      def revoke_access_token(id:)
-        config.require_secret_credential!('decks.revoke_access_token')
+      def revoke_token(id:)
+        config.require_secret_credential!('decks.revoke_token')
 
-        data = connection.execute(QueryBuilder.revoke_deck_access_token, { id: id })
-        !!data['deckAccessTokenRevoke']
+        data = connection.execute(QueryBuilder.revoke_deck_token, { id: id })
+        !!data['deckTokenRevoke']
       end
       # rubocop:enable Naming/PredicateMethod
 
@@ -650,6 +593,42 @@ module CardDB
 
       private
 
+      def normalize_deck_json_input(input)
+        normalize_deck_json_value(input, path: 'input')
+      end
+
+      def normalize_deck_json_value(value, path:)
+        return value unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(key, child), normalized|
+          key_name = key.to_s
+          child_path = "#{path}.#{key_name}"
+
+          normalized[key] = if JSON_OBJECT_INPUT_KEYS.include?(key_name)
+                              normalize_json_object(child, child_path)
+                            elsif key_name == 'entries' && child.is_a?(Array)
+                              child.each_with_index.map do |entry, index|
+                                normalize_deck_json_value(entry, path: "#{child_path}[#{index}]")
+                              end
+                            else
+                              child
+                            end
+        end
+      end
+
+      def normalize_json_object(value, path)
+        return value if value.nil? || value.is_a?(Hash)
+
+        if value.is_a?(String)
+          parsed = JSON.parse(value)
+          return parsed if parsed.is_a?(Hash)
+        end
+
+        raise ValidationError, "#{path} must be a JSON object"
+      rescue JSON::ParserError
+        raise ValidationError, "#{path} must be a JSON object"
+      end
+
       def entry_identifier(entry)
         entry[:identifier] || entry['identifier'] || raise(ArgumentError, 'entry identifier is required')
       end

data/lib/carddb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CardDB
-  VERSION = '0.4.1'
+  VERSION = '0.4.5'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carddb
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.5
 platform: ruby
 authors:
 - CardDB Team
@@ -121,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.14
 specification_version: 4
 summary: Ruby client for the CardDB API
 test_files: []