# bad - four spacesdefsome_methoddo_somethingend# gooddefsome_methoddo_somethingend

A lot of people these days feel that a maximum line length of 80 characters isjust a remnant of the past and makes little sense today. After all - moderndisplays can easily fit 200+ characters on a single line. Still, there are someimportant benefits to be gained from sticking to shorter lines of code.

First, and foremost - numerous studies have shown that humans read much fastervertically and very long lines of text impede the reading process. As notedearlier, one of the guiding principles of this style guide is to optimize thecode we write for human consumption.

Additionally, limiting the required editor window width makes it possible tohave several files open side-by-side, and works well when using code reviewtools that present the two versions in adjacent columns.

The default wrapping in most tools disrupts the visual structure of the code,making it more difficult to understand. The limits are chosen to avoid wrappingin editors with the window width set to 80, even if the tool places a markerglyph in the final column when wrapping lines. Some web based tools may notoffer dynamic line wrapping at all.

Some teams strongly prefer a longer line length. For code maintained exclusivelyor primarily by a team that can reach agreement on this issue, it is okay toincrease the line length limit up to 100 characters, or all the way upto 120 characters. Please, restrain the urge to go beyond 120 characters.

# badputs'foobar';# superfluous semicolon# goodputs'foobar'

# badputs'foo';puts'bar'# two expressions on the same line# goodputs'foo'puts'bar'puts'foo','bar'# this applies to puts in particular

# badnum.+42# goodnum +42

# badsum=1+2a,b=1,2classFooError<StandardError;end# goodsum=1 +2a,b=1,2classFooError <StandardError;end

# bade=M *c **2# goode=M *c**2

# bado_scale=1 /48r# goodo_scale=1/48r

# badfoo &.barfoo &.barfoo&.bar# goodfoo&.bar

# baduser&.address&.zip# gooduser &&user.address.zip

# baduser &&user.address &&user.address.zip# goodclassUserdefzipaddress&.zipendenduser&.zip

# badsome(arg).other[1,2,3].each{|e|putse}# goodsome(arg).other[1,2,3].each{ |e|putse}

# good - space after { and before }{one:1,two:2}# good - no space after { and before }{one:1,two:2}

# bad"From:#{user.first_name},#{user.last_name}"# good"From:#{user.first_name},#{user.last_name}"

# bad!something# good!something

# bad1 ..3'a' ...'z'# good1..3'a'...'z'

# badcasewhensong.name =='Misty'puts'Not again!'whensong.duration >120puts'Too long!'whenTime.now.hour >21puts"It's too late"elsesong.playend# goodcasewhensong.name =='Misty'puts'Not again!'whensong.duration >120puts'Too long!'whenTime.now.hour >21puts"It's too late"elsesong.playend

This is the style established in both "The Ruby Programming Language" and "Programming Ruby".Historically it is derived from the fact thatcase andswitch statements are not blocks, hence should not be indented, and thewhen andelse keywords are labels (compiled in the C language, they are literally labels forJMP calls).

# bad - pretty convolutedkind=caseyearwhen1850..1889then'Blues'when1890..1909then'Ragtime'when1910..1929then'New Orleans Jazz'when1930..1939then'Swing'when1940..1950then'Bebop'else'Jazz'endresult=ifsome_condcalc_somethingelsecalc_something_elseend# good - it's apparent what's going onkind=caseyearwhen1850..1889then'Blues'when1890..1909then'Ragtime'when1910..1929then'New Orleans Jazz'when1930..1939then'Swing'when1940..1950then'Bebop'else'Jazz'endresult=ifsome_condcalc_somethingelsecalc_something_elseend# good (and a bit more width efficient)kind=caseyearwhen1850..1889then'Blues'when1890..1909then'Ragtime'when1910..1929then'New Orleans Jazz'when1930..1939then'Swing'when1940..1950then'Bebop'else'Jazz'endresult=ifsome_condcalc_somethingelsecalc_something_elseend

# baddefsome_methoddata=initialize(options)data.manipulate!data.resultenddefsome_other_methodresultend# gooddefsome_methoddata=initialize(options)data.manipulate!data.resultenddefsome_other_methodresultend

# bad - It has two empty lines.some_methodsome_method# goodsome_methodsome_method

# badclassFooattr_reader:foodeffoo# do something...endend# goodclassFooattr_reader:foodeffoo# do something...endend

