Generating forms from models (a la django ModelForms) in Objective-C

Question

I'm taking the plunge into iPhone development after about two years working with django. As I've done tutorials and read documentation, one of the things that strikes me as inconvenient about the various libraries used in iPhone development is the amount of repetition required when creating user input forms for data models.

I know of two conventional approaches to user input form creation:

1. Create a group of UITextFields in Interface Builder that correspond with the properties on the model class and link them up to corresponding IBOutlets on a custom form controller.

2. Create a form view programatically with UITextFields in tables with a custom form view controller class. The class keeps a list of names that correspond to the properties of a model in an array, and then iterate over the array to create UITextFields for each table cell. Use special casing to determine which model attribute is being iterated over, and use that information to create table cells with corresponding UILabels and UITextFields.*

Of the two, only the first seems practical for iterative development, the second is painfully verbose and extremely difficult (for me) to read. With the introspective capabilities of Objective-C it seems like it would be possible to write code that accepted a model class as an argument and generate a form controller (and perhaps even a form view) from that information at runtime.

So I have three questions:

1. Are there conventional alternate approaches to creating form views and controllers for models other than the two I've listed above? I'm not loving either approach I've listed there.

2. Is automatic generation of form controllers / views at runtime feasible in Objective-C, or am I just barking up the wrong tree?

3. Has such automatic generation been attempted or accomplished already? (a little googling turned up nothing)

*My main reference for this comes from Example #6 in Chapter 9: Navigation Controllers and Table Views of Apress' "Beginning iPhone 3 Development"

Answer 1

It seems like your trying to write an iPhone app like you would a Django website, but the two are completely different.

Here is a quick rundown of MVC in cocoa:

1. Write your model classes independent of any controller or view
2. Write a controller that stores the model class as a key (e.g. -[MyController model] and -[MyController setModel:])
3. Open interface builder and design your view. Use bindings or code in the controller to make the view interact with the model

Answer 2

Keep in mind that systems like Django are based on completely scripted environments. The language constructs can be dynamically created, interpreted, and re-interpreted many times during the execution process.

Concepts like business rules and forms logic can literally be written as pages are being sent to the client/browser.

For compiled languages, all of these moving parts must be pre-created and fully resolved (for the most part). Most of the classic UML based source generation or template based systems were complex behemoths that generated very difficult to use code.

The MVC model and libraries like Cocoa and Carbon, though possibly not as "elegant" as the techniques possible in Django, did evolve around the need to tackle some of the same challenges.

Although other alternatives exist, such as marrying Objective-C to an interpreted language like LUA or Python is feasible. And there are several open source projects focused at building completely dynamic "over the air" user interface clients that sit on top of server based systems which broadcast details of how the interface looks and behaves. (I can't find the project but will edit when I do)

I'm not aware of any major work in this area and suspect that most normal iPhone applications simply haven't been complex enough either in scope or degree of variability to warrant the effort to create these automated systems.

Rarely is the user interface the complex part of an iPhone application, perhaps with the exception of a few unique games out there.

Barney

Answer 3

I'm working on the same problem now, in my case I have a complex set of models that are coming from WSDL, and there's a LOT of form elements that can change from time to time. I definitely do not want to be doing the forms by hand in code or in IB.

Objective-C is a fully dynamic language and you can definitely do what you want to do in a fully dynamic fashion. Assuming that your models are Core Data models, you can find all of the properties using something like [[myCoreDataObject entity] propertiesByName]. You can then iterate through these properties automatically creating the appropriate form fields depending on their types.

You would then create a subclass of for example UITableViewController which you pass an NSManagedObject to, and it will automatically create a form which matches the model object.

Answer 4

Those are two approaches to solve the same problem, really, and neither is more correct than the other. You can certainly do the first one quite easily -- ObjC is a fully dynamic language.

However, I would personally recommend not "fighting the framework." Just as how it's totally possible to take route #2 in Django, the framework isn't built around that approach and you'll end up writing a lot of code that you wouldn't have to write otherwise.

Cocoa's approach -- route #1 -- certainly has its merits. I would highly recommend giving it a chance.