Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Commits on Nov 18, 2015
  1. @ahmadsherif
  2. @ahmadsherif

    Reset globally cached klass methods in Module#prepend_features

    ahmadsherif committed
    Consider this example:
        class Parent
          def bar
        class Child < Parent
          def bar
          def foo
        # foo and bar are cached in the global cache
        prepended_module = do
          def foo
        # foo is cleared from the global cache, but bar is not
        # Child hierarchy is now Child < IncludedModule(prepended_module) < IncludedModule(Child) < Parent
        # When bar is looked up here, being still cached globally, Child#bar is the
        # result of the lookup (normally, it should be IncludedModule(Child)#bar).
        # Now when Child#bar is looking for its super, it goes to the first included
        # module, then the second included module, which has the same method table
        # as Child, returning Child#bar, causing non-ending recursive calls.
Commits on Nov 16, 2015
  1. @YorickPeterse

    Added iovec and msghdr structures

    YorickPeterse committed
    These will be required by the upcoming release of rubysl-socket.
  2. @ahmadsherif

    Include zlib linker flag if not building with the vendored one

    ahmadsherif committed
    Apparently building with LLVM enabled includes this flag, probably
    because of using `--system-libs`, so building without LLVM fails because
    it can't link against zlib.
  3. @ahmadsherif

    Bump Travis Ruby version to 2.2.0

    ahmadsherif committed
    OS X builds started to fail after the release of RubyGems 2.5.0, so this
    should fix it.
Commits on Oct 30, 2015
  1. @YorickPeterse

    Updated list of Socket constants to generate

    YorickPeterse committed
    The new list is based on the constants available as of MRI 2.2.3.
Commits on Oct 4, 2015
  1. @CpuID @YorickPeterse

    Fixes to assist building Rubinius under Alpine Linux (with musl).

    CpuID committed with YorickPeterse
    Not 100% building yet, but these cover some outstanding issues
Commits on Sep 22, 2015
  1. @YorickPeterse
  2. @YorickPeterse
Commits on Sep 3, 2015
  1. @brixen
Commits on Aug 25, 2015
  1. @YorickPeterse

    Clean up log output of serial_debug/ic_debug

    YorickPeterse committed
    Output is now sent to STDERR (to make it easier to redirect) and the
    actual debug messages have been trimmed a bit.
  2. @benlovell @YorickPeterse

    Specify `superclass` in respect to `prepend`

    benlovell committed with YorickPeterse
    This was unspecified/recently merged to ruby/rubyspec. Rubinius does
    the Right Thing :tm:
Commits on Jul 31, 2015
  1. @jemc
  2. @YorickPeterse
  3. @YorickPeterse

    Log class names for invalid ivars_ references

    YorickPeterse committed
    This makes it a bit easier to see what kind of objects we're dealing
    with when this occurs.
Commits on Jul 30, 2015
  1. @kachick

    Add a C-API "rb_hash_clear"

    kachick committed
Commits on Jul 29, 2015
  1. @jc00ke

    Merge pull request #3476 from kachick/range-bsearch

    jc00ke committed
    Fix Range#bsearch for matching end value in find-minimum mode
  2. @kachick
  3. @jc00ke

    Merge pull request #3475 from kachick/string-split

    jc00ke committed
    String#split should trim tail empty strings when the limit is zero
  4. @kachick
  5. @kachick
Commits on Jul 24, 2015
  1. @YorickPeterse

    Added failing Range#bsearch specs

    YorickPeterse committed
    These are taken from the ones mentioned by @heftig in #3458.
Commits on Jul 18, 2015
  1. @robin850
  2. @robin850

    Allow passing strings to #{private,public}_constant

    robin850 committed
    The maintained constants table is dealing with symbols but these methods
    can take strings as arguments ; it's pretty common to pass ``
    as an argument.
  3. @robin850 @YorickPeterse

    Rename `Float#negative?` to `Float#signbit?`

    robin850 committed with YorickPeterse
    Ruby 2.3 ships with a new `Numeric#negative?` method. Rubinius implements
    this method since b92c84f, for internal usage though ; it delegates to
    the signbit C++ function.
    However, `signbit`'s behavior can't match MRI `Float#negative?`'s one
    since the former operates on the sign while the latter operates on the
    value (see
Commits on Jul 17, 2015
  1. @brixen
  2. @brixen

    Synchronize ThreadGroup#add. Closes #3467.

    brixen committed
    Ruby generally makes no guarantees about thread safety, however, many
    accidental "guarantees" are assumed by Ruby programmers because of MRI's
    global interpreter lock.
    Rubinius makes internal operaions thread safe but generally does not make any
    thread safety guarantees for common Ruby objects like Array or Hash instances.
    It's perfectly possible to "corrupt" an Array by concurrently modifying it
    without synchronization.
    ThreadGroup presents an interesting case, however, because it is arguably a
    system structure. The API of ThreadGroup is minimal, consisting of these
    methods: add, enclose, enclosed?, list.
    Of these, only add presents a thread safety issue from the perspective of a
    potentially "corrupted" structure (ie the list of Threads in the group). It's
    possible for one Thread to enclose the group and another to get 'false' when
    calling #enclosed? "after" the other Thread called #enclose. That's not a case
    we are concerned with. The case of calling #add (which will implicitly also
    remove the Thread from another group if it is a member) should probably be
    thread safe.
    For this reason, we add synchronization around adding (and removing) a Thread
    from a ThreadGroup.
  3. @brixen
Commits on Jul 14, 2015
  1. @brixen

    Fixed setting log file access permissions.

    brixen committed
    Since the process umask can override our open permissions, we need to explicitly
    set the permissions.
  2. @brixen

    Updated Bundler to 1.10.5.

    brixen committed
  3. @brixen
  4. @brixen

    Smash another racey process spec.

    brixen committed
    There is no way to guarantee that the `Process.exit` from the thread completes
    before the `Process.exit` in the main thread. That's not how actual threads
    with no global interpreter lock work.
  5. @brixen

    Reworked halting the system.

    brixen committed
    This is the first step of a much refactor to introduce a proper System object
    instead of hanging all the process boot and halt logic off the Environment
    object. A lot of boot and halt code can then be cleaned up (eg creating and
    initializing the object space, loading the kernel code, etc).
    The main process thread (the one the OS creates when the process is first
    created) now boots the system and spawns a thread to start running Ruby code.
    The main thread goes on to process signals and halting the process. This is
    the only thread that processes halt code.
    When the process forks, a new thread is created to process signals and
    halting. In the future, fork() and exec() will be disallowed on all internal
    threads and only allowed on threads running Ruby code.
  6. @brixen
Commits on Jul 13, 2015
  1. @YorickPeterse

    Removed "BUNDLER WITH" crap from Gemfile.lock

    YorickPeterse committed
    Bundler no longer adds this when nothing changes, thankfully.
Something went wrong with that request. Please try again.