Forum: Ruby Scope resolution operator

(The code I will demonstrate is Rails-based, but the question is
Ruby-based.)

I'm familiar with the following:
ActiveRecord::Base

Basically says, look inside ActiveRecord for a class or module named
Base.

But what about the following:

::Attachment

Does that basically say, no matter what scope you are in, jump to the
highest level to look for the class or module named Attachment?

The following code only works when I prefix the Attachment class with ::

has_one :attachment, :as => :attachable, :class_name => '::Attachment'

def assign_attachment=(attachment_id)
  self.attachment = ::Attachment.find(attachment_id)
end

Alle domenica 25 gennaio 2009, Daniel Waite ha scritto:
> ::Attachment
> Does that basically say, no matter what scope you are in, jump to the
> highest level to look for the class or module named Attachment?

According to "The Ruby Programming Language", ::Something is a shortcut 
for
Object::Something. The idea is that ::Something should look up a 
constant
called Something in the global scope, but since ruby doesn't truly have 
a
global scope, it looks it up in the Object class, which is the nearest 
thing
in ruby to a global scope.

> The following code only works when I prefix the Attachment class with ::
>
> has_one :attachment, :as => :attachable, :class_name => '::Attachment'
>
> def assign_attachment=(attachment_id)
>   self.attachment = ::Attachment.find(attachment_id)
> end

Not knowing rails, I can't say much on this. However, if it works with
::Attachment and doesn't work with Attachment, the only thing I can 
think of
is that you have two constants called Attachment: one at global level, 
which
is the one you need here, and another at a more local level which is the 
one
you get without the ::

I hope this helps

Stefano

Stefano Crocco wrote:
> Not knowing rails, I can't say much on this. However, if it works with
> ::Attachment and doesn't work with Attachment, the only thing I can 
> think of
> is that you have two constants called Attachment: one at global level, 
> which
> is the one you need here, and another at a more local level which is the 
> one
> you get without the ::

You may not be familiar with Rails but you certainly know Ruby. That is 
exactly the case. The Paperclip module defines an Attachment class, 
methods of which I am using in my own Attachment class. Talk about a 
naming conflict. Grr...

Thanks for the reply Stefano, it's helped a lot.

2009/1/25 Stefano Crocco <stefano.crocco@alice.it>:
>> But what about the following:
>> ::Attachment
>> Does that basically say, no matter what scope you are in, jump to the
>> highest level to look for the class or module named Attachment?
>
> According to "The Ruby Programming Language", ::Something is a shortcut for
> Object::Something. The idea is that ::Something should look up a constant
> called Something in the global scope, but since ruby doesn't truly have a
> global scope, it looks it up in the Object class, which is the nearest thing
> in ruby to a global scope.

As an illustration:

14:52:57 ~$ ruby -e 'puts Object.constants.sort'
ARGF
ARGV
ArgumentError
Array
Bignum
Binding
Class
Comparable
Continuation
Data
Dir
ENV
EOFError
Enumerable
Errno
Exception
FALSE
FalseClass
File
FileTest
Fixnum
Float
FloatDomainError
GC
Hash
IO
IOError
IndexError
Integer
Interrupt
Kernel
LoadError
LocalJumpError
Marshal
MatchData
MatchingData
Math
Method
Module
NIL
NameError
NilClass
NoMemoryError
NoMethodError
NotImplementedError
Numeric
Object
ObjectSpace
...

You see all the globally scoped classes (later on there will be String
etc.). Notice also the nice element of self referentiality. :-)

Kind regards

robert

* Stefano Crocco <stefano.crocco@alice.it> (2009-01-25) schrieb:

> According to "The Ruby Programming Language", ::Something is a shortcut for 
> Object::Something. The idea is that ::Something should look up a constant 
> called Something in the global scope, but since ruby doesn't truly have a 
> global scope, it looks it up in the Object class, which is the nearest thing 
> in ruby to a global scope.

,----
| $ cat /tmp/scope.rb
| Something = "blubb"
| 
| module Bla
|   class Object
|     Something = "crazy"
|   end
| 
|   puts ::Something
|   puts Object::Something
| end
| $ ruby /tmp/scope.rb
| blubb
| crazy
| $
`----

mfg,                    simon .... l