# badclassFoodefbar;endprivatedefbaz;endend# goodclassFoodefbar;endprivatedefbaz;endend

# badclassFoodeffoobegindo_somethingdosomethingendrescuesomethingendtrueendend# goodclassFoodeffoobegindo_somethingdosomethingendrescuesomethingendendend

# bad - easier to move/add/remove parameters, but still not preferredsome_method(size,count,color,)# badsome_method(size,count,color,)# goodsome_method(size,count,color)

# baddefsome_method(arg1=:default,arg2=nil,arg3=[])# do something...end# gooddefsome_method(arg1=:default,arg2=nil,arg3=[])# do something...end

# bad (\ is not needed here)result=1 - \2# bad (\ is required, but still ugly as hell)result=1 \         -2# goodresult=1 -2long_string='First part of the long string' \' and second part of the long string'

# starting point (line is too long)defsend_mail(source)Mailer.deliver(to:'bob@example.com',from:'us@example.com',subject:'Important message',body:source.text)end# bad (double indent)defsend_mail(source)Mailer.deliver(to:'bob@example.com',from:'us@example.com',subject:'Important message',body:source.text)end# gooddefsend_mail(source)Mailer.deliver(to:'bob@example.com',from:'us@example.com',subject:'Important message',body:source.text)end# good (normal indent)defsend_mail(source)Mailer.deliver(to:'bob@example.com',from:'us@example.com',subject:'Important message',body:source.text)end

# baduser.set({name:'John',age:45,permissions:{read:true}})# gooduser.set(name:'John',age:45,permissions:{read:true})

classPerson <ActiveRecord::Base# badattr_reader(:name,:age)# goodattr_reader:name,:age# badvalidates(:name,{presence:true,length:{within:1..10}})# goodvalidates:name,presence:true,length:{within:1..10}end

# badputs(x +y)# goodputs(x +y)

# badcollection[index_or_key]# goodcollection[index_or_key]

# bad - single indentmenu_item=%w[SpamSpamSpamSpamSpamSpamSpamSpamBakedbeansSpamSpamSpamSpamSpam]# goodmenu_item=%w[SpamSpamSpamSpamSpamSpamSpamSpamBakedbeansSpamSpamSpamSpamSpam]# goodmenu_item=%w[SpamSpamSpamSpamSpamSpamSpamSpamBakedbeansSpamSpamSpamSpamSpam]

# bad - identifier is a Bulgarian word, using non-ascii (Cyrillic) charactersзаплата=1_000# bad - identifier is a Bulgarian word, written with Latin letters (instead of Cyrillic)zaplata=1_000# goodsalary=1_000

# bad:'some symbol':SomeSymbol:someSymbolsomeVar=5defsomeMethod# some codeenddefSomeMethod# some codeend# good:some_symbolsome_var=5defsome_method# some codeend

# bad:some_sym_1some_var_1=1var_10=10defsome_method_1# some codeend# good:some_sym1some_var1=1var10=10defsome_method1# some codeend

# badclassSomeclass# some codeendclassSome_Class# some codeendclassSomeXml# some codeendclassXmlSomething# some codeend# goodclassSomeClass# some codeendclassSomeXML# some codeendclassXMLSomething# some codeend

# badSomeConst=5# goodSOME_CONST=5

# baddefeven(value)end# gooddefeven?(value)end

# badclassPersondefis_tall?trueenddefcan_play_basketball?falseenddefdoes_like_candy?trueendend# goodclassPersondeftall?trueenddefbasketball_player?falseenddeflikes_candy?trueendend

# bad - there is no matching 'safe' methodclassPersondefupdate!endend# goodclassPersondefupdateendend# goodclassPersondefupdate!enddefupdateendend

classArraydefflatten_once!res=[]eachdo |e|[*e].each{ |f|res <<f}endreplace(res)enddefflatten_oncedup.flatten_once!endend

# badresult=hash.map{ |k,v|v +1}defsomething(x)unused_var,used_var=something_else(x)# some codeend# goodresult=hash.map{ |_k,v|v +1}defsomething(x)_unused_var,used_var=something_else(x)# some codeend# goodresult=hash.map{ |_,v|v +1}defsomething(x)_,used_var=something_else(x)# some codeend

# gooddef +(other)# body omittedend# baddef <<(other)@internal <<otherend# gooddef <<(item)@internal <<itemend# bad# Returns some string multiplied `other` timesdef *(other)# body omittedend# good# Returns some string multiplied `num` timesdef *(num)# body omittedend

