block methods

`{...}’ style:

bar.foo(vars){|vars2|
  
}

`do…end’ style:

bar.foo(vars) do |vars2|
  
end

one-line block:

bar.foo(){|var|   }

case-when Statements

Ruby’s case-when (not when-case) does not need ‘break’.

case foo
when condition1
  
when condition2
  
else
  
end

begin-rescue-end Statements

It handles errors (Exceptions).

begin
  
rescue FooError => e
  
rescue BazError => e2
  
rescue
  
end

White Space

Blank Lines

• Between sections of a source file
• Between class and module definitions
• Between methods
• Before blocks or single-line comments
• Between logical sections inside a method to improve readability

Blank spaces

A keyword followed by a parenthesis should be separated by a space.

ex:

while (foo.end?) {
  
}

The number of spaces should be balanced.

a+b      ## Correct
a + b    ## Correct
a+ b     ## AVOID!
a +b     ## AVOID! (Erroneous: interpreted as a(+b))

a += b + c
a = (a + b) / (c * d)
a = b
foo("foo" + buz + bar)

Naming Conventions

Classes/Modules

class and module names should be nouns; in mixed case with the first letter of each internal word capitalized.

ex:

class Raster,  class Raster::ImageSprite

Methods

Methods should be verbs. All lower case ASCII letters with words separated by underscores (’_’)

ex.

run(), run_fast(), obj.background_color()

Variables

variable names should be all lower case ASCII letters with words separated by underscore (’_’)

ex: i = 1 some_char = SomeChar.new() table_width = 0.0

Constants

constants should be all upper case with words separated by underscores (’_’). ((Huh, is there a reasonable background to distinguish constants from a class name which is a constant at the same time?))

ex:

MIN_LENGTH = 1
DEFAULT_HOST = "foo.example.com"

Omission

Speaking of ‘Connection Pool’ as a variable, you should decide to prefer name by scope such as the following…

• ‘conpool’ for local scope (such as local variable)
• ’@connection_pool’ for class scope (such as instance variable)

Pragmatic Programming Practices

Using attr_* to access

def foo()
  @foo
end

attr_reader :foo

Without Parenthesis

Some methods are used without parenthesis.

• require

ex.

require 'foo/bar'

• include

ex.

include FooModule

• p

ex.

p foo

• attr_*

ex.

attr_reader :foo, :bar

Reduce repetition

When successive lines of a script share something,

x = ModuleA::ClassB::method_c( a )
y = ModuleA::ClassB::method_d( b )

(- ‘function’ => ‘method’ -)

you should make it like this:

cb = ModuleA::ClassB
x = cb::method_c( a )
y = cb::method_d( b )

You can also do:

include ModuleA
x = ClassB::method_c(a)
y = ClassB::method_d(b)

Code Example

  =begin
    blahdy/blah.rb
    $Id:$

    Copyright (c) 2001 TAKAHASHI Masayoshi

    This is free software; you can copy and distribute and modify
    this program under the term of Ruby's License
    (http://www.ruby-lang.org/LINCENSE.txt)

  =end

  #
  # module description goes here.
  #
  # @version: 1.82
  # @author: TAKAHASHI Masayoshi
  #

  module Blahdy

    class Blah < SomeClass
      # A class implementation comment goes here.

      # CLASS_VAR1 documentation comment
      CLASS_VAR1 = 1;

      # CLASS_VAR2 documentation comment that happens
      # to be more than one line length.
      #
      CLASS_VAR2 = 1;

      # ...constructor Blah documentation comment...
      #
      def initialize()
        ## ...implementation goes here...
      end

      # ...method do_something documentation comment...
      #
      def do_sometiong()
        ## ...implementation goes here...
      end

      # ...method do_something_else documentation comment...
      #
      # @param some_param  description
      #
      def do_something_else(some_param)
        ## ...implementation goes here...
      end

    end

  end

Original document