action_spec 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a01ddc76d37b180c1564c96963ccce0bbe32cc9efd4c29deede6e1c3e7a8f7c7
-  data.tar.gz: a97df2927f2f5df0fce593b2ff55fa123d983ab6023690326bce9634ead51b31
+  metadata.gz: 432c84ac7303d7194f5617f2fe724bdb2d332662eb543a0545712731cac767dc
+  data.tar.gz: 90343cbda95d9a89452aabf86da6731606d2404a4c2bcd0a9358b48f705bd6cb
 SHA512:
-  metadata.gz: e5ba8be1ae92c054686603867e11cda5b1af8482113ae2fcd4b36303e9631f1bdfd3c915b5e724a84dcd3c20c29f2a3f46bb92f74654716c3037625125d00820
-  data.tar.gz: 0d8327b6f04162da2ceedf697ac0a0e3dde789584870ebde8c2769ac43e6bb00836a81386b61d519b2472cd4acd8ffaf19472bbd0490c7911f9295c5216d4ed4
+  metadata.gz: 631a11eea99a092b2c104ff3934fcddd1777f8a2346468ef91170ff1bc5acea9844002b438b4ec668a5a20f7a97d58c69bdf8f99482b1b757e4ccf01fadf119c
+  data.tar.gz: 886a2975a48967efcf844c4577f05c2ebbb4cd8ed2d6c883e80c6830b1388f57b38b9f6e202376b01a71d1109ec75869d20ab143950d60cb5638e98e4b111c02

data/README.md

@@ -1,6 +1,6 @@
-# ActionSpec [WIP]
+# ActionSpec
 
-Concise and Powerful API Documentation Solution for Rails.
+Concise and Powerful API Documentation Solution for Rails. [中文](README_zh.md)
 
 <img src=".github/assets/action_spec.jpg" />
 
@@ -10,24 +10,30 @@ Concise and Powerful API Documentation Solution for Rails.
 
 ## Table Of Contents
 
