{{title}}
51 |-
52 | {{#timbits}}
53 |
- {{.}} » 54 | {{/timbits}} 55 |
407 |
408 |
409 |
410 | Any valid media query will do. In fact, we also will respond to media query changes (including orientation!) so that as you resize the browser, any csi elements that were skipped due to unmet media queries will load once the media query is valid.
411 |
412 | A couple caveats you should be aware of. First, we will load csi includes based on the media query, but we won't unload them. Secondly, since we depend on the window.matchMedia() method, this doesn't work across all browsers. Specifically Opera, and IE9 or below. On these browsers, timbits csi will ignore the media queries and load each and every include. So you should still use CSS media queries to show/hide elements as if all the content was loaded.
413 |
414 | ### Wordpress Plugin
415 |
416 | For those of you who would like to utilize Timbits within your Wordpress environment, we've created a plugin for that called [wp-timbits](https://github.com/Postmedia/wp-timbits) which provides shortcode and widget support, supports Timbits' auto-discovery feature, includes the csi rendering library (with media query support) and has the ability to turn your Wordpress instance into a Timbits server.
417 |
418 | ## Road Map
419 |
420 | We have a number of items in the pipeline which we believe will provide a lot of power to this platform, such as:
421 |
422 | * Integrated benchmarks
423 | * Real-time data updates via Socket.IO
424 |
425 |
426 | ## Created by
427 |
428 | * Edward de Groot
429 | * Keith Benedict
430 | * Donnie Marges
431 | * Stephen Veerman
432 | * Kevin Gamble
433 |
--------------------------------------------------------------------------------
/bin/template/History.md:
--------------------------------------------------------------------------------
1 | 0.0.1 / current date
2 | ====================
3 |
4 | * Created new Timbits project
5 |
--------------------------------------------------------------------------------
/bin/template/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 20XX [Some Company]
2 |
--------------------------------------------------------------------------------
/bin/template/README.md:
--------------------------------------------------------------------------------
1 | # Timbits
2 | Built using [Timbits](http://github/com/postmedia/timbits)
3 |
4 |
--------------------------------------------------------------------------------
/bin/template/server.js:
--------------------------------------------------------------------------------
1 | var timbits = require('timbits');
2 | var server = timbits.serve();
3 | console.log("Press Ctrl+C to Exit");
--------------------------------------------------------------------------------
/bin/template/server_coffee.js:
--------------------------------------------------------------------------------
1 | require('coffee-script');
2 | var timbits = require('timbits');
3 | var server = timbits.serve();
4 | console.log("Press Ctrl+C to Exit");
--------------------------------------------------------------------------------
/bin/template/test/timbits-test.coffee:
--------------------------------------------------------------------------------
1 | # reduce logging levels to provide clean test feedback
2 | process.env.TIMBITS_VERBOSITY = 'critical'
3 | process.env.PANTRY_VERBOSITY = 'critical'
4 |
5 | # Module dependencies.
6 | timbits = require 'timbits'
7 | should = require 'timbits/node_modules/should'
8 | request = require 'timbits/node_modules/request'
9 |
10 | # should http extensions
11 | require 'timbits/node_modules/should-http'
12 |
13 | port = 8785
14 | alltests = process.env.TIMBITS_TEST_WHICH is 'all'
15 |
16 | server = timbits.serve( {port: port })
17 |
18 | validateRequest = (method, vpath, expect = 'html') ->
19 | describe vpath, ->
20 | test_msg = "should respond with #{expect} and status 200"
21 | if typeof expect isnt 'string'
22 | test_msg = "should respond with status #{expect}"
23 |
24 | it test_msg, (done) ->
25 | if method is "GET"
26 | request "http://localhost:#{port}#{vpath}", (err, res) ->
27 | should.not.exist err
28 | if typeof expect is 'string'
29 | res.should.have.status 200
30 | if expect is 'json'
31 | res.should.be.json
32 | else
33 | res.should.be.html
34 | else
35 | res.should.have.status expect
36 | done()
37 | else if method is "POST"
38 | request.post "http://localhost:#{port}#{vpath}", (err, res) ->
39 | should.not.exist err
40 | if typeof expect is 'string'
41 | res.should.have.status 200
42 | if expect is 'json'
43 | res.should.be.json
44 | else
45 | res.should.be.html
46 | else
47 | res.should.have.status expect
48 | done()
49 |
50 |
51 | describe 'timbits', ->
52 |
53 | describe 'automated test cases', ->
54 | for name, timbit of timbits.box
55 | if timbit.examples? and timbit.methods["GET"]
56 | describe "specified examples for #{name}", ->
57 | for example in timbit.examples
58 | validateRequest "GET", example.href
59 |
60 | if timbit.examples? and timbit.methods["POST"]
61 | describe "specified examples for #{name}", ->
62 | for example in timbit.examples
63 | validateRequest "POST", example.href
64 |
65 | dynatests = timbit.generateTests(alltests)
66 | if dynatests.length
67 | describe "dynamic tests for #{name}", ->
68 | for href in dynatests
69 | validateRequest "GET", href if timbit.methods["GET"]
70 | validateRequest "POST", href if timbit.methods["POST"]
71 |
72 |
--------------------------------------------------------------------------------
/bin/template/test/timbits-test.js:
--------------------------------------------------------------------------------
1 | // reduce logging levels to provide clean test feedback
2 | process.env.TIMBITS_VERBOSITY = 'critical';
3 | process.env.PANTRY_VERBOSITY = 'critical';
4 |
5 | // load modules
6 | var timbits = require('../lib/timbits')
7 | , should = require('should')
8 | , path = require('path')
9 | , request = require('request')
10 |
11 | // load hhtp extensions for should
12 | require('should-http');
13 |
14 | // set testing environment
15 | var port = 8785
16 | , alltests = process.env.TIMBITS_TEST_WHICH === 'all';
17 |
18 | // create test server
19 | var server = timbits.serve({
20 | home: process.cwd(),
21 | port: port,
22 | verbosity: 'critical'
23 | });
24 |
25 |
26 | // helper function for testing requests
27 | function validateRequest(method, vpath, expect) {
28 | expect = expect || 'html';
29 |
30 | describe(vpath, function() {
31 | var test_msg = "should respond with " + expect + " and status 200";
32 | if (typeof expect !== 'string')
33 | test_msg = "should respond with status " + expect;
34 |
35 | it(test_msg, function(done) {
36 | if (method=="GET") {
37 | request("http://localhost:" + port + vpath, function(err, res) {
38 | should.not.exist(err);
39 | if (typeof expect === 'string') {
40 | res.should.have.status(200);
41 | if (expect === 'json')
42 | res.should.be.json;
43 | else
44 | res.should.be.html;
45 | } else {
46 | res.should.have.status(expect);
47 | }
48 | done();
49 | });
50 | }
51 | else if (method=="POST") {
52 | request.post("http://localhost:" + port + vpath, function(err, res) {
53 | should.not.exist(err);
54 | if (typeof expect === 'string') {
55 | res.should.have.status(200);
56 | if (expect === 'json')
57 | res.should.be.json;
58 | else
59 | res.should.be.html;
60 | } else {
61 | res.should.have.status(expect);
62 | }
63 | done();
64 | });
65 | }
66 | });
67 | });
68 | };
69 |
70 |
71 | describe('timbits', function() {
72 | describe('automated test cases', function() {
73 | for (name in timbits.box) {
74 |
75 | timbit = timbits.box[name];
76 |
77 | // GET requests
78 | if (timbit.examples != null && timbit.methods['GET']) {
79 | describe('specified examples for ' + name, function() {
80 | timbit.examples.forEach(function(example) {
81 | validateRequest('GET', example.href);
82 | });
83 | });
84 | }
85 | // Post Requests
86 | if (timbit.examples != null && timbit.methods['POST']) {
87 | describe('specified examples for ' + name, function() {
88 | timbit.examples.forEach(function(example) {
89 | validateRequest('POST', example.href);
90 | });
91 | });
92 | }
93 |
94 | var dynatests = timbit.generateTests(alltests);
95 | if (dynatests.length) {
96 | describe("dynamic tests for " + name, function() {
97 | dynatests.forEach(function(href) {
98 | if (timbit.methods['GET'])
99 | validateRequest('GET', href);
100 | if (timbit.methods['POST'])
101 | validateRequest('POST', href);
102 | });
103 | });
104 | }
105 | }
106 | });
107 | });
--------------------------------------------------------------------------------
/bin/template/timbit.coffee:
--------------------------------------------------------------------------------
1 | # Timbit
2 |
3 | # load the timbits module
4 | timbits = require 'timbits'
5 |
6 | # create and export the timbit
7 | timbit = module.exports = new timbits.Timbit()
8 |
9 | # additional timbit implementation code follows...
10 |
11 | #timbit.about = 'a description about this timbit'
12 |
13 | #timbit.examples = [
14 | # {href: '/timbit/?q=winning', caption: 'Default View'}
15 | # {href: '/timbit/alternate?q=winning', caption: 'Alternate View'}
16 | #]
17 |
18 | #timbit.params = {
19 | # q: {description: 'Keyword to search for',required: true, strict: false, values: ['Coffee', 'Timbits']}
20 | #}
21 |
22 | timbit.eat = (req, res, context) ->
23 |
24 | src = {
25 | uri: "http://jsonip.com/?q=#{context.q}"
26 | }
27 |
28 | # use the helper method to @fetch the data
29 | # @fetch will call @render once we have the data
30 | @fetch req, res, context, src
--------------------------------------------------------------------------------
/bin/template/timbit.js:
--------------------------------------------------------------------------------
1 | // Timbit
2 |
3 | // load the timbits module
4 | var timbits = require('timbits');
5 |
6 | //create and export the timbit
7 | var timbit = module.exports = new timbits.Timbit();
8 |
9 | // additional timbit implementation code follows...
10 |
11 | /*
12 | timbit.about = 'a description about this timbit';
13 |
14 | timbit.examples = [
15 | {
16 | href: '/timbit/?q=winning',
17 | caption: 'Default View'
18 | }, {
19 | href: '/timbit/alternate?q=winning',
20 | caption: 'Alternate View'
21 | }
22 | ];
23 |
24 | timbit.params = {
25 | q: {
26 | description: 'Keyword to search for',
27 | required: true,
28 | strict: false,
29 | values: ['Coffee', 'Timbits']
30 | }
31 | };
32 | */
33 |
34 | timbit.eat = function(req, res, context) {
35 | var src = {
36 | uri: 'http://jsonip.com/?q=' + context.q
37 | };
38 | timbit.fetch(req, res, context, src);
39 | };
--------------------------------------------------------------------------------
/bin/timbits:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 |
3 | // load modules
4 | var fs = require('fs')
5 | , util = require('util')
6 | , path = require('path')
7 | , spawn = require("child_process").spawn
8 | , which = require(path.join(__dirname, '..', 'node_modules', 'which')).sync;
9 |
10 | // configure optimist
11 | var optimist = require(path.join(__dirname, '..', 'node_modules', 'optimist'))
12 | .alias('coffee', 'c')
13 | .describe('c', 'language: Use coffee-script files')
14 | .alias('all', 'a')
15 | .describe('a', 'test: run all dynamic tests')
16 | .alias('R', 'reporter').string('R')
17 | .describe('R', 'test: specify reporter to use')
18 | .alias('g', 'grep').string('g')
19 | .describe('g', 'test: only run tests matching Default {{name}} Timbit View
" 222 | ); 223 | 224 | } 225 | 226 | 227 | 228 | function startServer(filename) { 229 | console.log("Starting server (" + filename + ")"); 230 | loadEnv(); 231 | 232 | spawn(localCmd('runjs'), [filename], { 233 | stdio: [null, process.stdout, process.stderr], 234 | env: process.env 235 | }); 236 | } 237 | 238 | function runTests(alltests, options) { 239 | if (alltests) { 240 | process.env.TIMBITS_TEST_WHICH = 'all'; 241 | } 242 | loadEnv(); 243 | 244 | var mocha = spawn(localCmd('mocha'), options, { 245 | stdio: [null, process.stdout, process.stderr], 246 | env: process.env 247 | }); 248 | } 249 | 250 | function getPackage() { 251 | var data = fs.readFileSync(path.join(__dirname, '..', 'package.json')); 252 | return JSON.parse(data); 253 | } 254 | 255 | function showVersion() { 256 | var pkg = getPackage(); 257 | console.log(pkg.version); 258 | } 259 | 260 | function showHelp() { 261 | console.log(optimist.help()); 262 | } 263 | 264 | var argv = optimist.argv; 265 | var ext; 266 | switch (argv._[0]) { 267 | case 'n': 268 | case 'new': 269 | if (argv._.length < 2) { 270 | console.error('\033[31mnew project requires a name\033[0m'); 271 | showHelp(); 272 | } else { 273 | if ( argv['c'] || argv['coffee'] ) { 274 | ext = 'coffee'; 275 | } else { 276 | ext = 'js'; 277 | } 278 | newProject(argv._[1], ext); 279 | } 280 | break; 281 | 282 | case 'g': 283 | case 'generate': 284 | if (argv._.length < 2) { 285 | console.error('\033[31mnew timbit requires a name\033[0m'); 286 | showHelp(); 287 | } else { 288 | if ( argv['c'] || argv['coffee'] ) { 289 | ext = 'coffee'; 290 | } else { 291 | ext = 'js'; 292 | } 293 | generateTimbit(argv._[1], ext); 294 | } 295 | break; 296 | 297 | case 's': 298 | case 'server': 299 | filename = argv._.length > 1 ? optimist.argv._[1] : 'server.js'; 300 | startServer(filename); 301 | break; 302 | 303 | case 't': 304 | case 'test': 305 | options = ['--growl', '--colors']; 306 | for (key in argv) { 307 | switch(key){ 308 | case 'reporter': 309 | case 'grep': 310 | case 'timeout': 311 | case 'slow': 312 | options.push('--' + key, argv[key]); 313 | break; 314 | case 'invert': 315 | case 'watch': 316 | case 'debug': 317 | case 'bail': 318 | options.push('--' + key) 319 | break; 320 | case 'coffee': 321 | options.push( '--compilers', 'coffee:coffee-script' ); 322 | break; 323 | } 324 | } 325 | runTests(argv.a, options); 326 | break; 327 | 328 | case 'v': 329 | case 'version': 330 | showVersion(); 331 | break; 332 | 333 | default: 334 | if (argv.v != null) { 335 | showVersion(); 336 | } else { 337 | showHelp(); 338 | } 339 | } -------------------------------------------------------------------------------- /examples/helpers/hello.js: -------------------------------------------------------------------------------- 1 | module.exports = function hello(name) { 2 | return 'Hello there ' + name; 3 | }; -------------------------------------------------------------------------------- /examples/server-redis.coffee: -------------------------------------------------------------------------------- 1 | # Module dependencies. 2 | timbits = require '../src/timbits' 3 | 4 | # use redis for caching 5 | RedisStorage = require 'pantry/lib/pantry-redis' 6 | timbits.pantry.storage = new RedisStorage(null, null, null, 'DEBUG') 7 | timbits.pantry.configure {verbosity: 'DEBUG'} 8 | 9 | # start serving timbits 10 | server = timbits.serve {home: __dirname} 11 | -------------------------------------------------------------------------------- /examples/server.js: -------------------------------------------------------------------------------- 1 | //process.env.TIMBITS_VERBOSITY = 'debug'; 2 | //process.env.PANTRY_VERBOSITY = 'debug'; 3 | 4 | var timbits = require('../lib/timbits'); 5 | var server = timbits.serve({ 6 | home: __dirname 7 | }); -------------------------------------------------------------------------------- /examples/timbits/cherry.js: -------------------------------------------------------------------------------- 1 | // Cherry Timbit 2 | 3 | // load the timbits module 4 | var timbits = require('../../lib/timbits'); 5 | 6 | // create and export the timbit 7 | var timbit = module.exports = new timbits.Timbit(); 8 | 9 | // additional timbit implementation code follows... 10 | timbit.about = '\ 11 | Example of a timbit which actually does something.\ 12 | This timbit will display the current server time.\ 13 | '; 14 | 15 | timbit.examples = [ 16 | { 17 | href: '/cherry/', 18 | caption: 'Current Time' 19 | } 20 | ]; 21 | 22 | timbit.eat = function(req, res, context) { 23 | context.now = new Date(); 24 | return this.render(req, res, context); 25 | }; -------------------------------------------------------------------------------- /examples/timbits/chocolate.js: -------------------------------------------------------------------------------- 1 | // Chocolate Timbit 2 | 3 | // load the timbits module 4 | var timbits = require('../../lib/timbits'); 5 | 6 | // create and export the timbit 7 | var timbit = module.exports = new timbits.Timbit(); 8 | 9 | // additional timbit implementation code follows... 10 | timbit.about = '\ 11 | Example of a timbit which transforms remote data.\ 12 | This timbit will query Wordpress API and display the results\ 13 | There are two views available, the default and the alternate\ 14 | '; 15 | 16 | timbit.examples = [ 17 | { 18 | href: '/chocolate/?site=sports.nationalpost.com', 19 | caption: 'Latest Sports news from The National Post' 20 | }, { 21 | href: '/chocolate/alternate-view?site=sports.nationalpost.com&tag=Hockey&number=5', 22 | caption: 'Latest five posts on Hockey from The National Post' 23 | } 24 | ]; 25 | 26 | timbit.params = { 27 | site: { 28 | description: 'The Wordpress site to query', 29 | required: true, 30 | strict: false, 31 | values: ['sports.nationalpost.com', 'o.canada.com'] 32 | }, 33 | tag: { 34 | description: 'Tag to filter by', 35 | required: false, 36 | strict: false, 37 | values: ['Hockey', 'Detroit'] 38 | }, 39 | "number": { 40 | description: 'The number of posts to display', 41 | alias: 'rpp', 42 | "default": 10, 43 | strict: false, 44 | values: [3, 5, 10] 45 | } 46 | }; 47 | 48 | timbit.eat = function(req, res, context) { 49 | 50 | // specify the data source 51 | var src = { 52 | name: 'wordpress', 53 | uri: "http://public-api.wordpress.com/rest/v1/sites/" + context.site + "/posts?number=" + context.number 54 | }; 55 | 56 | if (context.tag) { 57 | src.uri += "&tag=" + context.tag; 58 | } 59 | 60 | // use the helper method to fetch the data 61 | // timbit.fetch will call timbit.render once we have the data 62 | timbit.fetch(req, res, context, src); 63 | }; -------------------------------------------------------------------------------- /examples/timbits/dutchie.js: -------------------------------------------------------------------------------- 1 | // Dutchie Timbit 2 | 3 | // load the timbits module 4 | var timbits = require('../../lib/timbits'); 5 | 6 | // create and export the timbit 7 | var timbit = module.exports = new timbits.Timbit(); 8 | 9 | // additional timbit implementation code follows... 10 | timbit.about = '\ 11 | Example of a timbit which re-uses another timbits views\ 12 | This timbit will query Wordpress API and display the results\ 13 | This timbit re-uses the views from the chocolate timbit\ 14 | '; 15 | 16 | timbit.examples = [ 17 | { 18 | href: '/dutchie/?site=news.nationalpost.com', 19 | caption: 'Latest news from The National Post' 20 | }, { 21 | href: '/dutchie/alternate-view?site=news.nationalpost.com&tag=Apple&number=5', 22 | caption: 'Latest five news posts on Apple from The National Post' 23 | } 24 | ]; 25 | 26 | timbit.params = { 27 | site: { 28 | description: 'The Wordpress site to query', 29 | required: true, 30 | strict: false, 31 | values: ['news.nationalpost.com', 'o.canada.com'] 32 | }, 33 | tag: { 34 | description: 'Tag to filter by', 35 | required: false, 36 | strict: false, 37 | values: ['Apple', 'Canada'] 38 | }, 39 | "number": { 40 | description: 'The number of posts to display', 41 | alias: 'rpp', 42 | "default": 10, 43 | strict: false, 44 | values: [3, 5, 10] 45 | } 46 | }; 47 | 48 | // let's just re-use the chocolate timbit views and use additional cache time 49 | timbit.viewBase = 'chocolate'; 50 | timbit.maxAge = 300; 51 | 52 | timbit.eat = function(req, res, context) { 53 | 54 | // specify the data source 55 | var src = { 56 | uri: "http://public-api.wordpress.com/rest/v1/sites/" + context.site + "/posts?number=" + context.number 57 | }; 58 | 59 | if (context.tag) { 60 | src.uri += "&tag=" + context.tag; 61 | } 62 | 63 | // instead of using the fetch helper method, let's show how to use pantry directly 64 | timbits.pantry.fetch(src, function(error, results) { 65 | context.wordpress = results; 66 | timbit.render(req, res, context); 67 | }); 68 | }; -------------------------------------------------------------------------------- /examples/timbits/plain.js: -------------------------------------------------------------------------------- 1 | // Plain Timbit 2 | 3 | // Load the timbits module 4 | var timbits = require('../../lib/timbits'); 5 | 6 | // create and export the timbit 7 | var timbit = module.exports = new timbits.Timbit(); 8 | 9 | 10 | // additional timbit implementation code follows... 11 | timbit.about = '\ 12 | Example of the simplest timbit that could possibly be created.\ 13 | This timbit will simply render a view using data from the query string.\ 14 | '; 15 | 16 | timbit.examples = [ 17 | { 18 | href: '/plain/', 19 | caption: 'Anonymous' 20 | }, { 21 | href: '/plain/?who=world', 22 | caption: 'Hello World' 23 | }, { 24 | href: '/plain/?who=Kevin&retro=true', 25 | caption: 'Flashback' 26 | } 27 | ]; 28 | 29 | timbit.params = { 30 | who: { 31 | description: 'Name of person to greet', 32 | "default": 'Anonymous', 33 | multiple: false, 34 | required: false, 35 | strict: false, 36 | values: ['Ed', 'World'] 37 | }, 38 | retro: { 39 | description: 'To test multi parameters and drive Kevin crazy', 40 | type: 'Boolean' 41 | } 42 | }; -------------------------------------------------------------------------------- /examples/timbits/post.js: -------------------------------------------------------------------------------- 1 | // Timbit 2 | 3 | // load the timbits module 4 | var timbits = require('../../lib/timbits'); 5 | 6 | //create and export the timbit 7 | var timbit = module.exports = new timbits.Timbit(); 8 | 9 | // additional timbit implementation code follows... 10 | 11 | timbit.about = 'An example timbit that handles just the post event'; 12 | 13 | // Set allowed methods, by default only GET is ever allowed 14 | timbit.methods = { 'GET': false, 'POST': true }; 15 | 16 | timbit.examples = [ 17 | { 18 | href: '/post', 19 | caption: 'Default View' 20 | } 21 | ]; 22 | 23 | 24 | timbit.eat = function(req, res, context) { 25 | var body = ''; 26 | req.on( 'data', function( data ) { 27 | body += data; 28 | } ); 29 | 30 | req.on( 'end', function () { 31 | context.body = body; 32 | timbit.render( req, res, context ) 33 | }); 34 | }; -------------------------------------------------------------------------------- /examples/views/cherry/default.hjs: -------------------------------------------------------------------------------- 1 |The current server date/time is {{now}}
-------------------------------------------------------------------------------- /examples/views/chocolate/alternate-view.hjs: -------------------------------------------------------------------------------- 1 |Alternate {{name}} Timbit View
2 |Latest posts from '{{site}}'
3 | 4 |-
5 | {{#wordpress.posts}}
6 |
- {{title}} - By {{author.name}} 7 | {{/wordpress.posts}} 8 |
Default {{name}} Timbit View
2 |Latest posts from '{{site}}'
3 | 4 |-
5 | {{#wordpress.posts}}
6 |
- {{title}} 7 | {{/wordpress.posts}} 8 |
2 | {{#retro}}Wazzzzzzup{{/retro}} 3 | {{^retro}}Hello{{/retro}} 4 | {{who}} 5 |
6 | {{#retro}} 7 | 15 | {{/retro}} -------------------------------------------------------------------------------- /examples/views/post/default.hjs: -------------------------------------------------------------------------------- 1 |HTTP Post Timbit Example
2 |Send a post request with content in the body, the content is shown below the line
3 |
4 | {{body}} 5 |
--------------------------------------------------------------------------------
/lib/templates/help.hjs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | 4 | {{body}} 5 |
49 |
58 |
59 |
--------------------------------------------------------------------------------
/lib/templates/test.hjs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
50 |
57 |
36 |
93 |
94 |
--------------------------------------------------------------------------------
/lib/templates/timbit-help.hjs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | {{title}}
37 | 38 | {{#failed}} 39 |
40 | 
41 |
43 |
44 |
64 |
65 | {{/failed}}
66 |
67 | {{#passed}}
68 |
41 | Failed {{failed}} of {{results.length}}
42 || Timbit | 46 |URL | 47 |HTTP Status | 48 |Error Message | 49 |
| {{timbit}} | 56 |{{href}} | 57 |{{status}} | 58 |{{error}} | 59 |
69 | 
70 |
72 |
73 |
89 |
90 | {{/passed}}
91 |
92 |
70 | Passed {{passed}} of {{results.length}}
71 || Timbit | 75 |URL | 76 |
| {{timbit}} | 83 |{{href}} | 84 |
55 |
117 |
118 |
--------------------------------------------------------------------------------
/lib/timbits.js:
--------------------------------------------------------------------------------
1 |
2 | // load required modules
3 | var fs = require('fs')
4 | , path = require('path')
5 | , querystring = require('querystring')
6 | , url = require('url')
7 | , winston = require('winston')
8 | , express = require('express')
9 | , hogan = require('hogan.js')
10 | , request = require('request');
11 |
12 | // default configuration
13 | var config = {
14 | appName: 'Timbits',
15 | base: '',
16 | port: 5678,
17 | home: process.cwd(),
18 | maxAge: 60, // default widget output cache time
19 | engine: 'hjs', // default view engine
20 | discovery: true, // support automatic discovery via /timbits/json
21 | help: true, // allow automatic help pages at /timbits/help and /[name]/help
22 | test: true, // allow automatic test pages at /timbits/test and /[name]/test
23 | json: true, // allow built in json view at /[name]/json
24 | jsonp: true // allow jsonp calls via /[name]/json?callback=
25 | };
26 |
27 | // retrieve list of matching files in a folder
28 | function filteredFiles(folder, pattern) {
29 | var files = [];
30 |
31 | if (fs.existsSync(folder)){
32 | fs.readdirSync(folder).forEach(function(file) {
33 | if (file.match(pattern) != null)
34 | files.push(file);
35 | });
36 | }
37 | return files;
38 | }
39 |
40 | // automagically load timbits found in the ./timbits folder
41 | function loadTimbits(callback) {
42 |
43 | var folder = path.join(config.home, "/timbits");
44 | var files = filteredFiles(folder, /\.(coffee|js)$/);
45 | var pending = files.length;
46 |
47 | files.forEach(function(file) {
48 | var name = file.substring(0, file.lastIndexOf("."));
49 | timbits.add(name, require(path.join(folder, file)), function() {
50 | pending--;
51 | if (pending === 0) callback();
52 | });
53 | });
54 | }
55 |
56 | // automagically load views for a given timbit
57 | function loadViews(timbit) {
58 | timbit.views = [];
59 |
60 | var pattern = new RegExp('\.' + timbits.app.settings['view engine'] + '$')
61 | , folder = path.join(config.home, 'views', timbit.viewBase);
62 |
63 | if (fs.existsSync(folder)) {
64 | var files = fs.readdirSync(folder);
65 | files.forEach(function(file) {
66 | timbit.views.push(file.replace(pattern, ''));
67 | });
68 | }
69 |
70 | // We will attempt the default view anyway and hope the timbit knows what it is doing.
71 | if (timbit.views.length === 0) timbit.views.push(timbit.defaultView);
72 | }
73 |
74 | // return a list of possible test values
75 | function getTestValues(values, alltests) {
76 | if (values != null && values.length != null && values.length !== 0) {
77 | if (alltests)
78 | return values;
79 | else
80 | return values.slice(0, 1);
81 | } else {
82 | return [];
83 | }
84 | }
85 |
86 | // compile built in templates
87 | function compileTemplate(name) {
88 | var filename = path.join(__dirname, "templates", name + '.hjs');
89 | var contents = fs.readFileSync(filename);
90 | return hogan.compile(contents.toString());
91 | }
92 |
93 | // generates the allowed methods
94 | function allowedMethods(methods) {
95 | // default values
96 | var methodsAllowed = { 'GET': true, 'POST': false, 'PUT': false, 'HEAD': false, 'DELETE': false };
97 | // check and override if one of the default methods
98 | for (var key in methods) {
99 | var newKey = key.toUpperCase();
100 | if ( methodsAllowed[newKey]!=undefined) {
101 | methodsAllowed[newKey] = Boolean(methods[key]);
102 | }
103 | }
104 | return methodsAllowed;
105 | }
106 |
107 | var timbits = this;
108 | this.box = {};
109 | this.pantry = require('pantry');
110 | this.templates = {
111 | help: compileTemplate('help'),
112 | timbitHelp: compileTemplate('timbit-help'),
113 | test: compileTemplate('test'),
114 | };
115 |
116 | this.getLogLevel = function() {
117 | switch (process.env.NODE_ENV) {
118 | case 'production':
119 | return 'info';
120 | case 'test':
121 | return 'error';
122 | default:
123 | return 'silly';
124 | }
125 | };
126 |
127 | //added winston object for logging.
128 | this.log = new (winston.Logger)({
129 | transports: [
130 | new (winston.transports.Console)({
131 | colorize: true,
132 | timestamp: true,
133 | level: this.getLogLevel()
134 | })
135 | ]
136 | });
137 |
138 | // creates, configures, and returns a standard express app
139 | this.serve = function(options) {
140 |
141 | /* configure options */
142 | for (var key in options) {
143 | value = options[key];
144 | config[key] = value;
145 | }
146 |
147 | /* configure express app */
148 | var app = timbits.app = express();
149 |
150 | app.set('views', "" + config.home + "/views");
151 | app.set('view engine', config.engine);
152 | app.set('jsonp callback', config.jsonp);
153 |
154 | app.use(express.favicon());
155 |
156 | // disable request logging for tests (avoid console clutter)
157 | if (app.get('env') === 'development')
158 | app.use(express.logger('dev'));
159 |
160 | app.use(express.compress());
161 | app.use(express.bodyParser());
162 | app.use(express.cookieParser());
163 | app.use(express.static(path.join(config.home, "public")));
164 | app.use(express.static(path.join(__dirname, "../resources")));
165 | app.use(express.errorHandler());
166 |
167 | // redirect root to help page
168 | if (config.help) {
169 | app.all(config.base + "/", function(req, res) {
170 | res.redirect(config.base + "/timbits/help");
171 | });
172 | }
173 |
174 | // route json discovery
175 | app.get(config.base + "/timbits/json", function(req, res) {
176 | if (config.discovery) {
177 | res.json(timbits.box);
178 | } else {
179 | res.send(404, "Automatic Discovery has been disabled");
180 | }
181 | });
182 |
183 | // route help page
184 | app.get(config.base + "/timbits/help", function(req, res) {
185 | if (config.help) {
186 | var context = {title: 'Timbits Help', timbits: []};
187 | for(var key in timbits.box) {
188 | context.timbits.push(key);
189 | }
190 | res.send(timbits.templates.help.render(context));
191 | } else {
192 | res.send(404, "Automatic Help has been disabled");
193 | }
194 | });
195 |
196 | // route master test page
197 | app.get(config.base + '/timbits/test/:which?', function(req, res) {
198 | if (config.test) {
199 | var alltests = (req.params.which === 'all')
200 | , all_results = []
201 | , pending = Object.keys(timbits.box).length;
202 |
203 | if (pending) {
204 | for (name in timbits.box) {
205 | var timbit = timbits.box[name];
206 | timbit.test('http://' + req.headers.host, alltests, function(results) {
207 | results.forEach(function(result) {
208 | all_results.push(result);
209 | });
210 | if (--pending === 0) {
211 | var passed = 0, failed = 0;
212 | all_results.forEach(function(result) {
213 | if (result.passed) passed++; else failed++;
214 | });
215 | res.send(timbits.templates.test.render({
216 | title: 'Testing Summary: all timbits',
217 | passed: passed,
218 | failed: failed,
219 | results: all_results
220 | }));
221 | }
222 | });
223 | }
224 | } else {
225 | res.send(ck.render(views.test, {}));
226 | }
227 | } else {
228 | res.send(404, "Automatic Test has been disabled");
229 | }
230 | });
231 |
232 | // automagically load timbits
233 | loadTimbits(function() {
234 | try {
235 | timbits.server = app.listen(process.env.PORT || process.env.C9_PORT || config.port);
236 | timbits.log.info("Timbits server listening on port " + timbits.server.address().port + " in " + app.settings.env + " mode");
237 | } catch (err) {
238 | timbits.log.error("Server could not start on port " + (process.env.PORT || process.env.C9_PORT || config.port) + ". (" + err + ")");
239 | console.log("\nPress Ctrl+C to Exit");
240 | process.exit(1);
241 | }
242 | });
243 |
244 | return app;
245 | };
246 |
247 | // use the 'add' method to place a timbit in the box
248 | this.add = function(name, timbit, callback) {
249 | timbits.log.info("Placing " + name + " in the box");
250 | timbits.box[name] = timbit;
251 |
252 | timbit.name = name;
253 | if (timbit.viewBase == null) timbit.viewBase = name;
254 | if (timbit.defaultView == null) timbit.defaultView = 'default';
255 | if (timbit.maxAge == null) timbit.maxAge = config.maxAge;
256 | timbit.methods = allowedMethods( (timbit.methods == null) ? {} : timbit.methods );
257 |
258 | loadViews(timbit);
259 |
260 | // route timbit help
261 | timbits.app.get(config.base + "/" + name + "/help", function(req, res) {
262 | if (config.help)
263 | res.send(timbits.templates.timbitHelp.render(timbit));
264 | else
265 | res.send(404, "Automatic Help has been disabled");
266 | });
267 |
268 | // route timbit testing
269 | timbits.app.get(config.base + "/" + name + "/test/:which?", function(req, res) {
270 | var alltests;
271 | if (config.test) {
272 | alltests = req.params.which === 'all';
273 | timbit.test("http://" + req.headers.host, alltests, function(results) {
274 | var passed = 0, failed = 0;
275 | results.forEach(function(result) {
276 | if (result.passed) passed++; else failed++;
277 | });
278 | res.send(timbits.templates.test.render({
279 | title: 'Testing Summary: ' + timbit.name,
280 | passed: passed,
281 | failed: failed,
282 | results: results
283 | }));
284 | });
285 | } else {
286 | res.send(404, "Automatic Test has been disabled");
287 | }
288 | });
289 |
290 | // main timbit route
291 | timbits.app.all(config.base + '/' + name + '/:view?', function(req, res) {
292 |
293 | // test if the method used is in the allowed methods,
294 | if ( timbit.methods[req.method] == undefined || timbit.methods[req.method] == false ) {
295 | res.send(405, "Method Not Allowed");
296 | return;
297 | }
298 |
299 | // set view name to default view if not specified
300 | if (req.params.view == null) req.params.view = timbit.defaultView;
301 |
302 | // initialize current request context
303 | var context = {
304 | name: timbit.name,
305 | view: timbit.viewBase + '/' + req.params.view,
306 | maxAge: timbit.maxAge
307 | };
308 |
309 | // add query string parameters to context
310 | for (var key in req.query) {
311 | var has_alias = false;
312 |
313 | if (context[key] == null && req.query[key] != null && req.query[key] !== '') {
314 |
315 | // handle aliased parameters
316 | for (var p in timbit.params) {
317 | if (timbit.params[p] === key) {
318 | has_alias = true;
319 | context[p] = req.query[key];
320 | }
321 | }
322 |
323 | // no alias found
324 | if (!has_alias)
325 | context[key] = req.query[key];
326 | }
327 | }
328 |
329 | // validate request
330 | for (var key in timbit.params) {
331 | var param = timbit.params[key];
332 |
333 | // if parameter isn't specified, use default value
334 | if (context[key] == null) context[key] = param.default;
335 |
336 | // test provided value based on type
337 | var value = context[key];
338 | if (value != null) {
339 |
340 | // default parameter type is String
341 | if (param.type == null) param.type = 'String';
342 |
343 | switch (param.type.toLowerCase()) {
344 |
345 | case 'number':
346 | context[key] = Number(value);
347 | if (isNaN(context[key]))
348 | throw value + ' is not a valid Number for ' + key;
349 | break;
350 |
351 | case 'boolean':
352 | switch (value.toLowerCase()) {
353 | case 'true':
354 | context[key] = true;
355 | break;
356 | case 'false':
357 | context[key]= false;
358 | break;
359 | default:
360 | throw value + ' is not a valid value for ' + key + '. Must be true of false';
361 | }
362 | break;
363 |
364 | case 'date':
365 | context[key] = Date.parse(value);
366 | if (isNaN(context[key]))
367 | throw value + ' is not a valid date for ' + key;
368 | break;
369 |
370 | }
371 | }
372 |
373 | if (param.required && value == null) {
374 | throw key + " is a required parameter";
375 | }
376 | if (value != null && param.strict && param.values.indexOf(value) === -1) {
377 | throw value + " is not a valid value for " + key + ". Must be one of [" + (param.values.join()) + "]";
378 | }
379 | if (value instanceof Array && !param.multiple) {
380 | throw key + " must be a single value";
381 | }
382 |
383 | }
384 |
385 | // with context created, it's time to consume this timbit
386 | timbit.eat(req, res, context);
387 | });
388 |
389 | // update example urls if base vpath specified
390 | if (config.base != null && timbit.examples != null) {
391 | timbit.examples.forEach(function(example) {
392 | example.href = config.base + example.href;
393 | });
394 | }
395 |
396 | // callback after timbit has been loaded
397 | callback();
398 |
399 | };
400 |
401 | // prototype for Timbit
402 | var Timbit = this.Timbit = function() {};
403 |
404 | Timbit.prototype.render = function(req, res, context) {
405 |
406 | // add caching headers
407 | res.setHeader("Cache-Control", "max-age=" + context.maxAge);
408 | res.setHeader("Edge-Control", "!no-store, max-age=" + context.maxAge);
409 |
410 | if (/^(\w+|(\w+-)+\w+)\/json$/.test(context.view)) {
411 | if (config.json)
412 | res.json(context);
413 | else
414 | res.send(404, "JSON view has been disabled");
415 | } else {
416 | res.render(context.view, context, function(err, str) {
417 | if (err) {
418 | timbits.log.error("Error rendering view " + context.view);
419 | req.next(err);
420 | } else {
421 | if (context.callback != null)
422 | res.json(str);
423 | else
424 | res.send(str);
425 | }
426 | });
427 | }
428 | };
429 |
430 | Timbit.prototype.fetch = function(req, res, context, options, callback) {
431 |
432 | // use built in render method by default
433 | if (callback == null) callback = this.render;
434 |
435 | var name = options.name || 'data';
436 | timbits.pantry.fetch(options, function(error, results) {
437 | if (error) {
438 | timbits.log.error("Error fetching resource '" + options.uri);
439 | req.next(error);
440 | } else {
441 | if (context[name] != null) {
442 | if (Object.prototype.toString.call(context[name][0]) === "[object Array]")
443 | context[name].push(results);
444 | else
445 | context[name] = [context[name], results];
446 | } else {
447 | context[name] = results;
448 | }
449 | callback(req, res, context);
450 | }
451 | });
452 | };
453 |
454 | Timbit.prototype.eat = function(req, res, context) {
455 | this.render(req, res, context);
456 | };
457 |
458 |
459 | Timbit.prototype.generateTests = function(alltests) {
460 |
461 | // create combination of required parameters
462 | var required = [];
463 | for (var name in this.params) {
464 | var param = this.params[name];
465 | if (param.required) {
466 | var temp = [];
467 | getTestValues(param.values, alltests).forEach(function(value) {
468 | if (required.length === 0)
469 | temp.push(name + "=" + value);
470 | else
471 | required.forEach(function(item) {
472 | temp.push(item + "&" + name + "=" + value);
473 | });
474 | });
475 | required = temp;
476 | }
477 | }
478 |
479 | // create list of possible queries using required and optional parameters
480 | var queries = [];
481 | required.forEach(function(item) {
482 | queries.push(item)
483 | });
484 |
485 | // only include optional parameters if all tests are requested
486 | if (alltests) {
487 | for (var name in this.params) {
488 | var param = this.params[name];
489 | if (!param.required) {
490 | getTestValues(param.values, alltests).forEach(function(value) {
491 | if (required.length === 0)
492 | queries.push(name + "=" + value);
493 | else
494 | required.forEach(function(item) {
495 | queries.push(item + "&" + name + "=" + value);
496 | });
497 | });
498 | }
499 | }
500 | }
501 |
502 | //create list of testable paths using available views and quiries
503 | var hrefs = [];
504 | var name = this.name
505 | this.views.forEach(function(view) {
506 | if (queries.length)
507 | queries.forEach(function(query) {
508 | hrefs.push("/" + name + "/" + view + "?" + query);
509 | });
510 | else
511 | hrefs.push("/" + name + "/" + view);
512 | });
513 |
514 | return hrefs;
515 | };
516 |
517 | Timbit.prototype.test = function(host, alltests, callback) {
518 |
519 | // generate dynamic list of test urls
520 | var tests = this.generateTests(alltests);
521 |
522 | // multiplier for tests total based on allowed methods, determine which methods are used
523 | var testsLength = 1;
524 | var getMethod = this.methods["GET"];
525 | var postMethod = this.methods["POST"];
526 | if (getMethod && postMethod)
527 | testsLength = 2;
528 |
529 | // add examples to list of tests
530 | if (this.examples) {
531 | this.examples.forEach(function(example) {
532 | tests.push(example.href);
533 | });
534 | }
535 |
536 | // run each test
537 | var results = [];
538 | var name = this.name;
539 |
540 | tests.forEach(function(href) {
541 | if (getMethod) {
542 | request(host + href, function(error, response, body) {
543 | error = error || (response.statusCode === 200 ? '' : body);
544 | results.push({
545 | timbit: name,
546 | href: href,
547 | error: error,
548 | status: response.statusCode,
549 | passed: response.statusCode === 200,
550 | failed: response.statusCode !== 200
551 | });
552 | if (results.length === (tests.length * testsLength))
553 | return callback(results);
554 | });
555 | }
556 | if (postMethod) {
557 | request.post(host + href, function(error, response, body) {
558 | error = error || (response.statusCode === 200 ? '' : body);
559 | results.push({
560 | timbit: name,
561 | href: href,
562 | error: error,
563 | status: response.statusCode,
564 | passed: response.statusCode === 200,
565 | failed: response.statusCode !== 200
566 | });
567 | if (results.length === (tests.length * testsLength))
568 | return callback(results);
569 | });
570 | }
571 | });
572 |
573 | };
574 |
575 | Timbit.prototype.paramsAsArray = function() {
576 | var array = [];
577 | for (var key in this.params) {
578 | array.push({key: key, value: this.params[key]});
579 | }
580 | return array;
581 | }
582 |
583 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "timbits",
3 | "description": "Widget framework based on Express",
4 | "version": "0.7.3",
5 | "homepage": "https://github.com/Postmedia/timbits",
6 | "author": "Edward de Groot
56 |
57 |
79 |
80 |
112 |
113 |
114 |
115 |
116 | {{name}}
58 |{{about}}
59 | 60 |Examples:
61 | {{^examples}} 62 |Developer was too lazy to define any examples.
63 | {{/examples}} 64 |-
65 | {{#examples}}
66 |
- {{caption}} 67 | {{/examples}} 68 |
Views
71 |-
72 | {{#views}}
73 |
- {{.}} 74 | {{/views}} 75 |
Parameters
78 || Name | 82 |Alias | 83 |Description | 84 |Type | 85 |Required | 86 |Multiple | 87 |Default | 88 |Values | 89 |
|---|---|---|---|---|---|---|---|
| {{key}} | 93 |{{value.alias}} | 94 |{{value.description}} | 95 |{{value.type}}{{^value.type}}String{{/value.type}} | 96 |{{value.required}} | 97 |{{value.multiple}} | 98 |{{value.default}} | 99 |
100 | {{#value.strict}}One of:{{/value.strict}}
101 | {{^value.strict}}Examples:{{/value.strict}}
102 |
|
108 |