NSHipster-New-Years-2014.md

Greetings, NSHipsters!

As we prepare to increment our NSDateComponents -year by 1, it's time once again for NSHipster end-of-the-year Reader Submissions! Last year, we got some mind-blowing tips and tricks. With the release of iOS 7 & Mavericks, and a year's worth of new developments in the Objective-C ecosystem, there should be a ton of new stuff to write up for this year.

Submit your favorite piece of Objective-C trivia, framework arcana, hidden Xcode feature, or anything else you think is cool, and you could have it featured in the year-end blowout article. Just comment on this gist below!

Here are a few examples of the kind of things I'd like to see:

• Using NSStringFromSelector(@selector()) as a safer way to do KVC / KVO / NSCoding.
• Panic's rather surprising discovery about the internals of the Lightning Digital AV Adapter
• This brilliant write-up deriving block syntax from C declarators by @nilsou, or @lazerwalker's more to-the-point site, "Fucking Block Syntax"

Can't wait to see what y'all come up with!

I am a big fan of buffering my table views. It's such a big experience improvement and so easy to accomplish too. It's mentioned in this blog post: http://www.nsprogrammer.com/2013/10/easy-uitableview-buffering.html under part two - but ultimately you just make your table view larger and take advantage of contentInset and scrollViewInsets.

There's a demo of the improvement too at http://www.github.com/NSProgrammer/NSProgrammer under
https://github.com/NSProgrammer/NSProgrammer/tree/master/code/Examples/TableViewOptimizations

One trick I like to use for classes that I want to behave as abstract is to use a macro to enforce that particular methods need to be overridden.

/**
    @def NS_UNRECOGNIZED_SELECTOR
    An easy to use macro to replace boylerplate code for implementing a method that wants to be overridden so it throws an \c NSInvalidArgumentException.
    @par Example:
    @code
    - (void) methodToOverride NS_UNRECOGNIZED_SELECTOR; // ';' is optional but can help with auto code alignement
    @endcode
 */

#define NS_UNRECOGNIZED_SELECTOR { ThrowUnrecognizedSelector(self, _cmd); }

NS_INLINE void ThrowUnrecognizedSelector(NSObject* obj, SEL cmd) __attribute__((noreturn));
NS_INLINE void ThrowUnrecognizedSelector(NSObject* obj, SEL cmd)
{
    [obj doesNotRecognizeSelector:cmd];
    abort(); // will never be reached, but prevents compiler warning
}

Simple use:

- (void) methodNeedingSubclassOverride NS_UNRECOGNIZED_SELECTOR;

Part of http://www.github.com/NSProgrammer/NSProgrammer

Not so much an Objective-C trick, I use the following C macros for floating point comparison since comparing floating point values can be very hairy:

/**
    @section Floating Point Comparison Macros
 */
#define FLOAT_EQ(floatA, floatB, epsilon)  (fabsf(floatA - floatB) < epsilon)
#define FLOAT_LT(floatA, floatB, epsilon)  (!FLOAT_EQ(floatA, floatB, epsilon) && floatA < floatB)
#define FLOAT_GT(floatA, floatB, epsilon)  (!FLOAT_EQ(floatA, floatB, epsilon) && floatA > floatB)
#define FLOAT_LTE(floatA, floatB, epsilon) (FLOAT_EQ(floatA, floatB, epsilon) || floatA < floatB)
#define FLOAT_GTE(floatA, floatB, epsilon) (FLOAT_EQ(floatA, floatB, epsilon) || floatA > floatB)

#define DOUBLE_EQ(floatA, floatB, epsilon)  (fabs(floatA - floatB) < epsilon)
#define DOUBLE_LT(floatA, floatB, epsilon)  (!FLOAT_EQ(floatA, floatB, epsilon) && floatA < floatB)
#define DOUBLE_GT(floatA, floatB, epsilon)  (!FLOAT_EQ(floatA, floatB, epsilon) && floatA > floatB)
#define DOUBLE_LTE(floatA, floatB, epsilon) (FLOAT_EQ(floatA, floatB, epsilon) || floatA < floatB)
#define DOUBLE_GTE(floatA, floatB, epsilon) (FLOAT_EQ(floatA, floatB, epsilon) || floatA > floatB)

Used like this:

