iby

This experiment was born out of ReactiveCocoa#3690 – a homeopathy to fix swizzling with more swizzling.

Ideally, there would be a way to simply intercept the call with a custom handler to add some logic. However, that's far from simple:

• Need to handle existing class methods (add vs. replace).
• Need to call original implementation and pass it parameters – no way of doing it in Swift in some cases (via message forwarding), no way of doing it reliably in Objective-C in others (via va_list)…

In theory, where my research stops, it's possible to achieve this via scenario:

1. Add a block implementation under a random non-clashing selector.

iby

import Foundation

fileprivate enum StdStream {
    case out
    case err

    fileprivate var fileDescriptor: FileDescriptor {
        switch self {
            case .out: return FileDescriptor(STDOUT_FILENO, "stdout")
            case .err: return FileDescriptor(STDERR_FILENO, "stderr")

iby

// This is a hideous hack for 10.11 where constraints are applied for detached view and the entire
// toolset panel looks like a huge cock…

if #available(macOS 10.13, *) {
} else if self.instructionView.isHidden && self.instructionView.superview != nil {
  self.stackView.removeView(self.instructionView)
} else if !self.instructionView.isHidden && self.instructionView.superview == nil {
  self.stackView.insertView(self.instructionView, at: 0, in: .center)
}

iby

private func exclude(paths: [String], at basePath: String) -> [String] {
    let slash = CharacterSet(charactersIn: "/")
    let baseURL = URL(fileURLWithPath: basePath, isDirectory: true)
    var exclusions = try! FileManager.default.contentsOfDirectory(atPath: basePath).sorted()
    var inclusions = paths

    // Cleanup paths removing and expanding `/.`, `/..`, etc.
    inclusions = inclusions.reduce(into: [], { inclusions, inclusion in
        let path = URL(fileURLWithPath: inclusion, relativeTo: baseURL).standardized.relativePath.trimmingCharacters(in: slash)
        if !path.isEmpty { inclusions.append(path) }

iby

import Slang

let source: String = "import Foundation; class Foo { let bar = 1 }"
let file: File = File(source)
let disassembly: Disassembly = try! Disassembly(file)
var edits: [Edit] = []

// Change "Foundation" identifier to "AppKit".
edits.append(Edit(disassembly.query.syntax.first(of: .identifier).select(where: { $0.contents == "Foundation" }).one!, "AppKit"))
// Change "class" keyword to "struct".

iby

import AppKit
import Metal
import QuartzCore

let view = NSView(frame: CGRect(x: 0, y: 0, width: 600, height: 400))
let circle = NSView(frame: CGRect(x: 0, y: 0, width: 50, height: 50))

circle.wantsLayer = true
circle.layer?.backgroundColor = NSColor.red.cgColor
circle.layer?.cornerRadius = 25

iby

let fooOne: Foo = Foo()
let fooTwo: Foo = Foo()

fooOne.reactive.signal.bar.observeValues({ Swift.print($0) })
fooOne.reactive.bind.bar <~ fooTwo.reactive.signal.bar

fooOne.bar = "Such b-a-r!"
fooTwo.bar = "Very BAR!"

iby

class Foo: ReactiveExtensionsProvider {
    let pipe = Signal<String, NoError>.pipe()
    var bar: String = "Such bar!" {
        didSet { self.pipe.input.send(value: self.bar) }
    }
}

extension Reactive.Binds where Base: Foo {
    var bar: BindingTarget<String> {
        return self.reactive.makeBindingTarget({ $0.bar = $1 })

iby

extension Reactive {

    /// A proxy which holds reactive binding target extensions of `Base`.
    struct Binds<Base> {
        fileprivate init(_ base: Base) { self.base = base }
        let base: Base
    }

    var bind: Binds<Base> { return Binds(self.base) }

iby

#import <AVFoundation/AVFoundation.h>

@interface MLWAsyncAVPlayer : AVPlayer

@end