Created
March 29, 2014 17:26
-
-
Save chucai/9858518 to your computer and use it in GitHub Desktop.
Snippet:Ruby Snippets with added rspec snippets
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# #!/usr/bin/env ruby | |
snippet #! | |
#!/usr/bin/env ruby | |
# 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 "${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} | |
end | |
snippet cla class .. initialize .. end | |
class ${1:`substitute(Filename(), '^.', '\u&', '')`} | |
def initialize(${2:args}) | |
${3} | |
end | |
end | |
snippet cla class .. < ParentClass .. initialize .. end | |
class ${1:`substitute(Filename(), '^.', '\u&', '')`} < ${2:ParentClass} | |
def initialize(${3:args}) | |
${4} | |
end | |
end | |
snippet cla ClassName = Struct .. do .. end | |
${1:`substitute(Filename(), '^.', '\u&', '')`} = 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__/ } | |
snippet cla class << self .. end | |
class << ${1:self} | |
${2} | |
end | |
# class .. < DelegateClass .. initialize .. end | |
snippet cla- | |
class ${1:`substitute(Filename(), '^.', '\u&', '')`} < DelegateClass(${2:ParentClass}) | |
def initialize(${3:args}) | |
super(${4:del_obj}) | |
${5} | |
end | |
end | |
snippet mod module .. end | |
module ${1:`substitute(Filename(), '^.', '\u&', '')`} | |
${2} | |
end | |
snippet mod module .. module_function .. end | |
module ${1:`substitute(Filename(), '^.', '\u&', '')`} | |
module_function | |
${2} | |
end | |
snippet mod module .. ClassMethods .. end | |
module ${1:`substitute(Filename(), '^.', '\u&', '')`} | |
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} | |
# 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}| | |
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 do | |
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 patfh | |
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 asnr | |
assert_nothing_raised(${1:Exception}) { ${2} } | |
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 asnt | |
assert_nothing_thrown { ${1} } | |
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 | |
snippet .and and_raise() | |
.and_raise( ${1:exception}.new("${2:message}") ) | |
snippet .and and_return { } | |
.and_return { ${1} } snippet .and and_return() .and_return( ${1:value} ) | |
snippet .and and_throw() | |
.and_throw( ${1:sym} ) | |
snippet .and and_yield() | |
.and_yield( ${1:values} ) | |
snippet .at at_least() | |
.at_least( ${1:n} ).times | |
snippet .at at_most() | |
.at_most( ${1:n} ).times | |
snippet .on | |
.once | |
snippet .tw | |
.twice | |
snippet .any | |
.any_number_of_times | |
snippet des Describe subject | |
describe "${1:subject}" do | |
${2} | |
end | |
snippet des Describe Type | |
describe ${1:Type} do | |
${2} | |
end | |
snippet des Describe Type, description | |
describe ${1:Type}, "${2:description}" do | |
${3} | |
end | |
snippet des Describe a shared group | |
describe "${1:A Shared Thing}", :shared => true do | |
${2} | |
end | |
snippet it it block | |
it "${1:should do something}" do | |
${2} | |
end | |
snippet it it (pending) | |
it "${1:does something}"${2} | |
snippet .ex | |
.exactly( ${1:n} ).times | |
snippet .w | |
.with( ${1:args} )${2} | |
snippet con | |
context "${1:context}" do | |
${2} | |
end | |
# this is the 'old' mock syntax (rspec 1.x) | |
# use 'double' for rspec 2.x | |
snippet mock | |
${1:var} = mock( "${2:mock_name}"${3:, :null_object => true} ) | |
${4} | |
snippet dou | |
${1:var} = double( "${2:double_name}" )${3:.as_null_object} | |
${4} | |
snippet st | |
stub!( :${1:expectation} ).with( ${2:args} ).and_return( ${3} ) | |
snippet bef Before each test | |
before( :each ) do | |
${1} | |
end | |
snippet bef Before all tests | |
before( :all ) do | |
${1} | |
end | |
snippet aft After each test | |
after( :each ) do | |
${1} | |
end | |
snippet aft After all tests | |
after( :all ) do | |
${1} | |
end | |
snippet sh= | |
${1:target}.should == ${2:value} | |
${3} | |
snippet shn= | |
${1:target}.should_not == ${2:value} | |
${3} | |
snippet she | |
${1:target}.should equal( ${2:value} ) | |
${3} | |
snippet shne | |
${1:target}.should_not equal( ${2:value} ) | |
${3} | |
snippet shm Should contain | |
${1:target}.should =~ /${2:regexp}/ | |
${3} | |
snippet shnm | |
${1:target}.should_not =~ /${2:regexp}/ | |
${3} | |
snippet shm Should match | |
${1:target}.should match( /${2:regexp}/ )${3} | |
snippet shb | |
${1:target}.should be( ${2:result} ) | |
${3} | |
snippet shnb | |
${1:target}.should_not be( ${2:result} ) | |
${3} | |
snippet shbko | |
${1:target}.should be_a_kind_of( ${2:klass} ) | |
${3} | |
snippet shnbko | |
${1:target}.should_not be_a_kind_of( ${2:klass} ) | |
${3} | |
snippet shbio | |
${1:target}.should be_instance_of( ${2:klass} ) | |
${3} | |
snippet shnbio | |
${1:target}.should_not be_instance_of( ${2:klass} ) | |
${3} | |
snippet shbc | |
${1:target}.should be_close( ${2:result}, ${3:tolerance} ) | |
${4} | |
snippet shnbc | |
${1:target}.should_not be_close( ${2:result}, ${3:tolerance} ) | |
${4} | |
snippet shh | |
${1:target}.should have( ${2:num} ).${3:things} | |
${4} | |
snippet shhal | |
${1:target}.should have_at_least( ${2:num} ).${3:things} | |
${4} | |
snippet shham | |
${1:target}.should have_at_most( ${2:num} ).${3:things} | |
${4} | |
snippet shbp | |
${1:target}.should ${2:be_${3:predicate}} ${4} | |
snippet shnbp | |
${1:target}.should_not ${2:be_${3:predicate}} ${4} | |
snippet exre | |
expect { ${1} }.to raise_exception( ${2:ErrorClass}, /${3:message match}/i ) | |
${4} | |
snippet exnre | |
expect { ${1} }.to_not raise_exception( ${2:ErrorClass} ) | |
${3} | |
snippet shre | |
lambda { ${1} }.should raise_exception( ${2:ErrorClass}, /${3:message match}/i ) | |
${4} | |
snippet shnre | |
lambda { ${1} }.should_not raise_exception( ${2:ErrorClass} ) | |
${3} | |
snippet shr | |
${1:mock}.should_receive( :${2:message} )${3} | |
snippet shnr | |
${1:mock}.should_not_receive( :${2:message} )${3} | |
snippet shrt | |
${1:target}.should respond_to( :${2:sym} ) | |
snippet shnrt | |
${1:target}.should_not respond_to( :${2:sym} ) | |
snippet shbl | |
it_should_behave_like "${1:shared behavior}" | |
${2} | |
snippet sim | |
def ${1:matcher_method}( expected ) | |
simple_matcher do |given, matcher| | |
matcher.description = "${2:verb} with #{expected.inspect}" | |
matcher.failure_message = "expected #{given.inspect} to $2 with #{expected.inspect}" | |
matcher.negative_failure_message = "expected #{given.inspect} not to $2 with #{expected.inspect}" | |
given.${3:...checks something and returns a boolean} | |
end | |
end |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment