Road to mobile w/ Sinatra, jQuery Mobile, Spine.js and Mustache

transcript

By Brian Sam-Bodden

with jqm, spine.mvc, sinatra and mustache

The Road to Mobile Web Development

WHAT I HAVE FOR YOU...

• A possible path to mobile web applications:

• Sinatra + Mustache for a Simpler Server-Side• jQuery Mobile for Out-of-the-box Mobile• Spine.js for MVC goodness on the Client-Side• Where to start? Front-to-Back or Back-to-Front?

THE MOBILE WEBAGENT COMPUTING COMES OF AGE

“...the future of computing is mobile... businesses should have their best developers working on their mobile

applications”Google’s Eric Schmidt Interview on TechCrunch, April 2010

MOBILE WEBAGENT COMPUTING COMES OF AGE

• 20%: decline of home PC usage since 2008 (1)

• 74%: increase of smart phones sold from 2010 to 2011(2)

• 261%: increase in smart tablets sold from 2010 to 2011(3)

• $9 billion: predicted US mobile shopping sales in 2011 (4)

• 10.8%: people who used a mobile device to visit a retailer’s site on Cyber Monday (up from 3.9% in 2010) (4)

MOBILE WEBSOME STATISTICS

“Manufacturers shipped more smartphones than personal

computers in the fourth quarter of 2010... crowning

mobile devices as the computing platform of choice.

Financial Times Article, February 2011

MOBILE WEBMOVE OVER PCS

• In a Mall Kiosk in Ft. Lauderdale, Florida:

MOBILE WEBSEEN IN UNUSUAL PLACES

HTML5WHAT YOU NEED TO KNOW

Big Picture: Canvas, Video, Geolocation and Offline Web Apps

Big Picture: IE Still Sucks! Who owns a windows phone anyways? :-)

• Simplified header and doctype: <!DOCTYPE html>

• Script tag doesn’t need type attribute

• Many more semantic tags added like header, nav, section, article, aside, footer, details, summary, address, figure, output, time, pubdate, nav, first, last, next, prev, menu, command, mark, strong, progress, meter and many, many more

• Data attributes (data-*)

• Media Tags

• Native GeoLocation API for Mobile Browsers

• 2D Graphics with Canvas

• Many new form input types

• Datalist

• Markup-driven form validation

• Local Storage, Web Sockets, Web Workers

THE ROAD TO MOBILEBROWSER-BASED OR NATIVE?

WEB OR NATIVE?MAKING AN INFORM DECISION

• Number of Mobile Web Apps have quickly surpassed their native counterparts

Taptu predicts that "the Mobile Touch Web will grow... and will approach the quality .. of [Native] Apps across all the

app categories except for games."

From “Mobile App or Browser-Based Site? Report Says The Browser Will Win on Mobile”February 2010, ReadWriteWeb.com

Factor Native Web

# of target devices

More Devices == More Projects, Inconsistencies between products

One codebase (with small tweaks) to rule them all

distribution Application Stores Processes/Charge Upfront :-) Instant

time to market Slow! Faster for simpler applications

developer skills Specialized UI developer skills: iOS, Android, etc. HTML/JavaScript/CSS + Frameworks

multimedia Audio/Video/ 2D and 3D graphics more accessible from native APIs

HTML 5 Video / Canvas coming along, WebGL future uncertain(1)

device integrationTouch Gestures / Accelerometer / Gyroscope / Camera / Geo-

location / File System / System Alerts more/only accessible from native APIs

Hacks abound to make some of these work

audiencegamers, selective downloaders (only download if app provides significant advantages of others) and the “only if I can have an

icon for it” crowd

anybody with a browser that it is inclined to use it!

• If your application core relies on 3D, File System, Camera, Mobile Security, System Alerts, Marketplace, Performance go Native

• If your application success hinges on ease of deployment and distribution, deeply linked pages, social media and constant updates/changes then go Web

• Factors that are improving and/or are close to match their native counterparts include audio, video, 2D graphics, input and gestures, accelerometer and gyroscope, geolocation and native-like application launcher

... and there is always the hybrid approach!

build it for the Web, convert it to Native

