Activesupport bug?

Discussion in 'Ruby' started by David Roderick, Oct 8, 2008.

  1. 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
    David Roderick, Oct 8, 2008
    #1
    1. Advertising

  2. 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 http://www.ruby-forum.com/.
    Brian Candler, Oct 8, 2008
    #2
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. han
    Replies:
    0
    Views:
    213
  2. john peter
    Replies:
    3
    Views:
    264
    Logan Capaldo
    Mar 31, 2006
  3. Trans
    Replies:
    0
    Views:
    116
    Trans
    Sep 12, 2006
  4. Tim Bray
    Replies:
    0
    Views:
    89
    Tim Bray
    Oct 13, 2006
  5. Ivo Wever
    Replies:
    1
    Views:
    174
    Ivo Wever
    Mar 28, 2011
Loading...

Share This Page