-- [OpenAPI Generation](#openapi-generation)
-- [Doc DSL](#doc-dsl)
-  - [`doc`](#doc)
-  - [`doc_dry`](#doc_dry)
-  - [DSL Reference](#dsl-reference)
-- [Schemas](#schemas)
-  - [Declare A Required Field](#declare-a-required-field)
-  - [Field Types](#field-types)
-  - [Field Options](#field-options)
-  - [Schemas From ActiveRecord](#schemas-from-activerecord)
-  - [Type And Boundary Matrix](#type-and-boundary-matrix)
-- [Parameter Validation And Type Coercion](#parameter-validation-and-type-coercion)
-  - [Validation Flow](#validation-flow)
-  - [Reading Processed Values With `px`](#reading-processed-values-with-px)
-  - [Errors](#errors)
-- [Configuration And I18n](#configuration-and-i18n)
-  - [Configuration](#configuration)
-  - [I18n](#i18n)
+1. [OpenAPI Generation](#openapi-generation)
+2. [Doc DSL](#doc-dsl)
+   1. [`doc`](#doc)
+   2. [`doc_dry`](#doc_dry)
+   3. [DSL Inside `doc`](#dsl-inside-doc)
+      1. [Parameter](#parameter)
+      2. [request body](#request-body)
+      3. [`openapi false`](#openapi-false)
+      4. [Scope](#scope)
+      5. [Response](#response)
+3. [Schemas](#schemas)
+   1. [Declare A Required Field](#declare-a-required-field)
+   2. [Field Types](#field-types)
+   3. [Field Options](#field-options)
+   4. [Schemas From ActiveRecord](#schemas-from-activerecord)
+   5. [Type And Boundary Matrix](#type-and-boundary-matrix)
+4. [Parameter Validation And Type Coercion](#parameter-validation-and-type-coercion)
+   1. [Validation Flow](#validation-flow)
+   2. [Reading Processed Values With `px`](#reading-processed-values-with-px)
+   3. [Errors](#errors)
+5. [Configuration And I18n](#configuration-and-i18n)
+   1. [Configuration](#configuration)
+   2. [I18n](#i18n)
+6. [AI Generation Style Guide](#ai-generation-style-guide)
 
 ## Example
 
@@ -56,10 +62,8 @@ class UsersController < ApplicationController
   }
   def create
     User.create!(
-      account_id: px[:account_id],
-      name: px[:name],
-      birthday: px[:birthday],
-      admin: px[:admin]
+      account_id: px[:account_id], name: px[:name],
+      **px.slice(:birthday, :admin, :profile)
     )
   end
 end
@@ -92,7 +96,7 @@ By default, this writes to:
 docs/openapi.yml
 ```
 
-For one-off runs, environment variables can override the default output path and document metadata:
+Environment variables can override the default output path and document metadata:
 
 ```bash
 bin/rails action_spec:gen \
@@ -146,6 +150,18 @@ def create
 end
 ```
 
+Override the default OpenAPI tag with `tag:`. By default, the tag comes from the routed `controller_path`:
+
+```ruby
+doc_dry(:index, tag: "backoffice")
+
+doc("List users", tag: "members") {
+  query :status, String
+}
+```
+
+Generated OpenAPI operations also include an `operationId`, built from the final tag plus the action name, for example `members_index` or `users_create`.
+
 ### `doc_dry`
 
 ```ruby
@@ -163,15 +179,7 @@ end
 
 All matching dry blocks are applied before the action-specific `doc`.
 
-You can also opt an action out of OpenAPI generation from either `doc` or `doc_dry`:
-
-```ruby
-doc {
-  openapi false
-}
-```
-
-### DSL Reference
+### DSL Inside `doc`
 
 #### Parameter
 
@@ -189,7 +197,16 @@ cookie  :remember_token, String
 cookie! :remember_token, String
 ```
 
-Bang methods mark the field as required. For example, `query! :page, Integer` means the request must include `page`.
+Bang methods mark the field as required. For example, `query! :page, Integer` means the request must include `page`, and the value must not be `nil`. Blank values are still allowed unless you set `blank: false`.
+
+If you prefer not to use bang methods, you can also write `required: true`:
+
+```ruby
+query :page, Integer, required: true
+json data: {
+  title: { type: String, required: true }
+}
+```
 
 Batch declaration forms:
 
@@ -230,11 +247,9 @@ Convenience helpers:
 
 ```ruby
 json data: { name!: String }
-
 json! data: { name!: String }
 
 form data: { file!: File, position: String }
-
 form! data: { file!: File }
 ```
 
@@ -244,16 +259,23 @@ Single multipart field helper:
 data :file, File
 ```
 
-For `body/body!`, `json/json!`, and `form/form!`, the bang form is currently kept for DSL compatibility. At runtime they all contribute to the same body contract, and root-body requiredness is not yet enforced as a separate rule.
+Notes:
+
+1. When multiple `body/body!`, `json/json!`, or `form/form!` declarations are used:
+   - declarations with the same media type are merged
+   - if multiple media types are declared, the generated OpenAPI document will emit multiple media types
+   - field validation and coercion do not distinguish between media types, and always read values from Rails `params`
+
+`body!`, `json!`, and `form!` make the root request body required at runtime. You can also write `required: true` on `body`, `json`, or `form` if you prefer not to use bang methods.
 
-#### OpenAPI
+#### `openapi false`
+
+You can also opt an action out of OpenAPI generation from either `doc` or `doc_dry`:
 
 ```ruby
 openapi false
 ```
 
-Use this when an action should stay out of the generated OpenAPI document. It also works inside `doc_dry`.
-
 #### Scope
 
 Use `scope` when you want a grouped view that spans multiple request locations:
@@ -264,6 +286,7 @@ doc {
     query :user_id, Integer
     form data: { name: String }
   }
+  form data: { not_in_scope: String }
 }
 ```
 
@@ -278,11 +301,27 @@ px.scope[:user] # => { user_id: 1, name: "Tom" }
 ```ruby
 response 200, desc: "success"
 response 422, "validation failed"
-resp 400, "bad request"
+response 200, :json, data: { code!: Integer, result: Object }
+
 error 401, "unauthorized"
+error 503, { code!: Integer, message!: String } # error data schema
+error 503, { code: 1000, message: "invalid params" } # unnamed error example
+error 503, invalid_params: { code: 1000, message: "invalid params" } # named error example
+# declare multiple named examples in batch
+errors 503, {
+  invalid_params: { code: 1000, message: "invalid params" },
+  network_error: { code: 1001, message: "network error" }
+}
+errors 503, network_error: { code: 1001 }, upstream_timeout: { code: 1002 } # braces are also optional
+
 ```
 
-Response declarations are stored as metadata now. They are not yet used to render responses automatically.
+Response declarations are stored as metadata and are emitted in OpenAPI. They do not render responses automatically at runtime.
+
+Notes:
+
+1. `response`, `error`, and `errors` default `media_type` to `:json` and this default is configurable.
+2. If examples are declared without an explicit schema, ActionSpec infers the response schema from the example payloads for OpenAPI generation.
 
 ## Schemas
 
@@ -305,7 +344,11 @@ Meaning of `!`:
 
 - `query!`, `path!`, `header!`, `cookie!` mark the parameter itself as required
 - keys such as `name!:` or `nickname!:` mark nested object fields as required
-- `body!`, `json!`, and `form!` are currently accepted for DSL consistency, but today they behave the same as the non-bang form at runtime
+- `body!`, `json!`, and `form!` mark the root request body as required
+
+You can also use `required: true` instead of bang syntax for parameters, nested fields, and the root request body.
+
+`required` in ActionSpec means "present and not `nil`". It does not reject blank strings by itself. If you want to reject blank values, use `blank: false` or `allow_blank: false`.
 
 #### Field Types
 
@@ -337,26 +380,31 @@ json data: {
 
 #### Field Options
 
-These options are currently used by the validator:
-
 ```ruby
 query :page, Integer, default: 1
 query :today, Date, default: -> { Time.current.to_date }
 query :status, String, enum: %w[draft published]
 query :score, Integer, range: { ge: 1, le: 5 }
 query :slug, String, pattern: /\A[a-z\-]+\z/
+query :title, String, blank: false # or allow_blank: false
+
+query :nickname, String, transform: :downcase
+query :page, Integer, transform: -> { it + 1 }, px: :page_number
+query :request_id, String, px_key: :trace_id
 ```
 
-These options are currently used by OpenAPI generation, but are not yet used by the runtime validator:
+Notes:
 
-- `desc`
-- `example`
-- `examples`
+- `transform` accepts a `Symbol` or a `Proc` and runs **after coercion**, before the value is written into `px`
+- `px` and `px_key` customize the key name written into `px`; `px` is the short form of `px_key`
 
-These options are not yet used by either the runtime validator or OpenAPI generation:
+These options are used by OpenAPI generation:
 
-- `allow_nil`
-- `allow_blank`
+```ruby
+query :page, Integer, desc: "page number", example: 1, examples: [1, 2, 3]
+```
+
+If an OpenAPI-facing option such as `default` cannot be converted into YAML, for example `default: -> { ... }`, it will be omitted from the generated OpenAPI document.
 
 #### Schemas From ActiveRecord
 
@@ -466,6 +514,8 @@ This hook also skips actions without a matching `doc`, so it is safe to declare
 
 `px` stores the processed values produced by ActionSpec. With `validate_params!` they stay raw; with `validate_and_coerce_params!` they are coerced values.
 
+Because `px` is still a hash, you can also use helpers such as `px.slice(...)` to simplify parameter access code.
+
 ```ruby
 px[:id]
 px[:page]
@@ -535,6 +585,7 @@ ActionSpec.configure { |config|
   config.open_api_title = "My API"
   config.open_api_version = "2026.03"
   config.open_api_server_url = "https://api.example.com"
+  config.default_response_media_type = :json
 
   config.error_messages[:invalid_type] = ->(_attribute, options) {
     "should be coercible to #{options.fetch(:expected)}"
@@ -544,29 +595,13 @@ ActionSpec.configure { |config|
 
 Available config keys:
 
-- `invalid_parameters_exception_class`
-  Default: `ActionSpec::InvalidParameters`.
-  Controls which exception class is raised when validation fails.
-
-- `error_messages`
-  Default: `{}`.
-  Lets you override error messages by error type, or by attribute plus error type.
-
-- `open_api_output`
-  Default: `"docs/openapi.yml"`.
-  Controls where `bin/rails action_spec:gen` writes the generated OpenAPI document.
-
-- `open_api_title`
-  Default: `nil`.
-  Sets the default OpenAPI `info.title` used by `bin/rails action_spec:gen`.
-
-- `open_api_version`
-  Default: `nil`.
-  Sets the default OpenAPI `info.version` used by `bin/rails action_spec:gen`.
-
-- `open_api_server_url`
-  Default: `nil`.
-  Sets the default server URL emitted in the generated OpenAPI document.
+- `invalid_parameters_exception_class`: Default `ActionSpec::InvalidParameters`; controls which exception class is raised when validation fails.
+- `error_messages`: Default `{}`; lets you override error messages by error type, or by attribute plus error type.
+- `open_api_output`: Default `"docs/openapi.yml"`; controls where `bin/rails action_spec:gen` writes the generated OpenAPI document.
+- `open_api_title`: Default `nil`; sets the default OpenAPI `info.title` used by `bin/rails action_spec:gen`.
+- `open_api_version`: Default `nil`; sets the default OpenAPI `info.version` used by `bin/rails action_spec:gen`.
+- `open_api_server_url`: Default `nil`; sets the default server URL emitted in the generated OpenAPI document.
+- `default_response_media_type`: Default `:json`; sets the default response media type used by `response`, `error`, and `errors` when no media type is passed explicitly.
 
 ### I18n
 
@@ -596,15 +631,26 @@ ActionSpec.configure { |config|
 }
 ```
 
+## AI Generation Style Guide
+
+When using AI tools to generate Rails controller code, and the change involves parameter validation, type coercion, default values, or similar parameter contracts, these conventions work well with ActionSpec:
+
+- use `doc { }` or `doc("Summary") { }`; do not add the action name, and do not leave a blank line between the `doc` block and the action method
+- use `{ }` blocks inside `doc` as well; prefer them over `do ... end`
+- when a batch has 3 fields or fewer and does not contain nested hashes, prefer a single-line style, for example:
+  - `json data: { type: String, required: true }`
+  - `in_query(name: String, value: String)` (prefer `in_xxx(...)` batch declarations over multiple `xx` DSL lines when possible)
+- use `doc_dry`, `scope`, and `transform`、`px(px_key)`、`px.slice` to keep controller concise
+- when request parameters match model declarations, prefer `.schemas` to keep `doc` concise
+
 ## What Is Not Implemented Yet
 
 - reusable `components` generation
 - `$ref` generation and deduplication
-- `description`, `operationId`, `tags`, `externalDocs`, `deprecated`, and `security` on operations
+- `description`, `externalDocs`, `deprecated`, and `security` on operations
 - parameter-level `style`, `explode`, `allowReserved`, `examples`, and richer header/cookie serialization controls
 - request body `encoding`
 - multiple request/response media types beyond the current direct DSL mapping
-- response body schema generation; current `response` / `resp` / `error` declarations only generate response descriptions
 - response headers
 - response links
 - callbacks
@@ -615,7 +661,7 @@ ActionSpec.configure { |config|
 - top-level `tags`
 - top-level `externalDocs`
 - `jsonSchemaDialect`
-- richer schema keywords beyond the current subset, including nullable/blank semantics, object-level constraints, and composition keywords such as `oneOf`, `anyOf`, `allOf`, and `not`
+- richer schema keywords beyond the current subset, including object-level constraints, and composition keywords such as `oneOf`, `anyOf`, `allOf`, and `not`
 
 ## Contributing
 

data/lib/action_spec/configuration.rb

@@ -3,7 +3,7 @@
 module ActionSpec
   class Configuration
     attr_accessor :invalid_parameters_exception_class, :open_api_output, :open_api_title, :open_api_version,
-                  :open_api_server_url
+                  :open_api_server_url, :default_response_media_type
     attr_reader :error_messages
 
     def initialize
@@ -12,6 +12,7 @@ module ActionSpec
       @open_api_title = nil
       @open_api_version = nil
       @open_api_server_url = nil
+      @default_response_media_type = :json
       @error_messages = ActiveSupport::HashWithIndifferentAccess.new
     end
 
@@ -33,6 +34,7 @@ module ActionSpec
         copy.open_api_title = open_api_title
         copy.open_api_version = open_api_version
         copy.open_api_server_url = open_api_server_url
+        copy.default_response_media_type = default_response_media_type
         copy.error_messages = error_messages.deep_dup
       end
     end

data/lib/action_spec/doc/dsl.rb

@@ -28,12 +28,12 @@ module ActionSpec
         end
       end
 
-      def body(media_type, data: {}, **)
-        add_body(media_type, data)
+      def body(media_type, data: {}, required: false, **)
+        add_body(media_type, data, required:)
       end
 
       def body!(media_type, data: {}, **)
-        add_body(media_type, data)
+        add_body(media_type, data, required: true)
       end
 
       def json(data:, **options)
@@ -67,57 +67,85 @@ module ActionSpec
         endpoint.options[:openapi] = enabled
       end
 
-      def response(code, description = nil, media_type = nil, desc: nil, **options)
+      RESPONSE_MEDIA_TYPES = %i[json form].freeze
+
+      def response(code, description = nil, media_type = nil, desc: nil, data: nil, example: nil, examples: nil, **options)
+        description, media_type = normalize_response_arguments(description, media_type)
+        schema, example, examples = normalize_response_body(description, data:, example:, examples:, options:)
         endpoint.add_response(
           code,
           Response.new(
             code:,
-            description: description || desc.to_s,
-            media_type:,
+            description: resolved_description(description, desc),
+            media_type: media_type || ActionSpec.config.default_response_media_type,
+            schema:,
+            example:,
+            examples:,
             options:
           )
         )
       end
 
-      alias resp response
-      alias error response
+      def error(code, description = nil, media_type = nil, desc: nil, **options)
+        response(code, description, media_type, desc: desc || "Error", **options)
+      end
+
+      def errors(code, examples = nil, media_type = nil, desc: "Error", **options)
+        response(code, nil, media_type, desc:, examples: examples || options, **options.except(*Array((examples || options).keys)))
+      end
 
       private
 
         attr_reader :endpoint
         attr_reader :scopes
 
+        def normalize_response_arguments(description, media_type)
+          return [nil, description] if media_type.nil? && response_media_type?(description)
+
+          [description, media_type]
+        end
+
+        def response_media_type?(value)
+          value.is_a?(Symbol) && RESPONSE_MEDIA_TYPES.include?(value)
+        end
+
+        def normalize_response_body(description, data:, example:, examples:, options:)
+          return [data && ActionSpec::Schema.from_definition(data), example, examples] if data || example || examples
+          return [nil, nil, options.presence] if options.present?
+          return [nil, nil, nil] if description.is_a?(String) || description.nil?
+
+          parsed_schema = ActionSpec::Schema.schema_definition?(description) ? ActionSpec::Schema.from_definition(description) : nil
+          return [parsed_schema, nil, nil] if parsed_schema
+
+          [nil, description, options.presence]
+        end
+
+        def resolved_description(description, desc)
+          return description if description.is_a?(String)
+          return desc if desc.present?
+
+          nil
+        end
+
         def add_param(location_name, name, type, required:, **options)
-          schema = ActionSpec::Schema.build(type, **options)
-          endpoint.request.add_param(location_name, ActionSpec::Schema::Field.new(name:, required:, schema:, scopes: scopes.dup))
+          required ||= options.delete(:required) == true
+          endpoint.request.add_param(
+            location_name,
+            ActionSpec::Schema.build_field(name, options.merge(type:), required:, scopes: scopes.dup)
+          )
         end
 
         def add_many(location_name, params, required:)
           params.each_pair do |name, definition|
-            if definition.is_a?(Hash) && !definition.key?(:type) && !definition.key?("type")
-              schema_options = definition.symbolize_keys
-              if (schema_options.keys - ActionSpec::Schema::OPTION_KEYS).present?
-                endpoint.request.add_param(
-                  location_name,
-                  ActionSpec::Schema::Field.new(
-                    name:,
-                    required:,
-                    schema: ActionSpec::Schema.from_definition(definition),
-                    scopes: scopes.dup
-                  )
-                )
-              else
-                add_param(location_name, name, String, required:, **definition)
-              end
-            elsif definition.is_a?(Hash)
-              add_param(location_name, name, definition[:type] || definition["type"] || String, required:, **definition.symbolize_keys.except(:type))
-            else
-              add_param(location_name, name, definition, required:)
-            end
+            endpoint.request.add_param(
+              location_name,
+              ActionSpec::Schema.build_field(name, definition, required:, scopes: scopes.dup)
+            )
           end
         end
 
-        def add_body(media_type, definition)
+        def add_body(media_type, definition, required:)
+          endpoint.request.require_body! if required
           ActionSpec::Schema.build_fields(definition, scopes: scopes.dup).each_value do |field|
             endpoint.request.add_body(media_type, field)
           end

data/lib/action_spec/doc/endpoint.rb

@@ -23,7 +23,8 @@ module ActionSpec
       end
 
       def add_response(code, response)
-        @responses[code.to_s] = response
+        existing = @responses[code.to_s]
+        @responses[code.to_s] = existing ? existing.merge(response) : response
       end
 
       def copy
@@ -46,6 +47,7 @@ module ActionSpec
         @cookie = Location.new(:cookie)
         @body = Location.new(:body)
         @body_media_types = {}
+        @body_required = false
       end
 
       def location(name)
@@ -61,6 +63,14 @@ module ActionSpec
         (@body_media_types[media_type.to_sym] ||= Location.new(media_type.to_sym)).add(field.copy)
       end
 
+      def require_body!
+        @body_required = true
+      end
+
+      def body_required?
+        @body_required
+      end
+
       def replace_with(other)
         @header = other.header
         @path = other.path
@@ -68,6 +78,7 @@ module ActionSpec
         @cookie = other.cookie
         @body = other.body
         @body_media_types = other.body_media_types
+        @body_required = other.body_required?
       end
 
       def copy
@@ -81,6 +92,7 @@ module ActionSpec
             :@body_media_types,
             body_media_types.transform_values(&:copy)
           )
+          request.instance_variable_set(:@body_required, body_required?)
         end
       end
     end
@@ -123,18 +135,87 @@ module ActionSpec
     end
 
     class Response
-      attr_reader :code, :description, :media_type, :options
+      attr_reader :code, :description, :media_types, :options
 
-      def initialize(code:, description:, media_type:, options:)
+      def initialize(code:, description:, media_type:, schema: nil, example: nil, examples: nil, options:)
         @code = code.to_s
         @description = description
-        @media_type = media_type
-        @options = options
+        @media_types = ActiveSupport::OrderedHash.new
+        @options = options.deep_dup
+        merge_media_type!(media_type || :json, schema:, example:, examples:, initialize: true)
+      end
+
+      def merge(other)
+        copy.tap do |merged|
+          merged.instance_variable_set(:@description, other.description.presence || description)
+          merged.instance_variable_set(:@options, options.deep_dup.merge(other.options.deep_dup))
+          other.media_types.each do |media_type, content|
+            merged.send(:merge_media_type!, media_type, **merged.send(:copy_content, content))
+          end
+        end
       end
 
       def copy
-        self.class.new(code:, description:, media_type:, options: options.deep_dup)
+        self.class.new(
+          code:,
+          description:,
+          media_type: nil,
+          schema: nil,
+          example: nil,
+          examples: nil,
+          options: options.deep_dup
+        ).tap do |response|
+          response.instance_variable_set(
+            :@media_types,
+            media_types.each_with_object(ActiveSupport::OrderedHash.new) do |(media_type, content), hash|
+              hash[media_type] = copy_content(content)
+            end
+          )
+        end
       end
+
+      private
+
+        def merge_media_type!(media_type, schema:, example:, examples:, initialize: false)
+          content = (@media_types[media_type.to_sym] ||= {
+            schema: nil,
+            example: nil,
+            examples: ActiveSupport::OrderedHash.new
+          })
+          content[:schema] = schema || content[:schema]
+
+          if examples.present?
+            convert_example_into_default_example!(content)
+            content[:examples].merge!(normalize_examples(examples))
+          elsif !example.nil?
+            if content[:examples].present? && !initialize
+              content[:examples]["default"] ||= example
+            else
+              content[:example] = example
+            end
+          end
+        end
+
+        def convert_example_into_default_example!(content)
+          return if content[:example].nil?
+
+          content[:examples]["default"] ||= content[:example]
+          content[:example] = nil
+        end
+
+        def normalize_examples(examples)
+          examples.each_with_object(ActiveSupport::OrderedHash.new) do |(name, value), hash|
+            hash[name.to_s] = value
+          end
+        end
+
+        def copy_content(content)
+          {
+            schema: content[:schema]&.copy,
+            example: content[:example].deep_dup,
+            examples: content[:examples].deep_dup
+          }
+        end
     end
   end
 end