http://rhomobile.com/https://webmynd.com/http://phonegap.com/http://appcelerator.com/

DEVELOPMENT APPROACHWHERE TO START?

• Server-side developers gravitate to fleshing out the API first

• Client-side developers start with the look and feel

• After trying both I’ve decided that it is best to start at both ends and meet in the middle :-)

APPROACHWHERE TO START?

SINATRATHE LIGHTWEIGHT HTTP RUBY DSL

• Why?

• Rails might be too heavy for our purposes

• You will/might need to support native clients

• API-driven and JSON is the payload

SINATRAA LIGHTWEIGHT SERVER SIDE ALTERNATIVE

• Multiple mini-apps in one process...

map '/' do run Comida::ComidaWebAppend

map '/api' do run Comida::ComidaApiend

module Comida # # The Web App # class ComidaWebApp < Sinatra::Base ... end # # The API # class ComidaApi < Sinatra::Base ... endend

• I wanted simple templates that I could render on the client and on the server

• No Ruby in my views, no markup in my Ruby!

MUSTACHELOGIC-LESS TEMPLATES

• Classy with logic less templates...

SINATRA W/ MUSTACHEA LIGHTWEIGHT SERVER SIDE ALTERNATIVE

• Render a mustache template (with a layout too).

class ComidaWebApp < Sinatra::Base register Mustache::Sinatra require './views/layout'

get '/' do mustache :search end

template/search.mustache

<section data-role="page" id="search_results"> <header data-role="header"> <h1>Resturants</h1> <nav data-role="navbar"> <ul> <li><a href="#home" class="ui-btn-active">Search</a></li> <li><a href="#menu">Menus</a></li> <li><a href="#order">Order</a></li> </ul> </nav> </header> <div data-role="content" id="content_main"> <form action="/api/menus.json" method="get" data-ajax="false" id="restaurant_selection_form"> <div id="restaurants_found"></div> <button type="submit" data-theme="a">Submit</button> </form> </div></section>

SINATRA W/ MUSTACHEA LIGHTWEIGHT SERVER SIDE ALTERNATIVE

template/search_result_page.mustache

• Simple API with Sinatra...

get '/search.json' do response = {} response[:restaurants] = restaurants content_type :json response.to_jsonend

• Let’s explore the sample’s app API with IRB and CURL

JQUERY MOBILEA JQUERY-DRIVEN USER INTERFACE FRAMEWORK

• A lightweight markup-driven User Interface (UI) framework for mobile web applications

• Build on JavaScript and making extensive use of the jQuery JavaScript Library (about 12K minified)

• Promotes the use of clean, semantic HTML that gets enhanced progressively and degrades gracefully if needed

• Supports a large variety of hardware and device features

• Supports Accessible Rich Internet Applications (WAI-ARIA)

• Theme-able following the ThemeRoller philosophy of jQuery UI

JQUERY MOBILEINTRODUCTION

• To start on your path to web development for mobile devices you’ll need:

• Editor: An editor capable of dealing with HTML, CSS and JavaScript and potentially with your server-side language/platform/framework of choice

• Emulation/Simulation: A way to emulate the different devices and resolutions that your application/website wants to target

• Debugging: For more complex applications the ability to debug, trace and analyze JavaScript code

JQUERY MOBILESETTING YOUR DEVELOPMENT ENVIRONMENT

SIMULATION, EMULATION & LIVE TESTING

WHAT TO DO WHEN

• The Mobile Web Development cycle involves coding, previewing often on a regular desktop/laptop web browser and interspersed testing on a particular device emulator or on the target device itself* (particularly to test the feel of any gesture based interaction, device orientation changes and

other features that can only be experienced on the device itself)

• The simplest way to test is to run a local Web Server on your development machine and access the application over a WIFI network

JQUERY MOBILEEMULATION CHOICES

