bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/express/examples/vhost/index.js

@@ -0,0 +1,53 @@
+'use strict'
+
+/**
+ * Module dependencies.
+ */
+
+var express = require('../..');
+var logger = require('morgan');
+var vhost = require('vhost');
+
+/*
+edit /etc/hosts:
+
+127.0.0.1       foo.example.com
+127.0.0.1       bar.example.com
+127.0.0.1       example.com
+*/
+
+// Main server app
+
+var main = express();
+
+if (!module.parent) main.use(logger('dev'));
+
+main.get('/', function(req, res){
+  res.send('Hello from main app!');
+});
+
+main.get('/:sub', function(req, res){
+  res.send('requested ' + req.params.sub);
+});
+
+// Redirect app
+
+var redirect = express();
+
+redirect.use(function(req, res){
+  if (!module.parent) console.log(req.vhost);
+  res.redirect('http://example.com:3000/' + req.vhost[0]);
+});
+
+// Vhost app
+
+var app = module.exports = express();
+
+app.use(vhost('*.example.com', redirect)); // Serves all subdomains via Redirect app
+app.use(vhost('example.com', main)); // Serves top level domain via Main server app
+
+/* istanbul ignore next */
+if (!module.parent) {
+  app.listen(3000);
+  console.log('Express started on port 3000');
+}

package/tests/fixtures/corpus/oss-repos/express/examples/view-constructor/github-view.js

@@ -0,0 +1,53 @@
+'use strict'
+
+/**
+ * Module dependencies.
+ */
+
+var https = require('node:https');
+var path = require('node:path');
+var extname = path.extname;
+
+/**
+ * Expose `GithubView`.
+ */
+
+module.exports = GithubView;
+
+/**
+ * Custom view that fetches and renders
+ * remove github templates. You could
+ * render templates from a database etc.
+ */
+
+function GithubView(name, options){
+  this.name = name;
+  options = options || {};
+  this.engine = options.engines[extname(name)];
+  // "root" is the app.set('views') setting, however
+  // in your own implementation you could ignore this
+  this.path = '/' + options.root + '/master/' + name;
+}
+
+/**
+ * Render the view.
+ */
+
+GithubView.prototype.render = function(options, fn){
+  var self = this;
+  var opts = {
+    host: 'raw.githubusercontent.com',
+    port: 443,
+    path: this.path,
+    method: 'GET'
+  };
+
+  https.request(opts, function(res) {
+    var buf = '';
+    res.setEncoding('utf8');
+    res.on('data', function(str){ buf += str });
+    res.on('end', function(){
+      self.engine(buf, options, fn);
+    });
+  }).end();
+};

package/tests/fixtures/corpus/oss-repos/express/examples/view-constructor/index.js

@@ -0,0 +1,48 @@
+'use strict'
+
+/**
+ * Module dependencies.
+ */
+
+var express = require('../../');
+var GithubView = require('./github-view');
+var md = require('marked').parse;
+
+var app = module.exports = express();
+
+// register .md as an engine in express view system
+app.engine('md', function(str, options, fn){
+  try {
+    var html = md(str);
+    html = html.replace(/\{([^}]+)\}/g, function(_, name){
+      return options[name] || '';
+    });
+    fn(null, html);
+  } catch(err) {
+    fn(err);
+  }
+});
+
+// pointing to a particular github repo to load files from it
+app.set('views', 'expressjs/express');
+
+// register a new view constructor
+app.set('view', GithubView);
+
+app.get('/', function(req, res){
+  // rendering a view relative to the repo.
+  // app.locals, res.locals, and locals passed
+  // work like they normally would
+  res.render('examples/markdown/views/index.md', { title: 'Example' });
+});
+
+app.get('/Readme.md', function(req, res){
+  // rendering a view from https://github.com/expressjs/express/blob/master/Readme.md
+  res.render('Readme.md');
+});
+
+/* istanbul ignore next */
+if (!module.parent) {
+  app.listen(3000);
+  console.log('Express started on port 3000');
+}

package/tests/fixtures/corpus/oss-repos/express/examples/view-locals/index.js

