thomasboyt

var path = require('path');
var fs = require('fs');

var globSync = require('glob').sync;
var yaml = require('js-yaml');

module.exports = function(folder) {
  var files = globSync(path.join(folder, '**/*.yaml'));

  var data = {};

kevburnsjr

<?php

class Route {

    public $name;
    public $uri_templates = array();
    public $params = array();
    
    public function __construct($name, $uri_templates) {
        $this->name = $name;

sebastianseilund

/**
 * `Ember.MergedArray` is an array that observes multiple other arrays (called source arrays) for changes and includes
 * all items from all source arrays in an efficient way.
 * 
 * Usage:
 * 
 * ```javascript
 * var obj = Ember.Object.create({
 *   people: [
 *      {

krisselden

var get = Ember.get, set = Ember.set, doc = document;

var FastSelectComponent = Ember.Component.extend({
  items: null,
  valuePath: 'value',
  labelPath: 'label',
  value: null,
  selected: null,

  tagName: 'select',

mattpodwysocki

    /**
     * Pauses the underlying observable sequence based upon the observable sequence which yields true/false.
     * @example
     * var pauser = new Rx.Subject();
     * var source = Rx.Observable.interval(100).pausable(pauser);
     * @param {Observable} pauser The observable sequence used to pause the underlying sequence.
     * @returns {Observable} The observable sequence which is paused based upon the pauser.
     */
    observableProto.pausable = function (pauser) {
        var self = this;

wycats

There are several types of relationships.

• OneToMany
• OneToOne
• OneToNone
• ManyToNone

A OneToMany relationship has a Set of members and a link to the belongsTo. Each member and the belongsTo has a link back to the relationship. The member links can change.

A ManyToNone relationship has a Set of members and a link to the belongsTo. The belongsTo has a link back to the relationship. The link doesn't change.

wycats

App.Router.map(function() {
  this.resource('post', { path: '/posts/:post_id' });
});

App.PostRoute = Ember.Route.extend({
  model: function(params) {
    return this.store.find('post', params.post_id);
  }
});

lukemelia

var empty, get, set,
  __hasProp = {}.hasOwnProperty;

get = Ember.get;
set = Ember.set;

empty = function(obj) {
  var key;
  for (key in obj) {
    if (!__hasProp.call(obj, key)) continue;

tim-evans

(function () {

// Implement debounce until backburner implements a proper debounce
var debouncees = [],
    pop = Array.prototype.pop;

var debounce = function (target, method /*, args, wait */) {
  var self = Ember.run.backburner,
      args = arguments,
      wait = pop.call(args),

possibilities

From Meteor's documentation:

In Meteor, your server code runs in a single thread per request, not in the asynchronous callback style typical of Node. We find the linear execution model a better fit for the typical server code in a Meteor application.

This guide serves as a mini-tour of tools, trix and patterns that can be used to run async code in Meteor.

Basic async

Sometimes we need to run async code in Meteor.methods. For this we create a Future to block until the async code has finished. This pattern can be seen all over Meteor's own codebase: