(Note: This task is part of the RUBY REWORK, which has (among other
goals) the goal to remove inconsistencies and limitations in the
Object Model and in the language. The time frame for the overall
rework is 3 months.)
INTRODUCTION
In ruby, the primitive data types are objects (instances of their
related classes, like Integer or String)
Ruby’s object model allows modifications of a class at runtime, even
if it is the class of a primitive data-type.
This is official functionality of the object model, which is
attractive, and provides flexibility - e.g. for framework design.
As a very simple example, a “running_counter” for the String class.
altering the behaviour of the original String class, without sub-
classing
this alteration is valid program wide
class String
@@running_counter = 0
def initialize(val)
@@running_counter += 1
self.replace(val)
end
def running_counter
@@running_counter
end
end
#now the strings contain a running_counter, convenient accessible via
an instance method
oo_string = String.new(“The String 1”)
p oo_string.running_counter #=> 1
oo_string = String.new(“The String 2”)
p oo_string.running_counter #=> 2
LIMITATION
The current implementation of ruby 1.9.2 has the following limitation:
String objects instantiated from literals behave different.
li_string = “The String 3”
p li_string.running_counter #=> 2, was not incremented
li_string = “The String 4”
p li_string.running_counter #=> 2, was not incremented
Although they should have the same behaviour, as they are instances of
class String, they have a slight different behavior.
The task is, to modify the ruby interpreter, thus objects instantiated
from literals behave like normally created objects, thus the above
code works as expected (the redefined initialize method is called).
Internally:
- the C-core calls the redefined “initialize” method of an object, if
it’s available
Implementation Requirements:
- Minimal influence on execution speed (< 1% if feature is unused,
interpreter dependent if feature is used ) - Reusable functionality (future unification of object model, e.g. to
make speed-critical items first-class-objects)
Needed Resources:
- time : 1 week of time
- budget: 500,- Euro
Needed Assistance (via emails):
ideally:
- Around 1 hour from a person with toolchain experiences (VC++ express
or mingw) - Around 1 hour from a person which is familiar with the ruby C source
codes - Around 1 hour from a person which is familiar with the ruby cross-
platform testing
Work Plan:
- 1 day : setup of tool-chain (compiler, debugger, IDE)
- 1 day : looking around in source code
- 1 day : implementation of 1st solution
- 1 day : implementation of 2nd solution
- 1 day : choose solution, refactoring, tests and documentation
- 1 day : spare day
If you would like to see this task fulfilled, and want to provide the
mentioned assistance or part of the budget (or a means to collect the
budget within a public system), please contact me with private email.
Related Issues:
Literal Instantiation breaks Object Model
Provide Class#cb_object_instantiated_from_literal(object)
Unify Variable Expansion within Strings
.