README.md

@@ -133,6 +133,8 @@ ensure that the class is in the required state before and after properties are s
 
 * Flexibility. Supports different approaches of dependency injection for different scenarios - native block-style, auto-wiring macros or Spring-style XML.
 
+* Excellent support for circular dependencies. 
+
 * Lean. It has a very low footprint, so is appropriate for CPU and memory constrained devices. 
 
 

Source/Component/Initializer/Collection/TyphoonParameterInjectedAsCollection.m

@@ -1,10 +1,13 @@
+////////////////////////////////////////////////////////////////////////////////
 //
-//  TyphoonParameterInjectedAsCollection.m
-//  Static Library
+//  TYPHOON FRAMEWORK
+//  Copyright 2013, Jasper Blues & Contributors
+//  All Rights Reserved.
 //
-//  Created by Erik Sundin on 8/31/13.
-//  Copyright (c) 2013 Jasper Blues. All rights reserved.
+//  NOTICE: The authors permit you to use, modify, and distribute this file
+//  in accordance with the terms of the license agreement accompanying it.
 //
+////////////////////////////////////////////////////////////////////////////////
 
 #import "TyphoonParameterInjectedAsCollection.h"
 

Source/Component/TyphoonDefinition+Infrastructure.h

@@ -0,0 +1,29 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  TYPHOON FRAMEWORK
+//  Copyright 2013, Jasper Blues & Contributors
+//  All Rights Reserved.
+//
+//  NOTICE: The authors permit you to use, modify, and distribute this file
+//  in accordance with the terms of the license agreement accompanying it.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#import "TyphoonDefinition.h"
+
+@class TyphoonPropertyPlaceholderConfigurer;
+@protocol TyphoonResource;
+
+/**
+ Declares short-hand definition factory methods for infrastructure components.
+ */
+@interface TyphoonDefinition (Infrastructure)
+
+/**
+ Factory method for a TyphoonPropertyPlaceholderConfigurer.
+ @param resource The resource to load.
+ @return a definition.
+ */
++ (TyphoonDefinition*)propertyPlaceholderWithResource:(id<TyphoonResource>)resource;
+
+@end

Source/Component/TyphoonDefinition+Infrastructure.m

@@ -0,0 +1,32 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  TYPHOON FRAMEWORK
+//  Copyright 2013, Jasper Blues & Contributors
+//  All Rights Reserved.
+//
+//  NOTICE: The authors permit you to use, modify, and distribute this file
+//  in accordance with the terms of the license agreement accompanying it.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+
+#import "TyphoonDefinition+Infrastructure.h"
+#import "TyphoonPropertyPlaceholderConfigurer.h"
+#import "TyphoonResource.h"
+#import "TyphoonInitializer.h"
+
+@implementation TyphoonDefinition (Infrastructure)
+
++ (TyphoonDefinition *)propertyPlaceholderWithResource:(id<TyphoonResource>)resource {
+
+    TyphoonDefinition *definition = [self withClass:[TyphoonPropertyPlaceholderConfigurer class] initialization:^(TyphoonInitializer *initializer) {
+
+        initializer.selector = @selector(configurerWithResource:);
+        [initializer injectWithObject:resource];
+
+    }];
+    definition.key = [NSString stringWithFormat:@"%@-%@", NSStringFromClass(definition.class), [resource description]];
+    return definition;
+}
+
+@end

Source/Factory/Block/TyphoonAssembly.m

@@ -20,8 +20,8 @@
 #import "TyphoonAssemblySelectorAdviser.h"
 #import "OCLogTemplate.h"
 
-static NSMutableDictionary *resolveStackForKey;
-static NSMutableArray *reservedSelectorsAsStrings;
+static NSMutableDictionary* resolveStackForSelector;
+static NSMutableArray* reservedSelectorsAsStrings;
 
 @implementation TyphoonAssembly
 
