Fix couple of typos

Author: michalsrutek

SampleApp/DipSampleApp/Providers/SWAPIPersonProvider.swift

@@ -8,7 +8,7 @@
 
 import Foundation
 
-///Provides Person entitis fetching them with web service
+///Provides Person entities fetching them with web service
 struct SWAPIPersonProvider : PersonProviderAPI {
     let ws: NetworkLayer
 

Sources/AutoInjection.swift

@@ -237,7 +237,7 @@ public extension Injected {
          For that reason if you resolve instance that has a _weak_ auto-injected property this property
          will be released when `resolve` will complete.
 
- Use `InjectedWeak<T>` to define one of two circular dependecies if another dependency is defined as `Injected<U>`.
+ Use `InjectedWeak<T>` to define one of two circular dependencies if another dependency is defined as `Injected<U>`.
  This will prevent a retain cycle between resolved instances.
 
  - warning: Do not define this property as optional or container will not be able to inject it.
@@ -299,7 +299,7 @@ public struct InjectedWeak<T>: _InjectedPropertyBox, AutoInjectedPropertyBox {
  For that reason if you resolve instance that has a _weak_ auto-injected property this property
  will be released when `resolve` will complete.
 
- Use `InjectedWeak<T>` to define one of two circular dependecies if another dependency is defined as `Injected<U>`.
+ Use `InjectedWeak<T>` to define one of two circular dependencies if another dependency is defined as `Injected<U>`.
  This will prevent a retain cycle between resolved instances.
 
  - warning: Do not define this property as optional or container will not be able to inject it.

Sources/Definition.swift

@@ -206,7 +206,7 @@ public final class Definition<T, U>: DefinitionType {
 
         //definitions for types that can be resolved by `forwardsTo` definition
         //can also be used to resolve self type and it's implementing types
-        //this way container properly reuses previosly resolved instances
+        //this way container properly reuses previously resolved instances
         //when there are several forwarded definitions
         //see testThatItReusesInstanceResolvedByTypeForwarding)
         for definition in forwardsTo.forwardsFrom {
@@ -292,17 +292,17 @@ class DefinitionBuilder<T, U> {
 
 typealias KeyDefinitionPair = (key: DefinitionKey, definition: _Definition)
 
-/// Definitions are matched if they are registered for the same tag and thier factories accept the same number of runtime arguments.
+/// Definitions are matched if they are registered for the same tag and their factories accept the same number of runtime arguments.
 private func ~=(lhs: KeyDefinitionPair, rhs: KeyDefinitionPair) -> Bool {
   guard lhs.key.type == rhs.key.type else { return false }
   guard lhs.key.tag == rhs.key.tag else { return false }
   guard lhs.definition.numberOfArguments == rhs.definition.numberOfArguments else { return false }
   return true
 }
 
-/// Returns key-defintion pairs with definitions able to resolve that type (directly or via type forwarding)
+/// Returns key-definition pairs with definitions able to resolve that type (directly or via type forwarding)
 /// and which tag matches provided key's tag or is nil if strictByTag is false.
-/// In the end filters defintions by type of runtime arguments.
+/// In the end filters definitions by type of runtime arguments.
 func filter(definitions _definitions: [KeyDefinitionPair], byKey key: DefinitionKey, strictByTag: Bool = false, byTypeOfArguments: Bool = false) -> [KeyDefinitionPair] {
   let definitions = _definitions
     .filter({ $0.key.type == key.type || $0.definition.doesImplements(type: key.type) })

Sources/Dip.swift

@@ -94,7 +94,7 @@ public final class DependencyContainer {
    Call this method to complete container setup. After container is bootstrapped
    you can not add or remove definitions. Trying to do so will cause runtime exception.
    You can completely reset container, after reset you can bootstrap it again. 
-   During bootsrap container will instantiate components registered with `EagerSingleton` scope.
+   During bootstrap container will instantiate components registered with `EagerSingleton` scope.
 
    - throws: `DipError` if failed to instantiate any component
   */
@@ -298,7 +298,7 @@ extension DependencyContainer {
     for collaborator in _collaborators {
       //if container is already in a context resolving this type
       //it means that it has been already called to resolve this type,
-      //so there is probably a cercular reference between containers.
+      //so there is probably a circular reference between containers.
       //To break it skip this container
       if let context = collaborator.context, context.resolvingType == key.type && context.tag == key.tag { continue }
 
@@ -453,7 +453,7 @@ extension DependencyContainer: CustomStringConvertible {
 //MARK: - DependencyTagConvertible
 
 /// Implement this protocol on your type if you want to use its instances as `DependencyContainer`'s tags.
-/// `DependencyContainer.Tag`, `String`, `Int` and any `RawRepresentable` with `RawType` of `String` or `Int` by default confrom to this protocol.
+/// `DependencyContainer.Tag`, `String`, `Int` and any `RawRepresentable` with `RawType` of `String` or `Int` by default conform to this protocol.
 public protocol DependencyTagConvertible {
   var dependencyTag: DependencyContainer.Tag { get }
 }

Sources/DipError.swift

@@ -66,7 +66,7 @@ public enum DipError: Error, CustomStringConvertible {
   case ambiguousDefinitions(type: Any.Type, definitions: [DefinitionType])
 
   /**
-   Thrown by `resolve(tag:)` if resolved instance does not implemenet resolved type (i.e. when type-forwarding).
+   Thrown by `resolve(tag:)` if resolved instance does not implement resolved type (i.e. when type-forwarding).
 
    - parameters:
       - resolved: Resolved instance

Sources/Resolve.swift

@@ -81,7 +81,7 @@ extension DependencyContainer {
 
    - parameters:
       - tag: The arbitrary tag to use to lookup definition.
-      - builder: Generic closure that accepts generic factory and returns inctance created by that factory.
+      - builder: Generic closure that accepts generic factory and returns instance created by that factory.
 
    - throws: `DipError.DefinitionNotFound`, `DipError.AutoInjectionFailed`, `DipError.AmbiguousDefinitions`, `DipError.InvalidType`
 

Sources/RuntimeArguments.swift

@@ -98,7 +98,7 @@ extension DependencyContainer {
    }
    ```
 
-   Though before you do so you should probably review your design and try to reduce number of depnedencies.
+   Though before you do so you should probably review your design and try to reduce number of dependencies.
    */
   public func register<T, U>(scope: ComponentScope, type: T.Type, tag: DependencyTagConvertible?, factory: @escaping (U) throws -> T, numberOfArguments: Int, autoWiringFactory: @escaping (DependencyContainer, Tag?) throws -> T) -> Definition<T, U> {
     let definition = DefinitionBuilder<T, U> {
@@ -141,7 +141,7 @@ extension DependencyContainer {
            which factories accept any number of runtime arguments and are tagged with the same tag,
            passed to `resolve` method, or with no tag. Container will try to use these definitions
            to resolve a component one by one until one of them succeeds, starting with tagged definitions
-           in order of decreasing their's factories number of arguments. If none of them succeds it will
+           in order of decreasing their's factories number of arguments. If none of them succeeds it will
            throw an error. If it finds two definitions with the same number of arguments - it will throw
            an error.
 

Tests/DipTests/AutoInjectionTests.swift

@@ -488,7 +488,7 @@ class AutoInjectionTests: XCTestCase {
     XCTAssertNil(server)
   }
 
-  func testThatItAutoInjectsWhenOverridenInDefinition() {
+  func testThatItAutoInjectsWhenOverriddenInDefinition() {
     let container = DependencyContainer(autoInjectProperties: false)
     container.register { ServerImp() as Server }
     container.register { ClientImp() as Client }

Tests/DipTests/ComponentScopeTests.swift

@@ -316,7 +316,7 @@ class ComponentScopeTests: XCTestCase {
     container.register(service, type: Service.self)
 
     //when
-    //resolve and realease reight away
+    //resolve and release right away
     _ = try? container.resolve() as ServiceImp1
 
     //then

Tests/DipTests/DefinitionTests.swift

@@ -100,7 +100,7 @@ class DefinitionTests: XCTestCase {
     XCTAssertFalse(blockCalled)
   }
 
-  func testThatItRegisteresOptionalTypesAsForwardedTypes() {
+  func testThatItRegistersOptionalTypesAsForwardedTypes() {
     let def = Definition<Service, ()>(scope: .unique) { ServiceImp() as Service }
 
     XCTAssertTrue(def.implementingTypes.contains(where: { $0 == Service?.self }))