• The Android SDK (http://developer.android.com) includes a device emulator that can support many Android Virtual Devices (AVDs).

JQUERY MOBILETHE ANDROID EMULATOR

• The iOS Simulator (http://developer.apple.com/programs/ios/) is tucked away in Apple’s free iPhone Software Development Kit

JQUERY MOBILETHE ANDROID EMULATOR

The iOS simulator can be found under /Developer/Platforms/iPhoneSimulator.platform/Developer/Applications and it is aptly named “iOS Simulator”

PAGESTHE BUILDING BLOCKS OF A MOBILE APPLICATION

• Let’s open the example_1.html page in Safari (5.1.2 shown below) at 1024x768:

part_1/example_1.html

jQuery Mobile applications can also be

used on desktop, laptops and tablets

JQUERY MOBILEEMULATING A DEVICE

• In Safari (5.1.2) at 640x960 (iPhone 4 resolution):

The iPhone, iPad and iPods use a mobile version of Safari so desktop Safari at iPhone/

iPad resolutions is a perfect browser for rapid development

• On the Android Emulator :

• On the iOS Emulator :

• On the iPhone 4:

• On the iPad

• The basic document contains a single Page with a Title and a Body showing some simple content

• jQuery Mobile Documents can contain one or more mobile pages as well explore later in the course

• The HTML document source is shown below:

JQUERY MOBILEGETTING STARTED

<!DOCTYPE html> <html> <head> <title>Browser Page Title</title> <meta name="viewport" content="width=device-width, initial-scale=1"> <link rel="stylesheet" href="http://code.jquery.com/mobile/1.0/jquery.mobile-1.0.min.css" /> <script type="text/javascript" src="http://code.jquery.com/jquery-1.6.4.min.js"></script> <script type="text/javascript" src="http://code.jquery.com/mobile/1.0/jquery.mobile-1.0.min.js"></script></head> <body>

<div data-role="header"> <h1>Page Title</h1> </div>

<div data-role="content"> <p>This is the content</p> </div>

</div>

</body></html>

• The body of the document consists of several div elements

• The div are decorated with HTML5 data-role attributes

• The outer div has a role of page and contains two stacked inner divs with the roles header and content

JQUERY MOBILEGETTING STARTED

<div data-role="header"> <h1>Page Title</h1> </div>

<div data-role="content"> <p>This is the content</p> </div>

</div>

</body></html>

• The link tag applies the jQuery Mobile CSS stylesheet to the document

• Commenting out the CSS reveals the simplicity of the underlying markup

MULTI-PAGE DOCUMENTSINLINE PAGES

MULTI-PAGE DOCSA DOCUMENT WITH A COUPLE OF PAGES

<div data-role="content"> <p>This is the home page</p> </div> <div data-role="footer" data-position="fixed"> <h4>The Footer</h4> </div>

</div>

<div data-role="header"> <h1>Other</h1> </div>

<div data-role="content"> <p>This is another page</p> </div> <div data-role="footer" data-position="fixed"> <h4>The Footer</h4> </div>

</div>part_1/example_2.html

MULTI-PAGE DOCSLOCATION HASH BASED NAVIGATION

http://.../part_1/example_2.html http://.../part_1/example_2.html#other

• HTML5 provides the window.location.hash which is exploited by jQuery Mobile to provide navigation to individual pages within a multi-page document

• Adding #other to the URL will navigate to the “other” page using the default transition (slide)

MULTI-PAGE DOCSLINKING PAGES

<div data-role="content"> <p>This is the home page</p> <p>Check out this <a href="#other">other</a> page</p> </div> <div data-role="footer" data-position="fixed"> <h4>The Footer</h4> </div>

</div>

• Let’s fill add navigation links to the other page from the home page and vice-versa:

<div data-role="content"> <p>This is another page</p> <p>Take me <a href="#home">back!</a></p> </div> <div data-role="footer" data-position="fixed"> <h4>The Footer</h4> </div>

</div>

MULTI-PAGE DOCSBACK LINKS

• A generic way to create a link to the previous page (without adding a new entry to the browser history) is to use the data-rel= “back” attribute as shown below:

<div data-role="content"> <p>This is another page</p> <p>Take me <a href="#home" data-rel="back">back!</a></p> </div> <div data-role="footer" data-position="fixed"> <h4>The Footer</h4> </div>

</div>

MULTI-PAGE DOCSA DOCUMENT WITH A COUPLE OF PAGES

• We can now navigate from #home to #other and back:

PAGE TRANSITIONSANIMATION BASED NAVIGATION

<div data-role="content"> <p>This is the home page</p> <p>Check out this <a href="#other" data-transition="flip">other</a> page</p> </div>

• So far we have seen the default ‘slide’ transition when navigating from page to page

• jQuery Mobile provides several transitions that we can apply via the data-transition attribute

• Let’s modify the link to the “other” page to use the “flip” transition animation

PAGE TRANSITIONSANIMATION BASED NAVIGATION

• The ‘flip’ transition animation in action:

BUTTONSSTYLIZED BUTTONS

<div data-role="header"> <a href="#home" data-role="button" data-rel="back" data-icon="back" >Back</a> <h1>Other</h1> </div>

• jQuery Mobile provides a “button” data-role attribute that can be applied to a link to turn it into a nicely styled button

• Let’s add a back button link to our “other” page

BUTTONSSTYLIZED BUTTONS

• The newly added back button:

LIST VIEWSSTYLING ORDERED OR UNORDERED LISTS

<div data-role="page" id="other"> ... <div data-role="content"> <h3>Unordered List</h3> <ul data-role="listview"> <li>Apples</li> <li>Oranges</li> <li>Peaches</li> </ul> <h3>Ordered List</h3> <ol data-role="listview"> <li>Woke up</li> <li>Fell out of bed</li> <li>Dragged a comb across my head</li> </ol> </div> ...</div>

• jQuery Mobile provides a “listview” data-role attribute that can turn an ordered or unordered list into a nicely styled native looking list

• Let’s modify the “other” page to show a couple of lists

• The styled lists on the ‘other’ page:

LIST VIEWSSTYLING ORDERED OR UNORDERED LISTS

• The beginnings of a mobile website for a restaurant

• On the home page we want to display the restaurant’s name and a logo alongside some welcome text and a button link to a “menu” page

• On the menu page we will display a list of menu items and a back button to the home page

DEMO 1.0LAUNCHING THE RESTAURANT MOBILE SITE

APPLICATION INITIALIZATION

USING THE JQUERY PLUGIN PATTERN

INITIALIZATIONUSING THE JQUERY PLUGIN PATTERN WITH JQUERY MOBILE

• Finally we can initialize the application by calling the initApp function from within a document ready handler function:

INITIALIZATIONUSING THE JQUERY PLUGIN PATTERN WITH JQUERY MOBILE

MVC IN JAVASCRIPTINTRODUCING SPINE.JS

SPINE.JSMVC FOR JAVASCRIPT

• Spine.js is a small library provides a micro-MVC framework for your JavaScript applications

• It allow you to create a separation between the model (business JavaScript code) and the view (which renders the DOM)

• When models change their associated views are re-rendered without tightly coupling them to the DOM

• Spine.js keeps state/model in a single space, model changes propagate automatically to the views with very little glue code

JQUERY SHOPPING CART

• Let’s walk through the code of a jQuery powered shopping cart from the ground up

• The markup consists of two lists styled to appear side-by-side and an element showing the total amount of the items in the shopping cart

• Each retail item will be represented by a div containing an image (drag handle), encode the item price in the div

• As items are dragged into the cart, use an effect to alert the user of the cart total amount changes

• The non-visual JS code uses the prototype pattern to separate the UI interactions from the business interactions

• As items are dropped into the cart, add controls to the items to increase the quantity

JQUERY SHOPPING CARTDRAG AND DROP SHOPPING CART

• The jQuery powered Shopping Cart project structure is shown below:

• jQuery Shopping Cart in action:

• At first glance the implementation of the shopping cart seems to work as advertised and even seems well thought- out. That is, until we start asking the hard questions.

• Shortcoming of the jQuery Shopping Cart:

• From the usability point of view, the first thing that jumps to mind is, what happens when the user clicks the refresh button?

• Since everything is just being kept in memory the answer is that it simply goes away

• Shortcoming of the jQuery Shopping Cart (cont.):

• For anything more complex we would end up with an unmanageable mess of UI callbacks all of which are currently living in the global JavaScript scope.

• Another problem glaring problem is the coupling of the concepts of the shopping cart and the items in the shopping cart.

• The items are simple JavaScript objects with no behavior, their reflection on the UI is controlled by the decorateForCart function

• Spine.js is partly based on Backbone’s API yet Spine’s take on the MVC pattern is slightly different

• I used Spine.js to refactor the jQuery Shopping Cart

• Problems I wanted to fix on the shopping cart solution:

• Using the back button or the refresh button loses the carts contents

• UI callbacks and manual event handling and triggering can quickly get out of hand

• Models: In Spine, models are created using the setup method of Spine.Model, which takes the name of the model and an array of properties

// Create the Item model.var Item = Spine.Model.sub();Item.configure("Item", "name", "pid", "price", "quantity");

part_2/examples/jquery-spine-shopping-cart/app/models/item.js

• To make the model persists between page reloads we extend the Item with the Spine.Model.Local module

// Persist model between page reloads.Item.extend(Spine.Model.Local);

• The extend method adds class properties to the model. We now have an object that can be created, saved and retrieved from the browser local storage.

• To add behavior to our model we use the include method which adds instance properties

• The four methods that we need for our Item model; increase, decrease, total and label

// Instance methodsItem.include({ // total: function() { return (this.price * this.quantity); }, // increase: function(quantity) { quantity = (typeof(quantity) != 'undefined') ? quantity : 1; this.quantity = this.quantity + quantity; this.save(); }, // decrease: function(quantity) { quantity = (typeof(quantity) != 'undefined') ? quantity : 1; if (this.quantity >= quantity) { this.quantity = this.quantity - quantity; } else { this.quantity = 0; } this.save(); }, // label: function() { return (this.name + " - $" + this.price); } });

• To instantiate an Item we use the create method which takes an object literal for the parameters. A new model can be persisted using the save method. When a model is saved it is assigned an identifier that can be retrieved via the id property.

var item = new Item({name: "Product 1", pid: "0001" , price: 100.0, quantity: 1});item.save();alert("Just saved Item with id => " + item.id);

• Controllers: Controllers in Spine are a combination of a traditional MVC controller and a view. Therefore controllers are in charge of rendering and manipulating one or more models in the context of controller’s functionality

• Our first Spine controller will deal with the rendering and manipulation of an individual Item. The CartItem controller will deal with user interface events to increase and decrease the quantity of a Item while keeping the user abreast of the changes.

• Spine controllers like the CartItem are created using the create method of Spine.Controller, which takes an object literal that a wide variety of properties

jQuery(function($){ window.CartItem = Spine.Controller.sub({ init: function(){ var cartItem = this; this.item.bind("quantityChanged", function() { cartItem.updateQty() }); $('#item_' + this.item.pid + ' .add').live('click', function(e) { cartItem.add(); e.preventDefault(); }); $('#item_' + this.item.pid + ' .remove').live('click', function(e) { cartItem.remove(); e.preventDefault(); }); },

part_2/examples/jquery-spine-shopping-cart/app/controllers/cart_item.js

• ... cont.

render: function(){ this.el = $.mustache($("#cartItem").html(), this.item); return this; }, // event handlers add: function(e) { this.item.increase(); }, remove: function(e) { this.item.decrease(); }, // ui methods updateQty: function() { $('#item_' + this.item.pid + ' #qty') .text(this.item.quantity) .effect("highlight", {}, 1500); } });})

part_2/examples/jquery-spine-shopping-cart/app/controllers/cart_item.js

• The cartItem template is a Mustache.js Template that enables the creation of markup templates containing binding expressions. The mustache method clones the template contents and replaces the binding expressions ({{exp}}) with the values of the object passed, in our case the controller’s enclosed Item model.

<script type="text/x-mustache-tmpl" id="cartItem"> <li class="product ui-state-default" id="item_{{pid}}" price="{{price}}"> {{label}} (<span id="qty">{{quantity}}</span>) <a href="#" class="add">+</a> <a href="#" class="remove">-</a> </li></script>

part_2/examples/jquery-spine-shopping-cart/shopping_cart.html

• To test our controller we need to instantiate an Item model and use it to instantiate the controller. We can then render the controller on the DOM of an HTML page

var item = new Item({name: "Product 1", pid: "0001" , price: 100.0, quantity: 1});var view = new CartItem({item: item});$("#item").html(view.render().el);

part_2/examples/jquery-spine-shopping-cart/tests/cart_item_test.html

• The ShoppingCart controller which will manage a collection of Item models. Internally the ShoppingCart keeps the items dropped in the items property

• The clear, total, isEmpty and itemsCount methods fulfill the business functionality of the cart

jQuery(function($){ window.ShoppingCart = Spine.Controller.sub({ el: $("#theCart"), init: function() { var cart = this; this.items = {}; $.each(Item.all(), function(){ cart.addItem(this); }); this.el.droppable({ accept: '.product', drop: this.proxy(this.drop) }); $('#dump', this.el).live('click', function() { cart.clear(); }); }, // removes all items from the cart clear: function() { $.each(this.items, function(){ this.destroy(); }); this.items = {}; this.updateCartTotal(); }, total: function() { var sum = 0.0; $.each(this.items, function(){ sum += this.total(); });

return sum; }, isEmpty: function() { return this.itemsCount() == 0; }, itemsCount: function() { var size = 0; var items = this.items; $.each(items, function(){ if (items.hasOwnProperty(this)) size++; });

return size; }, ...

part_2/examples/jquery-spine-shopping-cart/app/controllers/shopping_cart.js

...drop: function(ev, ui) { var item_dropped = ui.draggable; var pid = item_dropped.attr('id'); var price = item_dropped.attr('price'); var name = item_dropped.attr('name');

if (this.items.hasOwnProperty(pid)) { this.items[pid].increase(); } else { var item = Item.create({name: name, pid: pid, price: price, quantity: 1}); this.addItem(item); $(".items").append(CartItem.init({item: item}).render().el); }},

• The drop method handles drop events; it either creates a new item or increases the quantity of an existing item. It creates an Item model that is then rendered using the CartItem controller

...render: function() { this.el.html($.mustache($("#shoppingCart").html(), {})); $('#dump').button();

$.each(this.items, function(){ $(".items").append(CartItem.init({item: this}).render().el); }); this.updateCartTotal();},

• The render method render the #shoppingCart template, decorates the #dump button and loops through the contained Items creating a CartItem for each and rendering them in the .items

• The removeItem, updateCartTotal, removeIfQuantityZero and addItem deal with responding to UI events and updating the UI

...removeItem: function(item) { $('#item_' + item.pid).effect("puff", {}, "slow", function(){ $(this).remove(); });},

updateCartTotal: function() { $('#total').text(this.total()).effect("highlight", {}, 1500);},

removeIfQuantityZero: function(item) { if (item.quantity == 0) { this.removeItem(item); delete this.items[item.pid]; item.destroy(); }},

addItem: function(item) { this.items[item.pid] = item; item.bind("quantityChanged", this.proxy(this.updateCartTotal)); item.bind("quantityChanged", this.proxy(this.removeIfQuantityZero));item.bind("quantityChanged", function() { item.save() }); item.bind("destroy", this.proxy(this.removeItem)); item.save(); this.updateCartTotal();}

part_4/examples/jquery-spine-shopping-cart/app/application.js

• Finally to kick everything in motion the file application.js file begins by fetching any previously stored Item records, making the sample products draggable, creating a cart and rendering it.

jQuery(function($){ Item.fetch(); $(".product").draggable({ helper: 'clone', opacity: "0.5" }); var cart = new ShoppingCart(); cart.render();});

RESOURCES

RESOURCES• Sinatra: http://www.sinatrarb.com/

• jQuery Mobile: http://jquerymobile.com

• Spine.js: http://spinejs.com

• Example Code:

• https://github.com/bsbodden/jquery-shopping-cart

• https://github.com/bsbodden/jquery-spine-shopping-cart

• https://github.com/integrallis/jqm-spine-sinatra-demo

Road to mobile w/ Sinatra, jQuery Mobile, Spine.js and Mustache

Technology