arr=[1,2,3]# badforeleminarrdoputselemend# note that elem is accessible outside of the for loopelem# => 3# goodarr.each{ |elem|putselem}# elem is not accessible outside each blockelem# => NameError: undefined local variable or method `elem'

# badifsome_conditionthen# body omittedend# badcasefoowhenbarthen# body omittedend# badcaseexpressioninpatternthen# body omittedend# goodifsome_condition# body omittedend# goodcasefoowhenbar# body omittedend# goodcaseexpressioninpattern# body omittedend

# badifsome_conditiondo_somethingdo_something_elseend# goodifsome_conditiondo_somethingdo_something_elseend

# badresult=ifsome_conditionthensomethingelsesomething_elseend# goodresult=some_condition ?something :something_else

# badsome_condition ?(nested_condition ?nested_something :nested_something_else) :something_else# goodifsome_conditionnested_condition ?nested_something :nested_something_elseelsesomething_elseend

# badresult=ifsome_condition;somethingelsesomething_elseend# goodresult=some_condition ?something :something_else

# badifstatus ==:activeperform_actionelsifstatus ==:inactive ||status ==:hibernatingcheck_timeoutelsefinal_actionend# goodcasestatuswhen:activeperform_actionwhen:inactive,:hibernatingcheck_timeoutelsefinal_actionend

# badifconditionresult=xelseresult=yend# goodresult=ifconditionxelseyend

# badcaseexpressioninpattern;do_somethingend# goodcaseexpressioninpatternthendo_somethingend

# bad - parentheses are required because of op precedencex=(notsomething)# goodx= !something

# badx='test'# obscure nil checkif !!x# body omittedend# goodx='test'ifx# body omittedend# gooddefnamed?  !name.nil?end# gooddefbanned?  !!banned_until&.future?end

# good: and/or for control flowx=extract_argumentsorraiseArgumentError,"Not enough arguments!"user.suspended?andreturn:denied# bad# and/or in conditions (their precedence is low, might produce unexpected result)ifgot_needed_argumentsandarguments_valid# ...body omittedend# in logical expression calculationok=got_needed_argumentsandarguments_valid# good# &&/|| in conditionsifgot_needed_arguments &&arguments_valid# ...body omittedend# in logical expression calculationok=got_needed_arguments &&arguments_valid# bad# &&/|| for control flow (can lead to very surprising results)x=extract_arguments ||raise(ArgumentError,"Not enough arguments!")

# bad# Did author mean conditional return because `#log` could result in `nil`?# ...or was it just to have a smart one-liner?x=extract_argumentsandlog("extracted")andreturn# good# If the intention was conditional returnx=extract_argumentsifxreturniflog("extracted")end# If the intention was just "log, then return"x=extract_argumentsifxlog("extracted")returnend

Simply put - because they add some cognitive overhead, as they don’t behave like similarly named logical operators in other languages.

First of all,and andor operators have lower precedence than the= operator, whereas the&& and|| operators have higher precedence than the= operator, based on order of operations.

Also&& has higher precedence than||, where asand andor have the same one. Funny enough, even thoughand andorwere inspired by Perl, they don’t have different precedence in Perl.

# badifsome_conditiondo_somethingend# gooddo_somethingifsome_condition# another good optionsome_conditionanddo_something

# bad10.timesdo# multi-line body omittedendifsome_condition# goodifsome_condition10.timesdo# multi-line body omittedendend

# baddo_somethingifother_conditionifsome_condition# gooddo_somethingifsome_condition &&other_condition

# baddo_somethingif !some_condition# baddo_somethingif notsome_condition# gooddo_somethingunlesssome_condition# another good optionsome_condition ||do_something

# badunlesssuccess?puts'failure'elseputs'success'end# goodifsuccess?puts'success'elseputs'failure'end

# badif(x >10)# body omittedend# goodifx >10# body omittedend

# badwhilex >5do# body omittedenduntilx >5do# body omittedend# goodwhilex >5# body omittedenduntilx >5# body omittedend

# badwhilesome_conditiondo_somethingend# gooddo_somethingwhilesome_condition

# baddo_somethingwhile !some_condition# gooddo_somethinguntilsome_condition

# badwhiletruedo_somethingenduntilfalsedo_somethingend# goodloopdodo_somethingend

# badbeginputsvalval +=1endwhileval <0# goodloopdoputsvalval +=1breakunlessval <0end

