sample usage of backbone-fsm

## fsm_test.js
module.paths.push(".");

var assert = require("assert");
var _ = require("underscore");
var Backbone = require("backbone");
var FSM = require("backbone-fsm").BackboneFSM;

/* Implementation of a turnstile (i.e., at train station).  Turnstile is
initially locked and won't let people through.  Once a coin is
inserted, the turnstile becomes unlocked, and lets one person through before
locking again. */
var TurnstileFSM = FSM.define(
	{
		action: {person_entered: true},
		guard: {locked: false},
		result: {locked: true}
	},
	{
		action: {coin_inserted: true},
		result: {locked: false}
	}
);

var Turnstile = TurnstileFSM(
	Backbone.Model.extend({
		defaults: {
			locked: true
		}
	})
);

var myTurnstile = new Turnstile();
assert.equal(myTurnstile.can({person_entered: true}), false);
assert.equal(myTurnstile.can({coin_inserted: true}), true);
assert.equal(myTurnstile.get("locked"), true);
myTurnstile.transition({coin_inserted: true});
assert.equal(myTurnstile.can({person_entered: true}), true);
assert.equal(myTurnstile.can({coin_inserted: true}), true);
assert.equal(myTurnstile.get("locked"), false);
myTurnstile.transition({person_entered: true});
assert.equal(myTurnstile.get("locked"), true);

/* Implementation of a HTTP/1.0 response parser.
This implementation works on lines.  Further down,
I show how you can use another FSM to convert from
character-by-character stream (or chunked streams)
into lines. Chaining multiple FSMs together works wonders
and is easy with Backbone.Event mixin.*/
var HTTPFSM = FSM.define(
	{
		action: {read: /^.+$/m},
		guard: {mode: null},
		result: function(obj) {
			var code = obj.read.split(/\s/)[1];
			this.set({
				status_code: code,
				mode: "headers"
			});
		}
	},
	{
		action: {read: /^.+$/m},
		guard: {mode: "headers"},
		result: function(obj) {
			var parts = obj.read.split(":");
			var headers = this.get("headers");
			headers[parts[0].toLowerCase()] = parts[1].trim();
		}
	},
	{
		action: {read: /^$\n/m},
		guard: {mode: "headers"},
		result: {mode: "body"}
	},
	{
		action: {read: /^.*$/m},
		guard: {mode: "body"},
		result: function(obj) {
			var body = this.get("body") || "";
			this.set({body: body + obj.read});
		}
	}
);

var http_stream = [
  "HTTP/1.0 200 OK",
  "Date: Fri, 31 Dec 1999 23:59:59 GMT",
  "Content-Type: text/html",
  "Content-Length: 1354",
  "",
  "<html>",
  "<body>",
  "<h1>Hello World</h1>",
  "</body>"
];
var check_http = function(obj) {
	assert.equal(obj.get("status_code"), "200");
	assert.equal(obj.get("body"), "<html>\n<body>\n<h1>Hello World</h1>\n</body>");
	assert.equal(obj.get("headers")["date"], "Fri, 31 Dec 1999 23");
	assert.equal(obj.get("headers")["content-type"], "text/html");
	assert.equal(obj.get("headers")["content-length"], "1354");
}

var HTTPResponseParser = HTTPFSM(
	Backbone.Model.extend({
		defaults: {
			status_code: null,
			body: null,
			headers: null
		},
		initialize: function() {
			this.set("headers", {});
		}
	})
);

// Here we feed the parser just the raw lines
var myHTTP = new HTTPResponseParser();
_.each(_.initial(http_stream), function(v) {
	myHTTP.transition({read: v + "\n"});
});
myHTTP.transition({read: _.last(http_stream)});
check_http(myHTTP);


/* Implementation of a FSM that takes string chunks
and converts them into lines. Listeners will listen
for the emit_line event and act accordingly.*/
var Stream2LineFSM = FSM.define(
	{
		action: {read: FSM.ANY},
		result: function(obj) {
			var input = obj.read || "";
			var s = (this.get("buffer") || "") + input;
			var chunks = s.split("\n");
			if (chunks.length === 1) {
				this.set("buffer", chunks[0]);
			} else {
				_.each(_.initial(chunks), function(v) {
					this.trigger("emit_line", v + "\n");
				}, this);
				this.set("buffer", _.last(chunks));
			}
		}
	},
	{
		action: {EOF: FSM.ANY},
		result: function(obj) {
			this.trigger("emit_line", this.get("buffer") || "");
			this.set("buffer", null);
		}
	}
)

var Stream2Line = Stream2LineFSM(Backbone.Model);
var stream = http_stream.join("\n");


// Test by sending the entire response as one chunk
var streamer = new Stream2Line();
myHTTP = new HTTPResponseParser();
myHTTP.listenTo(streamer, "emit_line", function(v) {
	this.transition({read: v});
});
streamer.transition({read: stream});
streamer.transition({EOF: true});
check_http(myHTTP);


// Test by sending the entire response char-by-char
streamer = new Stream2Line();
myHTTP = new HTTPResponseParser();
myHTTP.listenTo(streamer, "emit_line", function(v) {
	this.transition({read: v});
});
for (var i=0; i<stream.length; i++) {
	streamer.transition({read: stream[i]});
}
streamer.transition({EOF: true});
check_http(myHTTP);


// Test by sending the entire response 2 characters at a time
streamer = new Stream2Line();
myHTTP = new HTTPResponseParser();
myHTTP.listenTo(streamer, "emit_line", function(v) {
	this.transition({read: v});
});
for (var i=0; i<stream.length; i+=2) {
	var c = (stream[i] || "") + (stream[i+1] || "");
	streamer.transition({read: c});
}
streamer.transition({EOF: true});
check_http(myHTTP);