@@ -0,0 +1,155 @@
+'use strict'
+
+/**
+ * Module dependencies.
+ */
+
+var express = require('../..');
+var path = require('node:path');
+var User = require('./user');
+var app = express();
+
+app.set('views', path.join(__dirname, 'views'));
+app.set('view engine', 'ejs');
+
+// filter ferrets only
+
+function ferrets(user) {
+  return user.species === 'ferret'
+}
+
+// naive nesting approach,
+// delegating errors to next(err)
+// in order to expose the "count"
+// and "users" locals
+
+app.get('/', function(req, res, next){
+  User.count(function(err, count){
+    if (err) return next(err);
+    User.all(function(err, users){
+      if (err) return next(err);
+      res.render('index', {
+        title: 'Users',
+        count: count,
+        users: users.filter(ferrets)
+      });
+    })
+  })
+});
+
+
+
+
+// this approach is cleaner,
+// less nesting and we have
+// the variables available
+// on the request object
+
+function count(req, res, next) {
+  User.count(function(err, count){
+    if (err) return next(err);
+    req.count = count;
+    next();
+  })
+}
+
+function users(req, res, next) {
+  User.all(function(err, users){
+    if (err) return next(err);
+    req.users = users;
+    next();
+  })
+}
+
+app.get('/middleware', count, users, function (req, res) {
+  res.render('index', {
+    title: 'Users',
+    count: req.count,
+    users: req.users.filter(ferrets)
+  });
+});
+
+
+
+
+// this approach is much like the last
+// however we're explicitly exposing
+// the locals within each middleware
+//
+// note that this may not always work
+// well, for example here we filter
+// the users in the middleware, which
+// may not be ideal for our application.
+// so in that sense the previous example
+// is more flexible with `req.users`.
+
+function count2(req, res, next) {
+  User.count(function(err, count){
+    if (err) return next(err);
+    res.locals.count = count;
+    next();
+  })
+}
+
+function users2(req, res, next) {
+  User.all(function(err, users){
+    if (err) return next(err);
+    res.locals.users = users.filter(ferrets);
+    next();
+  })
+}
+
+app.get('/middleware-locals', count2, users2, function (req, res) {
+  // you can see now how we have much less
+  // to pass to res.render(). If we have
+  // several routes related to users this
+  // can be a great productivity booster
+  res.render('index', { title: 'Users' });
+});
+
+// keep in mind that middleware may be placed anywhere
+// and in various combinations, so if you have locals
+// that you wish to make available to all subsequent
+// middleware/routes you can do something like this:
+
+/*
+
+app.use(function(req, res, next){
+  res.locals.user = req.user;
+  res.locals.sess = req.session;
+  next();
+});
+
+*/
+
+// or suppose you have some /admin
+// "global" local variables:
+
+/*
+
+app.use('/api', function(req, res, next){
+  res.locals.user = req.user;
+  res.locals.sess = req.session;
+  next();
+});
+
+*/
+
+// the following is effectively the same,
+// but uses a route instead:
+
+/*
+
+app.all('/api/*', function(req, res, next){
+  res.locals.user = req.user;
+  res.locals.sess = req.session;
+  next();
+});
+
+*/
+
+/* istanbul ignore next */
+if (!module.parent) {
+  app.listen(3000);
+  console.log('Express started on port 3000');
+}

package/tests/fixtures/corpus/oss-repos/express/examples/view-locals/user.js

@@ -0,0 +1,36 @@
+'use strict'
+
+module.exports = User;
+
+// faux model
+
+function User(name, age, species) {
+  this.name = name;
+  this.age = age;
+  this.species = species;
+}
+
+User.all = function(fn){
+  // process.nextTick makes sure this function API
+  // behaves in an asynchronous manner, like if it
+  // was a real DB query to read all users.
+  process.nextTick(function(){
+    fn(null, users);
+  });
+};
+
+User.count = function(fn){
+  process.nextTick(function(){
+    fn(null, users.length);
+  });
+};
+
+// faux database
+
+var users = [];
+
+users.push(new User('Tobi', 2, 'ferret'));
+users.push(new User('Loki', 1, 'ferret'));
+users.push(new User('Jane', 6, 'ferret'));
+users.push(new User('Luna', 1, 'cat'));
+users.push(new User('Manny', 1, 'cat'));