# baddefsome_method(some_arr)returnsome_arr.sizeend# gooddefsome_method(some_arr)some_arr.sizeend

# baddefready?ifself.last_reviewed_at >self.last_updated_atself.worker.update(self.content,self.options)self.status=:in_progressendself.status ==:verifiedend# gooddefready?iflast_reviewed_at >last_updated_atworker.update(content,options)self.status=:in_progressendstatus ==:verifiedend

classFooattr_accessor:options# okdefinitialize(options)self.options=options# both options and self.options are equivalent hereend# baddefdo_something(options={})unlessoptions[:when] ==:lateroutput(self.options[:message])endend# gooddefdo_something(params={})unlessparams[:when] ==:lateroutput(options[:message])endendend

# bad (+ a warning)ifv=array.grep(/foo/)do_something(v)# some codeend# good (MRI would still complain, but RuboCop won't)if(v=array.grep(/foo/))do_something(v)# some codeend# goodv=array.grep(/foo/)ifvdo_something(v)# some codeend

# badEND{puts'Goodbye!'}# goodat_exit{puts'Goodbye!'}

# baddefcompute_thing(thing)ifthing[:foo]update_with_bar(thing[:foo])ifthing[:foo][:bar]partial_compute(thing)elsere_compute(thing)endendend# gooddefcompute_thing(thing)returnunlessthing[:foo]update_with_bar(thing[:foo])returnre_compute(thing)unlessthing[:foo][:bar]partial_compute(thing)end

# bad[0,1,2,3].eachdo |item|ifitem >1putsitemendend# good[0,1,2,3].eachdo |item|nextunlessitem >1putsitemend

# badfailSomeException,'message'# goodraiseSomeException,'message'

# badraiseRuntimeError,'message'# good - signals a RuntimeError by defaultraise'message'

# badraiseSomeException.new('message')# Note that there is no way to do `raise SomeException.new('message'), backtrace`.# goodraiseSomeException,'message'# Consistent with `raise SomeException, 'message', backtrace`.

# baddeffooraiseensurereturn'very bad idea'end

# baddeffoobegin# main logic goes hererescue# failure handling goes hereendend# gooddeffoo# main logic goes hererescue# failure handling goes hereend

# badbeginsomething_that_might_failrescueIOError# handle IOErrorendbeginsomething_else_that_might_failrescueIOError# handle IOErrorend# gooddefwith_io_error_handlingyieldrescueIOError# handle IOErrorendwith_io_error_handling{something_that_might_fail}with_io_error_handling{something_else_that_might_fail}

# badbegindo_something# an exception occurs hererescueSomeErrorend# goodbegindo_something# an exception occurs hererescueSomeErrorhandle_exceptionend# goodbegindo_something# an exception occurs hererescueSomeError# Notes on why exception handling is not performedend# gooddo_somethingrescuenil

# bad - this catches exceptions of StandardError class and its descendant classesread_filerescuehandle_error($!)# good - this catches only the exceptions of Errno::ENOENT class and its descendant classesdeffooread_filerescueErrno::ENOENT=>ehandle_error(e)end

# badbeginn /drescueZeroDivisionErrorputs'Cannot divide by 0!'end# goodifd.zero?puts'Cannot divide by 0!'elsen /dend

# badbegin# calls to exit and kill signals will be caught (except kill -9)exitrescueExceptionputs"you didn't really want to exit, right?"# exception handlingend# goodbegin# a blind rescue rescues from StandardError, not Exception as many# programmers assume.rescue=>e# exception handlingend# also goodbegin# an exception occurs hererescueStandardError=>e# exception handlingend

# badbegin# some coderescueStandardError=>e# some handlingrescueIOError=>e# some handling that will never be executedend# goodbegin# some coderescueIOError=>e# some handlingrescueStandardError=>e# some handlingend

## text mode# bad (only when reading from beginning to end - modes: 'r', 'rt', 'r+', 'r+t')File.open(filename).readFile.open(filename, &:read)File.open(filename){ |f|f.read}File.open(filename)do |f|f.readendFile.open(filename,'r').readFile.open(filename,'r', &:read)File.open(filename,'r'){ |f|f.read}File.open(filename,'r')do |f|f.readend# goodFile.read(filename)## binary mode# bad (only when reading from beginning to end - modes: 'rb', 'r+b')File.open(filename,'rb').readFile.open(filename,'rb', &:read)File.open(filename,'rb'){ |f|f.read}File.open(filename,'rb')do |f|f.readend# goodFile.binread(filename)

