Running what's in master against my OS X Storyboard, I get references to UIStoryboard and UIViewController. Changing these to NSStoryboard and NSViewController gives me an error: ambiguous use of identifier (on line 13).

//
// Autogenerated by Natalie - Storyboard Generator Script.
// http://blog.krzyzanowskim.com
//

import Cocoa

//MARK: - Storyboards

extension UIStoryboard {
    func instantiateViewController<T: UIViewController where T: IdentifiableProtocol>(type: T.Type) -> T? {
        let instance = type.init()
        if let identifier = instance.identifier {
            return self.instantiateViewControllerWithIdentifier(identifier) as? T
        }
        return nil
    }
}

protocol Storyboard {
    static var storyboard: NSStoryboard { get }
    static var identifier: String { get }
}

struct Storyboards {

    struct Main: Storyboard {

        static let identifier = "Main"

        static var storyboard: NSStoryboard {
            return NSStoryboard(name: self.identifier, bundle: nil)
        }

        static func instantiateWindowControllerWithIdentifier(identifier: String) -> NSWindowController {
            return self.storyboard.instantiateControllerWithIdentifier(identifier) as! NSWindowController
        }

        static func instantiateViewController<T: UIViewController where T: IdentifiableProtocol>(type: T.Type) -> T? {
            return self.storyboard.instantiateViewController(type)
        }

        static func instantiateViewControllerWithIdentifier(identifier: String) -> NSViewController {
            return self.storyboard.instantiateControllerWithIdentifier(identifier) as! NSViewController
        }

        static func instantiateViewController<T: UIViewController where T: IdentifiableProtocol>(type: T.Type) -> T? {
            return self.storyboard.instantiateViewController(type)
        }

        static func instantiateDocumentWindowController() -> NSWindowController {
            return self.storyboard.instantiateControllerWithIdentifier("Document Window Controller") as! NSWindowController
        }
    }
}

//MARK: - ReusableKind
enum ReusableKind: String, CustomStringConvertible {
    case TableViewCell = "tableViewCell"
    case CollectionViewCell = "collectionViewCell"

    var description: String { return self.rawValue }
}

//MARK: - SegueKind
enum SegueKind: String, CustomStringConvertible {    
    case Relationship = "relationship" 
    case Show = "show"                 
    case Presentation = "presentation" 
    case Embed = "embed"               
    case Unwind = "unwind"             
    case Push = "push"                 
    case Modal = "modal"               
    case Popover = "popover"           
    case Replace = "replace"           
    case Custom = "custom"             

    var description: String { return self.rawValue } 
}

//MARK: - SegueProtocol
public protocol IdentifiableProtocol: Equatable {
    var identifier: String? { get }
}

public protocol SegueProtocol: IdentifiableProtocol {
}

public func ==<T: SegueProtocol, U: SegueProtocol>(lhs: T, rhs: U) -> Bool {
    return lhs.identifier == rhs.identifier
}

public func ~=<T: SegueProtocol, U: SegueProtocol>(lhs: T, rhs: U) -> Bool {
    return lhs.identifier == rhs.identifier
}

public func ==<T: SegueProtocol>(lhs: T, rhs: String) -> Bool {
    return lhs.identifier == rhs
}

public func ~=<T: SegueProtocol>(lhs: T, rhs: String) -> Bool {
    return lhs.identifier == rhs
}

public func ==<T: SegueProtocol>(lhs: String, rhs: T) -> Bool {
    return lhs == rhs.identifier
}

public func ~=<T: SegueProtocol>(lhs: String, rhs: T) -> Bool {
    return lhs == rhs.identifier
}

//MARK: - ReusableViewProtocol
public protocol ReusableViewProtocol: IdentifiableProtocol {
    var viewType: NSView.Type? { get }
}

public func ==<T: ReusableViewProtocol, U: ReusableViewProtocol>(lhs: T, rhs: U) -> Bool {
    return lhs.identifier == rhs.identifier
}

//MARK: - Protocol Implementation
extension NSStoryboardSegue: SegueProtocol {
}

//MARK: - NSViewController extension
extension NSViewController {
    func performSegue<T: SegueProtocol>(segue: T, sender: AnyObject?) {
        if let identifier = segue.identifier {
            performSegueWithIdentifier(identifier, sender: sender)
        }
    }

    func performSegue<T: SegueProtocol>(segue: T) {
        performSegue(segue, sender: nil)
    }
}

//MARK: - NSWindowController extension
extension NSWindowController {
    func performSegue<T: SegueProtocol>(segue: T, sender: AnyObject?) {
        if let identifier = segue.identifier {
            performSegueWithIdentifier(identifier, sender: sender)
        }
    }

