TODO list

Contents

Introduction

This document contains an (incomplete) list of work items.

Important items

Better documentation

Test suite

XXX: It might be a good idea to move the unittests to a seperate python package (e.g. PyObjCTest) that is not installed. I'd be surprised if anyone ever runs the unittests outside of the build tree.

The test suite needs to be enhanced.

Less important items

Refactor some parts of the bridge

From the top of my head:

Support for GNUstep

The current SVN version contains some support for GNUstep, this needs to be enhanced.

Unless somebody actually starts working on this GNUstep support will slowly fade away.

Complete Cocoa wrapping

We do not yet have a 100% coverage of the Cocoa API's. We also need code in the testsuite that checks if the function wrappers are working as expected.

Not all constants and enums from Cocoa are currently wrapped. The annotations for input/output arguments are not all checked and may not be complete or correct.

We also don't support all "difficult" methods yet, implementing these is not too hard but it is a lot of work.

Note that even though we do not have 100% coverage of Cocoa, the majority of useful functions, constants, and "difficult" methods are wrapped. If you run across a missing or incorrectly wrapped constant, function, or method please report it as a bug and/or post to pyobjc-dev about the issue. This is one area we intend to improve after the release of 1.3 when our new wrapper-generators are in a more complete state.

Pickle support

Objective-C objects don't support pickling.

This is post-1.3 work, in general this is a hard problem because it may involve object cycles that cross the Python-ObjC boundary.

NSCoder support

It might be useful to add default implementations of encodeWithCoder: and initWithCoder: methods to Python subclasses of Objective-C classes that implement these. Note that property list types should already be serializable (int, long, unicode, list, tuple, dict).

See also Pickle support.

Known issues

It is impossible to support methods with a variable number of arguments in the generic code (you have to re-implement almost all of the logic of these methods in order to know how many and which types of arguments are expected). Luckily there are not many varargs methods and most (if no all) of them can be easily avoided.

All existing varargs methods should be located and documented. Where possible we should provide custom wrappers, otherwise we should document alternatives.

Limitations such as the above should be clearly documented elsewhere, these are not necessarily TODO items.

Code cleanup

Cleanup Examples

The CurrencyConverter example should be removed, this should be the same as the final step of the tutorial. It isn't at the moment because additional cruft in the example.

Add examples that demonstrate:

Performance tuning/testing

Design and implement a set of performance tests for the bridge. Use this to investigate and fix any possible performance problems.

Add freelists

PyObjCSelector objects and PyObjCObject objects are created on a regular basis, we should check if using freelists would speed this up. See also Performance tuning/testing.

NOTE: first add performance tests then experiment with freelists.

Links to Apple documentation

Links to Apple documentation are not stable, can we add a layer of indirection here, e.g. link to the PyObjC website that will redirect to the right location?

We should also provide links to locally installed documentation, especially in the documentation that will be installed on the users machine.

Implement more of NSMutableDictionary in OC_PythonDictionary

The implementation of OC_PythonDictionary is very minimal, we should add additional methods in the NSMutableDictionary interface if those can be implemented efficiently. The default implementation will take care of the methods we cannot implement efficiently.

And the same is true of OC_PythonArray

In both cases we shouldn't do this unless we can measure the difference in performance.

Clean up OC_PythonObject

The code is a mess.

Rewrite scripts/find-raw-pointers.py

This is a script for finding 'difficult' methods. The script should be refactored to make it easier to create readable reports.

Finish refactoring of the code-generator scripts

  1. Change code-generator scripts to use loadBundleFunctions, etc.
  2. Move the code-generator scripts to PyObjCTools, to make it easier for others to generate wrappers.
  3. Install pyobjc-api.h.

setup.py cleanup

NSSet vs set

Check if it is possible to wrap NSSet using set (and v.v.).

Only implement this when it is possible to convert without loss of information.

Ronald, 20050130: converting is not an option: PyObjC takes care to preserve the identity of ObjC objects when passed through python. This is necessary for at least some APIs. Furthermore, both NSSet and __builtin__.set are mutable!

Python 2.4

Python 2.4 introduces a decorator syntax. Add convenience functions that make it easier to use decorators with PyObjC.

Also add example programs using decorators. Actually, first add the example(s) and extract useful convenience functions from those.

An example of a convenience function would be:

import objc

def method_signature(signature):
        def make_selector(func):
                return objc.selector(func, signature=signature)
        return make_selector

Which can be used like this:

class FooClass (NSObject):

        @method_signature("v@:i")
        def myIntMethod_(self, value):
                pass

NSLog, stringWithFormat, ...

Functions and methods that use format strings are not properly wrapped. Fix that.