## text mode# bad (only truncating modes: 'w', 'wt', 'w+', 'w+t')File.open(filename,'w').write(content)File.open(filename,'w'){ |f|f.write(content)}File.open(filename,'w')do |f|f.write(content)end# goodFile.write(filename,content)## binary mode# bad (only truncating modes: 'wb', 'w+b')File.open(filename,'wb').write(content)File.open(filename,'wb'){ |f|f.write(content)}File.open(filename,'wb')do |f|f.write(content)end# goodFile.binwrite(filename,content)

f=File.open('testfile')begin# .. processrescue# .. handle errorensuref.closeiffend

# bad - you need to close the file descriptor explicitlyf=File.open('testfile')# some action on the filef.close# good - the file descriptor is closed automaticallyFile.open('testfile')do |f|# some action on the fileend

# bad - race condition with another process may result in an error in `mkdir`unlessDir.exist?(path)FileUtils.mkdir(path)end# good - atomic and idempotent creationFileUtils.mkdir_p(path)# bad - race condition with another process may result in an error in `remove`ifFile.exist?(path)FileUtils.remove(path)end# good - atomic and idempotent removalFileUtils.rm_f(path)

# bada,b,c,d='foo','bar','baz','foobar'# gooda='foo'b='bar'c='baz'd='foobar'# good - swapping variable assignment# Swapping variable assignment is a special case because it will allow you to# swap the values that are assigned to each variable.a='foo'b='bar'a,b=b,aputsa# => 'bar'putsb# => 'foo'# good - method returndefmulti_return[1,2]endfirst,second=multi_return# good - use with splatfirst, *list=[1,2,3,4]# first => 1, list => [2, 3, 4]hello_array= *'Hello'# => ["Hello"]a= *(1..3)# => [1, 2, 3]

# badtmp=xx=yy=tmp# goodx,y=y,x

# badfoo='one,two,three,four,five'# Unnecessary assignment that does not provide useful informationfirst,second,_=foo.split(',')first,_,_=foo.split(',')first, *_=foo.split(',')# goodfoo='one,two,three,four,five'# The underscores are needed to show that you want all elements# except for the last number of underscore elements*beginning,_=foo.split(',')*beginning,something,_=foo.split(',')a,=foo.split(',')a,b,=foo.split(',')# Unnecessary assignment to an unused variable, but the assignment# provides us with useful information.first,_second=foo.split(',')first,_second,=foo.split(',')first, *_ending=foo.split(',')

# badx=x +yx=x *yx=x**yx=x /yx=x ||yx=x &&y# goodx +=yx *=yx **=yx /=yx ||=yx &&=y

# badname=name ?name :'Bozhidar'# badname='Bozhidar'unlessname# good - set name to 'Bozhidar', only if it's nil or falsename ||='Bozhidar'

# badifsomethingsomething=something.downcaseend# badsomething=something ?something.downcase :nil# oksomething=something.downcaseifsomething# goodsomething=something &&something.downcase# bettersomething &&=something.downcase

# badfoo.object_id ==bar.object_id# goodfoo.equal?(bar)

# badhash={}hash[foo.object_id]=:barifhash.key?(baz.object_id)# ...# goodhash={}.compare_by_identityhash[foo]=:barifhash.key?(baz)# ...

# badArray ===something(1..100) ===7/something/ ===some_string# goodsomething.is_a?(Array)(1..100).include?(7)some_string.match?(/something/)

# badsomething.kind_of?(Array)# goodsomething.is_a?(Array)

# badsomething.instance_of?(Array)# goodsomething.is_a?(Array)

# badvar.class ==Datevar.class.equal?(Date)var.class.eql?(Date)var.class.name =='Date'# goodvar.instance_of?(Date)

# bad - eql? is the same as == for strings'ruby'.eql?some_str# good'ruby' ==some_str1.0.eql?x# eql? makes sense here if want to differentiate between Integer and Float 1

# badnames.map{ |name|name.upcase}# goodnames.map(&:upcase)

names=%w[BozhidarFilippSarah]# badnames.eachdo |name|putsnameend# goodnames.each{ |name|putsname}# badnames.selectdo |name|name.start_with?('S')end.map{ |name|name.upcase}# goodnames.select{ |name|name.start_with?('S')}.map(&:upcase)