@@ -42,38 +42,38 @@ + (TyphoonAssembly*)defaultAssembly
 + (void)load
 {
     [super load];
-    resolveStackForKey = [[NSMutableDictionary alloc] init];
     [self reserveSelectors];
 }
 
 + (void)reserveSelectors;
 {
-  reservedSelectorsAsStrings = [[NSMutableArray alloc] init];
-  
-  [self markSelectorReserved:@selector(init)];
-  [self markSelectorReserved:@selector(cachedDefinitionsForMethodName)];
-  [self markSelectorReservedFromString:@".cxx_destruct"];
-  [self markSelectorReserved:@selector(defaultAssembly)];
+    reservedSelectorsAsStrings = [[NSMutableArray alloc] init];
+
+    [self markSelectorReserved:@selector(init)];
+    [self markSelectorReserved:@selector(cachedDefinitionsForMethodName)];
+    [self markSelectorReservedFromString:@".cxx_destruct"];
+    [self markSelectorReserved:@selector(defaultAssembly)];
 }
 
 + (void)markSelectorReserved:(SEL)selector
 {
-  [self markSelectorReservedFromString:NSStringFromSelector(selector)];
+    [self markSelectorReservedFromString:NSStringFromSelector(selector)];
 }
 
-+ (void)markSelectorReservedFromString:(NSString *)stringFromSelector
++ (void)markSelectorReservedFromString:(NSString*)stringFromSelector
 {
-  [reservedSelectorsAsStrings addObject:stringFromSelector];
+    [reservedSelectorsAsStrings addObject:stringFromSelector];
 }
 
 #pragma mark - Instance Method Resolution
 + (BOOL)resolveInstanceMethod:(SEL)sel
 {
-    if ([self shouldProvideDynamicImplementationFor:sel]) {
+    if ([self shouldProvideDynamicImplementationFor:sel])
+    {
         [self provideDynamicImplementationToConstructDefinitionForSEL:sel];
         return YES;
     }
-    
+
     return [super resolveInstanceMethod:sel];
 }
 
@@ -84,7 +84,7 @@ + (BOOL)shouldProvideDynamicImplementationFor:(SEL)sel;
 
 + (BOOL)selectorReserved:(SEL)selector
 {
-  return [reservedSelectorsAsStrings containsObject:NSStringFromSelector(selector)];
+    return [reservedSelectorsAsStrings containsObject:NSStringFromSelector(selector)];
 }
 
 + (void)provideDynamicImplementationToConstructDefinitionForSEL:(SEL)sel;
@@ -95,51 +95,52 @@ + (void)provideDynamicImplementationToConstructDefinitionForSEL:(SEL)sel;
 
 + (IMP)implementationToConstructDefinitionForSEL:(SEL)selWithAdvicePrefix
 {
-    return imp_implementationWithBlock((__bridge id) objc_unretainedPointer((TyphoonDefinition *)^(id me)
-       {
-           NSString *key = [TyphoonAssemblySelectorAdviser keyForAdvisedSEL:selWithAdvicePrefix];
-           return [self definitionForKey:key me:me];
-       }));
+    return imp_implementationWithBlock((__bridge id) objc_unretainedPointer((TyphoonDefinition*) ^(id me)
+    {
+        NSString* key = [TyphoonAssemblySelectorAdviser keyForAdvisedSEL:selWithAdvicePrefix];
+        return [self definitionForKey:key me:me];
+    }));
 }
 
-+ (TyphoonDefinition *)definitionForKey:(NSString *)key me:(id)me
++ (TyphoonDefinition*)definitionForKey:(NSString*)key me:(id)me
 {
     LogTrace(@"Resolving request for definition for key: %@", key);
 
-    TyphoonDefinition *cached = [self cachedDefinitionForKey:key me:me];
+    TyphoonDefinition* cached = [self cachedDefinitionForKey:key me:me];
     if (!cached)
     {
         LogTrace(@"Definition for key: '%@' is not cached, building...", key);
         return [self buildDefinitionForKey:key me:me];
     }
-        
+
     LogTrace(@"Using cached definition for key '%@.'", key);
     return cached;
 }
 
-+ (TyphoonDefinition *)cachedDefinitionForKey:(NSString *)key me:(id)me
++ (TyphoonDefinition*)cachedDefinitionForKey:(NSString*)key me:(id)me
 {
     return [[me cachedDefinitionsForMethodName] objectForKey:key];
 }
 
-+ (TyphoonDefinition *)buildDefinitionForKey:(NSString *)key me:(TyphoonAssembly *)me;
++ (TyphoonDefinition*)buildDefinitionForKey:(NSString*)key me:(TyphoonAssembly*)me;
 {
-    NSMutableArray *resolveStack = [self resolveStackForKey:key];
+    NSMutableArray* resolveStack = [self resolveStackForKey:key];
     [self markCurrentlyResolvingKey:key resolveStack:resolveStack];
-
-    if ([self dependencyForKey:key involvedInCircularDependencyInResolveStack:resolveStack]) {
+
+    if ([self dependencyForKey:key involvedInCircularDependencyInResolveStack:resolveStack])
+    {
         return [self definitionToTerminateCircularDependencyForKey:key];
     }
-    
+
     id cached = [self populateCacheWithDefinitionForKey:key me:me];
     [self markKeyResolved:key resolveStack:resolveStack];
-    
+
     LogTrace(@"Did finish building definition for key: '%@'", key);
-    
+
     return cached;
 }
 
-+ (BOOL)dependencyForKey:(NSString *)key involvedInCircularDependencyInResolveStack:(NSArray *)resolveStack;
++ (BOOL)dependencyForKey:(NSString*)key involvedInCircularDependencyInResolveStack:(NSArray*)resolveStack;
 {
     if ([resolveStack count] >= 2)
     {
@@ -151,67 +152,74 @@ + (BOOL)dependencyForKey:(NSString *)key involvedInCircularDependencyInResolveSt
             return YES;
         }
     }
-    
+
     return NO;
 }
 
-+ (TyphoonDefinition *)definitionToTerminateCircularDependencyForKey:(NSString *)key
++ (TyphoonDefinition*)definitionToTerminateCircularDependencyForKey:(NSString*)key
 {
     // we return a 'dummy' definition just to terminate the cycle. This dummy definition will be overwritten by the real one, which will be set further up the stack and will overwrite this one in 'cachedDefinitionsForMethodName'.
     return [[TyphoonDefinition alloc] initWithClass:[NSString class] key:key];
 }
 
-+ (NSMutableArray *)resolveStackForKey:(NSString *)key
++ (NSMutableArray*)resolveStackForKey:(NSString*)key
 {
-    NSMutableArray *resolveStack = [resolveStackForKey objectForKey:key];
-    if (!resolveStack) {
+    NSMutableArray* resolveStack = [resolveStackForSelector objectForKey:key];
+    if (!resolveStack)
+    {
+        if (!resolveStackForSelector)
+        {
+            resolveStackForSelector = [[NSMutableDictionary alloc] init];
+        }
         resolveStack = [[NSMutableArray alloc] init];
-        [resolveStackForKey setObject:resolveStack forKey:key];
+        [resolveStackForSelector setObject:resolveStack forKey:key];
     }
     return resolveStack;
 }
 
-+ (void)markCurrentlyResolvingKey:(NSString *)key resolveStack:(NSMutableArray *)resolveStack
++ (void)markCurrentlyResolvingKey:(NSString*)key resolveStack:(NSMutableArray*)resolveStack
 {
     [resolveStack addObject:key];
 }
 
-+ (TyphoonDefinition *)populateCacheWithDefinitionForKey:(NSString *)key me:(TyphoonAssembly *)me;
++ (TyphoonDefinition*)populateCacheWithDefinitionForKey:(NSString*)key me:(TyphoonAssembly*)me;
 {
     id d = [self definitionByCallingAssemblyMethodForKey:key me:me];
     [self populateCacheWithDefinition:d forKey:key me:me];
     return d;
 }
 
-+ (id)definitionByCallingAssemblyMethodForKey:(NSString *)key me:(TyphoonAssembly *)me
++ (id)definitionByCallingAssemblyMethodForKey:(NSString*)key me:(TyphoonAssembly*)me
 {
     SEL sel = [TyphoonAssemblySelectorAdviser advisedSELForKey:key];
-    id cached = objc_msgSend(me, sel); // the advisedSEL will call through to the original, unwrapped implementation because of the active swizzling.
+    id cached = objc_msgSend(me,
+        sel); // the advisedSEL will call through to the original, unwrapped implementation because of the active swizzling.
     return cached;
 }
 
-+ (void)populateCacheWithDefinition:(TyphoonDefinition *)cached forKey:(NSString *)key me:(id)me
++ (void)populateCacheWithDefinition:(TyphoonDefinition*)cached forKey:(NSString*)key me:(id)me
 {
     if (cached && [cached isKindOfClass:[TyphoonDefinition class]])
     {
         TyphoonDefinition* definition = (TyphoonDefinition*) cached;
         [self setKey:key onDefinitionIfExistingKeyEmpty:definition];
-        
+
         [[me cachedDefinitionsForMethodName] setObject:definition forKey:key];
     }
 }
 
-+ (void)setKey:(NSString *)key onDefinitionIfExistingKeyEmpty:(TyphoonDefinition *)definition
++ (void)setKey:(NSString*)key onDefinitionIfExistingKeyEmpty:(TyphoonDefinition*)definition
 {
     if ([definition.key length] == 0)
     {
         definition.key = key;
     }
 }
 
-+ (void)markKeyResolved:(NSString *)key resolveStack:(NSMutableArray *)resolveStack
++ (void)markKeyResolved:(NSString*)key resolveStack:(NSMutableArray*)resolveStack
 {
-    if (resolveStack.count) {
+    if (resolveStack.count)
+    {
         [resolveStack removeAllObjects];
     }
 }

Source/Factory/Mutator/Patcher/TyphoonPatcher.h → Source/Factory/Config/Patcher/TyphoonPatcher.h

@@ -11,7 +11,7 @@
 
 
 #import <Foundation/Foundation.h>
-#import "TyphoonComponentFactoryMutator.h"
+#import "TyphoonComponentFactoryPostProcessor.h"
 
 typedef id (^ObjectCreationBlock)();
 
@@ -23,7 +23,7 @@ typedef id (^ObjectCreationBlock)();
 *
 *
 */
-@interface TyphoonPatcher : NSObject <TyphoonComponentFactoryMutator>
+@interface TyphoonPatcher : NSObject <TyphoonComponentFactoryPostProcessor>
 {
     NSMutableDictionary* _patches;
 }

Source/Factory/Mutator/Patcher/TyphoonPatcher.m → Source/Factory/Config/Patcher/TyphoonPatcher.m

@@ -15,7 +15,7 @@
 #import "TyphoonInitializer.h"
 #import "OCLogTemplate.h"
 #import "TyphoonDefinition+InstanceBuilder.h"
-
+#import "TyphoonComponentFactory.h"
 
 @implementation TyphoonPatcher
 
@@ -49,7 +49,20 @@ - (void)patchDefinition:(TyphoonDefinition*)definition withObject:(ObjectCreatio
 /* ====================================================================================================================================== */
 #pragma mark - Protocol Methods
 
-- (NSArray*)newDefinitionsToRegister
+- (void)postProcessComponentFactory:(TyphoonComponentFactory *)factory
+{
+    for (TyphoonDefinition *newDefinition in [self newDefinitionsToRegister])
+    {
+        [factory register:newDefinition];
+    }
+
+    for (TyphoonDefinition* definition in [factory registry])
+    {
+        [self patchDefinitionIfNeeded:definition];
+    }
+}
+
+- (NSArray *)newDefinitionsToRegister
 {
     NSMutableArray* newDefinitions = [[NSMutableArray alloc] init];
     for (NSString* key in [_patches allKeys])
@@ -64,18 +77,15 @@ - (NSArray*)newDefinitionsToRegister
     return [newDefinitions copy];
 }
 
-- (void)mutateComponentDefinitionsIfRequired:(NSArray*)componentDefinitions
+- (void)patchDefinitionIfNeeded:(TyphoonDefinition*)definition
 {
-    for (TyphoonDefinition* definition in componentDefinitions)
+    id patchObject = [_patches objectForKey:definition.key];
+    if (patchObject)
     {
-        id patchObject = [_patches objectForKey:definition.key];
-        if (patchObject)
-        {
-            LogDebug(@"Patching component with key %@ with object %@", definition.key, patchObject);
-            [definition setFactoryReference:[self patchFactoryNameForKey:definition.key]];
-            [definition setInitializer:[[TyphoonInitializer alloc] initWithSelector:@selector(object)]];
-            [definition setInjectedProperties:nil];
-        }
+        LogDebug(@"Patching component with key %@ with object %@", definition.key, patchObject);
+        [definition setFactoryReference:[self patchFactoryNameForKey:definition.key]];
+        [definition setInitializer:[[TyphoonInitializer alloc] initWithSelector:@selector(object)]];
+        [definition setInjectedProperties:nil];
     }
 }