Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Ruby > Activesupport bug?

Thread Tools

Activesupport bug?

David Roderick
Posts: n/a
Ruby 1.9 does not work with rails. My ruby1.9 cannot work with rails and
produces an error message about == and >= so why not remove these ?

In activesupport/lib/active_support module ActiveSupport is the following

module ActiveSupport
if defined? ::BasicObject
class BasicObject < ::BasicObject
undef_method :==
undef_method :equal?

# Let ActiveSupport::BasicObject at least raise exceptions.
def raise(*args)
::Object.send(:raise, *args)
require 'blankslate'
BasicObject = BlankSlate

For a start the method as equal? means a.object_id == b.object_id
Getting rid of it seems a mistake
Further the Object.eql? and Object.== are both Object.equal? and the
former two are often redefined at children of object.


if defined? ::BasicObject

::BasicObject seems to be an attempt to refers to constant
in Object::BasicObject because
if ActiveSupport::BasicObject

does not seem intelligent. The person who is altering the
same module already knows whether a constant called ::BasicObject
is defined at this same lexical level as the module as ActiveSupport.

Using explicit namespace would avoid my confusion.

Are trying to decide whether ActiveSupport::BasicObject is already

I presume not.

So assuming that we are trying to discover whether there is a constant
called ::BasicSupport which refers to an instance of the class as
BasicObject, which is only within ruby 1.9 and not 1.8

From outside of a class and within a module the method as
needs to be used so to discover constants within are inside of the
scope of the object as Object, such as Object::BasicObject , and to
discover constants within are inside of the scope of the object as
BasicObject, such as BasicObject::BasicObject the method as
is required.

When we do this

class ActiveSupport::BasicObject < ::BasicObject

we can find a constant called BasicObject with the top level scope
of Object, which is Object::BasicObject because this is referenced
within the definition of a class and this *will* check the top-level
scope without having to make an explicit call to self.ancestors, even
though this class definition is made within a module.

So if the constant as Object::BasicOject is a constant which refers to
an object which is an instance of the class as BasicObject
we have bypassed the class as Object
Is this correct?
Where have the comparable methods gone?
Are those mixed in at the level of BasicObject. I don't know the answer
at present.

What do you think?
Am I wrong? I am new to ruby. I read the O'Reilly book this summer
learnt this from this book.

David Roderick
Reply With Quote
Brian Candler
Posts: n/a
I'm afraid you're asking on the wrong mailing list. This one is for
Ruby, the language itself.

Rails is written in Ruby, but is such a substantial and complex project
in its own right that there are other mailing lists and forums devoted
to it.
Posted via

Reply With Quote

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off

Similar Threads
Thread Thread Starter Forum Replies Last Post
On Modules and require in general / on ActiveSupport in particular nrolland Ruby 1 12-04-2006 02:24 AM
Can't get ActiveSupport::Multibyte going Tim Bray Ruby 0 10-12-2006 11:49 PM
Value of ActiveSupport's Modularization Trans Ruby 0 09-12-2006 03:09 PM
can activesupport gem be used in "standalone" fashion? john peter Ruby 3 03-31-2006 09:03 PM
`report_activate_error': Could not find RubyGem activesupport han Ruby 0 10-25-2005 03:37 PM