gollum 4.1.4 → 5.0.0

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/plain_text.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./plain_text.snippets");
-exports.scope = "plain_text";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/powershell.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./powershell.snippets");
-exports.scope = "powershell";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/praat.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./praat.snippets");
-exports.scope = "praat";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/prolog.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./prolog.snippets");
-exports.scope = "prolog";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/properties.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./properties.snippets");
-exports.scope = "properties";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/protobuf.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = "";
-exports.scope = "protobuf";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/python.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./python.snippets");
-exports.scope = "python";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/python.snippets

@@ -1,158 +0,0 @@
-snippet #!
-	#!/usr/bin/env python
-snippet imp
-	import ${1:module}
-snippet from
-	from ${1:package} import ${2:module}
-# Module Docstring
-snippet docs
-	'''
-	File: ${1:FILENAME:file_name}
-	Author: ${2:author}
-	Description: ${3}
-	'''
-snippet wh
-	while ${1:condition}:
-		${2:# TODO: write code...}
-# dowh - does the same as do...while in other languages
-snippet dowh
-	while True:
-		${1:# TODO: write code...}
-		if ${2:condition}:
-			break
-snippet with
-	with ${1:expr} as ${2:var}:
-		${3:# TODO: write code...}
-# New Class
-snippet cl
-	class ${1:ClassName}(${2:object}):
-		"""${3:docstring for $1}"""
-		def __init__(self, ${4:arg}):
-			${5:super($1, self).__init__()}
-			self.$4 = $4
-			${6}
-# New Function
-snippet def
-	def ${1:fname}(${2:`indent('.') ? 'self' : ''`}):
-		"""${3:docstring for $1}"""
-		${4:# TODO: write code...}
-snippet deff
-	def ${1:fname}(${2:`indent('.') ? 'self' : ''`}):
-		${3:# TODO: write code...}
-# New Method
-snippet defs
-	def ${1:mname}(self, ${2:arg}):
-		${3:# TODO: write code...}
-# New Property
-snippet property
-	def ${1:foo}():
-		doc = "${2:The $1 property.}"
-		def fget(self):
-			${3:return self._$1}
-		def fset(self, value):
-			${4:self._$1 = value}
-# Ifs
-snippet if
-	if ${1:condition}:
-		${2:# TODO: write code...}
-snippet el
-	else:
-		${1:# TODO: write code...}
-snippet ei
-	elif ${1:condition}:
-		${2:# TODO: write code...}
-# For
-snippet for
-	for ${1:item} in ${2:items}:
-		${3:# TODO: write code...}
-# Encodes
-snippet cutf8
-	# -*- coding: utf-8 -*-
-snippet clatin1
-	# -*- coding: latin-1 -*-
-snippet cascii
-	# -*- coding: ascii -*-
-# Lambda
-snippet ld
-	${1:var} = lambda ${2:vars} : ${3:action}
-snippet .
-	self.
-snippet try Try/Except
-	try:
-		${1:# TODO: write code...}
-	except ${2:Exception}, ${3:e}:
-		${4:raise $3}
-snippet try Try/Except/Else
-	try:
-		${1:# TODO: write code...}
-	except ${2:Exception}, ${3:e}:
-		${4:raise $3}
-	else:
-		${5:# TODO: write code...}
-snippet try Try/Except/Finally
-	try:
-		${1:# TODO: write code...}
-	except ${2:Exception}, ${3:e}:
-		${4:raise $3}
-	finally:
-		${5:# TODO: write code...}
-snippet try Try/Except/Else/Finally
-	try:
-		${1:# TODO: write code...}
-	except ${2:Exception}, ${3:e}:
-		${4:raise $3}
-	else:
-		${5:# TODO: write code...}
-	finally:
-		${6:# TODO: write code...}
-# if __name__ == '__main__':
-snippet ifmain
-	if __name__ == '__main__':
-		${1:main()}
-# __magic__
-snippet _
-	__${1:init}__${2}
-# python debugger (pdb)
-snippet pdb
-	import pdb; pdb.set_trace()
-# ipython debugger (ipdb)
-snippet ipdb
-	import ipdb; ipdb.set_trace()
-# ipython debugger (pdbbb)
-snippet pdbbb
-	import pdbpp; pdbpp.set_trace()
-snippet pprint
-	import pprint; pprint.pprint(${1})${2}
-snippet "
-	"""
-	${1:doc}
-	"""
-# test function/method
-snippet test
-	def test_${1:description}(${2:self}):
-		${3:# TODO: write code...}
-# test case
-snippet testcase
-	class ${1:ExampleCase}(unittest.TestCase):
-		
-		def test_${2:description}(self):
-			${3:# TODO: write code...}
-snippet fut
-	from __future__ import ${1}
-#getopt
-snippet getopt
-	try:
-		# Short option syntax: "hv:"
-		# Long option syntax: "help" or "verbose="
-		opts, args = getopt.getopt(sys.argv[1:], "${1:short_options}", [${2:long_options}])
-	
-	except getopt.GetoptError, err:
-		# Print debug info
-		print str(err)
-		${3:error_action}
-
-	for option, argument in opts:
-		if option in ("-h", "--help"):
-			${4}
-		elif option in ("-v", "--verbose"):
-			verbose = argument

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/r.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./r.snippets");
-exports.scope = "r";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/r.snippets

@@ -1,121 +0,0 @@
-snippet #!
-	#!/usr/bin/env Rscript
-
-# includes
-snippet lib
-	library(${1:package})
-snippet req
-	require(${1:package})
-snippet source
-	source('${1:file}')
-
-# conditionals
-snippet if
-	if (${1:condition}) {
-		${2:code}
-	}
-snippet el
-	else {
-		${1:code}
-	}
-snippet ei
-	else if (${1:condition}) {
-		${2:code}
-	}
-
-# functions
-snippet fun
-	${1:name} = function (${2:variables}) {
-		${3:code}
-	}
-snippet ret
-	return(${1:code})
-
-# dataframes, lists, etc
-snippet df
-	${1:name}[${2:rows}, ${3:cols}]
-snippet c
-	c(${1:items})
-snippet li
-	list(${1:items})
-snippet mat
-	matrix(${1:data}, nrow=${2:rows}, ncol=${3:cols})
-
-# apply functions
-snippet apply
-	apply(${1:array}, ${2:margin}, ${3:function})
-snippet lapply
-	lapply(${1:list}, ${2:function})
-snippet sapply
-	lapply(${1:list}, ${2:function})
-snippet vapply
-	vapply(${1:list}, ${2:function}, ${3:type})
-snippet mapply
-	mapply(${1:function}, ${2:...})
-snippet tapply
-	tapply(${1:vector}, ${2:index}, ${3:function})
-snippet rapply
-	rapply(${1:list}, ${2:function})
-
-# plyr functions
-snippet dd
-	ddply(${1:frame}, ${2:variables}, ${3:function})
-snippet dl
-	dlply(${1:frame}, ${2:variables}, ${3:function})
-snippet da
-	daply(${1:frame}, ${2:variables}, ${3:function})
-snippet d_
-	d_ply(${1:frame}, ${2:variables}, ${3:function})
-
-snippet ad
-	adply(${1:array}, ${2:margin}, ${3:function})
-snippet al
-	alply(${1:array}, ${2:margin}, ${3:function})
-snippet aa
-	aaply(${1:array}, ${2:margin}, ${3:function})
-snippet a_
-	a_ply(${1:array}, ${2:margin}, ${3:function})
-
-snippet ld
-	ldply(${1:list}, ${2:function})
-snippet ll
-	llply(${1:list}, ${2:function})
-snippet la
-	laply(${1:list}, ${2:function})
-snippet l_
-	l_ply(${1:list}, ${2:function})
-
-snippet md
-	mdply(${1:matrix}, ${2:function})
-snippet ml
-	mlply(${1:matrix}, ${2:function})
-snippet ma
-	maply(${1:matrix}, ${2:function})
-snippet m_
-	m_ply(${1:matrix}, ${2:function})
-
-# plot functions
-snippet pl
-	plot(${1:x}, ${2:y})
-snippet ggp
-	ggplot(${1:data}, aes(${2:aesthetics}))
-snippet img
-	${1:(jpeg,bmp,png,tiff)}(filename="${2:filename}", width=${3}, height=${4}, unit="${5}")
-	${6:plot}
-	dev.off()
-
-# statistical test functions
-snippet fis
-	fisher.test(${1:x}, ${2:y})
-snippet chi
-	chisq.test(${1:x}, ${2:y})
-snippet tt
-	t.test(${1:x}, ${2:y})
-snippet wil
-	wilcox.test(${1:x}, ${2:y})
-snippet cor
-	cor.test(${1:x}, ${2:y})
-snippet fte
-	var.test(${1:x}, ${2:y})
-snippet kvt 
-	kv.test(${1:x}, ${2:y})

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/rdoc.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./rdoc.snippets");
-exports.scope = "rdoc";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/rhtml.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./rhtml.snippets");
-exports.scope = "rhtml";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/rst.snippets

@@ -1,22 +0,0 @@
-# rst
-
-snippet :
-	:${1:field name}: ${2:field body}
-snippet *
-	*${1:Emphasis}*
-snippet **
-	**${1:Strong emphasis}**
-snippet _
-	\`${1:hyperlink-name}\`_
-	.. _\`$1\`: ${2:link-block}
-snippet =
-	${1:Title}
-	=====${2:=}
-	${3}
-snippet -
-	${1:Title}
-	-----${2:-}
-	${3}
-snippet cont:
-	.. contents::
-	

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/ruby.js

@@ -1,7 +0,0 @@
-define(function(require, exports, module) {
-"use strict";
-
-exports.snippetText = require("../requirejs/text!./ruby.snippets");
-exports.scope = "ruby";
-
-});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/snippets/ruby.snippets

@@ -1,928 +0,0 @@
-########################################
-# Ruby snippets - for Rails, see below #
-########################################
-
-# encoding for Ruby 1.9
-snippet enc
-	# encoding: utf-8
-
-# #!/usr/bin/env ruby
-snippet #!
-	#!/usr/bin/env ruby
-	# encoding: utf-8
-
-# New Block
-snippet =b
-	=begin rdoc
-		${1}
-	=end
-snippet y
-	:yields: ${1:arguments}
-snippet rb
-	#!/usr/bin/env ruby -wKU
-snippet beg
-	begin
-		${3}
-	rescue ${1:Exception} => ${2:e}
-	end
-
-snippet req require
-	require "${1}"${2}
-snippet #
-	# =>
-snippet end
-	__END__
-snippet case
-	case ${1:object}
-	when ${2:condition}
-		${3}
-	end
-snippet when
-	when ${1:condition}
-		${2}
-snippet def
-	def ${1:method_name}
-		${2}
-	end
-snippet deft
-	def test_${1:case_name}
-		${2}
-	end
-snippet if
-	if ${1:condition}
-		${2}
-	end
-snippet ife
-	if ${1:condition}
-		${2}
-	else
-		${3}
-	end
-snippet elsif
-	elsif ${1:condition}
-		${2}
-snippet unless
-	unless ${1:condition}
-		${2}
-	end
-snippet while
-	while ${1:condition}
-		${2}
-	end
-snippet for
-	for ${1:e} in ${2:c}
-		${3}
-	end
-snippet until
-	until ${1:condition}
-		${2}
-	end
-snippet cla class .. end
-	class ${1:`substitute(Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`}
-		${2}
-	end
-snippet cla class .. initialize .. end
-	class ${1:`substitute(Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`}
-		def initialize(${2:args})
-			${3}
-		end
-	end
-snippet cla class .. < ParentClass .. initialize .. end
-	class ${1:`substitute(Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} < ${2:ParentClass}
-		def initialize(${3:args})
-			${4}
-		end
-	end
-snippet cla ClassName = Struct .. do .. end
-	${1:`substitute(Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} = Struct.new(:${2:attr_names}) do
-		def ${3:method_name}
-			${4}
-		end
-	end
-snippet cla class BlankSlate .. initialize .. end
-	class ${1:BlankSlate}
-		instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ }
-	end
-snippet cla class << self .. end
-	class << ${1:self}
-		${2}
-	end
-# class .. < DelegateClass .. initialize .. end
-snippet cla-
-	class ${1:`substitute(Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`} < DelegateClass(${2:ParentClass})
-		def initialize(${3:args})
-			super(${4:del_obj})
-
-			${5}
-		end
-	end
-snippet mod module .. end
-	module ${1:`substitute(Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`}
-		${2}
-	end
-snippet mod module .. module_function .. end
-	module ${1:`substitute(Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`}
-		module_function
-
-		${2}
-	end
-snippet mod module .. ClassMethods .. end
-	module ${1:`substitute(Filename(), '\(_\|^\)\(.\)', '\u\2', 'g')`}
-		module ClassMethods
-			${2}
-		end
-
-		module InstanceMethods
-
-		end
-
-		def self.included(receiver)
-			receiver.extend         ClassMethods
-			receiver.send :include, InstanceMethods
-		end
-	end
-# attr_reader
-snippet r
-	attr_reader :${1:attr_names}
-# attr_writer
-snippet w
-	attr_writer :${1:attr_names}
-# attr_accessor
-snippet rw
-	attr_accessor :${1:attr_names}
-snippet atp
-	attr_protected :${1:attr_names}
-snippet ata
-	attr_accessible :${1:attr_names}
-# include Enumerable
-snippet Enum
-	include Enumerable
-
-	def each(&block)
-		${1}
-	end
-# include Comparable
-snippet Comp
-	include Comparable
-
-	def <=>(other)
-		${1}
-	end
-# extend Forwardable
-snippet Forw-
-	extend Forwardable
-# def self
-snippet defs
-	def self.${1:class_method_name}
-		${2}
-	end
-# def method_missing
-snippet defmm
-	def method_missing(meth, *args, &blk)
-		${1}
-	end
-snippet defd
-	def_delegator :${1:@del_obj}, :${2:del_meth}, :${3:new_name}
-snippet defds
-	def_delegators :${1:@del_obj}, :${2:del_methods}
-snippet am
-	alias_method :${1:new_name}, :${2:old_name}
-snippet app
-	if __FILE__ == $PROGRAM_NAME
-		${1}
-	end
-# usage_if()
-snippet usai
-	if ARGV.${1}
-		abort "Usage: #{$PROGRAM_NAME} ${2:ARGS_GO_HERE}"${3}
-	end
-# usage_unless()
-snippet usau
-	unless ARGV.${1}
-		abort "Usage: #{$PROGRAM_NAME} ${2:ARGS_GO_HERE}"${3}
-	end
-snippet array
-	Array.new(${1:10}) { |${2:i}| ${3} }
-snippet hash
-	Hash.new { |${1:hash}, ${2:key}| $1[$2] = ${3} }
-snippet file File.foreach() { |line| .. }
-	File.foreach(${1:"path/to/file"}) { |${2:line}| ${3} }
-snippet file File.read()
-	File.read(${1:"path/to/file"})${2}
-snippet Dir Dir.global() { |file| .. }
-	Dir.glob(${1:"dir/glob/*"}) { |${2:file}| ${3} }
-snippet Dir Dir[".."]
-	Dir[${1:"glob/**/*.rb"}]${2}
-snippet dir
-	Filename.dirname(__FILE__)
-snippet deli
-	delete_if { |${1:e}| ${2} }
-snippet fil
-	fill(${1:range}) { |${2:i}| ${3} }
-# flatten_once()
-snippet flao
-	inject(Array.new) { |${1:arr}, ${2:a}| $1.push(*$2)}${3}
-snippet zip
-	zip(${1:enums}) { |${2:row}| ${3} }
-# downto(0) { |n| .. }
-snippet dow
-	downto(${1:0}) { |${2:n}| ${3} }
-snippet ste
-	step(${1:2}) { |${2:n}| ${3} }
-snippet tim
-	times { |${1:n}| ${2} }
-snippet upt
-	upto(${1:1.0/0.0}) { |${2:n}| ${3} }
-snippet loo
-	loop { ${1} }
-snippet ea
-	each { |${1:e}| ${2} }
-snippet ead
-	each do |${1:e}|
-		${2}
-	end
-snippet eab
-	each_byte { |${1:byte}| ${2} }
-snippet eac- each_char { |chr| .. }
-	each_char { |${1:chr}| ${2} }
-snippet eac- each_cons(..) { |group| .. }
-	each_cons(${1:2}) { |${2:group}| ${3} }
-snippet eai
-	each_index { |${1:i}| ${2} }
-snippet eaid
-	each_index do |${1:i}|
-		${2}
-	end
-snippet eak
-	each_key { |${1:key}| ${2} }
-snippet eakd
-	each_key do |${1:key}|
-		${2}
-	end
-snippet eal
-	each_line { |${1:line}| ${2} }
-snippet eald
-	each_line do |${1:line}|
-		${2}
-	end
-snippet eap
-	each_pair { |${1:name}, ${2:val}| ${3} }
-snippet eapd
-	each_pair do |${1:name}, ${2:val}|
-		${3}
-	end
-snippet eas-
-	each_slice(${1:2}) { |${2:group}| ${3} }
-snippet easd-
-	each_slice(${1:2}) do |${2:group}|
-		${3}
-	end
-snippet eav
-	each_value { |${1:val}| ${2} }
-snippet eavd
-	each_value do |${1:val}|
-		${2}
-	end
-snippet eawi
-	each_with_index { |${1:e}, ${2:i}| ${3} }
-snippet eawid
-	each_with_index do |${1:e},${2:i}|
-		${3}
-	end
-snippet reve
-	reverse_each { |${1:e}| ${2} }
-snippet reved
-	reverse_each do |${1:e}|
-		${2}
-	end
-snippet inj
-	inject(${1:init}) { |${2:mem}, ${3:var}| ${4} }
-snippet injd
-	inject(${1:init}) do |${2:mem}, ${3:var}|
-		${4}
-	end
-snippet map
-	map { |${1:e}| ${2} }
-snippet mapd
-	map do |${1:e}|
-		${2}
-	end
-snippet mapwi-
-	enum_with_index.map { |${1:e}, ${2:i}| ${3} }
-snippet sor
-	sort { |a, b| ${1} }
-snippet sorb
-	sort_by { |${1:e}| ${2} }
-snippet ran
-	sort_by { rand }
-snippet all
-	all? { |${1:e}| ${2} }
-snippet any
-	any? { |${1:e}| ${2} }
-snippet cl
-	classify { |${1:e}| ${2} }
-snippet col
-	collect { |${1:e}| ${2} }
-snippet cold
-	collect do |${1:e}|
-		${2}
-	end
-snippet det
-	detect { |${1:e}| ${2} }
-snippet detd
-	detect do |${1:e}|
-		${2}
-	end
-snippet fet
-	fetch(${1:name}) { |${2:key}| ${3} }
-snippet fin
-	find { |${1:e}| ${2} }
-snippet find
-	find do |${1:e}|
-		${2}
-	end
-snippet fina
-	find_all { |${1:e}| ${2} }
-snippet finad
-	find_all do |${1:e}|
-		${2}
-	end
-snippet gre
-	grep(${1:/pattern/}) { |${2:match}| ${3} }
-snippet sub
-	${1:g}sub(${2:/pattern/}) { |${3:match}| ${4} }
-snippet sca
-	scan(${1:/pattern/}) { |${2:match}| ${3} }
-snippet scad
-	scan(${1:/pattern/}) do |${2:match}|
-		${3}
-	end
-snippet max
-	max { |a, b| ${1} }
-snippet min
-	min { |a, b| ${1} }
-snippet par
-	partition { |${1:e}| ${2} }
-snippet pard
-	partition do |${1:e}|
-		${2}
-	end
-snippet rej
-	reject { |${1:e}| ${2} }
-snippet rejd
-	reject do |${1:e}|
-		${2}
-	end
-snippet sel
-	select { |${1:e}| ${2} }
-snippet seld
-	select do |${1:e}|
-		${2}
-	end
-snippet lam
-	lambda { |${1:args}| ${2} }
-snippet doo
-	do
-		${1}
-	end
-snippet dov
-	do |${1:variable}|
-		${2}
-	end
-snippet :
-	:${1:key} => ${2:"value"}${3}
-snippet ope
-	open(${1:"path/or/url/or/pipe"}, "${2:w}") { |${3:io}| ${4} }
-# path_from_here()
-snippet fpath
-	File.join(File.dirname(__FILE__), *%2[${1:rel path here}])${2}
-# unix_filter {}
-snippet unif
-	ARGF.each_line${1} do |${2:line}|
-		${3}
-	end
-# option_parse {}
-snippet optp
-	require "optparse"
-
-	options = {${1:default => "args"}}
-
-	ARGV.options do |opts|
-		opts.banner = "Usage: #{File.basename($PROGRAM_NAME)}
-snippet opt
-	opts.on( "-${1:o}", "--${2:long-option-name}", ${3:String},
-	         "${4:Option description.}") do |${5:opt}|
-		${6}
-	end
-snippet tc
-	require "test/unit"
-
-	require "${1:library_file_name}"
-
-	class Test${2:$1} < Test::Unit::TestCase
-		def test_${3:case_name}
-			${4}
-		end
-	end
-snippet ts
-	require "test/unit"
-
-	require "tc_${1:test_case_file}"
-	require "tc_${2:test_case_file}"${3}
-snippet as
-	assert ${1:test}, "${2:Failure message.}"${3}
-snippet ase
-	assert_equal ${1:expected}, ${2:actual}${3}
-snippet asne
-	assert_not_equal ${1:unexpected}, ${2:actual}${3}
-snippet asid
-	assert_in_delta ${1:expected_float}, ${2:actual_float}, ${3:2 ** -20}${4}
-snippet asio
-	assert_instance_of ${1:ExpectedClass}, ${2:actual_instance}${3}
-snippet asko
-	assert_kind_of ${1:ExpectedKind}, ${2:actual_instance}${3}
-snippet asn
-	assert_nil ${1:instance}${2}
-snippet asnn
-	assert_not_nil ${1:instance}${2}
-snippet asm
-	assert_match /${1:expected_pattern}/, ${2:actual_string}${3}
-snippet asnm
-	assert_no_match /${1:unexpected_pattern}/, ${2:actual_string}${3}
-snippet aso
-	assert_operator ${1:left}, :${2:operator}, ${3:right}${4}
-snippet asr
-	assert_raise ${1:Exception} { ${2} }
-snippet asrd
-	assert_raise ${1:Exception} do
-		${2}
-	end
-snippet asnr
-	assert_nothing_raised ${1:Exception} { ${2} }
-snippet asnrd
-	assert_nothing_raised ${1:Exception} do
-		${2}
-	end
-snippet asrt
-	assert_respond_to ${1:object}, :${2:method}${3}
-snippet ass assert_same(..)
-	assert_same ${1:expected}, ${2:actual}${3}
-snippet ass assert_send(..)
-	assert_send [${1:object}, :${2:message}, ${3:args}]${4}
-snippet asns
-	assert_not_same ${1:unexpected}, ${2:actual}${3}
-snippet ast
-	assert_throws :${1:expected} { ${2} }
-snippet astd
-	assert_throws :${1:expected} do
-		${2}
-	end
-snippet asnt
-	assert_nothing_thrown { ${1} }
-snippet asntd
-	assert_nothing_thrown do
-		${1}
-	end
-snippet fl
-	flunk "${1:Failure message.}"${2}
-# Benchmark.bmbm do .. end
-snippet bm-
-	TESTS = ${1:10_000}
-	Benchmark.bmbm do |results|
-		${2}
-	end
-snippet rep
-	results.report("${1:name}:") { TESTS.times { ${2} }}
-# Marshal.dump(.., file)
-snippet Md
-	File.open(${1:"path/to/file.dump"}, "wb") { |${2:file}| Marshal.dump(${3:obj}, $2) }${4}
-# Mashal.load(obj)
-snippet Ml
-	File.open(${1:"path/to/file.dump"}, "rb") { |${2:file}| Marshal.load($2) }${3}
-# deep_copy(..)
-snippet deec
-	Marshal.load(Marshal.dump(${1:obj_to_copy}))${2}
-snippet Pn-
-	PStore.new(${1:"file_name.pstore"})${2}
-snippet tra
-	transaction(${1:true}) { ${2} }
-# xmlread(..)
-snippet xml-
-	REXML::Document.new(File.read(${1:"path/to/file"}))${2}
-# xpath(..) { .. }
-snippet xpa
-	elements.each(${1:"//Xpath"}) do |${2:node}|
-		${3}
-	end
-# class_from_name()
-snippet clafn
-	split("::").inject(Object) { |par, const| par.const_get(const) }
-# singleton_class()
-snippet sinc
-	class << self; self end
-snippet nam
-	namespace :${1:`Filename()`} do
-		${2}
-	end
-snippet tas
-	desc "${1:Task description}"
-	task :${2:task_name => [:dependent, :tasks]} do
-		${3}
-	end
-# block
-snippet b
-	{ |${1:var}| ${2} }
-snippet begin
-	begin
-		raise 'A test exception.'
-	rescue Exception => e
-		puts e.message
-		puts e.backtrace.inspect
-	else
-		# other exception
-	ensure
-		# always executed
-	end
-
-#debugging
-snippet debug
-	require 'ruby-debug'; debugger; true;
-snippet pry
-	require 'pry'; binding.pry
-
-#############################################
-# Rails snippets - for pure Ruby, see above #
-#############################################
-snippet art
-	assert_redirected_to ${1::action => "${2:index}"}
-snippet artnp
-	assert_redirected_to ${1:parent}_${2:child}_path(${3:@$1}, ${4:@$2})
-snippet artnpp
-	assert_redirected_to ${1:parent}_${2:child}_path(${3:@$1})
-snippet artp
-	assert_redirected_to ${1:model}_path(${2:@$1})
-snippet artpp
-	assert_redirected_to ${1:model}s_path
-snippet asd
-	assert_difference "${1:Model}.${2:count}", $1 do
-		${3}
-	end
-snippet asnd
-	assert_no_difference "${1:Model}.${2:count}" do
-		${3}
-	end
-snippet asre
-	assert_response :${1:success}, @response.body${2}
-snippet asrj
-	assert_rjs :${1:replace}, "${2:dom id}"
-snippet ass assert_select(..)
-	assert_select '${1:path}', :${2:text} => '${3:inner_html' ${4:do}
-snippet bf
-	before_filter :${1:method}
-snippet bt
-	belongs_to :${1:association}
-snippet crw
-	cattr_accessor :${1:attr_names}
-snippet defcreate
-	def create
-		@${1:model_class_name} = ${2:ModelClassName}.new(params[:$1])
-
-		respond_to do |wants|
-			if @$1.save
-				flash[:notice] = '$2 was successfully created.'
-				wants.html { redirect_to(@$1) }
-				wants.xml  { render :xml => @$1, :status => :created, :location => @$1 }
-			else
-				wants.html { render :action => "new" }
-				wants.xml  { render :xml => @$1.errors, :status => :unprocessable_entity }
-			end
-		end
-	end${3}
-snippet defdestroy
-	def destroy
-		@${1:model_class_name} = ${2:ModelClassName}.find(params[:id])
-		@$1.destroy
-
-		respond_to do |wants|
-			wants.html { redirect_to($1s_url) }
-			wants.xml  { head :ok }
-		end
-	end${3}
-snippet defedit
-	def edit
-		@${1:model_class_name} = ${2:ModelClassName}.find(params[:id])
-	end
-snippet defindex
-	def index
-		@${1:model_class_name} = ${2:ModelClassName}.all
-
-		respond_to do |wants|
-			wants.html # index.html.erb
-			wants.xml  { render :xml => @$1s }
-		end
-	end${3}
-snippet defnew
-	def new
-		@${1:model_class_name} = ${2:ModelClassName}.new
-
-		respond_to do |wants|
-			wants.html # new.html.erb
-			wants.xml  { render :xml => @$1 }
-		end
-	end${3}
-snippet defshow
-	def show
-		@${1:model_class_name} = ${2:ModelClassName}.find(params[:id])
-
-		respond_to do |wants|
-			wants.html # show.html.erb
-			wants.xml  { render :xml => @$1 }
-		end
-	end${3}
-snippet defupdate
-	def update
-		@${1:model_class_name} = ${2:ModelClassName}.find(params[:id])
-
-		respond_to do |wants|
-			if @$1.update_attributes(params[:$1])
-				flash[:notice] = '$2 was successfully updated.'
-				wants.html { redirect_to(@$1) }
-				wants.xml  { head :ok }
-			else
-				wants.html { render :action => "edit" }
-				wants.xml  { render :xml => @$1.errors, :status => :unprocessable_entity }
-			end
-		end
-	end${3}
-snippet flash
-	flash[:${1:notice}] = "${2}"
-snippet habtm
-	has_and_belongs_to_many :${1:object}, :join_table => "${2:table_name}", :foreign_key => "${3}_id"${4}
-snippet hm
-	has_many :${1:object}
-snippet hmd
-	has_many :${1:other}s, :class_name => "${2:$1}", :foreign_key => "${3:$1}_id", :dependent => :destroy${4}
-snippet hmt
-	has_many :${1:object}, :through => :${2:object}
-snippet ho
-	has_one :${1:object}
-snippet i18
-	I18n.t('${1:type.key}')${2}
-snippet ist
-	<%= image_submit_tag("${1:agree.png}", :id => "${2:id}"${3} %>
-snippet log
-	Rails.logger.${1:debug} ${2}
-snippet log2
-	RAILS_DEFAULT_LOGGER.${1:debug} ${2}
-snippet logd
-	logger.debug { "${1:message}" }${2}
-snippet loge
-	logger.error { "${1:message}" }${2}
-snippet logf
-	logger.fatal { "${1:message}" }${2}
-snippet logi
-	logger.info { "${1:message}" }${2}
-snippet logw
-	logger.warn { "${1:message}" }${2}
-snippet mapc
-	${1:map}.${2:connect} '${3:controller/:action/:id}'
-snippet mapca
-	${1:map}.catch_all "*${2:anything}", :controller => "${3:default}", :action => "${4:error}"${5}
-snippet mapr
-	${1:map}.resource :${2:resource}
-snippet maprs
-	${1:map}.resources :${2:resource}
-snippet mapwo
-	${1:map}.with_options :${2:controller} => '${3:thing}' do |$3|
-		${4}
-	end
-snippet mbs
-	before_save :${1:method}
-snippet mcht
-	change_table :${1:table_name} do |t|
-		${2}
-	end
-snippet mp
-	map(&:${1:id})
-snippet mrw
-	mattr_accessor :${1:attr_names}
-snippet oa
-	order("${1:field}")
-snippet od
-	order("${1:field} DESC")
-snippet pa
-	params[:${1:id}]${2}
-snippet ra
-	render :action => "${1:action}"
-snippet ral
-	render :action => "${1:action}", :layout => "${2:layoutname}"
-snippet rest
-	respond_to do |wants|
-		wants.${1:html} { ${2} }
-	end
-snippet rf
-	render :file => "${1:filepath}"
-snippet rfu
-	render :file => "${1:filepath}", :use_full_path => ${2:false}
-snippet ri
-	render :inline => "${1:<%= 'hello' %>}"
-snippet ril
-	render :inline => "${1:<%= 'hello' %>}", :locals => { ${2::name} => "${3:value}"${4} }
-snippet rit
-	render :inline => "${1:<%= 'hello' %>}", :type => ${2::rxml}
-snippet rjson
-	render :json => ${1:text to render}
-snippet rl
-	render :layout => "${1:layoutname}"
-snippet rn
-	render :nothing => ${1:true}
-snippet rns
-	render :nothing => ${1:true}, :status => ${2:401}
-snippet rp
-	render :partial => "${1:item}"
-snippet rpc
-	render :partial => "${1:item}", :collection => ${2:@$1s}
-snippet rpl
-	render :partial => "${1:item}", :locals => { :${2:$1} => ${3:@$1}
-snippet rpo
-	render :partial => "${1:item}", :object => ${2:@$1}
-snippet rps
-	render :partial => "${1:item}", :status => ${2:500}
-snippet rt
-	render :text => "${1:text to render}"
-snippet rtl
-	render :text => "${1:text to render}", :layout => "${2:layoutname}"
-snippet rtlt
-	render :text => "${1:text to render}", :layout => ${2:true}
-snippet rts
-	render :text => "${1:text to render}", :status => ${2:401}
-snippet ru
-	render :update do |${1:page}|
-		$1.${2}
-	end
-snippet rxml
-	render :xml => ${1:text to render}
-snippet sc
-	scope :${1:name}, :where(:@${2:field} => ${3:value})
-snippet sl
-	scope :${1:name}, lambda do |${2:value}|
-		where("${3:field = ?}", ${4:bind var})
-	end
-snippet sha1
-	Digest::SHA1.hexdigest(${1:string})
-snippet sweeper
-	class ${1:ModelClassName}Sweeper < ActionController::Caching::Sweeper
-		observe $1
-
-		def after_save(${2:model_class_name})
-			expire_cache($2)
-		end
-
-		def after_destroy($2)
-			expire_cache($2)
-		end
-
-		def expire_cache($2)
-			expire_page
-		end
-	end
-snippet tcb
-	t.boolean :${1:title}
-	${2}
-snippet tcbi
-	t.binary :${1:title}, :limit => ${2:2}.megabytes
-	${3}
-snippet tcd
-	t.decimal :${1:title}, :precision => ${2:10}, :scale => ${3:2}
-	${4}
-snippet tcda
-	t.date :${1:title}
-	${2}
-snippet tcdt
-	t.datetime :${1:title}
-	${2}
-snippet tcf
-	t.float :${1:title}
-	${2}
-snippet tch
-	t.change :${1:name}, :${2:string}, :${3:limit} => ${4:80}
-	${5}
-snippet tci
-	t.integer :${1:title}
-	${2}
-snippet tcl
-	t.integer :lock_version, :null => false, :default => 0
-	${1}
-snippet tcr
-	t.references :${1:taggable}, :polymorphic => { :default => '${2:Photo}' }
-	${3}
-snippet tcs
-	t.string :${1:title}
-	${2}
-snippet tct
-	t.text :${1:title}
-	${2}
-snippet tcti
-	t.time :${1:title}
-	${2}
-snippet tcts
-	t.timestamp :${1:title}
-	${2}
-snippet tctss
-	t.timestamps
-	${1}
-snippet va
-	validates_associated :${1:attribute}
-snippet vao
-	validates_acceptance_of :${1:terms}
-snippet vc
-	validates_confirmation_of :${1:attribute}
-snippet ve
-	validates_exclusion_of :${1:attribute}, :in => ${2:%w( mov avi )}
-snippet vf
-	validates_format_of :${1:attribute}, :with => /${2:regex}/
-snippet vi
-	validates_inclusion_of :${1:attribute}, :in => %w(${2: mov avi })
-snippet vl
-	validates_length_of :${1:attribute}, :within => ${2:3}..${3:20}
-snippet vn
-	validates_numericality_of :${1:attribute}
-snippet vpo
-	validates_presence_of :${1:attribute}
-snippet vu
-	validates_uniqueness_of :${1:attribute}
-snippet wants
-	wants.${1:js|xml|html} { ${2} }
-snippet wc
-	where(${1:"conditions"}${2:, bind_var})
-snippet wh
-	where(${1:field} => ${2:value})
-snippet xdelete
-	xhr :delete, :${1:destroy}, :id => ${2:1}${3}
-snippet xget
-	xhr :get, :${1:show}, :id => ${2:1}${3}
-snippet xpost
-	xhr :post, :${1:create}, :${2:object} => { ${3} }
-snippet xput
-	xhr :put, :${1:update}, :id => ${2:1}, :${3:object} => { ${4} }${5}
-snippet test
-	test "should ${1:do something}" do
-		${2}
-	end
-#migrations
-snippet mac
-	add_column :${1:table_name}, :${2:column_name}, :${3:data_type}
-snippet mrc
-	remove_column :${1:table_name}, :${2:column_name}
-snippet mrnc
-	rename_column :${1:table_name}, :${2:old_column_name}, :${3:new_column_name}
-snippet mcc
-	change_column :${1:table}, :${2:column}, :${3:type}
-snippet mccc
-	t.column :${1:title}, :${2:string}
-snippet mct
-	create_table :${1:table_name} do |t|
-		t.column :${2:name}, :${3:type}
-	end
-snippet migration
-	class ${1:class_name} < ActiveRecord::Migration
-		def self.up
-			${2}
-		end
-
-		def self.down
-		end
-	end
-
-snippet trc
-	t.remove :${1:column}
-snippet tre
-	t.rename :${1:old_column_name}, :${2:new_column_name}
-	${3}
-snippet tref
-	t.references :${1:model}
-
-#rspec
-snippet it
-	it "${1:spec_name}" do
-		${2}
-	end
-snippet itp
-	it "${1:spec_name}"
-	${2}
-snippet desc
-	describe ${1:class_name} do
-		${2}
-	end
-snippet cont
-	context "${1:message}" do
-		${2}
-	end
-snippet bef
-	before :${1:each} do
-		${2}
-	end
-snippet aft
-	after :${1:each} do
-		${2}
-	end