# Activesupport bug?

**URL:** <https://www.ruby-forum.com/t/activesupport-bug/150438>\
**Category:** Ruby\
**Created:** [October 8, 2008, 4:15pm UTC](https://www.ruby-forum.com/t/activesupport-bug/150438 "2008-10-08T16:15:26Z")\
**Posts on this page:** 2\
**Page:** 1

<div class="post-metadata">

**Author:** ![davidjrice](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/5e9695/32.png) [@davidjrice](https://www.ruby-forum.com/u/davidjrice)\
**Post date:** [October 8, 2008, 4:15pm UTC](https://www.ruby-forum.com/t/activesupport-bug/150438/1 "2008-10-08T16:15:26Z")

</div>

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)
  end
end

```

else  
require ‘blankslate’  
BasicObject = BlankSlate  
end  
end

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.

Secondly,Within

```
            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  
defined?

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  
self.ancestor  
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  
Object.ancestors  
is required.

When we do this

```
 class ActiveSupport::BasicObject < ::BasicObject
 end

```

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

---

<div class="post-metadata">

**Author:** ![davidjrice](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/d/5e9695/32.png) [@davidjrice](https://www.ruby-forum.com/u/davidjrice)\
**Post date:** [October 8, 2008, 9:05pm UTC](https://www.ruby-forum.com/t/activesupport-bug/150438/2 "2008-10-08T21:05:37Z")

</div>

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.