inc_gollum 4.1.2c

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,158 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,928 @@
+########################################
+# 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