Skip to content
Browse files

bootstrap Sinatra

  • Loading branch information...
2 parents b0a7165 + 9fe4b8e commit 9e65574fc7e74405068c1257b2d7bbd600b202a9 @mislav committed Apr 20, 2012
Showing with 2,037 additions and 0 deletions.
  1. +2 −0 .gitignore
  2. +20 −0 Gemfile
  3. +13 −0 app.rb
  4. +13 −0 config.ru
  5. +153 −0 lib/sinatra_boilerplate.rb
  6. +807 −0 public/underscore.js
  7. +1,006 −0 public/zepto.js
  8. +1 −0 views/app.coffee
  9. +7 −0 views/index.haml
  10. +15 −0 views/style.sass
View
2 .gitignore
@@ -0,0 +1,2 @@
+.bundle
+.sass-cache
View
20 Gemfile
@@ -0,0 +1,20 @@
+source :rubygems
+
+gem 'sinatra'
+gem 'activesupport'
+gem 'i18n' # stupid activesupport dependency
+
+group :development do
+ gem 'shotgun'
+ gem 'thin'
+ gem 'ruby-debug', :platforms => :mri_18
+ gem 'ruby-debug19', :require => 'ruby-debug', :platforms => :mri_19
+end
+
+gem 'haml'
+gem 'sass'
+gem 'compass'
+gem 'coffee-script'
+# gem 'therubyracer', :group => :development
+gem 'therubyracer-heroku', '~> 0.8.1.pre3', :group => :production
+gem 'uglifier'
View
13 app.rb
@@ -0,0 +1,13 @@
+# encoding: utf-8
+require 'sinatra'
+require 'sinatra_boilerplate'
+
+set :js_assets, %w[zepto.js underscore.js app.coffee]
+
+configure :development do
+ set :logging, false
+end
+
+get "/" do
+ haml :index
+end
View
13 config.ru
@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+$LOAD_PATH.unshift ENV['APP_ROOT'] || File.expand_path('..', __FILE__)
+$LOAD_PATH.unshift File.join($LOAD_PATH.first, 'lib')
+
+Encoding.default_external = 'utf-8'
+
+# require 'ruby-debug' if ENV['RACK_ENV'] == 'development'
+
+require 'app'
+run Sinatra::Application
View
153 lib/sinatra_boilerplate.rb
@@ -0,0 +1,153 @@
+require 'sinatra/base'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/integer/time'
+require 'active_support/core_ext/time/acts_like'
+
+# This Sinatra extension configures your app for serving Haml + HTML5,
+# Sass + Compass, and CoffeeScript with concatenation and compression.
+#
+# The only requirement is defining your JavaScript assets:
+#
+# set :js_assets, %w[zepto.js underscore.js app.coffee]
+#
+# Regular .js files must be under "public/", and .coffee under "views/".
+#
+# Now use the `javascript_includes` helper to render SCRIPT tags.
+#
+# The provided middleware will serve individual .coffee and .s[ac]ss files.
+# In production mode all JavaScript assets will be served from "/all.js"
+# which is a special resource that concatenates and compresses all files.
+module SinatraBoilerplate
+ # poor man's Sprockets
+ class Middleware < Struct.new(:app, :settings)
+ DEFAULT_EXPIRES = 60*60*24*7 # a week
+ JS_MIME = 'application/javascript'
+
+ attr_reader :expires_in
+
+ def initialize(app, settings, options = {})
+ super(app, settings)
+ @expires_in = options.fetch(:expires_in, DEFAULT_EXPIRES).to_i
+ end
+
+ def template_path(path)
+ File.join(settings.views, path)
+ end
+
+ def call(env)
+ if env['PATH_INFO'] =~ /\.(js|css)$/
+ path, ext = $`, $1
+
+ # /css/style.css -> views/css/style.s[ca]ss
+ # /js/app.js -> views/js/app.coffee
+ case ext
+ when 'css'
+ if found = Dir.glob(template_path("#{path}.s[ca]ss")).first
+ template = Tilt.new(found, nil, settings.sass)
+ return response(env, template.class.default_mime_type, ->{template.render},
+ get_mtime(template.file, *sass_dependencies(template)))
+ end
+ when 'js'
+ body = if '/all' == path
+ source = javascript_files
+ ->{merge_javascripts(source)}
+ elsif source = template_path("#{path}.coffee") and File.exist? source
+ ->{Tilt.new(source).render}
+ end
+
+ return response(env, JS_MIME, body, get_mtime(*source)) if body
+ end
+ end
+ app.call(env)
+ end
+
+ def sass_dependencies(template)
+ template.instance_variable_get('@engine')
+ .dependencies.map { |s| s.options[:filename] }
+ .select { |f| f.index(settings.root) == 0 }
+ end
+
+ def javascript_files
+ settings.js_assets.map do |name|
+ name.end_with?('.coffee') ? template_path(name) : File.join(settings.public_folder, name)
+ end
+ end
+
+ def merge_javascripts(files)
+ require 'uglifier' unless defined? Uglifier
+ Uglifier.new.compile files.map { |name|
+ name.end_with?('.js') ? File.read(name) : Tilt.new(name).render
+ }.join(";")
+ end
+
+ def get_mtime(*files)
+ files.map { |f| File.mtime(f) }.max
+ end
+
+ def response(env, mime_type, body, mtime = nil)
+ status, headers = 200, {}
+ if mtime
+ expires_at = Time.now + expires_in
+ headers['Expires'] = expires_at.httpdate
+ headers['Cache-control'] = "public, must-revalidate, max-age=#{expires_in}"
+ headers['Last-modified'] = mtime.httpdate
+ if client_time = env['HTTP_IF_MODIFIED_SINCE'] and Time.httpdate(client_time) >= mtime
+ status, body = 304, ""
+ else
+ headers['Content-type'] = mime_type
+ end
+ end
+ body = body.call if body.respond_to? :call
+ [status, headers, Array(body)]
+ end
+ end
+
+ module Helpers
+ def javascript_assets
+ settings.js_assets
+ end
+
+ def javascript_includes_names
+ if settings.production? then %w[/all.js]
+ else javascript_assets.map {|f| "/#{File.basename(f, '.*')}.js" }
+ end
+ end
+
+ def javascript_includes
+ javascript_includes_names.map {|a| %(<script src="#{a}"></script>) }.join("\n")
+ end
+ end
+
+ def self.registered(app)
+ app.helpers Helpers
+
+ app.set :haml, format: :html5
+
+ app.set :sass do
+ require 'compass'
+ Compass.configuration do |config|
+ config.project_path = app.settings.root
+ config.sass_dir = app.settings.views
+ end
+
+ options = {style: app.settings.production? ? :compressed : :nested}
+ options[:cache_location] = File.join(ENV['TMPDIR'], 'sass-cache') if ENV['TMPDIR']
+ Compass.sass_engine_options.merge options
+ end
+
+ app.use Middleware, app.settings
+ end
+
+ Sinatra.register self
+end
+
+# monkeypatch to Tilt to enable rendering coffeescript with multibyte
+# characters in it
+Tilt::CoffeeScriptTemplate.class_eval do
+ alias original_prepare prepare
+ def prepare
+ original_prepare
+ data.force_encoding 'UTF-8'
+ end
+end
View
807 public/underscore.js
@@ -0,0 +1,807 @@
+// Underscore.js 1.1.6
+// (c) 2011 Jeremy Ashkenas, DocumentCloud Inc.
+// Underscore is freely distributable under the MIT license.
+// Portions of Underscore are inspired or borrowed from Prototype,
+// Oliver Steele's Functional, and John Resig's Micro-Templating.
+// For all details and documentation:
+// http://documentcloud.github.com/underscore
+
+(function() {
+
+ // Baseline setup
+ // --------------
+
+ // Establish the root object, `window` in the browser, or `global` on the server.
+ var root = this;
+
+ // Save the previous value of the `_` variable.
+ var previousUnderscore = root._;
+
+ // Establish the object that gets returned to break out of a loop iteration.
+ var breaker = {};
+
+ // Save bytes in the minified (but not gzipped) version:
+ var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+ // Create quick reference variables for speed access to core prototypes.
+ var slice = ArrayProto.slice,
+ unshift = ArrayProto.unshift,
+ toString = ObjProto.toString,
+ hasOwnProperty = ObjProto.hasOwnProperty;
+
+ // All **ECMAScript 5** native function implementations that we hope to use
+ // are declared here.
+ var
+ nativeForEach = ArrayProto.forEach,
+ nativeMap = ArrayProto.map,
+ nativeReduce = ArrayProto.reduce,
+ nativeReduceRight = ArrayProto.reduceRight,
+ nativeFilter = ArrayProto.filter,
+ nativeEvery = ArrayProto.every,
+ nativeSome = ArrayProto.some,
+ nativeIndexOf = ArrayProto.indexOf,
+ nativeLastIndexOf = ArrayProto.lastIndexOf,
+ nativeIsArray = Array.isArray,
+ nativeKeys = Object.keys,
+ nativeBind = FuncProto.bind;
+
+ // Create a safe reference to the Underscore object for use below.
+ var _ = function(obj) { return new wrapper(obj); };
+
+ // Export the Underscore object for **CommonJS**, with backwards-compatibility
+ // for the old `require()` API. If we're not in CommonJS, add `_` to the
+ // global object.
+ if (typeof module !== 'undefined' && module.exports) {
+ module.exports = _;
+ _._ = _;
+ } else {
+ root._ = _;
+ }
+
+ // Current version.
+ _.VERSION = '1.1.6';
+
+ // Collection Functions
+ // --------------------
+
+ // The cornerstone, an `each` implementation, aka `forEach`.
+ // Handles objects implementing `forEach`, arrays, and raw objects.
+ // Delegates to **ECMAScript 5**'s native `forEach` if available.
+ var each = _.each = _.forEach = function(obj, iterator, context) {
+ if (obj == null) return;
+ if (nativeForEach && obj.forEach === nativeForEach) {
+ obj.forEach(iterator, context);
+ } else if (_.isNumber(obj.length)) {
+ for (var i = 0, l = obj.length; i < l; i++) {
+ if (iterator.call(context, obj[i], i, obj) === breaker) return;
+ }
+ } else {
+ for (var key in obj) {
+ if (hasOwnProperty.call(obj, key)) {
+ if (iterator.call(context, obj[key], key, obj) === breaker) return;
+ }
+ }
+ }
+ };
+
+ // Return the results of applying the iterator to each element.
+ // Delegates to **ECMAScript 5**'s native `map` if available.
+ _.map = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+ each(obj, function(value, index, list) {
+ results[results.length] = iterator.call(context, value, index, list);
+ });
+ return results;
+ };
+
+ // **Reduce** builds up a single result from a list of values, aka `inject`,
+ // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+ _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+ var initial = memo !== void 0;
+ if (obj == null) obj = [];
+ if (nativeReduce && obj.reduce === nativeReduce) {
+ if (context) iterator = _.bind(iterator, context);
+ return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+ }
+ each(obj, function(value, index, list) {
+ if (!initial && index === 0) {
+ memo = value;
+ initial = true;
+ } else {
+ memo = iterator.call(context, memo, value, index, list);
+ }
+ });
+ if (!initial) throw new TypeError("Reduce of empty array with no initial value");
+ return memo;
+ };
+
+ // The right-associative version of reduce, also known as `foldr`.
+ // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+ _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+ if (obj == null) obj = [];
+ if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+ if (context) iterator = _.bind(iterator, context);
+ return memo !== void 0 ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+ }
+ var reversed = (_.isArray(obj) ? obj.slice() : _.toArray(obj)).reverse();
+ return _.reduce(reversed, iterator, memo, context);
+ };
+
+ // Return the first value which passes a truth test. Aliased as `detect`.
+ _.find = _.detect = function(obj, iterator, context) {
+ var result;
+ any(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) {
+ result = value;
+ return true;
+ }
+ });
+ return result;
+ };
+
+ // Return all the elements that pass a truth test.
+ // Delegates to **ECMAScript 5**'s native `filter` if available.
+ // Aliased as `select`.
+ _.filter = _.select = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+ each(obj, function(value, index, list) {
+ if (iterator.call(context, value, index, list)) results[results.length] = value;
+ });
+ return results;
+ };
+
+ // Return all the elements for which a truth test fails.
+ _.reject = function(obj, iterator, context) {
+ var results = [];
+ if (obj == null) return results;
+ each(obj, function(value, index, list) {
+ if (!iterator.call(context, value, index, list)) results[results.length] = value;
+ });
+ return results;
+ };
+
+ // Determine whether all of the elements match a truth test.
+ // Delegates to **ECMAScript 5**'s native `every` if available.
+ // Aliased as `all`.
+ _.every = _.all = function(obj, iterator, context) {
+ var result = true;
+ if (obj == null) return result;
+ if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+ each(obj, function(value, index, list) {
+ if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+ });
+ return result;
+ };
+
+ // Determine if at least one element in the object matches a truth test.
+ // Delegates to **ECMAScript 5**'s native `some` if available.
+ // Aliased as `any`.
+ var any = _.some = _.any = function(obj, iterator, context) {
+ iterator || (iterator = _.identity);
+ var result = false;
+ if (obj == null) return result;
+ if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+ each(obj, function(value, index, list) {
+ if (result = iterator.call(context, value, index, list)) return breaker;
+ });
+ return result;
+ };
+
+ // Determine if a given value is included in the array or object using `===`.
+ // Aliased as `contains`.
+ _.include = _.contains = function(obj, target) {
+ var found = false;
+ if (obj == null) return found;
+ if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+ any(obj, function(value) {
+ if (found = value === target) return true;
+ });
+ return found;
+ };
+
+ // Invoke a method (with arguments) on every item in a collection.
+ _.invoke = function(obj, method) {
+ var args = slice.call(arguments, 2);
+ return _.map(obj, function(value) {
+ return (method.call ? method || value : value[method]).apply(value, args);
+ });
+ };
+
+ // Convenience version of a common use case of `map`: fetching a property.
+ _.pluck = function(obj, key) {
+ return _.map(obj, function(value){ return value[key]; });
+ };
+
+ // Return the maximum element or (element-based computation).
+ _.max = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
+ var result = {computed : -Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed >= result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Return the minimum element (or element-based computation).
+ _.min = function(obj, iterator, context) {
+ if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
+ var result = {computed : Infinity};
+ each(obj, function(value, index, list) {
+ var computed = iterator ? iterator.call(context, value, index, list) : value;
+ computed < result.computed && (result = {value : value, computed : computed});
+ });
+ return result.value;
+ };
+
+ // Sort the object's values by a criterion produced by an iterator.
+ _.sortBy = function(obj, iterator, context) {
+ return _.pluck(_.map(obj, function(value, index, list) {
+ return {
+ value : value,
+ criteria : iterator.call(context, value, index, list)
+ };
+ }).sort(function(left, right) {
+ var a = left.criteria, b = right.criteria;
+ return a < b ? -1 : a > b ? 1 : 0;
+ }), 'value');
+ };
+
+ // Use a comparator function to figure out at what index an object should
+ // be inserted so as to maintain order. Uses binary search.
+ _.sortedIndex = function(array, obj, iterator) {
+ iterator || (iterator = _.identity);
+ var low = 0, high = array.length;
+ while (low < high) {
+ var mid = (low + high) >> 1;
+ iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
+ }
+ return low;
+ };
+
+ // Safely convert anything iterable into a real, live array.
+ _.toArray = function(iterable) {
+ if (!iterable) return [];
+ if (iterable.toArray) return iterable.toArray();
+ if (_.isArray(iterable)) return iterable;
+ if (_.isArguments(iterable)) return slice.call(iterable);
+ return _.values(iterable);
+ };
+
+ // Return the number of elements in an object.
+ _.size = function(obj) {
+ return _.toArray(obj).length;
+ };
+
+ // Array Functions
+ // ---------------
+
+ // Get the first element of an array. Passing **n** will return the first N
+ // values in the array. Aliased as `head`. The **guard** check allows it to work
+ // with `_.map`.
+ _.first = _.head = function(array, n, guard) {
+ return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
+ };
+
+ // Returns everything but the first entry of the array. Aliased as `tail`.
+ // Especially useful on the arguments object. Passing an **index** will return
+ // the rest of the values in the array from that index onward. The **guard**
+ // check allows it to work with `_.map`.
+ _.rest = _.tail = function(array, index, guard) {
+ return slice.call(array, (index == null) || guard ? 1 : index);
+ };
+
+ // Get the last element of an array.
+ _.last = function(array) {
+ return array[array.length - 1];
+ };
+
+ // Trim out all falsy values from an array.
+ _.compact = function(array) {
+ return _.filter(array, function(value){ return !!value; });
+ };
+
+ // Return a completely flattened version of an array.
+ _.flatten = function(array) {
+ return _.reduce(array, function(memo, value) {
+ if (_.isArray(value)) return memo.concat(_.flatten(value));
+ memo[memo.length] = value;
+ return memo;
+ }, []);
+ };
+
+ // Return a version of the array that does not contain the specified value(s).
+ _.without = function(array) {
+ var values = slice.call(arguments, 1);
+ return _.filter(array, function(value){ return !_.include(values, value); });
+ };
+
+ // Produce a duplicate-free version of the array. If the array has already
+ // been sorted, you have the option of using a faster algorithm.
+ // Aliased as `unique`.
+ _.uniq = _.unique = function(array, isSorted) {
+ return _.reduce(array, function(memo, el, i) {
+ if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) memo[memo.length] = el;
+ return memo;
+ }, []);
+ };
+
+ // Produce an array that contains every item shared between all the
+ // passed-in arrays.
+ _.intersect = function(array) {
+ var rest = slice.call(arguments, 1);
+ return _.filter(_.uniq(array), function(item) {
+ return _.every(rest, function(other) {
+ return _.indexOf(other, item) >= 0;
+ });
+ });
+ };
+
+ // Zip together multiple lists into a single array -- elements that share
+ // an index go together.
+ _.zip = function() {
+ var args = slice.call(arguments);
+ var length = _.max(_.pluck(args, 'length'));
+ var results = new Array(length);
+ for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
+ return results;
+ };
+
+ // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+ // we need this function. Return the position of the first occurrence of an
+ // item in an array, or -1 if the item is not included in the array.
+ // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+ // If the array is large and already in sort order, pass `true`
+ // for **isSorted** to use binary search.
+ _.indexOf = function(array, item, isSorted) {
+ if (array == null) return -1;
+ var i, l;
+ if (isSorted) {
+ i = _.sortedIndex(array, item);
+ return array[i] === item ? i : -1;
+ }
+ if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
+ for (i = 0, l = array.length; i < l; i++) if (array[i] === item) return i;
+ return -1;
+ };
+
+
+ // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+ _.lastIndexOf = function(array, item) {
+ if (array == null) return -1;
+ if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
+ var i = array.length;
+ while (i--) if (array[i] === item) return i;
+ return -1;
+ };
+
+ // Generate an integer Array containing an arithmetic progression. A port of
+ // the native Python `range()` function. See
+ // [the Python documentation](http://docs.python.org/library/functions.html#range).
+ _.range = function(start, stop, step) {
+ if (arguments.length <= 1) {
+ stop = start || 0;
+ start = 0;
+ }
+ step = arguments[2] || 1;
+
+ var len = Math.max(Math.ceil((stop - start) / step), 0);
+ var idx = 0;
+ var range = new Array(len);
+
+ while(idx < len) {
+ range[idx++] = start;
+ start += step;
+ }
+
+ return range;
+ };
+
+ // Function (ahem) Functions
+ // ------------------
+
+ // Create a function bound to a given object (assigning `this`, and arguments,
+ // optionally). Binding with arguments is also known as `curry`.
+ // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
+ // We check for `func.bind` first, to fail fast when `func` is undefined.
+ _.bind = function(func, obj) {
+ if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+ var args = slice.call(arguments, 2);
+ return function() {
+ return func.apply(obj, args.concat(slice.call(arguments)));
+ };
+ };
+
+ // Bind all of an object's methods to that object. Useful for ensuring that
+ // all callbacks defined on an object belong to it.
+ _.bindAll = function(obj) {
+ var funcs = slice.call(arguments, 1);
+ if (funcs.length == 0) funcs = _.functions(obj);
+ each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+ return obj;
+ };
+
+ // Memoize an expensive function by storing its results.
+ _.memoize = function(func, hasher) {
+ var memo = {};
+ hasher || (hasher = _.identity);
+ return function() {
+ var key = hasher.apply(this, arguments);
+ return hasOwnProperty.call(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+ };
+ };
+
+ // Delays a function for the given number of milliseconds, and then calls
+ // it with the arguments supplied.
+ _.delay = function(func, wait) {
+ var args = slice.call(arguments, 2);
+ return setTimeout(function(){ return func.apply(func, args); }, wait);
+ };
+
+ // Defers a function, scheduling it to run after the current call stack has
+ // cleared.
+ _.defer = function(func) {
+ return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+ };
+
+ // Internal function used to implement `_.throttle` and `_.debounce`.
+ var limit = function(func, wait, debounce) {
+ var timeout;
+ return function() {
+ var context = this, args = arguments;
+ var throttler = function() {
+ timeout = null;
+ func.apply(context, args);
+ };
+ if (debounce) clearTimeout(timeout);
+ if (debounce || !timeout) timeout = setTimeout(throttler, wait);
+ };
+ };
+
+ // Returns a function, that, when invoked, will only be triggered at most once
+ // during a given window of time.
+ _.throttle = function(func, wait) {
+ return limit(func, wait, false);
+ };
+
+ // Returns a function, that, as long as it continues to be invoked, will not
+ // be triggered. The function will be called after it stops being called for
+ // N milliseconds.
+ _.debounce = function(func, wait) {
+ return limit(func, wait, true);
+ };
+
+ // Returns a function that will be executed at most one time, no matter how
+ // often you call it. Useful for lazy initialization.
+ _.once = function(func) {
+ var ran = false, memo;
+ return function() {
+ if (ran) return memo;
+ ran = true;
+ return memo = func.apply(this, arguments);
+ };
+ };
+
+ // Returns the first function passed as an argument to the second,
+ // allowing you to adjust arguments, run code before and after, and
+ // conditionally execute the original function.
+ _.wrap = function(func, wrapper) {
+ return function() {
+ var args = [func].concat(slice.call(arguments));
+ return wrapper.apply(this, args);
+ };
+ };
+
+ // Returns a function that is the composition of a list of functions, each
+ // consuming the return value of the function that follows.
+ _.compose = function() {
+ var funcs = slice.call(arguments);
+ return function() {
+ var args = slice.call(arguments);
+ for (var i=funcs.length-1; i >= 0; i--) {
+ args = [funcs[i].apply(this, args)];
+ }
+ return args[0];
+ };
+ };
+
+ // Returns a function that will only be executed after being called N times.
+ _.after = function(times, func) {
+ return function() {
+ if (--times < 1) { return func.apply(this, arguments); }
+ };
+ };
+
+
+ // Object Functions
+ // ----------------
+
+ // Retrieve the names of an object's properties.
+ // Delegates to **ECMAScript 5**'s native `Object.keys`
+ _.keys = nativeKeys || function(obj) {
+ if (obj !== Object(obj)) throw new TypeError('Invalid object');
+ var keys = [];
+ for (var key in obj) if (hasOwnProperty.call(obj, key)) keys[keys.length] = key;
+ return keys;
+ };
+
+ // Retrieve the values of an object's properties.
+ _.values = function(obj) {
+ return _.map(obj, _.identity);
+ };
+
+ // Return a sorted list of the function names available on the object.
+ // Aliased as `methods`
+ _.functions = _.methods = function(obj) {
+ return _.filter(_.keys(obj), function(key){ return _.isFunction(obj[key]); }).sort();
+ };
+
+ // Extend a given object with all the properties in passed-in object(s).
+ _.extend = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ for (var prop in source) {
+ if (source[prop] !== void 0) obj[prop] = source[prop];
+ }
+ });
+ return obj;
+ };
+
+ // Fill in a given object with default properties.
+ _.defaults = function(obj) {
+ each(slice.call(arguments, 1), function(source) {
+ for (var prop in source) {
+ if (obj[prop] == null) obj[prop] = source[prop];
+ }
+ });
+ return obj;
+ };
+
+ // Create a (shallow-cloned) duplicate of an object.
+ _.clone = function(obj) {
+ return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+ };
+
+ // Invokes interceptor with the obj, and then returns obj.
+ // The primary purpose of this method is to "tap into" a method chain, in
+ // order to perform operations on intermediate results within the chain.
+ _.tap = function(obj, interceptor) {
+ interceptor(obj);
+ return obj;
+ };
+
+ // Perform a deep comparison to check if two objects are equal.
+ _.isEqual = function(a, b) {
+ // Check object identity.
+ if (a === b) return true;
+ // Different types?
+ var atype = typeof(a), btype = typeof(b);
+ if (atype != btype) return false;
+ // Basic equality test (watch out for coercions).
+ if (a == b) return true;
+ // One is falsy and the other truthy.
+ if ((!a && b) || (a && !b)) return false;
+ // Unwrap any wrapped objects.
+ if (a._chain) a = a._wrapped;
+ if (b._chain) b = b._wrapped;
+ // One of them implements an isEqual()?
+ if (a.isEqual) return a.isEqual(b);
+ // Check dates' integer values.
+ if (_.isDate(a) && _.isDate(b)) return a.getTime() === b.getTime();
+ // Both are NaN?
+ if (_.isNaN(a) && _.isNaN(b)) return false;
+ // Compare regular expressions.
+ if (_.isRegExp(a) && _.isRegExp(b))
+ return a.source === b.source &&
+ a.global === b.global &&
+ a.ignoreCase === b.ignoreCase &&
+ a.multiline === b.multiline;
+ // If a is not an object by this point, we can't handle it.
+ if (atype !== 'object') return false;
+ // Check for different array lengths before comparing contents.
+ if (a.length && (a.length !== b.length)) return false;
+ // Nothing else worked, deep compare the contents.
+ var aKeys = _.keys(a), bKeys = _.keys(b);
+ // Different object sizes?
+ if (aKeys.length != bKeys.length) return false;
+ // Recursive comparison of contents.
+ for (var key in a) if (!(key in b) || !_.isEqual(a[key], b[key])) return false;
+ return true;
+ };
+
+ // Is a given array or object empty?
+ _.isEmpty = function(obj) {
+ if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+ for (var key in obj) if (hasOwnProperty.call(obj, key)) return false;
+ return true;
+ };
+
+ // Is a given value a DOM element?
+ _.isElement = function(obj) {
+ return !!(obj && obj.nodeType == 1);
+ };
+
+ // Is a given value an array?
+ // Delegates to ECMA5's native Array.isArray
+ _.isArray = nativeIsArray || function(obj) {
+ return toString.call(obj) === '[object Array]';
+ };
+
+ // Is a given variable an arguments object?
+ _.isArguments = function(obj) {
+ return !!(obj && hasOwnProperty.call(obj, 'callee'));
+ };
+
+ // Is a given value a function?
+ _.isFunction = function(obj) {
+ return !!(obj && obj.constructor && obj.call && obj.apply);
+ };
+
+ // Is a given value a string?
+ _.isString = function(obj) {
+ return !!(obj === '' || (obj && obj.charCodeAt && obj.substr));
+ };
+
+ // Is a given value a number?
+ _.isNumber = function(obj) {
+ return !!(obj === 0 || (obj && obj.toExponential && obj.toFixed));
+ };
+
+ // Is the given value `NaN`? `NaN` happens to be the only value in JavaScript
+ // that does not equal itself.
+ _.isNaN = function(obj) {
+ return obj !== obj;
+ };
+
+ // Is a given value a boolean?
+ _.isBoolean = function(obj) {
+ return obj === true || obj === false;
+ };
+
+ // Is a given value a date?
+ _.isDate = function(obj) {
+ return !!(obj && obj.getTimezoneOffset && obj.setUTCFullYear);
+ };
+
+ // Is the given value a regular expression?
+ _.isRegExp = function(obj) {
+ return !!(obj && obj.test && obj.exec && (obj.ignoreCase || obj.ignoreCase === false));
+ };
+
+ // Is a given value equal to null?
+ _.isNull = function(obj) {
+ return obj === null;
+ };
+
+ // Is a given variable undefined?
+ _.isUndefined = function(obj) {
+ return obj === void 0;
+ };
+
+ // Utility Functions
+ // -----------------
+
+ // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+ // previous owner. Returns a reference to the Underscore object.
+ _.noConflict = function() {
+ root._ = previousUnderscore;
+ return this;
+ };
+
+ // Keep the identity function around for default iterators.
+ _.identity = function(value) {
+ return value;
+ };
+
+ // Run a function **n** times.
+ _.times = function (n, iterator, context) {
+ for (var i = 0; i < n; i++) iterator.call(context, i);
+ };
+
+ // Add your own custom functions to the Underscore object, ensuring that
+ // they're correctly added to the OOP wrapper as well.
+ _.mixin = function(obj) {
+ each(_.functions(obj), function(name){
+ addToWrapper(name, _[name] = obj[name]);
+ });
+ };
+
+ // Generate a unique integer id (unique within the entire client session).
+ // Useful for temporary DOM ids.
+ var idCounter = 0;
+ _.uniqueId = function(prefix) {
+ var id = idCounter++;
+ return prefix ? prefix + id : id;
+ };
+
+ // By default, Underscore uses ERB-style template delimiters, change the
+ // following template settings to use alternative delimiters.
+ _.templateSettings = {
+ evaluate : /<%([\s\S]+?)%>/g,
+ interpolate : /<%=([\s\S]+?)%>/g
+ };
+
+ // JavaScript micro-templating, similar to John Resig's implementation.
+ // Underscore templating handles arbitrary delimiters, preserves whitespace,
+ // and correctly escapes quotes within interpolated code.
+ _.template = function(str, data) {
+ var c = _.templateSettings;
+ var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
+ 'with(obj||{}){__p.push(\'' +
+ str.replace(/\\/g, '\\\\')
+ .replace(/'/g, "\\'")
+ .replace(c.interpolate, function(match, code) {
+ return "'," + code.replace(/\\'/g, "'") + ",'";
+ })
+ .replace(c.evaluate || null, function(match, code) {
+ return "');" + code.replace(/\\'/g, "'")
+ .replace(/[\r\n\t]/g, ' ') + "__p.push('";
+ })
+ .replace(/\r/g, '\\r')
+ .replace(/\n/g, '\\n')
+ .replace(/\t/g, '\\t')
+ + "');}return __p.join('');";
+ var func = new Function('obj', tmpl);
+ return data ? func(data) : func;
+ };
+
+ // The OOP Wrapper
+ // ---------------
+
+ // If Underscore is called as a function, it returns a wrapped object that
+ // can be used OO-style. This wrapper holds altered versions of all the
+ // underscore functions. Wrapped objects may be chained.
+ var wrapper = function(obj) { this._wrapped = obj; };
+
+ // Expose `wrapper.prototype` as `_.prototype`
+ _.prototype = wrapper.prototype;
+
+ // Helper function to continue chaining intermediate results.
+ var result = function(obj, chain) {
+ return chain ? _(obj).chain() : obj;
+ };
+
+ // A method to easily add functions to the OOP wrapper.
+ var addToWrapper = function(name, func) {
+ wrapper.prototype[name] = function() {
+ var args = slice.call(arguments);
+ unshift.call(args, this._wrapped);
+ return result(func.apply(_, args), this._chain);
+ };
+ };
+
+ // Add all of the Underscore functions to the wrapper object.
+ _.mixin(_);
+
+ // Add all mutator Array functions to the wrapper.
+ each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+ var method = ArrayProto[name];
+ wrapper.prototype[name] = function() {
+ method.apply(this._wrapped, arguments);
+ return result(this._wrapped, this._chain);
+ };
+ });
+
+ // Add all accessor Array functions to the wrapper.
+ each(['concat', 'join', 'slice'], function(name) {
+ var method = ArrayProto[name];
+ wrapper.prototype[name] = function() {
+ return result(method.apply(this._wrapped, arguments), this._chain);
+ };
+ });
+
+ // Start chaining a wrapped Underscore object.
+ wrapper.prototype.chain = function() {
+ this._chain = true;
+ return this;
+ };
+
+ // Extracts the result from a wrapped and chained object.
+ wrapper.prototype.value = function() {
+ return this._wrapped;
+ };
+
+})();
View
1,006 public/zepto.js
@@ -0,0 +1,1006 @@
+// Zepto.js
+// (c) 2010, 2011 Thomas Fuchs
+// Zepto.js may be freely distributed under the MIT license.
+
+(function(undefined){
+ if (String.prototype.trim === undefined) // fix for iOS 3.2
+ String.prototype.trim = function(){ return this.replace(/^\s+/, '').replace(/\s+$/, '') };
+
+ // For iOS 3.x
+ // from https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduce
+ if (Array.prototype.reduce === undefined)
+ Array.prototype.reduce = function(fun){
+ if(this === void 0 || this === null) throw new TypeError();
+ var t = Object(this), len = t.length >>> 0, k = 0, accumulator;
+ if(typeof fun != 'function') throw new TypeError();
+ if(len == 0 && arguments.length == 1) throw new TypeError();
+
+ if(arguments.length >= 2)
+ accumulator = arguments[1];
+ else
+ do{
+ if(k in t){
+ accumulator = t[k++];
+ break;
+ }
+ if(++k >= len) throw new TypeError();
+ } while (true);
+
+ while (k < len){
+ if(k in t) accumulator = fun.call(undefined, accumulator, t[k], k, t);
+ k++;
+ }
+ return accumulator;
+ };
+
+})();
+// Zepto.js
+// (c) 2010, 2011 Thomas Fuchs
+// Zepto.js may be freely distributed under the MIT license.
+
+var Zepto = (function() {
+ var undefined, key, $$, classList,
+ emptyArray = [], slice = emptyArray.slice,
+ document = window.document,
+ elementDisplay = {}, classCache = {},
+ getComputedStyle = document.defaultView.getComputedStyle,
+ cssNumber = { 'column-count': 1, 'columns': 1, 'font-weight': 1, 'line-height': 1,'opacity': 1, 'z-index': 1, 'zoom': 1 },
+ fragmentRE = /^\s*<(\w+)[^>]*>/,
+ elementTypes = [1, 9, 11],
+ adjacencyOperators = ['prepend', 'after', 'before', 'append'],
+ reverseAdjacencyOperators = ['append', 'prepend'],
+ containers = {
+ 'th': document.createElement('tr'),
+ 'td': document.createElement('tr'),
+ '*': document.createElement('div')
+ };
+
+ function isF(value) { return ({}).toString.call(value) == "[object Function]" }
+ function isO(value) { return value instanceof Object }
+ function isA(value) { return value instanceof Array }
+
+ function compact(array) { return array.filter(function(item){ return item !== undefined && item !== null }) }
+ function flatten(array) { return [].concat.apply([], array) }
+ function camelize(str) { return str.replace(/-+(.)?/g, function(match, chr){ return chr ? chr.toUpperCase() : '' }) }
+ function dasherize(str){
+ return str.replace(/::/g, '/')
+ .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+ .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+ .replace(/_/g, '-')
+ .toLowerCase();
+ }
+ function uniq(array) { return array.filter(function(item,index,array){ return array.indexOf(item) == index }) }
+
+ function classRE(name){
+ return name in classCache ?
+ classCache[name] : (classCache[name] = new RegExp('(^|\\s)' + name + '(\\s|$)'));
+ }
+
+ function maybeAddPx(name, value) { return (typeof value == "number" && !cssNumber[dasherize(name)]) ? value + "px" : value; }
+
+ function defaultDisplay(nodeName) {
+ var element, display;
+ if (!elementDisplay[nodeName]) {
+ element = document.createElement(nodeName);
+ document.body.appendChild(element);
+ display = getComputedStyle(element, '').getPropertyValue("display");
+ element.parentNode.removeChild(element);
+ display == "none" && (display = "block");
+ elementDisplay[nodeName] = display;
+ }
+ return elementDisplay[nodeName];
+ }
+
+ function fragment(html, name) {
+ if (name === undefined) fragmentRE.test(html) && RegExp.$1;
+ if (!(name in containers)) name = '*';
+ var container = containers[name];
+ container.innerHTML = '' + html;
+ return slice.call(container.childNodes);
+ }
+
+ function Z(dom, selector){
+ dom = dom || emptyArray;
+ dom.__proto__ = Z.prototype;
+ dom.selector = selector || '';
+ return dom;
+ }
+
+ function $(selector, context){
+ if (!selector) return Z();
+ if (context !== undefined) return $(context).find(selector);
+ else if (isF(selector)) return $(document).ready(selector);
+ else if (selector instanceof Z) return selector;
+ else {
+ var dom;
+ if (isA(selector)) dom = compact(selector);
+ else if (elementTypes.indexOf(selector.nodeType) >= 0 || selector === window)
+ dom = [selector], selector = null;
+ else if (fragmentRE.test(selector))
+ dom = fragment(selector, RegExp.$1), selector = null;
+ else if (selector.nodeType && selector.nodeType == 3) dom = [selector];
+ else dom = $$(document, selector);
+ return Z(dom, selector);
+ }
+ }
+
+ $.extend = function(target){
+ slice.call(arguments, 1).forEach(function(source) {
+ for (key in source) target[key] = source[key];
+ })
+ return target;
+ }
+ $.qsa = $$ = function(element, selector){ return slice.call(element.querySelectorAll(selector)) }
+
+ function filtered(nodes, selector){
+ return selector === undefined ? $(nodes) : $(nodes).filter(selector);
+ }
+
+ function funcArg(context, arg, idx, payload){
+ return isF(arg) ? arg.call(context, idx, payload) : arg;
+ }
+
+ $.isFunction = isF;
+ $.isObject = isO;
+ $.isArray = isA;
+
+ $.fn = {
+ forEach: emptyArray.forEach,
+ map: emptyArray.map,
+ reduce: emptyArray.reduce,
+ push: emptyArray.push,
+ indexOf: emptyArray.indexOf,
+ concat: emptyArray.concat,
+ slice: function(){
+ return $(slice.apply(this, arguments));
+ },
+ ready: function(callback){
+ if (document.readyState == 'complete' || document.readyState == 'loaded') callback();
+ document.addEventListener('DOMContentLoaded', callback, false);
+ return this;
+ },
+ get: function(idx){ return idx === undefined ? this : this[idx] },
+ size: function(){ return this.length },
+ remove: function () {
+ return this.each(function () {
+ if (this.parentNode != null) {
+ this.parentNode.removeChild(this);
+ }
+ });
+ },
+ each: function(callback){
+ this.forEach(function(el, idx){ callback.call(el, idx, el) });
+ return this;
+ },
+ filter: function(selector){
+ return $([].filter.call(this, function(element){
+ return $$(element.parentNode, selector).indexOf(element) >= 0;
+ }));
+ },
+ end: function(){
+ return this.prevObject || $();
+ },
+ add:function(selector,context){
+ return $(uniq(this.concat($(selector,context))));
+ },
+ is: function(selector){
+ return this.length > 0 && $(this[0]).filter(selector).length > 0;
+ },
+ not: function(selector){
+ var nodes=[];
+ if (isF(selector) && selector.call !== undefined)
+ this.each(function(idx){
+ if (!selector.call(this,idx)) nodes.push(this);
+ });
+ else {
+ var excludes = typeof selector == 'string' ? this.filter(selector) :
+ ('length' in selector && isF(selector.item)) ? slice.call(selector) : $(selector);
+ this.forEach(function(el){
+ if (excludes.indexOf(el) < 0) nodes.push(el);
+ });
+ }
+ return $(nodes);
+ },
+ eq: function(idx){
+ return idx === -1 ? this.slice(idx) : this.slice(idx, + idx + 1);
+ },
+ first: function(){ return $(this[0]) },
+ last: function(){ return $(this[this.length - 1]) },
+ find: function(selector){
+ var result;
+ if (this.length == 1) result = $$(this[0], selector);
+ else result = flatten(this.map(function(el){ return $$(el, selector) }));
+ return $(result);
+ },
+ closest: function(selector, context){
+ var node = this[0], nodes = $$(context !== undefined ? context : document, selector);
+ if (nodes.length === 0) node = null;
+ while(node && node !== document && nodes.indexOf(node) < 0) node = node.parentNode;
+ return $(node !== document && node);
+ },
+ parents: function(selector){
+ var ancestors = [], nodes = this;
+ while (nodes.length > 0)
+ nodes = compact(nodes.map(function(node){
+ if ((node = node.parentNode) && node !== document && ancestors.indexOf(node) < 0) {
+ ancestors.push(node);
+ return node;
+ }
+ }));
+ return filtered(ancestors, selector);
+ },
+ parent: function(selector){
+ return filtered(uniq(compact(this.pluck('parentNode'))), selector);
+ },
+ children: function(selector){
+ return filtered(flatten(this.map(function(el){ return slice.call(el.children) })), selector);
+ },
+ siblings: function(selector){
+ return filtered(flatten(this.map(function(el){
+ return slice.call(el.parentNode.children).filter(function(child){ return child!==el });
+ })), selector);
+ },
+ empty: function(){ return this.each(function(){ this.innerHTML = '' }) },
+ pluck: function(property){ return this.map(function(element){ return element[property] }) },
+ show: function(){
+ return this.each(function() {
+ this.style.display == "none" && (this.style.display = null);
+ if (getComputedStyle(this, '').getPropertyValue("display") == "none") {
+ this.style.display = defaultDisplay(this.nodeName)
+ }
+ })
+ },
+ replaceWith: function(newContent) {
+ return this.each(function() {
+ var par=this.parentNode,next=this.nextSibling;
+ $(this).remove();
+ next ? $(next).before(newContent) : $(par).append(newContent);
+ });
+ },
+ wrap: function(newContent) {
+ return this.each(function() {
+ $(this).wrapAll($(newContent)[0].cloneNode(false));
+ });
+ },
+ wrapAll: function(newContent) {
+ if (this[0]) {
+ $(this[0]).before(newContent = $(newContent));
+ newContent.append(this);
+ }
+ return this;
+ },
+ unwrap: function(){
+ this.parent().each(function(){
+ $(this).replaceWith($(this).children());
+ });
+ return this;
+ },
+ hide: function(){
+ return this.css("display", "none")
+ },
+ toggle: function(setting){
+ return (setting === undefined ? this.css("display") == "none" : setting) ? this.show() : this.hide();
+ },
+ prev: function(){ return $(this.pluck('previousElementSibling')) },
+ next: function(){ return $(this.pluck('nextElementSibling')) },
+ html: function(html){
+ return html === undefined ?
+ (this.length > 0 ? this[0].innerHTML : null) :
+ this.each(function(idx){ this.innerHTML = funcArg(this, html, idx, this.innerHTML) });
+ },
+ text: function(text){
+ return text === undefined ?
+ (this.length > 0 ? this[0].textContent : null) :
+ this.each(function(){ this.textContent = text });
+ },
+ attr: function(name, value){
+ return (typeof name == 'string' && value === undefined) ?
+ (this.length > 0 && this[0].nodeName == 'INPUT' && this[0].type == 'text' && name == 'value') ? (this.val()) :
+ (this.length > 0 ? this[0].getAttribute(name) || (name in this[0] ? this[0][name] : undefined) : undefined) :
+ this.each(function(idx){
+ if (isO(name)) for (key in name) this.setAttribute(key, name[key])
+ else this.setAttribute(name, funcArg(this, value, idx, this.getAttribute(name)));
+ });
+ },
+ removeAttr: function(name) {
+ return this.each(function() { this.removeAttribute(name); });
+ },
+ data: function(name, value){
+ return this.attr('data-' + name, value);
+ },
+ val: function(value){
+ return (value === undefined) ?
+ (this.length > 0 ? this[0].value : null) :
+ this.each(function(){
+ this.value = value;
+ });
+ },
+ offset: function(){
+ if(this.length==0) return null;
+ var obj = this[0].getBoundingClientRect();
+ return {
+ left: obj.left + document.body.scrollLeft,
+ top: obj.top + document.body.scrollTop,
+ width: obj.width,
+ height: obj.height
+ };
+ },
+ css: function(property, value){
+ if (value === undefined && typeof property == 'string')
+ return this[0].style[camelize(property)] || getComputedStyle(this[0], '').getPropertyValue(property);
+ var css = '';
+ for (key in property) css += dasherize(key) + ':' + maybeAddPx(key, property[key]) + ';';
+ if (typeof property == 'string') css = dasherize(property) + ":" + maybeAddPx(property, value);
+ return this.each(function() { this.style.cssText += ';' + css });
+ },
+ index: function(element){
+ return element ? this.indexOf($(element)[0]) : this.parent().children().indexOf(this[0]);
+ },
+ hasClass: function(name){
+ if (this.length < 1) return false;
+ else return classRE(name).test(this[0].className);
+ },
+ addClass: function(name){
+ return this.each(function(idx) {
+ classList = [];
+ var cls = this.className, newName = funcArg(this, name, idx, cls);
+ newName.split(/\s+/g).forEach(function(klass) {
+ if (!$(this).hasClass(klass)) {
+ classList.push(klass)
+ }
+ }, this);
+ classList.length && (this.className += (cls ? " " : "") + classList.join(" "))
+ });
+ },
+ removeClass: function(name){
+ return this.each(function(idx) {
+ if(name === undefined)
+ return this.className = '';
+ classList = this.className;
+ funcArg(this, name, idx, classList).split(/\s+/g).forEach(function(klass) {
+ classList = classList.replace(classRE(klass), " ")
+ });
+ this.className = classList.trim()
+ });
+ },
+ toggleClass: function(name, when){
+ return this.each(function(idx){
+ var cls = this.className, newName = funcArg(this, name, idx, cls);
+ ((when !== undefined && !when) || $(this).hasClass(newName)) ?
+ $(this).removeClass(newName) : $(this).addClass(newName)
+ });
+ },
+ submit: function () {
+ return this.each(function () {
+ try {
+ // Submit first form element
+ this.submit();
+ return;
+ } catch(e) {};
+ });
+ }
+ };
+
+ 'filter,add,not,eq,first,last,find,closest,parents,parent,children,siblings'.split(',').forEach(function(property){
+ var fn = $.fn[property];
+ $.fn[property] = function() {
+ var ret = fn.apply(this, arguments);
+ ret.prevObject = this;
+ return ret;
+ }
+ });
+
+ ['width', 'height'].forEach(function(property){
+ $.fn[property] = function(){ var offset = this.offset(); return offset ? offset[property] : null }
+ });
+
+ function insert(operator, target, node) {
+ var parent = (!operator || operator == 3) ? target : target.parentNode;
+ parent.insertBefore(node,
+ !operator ? parent.firstChild : // prepend
+ operator == 1 ? target.nextSibling : // after
+ operator == 2 ? target : // before
+ null); // append
+ }
+
+ adjacencyOperators.forEach(function(key, operator) {
+ $.fn[key] = function(html){
+ var nodes = typeof(html) == 'object' ? html : fragment(html);
+ if (!('length' in nodes)) nodes = [nodes];
+ if (nodes.length < 1) return this;
+ var size = this.length, copyByClone = size > 1, inReverse = operator < 2;
+
+ return this.each(function(index, target){
+ for (var i = 0; i < nodes.length; i++) {
+ var node = nodes[inReverse ? nodes.length-i-1 : i];
+ if (copyByClone && index < size - 1) node = node.cloneNode(true);
+ insert(operator, target, node);
+ }
+ });
+ };
+ });
+
+ reverseAdjacencyOperators.forEach(function(key) {
+ $.fn[key+'To'] = function(html){
+ if (typeof(html) != 'object') html = $(html);
+ html[key](this);
+ return this;
+ };
+ });
+
+ Z.prototype = $.fn;
+
+ return $;
+})();
+
+'$' in window || (window.$ = Zepto);
+// Zepto.js
+// (c) 2010, 2011 Thomas Fuchs
+// Zepto.js may be freely distributed under the MIT license.
+
+(function($){
+ var $$ = $.qsa, handlers = {}, _zid = 1;
+ function zid(element) {
+ return element._zid || (element._zid = _zid++);
+ }
+ function findHandlers(element, event, fn, selector) {
+ event = parse(event);
+ if (event.ns) var matcher = matcherFor(event.ns);
+ return (handlers[zid(element)] || []).filter(function(handler) {
+ return handler
+ && (!event.e || handler.e == event.e)
+ && (!event.ns || matcher.test(handler.ns))
+ && (!fn || handler.fn == fn)
+ && (!selector || handler.sel == selector);
+ });
+ }
+ function parse(event) {
+ var parts = ('' + event).split('.');
+ return {e: parts[0], ns: parts.slice(1).sort().join(' ')};
+ }
+ function matcherFor(ns) {
+ return new RegExp('(?:^| )' + ns.replace(' ', ' .* ?') + '(?: |$)');
+ }
+
+ function add(element, events, fn, selector, delegate){
+ var id = zid(element), set = (handlers[id] || (handlers[id] = []));
+ events.split(/\s/).forEach(function(event){
+ var callback = delegate || fn;
+ var proxyfn = function(event) { return callback.call(element, event, event.data) };
+ var handler = $.extend(parse(event), {fn: fn, proxy: proxyfn, sel: selector, del: delegate, i: set.length});
+ set.push(handler);
+ element.addEventListener(handler.e, proxyfn, false);
+ });
+ }
+ function remove(element, events, fn, selector){
+ var id = zid(element);
+ (events || '').split(/\s/).forEach(function(event){
+ findHandlers(element, event, fn, selector).forEach(function(handler){
+ delete handlers[id][handler.i];
+ element.removeEventListener(handler.e, handler.proxy, false);
+ });
+ });
+ }
+
+ $.event = { add: add, remove: remove }
+
+ $.fn.bind = function(event, callback){
+ return this.each(function(){
+ add(this, event, callback);
+ });
+ };
+ $.fn.unbind = function(event, callback){
+ return this.each(function(){
+ remove(this, event, callback);
+ });
+ };
+ $.fn.one = function(event, callback){
+ return this.each(function(){
+ var self = this;
+ add(this, event, function wrapper(evt){
+ callback.call(self, evt);
+ remove(self, event, arguments.callee);
+ });
+ });
+ };
+
+ var eventMethods = ['preventDefault', 'stopImmediatePropagation', 'stopPropagation'];
+ function createProxy(event) {
+ var proxy = $.extend({originalEvent: event}, event);
+ eventMethods.forEach(function(key) {
+ proxy[key] = function() {return event[key].apply(event, arguments)};
+ });
+ return proxy;
+ }
+
+ $.fn.delegate = function(selector, event, callback){
+ return this.each(function(i, element){
+ add(element, event, callback, selector, function(e, data){
+ var target = e.target, nodes = $$(element, selector);
+ while (target && nodes.indexOf(target) < 0) target = target.parentNode;
+ if (target && !(target === element) && !(target === document)) {
+ callback.call(target, $.extend(createProxy(e), {
+ currentTarget: target, liveFired: element
+ }), data);
+ }
+ });
+ });
+ };
+ $.fn.undelegate = function(selector, event, callback){
+ return this.each(function(){
+ remove(this, event, callback, selector);
+ });
+ }
+
+ $.fn.live = function(event, callback){
+ $(document.body).delegate(this.selector, event, callback);
+ return this;
+ };
+ $.fn.die = function(event, callback){
+ $(document.body).undelegate(this.selector, event, callback);
+ return this;
+ };
+
+ $.fn.trigger = function(event, data){
+ var type = event.type || event;
+ if(typeof event !== "object"){
+ event = document.createEvent('Events');
+ event.initEvent(type, true, true)
+ }
+ event.data = data;
+ return this.each(function(){
+ this.dispatchEvent(event);
+ });
+ };
+
+ $.Event = function(src, props) {
+ var event = document.createEvent('Events');
+ if (props) $.extend(event, props);
+ event.initEvent(src, true, true);
+ return event;
+ };
+
+})(Zepto);
+// Zepto.js
+// (c) 2010, 2011 Thomas Fuchs
+// Zepto.js may be freely distributed under the MIT license.
+
+(function($){
+ function detect(ua){
+ var ua = ua, os = {},
+ android = ua.match(/(Android)\s+([\d.]+)/),
+ ipad = ua.match(/(iPad).*OS\s([\d_]+)/),
+ iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/),
+ webos = ua.match(/(webOS|hpwOS)[\s\/]([\d.]+)/),
+ touchpad = webos && ua.match(/TouchPad/),
+ blackberry = ua.match(/(BlackBerry).*Version\/([\d.]+)/);
+ if (android) os.android = true, os.version = android[2];
+ if (iphone) os.ios = true, os.version = iphone[2].replace(/_/g, '.'), os.iphone = true;
+ if (ipad) os.ios = true, os.version = ipad[2].replace(/_/g, '.'), os.ipad = true;
+ if (webos) os.webos = true, os.version = webos[2];
+ if (touchpad) os.touchpad = true;
+ if (blackberry) os.blackberry = true, os.version = blackberry[2];
+ return os;
+ }
+
+ // ### $.os
+ //
+ // Object contains information about running environmental
+ //
+ // *Example:*
+ //
+ // $.os.ios // => true if running on Apple iOS
+ // $.os.android // => true if running on Android
+ // $.os.webos // => true if running on HP/Palm WebOS
+ // $.os.touchpad // => true if running on a HP TouchPad
+ // $.os.version // => string with version number,
+ // "4.0", "3.1.1", "2.1", etc.
+ // $.os.iphone // => true if running on iPhone
+ // $.os.ipad // => true if running on iPad
+ // $.os.blackberry // => true if running on BlackBerry
+ //
+ $.os = detect(navigator.userAgent);
+ $.__detect = detect;
+
+ var v = navigator.userAgent.match(/WebKit\/([\d.]+)/);
+ $.browser = v ? { webkit: true, version: v[1] } : { webkit: false };
+
+})(Zepto);
+// Zepto.js
+// (c) 2010, 2011 Thomas Fuchs
+// Zepto.js may be freely distributed under the MIT license.
+
+(function($, undefined){
+ var supportedTransforms = [
+ 'scale scaleX scaleY',
+ 'translate', 'translateX', 'translateY', 'translate3d',
+ 'skew', 'skewX', 'skewY',
+ 'rotate', 'rotateX', 'rotateY', 'rotateZ',
+ 'matrix'
+ ];
+
+ $.fn.anim = function(properties, duration, ease, callback){
+ var transforms = [], cssProperties = {}, key, that = this, wrappedCallback;
+
+ for (key in properties)
+ if (supportedTransforms.indexOf(key)>0)
+ transforms.push(key + '(' + properties[key] + ')');
+ else
+ cssProperties[key] = properties[key];
+
+ wrappedCallback = function(){
+ that.css({'-webkit-transition':'none'});
+ callback && callback();
+ }
+
+ if (duration > 0)
+ this.one('webkitTransitionEnd', wrappedCallback);
+ else
+ setTimeout(wrappedCallback, 0);
+
+ return this.css(
+ $.extend({
+ '-webkit-transition': 'all ' + (duration !== undefined ? duration : 0.5) + 's ' + (ease || ''),
+ '-webkit-transform': transforms.join(' ')
+ }, cssProperties)
+ );
+ }
+})(Zepto);
+// Zepto.js
+// (c) 2010, 2011 Thomas Fuchs
+// Zepto.js may be freely distributed under the MIT license.
+
+(function($){
+ var jsonpID = 0,
+ isObject = $.isObject,
+ key;
+
+ // Empty function, used as default callback
+ function empty() {}
+
+ // ### $.ajaxJSONP
+ //
+ // Load JSON from a server in a different domain (JSONP)
+ //
+ // *Arguments:*
+ //
+ // options — object that configure the request,
+ // see avaliable options below
+ //
+ // *Avaliable options:*
+ //
+ // url — url to which the request is sent
+ // success — callback that is executed if the request succeeds
+ //
+ // *Example:*
+ //
+ // $.ajaxJSONP({
+ // url: 'http://example.com/projects?callback=?',
+ // success: function (data) {
+ // projects.push(json);
+ // }
+ // });
+ //
+ $.ajaxJSONP = function(options){
+ var jsonpString = 'jsonp' + ++jsonpID,
+ script = document.createElement('script');
+ window[jsonpString] = function(data){
+ options.success(data);
+ delete window[jsonpString];
+ };
+ script.src = options.url.replace(/=\?/, '=' + jsonpString);
+ $('head').append(script);
+ };
+
+ // ### $.ajaxSettings
+ //
+ // AJAX settings
+ //
+ $.ajaxSettings = {
+ // Default type of request
+ type: 'GET',
+ // Callback that is executed before request
+ beforeSend: empty,
+ // Callback that is executed if the request succeeds
+ success: empty,
+ // Callback that is executed the the server drops error
+ error: empty,
+ // Callback that is executed on request complete (both: error and success)
+ complete: empty,
+ // MIME types mapping
+ accepts: {
+ script: 'text/javascript, application/javascript',
+ json: 'application/json',
+ xml: 'application/xml, text/xml',
+ html: 'text/html',
+ text: 'text/plain'
+ }
+ };
+
+ // ### $.ajax
+ //
+ // Perform AJAX request
+ //
+ // *Arguments:*
+ //
+ // options — object that configure the request,
+ // see avaliable options below
+ //
+ // *Avaliable options:*
+ //
+ // type ('GET') — type of request GET / POST
+ // url (window.location) — url to which the request is sent
+ // data — data to send to server,
+ // can be string or object
+ // dataType ('json') — what response type you accept from
+ // the server:
+ // 'json', 'xml', 'html', or 'text'
+ // success — callback that is executed if
+ // the request succeeds
+ // error — callback that is executed if
+ // the server drops error
+ //
+ // *Example:*
+ //
+ // $.ajax({
+ // type: 'POST',
+ // url: '/projects',
+ // data: { name: 'Zepto.js' },
+ // dataType: 'html',
+ // success: function (data) {
+ // $('body').append(data);
+ // },
+ // error: function (xhr, type) {
+ // alert('Error!');
+ // }
+ // });
+ //
+ $.ajax = function(options){
+ options = options || {};
+ var settings = $.extend({}, options);
+ for (key in $.ajaxSettings) if (!settings[key]) settings[key] = $.ajaxSettings[key];
+
+ if (/=\?/.test(settings.url)) return $.ajaxJSONP(settings);
+
+ if (!settings.url) settings.url = window.location.toString();
+ if (settings.data && !settings.contentType) settings.contentType = 'application/x-www-form-urlencoded';
+ if (isObject(settings.data)) settings.data = $.param(settings.data);
+
+ if (settings.type.match(/get/i) && settings.data) {
+ var queryString = settings.data;
+ if (settings.url.match(/\?.*=/)) {
+ queryString = '&' + queryString;
+ } else if (queryString[0] != '?') {
+ queryString = '?' + queryString;
+ }
+ settings.url += queryString;
+ }
+
+ var mime = settings.accepts[settings.dataType],
+ xhr = new XMLHttpRequest();
+
+ settings.headers = $.extend({'X-Requested-With': 'XMLHttpRequest'}, settings.headers || {});
+ if (mime) settings.headers['Accept'] = mime;
+
+ xhr.onreadystatechange = function(){
+ if (xhr.readyState == 4) {
+ var result, error = false;
+ if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 0) {
+ if (mime == 'application/json' && !(xhr.responseText == '')) {
+ try { result = JSON.parse(xhr.responseText); }
+ catch (e) { error = e; }
+ }
+ else result = xhr.responseText;
+ if (error) settings.error(xhr, 'parsererror', error);
+ else settings.success(result, 'success', xhr);
+ } else {
+ error = true;
+ settings.error(xhr, 'error');
+ }
+ settings.complete(xhr, error ? 'error' : 'success');
+ }
+ };
+
+ xhr.open(settings.type, settings.url, true);
+ if (settings.beforeSend(xhr, settings) === false) {
+ xhr.abort();
+ return false;
+ }
+
+ if (settings.contentType) settings.headers['Content-Type'] = settings.contentType;
+ for (name in settings.headers) xhr.setRequestHeader(name, settings.headers[name]);
+ xhr.send(settings.data);
+
+ return xhr;
+ };
+
+ // ### $.get
+ //
+ // Load data from the server using a GET request
+ //
+ // *Arguments:*
+ //
+ // url — url to which the request is sent
+ // success — callback that is executed if the request succeeds
+ //
+ // *Example:*
+ //
+ // $.get(
+ // '/projects/42',
+ // function (data) {
+ // $('body').append(data);
+ // }
+ // );
+ //
+ $.get = function(url, success){ $.ajax({ url: url, success: success }) };
+
+ // ### $.post
+ //
+ // Load data from the server using POST request
+ //
+ // *Arguments:*
+ //
+ // url — url to which the request is sent
+ // [data] — data to send to server, can be string or object
+ // [success] — callback that is executed if the request succeeds
+ // [dataType] — type of expected response
+ // 'json', 'xml', 'html', or 'text'
+ //
+ // *Example:*
+ //
+ // $.post(
+ // '/projects',
+ // { name: 'Zepto.js' },
+ // function (data) {
+ // $('body').append(data);
+ // },
+ // 'html'
+ // );
+ //
+ $.post = function(url, data, success, dataType){
+ if ($.isFunction(data)) dataType = dataType || success, success = data, data = null;
+ $.ajax({ type: 'POST', url: url, data: data, success: success, dataType: dataType });
+ };
+
+ // ### $.getJSON
+ //
+ // Load JSON from the server using GET request
+ //
+ // *Arguments:*
+ //
+ // url — url to which the request is sent
+ // success — callback that is executed if the request succeeds
+ //
+ // *Example:*
+ //
+ // $.getJSON(
+ // '/projects/42',
+ // function (json) {
+ // projects.push(json);
+ // }
+ // );
+ //
+ $.getJSON = function(url, success){ $.ajax({ url: url, success: success, dataType: 'json' }) };
+
+ // ### $.fn.load
+ //
+ // Load data from the server into an element
+ //
+ // *Arguments:*
+ //
+ // url — url to which the request is sent
+ // [success] — callback that is executed if the request succeeds
+ //
+ // *Examples:*
+ //
+ // $('#project_container').get(
+ // '/projects/42',
+ // function () {
+ // alert('Project was successfully loaded');
+ // }
+ // );
+ //
+ // $('#project_comments').get(
+ // '/projects/42 #comments',
+ // function () {
+ // alert('Comments was successfully loaded');
+ // }
+ // );
+ //
+ $.fn.load = function(url, success){
+ if (!this.length) return this;
+ var self = this, parts = url.split(/\s/), selector;
+ if (parts.length > 1) url = parts[0], selector = parts[1];
+ $.get(url, function(response){
+ self.html(selector ?
+ $(document.createElement('div')).html(response).find(selector).html()
+ : response);
+ success && success();
+ });
+ return this;
+ };
+
+ // ### $.param
+ //
+ // Encode object as a string for submission
+ //
+ // *Arguments:*
+ //
+ // obj — object to serialize
+ // [v] — root node
+ //
+ // *Example:*
+ //
+ // $.param( { name: 'Zepto.js', version: '0.6' } );
+ //
+ $.param = function(obj, v){
+ var result = [], add = function(key, value){
+ result.push(encodeURIComponent(v ? v + '[' + key + ']' : key)
+ + '=' + encodeURIComponent(value));
+ },
+ isObjArray = $.isArray(obj);
+
+ for(key in obj)
+ if(isObject(obj[key]))
+ result.push($.param(obj[key], (v ? v + '[' + key + ']' : key)));
+ else
+ add(isObjArray ? '' : key, obj[key]);
+
+ return result.join('&').replace('%20', '+');
+ };
+})(Zepto);
+// Zepto.js
+// (c) 2010, 2011 Thomas Fuchs
+// Zepto.js may be freely distributed under the MIT license.
+
+(function($){
+ var touch = {}, touchTimeout;
+
+ function parentIfText(node){
+ return 'tagName' in node ? node : node.parentNode;
+ }
+
+ function swipeDirection(x1, x2, y1, y2){
+ var xDelta = Math.abs(x1 - x2), yDelta = Math.abs(y1 - y2);
+ if (xDelta >= yDelta) {
+ return (x1 - x2 > 0 ? 'Left' : 'Right');
+ } else {
+ return (y1 - y2 > 0 ? 'Up' : 'Down');
+ }
+ }
+
+ $(document).ready(function(){
+ $(document.body).bind('touchstart', function(e){
+ var now = Date.now(), delta = now - (touch.last || now);
+ touch.target = parentIfText(e.touches[0].target);
+ touchTimeout && clearTimeout(touchTimeout);
+ touch.x1 = e.touches[0].pageX;
+ touch.y1 = e.touches[0].pageY;
+ if (delta > 0 && delta <= 250) touch.isDoubleTap = true;
+ touch.last = now;
+ }).bind('touchmove', function(e){
+ touch.x2 = e.touches[0].pageX;
+ touch.y2 = e.touches[0].pageY;
+ }).bind('touchend', function(e){
+ if (touch.isDoubleTap) {
+ $(touch.target).trigger('doubleTap');
+ touch = {};
+ } else if (touch.x2 > 0 || touch.y2 > 0) {
+ (Math.abs(touch.x1 - touch.x2) > 30 || Math.abs(touch.y1 - touch.y2) > 30) &&
+ $(touch.target).trigger('swipe') &&
+ $(touch.target).trigger('swipe' + (swipeDirection(touch.x1, touch.x2, touch.y1, touch.y2)));
+ touch.x1 = touch.x2 = touch.y1 = touch.y2 = touch.last = 0;
+ } else if ('last' in touch) {
+ touchTimeout = setTimeout(function(){
+ touchTimeout = null;
+ $(touch.target).trigger('tap')
+ touch = {};
+ }, 250);
+ }
+ }).bind('touchcancel', function(){ touch = {} });
+ });
+
+ ['swipe', 'swipeLeft', 'swipeRight', 'swipeUp', 'swipeDown', 'doubleTap', 'tap'].forEach(function(m){
+ $.fn[m] = function(callback){ return this.bind(m, callback) }
+ });
+})(Zepto);
View
1 views/app.coffee
@@ -0,0 +1 @@
+console.log "hello from Coffee"
View
7 views/index.haml
@@ -0,0 +1,7 @@
+!!!
+%title New application
+= javascript_includes
+%link{ rel: "stylesheet", type: "text/css", href: "/style.css" }
+
+%h1 New application
+%p Hello from your new app.
View
15 views/style.sass
@@ -0,0 +1,15 @@
+@import "compass"
+
+html
+ background: gray
+
+body
+ font: medium/1.2 Helvetica, sans-serif
+ margin: 10px
+ padding: .5em 1em
+ background: white
+ border: 1px solid #666
+ +border-radius(10px)
+
+h1:first-child
+ margin-top: 0

0 comments on commit 9e65574

Please sign in to comment.
Something went wrong with that request. Please try again.