Introduce new middleware API

CHANGELOG.md

@@ -1,7 +1,14 @@
 # Rodux Changelog
 
 ## Current master
-* No changes
+* Added `combineReducers` utility, mirroring Redux's ([#9](https://github.com/Roblox/rodux/pull/9))
+* Added `createReducer` utility, similar to `redux-create-reducer` ([#10](https://github.com/Roblox/rodux/pull/10))
+* `type` is now required as a field on all actions
+* Introduced middleware ([#13](https://github.com/Roblox/rodux/pull/13))
+	* Thunks are no longer enabled by default, use `Rodux.thunkMiddleware` to add them back.
+	* Added `Rodux.loggerMiddleware` as a simple debugger
+	* The middleware API changed in [#29](https://github.com/Roblox/rodux/pull/29) in a backwards-incompatible way!
+* Errors thrown in `changed` event now have correct stack traces ([#27](https://github.com/Roblox/rodux/pull/27))
 
-## 1.0.0 (TODO: Date)
-* Initial release
+## Public Release (December 13, 2017)
+* Initial release!

docs/api-reference.md

@@ -155,22 +155,25 @@ local reducer = createReducer(initialState, {
 ## Middleware
 Rodux provides an API that allows changing the way that actions are dispatched called *middleware*. To attach middlewares to a store, pass a list of middleware as the third argument to `Store.new`.
 
+!!! warn
+	The middleware API changed in [#29](https://github.com/Roblox/rodux/pull/29) -- middleware written against the old API will not work!
+
 A single middleware is just a function with the following signature:
 
 ```
-(next) -> (store, action) -> result
+(nextDispatch, store) -> (action) -> result
 ```
 
 That is, middleware is a function that accepts the next middleware to apply and returns a new function. That function takes the `Store` and the current action and can dispatch more actions, log to output, or do network requests!
 
 A simple version of Rodux's `loggerMiddleware` is as easy as:
 
 ```lua
-local function simpleLogger(next)
-	return function(store, action)
+local function simpleLogger(nextDispatch, store)
+	return function(action)
 		print("Dispatched action of type", action.type)
 
-		return next(store, action)
+		return nextDispatch(action)
 	end
 end
 ```

lib/Store.lua

@@ -48,12 +48,18 @@ function Store.new(reducer, initialState, middlewares)
 	table.insert(self._connections, connection)
 
 	if middlewares then
-		local dispatch = Store.dispatch
+		local unboundDispatch = self.dispatch
+		local dispatch = function(...)
+			return unboundDispatch(self, ...)
+		end
+
 		for _, middleware in ipairs(middlewares) do
-			dispatch = middleware(dispatch)
+			dispatch = middleware(dispatch, self)
 		end
 
-		self.dispatch = dispatch
+		self.dispatch = function(self, ...)
+			return dispatch(...)
+		end
 	end
 
 	return self

lib/Store.spec.lua

@@ -36,26 +36,51 @@ return function()
 		end)
 
 		it("should modify the dispatch method when middlewares are passed", function()
+			local middlewareInstantiateCount = 0
 			local middlewareInvokeCount = 0
+			local passedDispatch
+			local passedStore
+			local passedAction
 
 			local function reducer(state, action)
+				if action.type == "test" then
+					return "test state"
+				end
+
 				return state
 			end
 
-			local function testMiddleware(next)
-				return function(store, action)
+			local function testMiddleware(nextDispatch, store)
+				middlewareInstantiateCount = middlewareInstantiateCount + 1
+				passedDispatch = nextDispatch
+				passedStore = store
+
+				return function(action)
 					middlewareInvokeCount = middlewareInvokeCount + 1
-					next(store, action)
+					passedAction = action
+
+					nextDispatch(action)
 				end
 			end
 
 			local store = Store.new(reducer, "initial state", { testMiddleware })
 
+			expect(middlewareInstantiateCount).to.equal(1)
+			expect(middlewareInvokeCount).to.equal(0)
+			expect(passedDispatch).to.be.a("function")
+			expect(passedStore).to.equal(store)
+
 			store:dispatch({
 				type = "test",
 			})
 
+			expect(middlewareInstantiateCount).to.equal(1)
 			expect(middlewareInvokeCount).to.equal(1)
+			expect(passedAction.type).to.equal("test")
+
+			store:flush()
+
+			expect(store:getState()).to.equal("test state")
 
 			store:destruct()
 		end)

lib/loggerMiddleware.lua

@@ -39,9 +39,9 @@ local loggerMiddleware = {
 	outputFunction = print,
 }
 
-function loggerMiddleware.middleware(next)
-	return function(store, action)
-		local result = next(store, action)
+function loggerMiddleware.middleware(nextDispatch, store)
+	return function(action)
+		local result = nextDispatch(action)
 
 		loggerMiddleware.outputFunction(("Action dispatched: %s\nState changed to: %s"):format(
 			prettyPrint(action),

lib/thunkMiddleware.lua

@@ -4,12 +4,12 @@
 	This middleware consumes the function; middleware further down the chain
 	will not receive it.
 ]]
-local function thunkMiddleware(next)
-	return function(store, action)
+local function thunkMiddleware(nextDispatch, store)
+	return function(action)
 		if typeof(action) == "function" then
 			return action(store)
 		else
-			return next(store, action)
+			return nextDispatch(action)
 		end
 	end
 end