if (FLOAT_EQ(fDollarValue, 0.0, 0.005)
{
    NSLog(@"The total is $0.00");
}

Part of http://www.github.com/NSProgrammer/NSProgrammer

Detecting the image type of a data blob:

NS_INLINE NSPUIImageType _DetectDataImageType(NSData* imageData)
{
    if (imageData.length > 4)
    {
        const unsigned char* bytes = imageData.bytes;

        if (bytes[0]==0xff && 
            bytes[1]==0xd8 && 
            bytes[2]==0xff /* && bytes[3]==0xe0 -- the last byte of JPEG type can have numerous values, just accept anything for detection.*/)
            return NSPUIImageType_JPEG;

        if (bytes[0]==0x89 &&
            bytes[1]==0x50 &&
            bytes[2]==0x4e &&
            bytes[3]==0x47)
            return NSPUIImageType_PNG;
    }

    return NSPUIImageType_Unknown;
}

Part of http://www.github.com/NSProgrammer/NSProgrammer

Add #define OBJC_OLD_DISPATCH_PROTOTYPES 0 in your .pch file. This will force you to cast objc_msgSend calls.

You can easily hook NSLog with the private function _NSSetLogCStringFunction. But don’t do it of course.

Print which context is passed to observeValueForKeyPath:ofObject:change:context: in lldb.
Say you have declared a context like this:

static const void *MyFooContext = &MyFooContext;

And you want to to know what context it is when you are inside

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context

Just do this:

(lldb) image lookup -a `context`
      Address: MyApp[0x00026258] (MyApp.__DATA.__data + 4)
      Summary: MyFooContext

Import class-dump info into GDB

My best Stack Overflow answer in 2013. Allows you to restore ObjC symbols in order to debug stripped apps easily.

With regards to localising strings I usually have a function like this somewhere in a .h file:

static inline NSString *JSLocalizedString(NSString *key, NSString *defaultValue) {
    return NSLocalizedStringWithDefaultValue(key, nil, [NSBundle mainBundle], defaultValue, nil);
}

static inline NSString *JSLocalizedStringWithComment(NSString *key, NSString *defaultValue, NSString *comment) {
    return NSLocalizedStringWithDefaultValue(key, nil, [NSBundle mainBundle], defaultValue, comment);
}

Used like:

NSString *title = JSLocalizedString(@"JS:Login:Title", "Login");
NSString *loginButtonText = JSLocalizedStringWithComment(@"JS:Login:LoginButton", @"Sign in", @"The login button for when users already have an account");

If you are laying out your views manually, set your view frames in a block. The indentation helps delineate where you are setting frames and the code blocks let you reuse variable names. You can now just name your frames frame instead of closeButtonFrame, nextButtonFrame, loadingLabelFrame, which can get tiresome if you have a lot of views to position.

self.closeButton.frame = ({
    CGRect frame;
    // Calculate the frame here
    frame
});

self.nextButton.frame = ({
    CGRect frame;
    // Calculate the frame here
    frame
});

self.loadingLabel.frame = ({
    CGRect frame;
    // Calculate the frame here
    frame
});

A quick-and-dirty way to debug any instance - at any point during execution, without waiting to hit a breakpoint - is to NSLog the memory address in the object's initializer method:
NSLog(@"<%@>: %p", NSStringFromClass([self class]), self); (example: <XXFooView>: 0xDEADBEEF)

Once that prints, make note of the memory address (in the example above, it's 0xDEADBEEF).

Now, whenever you feel like it, you can hit the Pause execution button and type this in the debugger:
po 0xDEADBEEF
and the description of that object will print in the debugger.

It's a simple one, but an incredibly handy one:

BOOL someBoolean = YES;
NSLog(@"someBoolean: %@", someBoolean ? @"YES" : @"NO");

...output:
someBoolean: YES

Copy and paste this over the closing brace of application:didFinishLaunchingWithOptions: to quickly add a debug button to the top left corner of your app's window, and an easily-triggerable method to put test code into:

UIButton *debugButton = [UIButton buttonWithType:UIButtonTypeRoundedRect];
debugButton.frame = CGRectMake(0.f, 20.f, 44.f, 44.f);
[debugButton addTarget:self action:@selector(didPressDebugButton) forControlEvents:UIControlEventTouchUpInside];
[self.window addSubview:debugButton];

return YES;  
}

- (void)didPressDebugButton
{
  NSLog(@"boink!");
}

Protect your class from default initializers by marking init and new as unavailable. You can also provide a custom string that the compiler will display if somebody tries to use one.

-(instancetype) init attribute((unavailable("Please use initWithString")));
+(instancetype) new attribute((unavailable("Please use initWithString")));

In my attempts to avoid learning how to method-swizzle, I came up with a way of "replacing" classes with subclasses.

@implementation NSLayoutManager (JLLayoutManager)

// [NSLayoutManager alloc] will return an instance of  JLLayoutManager.
+ (id)alloc
{
    if ([self class] == [NSLayoutManager class]) {
        return [JLLayoutManager alloc];
    }
    return [super alloc];
}

@end

I wrote the helper function for creating key path from selectors

inline NSString * PTPKeyPathsForKeys(SEL key, ...) {
  if (!key) {
    return nil;
  }
  NSMutableArray *keys = [[NSMutableArray alloc] init];
  va_list args;
  va_start(args, key);
  SEL arg = key;
  do {
    [keys addObject:NSStringFromSelector(arg)];
  } while ((arg = va_arg(args, SEL)));
  va_end(args);

  return [keys componentsJoinedByString:@"."];
}

Usage

NSString *keyPath = PTPKeyPathsForKeys(@selector(data), @selector(name), NULL); // @"data.name"

you should write a Post about the advantage from xcconfig files

yeah xcconfig files @carlj

Recently I discovered a new Foundation class named NSByteCountFormatter, no more custom file size formatters! Documentation.

My favorite self-written hack this year is SPAwait. It emulates the await keyword from C# 4 (or Futures.wait from node.js) by building coroutines using macros, blocks and non-structured case statements (inspired by an old mikeash post). Unfortunately, it doesn't work great with ARC :( while not usable in real life, such structure allows you to write asynchronous code as if it was synchronous, which is absolutely magical and wonderful. Way better than either callbacks or futures.

https://github.com/nevyn/SPAsync/blob/master/include/SPAsync/SPAwait.h

iOS7 has introduced a lot of changes in the API, both deprecating and introducing new methods, in different frameworks.

One way to deal with this is to temporary disable the deprecated warnings in clang with a pragma (where you handle the API differences).

Another way is to use the excellent Deploymate for managing different iOS versions. It analyzes your code and gives you warnings for deprecated/new methods. Like with clang, you can use a pragma to let Deploymate ignore it.

Here is a gist with a few macros to help with checking the iOS version and ignore both clang and Deploymate's warnings.

To use the macros, simply do:

AVAILABLE_API_IF_GREATER_THAN(@“7.0”)
    do_something_only_in_ios7();
AVAILABLE_API_ELSE
    do_something_for_others();
AVAILABLE_API_END