README: Added basic examples

Author: lukaskubanek

README-legacy.md

@@ -1,34 +1,5 @@
 ## Usage
 
-Let's say you want to amend `sayHi` from `TestClass`:
-
-```swift
-class TestClass: NSObject {
-    // Functions need to be marked as `@objc dynamic` or written in Objective-C.
-    @objc dynamic func sayHi() -> String {
-        print("Calling sayHi")
-        return "Hi there 👋"
-    }
-}
-
-let interposer = try Interpose(TestClass.self) {
-    try $0.prepareHook(
-        #selector(TestClass.sayHi),
-        methodSignature: (@convention(c) (AnyObject, Selector) -> String).self,
-        hookSignature: (@convention(block) (AnyObject) -> String).self) {
-            store in { `self` in
-                print("Before Interposing \(`self`)")
-                let string = store.original(`self`, store.selector) // free to skip
-                print("After Interposing \(`self`)")
-                return string + "and Interpose"
-            }
-    }
-}
-
-// Don't need the hook anymore? Undo is built-in!
-interposer.revert()
-```
-
 Want to hook just a single instance? No problem!
 
 ```swift
@@ -41,15 +12,6 @@ let hook = try testObj.hook(
 }
 ```
 
-Here's what we get when calling `print(TestClass().sayHi())`
-```
-[Interposer] Swizzled -[TestClass.sayHi] IMP: 0x000000010d9f4430 -> 0x000000010db36020
-Before Interposing <InterposeTests.TestClass: 0x7fa0b160c1e0>
-Calling sayHi
-After Interposing <InterposeTests.TestClass: 0x7fa0b160c1e0>
-Hi there 👋 and Interpose
-``` 
-
 ## Object Hooking
 
 InterposeKit can hook classes and object. Class hooking is similar to swizzling, but object-based hooking offers a variety of new ways to set hooks. This is achieved via creating a dynamic subclass at runtime. 

README.md

@@ -55,16 +55,72 @@ Then add the product to any target that needs it:
 
 ### Class Hook: Instance Method 
 
-…
+```swift
+class MyClass: NSObject {
+    @objc dynamic func getValue() -> Int {
+        return 42
+    }
+}
+
+let object = MyClass()
+print(object.getValue()) // => 42
+
+let hook = try Interpose.applyHook(
+    on: MyClass.self,
+    for: #selector(MyClass.getValue),
+    methodSignature: (@convention(c) (MyClass, Selector) -> Int).self,
+    hookSignature: (@convention(block) (MyClass) -> Int).self
+) { hook in
+    return { `self` in
+        // Retrieve the original result and add 1 to it. This can be skipped.
+        return hook.original(`self`, hook.selector) + 1
+    }
+}
+
+print(object.getValue()) // => 43
+
+try hook.revert()
+print(object.getValue()) // => 42
+```
 
 ### Class Hook: Class Method
 
-…
+```swift
+class MyClass: NSObject {
+    @objc dynamic class func getStaticValue() -> Int {
+        return 42
+    }
+}
+
+print(MyClass.getStaticValue()) // => 42
+
+let hook = try Interpose.applyHook(
+    on: MyClass.self,
+    for: #selector(MyClass.getStaticValue),
+    methodKind: .class,
+    methodSignature: (@convention(c) (MyClass.Type, Selector) -> Int).self,
+    hookSignature: (@convention(block) (MyClass.Type) -> Int).self
+) { hook in
+    return { `class` in
+        // Retrieve the original result and add 1 to it. This can be skipped.
+        return hook.original(`class`, hook.selector) + 1
+    }
+}
+
+print(MyClass.getStaticValue()) // => 43
+
+try hook.revert()
+print(MyClass.getStaticValue()) // => 42
+```
 
 ### Object Hook
 
 …  
 
+### More Examples
+
+You can check out the extensive test suite to see more advanced examples or the example Xcode project to see more real-life examples of tweaking AppKit classes.  
+
 ## What’s Changed
 
 Compared to the [original implementation](https://github.com/steipete/InterposeKit), this fork introduces several API and internal changes. Here is a summary of key differences with migration hints.