snippets/ruby.json

{
	"Exception block": {
		"prefix": "begin",
		"body": [
			"begin",
			"\t$1",
			"rescue => exception",
			"\t",
			"end"
		]
	},
	"Exception block with ensure": {
		"prefix": "begin ensure",
		"body": [
			"begin",
			"\t$1",
			"rescue => exception",
			"\t",
			"ensure",
			"\t",
			"end"
		]
	},
	"Exception block with else and ensure": {
		"prefix": "begin",
		"body": [
			"begin",
			"\t$1",
			"rescue => exception",
			"\t",
			"else",
			"\t",
			"ensure",
			"\t",
			"end"
		]
	},
	"Class definition with initialize": {
		"prefix": "class init",
		"body": [
			"class ${1:ClassName}",
			"\tdef initialize",
			"\t\t$0",
			"\tend",
			"end"
		]
	},
	"Class definition": {
		"prefix": "class",
		"body": [
			"class ${1:ClassName}",
			"\t$0",
			"end"
		]
	},
	"for loop": {
		"prefix": "for",
		"body": [
			"for ${1:value} in ${2:enumerable} do",
			"\t$0",
			"end"
		]
	},
	"if": {
		"prefix": "if",
		"body": [
			"if ${1:test}",
			"\t$0",
			"end"
		]
	},
	"if else": {
		"prefix": "ife",
		"body": [
			"if ${1:test}",
			"\t$0",
			"else",
			"\t",
			"end"
		]
	},
	"if elsif": {
		"prefix": "ifei",
		"body": [
			"if ${1:test}",
			"\t$0",
			"elsif ",
			"\t",
			"end"
		]
	},
	"if elsif else": {
		"prefix": "ifee",
		"body": [
			"if ${1:test}",
			"\t$0",
			"elsif ",
			"\t",
			"else",
			"\t",
			"end"
		]
	},
	"case": {
		"prefix": "case",
		"body": [
			"case ${1:test}",
			"when $2",
			"\t$3",
			"when $4",
			"\t$5",
			"else",
			"\t$6",
			"end"
		]
	},
	"forever loop": {
		"prefix": "loop",
		"body": [
			"loop do",
			"\t$0",
			"end"
		]
	},
	"Module definition": {
		"prefix": "module",
		"body": [
			"module ${1:ModuleName}",
			"\t$0",
			"end"
		]
	},
	"unless": {
		"prefix": "unless",
		"body": [
			"unless ${1:test}",
			"\t$0",
			"end"
		]
	},
	"until loop": {
		"prefix": "until",
		"body": [
			"until ${1:test}",
			"\t$0",
			"end"
		]
	},
	"while loop": {
		"prefix": "while",
		"body": [
			"while ${1:test}",
			"\t$0",
			"end"
		]
	},
	"method definition": {
		"prefix": "def",
		"body": [
			"def ${1:method_name}",
			"\t$0",
			"end"
		]
	},
  "class method definition": {
    "prefix": "defs",
    "body": [
      "def self.${1:method_name}",
      "\t$0",
      "end"
    ]
  },
  "initialize method definition": {
    "prefix": "definit",
    "body": [
      "def initialize(${1:args})",
      "\t$0",
      "end"
    ]
  },
  "method_missing definition": {
    "prefix": "defmm",
    "body": [
      "def method_missing(meth, *args, &blk)",
      "\t$0",
      "end"
    ]
  },
  "delegator definition": {
    "prefix": "defd",
    "body": "def_delegator :${1:@del_obj}, :${2:del_meth}, :${0:new_name}"
  },
  "alias method definition": {
    "prefix": "am",
    "body": "alias_method :${1:new_name}, :${0:old_name}"
  },
	"Rake Task": {
		"prefix": "rake",
		"description": "Create a Rake Task",
		"body": [
			"namespace :${1} do",
			"\tdesc \"${2}\"",
			"\ttask ${3}: :environment do",
			"\t\t${4}",
			"\tend",
			"end"
		]
	},
	"Insert do … end block": {
		"prefix": "do",
		"body": [
			"do",
			"\t$0",
			"end"
		]
	},
	"Insert do |variable| … end block": {
		"prefix": "dop",
		"body": [
			"do |${1:variable}|",
			"\t$0",
			"end"
		]
	},
	"Insert curly braces block": {
		"prefix": [
			"{p",
			"{P"
		],
		"body": "{ ${1:|${2:variable}| }$0 "
	},
  "Insert encoding comment": {
    "prefix": "enc",
    "body": "# encoding: utf-8$0"
  },
  "Insert frozen literal string": {
    "prefix": "frozen",
    "body": "# frozen_string_literal: true$0"
  },
  "Insert require": {
    "prefix": "req",
    "body": "require '${1}'$0"
  },
  "Insert require_relative": {
    "prefix": "reqr",
    "body": "require_relative '${1}'$0"
  },
  "Insert attr_reader": {
    "prefix": "r",
    "body": "attr_reader :${0:attr_names}"
  },
  "Insert attr_writer": {
    "prefix": "w",
    "body": "attr_writer :${0:attr_names}"
  },
  "Insert attr_accessor": {
    "prefix": "rw",
    "body": "attr_accessor :${0:attr_names}"
  },
  "Insert inctance variable cache": {
    "prefix": "ivc",
    "body": "@${1:variable_name} ||= ${0:cached_value}"
  },
  "Insert each with inline block": {
    "prefix": "ea",
    "body": "each { |${1:e}| $0 }"
  },
  "Insert each with multiline block": {
    "prefix": "ead",
    "body": [
      "each do |${1:e}|",
      "\t$0",
      "end"
    ]
  },
  "Insert each with index inline block": {
    "prefix": "eawi",
    "body": "each_with_index { |${1:e}, ${2:i}| $0 }"
  },
  "Insert each with index multiline block": {
    "prefix": "eawid",
    "body": [
      "each_with_index do |${1:e}, ${2:i}|",
      "\t$0",
      "end"
    ]
  },
  "Insert reduce inline block": {
    "prefix": "red",
    "body": "reduce(${1:init}) { |${2:mem}, ${3:var}| $0 }"
  },
  "Insert reduce multiline block": {
    "prefix": "redd",
    "body": [
      "reduce(${1:init}) do |${2:mem}, ${3:var}|",
      "\t$0",
      "end"
    ]
  },
  "Insert map inline block": {
    "prefix": "map",
    "body": "map { |${1:e}| $0 }"
  },
  "Insert map multiline block": {
    "prefix": "mapd",
    "body": [
      "map do |${1:e}|",
      "\t$0",
      "end"
    ]
  },
  "Insert lambda arrow": {
    "prefix": "->",
    "body": "-> { $0 }"
  },
  "Insert lambda arrow with arguments": {
    "prefix": "->a",
    "body": "->(${1:args}) { $0 }"
  },
  "Insert do block": {
    "prefix": "do",
    "body": [
      "do",
      "\t$0",
      "end"
    ]
  },
  "Insert do block with variables": {
    "prefix": "dov",
    "body": [
      "do |${1:v}|",
      "\t$0",
      "end"
    ]
  },
  "Insert key: value": {
    "prefix": ":",
    "body": "${1:key}: ${2:value}"
  },
  "Insert inline block": {
    "prefix": "b",
    "body": "{ |${1:var}| $0 }"
  },
  "Insert byebug call": {
    "prefix": "bye",
    "body": "require 'byebug'; byebug"
  },
  "Insert debug call": {
    "prefix": "debug",
    "body": "require 'debug'; debugger"
  },
  "Insert pry call": {
    "prefix": "pry",
    "body": "require 'pry'; binding.pry"
  },
  "Insert irb call": {
    "prefix": "irb",
    "body": "binding.irb"
  },
  "Insert RSpec.describe class": {
    "prefix": "rdesc",
    "body": [
      "RSpec.describe ${1:described_class} do",
      "\t$0",
      "end"
    ]
  },
  "Insert describe class": {
    "prefix": "desc",
    "body": [
      "describe ${1:described_class} do",
      "\t$0",
      "end"
    ]
  },
  "Insert describe block": {
    "prefix": "descm",
    "body": [
      "describe '${1:#method}' do",
      "\t${0:pending 'Not implemented'}",
      "end"
    ]
  },
  "Insert context block": {
    "prefix": "cont",
    "body": [
      "context '${1:message}' do",
      "\t$0",
      "end"
    ]
  },
  "Insert before block": {
    "prefix": "bef",
    "body": [
      "before :${1:each} do",
      "\t$0",
      "end"
    ]
  },
  "Insert let": {
    "prefix": "let",
    "body": "let(:${1:object}) { $0 }"
  },
  "Insert let!": {
    "prefix": "let!",
    "body": "let!(:${1:object}) { $0 }"
  },
  "Insert subject definition": {
    "prefix": "subj",
    "body": "subject(:${1:name}) { $0 }"
  },
  "Insert expect": {
    "prefix": "exp",
    "body": "expect(${1:object}).to ${0}"
  },
  "Insert expect with block": {
    "prefix": "expb",
    "body": "expect { ${1:object} }.to ${0}"
  },
  "Insert expect with raise_error": {
    "prefix": "experr",
    "body": "expect { ${1:object} }.to raise_error ${2:StandardError}"
  },
  "Insert allow": {
    "prefix": "allow",
    "body": "allow(${1:object}).to $0"
  },
  "Insert shared_examples": {
    "prefix": "shared",
    "body": "shared_examples '${0:shared examples name}'"
  },
  "Insert it_behaves_like": {
    "prefix": "ibl",
    "body": "it_behaves_like '${0:shared examples name}'"
  },
  "Insert it block": {
    "prefix": "it",
    "body": [
      "it '${1:spec_name}' do",
      "\t$0",
      "end"
    ]
  }
}