# badfoodo |arg|bar(arg)end# goodfoodo |arg|bar(arg)end# bad->(arg)dobar(arg)end# good->(arg){bar(arg)}

require'tempfile'# baddefwith_tmp_dirDir.mktmpdirdo |tmp_dir|Dir.chdir(tmp_dir){ |dir|yielddir}# block just passes argumentsendend# gooddefwith_tmp_dir(&block)Dir.mktmpdirdo |tmp_dir|Dir.chdir(tmp_dir, &block)endendwith_tmp_dirdo |dir|puts"dir is accessible as a parameter and pwd is set:#{dir}"end

# bad - easier to move/add/remove parameters, but still not preferred[[1,2,3],[4,5,6]].eachdo |a,b,c,|a +b +cend# good[[1,2,3],[4,5,6]].eachdo |a,b,c|a +b +cend# bad[[1,2,3],[4,5,6]].each{ |a,b,c,|a +b +c}# good[[1,2,3],[4,5,6]].each{ |a,b,c|a +b +c}# good - this comma is meaningful for array destructuring[[1,2,3],[4,5,6]].map{ |a,|a}

# baddeffoo(x)defbar(y)# body omittedendbar(x)end# good - the same as the previous, but no bar redefinition on every foo calldefbar(y)# body omittedenddeffoo(x)bar(x)end# also gooddeffoo(x)bar=->(y){ ...}bar.call(x)end

# badl=lambda{ |a,b|a +b}l.call(1,2)# correct, but looks extremely awkwardl=->(a,b)dotmp=a *7tmp *b /50end# goodl=->(a,b){a +b}l.call(1,2)l=lambdado |a,b|tmp=a *7tmp *b /50end

# badl=->x,y{something(x,y)}# goodl=->(x,y){something(x,y)}

# badl=->(){something}# goodl=->{something}

# badp=Proc.new{ |n|putsn}# goodp=proc{ |n|putsn}

# bad - looks similar to Enumeration accessl=->(v){putsv}l[1]# bad - most compact form, but might be confusing for newcomers to Rubyl=->(v){putsv}l.(1)# good - a bit verbose, but crystal clearl=->(v){putsv}l.call(1)

# baddefsome_method;end# goodclassSomeClassdefsome_method;endend

# baddeftoo_much;something;something_else;end# okish - notice that the first ; is requireddefno_braces_method;bodyend# okish - notice that the second ; is optionaldefno_braces_method;body;end# okish - valid syntax, but no ; makes it kind of hard to readdefsome_method()bodyend# gooddefsome_methodbodyend

# gooddefno_op;end

# baddeffib(x)=ifx <2xelsefib(x -1) +fib(x -2)end# gooddefthe_answer=42defget_x=@xdefsquare(x)=x *x# Not (so) good: has side effectdefset_x(x)=(@x=x)defprint_foo=puts("foo")

# baddeffoo=trueifbar# good - using a non-endless method is more explicitdeffootrueendifbar# ok - method body is explicitdeffoo=(trueifbar)# ok - method definition is explicit(deffoo=true)ifbar

# badSomeClass::some_methodsome_object::some_method# goodSomeClass.some_methodsome_object.some_methodSomeModule::SomeClass::SOME_CONSTSomeModule::SomeClass()

# badclassFoodefself::some_methodendend# goodclassFoodefself.some_methodendend

# baddefsome_method()# body omittedend# gooddefsome_method# body omittedend# baddefsome_method_with_parametersparam1,param2# body omittedend# gooddefsome_method_with_parameters(param1,param2)# body omittedend

# badx=Math.siny# goodx=Math.sin(y)# badarray.deletee# goodarray.delete(e)# badtemperance=Person.new'Temperance',30# goodtemperance=Person.new('Temperance',30)

Non-Declarative Methods That Have "keyword" Status in Ruby

For non-declarative methods with "keyword" status (e.g., variousKernel instance methods), two styles are considered acceptable.By far the most popular style is to omit parentheses.Rationale: The code reads better, and method calls look more like keywords.A less-popular style, but still acceptable, is to include parentheses.Rationale: The methods have ordinary semantics, so why treat them differently, and it’s easier to achieve a uniform style by not worrying about which methods have "keyword" status.Whichever one you pick, apply it consistently.

