When you first use $.ajax() in jQuery, it is easy and tempting to set up a HTTP request/response style communication mechanism between your client and your server. Your client sends a HTTP request, it provides a handler to receive the HTTP response and the handler does something with the result. That seems fine ...
... except it breaks down pretty easily. If the server takes too long, the HTTP connection times out and the response is lost. And, when it breaks down, you hack on it, adding polling and/or subscription mechanisms. Then it breaks down some more and you hack on it some more.
Events are always better.
With events, the client sends and receives events (e.g. a JSON object).
Events are self-contained. They do not require any external information. For example, the event should not have a different meaning if it is called on one URI (e.g. /users) versus another URI (e.g. /groups). If it does, the event should be updated with that new information to keep the event self-contained. So, in our example, maybe an "domain" key is added to the event which is assigned a value of "users" or "groups". After modifying the event, the event would again be self-contained and the URI that it was sent to can be forgotten.
An event should also be disconnected from the communications mechanism: it should not matter if an event was received via a HTTP request (or HTTP response), short-polling, long-polling, JSONP, Socket.IO or even some strange new datagram mechanism (which would be session-less and not allow responses). Different communication transports should be easy to substitute.
Events work in "fire and forget" mode. Once an event is fired, it is gone. The sender does not concern itself whether the event is received or not; it lets the event delivery mechanism do its work and deliver the event with no further interaction.
But what if your code expects a response?
The event handler should receive the event, process it and then send a response event back to the original sender. A response event is new event that is created by the receiver and sent to the original sender with a reference to the original event. Usually, the events contain a unique event number which the response event can reference. The response is still a new event; it just references another event.
With HTTP, an assumption is made that every request has its own response. This assumption may not be valid when you are using long-polling instead of HTTP. With events, however, the assumption is removed; events can be sent and response events can be sent back using some other mechanism or at a much later date. HTTP relies on the response being sent back in the same HTTP connection as the HTTP request was sent. Events do not.
Events can be built on top of HTTP requests/responses. Events are sent as part of the GET query string or the POST data and any pending events can be returned in the HTTP response body. The difference is that the events returned do not need to correspond to the events sent. Arbitrary events can be sent and arbitrary events can be received in the same HTTP connection with no relationship implied between them.
Inevitably, it seems that most systems move towards an event system (or suffer through an ever growing number of hacks to add flexibility to HTTP request/response designs).
If you want my advice, consider starting any new code with events, rather than muddling through with an HTTP request/response system and converting it later.
Thursday, July 3, 2014
Friday, January 3, 2014
Super simple JSON and MySQL
I invented jsonhib (available for Node.js and PHP at http://github.com/ajaximrpg/jsonhib ) to provide a "good enough" solution to reading and writing JSON data to a MySQL database.
Most developers say this is impossible.
But, to read JSON from a MySQL database, jsonhib has a readRows() method that takes two arguments: a table name and a WHERE clause. It returns a JSON array of JSON objects where each object represents a MySQL row. The columns of each MySQL row become JSON property names; the values of each MySQL row become property values. The WHERE clause only serves to narrow the number of JSON objects returned.
In Node.js, it looks like this:
// assume 'mytable' is a MySQL table with these columns: id, name
jh.readRows('mytable', 'WHERE id > 0', function(s) {
var str = s;
});
// str='[{"id": 1, "name": "bob"}, {"id": 2, "name": "fred"}]'
Most developers say this is impossible.
But, to read JSON from a MySQL database, jsonhib has a readRows() method that takes two arguments: a table name and a WHERE clause. It returns a JSON array of JSON objects where each object represents a MySQL row. The columns of each MySQL row become JSON property names; the values of each MySQL row become property values. The WHERE clause only serves to narrow the number of JSON objects returned.
In Node.js, it looks like this:
// assume 'mytable' is a MySQL table with these columns: id, name
jh.readRows('mytable', 'WHERE id > 0', function(s) {
var str = s;
});
// str='[{"id": 1, "name": "bob"}, {"id": 2, "name": "fred"}]'
Most developers will object that the objects are out of order. "There's no sorting or ordering," they say, "the objects come out in random order."
They sure do. Sometimes, the client doesn't care so it doesn't matter. But, if it does matter and an additional integer column can be added to the table (a sort_column column), jsonhib can be directed to use this hidden column to maintain the order of rows. And, if the table can't be modified, jsonhib relies on the caller to reorder the JSON array if he wishes.
Another objection is that MySQL databases require a schema and JSON objects can have arbitrary properties. "The only choice is to put all your JSON objects in one table and serialize the JSON to a single MySQL text column," they say.
Uh, is that how you do it in client? Just have all your JSON objects crammed into a single humongous array? Mix your customer JSON objects with your sales order JSON objects and your permissions JSON objects? Of course not! You assign arrays of similar JSON objects to different variables. In this case, similar JSON objects are assigned to specific MySQL tables. Your client doesn't add customer JSON objects to the permissions variable; don't add customer data to the MySQL permissions table.
Also, don't all customers have a name? Isn't their name always a string, not a floating point value? Yes, JSON objects can have arbitrary properties but they always have a lot of properties that are expected and required and are of a specific type. jsonhib relies on the caller to know that, by default, JSON properties that do not fit into the MySQL schema will be discarded. Avoid extra properties or store them somewhere else. If that is not desirable and an additional string column can be added to the table (a json_column column), jsonhib can be directed to use this hidden column to keep track of JSON data that doesn't fit into the MySQL schema. This column doesn't keep all the JSON data; it just keeps the JSON properties that don't have a corresponding dedicated MySQL column or have a MySQL column of the wrong type.
jsonhib really is just an object-relational mapping (ORM) layer for JSON and MySQL. When reading, jsonhib queries MySQL rows and sensibly maps MySQL columns to JSON properties and, if available, uses the sort_column and json_column columns to fix up the mismatches between how MySQL works and how JSON works.
Besides reading, jsonhib can also insert, delete and update JSON objects. JSON arrays (i.e. MySQL tables) can also be reordered using the moveRow() method.
// insert a row
jh.insertRow('mytable', '', -1, '{"id": 1, "name": "bob"}',
function() {});
// delete a row
jh.deleteRow('mytable', '', 0,
function() {});
// update a row
jh.updateRow('mytable', 'WHERE id=1', 0, '{"id": 1, "name": "eric"}',
function() {});
// move a row (huh?)
jh.moveRow('mytable', 'WHERE id=1', 0, 1,
function() {});
jsonhib has a lot of nice attributes. Other solutions require new SQL syntax provided by specially modified MySQL database software, plugins or new versions but jsonhib works with any MySQL version and any MySQL data. Existing applications and processes that use the MySQL database work without modification and can work with data that is inserted, updated and deleted using jsonhib.
Impossible? No, not impossible. JSON can be stored in MySQL.
Rewrite a CSS stylesheet using PHP
I've been writing a user-generated content system in PHP where users can upload CSS (and HTML) that will be shown in a DIV. Of course, I wanted to restrict their CSS to only be applied inside the DIV and not style the surrounding content (either accidentally or maliciously).
The first step was easy: create a class and assign it to the DIV.
<div class="user_content">
But how to restrict a CSS stylesheet with a bunch of random rules to that DIV?
Given something like this:
.block input, table td.money {
...
}
How do I turn it into this?
.user_content .block input, .user_content table td.money {
...
}
A long search finally ended when Stack Overflow revealed a way to insert my user_content class before every rule using a fancy regular expression ... but it broke down on comments with commas in them. It was a long search because it was very difficult to figure out what search terms to use and a real bummer that the solution broke down on something as common as comments.
So, I developed this code to handle block out the commas in comments, apply the fancy regular expression from Stack Overflow and then put the commas back.
function rewriteCss($css, $cssClazz) {
while (preg_match('/(\/\*.+?),(.+?\*\/)/', $css) === 1) {
$contents = preg_replace(
'/(\/\*.+?),(.+?\*\/)/', '$1:comma:$2', $css);
}
$css = preg_replace(
'/([^\r\n,{}]+)(,\s*(?=[^}]*{)|\s*{)/',
'.'.$cssClazz.' $1$2', $css);
while (preg_match('/(\/\*.+?):comma:(.+?\*\/)/', $css) === 1) {
$css = preg_replace(
'/(\/\*.+?):comma:(.+?\*\/)/', '$1,$2', $css);
}
return $css;
}
That did the trick. Each comma in a comment is blocked out by replacing it with :comma:. Then, a complicated preg_replace() call is made with the fancy regular expression from Stack Overflow. Finally, the :comma: in comments are restored to being literal commas.
Super.
The first step was easy: create a class and assign it to the DIV.
<div class="user_content">
But how to restrict a CSS stylesheet with a bunch of random rules to that DIV?
Given something like this:
.block input, table td.money {
...
}
How do I turn it into this?
.user_content .block input, .user_content table td.money {
...
}
A long search finally ended when Stack Overflow revealed a way to insert my user_content class before every rule using a fancy regular expression ... but it broke down on comments with commas in them. It was a long search because it was very difficult to figure out what search terms to use and a real bummer that the solution broke down on something as common as comments.
So, I developed this code to handle block out the commas in comments, apply the fancy regular expression from Stack Overflow and then put the commas back.
function rewriteCss($css, $cssClazz) {
while (preg_match('/(\/\*.+?),(.+?\*\/)/', $css) === 1) {
$contents = preg_replace(
'/(\/\*.+?),(.+?\*\/)/', '$1:comma:$2', $css);
}
$css = preg_replace(
'/([^\r\n,{}]+)(,\s*(?=[^}]*{)|\s*{)/',
'.'.$cssClazz.' $1$2', $css);
while (preg_match('/(\/\*.+?):comma:(.+?\*\/)/', $css) === 1) {
$css = preg_replace(
'/(\/\*.+?):comma:(.+?\*\/)/', '$1,$2', $css);
}
return $css;
}
That did the trick. Each comma in a comment is blocked out by replacing it with :comma:. Then, a complicated preg_replace() call is made with the fancy regular expression from Stack Overflow. Finally, the :comma: in comments are restored to being literal commas.
Super.
Thursday, October 24, 2013
jQuery Tabs One Tab Bug
I needed to add tabs to my jQuery so, naturally, I selected jQuery Tabs. It worked great!
Except for a gnarly jQuery bug. If I had only one tab, the tab background (e.g. the ol/ul element) would be one pixel shorter than if I had two or more tabs. Also, with only one tab, there was an "off by one" bug where the one and only tab would descend by extra one pixel below the tab background. This "off by one" effect wasn't that noticeable, especially depending on the various colors involved, which is why it may have slipped by the jQuery Tab developers.
The visual effect would be that, when the user took some action that would add a second tab, the tab background would grow by one pixel and the "off by one" effect would be fixed for all tabs.
I spent a good number of hours hunting for the problem before finding it in jquery.ui.tabs.css. It contained a rule like this:
.ui-tabs .ui-tabs-nav li.ui-tabs-active {
margin-bottom: -1px;
padding-bottom: 1px;
}
Except for a gnarly jQuery bug. If I had only one tab, the tab background (e.g. the ol/ul element) would be one pixel shorter than if I had two or more tabs. Also, with only one tab, there was an "off by one" bug where the one and only tab would descend by extra one pixel below the tab background. This "off by one" effect wasn't that noticeable, especially depending on the various colors involved, which is why it may have slipped by the jQuery Tab developers.
The visual effect would be that, when the user took some action that would add a second tab, the tab background would grow by one pixel and the "off by one" effect would be fixed for all tabs.
I spent a good number of hours hunting for the problem before finding it in jquery.ui.tabs.css. It contained a rule like this:
.ui-tabs .ui-tabs-nav li.ui-tabs-active {
margin-bottom: -1px;
padding-bottom: 1px;
}
The margin-bottom style with a negative margin was the issue. The tab background calculated its height according to the height of its child tab (e.g. the li element). But, apparently, if negative margins are used, the height of the child element is reduced by the negative margin for parent calculation purpose. For example, if a child element is 15 pixels high and has a margin of -2, the parent sees the child element as 13 pixels high.
The negative margin is only applied to the active tab. If there is only one tab, the tab background uses only that tab for calculation purposes and is one pixel too short. If a second tab is added, then, presto!, there is at least one inactive tab. Inactive tabs don't get the CSS rule that applies the negative margin so the "negative margin discount" isn't applied. The tab background grows by one pixel so it can contain the inactive tab and solves the issue for all tabs ... at least until there is one tab (which will be the active tab) again.
I confirmed the issue in two ways. First, I changed the margin-bottom from -1 pixel to -10 pixels and saw the tab background shrink by 9 pixels. But, of course, when a second tab was added, the height of the tab background jumped by 9 pixels. Second, I created two tabs and then used the Inspector in my browser to hack in the ui-tabs-active CSS class to both tabs such that there were seemingly two active tabs and zero inactive tabs and was rewarded to see the tab background shrink.
But how to fix?
I tried hacking jQuery Tab JavaScript and modifying the CSS rule above. Sometimes, I fixed it but then I'd break something else. Finally, I realized that I needed a way to use the negative margin CSS rule only when there were two or more tabs (which worked already) and then apply a different CSS rule when there was one and only one tab.
CSS3 to the rescue! As it turns out, there is a way to create a CSS rule that is only applied when an element contains only one child.
.ui-tabs .ui-tabs-nav li:first-child:nth-last-child(1) {
margin-bottom: 0px;
position: relative;
top: 1px;
}
Rather than changing the CSS rule in jquery.ui.tabs.css, I modify it with my own CSS rule in my own stylesheet that is only applied when there is one child. My own rule resets margin-bottom from -1 to 0 and then uses position: relative and top: 1px to accomplish the same "border overlap" effect that negative margins were trying to achieve.
Wednesday, September 18, 2013
Fetch a Single Backbone.js Object via REST
In a previous post, I described how to fetch a collection using Backbone.js RESTful Persistence. But, this morning, I was a little befuddled as to how to fetch a single object without fetching the entire collection.
The trick is to create a new model with the id attribute and add an options object to the model constructor with the urlRoot property.
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title></title>
<meta name="description" content="">
</head>
<body onload="onload();">
<script src="jquery-1.10.1.js"></script>
<script src="underscore.js"></script>
<script src="backbone.js"></script>
<script language="JavaScript"> function onload() {
// create a data model
var Person = Backbone.Model.extend({
defaults: {
name: '',
age: 1
}
});
// create a data model collection
var PersonCollection = Backbone.Collection.extend({
model: Person,
url: 'backbone.php'
});
var oneOff = new Person({id: 138}, {urlRoot: 'backbone.php'});
oneOff.fetch({
success: function(model) {
console.log(JSON.stringify(oneOff.toJSON()));
}
});
} </script>
</body>
</html>
But, of course, this required an improvement to PHP code in the "Backbone.js REST with PHP" post. Until now, a GET request always returned the entire collection from backbone.php but I had to update it to check the request URI and, if an object was specified, to find and print that object only.
I've made over a dozen changes to the "Backbone.js REST with PHP" post since I originally published it; I just keep stumbling across new features and quirks which seem to only be covered in bits and pieces all over the Internet.
Wednesday, September 11, 2013
Finally, A Simple Backbone.js Router!
The Internet provides plenty of Backbone.js Router examples but not a simple, straightforward sample that can easily be demonstrated without a web server.
A good example needs to be complete, show a generic implementation that will be often used verbatim and can be easily extended and that will highlight concerns. The following example shows how to implement a Backbone.js Router to access different pages while using a single HTML page and highlights when the page variables will be reset.
Here's some code that you can copy-and-paste into a file named router.html:
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Backbone.js Router Example</title>
<meta name="description" content="">
</head>
<body>
<div id="page">
Welcome to Backbone.js routers!
</div>
<input type="button" value="About"
onclick="pageRouter.navigate('about', {trigger: true});"></input>
<input type="button" value="Page 1"
onclick="pageRouter.navigate('page/1', {trigger: true});"></input>
<input type="button" value="Page 2"
onclick="pageRouter.navigate('page/2', {trigger: true});"></input>
<input type="button" value="Page 3"
onclick="pageRouter.navigate('page/3', {trigger: true});"></input>
<script src="jquery-1.10.1.js"></script>
<script src="underscore.js"></script>
<script src="backbone.js"></script>
<script language="JavaScript">
var visited = 1;
var PageRouter = Backbone.Router.extend({
routes: {
'about': 'routeToAbout',
'page/:num': 'routeToPage'
},
// one way to define a route handler
routeToAbout: function() {
$('#page').html('About, visited '+visited+' pages');
++visited;
}
});
// create a router instance
var pageRouter = new PageRouter();
// a second way to define a route handler
pageRouter.on('route:routeToPage', function(num) {
$('#page').html('Page '+num+', visited '+visited+' pages');
++visited;
});
Backbone.history.start();
</script>
</body>
</html>
A good example needs to be complete, show a generic implementation that will be often used verbatim and can be easily extended and that will highlight concerns. The following example shows how to implement a Backbone.js Router to access different pages while using a single HTML page and highlights when the page variables will be reset.
Here's some code that you can copy-and-paste into a file named router.html:
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Backbone.js Router Example</title>
<meta name="description" content="">
</head>
<body>
<div id="page">
Welcome to Backbone.js routers!
</div>
<input type="button" value="About"
onclick="pageRouter.navigate('about', {trigger: true});"></input>
<input type="button" value="Page 1"
onclick="pageRouter.navigate('page/1', {trigger: true});"></input>
<input type="button" value="Page 2"
onclick="pageRouter.navigate('page/2', {trigger: true});"></input>
<input type="button" value="Page 3"
onclick="pageRouter.navigate('page/3', {trigger: true});"></input>
<script src="jquery-1.10.1.js"></script>
<script src="underscore.js"></script>
<script src="backbone.js"></script>
<script language="JavaScript">
var visited = 1;
var PageRouter = Backbone.Router.extend({
routes: {
'about': 'routeToAbout',
'page/:num': 'routeToPage'
},
// one way to define a route handler
routeToAbout: function() {
$('#page').html('About, visited '+visited+' pages');
++visited;
}
});
// create a router instance
var pageRouter = new PageRouter();
// a second way to define a route handler
pageRouter.on('route:routeToPage', function(num) {
$('#page').html('Page '+num+', visited '+visited+' pages');
++visited;
});
Backbone.history.start();
</script>
</body>
</html>
Assuming that you have the Backbone.js infrastructure (i.e. jquery-1.10.1.js, underscore.js and backbone.js), you can load this into any popular browser without a web server. For example, if you are using Windows and place your files in the C:\ folder, you can type the following directly into the location bar:
file:///C:/router.html
If you want to visit one of the routes, you can press the "About", "Page 1", "Page 2" or "Page 3" buttons on the web page. Or, you can directly visit the routes by copy-and-pasting the following URLs into the location bar:
file:///C:/router.html#about
file:///C:/router.html#page/1
file:///C:/router.html#page/2
file:///C:/router.html#page/3
Notice how the global variable, visited, is maintained (usually) or reset (when the page is reloaded). It is critical that your design take into account the circumstances under which page variables are reset.
Some other examples neglect to include a call to Backbone.history.start() and, without it, the page does nothing. A confusing oversight!
Hopefully, this example lets you learn about Backbone.js Routers in a straightforward way without pausing to manipulate a web server.
Friday, September 6, 2013
Backbone.js REST with PHP
Why isn't there a simple example where Backbone.js RESTful Persistence uses PHP?
Backbone.js has Models and Collections which can be, in theory, easily connected to a REST backend so that adds, deletes and changes on the client are mirrored on the server.
The following sync.html file is a simple demo (or, at least, as simple as I could make it!) that uses a single PHP page, backbone.php, as a server.
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title></title>
<meta name="description" content="">
</head>
<body onload="onload();">
<script src="jquery-1.10.1.js"></script>
<script src="underscore.js"></script>
<script src="backbone.js"></script>
<script language="JavaScript"> function onload() {
// optional since these are the defaults
Backbone.emulateHTTP = false;
Backbone.emulateJSON = false;
// create a data model
var Person = Backbone.Model.extend({
defaults: {
name: '',
age: 1
}
});
// create a data model collection
var PersonCollection = Backbone.Collection.extend({
model: Person,
url: 'backbone.php'
});
// store a collection first for nice demo
var people = new PersonCollection([
new Person({"name": "Bob", "age": 20}),
new Person({"name": "Bill", "age": 25}),
new Person({"name": "John", "age": 30})
]);
// jQuery promise deals with async issues
var promise = $.Deferred();
people.forEach(function(person) {
promise.then(function() {
console.log('saving '+person.get('name'));
person.save();
});
});
promise.then(function() {
// fetch the collection via HTTP GET
people = new PersonCollection();
people.fetch({ success: function(collection) {
// pretty print the people who were fetched
console.log(JSON.stringify(collection.toJSON()));
// another promise
var promise = $.Deferred();
// change Bob's age and store him via HTTP PUT
collection.filter(function(person) {
return person.get('name') === 'Bob';
}).forEach(function(person) {
promise.then(function() {
console.log('changing Bob\'s age');
collection.get(person.id).set('age', 40).save();
});
});
// change Bill's age and store him via HTTP PUT
collection.filter(function(person) {
return person.get('name') === 'Bill';
}).forEach(function(person) {
promise.then(function() {
console.log('changing Bill\'s age');
person.set('age', 45).save();
});
});
// change Bill's properties via HTTP PATCH
collection.filter(function(person) {
return person.get('name') === 'Bill';
}).forEach(function(person) {
promise.then(function() {
console.log('patching Bill');
person.save({name: 'Billy', age: 55} , {patch: true});
});
});
// create Tim via HTTP POST
promise.then(function() {
console.log('creating Tim');
collection.create({
name: 'Tim', age: 50
}, {
wait: true,
success: function(resp) {
// delete John via HTTP DELETE
collection.filter(function(person) {
return person.get('name') === 'John';
}).forEach(function(person) {
console.log('destroying John');
person.destroy({ success: function(resp) {
// pretty print the people in the collection
console.log(JSON.stringify(collection.toJSON()));
}});
});
}
});
});
promise.resolve();
}});
});
promise.resolve();
} </script>
</body>
</html>
This page creates the initial collection, then executes a series of modifications, then shows the final collection. The modifications are as follows: (1) Bob's age is changed from 20 to 40; (2) Bill's age is changed from 25 to 45; (3) Bill's name is patched to "Billy" and his age is patched to 55; (4) Tim is created and added; and (5) John is deleted from the collection.
saving Bob
saving Bill
saving John
[{"id":41,"name":"Bill","age":25},{"id":978,"name":"Bob","age":20},{"id":726,"name":"John","age":30}]
changing Bob's age
changing Bill's age
patching Bill
creating Tim
destroying John
[{"id":41,"name":"Billy","age":55},{"id":978,"name":"Bob","age":40},{"name":"Tim","age":50,"id":689}]
It works by first creating a Backbone.js model called Person.
It then creates a Backbone.js collection called PersonCollection which, like a model, is a "kind" of object, not an object instance. By default, the url property assigns backbone.php as the server URL that will handle Backbone.js RESTful Persistence.
Then, a collection instance with model instances is created and stored in the people variable.
So far, no REST calls have been made. Backbone.js REST calls are asynchronous so, to avoid race conditions, it is helpful to use a feature like the jQuery promise APIs. The promise APIs allow the developer to make REST calls (or other function calls) to only let the next REST call start only after the previous REST call has finished. The three Person objects in the collection are stored as promises so they can be saved to the backend in order.
A final promise is added to execute the remaining operations. The people variable is replaced with an empty collection and the previously saved models will be load into the collection using Backbone.js fetch() API as a test. A new promise variable is created and promises are made to change Bob's and Bill's ages. Finally, Tim is created, John is destroyed/deleted and the models left in both the client-side (i.e. the collection variable) and the server-side (i.e. store.txt) are the same.
The resolve() function on the promise variable kicks off the actual execution of the promises.
Although I had hoped to avoid the complication of using the jQuery promise APIs in this example, the asynchronous nature of REST APIs make it necessary, even in this simple case.
The only backend is a backbone.php page. It usually works but it has to use some hacks and tricks which aren't kosher. It uses a single store.txt file for a data store in the service of clarity but at the expense of reliability; a database would be better. It also might not work on every PHP server. That said ...
... it will give you a good idea how Backbone.js RESTful Persistence works.
<?php
$lock = fopen('log.txt', 'a+');
$floc = flock($lock, LOCK_EX);
fwrite($lock, $_SERVER['REQUEST_METHOD']." ");
fwrite($lock, $_SERVER['REQUEST_URI']." lock\r\n");
if (!$floc) {
fwrite($lock, "flock() failed\r\n");
}
if ($_SERVER['REQUEST_METHOD'] == 'GET') {
// see if fetching a single object
$id = explode('/', $_SERVER['REQUEST_URI']);
$id = array_pop($id);
if (strpos(strrev($id), strrev('.php')) === 0) {
// select (fetch) the collection
$json = file_get_contents('store.txt');
if ($json === false) {
$json = "[\n]";
}
fwrite($lock, $json."\r\n");
print $json;
} else {
// select (fetch) the object
fwrite($lock, "GET $id\r\n");
if ((string)(int)$id != $id) {
$id = '"'.$id.'"';
}
// get the item from store.txt
$json = file_get_contents('store.txt');
if ($json === false) {
fwrite($lock, "[\n]\r\n");
fwrite($lock, "{}\r\n");
print "{}";
} else {
fwrite($lock, $json."\r\n");
$found = false;
$json = explode("\n", $json);
$json = array_slice($json, 1, -1);
for ($p=0; $p < count($json); ++$p) {
if (strpos($json[$p], '"id":'.$id) !== false) {
$person = rtrim($json[$p], ', ');
$found = true;
break;
}
}
if ($found) {
fwrite($lock, $person."\r\n");
print $person;
} else {
fwrite($lock, "{}\r\n");
print "{}";
}
}
}
} else {
// set flags for actions and options
$emulateHTTP = false;
$emulateJSON = false;
$insert = false;
$update = ($_SERVER['REQUEST_METHOD'] == 'PUT');
$patch = ($_SERVER['REQUEST_METHOD'] == 'PATCH');
$delete = ($_SERVER['REQUEST_METHOD'] == 'DELETE');
if ($update || $patch) {
// get the new value
$person = file_get_contents('php://input');
// don't trust $_SERVER['CONTENT_TYPE']
if ((substr($person, 0, 1) != '{')
&& (substr($person, 0, 1) != '[')) {
$emulateJSON = true;
}
if ($emulateJSON) {
$person = urldecode($person);
$person = explode('=', $person);
$person = $person[1];
}
} elseif ($_SERVER['REQUEST_METHOD'] == 'POST') {
// get emulated action and value
$emulateHTTP = true;
if (isset($_POST['_method'])) {
if ($_POST['_method'] === 'PUT') {
$update = true;
$person = $_POST['model'];
} elseif ($_POST['_method'] === 'PATCH') {
$patch = true;
$person = $_POST['model'];
} elseif ($_POST['_method'] === 'DELETE') {
$delete = true;
}
} elseif (isset($_POST['model'])) {
$person = urldecode($_POST['model']);
$insert = true;
} else {
$person = file_get_contents('php://input');
if ($person === '') {
$delete = true;
} else {
$id = explode('/', $_SERVER['REQUEST_URI']);
$id = array_pop($id);
if (is_numeric($id)) {
if (preg_match('/"id":(.*?)[,}]/', $person) === 1) {
$update = true;
}
$patch = !$update;
} else {
$insert = true;
$emulateHTTP = false;
}
}
}
}
if ($delete) {
// delete the object from store.txt
$id = explode('/', $_SERVER['REQUEST_URI']);
$id = array_pop($id);
fwrite($lock, "DELETE $id\r\n");
if ((string)(int)$id != $id) {
$id = '"'.$id.'"';
}
// remove the item in store.txt
$json = file_get_contents('store.txt');
if ($json === false) {
fwrite($lock, "[\n]\r\n");
fwrite($lock, "[\n]\r\n");
} else {
fwrite($lock, $json."\r\n");
$found = false;
$json = explode("\n", $json);
$json = array_slice($json, 1, -1);
for ($p=0; $p < count($json); ++$p) {
if (strpos($json[$p], '"id":'.$id) !== false) {
$person = rtrim($json[$p], ', ');
array_splice($json, $p, 1);
array_push($json, rtrim(array_pop($json), ', '));
$found = true;
break;
}
}
if ($found) {
$json = implode("\n", $json);
$json = "[\n".$json."\n]";
file_put_contents('store.txt', $json);
print $person;
}
fwrite($lock, $json."\r\n");
}
} else {
// insert (create) or update the item in store.txt
$verb = $update? 'PUT ': 'PATCH ';
fwrite($lock, ($insert? 'POST ': $verb)."$person\r\n");
if ($insert) {
$id = rand(0, 999);
$person = '{"id":'.$id.','.substr($person, 1);
} elseif ($patch) {
$id = explode('/', $_SERVER['REQUEST_URI']);
$id = array_pop($id);
$person = '{"id":'.$id.','.substr($person, 1);
// PATCH is broken but use JSON to merge $person
// with the value in store.txt
}
$json = file_get_contents('store.txt');
if ($json === false) {
fwrite($lock, "[\n]\r\n");
$json = "[\n".$person."\n]";
} else {
fwrite($lock, $json."\r\n");
preg_match('/"id":(.*?)[,}]/', $person, $id);
$id = $id[1];
$found = false;
$json = explode("\n", $json);
$json = array_slice($json, 1, -1);
// replace the item with the new value
if ($update || $patch) {
for ($p=0; $p < count($json); ++$p) {
if (strpos($json[$p], '"id":'.$id) !== false) {
$last = ($p == count($json) - 1);
$json[$p] = $person.($last? '': ',');
$found = true;
}
}
}
$json = implode("\n", $json);
// insert the new value
if (!$found) {
$json .= ",\n".$person;
}
$json = "[\n".$json."\n]";
}
fwrite($lock, $json."\r\n");
file_put_contents('store.txt', $json);
print $person;
}
}
fwrite($lock, $_SERVER['REQUEST_METHOD']." unlock\r\n");
flock($lock, LOCK_UN);
fclose($lock);
?>
When the sync.html is loaded, it uses backbone.php to synchronize the models from the client-side to the server-side via REST. By setting the url parameter on the Backbone.js Collection in sync.html, Backbone.js RESTful Persistence is activated and directed to backbone.php on the server.
The PHP REQUEST_METHOD is used to separate the HTTP actions into GET, PUT, PATCH, POST and DELETE. The people.fetch() call in sync.html corresponds to the GET action in backbone.php. The person.save() call in sync.html corresponds to the PUT or PATCH actions in backbone.php. The collection.create() call in sync.html corresponds to the POST action in backbone.php. The person.destroy() call in sync.html corresponds to the DELETE action in backbone.php.
The implementations of GET, PUT, PATCH, POST and DELETE all manipulate a store.txt file on the server that stores JSON data for the collection. It is complicated in places to avoid reliance on a JSON library in PHP but the end result is the same: adding, changing and deleting objects from a JSON array which is stored in store.txt.
I wish that the PHP flock() function calls were not necessary but they are a solid but not wholly successful way to handle the race conditions that can occur on PHP platforms. Race conditions can occur when several REST calls are executed simultaneously. Backbone.js does not wait from one REST action to finish before executing another one and, to keep sync.html simple, I've ignored this on the client and used PHP flock() to control this on the server. The log.txt file, which is used with PHP flock(), also serves as a log.
So, finally, here's something to get you started with Backbone.js and PHP.
Subscribe to:
Posts (Atom)