Merge branch 'develop'

Author: bolismauro

Demo/IOS/UI/CounterScreen.swift

@@ -50,10 +50,10 @@ struct CounterScreen: ConnectedNodeDescription, PlasticNodeDescription, PlasticR
         $0.setKey(Keys.decrementButton)
         $0.titles[.normal] = "Decrement"
         $0.backgroundColor = .dogwoodRose
-        $0.titleColors = [.highlighted : .jet]
+        $0.titleColors = [.highlighted: .jet]
 
         $0.touchHandlers = [
-          .touchUpInside : {
+          .touchUpInside: {
             dispatch(DecrementCounter())
           }
         ]
@@ -62,10 +62,10 @@ struct CounterScreen: ConnectedNodeDescription, PlasticNodeDescription, PlasticR
         $0.setKey(Keys.incrementButton)
         $0.titles[.normal] = "Increment"
         $0.backgroundColor = .japaneseIndigo
-        $0.titleColors = [.highlighted : .jet]
+        $0.titleColors = [.highlighted: .jet]
 
         $0.touchHandlers = [
-          .touchUpInside : {
+          .touchUpInside: {
             dispatch(IncrementCounter())
           }
         ]

Examples/CodingLove/CodingLove/Actions/FetchMorePosts.swift

@@ -10,7 +10,6 @@ import Foundation
 import Katana
 
 struct FetchMorePosts: AsyncAction, ActionWithSideEffect {
-    
     public struct CompletedActionPayload {
         var posts: [Post]
         var allFetched: Bool = false
@@ -56,26 +55,26 @@ struct FetchMorePosts: AsyncAction, ActionWithSideEffect {
     }
 
     public func sideEffect(
-        state: State,
-        dispatch: @escaping StoreDispatch,
-        dependencies: SideEffectDependencyContainer
-    ) {
-        
-        let castedState = state as! CodingLoveState
-        let page: Int = castedState.page
-        
-        let postsProvider = dependencies as! PostsProvider
-        
-        postsProvider.fetchPosts(for: page) { (result, errorMessage) in
-            if let data = result {
-                let (posts, allFetched) = data
-                dispatch(self.completedAction {
-                  $0.completedPayload = CompletedActionPayload(posts: posts, allFetched: allFetched)
-                })
-            
-            } else {
-                dispatch(self.failedAction { $0.failedPayload = errorMessage! })
-            }
+      currentState: State,
+      previousState: State,
+      dispatch: @escaping StoreDispatch,
+      dependencies: SideEffectDependencyContainer) {
+    
+      let castedState = currentState as! CodingLoveState
+      let page: Int = castedState.page
+      
+      let postsProvider = dependencies as! PostsProvider
+      
+      postsProvider.fetchPosts(for: page) { (result, errorMessage) in
+        if let data = result {
+          let (posts, allFetched) = data
+          dispatch(self.completedAction {
+            $0.completedPayload = CompletedActionPayload(posts: posts, allFetched: allFetched)
+          })
+          
+        } else {
+          dispatch(self.failedAction { $0.failedPayload = errorMessage! })
         }
+      }
     }
 }

Examples/CodingLove/CodingLove/Providers/PostsProvider.swift

@@ -11,12 +11,8 @@ import Katana
 
 let postsPerPage = 3
 
-struct PostsProvider: SideEffectDependencyContainer {
-    var posts: [Post]
-    
-    public init(state: State, dispatch: @escaping StoreDispatch) {
-        self.posts = [Post]()
-    }
+class PostsProvider: SideEffectDependencyContainer {
+    public required init(dispatch: @escaping StoreDispatch) {}
 
     public func fetchPosts(for page: Int, completion: @escaping (([Post], Bool)?, String?) -> ()) {
         DispatchQueue.global().async {

Katana/Core/Animations/AnimationUtils.swift

@@ -11,16 +11,16 @@ import Foundation
 /// Namespace for some animation utilities methods
 struct AnimationUtils {
   private init () {}
-
+  
   /// The intermediate steps of the 4 step animation
   enum AnimationStep {
     /// The first intermediate step
     case firstIntermediate
-
+    
     /// The second intermediate step
     case secondIntermediate
   }
-
+  
   /**
    Merges `descriptions` with `other` using a strategy that depends on the step.
 
@@ -42,72 +42,21 @@ struct AnimationUtils {
    - parameter step:         the step of the process
    - returns: an array of descriptions with elements merged following the algorithm described above
 
-  */
+   */
   static func mergedDescriptions(
     _ descriptions: [AnyNodeDescription],
     _ other: [AnyNodeDescription],
     step: AnimationStep) -> [AnyNodeDescription] {
-
-    let firstArray: [AnyNodeDescription]
-    let secondArray: [AnyNodeDescription]
-
+    
     switch step {
     case .firstIntermediate:
-      firstArray = descriptions
-      secondArray = other
-
+      return self.mergedDescriptions(descriptions, with: other)
+      
     case .secondIntermediate:
-      firstArray = other
-      secondArray = descriptions
-    }
-
-    // lookup for first array
-    var firstArrayLookup = [Int: Int]()
-    for (index, item) in firstArray.enumerated() {
-      firstArrayLookup[item.replaceKey] = index
-    }
-
-    // lookup for second array
-    var secondArrayLookup = [Int: Int]()
-    for (index, item) in secondArray.enumerated() {
-      secondArrayLookup[item.replaceKey] = index
-    }
-
-    var result = firstArray
-    var added = 0
-    var firstArrayMaxPosition = -1
-
-    for item in secondArray {
-      let position = firstArrayLookup[item.replaceKey]
-
-      if let position = position {
-        // we already have the item
-        firstArrayMaxPosition = max(firstArrayMaxPosition, position)
-        continue
-      }
-
-      result.insert(item, at: added + firstArrayMaxPosition + 1)
-      added = added + 1
+      return self.mergedDescriptions(other, with: descriptions)
     }
-
-    // merge also children, if needed
-    result = result.map { description in
-      guard var propsWithChildren = description.anyProps as? Childrenable else {
-        return description
-      }
-
-      let secondItemChildren = secondArrayLookup[description.replaceKey]
-        .flatMap({ secondArray[$0] })
-        .flatMap({ $0 as? AnyNodeDescriptionWithChildren })
-        .flatMap({ $0.children })
-
-      propsWithChildren.children = mergedDescriptions(propsWithChildren.children, secondItemChildren ?? [], step: step)
-      return type(of: description).init(anyProps: propsWithChildren as! AnyNodeDescriptionProps)
-    }
-
-    return result
   }
-
+  
   /**
    Updates the descriptions using an instance of `ChildrenAnimations`.
 
@@ -124,63 +73,124 @@ struct AnimationUtils {
    - parameter targetChildren:      the target children used to define when apply a transformation
    - parameter step:         the step of the process
    - returns: an array of updated descriptions
-  */
+   */
   static func updatedDescriptions(
     for descriptions: [AnyNodeDescription],
     using childrenAnimation: AnyChildrenAnimations,
     targetChildren: [AnyNodeDescription],
     step: AnimationStep) -> [AnyNodeDescription] {
-
+    
     return descriptions.map { (item: AnyNodeDescription) -> AnyNodeDescription in
       let itemReplaceKey = item.replaceKey
       let index = targetChildren.index { $0.replaceKey == itemReplaceKey }
       var item = item
-
+      
       if index == nil {
         // the item is missing in the comparison, update it
         item = self.updatedDescription(for: item, using: childrenAnimation, step: step)
       }
-
+      
       if var propsWithChildren = item.anyProps as? Childrenable {
         // the item has children, let's manage also the children
         let children = propsWithChildren.children
         let target = (item as? AnyNodeDescriptionWithChildren).flatMap({ $0.children })
-
+        
         propsWithChildren.children = updatedDescriptions(
           for: children,
           using: childrenAnimation,
           targetChildren: target ?? [],
           step: step
         )
-
+        
         return type(of: item).init(anyProps: propsWithChildren as! AnyNodeDescriptionProps)
       }
-
+      
       // nothing to do
       return item
     }
   }
-
+  
   /**
    Updates the description using an instance of `ChildrenAnimations`.
 
    - parameter description:         the original description
    - parameter childrenAnimation:   the animations to use
    - parameter step:         the step of the process
    - returns: the updated description
-  */
+   */
   private static func updatedDescription(
     for description: AnyNodeDescription,
     using childrenAnimation: AnyChildrenAnimations,
     step: AnimationStep) -> AnyNodeDescription {
-
+    
     let animation = childrenAnimation[description]
     let transformers = step == .firstIntermediate ? animation.entryTransformers : animation.leaveTransformers
-
+    
     let newProps = transformers.reduce(description.anyProps, { (props, transformer) -> AnyNodeDescriptionProps in
       return transformer(props)
     })
-
+    
     return type(of: description).init(anyProps: newProps)
   }
+  
+  /**
+   Merge two `AnyNodeDescription` arrays. The first array has the priority
+   if two elements are the same. The method will propagate the merge to also
+   the children of the node descriptions, if the element implements
+   the `Childrenable` protocol
+   
+   - parameter firstArray: the first array
+   - parameter secondArray: the second array
+   - returns: the merged array
+   */
+  private static func mergedDescriptions(
+    _ firstArray: [AnyNodeDescription],
+    with secondArray: [AnyNodeDescription]) -> [AnyNodeDescription] {
+    
+    // lookup for first array
+    var firstArrayLookup = [Int: Int]()
+    for (index, item) in firstArray.enumerated() {
+      firstArrayLookup[item.replaceKey] = index
+    }
+    
+    // lookup for second array
+    var secondArrayLookup = [Int: Int]()
+    for (index, item) in secondArray.enumerated() {
+      secondArrayLookup[item.replaceKey] = index
+    }
+    
+    var result = firstArray
+    var added = 0
+    var firstArrayMaxPosition = -1
+    
+    for item in secondArray {
+      let position = firstArrayLookup[item.replaceKey]
+      
+      if let position = position {
+        // we already have the item
+        firstArrayMaxPosition = max(firstArrayMaxPosition, position)
+        continue
+      }
+      
+      result.insert(item, at: added + firstArrayMaxPosition + 1)
+      added = added + 1
+    }
+    
+    // merge also children, if needed
+    result = result.map { description in
+      guard var propsWithChildren = description.anyProps as? Childrenable else {
+        return description
+      }
+      
+      let secondItemChildren = secondArrayLookup[description.replaceKey]
+        .flatMap({ secondArray[$0] })
+        .flatMap({ $0 as? AnyNodeDescriptionWithChildren })
+        .flatMap({ $0.children })
+      
+      propsWithChildren.children = self.mergedDescriptions(propsWithChildren.children, with: secondItemChildren ?? [])
+      return type(of: description).init(anyProps: propsWithChildren as! AnyNodeDescriptionProps)
+    }
+    
+    return result
+  }
 }

Katana/Store/ActionWithSideEffect.swift

@@ -14,35 +14,34 @@ import Foundation
 
  A side effect is nothing more than a piece of code that can interact with external
  services or APIs (e.g., make a network request, get information from the disk and so on).
- Side effects are needed because the `updateState(currentState:)` function (which is the only other operation
+ Side effects are needed because the `updatedState(currentState:)` function (which is the only other operation
  that is performed when an action is dispatched) must be pure and therefore it cannot
  interact with disk, network and so on.
 
  ### Dependencies
- You can see from the `sideEffect(state:dispatch:dependencies:)` signature that
+ You can see from the `sideEffect(currentState:previousState:dispatch:dependencies:)` signature that
  a side effect takes as input some dependencies. This is a form of dependency injection
  for the side effects. By using only methods coming from the dependencies (instead of relying on
  global imports), testing is much more easier since you can inject a mocked version
  of the things you need in the side effect. For example, in a test, you may want to
  inject a mocked version of the class that manages the API requests, in order to control
  the result of the network call.
- 
- Every time a side effect is triggered, the dependencies (or better, the `SideEffectDependencyContainer`)
- is instantiated from scratch. We do this to avoid that pieces of state are saved in the managers or
- in the classes that there are in the dependencies, since we want to store all the relevant
- information in the `Store`
 */
 public protocol ActionWithSideEffect: Action {
   /**
    Performs the side effect. This method is invoked when the action is dispatched,
-   before it goes in the `updateState(currentState:action:)` function.
+   after the `updateState(currentState:action:)` function.
 
-   - parameter state:         the current state
-   - parameter dispatch:      a closure that can be used to dispatch new actions
-   - parameter dependencies:  the dependencies of the side effect
+   - parameter currentState:    the current state. The one returned by the
+                                `updateState(currentState:action:)` method
+   - parameter previousState:   the state of the store before the `updateState(currentState:action:)`
+                                invokation
+   - parameter dispatch:        a closure that can be used to dispatch new actions
+   - parameter dependencies:    the dependencies of the side effect
   */
   func sideEffect(
-    state: State,
+    currentState: State,
+    previousState: State,
     dispatch: @escaping StoreDispatch,
     dependencies: SideEffectDependencyContainer
   )