What are the uppercase and lowercase rules of ruby method name?

Question

I am a ruby beginner. From the book, I know that ruby method name should start with a lowercase letter ( or underscore). But I found different scenarios:

1. if a method is defined outside a class, it can only begin with lowercase letter, Ruby will complain error if you try to define a method which begin with uppercase letter, for example:

   define sayHi
    puts "Hello" 
   end
   sayHi   # => Hello
   

   but, the following code is not working:

   define SayHi
     puts "Hello" 
    end
    SayHi 

   it will produce error:
   :in `': uninitialized constant SayHi (NameError)
   

1. If a method is defined inside a class, then it can begin with uppercase letter:

    class Test
      def SayHi
       puts "hello" 
      end
    end
    t = Test.new
    t.SayHi    # => hello
    

Does anyone know why #1 does not work while #2 work? What are the exact rules the ruby method name?

Answer 1

the folloing links should answer your questions:

http://www.softiesonrails.com/2007/10/18/ruby-101-naming-conventions

http://itsignals.cascadia.com.au/?p=7

Answer 2

By convention, things that start with uppercase letters are constants. When you invoke SayHi, you're telling Ruby to look for a constant with this name. Of course, there isn't one, so it fails.

If you want to invoke the method, you'll need to add a pair of parentheses. For example,

def S
  puts "shazam!"
end

S    #=> NameError: uninitialized constant S
S()  #=> "shazam!"

Inside of a class, the resolution rules are a little different. Let's define a simple class with a constant and a method named to look like a constant:

irb(main):001:0> class C
irb(main):002:1>   A = "x"
irb(main):003:1>   def B
irb(main):004:2>     puts "B() invoked"
irb(main):005:2>   end
irb(main):006:1> end
=> nil

Now, A is certainly a constant. But what about B?

irb(main):008:0> C.const_defined?("A")
=> true    # A is a constant!
irb(main):009:0> C.const_defined?("B")
=> false   # B looks like a constant but isn't, because we
           # used "def" to create it. "def" is for methods,
           # not constants.

So it isn't a constant, just a method with that name. When we try to access B from an instance of C, now Ruby's looking for a method:

irb(main):011:0> C.new.B
B() invoked
=> nil

If we wanted to access a constant of C instead, we use the scope qualifier :::

irb(main):012:0> C::A
=> "x"

Answer 3

Don't do any of what you're trying to do. It's bad coding style.

Good Ruby coding style:

def method_name
end

# or

class CamelCase
  def method_name(parameter_name)
  end
end

Almost anything else is simply wrong. The language might let you do other stuff, but that doesn't mean you should.

Also, generally you don't want to be defining methods outside of a class or module — that's acceptable in short throw-away scripts, but not in projects of substance.