What's included?

There's more!

Who's responsible?

Getting started with Flatiron

$ [sudo] npm install flatiron -g

$ flatiron create <app-name> <type>

  {
    "name": "your-application",
    "dependencies": {
      "flatiron": "*"
    }
  }

$ cd /path/to/your/app
$ npm install

URL Routing with Director

  var flatiron = require('flatiron'),
       app = flatiron.app;
  
  app.use(flatiron.plugins.cli, {
    // CLI options
  });
  
  //
  // app.router is now available. app.cmd is also available
  // as a shortcut for creating routes
  //
  app.cmd('version', function () {
    console.log('flatiron ' + flatiron.version);
  });

  var flatiron = require('flatiron'),
      app = flatiron.app;
  
  app.use(flatiron.plugins.http, {
    // HTTP options
  });
  
  //
  // app.router is now available. app[HTTP-VERB] is also available
  // as a shortcut for creating routes
  //
  app.router.get('/version', function () {
    this.res.writeHead(200, { 'Content-Type': 'text/plain' })
    this.res.end('flatiron ' + flatiron.version);
  });
  
  app.start(8080);

 var routes = {
  '/authors': {
    on: showAuthor,
    '/books': { on: [showCover, showDescription] },
    '/bios': { on: [showPicture, showBiography] }
  }
};

var router = Router(routes);

//
// require the native http module, as well as director.
//
var http = require('http'),
    director = require('director');

//
// for the sake of example, lets actually define one of the
// functions that might be called from in a routing table.
//
function showAuthor() {
  this.res.writeHead(200, { 'Content-Type': 'text/plain' })
  this.res.end('Carl Sagan');
}

var routes = {
  '/authors': {
    on: showAuthor,
    '/books': { on: [showCover, showDescription] },
    '/bios': { on: [showPicture, showBiography] }
  }
};

//
// define a routing table.
//
var router = new director.http.Router(routes);

//
// setup a server and when there is a request, dispatch the
// route that was requestd in the request object.
//
var server = http.createServer(function (req, res) {
  router.dispatch(req, res, function (err) {
    if (err) {
      res.writeHead(404);
      res.end();
    }
  });
});

//
// You can also do ad-hoc routing, similar to `journey` or `express`.
// This can be done with a string or a regexp.
//
router.get('/bonjour', helloWorld);
router.get(/hola/, helloWorld);

//
// set the server to listen on port `8080`.
//
server.listen(8080);

Templating with Plates

  var plates = require('plates');

var plates = require('plates');

var html = '<div id="test">Old Value</div>';
var data = { "test": "New Value" };

var output = plates.bind(html, data); 

var html = '<span>User</span>...<span>User</span>';

var data = { "username": "John Smith" };
var map = plates.Map();

map.class('name').to('username');

console.log(plates.bind(html, data, map));

var html = '<a class="/"></a>';

var data = { "newurl": "www.nodejitsu.com" };
var map = plates.Map();

map.where('href').is('/').insert('newurl');

console.log(plates.bind(html, data, map));

var html = '<a class="/"></a>';

var data = { "imageurl": "www.nodejitsu.com" };
var map = plates.Map();

map.where('data-foo').is('bar').use('imageurl').as('src');

console.log(plates.bind(html, data, map));

Data Management with Resourceful

  var resourceful = require('resourceful');

var Creature = resourceful.define('creature');

Creature.property('diet'); // Defaults to String
Creature.property('vertebrate', Boolean);
Creature.property('belly', Array);

Creature.prototype.feed = function (food) {
  this.belly.push(food);
};

var wolf = new Creature({
  diet:      'carnivor',
  vertebrate: true
});

wolf.feed('squirrel');
console.dir(wolf.belly);
// ['squirrel']

Middleware with Union

  var flatiron = require('flatiron'),
      app = flatiron.app;
  
  app.use(flatiron.plugins.http, {
    //
    // List of middleware to use before dispatching 
    // to app.router
    //
    before: [],
    //
    // List of Streams to execute on the response pipeline 
    //
    after: []
  });
  
  //
  // Both app.listen(port, [host,] callback) and 
  // app.start(port, [host,] callback) are now attached 
  // to your application. app.start() will automatically 
  // call app.listen() after calling app.init().
  //
  app.listen(8000, function () {
    console.log('Application is now started on port 8000');
  });

//
// for the sake of this example, lets define a function to represent our
// middleware. Your middleware would likely be a more complex module.
//
function middleware1(req, res) {
  if(~req.url.indexOf('foo')) {
    return false;
  }
}

var server = union.createServer({
  before: [
    middleware1
  ]
});

router.get(/foo/, function () {
  this.res.writeHead(200, { 'Content-Type': 'text/plain' });
  this.res.end('never sent\n');
});

Plugins with Broadway

  var flatiron = require('flatiron'),
      app = flatiron.app;

  var customPlugin = {
    name: 'custom-plugin',
    attach: function (options) {
      //
      // Extend the application
      //
      app.yourCustomMethod = function () {
        
      };
    },
    init: function (done) {
      //
      // Initialize anything your plugin needs,
      // asynchronously if necessary, then call done().
      //
      done();
    }
  };
  
  app.use(customPlugin);

var plugin = {
  "name": "example-plugin", // Plugin's name

  "attach": function attach(options) {
    // Called with plugin options once plugin attached to application
    // `this` - is a reference to application
  },

  "detach": function detach() {
    // Called when plugin detached from application
    // (Only if plugin with same name was attached)
    // `this` - is a reference to application
  }

  "init": function init(callback) {
    // Called on application initialization
    // App#init(callback) called once every plugin will call `callback`
    // `this` - is a reference to application
  }
};

Logging with Winston

  var flatiron = require('flatiron'),
      app = flatiron.app;

  app.log.info('Logging to my flatiron application', {
    with: 'custom metadata'
  });

var winston = require('winston');

winston.log('info', 'Hello distributed log files!');
winston.info('Hello again distributed logs');

winston.add(winston.transports.File, { filename: 'somefile.log' });
winston.remove(winston.transports.Console);