# baddefsome_method(a=1,b=2,c,d)puts"#{a},#{b},#{c},#{d}"endsome_method('w','x')# => '1, 2, w, x'some_method('w','x','y')# => 'w, 2, x, y'some_method('w','x','y','z')# => 'w, x, y, z'# gooddefsome_method(c,d,a=1,b=2)puts"#{a},#{b},#{c},#{d}"endsome_method('w','x')# => '1, 2, w, x'some_method('w','x','y')# => 'y, 2, w, x'some_method('w','x','y','z')# => 'y, z, w, x'

# baddefsome_method(foo:false,bar:,baz:10)# body omittedend# gooddefsome_method(bar:,foo:false,baz:10)# body omittedend

# baddefsome_method(bar=false)putsbarend# bad - common hack before keyword args were introduceddefsome_method(options={})bar=options.fetch(:bar,false)putsbarend# gooddefsome_method(bar:false)putsbarendsome_method# => falsesome_method(bar:true)# => true

# baddefsome_method(a,b=5,c=1)# body omittedend# gooddefsome_method(a,b:5,c:1)# body omittedend

# baddefsome_method(options={})bar=options.fetch(:bar,false)putsbarend# gooddefsome_method(bar:false)putsbarend

# badsome_method(**opts.merge(foo:true))# goodsome_method(**opts,foo:true)

# baddefsome_method(*args, &block)other_method(*args, &block)end# baddefsome_method(*args, **kwargs, &block)other_method(*args, **kwargs, &block)end# bad# Please note that it can cause unexpected incompatible behavior# because `...` forwards block also.# https://github.com/rubocop/rubocop/issues/7549defsome_method(*args)other_method(*args)end# gooddefsome_method(...)other_method(...)end

# baddefsome_method(&block)other_method(&block)end# gooddefsome_method(&)other_method(&)end

classPerson# extend/include/prepend go firstextendSomeModuleincludeAnotherModuleprependYetAnotherModule# inner classesclassCustomError <StandardErrorend# constants are nextSOME_CONSTANT=20# afterwards we have attribute macrosattr_reader:name# followed by other macros (if any)validates:name# public class methods are next in linedefself.some_methodend# initialization goes between class methods and other instance methodsdefinitializeend# followed by other public instance methodsdefsome_methodend# protected and private methods are grouped near the endprotecteddefsome_protected_methodendprivatedefsome_private_methodendend

# badclassPersonincludeFoo,Barend# goodclassPerson# multiple mixins go in separate statementsincludeFooincludeBarend

# badFooError=Class.new(StandardError)# okishclassFooError <StandardError;end# okclassFooError <StandardErrorend

# bad# foo.rbclassFooclassBar# 30 methods insideendclassCar# 20 methods insideend# 30 methods insideend# good# foo.rbclassFoo# 30 methods insideend# foo/bar.rbclassFooclassBar# 30 methods insideendend# foo/car.rbclassFooclassCar# 20 methods insideendend

moduleUtilitiesclassQueueendend# badclassUtilities::StoreModule.nesting# => [Utilities::Store]definitialize# Refers to the top level ::Queue class because Utilities isn't in the# current nesting chain.@queue=Queue.newendend# goodmoduleUtilitiesclassWaitingListModule.nesting# => [Utilities::WaitingList, Utilities]definitialize@queue=Queue.new# Refers to Utilities::Queueendendend

# badclassSomeClassdefself.some_method# body omittedenddefself.some_other_method# body omittedendend# goodmoduleSomeModulemodule_functiondefsome_method# body omittedenddefsome_other_method# body omittedendend

# badmoduleUtilitiesextendselfdefparse_something(string)# do stuff hereenddefother_utility_method(number,string)# do some more stuffendend# goodmoduleUtilitiesmodule_functiondefparse_something(string)# do stuff hereenddefother_utility_method(number,string)# do some more stuffendend

classPersonattr_reader:first_name,:last_namedefinitialize(first_name,last_name)@first_name=first_name@last_name=last_nameenddefto_s"#{first_name}#{last_name}"endend

# badclassPersondefinitialize(first_name,last_name)@first_name=first_name@last_name=last_nameenddeffirst_name@first_nameenddeflast_name@last_nameendend# goodclassPersonattr_reader:first_name,:last_namedefinitialize(first_name,last_name)@first_name=first_name@last_name=last_nameendend

# badclassPersondefget_name"#{@first_name}#{@last_name}"enddefset_name(name)@first_name,@last_name=name.split(' ')endend# goodclassPersondefname"#{@first_name}#{@last_name}"enddefname=(name)@first_name,@last_name=name.split(' ')endend