Why was this change made (Body)

Add a CI tool for automated testing and building to protect against breaking changes.

Bitrise

Bitrise is an automation tool that can will build, test, distribute etc., It's also free.

Why is this a WIP/Draft?

Trying a few CI tools out.

Testing BitRise PR comments. This may not work because I could only point it to my fork of the repo.

Footer

• [x] There are no breaking changes

From Issue 21

Implements #8

This PR add functionality to resolve dependencies by name or in this case tag. In order to do so, I changed the following:

A component no longer has a tag: String but an let identifier: AnyHashable. This identifier is used to reference the Component as well as the instance in the Container (ComponentStack and InstanceStack). I also added a ComponentIdentifier struct that uses the Type of the factory as well as an optional tag to calculate the hashValue. So instead of a String of the Type, we now use the hashValue of the type to identify a Component or an instance in our Container.

Next I added an optional tag: AnyHashable parameter to all functions that are used to register or resolve dependencies.

I didn't write any documentation in the README yet since I first wanted to get some feedback about this first. I am looking forward to hear ideas on how this could be improved.

I stumbled upon the Scope enum and found the prototype case a bit misleading:

/// Defines the `Component` scope.
public enum Scope {
    /// The same instance of the class is returned each time it is injected.
    case singleton

    /// A new instance of the class is created each time it is injected.
    case prototype // Consider renaming this to `clone` or `instance`?
}

// I'd consider prototype as a term for some form of an abstract class
// the attached documentation above even describes the behavior as creating an instance
container.register(as: .prototype) { ComponentX() }

// I'd found one of these more meaningful
container.register(as: .clone) { ComponentX() }
container.register(as: .instance) { ComponentX() }

When playing around with the example application I kind of stumbled upon a potential issue with the implementation itself:

Having a DependencyContainer register a service:

public extension DependencyContainer {
    static var app: DependencyContainer {
        return DependencyContainer { container in
            container.register(as: .prototype) { 
                 // This will register LocalStorage explicitly with it's protocol
                 LocalStorage() as LocalStorageProtocol
            }
        }
    }
}

The type of the registered service/component kind of gets lost when using the inject() method: As a developer I may not know what type of services are registered :thinking:

class ModalViewController: UIViewController {
    let storage: LocalStorageProtocol = inject() // This will compile and will run
    let storage: LocalStorage = inject() // This will compile but won't run

    @IBAction func close(_ sender: Any) {
        dismiss(animated: true)
    }
}

I'm not sure if that's possible from my current understanding of the DIKit code but having something like inject(ofType: LocalStorage) could help? Maybe the resolve() function could be improved to use stacks of components/instances that are better typed that using a String representation? 🤔

Currently, a propertyWrapper can neither be used on local variables nor on a constructor / functions. There is already a possibility to use constructor dependency injection like:

let backend: BackendProtocol
init(backend: BackendProtocol = resolve()) {
   self.backend = backend
}

Why was this change made (Body)

In response to issue #25.

Footer

• [x] There are no breaking changes
  • If not why and what: breaks the API.

From Issue 25

Why was this change made (Body)

During my first PR against master I was made aware that there was a format I didn't adhere to that was called out in the Contrubuting Documentation. To help other's not make the same mistake this adds a PR template that will automatically add this markdown format to each PR opened. There are comments in the markdown that link to the contributing documentation for ease of access.

Footer

• [x] There are no breaking changes If not why and what:

Hi I'm trying to use this library with the new SwiftUI lifecycle that doesn't have an AppDelegate, it seemed ok to initialize it in the "App" class (the one with @main annotation) but when i do, it throws an error "Fatal error: root DependencyContainer is not yet set."

@main
class ChopsticksApp: App {
    @Inject var viewModel: StartupViewModel
    
    required init() {
        FirebaseApp.configure()
        DependencyContainer.defined(by: modules { .main; .restaurant; .common; .restaurantList })
    }
    
    var body: some Scene {
        WindowGroup {
            
        }
    }
}

Also this method of initialization is giving another error

The modules are defined like this

public extension DependencyContainer {
    static var main = module {
        single { FirebaseApp.app() as FirebaseApp? }
    }
}

This is the documentation for ticket #8 and PR #39.

I also added a super simple example to the example project. Nothing complex but should show one possible way to use it.

Currently lazy injection works through a different computed propery behaviour. Due to using an enum for @Inject it is mutating. Hence it is not really useful in a struct, as we are not allowed to alter a variable within a struct Cannot use mutating getter on immutable value: function call returns immutable value. And as 'mutating' may only be used on 'func' declarations we need a different approach.

As we are not allowed to invoke UIApplication.shared.delegate on anything but the main thread, we need some workaround, especially for the other derivatives, like macOS, tvOS, etc.!

Thus, we use some kind of dirty static variable to get along with those issues.

Besides these changes, I also include lazy injection and bit of syntactic sugar for that.

This PR is a draft to have a discussion if this is a thing we want to add at all and how.

This PR adds support for dependencies with arguments. I am looking forward for any feedback and thoughts about this.

Usage

