Enhance macro options (#75)

## Description

This pull request enhances the customization options for macro expansion
on `Schemable`.

```swift
@Schemable
+ @ObjectOptions(.additionalProperties { false })
struct Person {
  let firstName: String
  let lastName: String?
-  @NumberOptions(minimum: 0, maximum: 120)
+  @NumberOptions(.minimum(0), .maximum(120))
  let age: Int
}
```

Notice that the `@ObjectOptions` macro now supports additional
properties object options and other closure based options that were
removed when parsing was introduced.

Instead of the option settings have a new trait-based syntax that allows
for extensibility and the closures/builders mentioned above.

Closes #19 , #27

## Type of Change

- [x] Bug fix
- [x] New feature
- [x] Breaking change
- [x] Documentation update

## Additional Notes

Add any other context or screenshots about the pull request here.

Author: ajevans99

.github/actions/xcode-setup/action.yml

@@ -6,4 +6,4 @@ runs:
     - name: Xcode setup
       shell: bash
       run: |
-        sudo xcode-select -s /Applications/Xcode_16.1.app
+        sudo xcode-select -s /Applications/Xcode_16.3.app

.github/workflows/ci.yml

@@ -11,7 +11,7 @@ on:
 
 jobs:
   build_and_test:
-    runs-on: macos-latest
+    runs-on: macos-15
 
     name: Build and Test on macOS with Swift 6.0
     steps:
@@ -29,7 +29,7 @@ jobs:
     - name: Build
       run: swift build -v
     - name: Run tests
-      run: swift test --enable-experimental-swift-testing
+      run: swift test
 
   build_linux:
     name: Build on Linux

README.md

@@ -46,11 +46,20 @@ Use the power of Swift result builders to generate JSON schema documents.
 
 <details>
   <summary>Generated JSON Schema</summary>
+
+  `Schema` returned from `personSchema.definition()` conforms to `Codable`.
+
+  ```swift
+  let encoder = JSONEncoder()
+  encoder.outputFormatting = .prettyPrinted
+
+  let schemaData = try! encoder.encode(personSchema.definition())
+  let string = String(data: schemaData, encoding: .utf8)!
+  print(string)
+  ```
 
   ```json
   {
-    "$id": "https://example.com/person.schema.json",
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
     "title": "Person",
     "type": "object",
     "properties": {
@@ -78,10 +87,11 @@ Use the `@Schemable` macro from `JSONSchemaBuilder` to automatically generate th
 
 ```swift
 @Schemable
+@ObjectOptions(.additionalProperties { false })
 struct Person {
   let firstName: String
   let lastName: String?
-  @NumberOptions(minimum: 0, maximum: 120)
+  @NumberOptions(.minimum(0), .maximum(120))
   let age: Int
 }
 ```
@@ -113,6 +123,7 @@ struct Person {
           }
           .required()
         }
+        .additionalProperties { false }
       }
     }
   }
@@ -236,8 +247,7 @@ dump(result2, name: "Instance 2 Validation Result")
 <details>
   <summary>Instance 2 Validation Result</summary>
 
-  ```
-  ▿ Instance 2 Validation Result: JSONSchema.ValidationResult
+  ```  ▿ Instance 2 Validation Result: JSONSchema.ValidationResult
   - isValid: false
   ▿ keywordLocation: #
     - path: 0 elements

Sources/JSONSchemaBuilder/Documentation.docc/Articles/Macros.md

@@ -55,14 +55,14 @@ There are also type specific attributes that can be used to customize the genera
 ```swift
 @Schemable
 struct Person {
-  @SchemaOptions(description: "The person's first name.")
+  @SchemaOptions(.description("The person's first name."))
   let firstName: String
 
-  @SchemaOptions(description: "The person's last name.")
+  @SchemaOptions(.description("The person's last name."))
   let lastName: String
 
-  @SchemaOptions(description: "Age in years")
-  @JSONInteger(minimum: 0, maximum: 120)
+  @SchemaOptions(.description("Age in years"))
+  @NumberOptions(.minimum(0), .maximum(120))
   let age: Int
 }
 ```

Sources/JSONSchemaBuilder/Macros/SchemaOptions/SchemaOptions.swift

@@ -2,12 +2,48 @@ import JSONSchema
 
 @attached(peer)
 public macro SchemaOptions(
-  title: String? = nil,
-  description: String? = nil,
-  default: JSONValue? = nil,
-  examples: JSONValue? = nil,
-  readOnly: Bool? = nil,
-  writeOnly: Bool? = nil,
-  deprecated: Bool? = nil,
-  comment: String? = nil
+  _ traits: SchemaTrait...
 ) = #externalMacro(module: "JSONSchemaMacro", type: "SchemaOptionsMacro")
+
+public protocol SchemaTrait {}
+
+public struct SchemaOptionsTrait: SchemaTrait {
+  fileprivate init() {}
+
+  fileprivate static let errorMessage =
+    "This method should only be used within @SchemaOptions macro"
+}
+
+extension SchemaTrait where Self == SchemaOptionsTrait {
+  public static func title(_ value: String) -> SchemaOptionsTrait {
+    fatalError(SchemaOptionsTrait.errorMessage)
+  }
+
+  public static func description(_ value: String) -> SchemaOptionsTrait {
+    fatalError(SchemaOptionsTrait.errorMessage)
+  }
+
+  public static func `default`(_ value: JSONValue) -> SchemaOptionsTrait {
+    fatalError(SchemaOptionsTrait.errorMessage)
+  }
+
+  public static func examples(_ value: JSONValue) -> SchemaOptionsTrait {
+    fatalError(SchemaOptionsTrait.errorMessage)
+  }
+
+  public static func readOnly(_ value: Bool) -> SchemaOptionsTrait {
+    fatalError(SchemaOptionsTrait.errorMessage)
+  }
+
+  public static func writeOnly(_ value: Bool) -> SchemaOptionsTrait {
+    fatalError(SchemaOptionsTrait.errorMessage)
+  }
+
+  public static func deprecated(_ value: Bool) -> SchemaOptionsTrait {
+    fatalError(SchemaOptionsTrait.errorMessage)
+  }
+
+  public static func comment(_ value: String) -> SchemaOptionsTrait {
+    fatalError(SchemaOptionsTrait.errorMessage)
+  }
+}

Sources/JSONSchemaBuilder/Macros/SchemaOptions/TypeSpecific/ArrayOptions.swift

@@ -2,9 +2,54 @@ import JSONSchema
 
 @attached(peer)
 public macro ArrayOptions(
-  minContains: Int? = nil,
-  maxContains: Int? = nil,
-  minItems: Int? = nil,
-  maxItems: Int? = nil,
-  uniqueItems: Bool? = nil
+  _ traits: ArrayTrait...
 ) = #externalMacro(module: "JSONSchemaMacro", type: "ArrayOptionsMacro")
+
+public protocol ArrayTrait {}
+
+public struct ArraySchemaTrait: ArrayTrait {
+  fileprivate init() {}
+
+  fileprivate static let errorMessage = "This method should only be used within @ArrayOptions macro"
+}
+
+extension ArrayTrait where Self == ArraySchemaTrait {
+  public static func minContains(_ value: Int) -> ArraySchemaTrait {
+    fatalError(ArraySchemaTrait.errorMessage)
+  }
+
+  public static func maxContains(_ value: Int) -> ArraySchemaTrait {
+    fatalError(ArraySchemaTrait.errorMessage)
+  }
+
+  public static func minItems(_ value: Int) -> ArraySchemaTrait {
+    fatalError(ArraySchemaTrait.errorMessage)
+  }
+
+  public static func maxItems(_ value: Int) -> ArraySchemaTrait {
+    fatalError(ArraySchemaTrait.errorMessage)
+  }
+
+  public static func uniqueItems(_ value: Bool = true) -> ArraySchemaTrait {
+    fatalError(ArraySchemaTrait.errorMessage)
+  }
+
+  public static func prefixItems(
+    @JSONSchemaCollectionBuilder<JSONValue> _ prefixItems: @escaping () -> [JSONComponents
+      .AnyComponent<JSONValue>]
+  ) -> ArraySchemaTrait {
+    fatalError(ArraySchemaTrait.errorMessage)
+  }
+
+  public static func unevaluatedItems<Component: JSONSchemaComponent>(
+    @JSONSchemaBuilder _ unevaluatedItems: @escaping () -> Component
+  ) -> ArraySchemaTrait {
+    fatalError(ArraySchemaTrait.errorMessage)
+  }
+
+  public static func contains(
+    @JSONSchemaBuilder _ contains: @escaping () -> any JSONSchemaComponent
+  ) -> ArraySchemaTrait {
+    fatalError(ArraySchemaTrait.errorMessage)
+  }
+}

Sources/JSONSchemaBuilder/Macros/SchemaOptions/TypeSpecific/NumberOptions.swift

@@ -2,9 +2,36 @@ import JSONSchema
 
 @attached(peer)
 public macro NumberOptions(
-  multipleOf: Double? = nil,
-  minimum: Double? = nil,
-  exclusiveMinimum: Bool? = nil,
-  maximum: Double? = nil,
-  exclusiveMaximum: Bool? = nil
+  _ traits: NumberTrait...
 ) = #externalMacro(module: "JSONSchemaMacro", type: "NumberOptionsMacro")
+
+public protocol NumberTrait {}
+
+public struct NumberSchemaTrait: NumberTrait {
+  fileprivate init() {}
+
+  fileprivate static let errorMessage =
+    "This method should only be used within @NumberOptions macro"
+}
+
+extension NumberTrait where Self == NumberSchemaTrait {
+  public static func multipleOf(_ value: Double) -> NumberSchemaTrait {
+    fatalError(NumberSchemaTrait.errorMessage)
+  }
+
+  public static func minimum(_ value: Double) -> NumberSchemaTrait {
+    fatalError(NumberSchemaTrait.errorMessage)
+  }
+
+  public static func exclusiveMinimum(_ value: Double) -> NumberSchemaTrait {
+    fatalError(NumberSchemaTrait.errorMessage)
+  }
+
+  public static func maximum(_ value: Double) -> NumberSchemaTrait {
+    fatalError(NumberSchemaTrait.errorMessage)
+  }
+
+  public static func exclusiveMaximum(_ value: Double) -> NumberSchemaTrait {
+    fatalError(NumberSchemaTrait.errorMessage)
+  }
+}

Sources/JSONSchemaBuilder/Macros/SchemaOptions/TypeSpecific/ObjectOptions.swift

@@ -2,6 +2,48 @@ import JSONSchema
 
 @attached(peer)
 public macro ObjectOptions(
-  minProperties: Int? = nil,
-  maxProperties: Int? = nil
+  _ traits: ObjectTrait...
 ) = #externalMacro(module: "JSONSchemaMacro", type: "ObjectOptionsMacro")
+
+public protocol ObjectTrait {}
+
+public struct ObjectSchemaTrait: ObjectTrait {
+  fileprivate init() {}
+
+  fileprivate static let errorMessage =
+    "This method should only be used within @ObjectOptions macro"
+}
+
+extension ObjectTrait where Self == ObjectSchemaTrait {
+  public static func additionalProperties(
+    @JSONSchemaBuilder _ content: @escaping () -> some JSONSchemaComponent
+  ) -> ObjectSchemaTrait {
+    fatalError(ObjectSchemaTrait.errorMessage)
+  }
+
+  public static func patternProperties(
+    @JSONPropertySchemaBuilder _ patternProperties: @escaping () -> some PropertyCollection
+  ) -> ObjectSchemaTrait {
+    fatalError(ObjectSchemaTrait.errorMessage)
+  }
+
+  public static func unevaluatedProperties(
+    @JSONSchemaBuilder _ content: @escaping () -> some JSONSchemaComponent
+  ) -> ObjectSchemaTrait {
+    fatalError(ObjectSchemaTrait.errorMessage)
+  }
+
+  public static func minProperties(_ value: Int) -> ObjectSchemaTrait {
+    fatalError(ObjectSchemaTrait.errorMessage)
+  }
+
+  public static func maxProperties(_ value: Int) -> ObjectSchemaTrait {
+    fatalError(ObjectSchemaTrait.errorMessage)
+  }
+
+  public static func propertyNames(
+    @JSONSchemaBuilder _ content: @escaping () -> some JSONSchemaComponent
+  ) -> ObjectSchemaTrait {
+    fatalError(ObjectSchemaTrait.errorMessage)
+  }
+}

Sources/JSONSchemaBuilder/Macros/SchemaOptions/TypeSpecific/StringOptions.swift

@@ -2,8 +2,32 @@ import JSONSchema
 
 @attached(peer)
 public macro StringOptions(
-  minLength: Int? = nil,
-  maxLength: Int? = nil,
-  pattern: String? = nil,
-  format: String? = nil
+  _ traits: StringTrait...
 ) = #externalMacro(module: "JSONSchemaMacro", type: "StringOptionsMacro")
+
+public protocol StringTrait {}
+
+public struct StringSchemaTrait: StringTrait {
+  fileprivate init() {}
+
+  fileprivate static let errorMessage =
+    "This method should only be used within @StringOptions macro"
+}
+
+extension StringTrait where Self == StringSchemaTrait {
+  public static func minLength(_ value: Int) -> StringSchemaTrait {
+    fatalError(StringSchemaTrait.errorMessage)
+  }
+
+  public static func maxLength(_ value: Int) -> StringSchemaTrait {
+    fatalError(StringSchemaTrait.errorMessage)
+  }
+
+  public static func pattern(_ value: String) -> StringSchemaTrait {
+    fatalError(StringSchemaTrait.errorMessage)
+  }
+
+  public static func format(_ value: String) -> StringSchemaTrait {
+    fatalError(StringSchemaTrait.errorMessage)
+  }
+}

Sources/JSONSchemaClient/main.swift

@@ -43,7 +43,7 @@ struct Flight: Sendable {
   let origin: String
   let destination: String?
   let airline: Airline
-  @NumberOptions(multipleOf: 0.5)
+  @NumberOptions(.multipleOf(0.5))
   let duration: Double
 }
 
@@ -67,6 +67,10 @@ let nameBuilder = JSONObject {
 }
 let schema = nameBuilder.definition()
 
+let schemaData = try! encoder.encode(nameBuilder.definition())
+let string = String(data: schemaData, encoding: .utf8)!
+print(string)
+
 let instance1: JSONValue = ["name": "Alice"]
 let instance2: JSONValue = ["name": ""]
 
@@ -76,6 +80,18 @@ let result2 = schema.validate(instance2)
 dump(result2, name: "Instance 2 Validation Result")
 
 @Schemable
+@ObjectOptions(.additionalProperties { false })
 public struct Weather {
   let temperature: Double
 }
+
+@Schemable
+@ObjectOptions(
+  .additionalProperties {
+    JSONString()
+      .pattern("^[a-zA-Z]+$")
+  }
+)
+public struct Weather20 {
+  let temperature: Double
+}