    func performSegue<T: SegueProtocol>(segue: T) {
        performSegue(segue, sender: nil)
    }
}


//MARK: - ViewController

Executing natalie, even with no arguments, in commandline throws an error like this: dyld: Symbol not found: __T0s11CommandLineO9argumentsSaySSGvZ.

swift --version outputs the following after switching command-line-tools back to 9.2 (9C40b): Apple Swift version 4.0.3 (swiftlang-900.0.74.1 clang-900.0.39.2) Target: x86_64-apple-macosx10.9

If I build the natalie project in Xcode 9.2 or 9.3 and execute the generated executable it just works fine.

Maybe the natalie executable is not compatible with the updated swift version in the system?

Hi,

I modified quite a few things, the main reason was to be able to use the same ViewController class multiple times in different storyboards each with a different Storyboard ID. This was impossible before because you would end up adding an extension twice to the same class.

Now because the storyboards are structs, it means that I was able to specialise instantiateInitialViewController method so that the return type is the same as the type of the ViewController.

To instantiate a Viewcontroller with id "ListVC" in storyboard Main, you do:

let vc = Storyboards.Main.ListVC()

If you have any questions or remarks, my ears are open.

this https://github.com/krzyzanowskim/Natalie/blame/master/natalie.swift#L681 is not working for OSX. Do not compile. saying that Segue is not convertible to AnyObject.Type cc @phimage

I always get this error whenever I try to checkout other branch in Xcode.

could not remove '/Users/account/Documents/Code/App/Company/project-app/PROJ/Storyboards.swift': Operation not permitted (-1)

Any ideas?

I'm having a new issue after xcode 7 kicked in. I have 2 xcode installations now, one with 6.4 and one with 7. The only thing that doesn't pass during the build phase is Natalie. It throws me "Command /bin/sh failed with exit code 133"

and "Natalie generator dyld: Library not loaded: @rpath/libswiftSecurity.dylib Referenced from: /usr/local/bin/natalie.swift Reason: image not found"

and "/usr/local/bin/natalie.swift "$PROJECT_DIR/$PROJECT_NAME" > "$PROJECT_DIR/$PROJECT_NAME/Layout/Storyboards.swift""

Anyone has the same issue? Did I mess up when doubling the installation?

I've splited Natalie.swift into 2 files:

• code, main code that you can add to target and use Xcode highlight and autosuggestions
• main, a global code for script

Also there are 2 ways to merge them.

• run make
• open NatalieExample and run it. It uses a script to merge source code into Natalie.swift file

Cannot build 0.5.0 on macOS 10.13 with Xcode 9:

$ swift build -c release -Xswiftc -static-stdlib
Compile Swift Module 'natalie' (14 sources)
natalie.XMLIndexer:72:22: error: invalid redeclaration of 'Element'
    public typealias Element = natalie.XMLIndexer
                     ^
/private/tmp/Natalie-0.5.0/Sources/natalie/SWXMLHash/SWXMLHash.swift:359:10: note: 'Element' previously declared here
    case Element(XMLElement)
         ^
error: terminated(1): /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swift-build-tool -f /private/tmp/Natalie-0.5.0/.build/release.yaml main

Im interested to know what is actually broken here, what is it that you are trying to achieve?

Here is a playground I was messing about in, could you please give me one in a broken state?

enum Segue: String {
  case ScreenOneSegue = "abcdef"
}

func prepareForSegue(storyboardSegue: UIStoryboardSegue, sender: AnyObject?) {

//  if storyboardSegue == Segue.ScreenOneSegue {
//    let viewController = storyboardSegue.destinationViewController
//    viewController?.view.backgroundColor = UIColor.yellowColor()
//  }

  guard let identifier = storyboardSegue.identifier, segue = Segue(rawValue: identifier) else {
    return
  }

  switch segue {

  case .ScreenOneSegue:
    print("got here")

  }

  switch storyboardSegue {

  case _ where storyboardSegue == Segue.ScreenOneSegue:
    print("got here")

  default:
    break

  }

}

func ==<T: RawRepresentable where T.RawValue == String>(x: UIStoryboardSegue, y: T) -> Bool {
  return x.identifier == y.rawValue
}

From what I can gather you are trying to remove the need for

guard let identifier = storyboardSegue.identifier, segue = Segue(rawValue: identifier) else {
  return
}

and perform a switch on the UIStoryboardSegue itself

in Xcode Product menu, added a Natalie menu

• Generate to launch code generation
• Enable generate when saving : to save each time a user do File>Save
• the last menu to change natalie.swift path

Feel free to reject the pull request, if you prefer I will make an independent project