// Defining a resolvable
factory { LocalStorage(name: "default") as LocalStorageProtocol }
factory { name in LocalStorage(name: name) as LocalStorageProtocol }
factory { (args: (name: String, other: Int)) in LocalStorage(name: args.name) as LocalStorageProtocol }

// Resolving a depdendency
@Inject var defaultLocalStorage: LocalStorageProtocol
@Inject("With just one parameter") var localStorageWithJustOneParameter: LocalStorageProtocol
@Inject((name: "Local Storage with multiple parameters", other: 1)) var localStorageWithMultipleParameters: LocalStorageProtocol

let localStorage: LocalStorageProtocol = resolve("The name of the storage")

func doSomething(_ storage: LocalStorageProtocol = resolve("storage name")) { }

Implementation details

• Only factories can have an argument
• One cannot define a resolvable with a tag and arguments
• It is possible to define multiple resolvables of the same type with different arguments
• resolvables can only have a single argument. Multiple arguments can be resolved using tuples
• The type of the resolvable at definition time must match exactly the one at resolution time. E.g. String != String?or (String, Int) != (name: String, age: Int).

Todos

• [ ] Add documentation in code
• [ ] Add documentation in the Readme

Hello, i have a bug when trying to resolve a dependency that i have in multiple targets

My componentStack is this:

(lldb) po self.componentStack
▿ 8 elements
  ▿ 0 : 2 elements
    ▿ key : AnyHashable(DIKit.ComponentIdentifier(tag: nil, type: Restaurants.RestaurantsLocalDataSource))
      ▿ value : ComponentIdentifier
        - tag : nil
        - type : Restaurants.RestaurantsLocalDataSource
    ▿ value : <Component<RestaurantsLocalDataSource>: 0x600000b0c060>
  ▿ 1 : 2 elements
    ▿ key : AnyHashable(DIKit.ComponentIdentifier(tag: nil, type: Restaurants.RestaurantsRemoteDataSource))
      ▿ value : ComponentIdentifier
        - tag : nil
        - type : Restaurants.RestaurantsRemoteDataSource
    ▿ value : <Component<RestaurantsRemoteDataSource>: 0x600000b0c120>
  ▿ 2 : 2 elements
    ▿ key : AnyHashable(DIKit.ComponentIdentifier(tag: nil, type: RestaurantList.RestaurantListViewModel))
      ▿ value : ComponentIdentifier
        - tag : nil
        - type : RestaurantList.RestaurantListViewModel
    ▿ value : <Component<RestaurantListViewModel>: 0x600000b14360>
  ▿ 3 : 2 elements
    ▿ key : AnyHashable(DIKit.ComponentIdentifier(tag: nil, type: Chopsticks.StartupViewModel))
      ▿ value : ComponentIdentifier
        - tag : nil
        - type : Chopsticks.StartupViewModel
    ▿ value : <Component<StartupViewModel>: 0x600000b043c0>
  ▿ 4 : 2 elements
    ▿ key : AnyHashable(DIKit.ComponentIdentifier(tag: nil, type: Swift.Optional<__C.FIRApp>))
      ▿ value : ComponentIdentifier
        - tag : nil
        - type : Swift.Optional<__C.FIRApp>
    ▿ value : <Component<Optional<FIRApp>>: 0x600000b04360>
  ▿ 5 : 2 elements
    ▿ key : AnyHashable(DIKit.ComponentIdentifier(tag: nil, type: RealmSwift.Realm))
      ▿ value : ComponentIdentifier
        - tag : nil
        - type : RealmSwift.Realm
    ▿ value : <Component<Realm>: 0x600000b14240>
  ▿ 6 : 2 elements
    ▿ key : AnyHashable(DIKit.ComponentIdentifier(tag: nil, type: Restaurants.RestaurantRepository))
      ▿ value : ComponentIdentifier
        - tag : nil
        - type : Restaurants.RestaurantRepository
    ▿ value : <Component<RestaurantRepository>: 0x600000b0c000>
  ▿ 7 : 2 elements
    ▿ key : AnyHashable(DIKit.ComponentIdentifier(tag: nil, type: FIRFirestore))
      ▿ value : ComponentIdentifier
        - tag : nil
        - type : FIRFirestore
    ▿ value : <Component<FIRFirestore>: 0x600000b14300>

The identifier is this:

(lldb) po identifier
▿ ComponentIdentifier
  - tag : nil
  - type : FIRFirestore

But this still finds no matching component in the stack. I have a module providing the dependency in one target (dynamic framework) of my app, and the dependency itself is requested in another target

I'm trying to cover a use case when the root module needs to be rebuilt due to an API environment change. Once the network client changes, the affected modules should be redefined.

In Koin there's a loadKoinModules that lets the developer replace affected modules after startKoin is called (reset cached data when the user logs out).

Let me know if you had something similar in mind and I'm happy to contribute.

This would also fix #42

The @OptionalInject wrapper only works if one provides a non-optional component. If the component is optional, the @OptionalInject wrapped instance always ends up nil.

This appears to be because the component is registered using its optional type (e.g. Optional<ComponentF>) but then the resolve fails as it is looking for non-optional type (e.g. ComponentF).

This can be demonstrated in DIKitTests testOptionalInjection by making ComponentF's init optional.

Doing this causes the test to fail.