package/tests/fixtures/corpus/oss-repos/express/examples/view-locals/views/index.ejs

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <title><%= title %></title>
+    <style media="screen">
+      body {
+        padding: 50px;
+        font: 16px Helvetica, Arial;
+      }
+    </style>
+  </head>
+  <body>
+    <h2><%= title %></h2>
+    <% users.forEach(function(user) { %>
+      <li><strong><%= user.name %></strong> is a <% user.age %> year old <%= user.species %></li>
+    <% }); %>
+  </body>
+</html>

package/tests/fixtures/corpus/oss-repos/express/examples/web-service/index.js

@@ -0,0 +1,117 @@
+'use strict'
+
+/**
+ * Module dependencies.
+ */
+
+var express = require('../../');
+
+var app = module.exports = express();
+
+// create an error with .status. we
+// can then use the property in our
+// custom error handler (Connect respects this prop as well)
+
+function error(status, msg) {
+  var err = new Error(msg);
+  err.status = status;
+  return err;
+}
+
+// if we wanted to supply more than JSON, we could
+// use something similar to the content-negotiation
+// example.
+
+// here we validate the API key,
+// by mounting this middleware to /api
+// meaning only paths prefixed with "/api"
+// will cause this middleware to be invoked
+
+app.use('/api', function(req, res, next){
+  var key = req.query['api-key'];
+
+  // key isn't present
+  if (!key) return next(error(400, 'api key required'));
+
+  // key is invalid
+  if (apiKeys.indexOf(key) === -1) return next(error(401, 'invalid api key'))
+
+  // all good, store req.key for route access
+  req.key = key;
+  next();
+});
+
+// map of valid api keys, typically mapped to
+// account info with some sort of database like redis.
+// api keys do _not_ serve as authentication, merely to
+// track API usage or help prevent malicious behavior etc.
+
+var apiKeys = ['foo', 'bar', 'baz'];
+
+// these two objects will serve as our faux database
+
+var repos = [
+  { name: 'express', url: 'https://github.com/expressjs/express' },
+  { name: 'stylus', url: 'https://github.com/learnboost/stylus' },
+  { name: 'cluster', url: 'https://github.com/learnboost/cluster' }
+];
+
+var users = [
+  { name: 'tobi' }
+  , { name: 'loki' }
+  , { name: 'jane' }
+];
+
+var userRepos = {
+  tobi: [repos[0], repos[1]]
+  , loki: [repos[1]]
+  , jane: [repos[2]]
+};
+
+// we now can assume the api key is valid,
+// and simply expose the data
+
+// example: http://localhost:3000/api/users/?api-key=foo
+app.get('/api/users', function (req, res) {
+  res.send(users);
+});
+
+// example: http://localhost:3000/api/repos/?api-key=foo
+app.get('/api/repos', function (req, res) {
+  res.send(repos);
+});
+
+// example: http://localhost:3000/api/user/tobi/repos/?api-key=foo
+app.get('/api/user/:name/repos', function(req, res, next){
+  var name = req.params.name;
+  var user = userRepos[name];
+
+  if (user) res.send(user);
+  else next();
+});
+
+// middleware with an arity of 4 are considered
+// error handling middleware. When you next(err)
+// it will be passed through the defined middleware
+// in order, but ONLY those with an arity of 4, ignoring
+// regular middleware.
+app.use(function(err, req, res, next){
+  // whatever you want here, feel free to populate
+  // properties on `err` to treat it differently in here.
+  res.status(err.status || 500);
+  res.send({ error: err.message });
+});
+
+// our custom JSON 404 middleware. Since it's placed last
+// it will be the last middleware called, if all others
+// invoke next() and do not respond.
+app.use(function(req, res){
+  res.status(404);
+  res.send({ error: "Sorry, can't find that" })
+});
+
+/* istanbul ignore next */
+if (!module.parent) {
+  app.listen(3000);
+  console.log('Express started on port 3000');
+}

package/tests/fixtures/corpus/oss-repos/express/index.js

@@ -0,0 +1,11 @@
+/*!
+ * express
+ * Copyright(c) 2009-2013 TJ Holowaychuk
+ * Copyright(c) 2013 Roman Shtylman
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict';
+
+module.exports = require('./lib/express');