If one's .storyboard includes a View Controller subclass defined in a module/framework that must normally be imported the generated file will have to import it as well.

A project I am working on correlates our Storyboard file's names with the UIViewController subclass that is it's initial view controller. The result is a Storyboards.* struct that conflicts in naming with the view controller type itself:

...
    struct ExampleViewController: Storyboard {

        static let identifier = "ExampleViewController"

        static var storyboard: UIStoryboard {
            return UIStoryboard(name: self.identifier, bundle: nil)
        }

        static func instantiateExampleViewController() -> ExampleViewController {
            return self.storyboard.instantiateExampleViewController() as! ExampleViewController
        }

        static func instantiateViewController(withIdentifier identifier: String) -> UIViewController {
            return self.storyboard.instantiateViewController(withIdentifier: identifier)
        }

        static func instantiateViewController<T: UIViewController>(ofType type: T.Type) -> T? where T: IdentifiableProtocol {
            return self.storyboard.instantiateViewController(ofType: type)
        }
    }
...

I appreciate the brevity of the struct's name and appending something like "File" clutters that. On the other hand it is more explicit: these are mappings to files as much as we'd love to abstract them away.

I am getting a build issue in my generated output file. The issue is with this code:

extension IdentifiableProtocol where Self: ExpenseClaimsNavigationController {
    public var storyboardIdentifier: String? { return "ExpenseClaimsNavigationController" }
    static var storyboardIdentifier: String? { return "ExpenseClaimsNavigationController" }
}

Specifically the public var. The exact error is: Cannot declare a public var in an extension with internal requirements

This is the relevant class:

class RotatingNavigationController: UINavigationController {
	override var shouldAutorotate: Bool {
		return true
	}
	
	override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
		return [.portrait, .landscape]
	}
}

class LeaveAttachmentNavigationController: RotatingNavigationController {}
class ExpenseClaimsNavigationController: RotatingNavigationController {}

Strangely I don't have this issue in another project, the public keyword is not present. Am I doing something wrong or is this an issue with Natalie?

This is an issue if the storyboard has the same name as the initial controller e.g.

struct Storyboards {
    struct FooViewController: Storyboard {
        static func instantiateInitialController() -> FooViewController {
            return self.storyboard.instantiateInitialController() as! FooViewController
        }
    }
}

Opps! instantiateInitialController returns a Storyboards.FooViewController, not a Module.FooViewController :-(

The obvious work-around is not to name storyboards using the same name as the initial view controller. However for simple storyboards this can be a convenient and natural naming.

Looks like natalie just needs to parse the "customModule" attribute for "viewControllers" in the storyboard xml.

We have a project that came with Natalie installed and contains a very large storyboard. Our next step is that we want to refactor this main storyboard into a number of smaller storyboards. Do you have any suggestions of how to do this with Natalie installed? At the moment, as I understand it, there are a few issues being caused?

I can't really find any documentation on this and the team members (@gslondon) haven't really used Natalie before? If you could give some suggestions, documentations or blog posts about this that would be really helpful!

Hello,

I have just integrated Natalie with my project using the build script given in the README. When trying to compile the generated Storyboards.swift, I am having the error Ambiguous type name 'Segue'.

The issue is caused on a custom view controller inheriting from another custom view controller, therefore, on the child view controller, the type Segue can refer to neither it's own type or it's parent's type.

The generated code looks like the following:

extension X { 

    enum Segue: String, CustomStringConvertible, SegueProtocol {
        case viewDetail = "viewDetail"

        var kind: SegueKind? {
            switch (self) {
            case .viewDetail:
                return SegueKind(rawValue: "show")
            }
        }

        var destination: UIViewController.Type? {
            switch (self) {
            default:
                assertionFailure("Unknown destination")
                return nil
            }
        }

        var identifier: String? { return self.description } 
        var description: String { return self.rawValue }
    }

}

extension UIStoryboardSegue {
    func selection() -> Y.Segue? {  // <-- Error on this line
        if let identifier = self.identifier {
            return DeliveryOrderHistoryViewController.Segue(rawValue: identifier)
        }
        return nil
    }
}

extension Y { 

    enum Segue: String, CustomStringConvertible, SegueProtocol {
        case viewDetail = "viewDetail"

        var kind: SegueKind? {
            switch (self) {
            case .viewDetail:
                return SegueKind(rawValue: "show")
            }
        }

        var destination: UIViewController.Type? {
            switch (self) {
            default:
                assertionFailure("Unknown destination")
                return nil
            }
        }

        var identifier: String? { return self.description } 
        var description: String { return self.rawValue }
    }

}

On the code above, Y inherits from X, which in turn inherits from UIViewController.

Do you have any recommendations on how to fix the issue?