creationix

// This is my proto library but without changing Object.prototype
// Then only sub-objects of Class have the special properties.
var Class = module.exports = Object.create(Object.prototype, {
  // Implements a forEach much like the one for Array.prototype.forEach, but for
  // any object.
  forEach: {value: function forEach(callback, thisObject) {
    var keys = Object.keys(this);
    var length = keys.length;
    for (var i = 0; i < length; i++) {
      var key = keys[i];

swaroopch

#!/bin/bash

function flask-boilerplate-tmux
{
    # https://github.com/swaroopch/flask-boilerplate
    BASE="$HOME/code/flask-boilerplate"
    cd $BASE

    tmux start-server
    tmux new-session -d -s flaskboilerplate -n model

stammy

# View my Jekyll blog http://paulstamatiou.com and my jekyll migration post http://paulstamatiou.com/how-to-wordpress-to-jekyll/
#
#
# based on the import script by icebreaker, which is based on mojombo's
# https://github.com/mojombo/jekyll/blob/master/lib/jekyll/migrators/wordpress.rb
# https://gist.github.com/303570
# edited to rewrite image URLs to use my CloudFront URL

require 'rubygems'
require 'sequel'

mathieul

/*
* jasmine.requirejs() returns a function that will load the file(s) required
* and will wait until it's done before proceeding with running specs. 
* The function returned is intended to be passed to beforeEach() so the file(s)
* is(are) loaded before running each spec.
*
* Syntax:
*
* jasmine.requirejs(options, files)
* or

cmorss

Handlebars.template = function(templateString) {
  return function () {
    if (arguments.length < 1) {
      // With no arguments, return the raw template -- useful for rendering
      // partials.
      return templateString;
    } else {
      Handlebars.templates = Handlebars.templates || {}
      Handlebars.templates[templateString] = Handlebars.templates[templateString] || Handlebars.compile(templateString);
      return Handlebars.templates[templateString](arguments[0], arguments[1]);

st33n

#!/usr/bin/env ruby
# Lean Architecture example in Ruby - with ContextAccessor

# This example keeps interaction state in a "current context", represented
# by a ContextAccessor module. This can be mixed in to any class that needs 
# access to the current context. It is implemented as a thread-local variable.

module ContextAccessor
  def context
    Thread.current[:context]

bartoszmajsak

#!/bin/bash

# This way you can customize which branches should be skipped when
# prepending commit message. 
if [ -z "$BRANCHES_TO_SKIP" ]; then
  BRANCHES_TO_SKIP=(master develop test)
fi

BRANCH_NAME=$(git symbolic-ref --short HEAD)
BRANCH_NAME="${BRANCH_NAME##*/}"

mcmire

(function(jq) {

window.Jammit = {
  // At the top of the Javascript file that Jammit assembles, this function is
  // called once for each Mustache template that Jammit encounters. It does two
  // things:
  //
  // 1) It tells Handlebars about the template by putting its raw content in
  //    Handlebars.partials. This makes it  possible for any Mustache template
  //    to refer to another via a partial.

maxbrunsfeld

// This method gives you an easier way of calling super
// when you're using Backbone in plain javascript.
// It lets you avoid writing the constructor's name multiple
// times. You still have to specify the name of the method.
//
// So instead of having to write:
//
//   User = Backbone.Model.extend({
//     save: function(attrs) {
//       this.beforeSave(attrs);

tbranyen

(function() {

var buildMap = {};

/* RequireJS Use Plugin v0.2.0
 * Copyright 2012, Tim Branyen (@tbranyen)
 * use.js may be freely distributed under the MIT license.
 */
define({
  version: "0.2.0",