[refactor] Controllable -> Callable 이름 수정

Author: ShapeKim98

README.md

@@ -9,7 +9,7 @@ Delegation is a Swift macro package that unlocks builder-style configuration for
 ## 주요 기능 (Features)
 
 - `@Delegatable` 애트리뷰트 하나로 체이닝 가능한 빌더 메서드 자동 생성
-- `@Controllable` 애트리뷰트를 void 메서드에 붙여 체이닝 가능한 `Self` 반환 메서드 생성
+- `@Callable` 애트리뷰트를 void 메서드에 붙여 체이닝 가능한 `Self` 반환 메서드 생성
 - `async`, `throws`, 다중 파라미터, `@Sendable` 등 클로저 특성 그대로 유지
 - 시스템 기본 언어에 맞춰 한국어/영어 진단 메시지 자동 출력
 
@@ -28,7 +28,7 @@ let package = Package(
     name: "YourApp",
     platforms: [.iOS(.v14), .macOS(.v11), .tvOS(.v14), .watchOS(.v7), .macCatalyst(.v13)],
     dependencies: [
-        .package(url: "https://github.com/ShapeKim98/Delegation.git", from: "0.2.0")
+        .package(url: "https://github.com/ShapeKim98/Delegation.git", from: "0.3.0")
     ],
     targets: [
         .target(
@@ -41,8 +41,8 @@ let package = Package(
 )
 ```
 
-> 현재 최신 태그는 `0.2.0`이며 릴리스에 맞춰 갱신해 주세요.
-> The current release tag is `0.2.0`; bump it as you publish newer versions.
+> 현재 최신 태그는 `0.3.0`이며 릴리스에 맞춰 갱신해 주세요.
+> The current release tag is `0.3.0`; bump it as you publish newer versions.
 
 ## 사용 방법 (Usage)
 
@@ -74,14 +74,14 @@ ContentView()
     }
 ```
 
-### @Controllable
+### @Callable
 
 ```swift
 struct NumberController {
     private var number = 0
     var currentNumber: Int { number }
 
-    @Controllable
+    @Callable
     private mutating func changeNumber(_ value: Int) {
         number = value
     }
@@ -93,8 +93,8 @@ let controller = NumberController()
 print(controller.currentNumber) // 10
 ```
 
-- 반환 타입이 없는 메서드에 `@Controllable`을 붙이면 본문을 복사한 뒤 `Self`를 반환하는 빌더 메서드가 추가됩니다. 값 타입은 복사본을, 참조 타입은 원본 인스턴스를 그대로 반환합니다.
-  Annotate void functions with `@Controllable` to synthesise a builder method that mirrors the body and returns `Self`; value types return a copy while reference types return the original instance.
+- 반환 타입이 없는 메서드에 `@Callable`을 붙이면 본문을 복사한 뒤 `Self`를 반환하는 빌더 메서드가 추가됩니다. 값 타입은 복사본을, 참조 타입은 원본 인스턴스를 그대로 반환합니다.
+  Annotate void functions with `@Callable` to synthesise a builder method that mirrors the body and returns `Self`; value types return a copy while reference types return the original instance.
 - `mutating`, `async`, `throws` 등 기존 선언의 효과는 새 메서드에도 유지됩니다.
   Existing modifiers such as `mutating`, `async`, and `throws` propagate to the generated method.
 - SwiftUI `View`처럼 `@State`를 사용하는 값 타입 샘플은 `Sources/DelegationClient/main.swift`에서 확인할 수 있습니다.
@@ -133,7 +133,7 @@ struct ContentView: View {
     @Delegatable private var buttonClicked: (() -> Void)?
     @State private var title = "Hello, world!"
 
-    @Controllable
+    @Callable
     private func changeTitle(_ text: String) {
         title = text
     }
@@ -175,8 +175,8 @@ ContentView()
     .changeTitle("Delegation")
 ```
 
-- `@Controllable`이 생성한 빌더를 통해 SwiftUI 상태(`@State`)를 체이닝으로 갱신할 수 있습니다.
-  Use the builder produced by `@Controllable` to update SwiftUI `@State` via chaining.
+- `@Callable`이 생성한 빌더를 통해 SwiftUI 상태(`@State`)를 체이닝으로 갱신할 수 있습니다.
+  Use the builder produced by `@Callable` to update SwiftUI `@State` via chaining.
 - 패키지는 별도 실행 타깃을 포함하지 않으며, 위 코드는 문서용 예시입니다.
   The package ships without an executable sample target; the snippet above is for documentation only.
 
@@ -194,7 +194,7 @@ final class ListViewController: UIViewController {
     @Delegatable private var presentSettings: (() -> Void)?
     private var titleText = "목록"
 
-    @Controllable
+    @Callable
     private func updateTitle(_ text: String) {
         titleText = text
         title = text
@@ -233,8 +233,8 @@ let controller = ListViewController()
     .updateTitle("목록 화면")
 ```
 
-- 클래스에서도 `@Controllable`이 생성한 체이닝 메서드로 내부 상태를 직접 갱신할 수 있습니다.
-  The `@Controllable` builder lets reference types update their internal state while participating in the chain.
+- 클래스에서도 `@Callable`이 생성한 체이닝 메서드로 내부 상태를 직접 갱신할 수 있습니다.
+  The `@Callable` builder lets reference types update their internal state while participating in the chain.
 - 샘플 코드는 문서용 예시이며, 실제 앱 구조에 맞춰 델리게이트 채택과 레이아웃을 조정하세요.
   The snippet is documentation-only; adapt delegate conformance and layout to your project needs.
 

Sources/Delegation/Delegation.swift

@@ -30,10 +30,10 @@
 @attached(peer, names: arbitrary)
 public macro Delegatable() = #externalMacro(module: "DelegationMacros", type: "DelegatableMacro")
 
-/// `@Controllable`를 void 메서드에 붙이면 동일한 시그니처로 `Self`를 반환하는 메서드를 생성합니다.
+/// `@Callable`을 void 메서드에 붙이면 동일한 시그니처로 `Self`를 반환하는 메서드를 생성합니다.
 ///
 /// ```swift
-/// @Controllable
+/// @Callable
 /// private func changeNumber(_ number: Int) {
 ///     self.number = number
 /// }
@@ -49,4 +49,4 @@ public macro Delegatable() = #externalMacro(module: "DelegationMacros", type: "D
 /// }
 /// ```
 @attached(peer, names: arbitrary)
-public macro Controllable() = #externalMacro(module: "DelegationMacros", type: "ControllableMacro")
+public macro Callable() = #externalMacro(module: "DelegationMacros", type: "CallableMacro")

Sources/DelegationClient/main.swift

@@ -35,7 +35,7 @@ struct ContentView: View {
 
     var currentNumber: Int { _number.wrappedValue }
 
-    @Controllable
+    @Callable
     private mutating func changeNumber(_ number: Int) {
         _number = State(initialValue: number)
     }
@@ -67,7 +67,7 @@ print("SwiftUI 뷰 상태 숫자: \(contentView.currentNumber)")
 final class NumberController {
     var number = 0
 
-    @Controllable
+    @Callable
     private func changeNumber(_ number: Int) {
         self.number = number
     }

…DelegationMacros/ControllableMacro.swift …ces/DelegationMacros/CallableMacro.swiftSources/DelegationMacros/ControllableMacro.swift renamed to Sources/DelegationMacros/CallableMacro.swift Sources/DelegationMacros/ControllableMacro.swift renamed to Sources/DelegationMacros/CallableMacro.swift

@@ -3,7 +3,7 @@ import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
 
-enum ControllableMacroSupport {
+enum CallableMacroSupport {
     static func attributeBaseName(from attribute: AttributeSyntax) -> String {
         let description = attribute.attributeName.trimmedDescription
         if let lastComponent = description.split(separator: ".").last {
@@ -68,7 +68,7 @@ enum ControllableMacroSupport {
     }
 }
 
-public struct ControllableMacro: PeerMacro {
+public struct CallableMacro: PeerMacro {
     public static func expansion(
         of attribute: AttributeSyntax,
         providingPeersOf declaration: some DeclSyntaxProtocol,
@@ -77,17 +77,17 @@ public struct ControllableMacro: PeerMacro {
         guard let functionDecl = declaration.as(FunctionDeclSyntax.self) else {
             throw DelegationMacroError.message(
                 MacroSupport.localizedMessage(
-                    korean: "@Controllable는 함수 선언에만 사용할 수 있습니다.",
-                    english: "Apply @Controllable to functions only."
+                    korean: "@Callable는 함수 선언에만 사용할 수 있습니다.",
+                    english: "Apply @Callable to functions only."
                 )
             )
         }
 
         guard functionDecl.body != nil else {
             throw DelegationMacroError.message(
                 MacroSupport.localizedMessage(
-                    korean: "@Controllable 메서드는 본문을 포함해야 합니다.",
-                    english: "@Controllable functions must provide a body."
+                    korean: "@Callable 메서드는 본문을 포함해야 합니다.",
+                    english: "@Callable functions must provide a body."
                 )
             )
         }
@@ -97,8 +97,8 @@ public struct ControllableMacro: PeerMacro {
             if returnType != "Void" && returnType != "()" {
                 throw DelegationMacroError.message(
                     MacroSupport.localizedMessage(
-                        korean: "@Controllable는 반환 타입이 없는 함수에서만 사용할 수 있습니다.",
-                        english: "Use @Controllable only on functions without a return type."
+                        korean: "@Callable는 반환 타입이 없는 함수에서만 사용할 수 있습니다.",
+                        english: "Use @Callable only on functions without a return type."
                     )
                 )
             }
@@ -117,8 +117,8 @@ public struct ControllableMacro: PeerMacro {
                 continue
             }
 
-            let name = ControllableMacroSupport.attributeBaseName(from: attribute)
-            if name.caseInsensitiveCompare("Controllable") == .orderedSame {
+            let name = CallableMacroSupport.attributeBaseName(from: attribute)
+            if name.caseInsensitiveCompare("Callable") == .orderedSame {
                 continue
             }
 
@@ -146,7 +146,7 @@ public struct ControllableMacro: PeerMacro {
 
         let modifiers = functionDecl.modifiers
         for modifier in modifiers where MacroSupport.shouldCopyToBuilder(modifier) {
-            let text = ControllableMacroSupport.modifierDescription(modifier)
+            let text = CallableMacroSupport.modifierDescription(modifier)
             if !text.isEmpty {
                 modifierComponents.append(text)
             }
@@ -173,21 +173,21 @@ public struct ControllableMacro: PeerMacro {
             }
         }
 
-        let callPrefix = ControllableMacroSupport.callPrefix(for: functionDecl.signature)
-        let arguments = ControllableMacroSupport.argumentList(from: functionDecl.signature.parameterClause)
+        let callPrefix = CallableMacroSupport.callPrefix(for: functionDecl.signature)
+        let arguments = CallableMacroSupport.argumentList(from: functionDecl.signature.parameterClause)
         let isReferenceType = MacroSupport.isReferenceTypeContext(for: functionDecl)
-        let requiresCopy = ControllableMacroSupport.requiresMutableCopy(functionDecl.modifiers) && !isReferenceType
+        let requiresCopy = CallableMacroSupport.requiresMutableCopy(functionDecl.modifiers) && !isReferenceType
 
-        let invocationTarget = requiresCopy ? "controllable" : "self"
+        let invocationTarget = requiresCopy ? "callable" : "self"
         let invocation = arguments.isEmpty
             ? "\(invocationTarget).\(identifier)()"
             : "\(invocationTarget).\(identifier)(\(arguments))"
 
         var bodyLines: [String] = []
         if requiresCopy {
-            bodyLines.append("    var controllable = self")
+            bodyLines.append("    var callable = self")
             bodyLines.append("    let _: Void = \(callPrefix)\(invocation)")
-            bodyLines.append("    return controllable")
+            bodyLines.append("    return callable")
         } else {
             bodyLines.append("    let _: Void = \(callPrefix)\(invocation)")
             bodyLines.append("    return self")

Sources/DelegationMacros/DelegatableMacro.swift

@@ -113,6 +113,6 @@ public struct DelegatableMacro: PeerMacro {
 struct DelegationPlugin: CompilerPlugin {
     let providingMacros: [Macro.Type] = [
         DelegatableMacro.self,
-        ControllableMacro.self,
+        CallableMacro.self,
     ]
 }