Historical errata for Metaprogramming Ruby

> Then I went asked the class for a list of its instance methods

Extra “went” or missing “and” before asked.

The ISBN format is actually less obvious than the book implies. I’ll have to change the example (reported by Jeremy Sydick).

The description of instance_eval() is confusing. Clarify that it just changes self. (reported by Ola Bini).

If Numeric.money() is defined as Money.new(self*100), then 10000.to_money() should be $10,000.00, not $100.00 as stated.

The Quiz Solution says:
You can ask Ruby itself for the ancestors chain of Book:
b = Book.new
b.print_to_screen

shouldn’t the last line be ‘b.class.ancestors’ or
‘Book.ancestors’?

Throughout the PDF I come across:

Class’

as the possessive of Class. The s at the end of a Class is not a plural s so the correct possessive is:

Class’s

There’s a growing tendency to apply the “s-apostrophe” rule to all words ending in s and not just those with a plural s, but it jars. The best rule of thumb is to ask yourself, “What would I say out loud?” I’ve never heard anyone say “Class’” as the possessive of “Class” - it’s always “Class’s” - hence that’s the best spelling to use.

There’s quite a good article about this on Wikipedia if you want more information. Don’t be afraid of s-apostrophe-s.

Code snippets being interrupted by the inset boxes is (mildly) annoying.

Pictures are missing from the epub version.

“Then I went asked the class for a list of its instance methods.”

I think there should be an ‘and’ between ‘went’ and ‘asked’ or delete the ‘went’.

Proposal:
“Then I asked the class for a list of its instance methods.”

‘Egiptology’ should be ‘Egyptology’.

I think that is a good idea to add the cool technique of methods that return dynamic class instances, like Camping does in routing, working with examples like:

class MyClass < Other ‘something’
end

Only a few people know about it, and I realize that this will be good if it’s exposed on this book

re: missing pictures in epub version. reader is stanza 1.9 on iphone OS 3. None of the pictures shows, at least until end of chapter 4 (starting chap 5 soon…great book so far btw)

The description in the “Privacy Matters” blurb about Ruby 1.9’s behaviour of private methods is incorrect. Object#send() was not modified to disallow message passing to private methods in 1.9— furthermore, there is no method #send!() defined in Ruby 1.9.1.

“rows_with(:country)()” appears to have an extraneous pair of parentheses at the end (probably should be just “rows_with(:country)”).

In the definition of method_missing, shouldn’t there be a “return” before “super”?

“ornitology” should be “ornithology”

You write:

" You can think of instance variables
and their values as keys and values in a hash."

I think you meant to say the name of the variable would be used as the key.

“How can a mixin like CacheMixin bend the rules and define class method on the class that includes it?”

should be

“How can a mixin like CacheMixin bend the rules and define class methods on the class that includes it?”

a =|| []

should be

a ||= []

The sidebar about symbols doesn’t mention that Ruby recognizes symbols faster than strings. While this is not essential I think it’s valid enough to mention in a symbols vs. strings argument.

class’ should be class’s

The name ‘base’ in the code example is misleading to me - I’d expect ‘base’ to refer to the superclass String, not the subclass MyString.

Last sentence under “Scope Wrap-Up”. “This a Flat Scope (99), the basic closure-related spell.”
Should this be “This is a Flat Scope…”?

“Delving into the the Object Model, at the very heart of Ruby, …” - I think there is an extra “the”.

test_class should be time_class

Top of the page:
Appears to be no space between “and” and “eval()free" looks like ”andeval()-free", but copy & paste shows a space there…

PS. Loving this book - exactly what I’ve needed to really ‘grok’ Ruby - thanks!

Just under the paragraph:
“Now Computer#respond_to?( ) knows about Ghost Methods:
cmp.respond_to?(:mouse) # => true”
there is a “require ‘unit_test’ ” line that don’t really belong here, I think.

The use of the first x variable (in my_method) is not really clear, as it’s not used at all. I understand that the goal is just to tell that the block will use the x defined outside of the method, and not inside, but I don’t really find it convincing. Maybe it would be better to use the “method” x inside the yield, like “yield(x)” ? Or maybe using back the result of the yield? Or maybe, doing a diagram showing the execution inside the method, and thus really showing clearly that the x used is the one defined outside? Just a suggestion, of course.

I don’t find the example of local variable name overwriting by block variable very convincing. A note or a diagram should maybe be made to indicate that naming the block argument ‘x’ is like passing the local variable x as the arg to the block, and then calling “yield(2)” just put 2 in x, thus the result with the local variable. I understand the example, but don’t find it crystal clear. Just a suggestion of course.

Sorry about that, but again, I don’t find your example crystal clear. It’s really easy to understand it wrong. Maybe it would be better for this whole paragraph to use kind of “scope” diagram, indicating what’s the scope (which variables are defined, what are their values, where were they defined, etc.), for pertinent lines of code. A bit like the “hierachy” object and classes diagrams that you used in Chapter one or that Dave Thomas used in its Ruby Metaprogramming screencasts (insert free ads here). Just simple square boxes diagrams will do, and I think it will greatly help to understand all this. Just a suggestion of course.

The list of Callable Objects (Blocks, Procs, Lambda, Methods) may be better at the start of the section 3.5 (Callable objects). It would be easier to follow the list of descriptions of all callable objects. Also, it may be better to subdivise it into a main list (Blocks, Procs, Methods) and then a sublist for Procs (regular procs and lambda) and then finally describe all the way to create a Proc (Proc.new, lambda(), proc(), &block, ->(x) {}, to_proc()). Once all those information are given, like a outline, it will be easier to follow the rest of the chapter, which is a list of description of all those objects. Just a suggestion of course.

Concerning the last example of “Class Variables”, I think it should be noted why it is the case (overwriting @v). In particular, this would explain why there is overwriting when the class var is defined in the top level, but NOT in a containing class: class MyClass1 v = 1 class MyClass2 v = 2 end @v # => 1
end

So in fact, the surprise overwriting happens only if @@v is defined in the top level, that is in Object (And Object being the superclass of everyclass…). Just a suggestion, of course.

I don’t think that your example of use of class_eval is pertinent. In fact, you’re not using the fact that class_eval is redefining the current class, you’re just using the fact that class_eval is redefining self, just like instance_eval. Indeed, one can change class_eval with instance_eval in the example and the example is working exactly the same. It’s not a problem to show an example where class_eval can do the same thing than instance_eval, but it’s a bit of a problem when you introduced class_eval as able to do different things than instance_eval. At least, you should mention that here, class_eval is not used for its current class changing capacity, but only for its self changing capacity, and that instance_eval can do exactly the same thing.

“While instance_eval( ) only changes self, class_eval( ) changes both self and
the current class.” This is not exactly true. instance_eval ALSO change the current class, just not the same way than class_eval(). Instance_eval change the current class not to be the receiver, but the eigenclass of the receiver. Even if the eigenclass is not yet defined at this point in the book, I think at least a footnote should be put to inform the reader about this. I think also that a sidebar, when talking about eigenclass, about instance_eval changing current class to the eigenclass of the receiver, would be a good thing, if only for completeness.

In the second example: “def s.title? ” I think this “s” came from nowhere, and is never again used.
I think the singleton method “title?” should be defined AFTER paragraph is defined, and on it, so that it can be passed to index.

In figure 4.5, I think the “go to right” link shouldn’t be called “Eigenclass” but “class”, as it’s the SAME link and same mechanism, be it a regular class or a eigenclass. Moreover, it’s more consistent with preceding figures (like figure 4.3).
Then, the “Class” class is missing from figure 4.5, which will:

- make the link with figures 1.4 and 1.5
- make the link with first solution described next page (putting class attributes in Class class).

I think that two figures would be very much helpful to explain the class attribute example. One would be with attr defined “classically” (class MyClass; attr_accessor :my_attribute; end), the other one would be with attr defined at the class level, in the eigenclass. For each case, the figure will describe the place of the methods and the call path (go to right, then up). It will be good to see the difference between the two (in fact, just a switch on the right). Just a suggestion.

A figure for each example code (Class Extension and Object Extension) would be very much welcome I think. Just a suggestion.

To finish section 4.5, just before going to aliases, I think it could be good to have a full-page figure of a full complete object model, with an object, its eigen class, its eigenclass module (Object extension), then its class, a module, a superclass, a superclass module, and Object, and then, to the right, the classes eigenclasses, and then some modules over those eigenclasses (Class extension), and then Class, Module, and back to Object.
The idea is to get an object model as complete as possible, with every cases, and especially every cases seen until there in the whole book. Just a suggestion.

Code colouring of the eval string in the Capistrano map.each block is wrong: some of the eval string appears green as if its a comment.

Code colouring is wrong in the nested irb example.

Suggest you use instead of tags in your eRB HTML.

Last paragraph second sentence reads better as “It not only contains class methods that do important stuff like opening database connections—it’s also the base class of all mapped classes like Duck:”

“the MVC component that contains domain objects and logics.”

I would use the singular ‘logic’.

“ActiveRecord::Base is the most important class in ActiveRecord. Not only
it carries class methods that do…”

- shouldn’t this be “…not only DOES it…”?

some_duck = Duck.find(:first)
my_duck.id # => 1
some_duck.name # => “Donald”
some_duck.delete

Why is this my_duck.id and not some_duck.id? Aren’t you trying to show how the data is called back from the db?

“No Java coder in her right mind …”

- I think the unisex adjective ‘their’ would be a little more appropriate here?

The code from alias_method_chain was edited improperly to make it fit on the page, resulting in an error in the lines that assign with_method and without_method

Footnote 2 contains an extraneous closing parenthesis.

In the callout box “Where Should You Put Your Methods?”, the reference to page 29 for Open Class should be 26 (as the first reference in that box already is). Also, the reference for Singleton Method is page 128; it should be 127 (but the link correctly goes to page 127).

Footnote nr. 6 at page 70
“See the sidebar on page 65. The sidebar also explains why in Ruby 1.9, you have to use send!( ) instead of send( ).”

The sidebar say about “send” and “public_send”. I think the footnote could be erased.

module Text

1. …
   That’s where the problem lies: Since Text is already the name of a module
   in Bookworm, Ruby complains that it can’t also be the name of a
   class at the same time.

Text is a module in ActionMailer (format.rb), not in Bookworm, where’s a class.

I think from the following the second ‘instance’ can be erased. So:

An object’s instance variables live in the object itself,
and an object’s instance methods live in the object’s class.

will become:

An object’s instance variables live in the object itself,
and an object’s methods live in the object’s class.

:-)

In the “Is Monkeypatching Evil?” sidebar the final sentence reads “Finally, you can apply techniques such as that described in the (as yet) unwritten sb.rakeAndMonkeypatching to minimize your chances of catching a Monkeypatching bug”

I suspect you meant either “to maximize your changes of catching a Monkeypatching bug,” or “to minimize your changes of causing a Monkeypatching bug.”

The redflag.rb script (An Even Better DSL) doesn’t work in ruby 1.8 (I don’t think passing ‘&block’ style args to a block is supported). Should this compatibility issue be flagged?

Last para. : […] where the block pick up its bindings.
< should be “picks” ?

This is a magnificent and readable book and I love getting
fully immersed into each subject! P.S. PLEASE KEEP the
lovely hand-crafted line drawings!

[…]" a computer scientists would say " < sing. scientist ?

3rd para. “… basically, whenever one of many different things happen.” <- ? one .. “happens.” [nitty, I know]

In the second paragraph:
As he draws Figure 1.7, Bills also explains …
Since I’m not so good at English, I do not understand why “Bill” is plural in this context. I think “Bill” does not need to be plural. Sorry, if I’m wrong.

“— that’s what the define_methods() method is for.” <- sing. ‘define_method()’ ?

Paolo .. my mistake .. define_methods() is not a typo. You can erase my noise if you wish. Thanks for a great book!

Obi-Wan would say it more like this:
“Global variables in disguise, those top–level instance variables are like. Get rid of them, why don’t you?”

When I run this code, Ruby 1.9.1 returns an array, not the puts result in the first highline example.
Return value:
[“puts \\”You’re friends with \\#{friends.inspect}\\“Tom”, “Jane”, “Ricky”]

When running the Code Processor example, I get his error using Ruby 1.9.1:

TypeError: can’t convert String into Integer
from (irb):44:in `read’
from (irb):44
from /usr/local/bin/irb:12:in `

I found the problem. The “puts” line has to be executed after the “Friends?” prompt. When I cut and paste all 3 lines, the puts line doesn’t execute as expected. Perhaps moving the puts line to be after the “Friends?” prompt might work better, if users are cutting and pasting example code.

BTW, this is one great book. Your examples all are very consise and directed to a particular point, without a lot of embellishment. And sorry for my Yoda/Obi Wan mixup. “A brain fart, it must have been.”

“If all you want is change self,”

This might be better:

“If all you want is to change self,”

Ruby 1.9.1 - I get this same error in both irb and "ruby -e broken_math.rb’

/usr/lib/ruby/gems/…/gems/test-unit-2.0.3/lib/test/unit/autorunner.rb:274:in `block in keyword_display’: undefined method `[]’ for nil:NilClass (NoMethodError)

The Around Alias works fine for the FixNum class, but the test code blows up. Am I missing something?

“wether” should be “whether”

“After reading though this book,”
change to:
“After reading through this book,”

3rd paragraph in it says: " It’s easier to adapt
Ruby to your own needs that it is to adapt Java"

“that” should be “than”

Steve’s report #40716 might be about a technical error : the
File.readlines method works as advertised here. My tiny 2c.

Rule 6 at the bottom of the page is slightly incomplete. “The superclass of the eigenclass of a class is the eigenclass of the class’s superclass” does not apply to #BasicObject, since BasicObject does not have a superclass. In fact, the superclass of #BasicObject is Class (which makes sense, because the object is, after all, an instance of Class).

While adding this detail makes rule 6 complete, it may also make it hopelessly confusing.

Re: Steve’s report #40719 .. I suspect that the test-unit
gem may be the trouble. If I use the ‘test/unit’ that ships
with Ruby 1.9.1 (on linux) I have success for the broken_math.rb test.

On the last line but 4:
For short, you can this spell a Flat Scope.

I guess this should be:
For short, you call this spell a Flat Scope.

First line:

Bill decides it’s time time for a story:

Duplicated words ‘time’.

How? By getting get rid of all the define_component( ) methods.

should read:

How? By getting rid of all the define_component( ) methods.

I think that the diagram 4.6 on page 149, although technically correct, miss the point to be made. It’s true that the class of #MyClass is a Class, but that’s not what’s important, because methods in the class of the eigenclass can only be called if you call directly the eigenclass (only ONE step to the right at a time).
What’s important here is that the SUPERCLASS of the eigenclass #MyClass is Class! Then, it means that if you call a class method on MyClass, then it will search FIRST in the eigenclass (one step to the right) THEN in the Class (one step up). And then, this explains WHY the preceding code (using the b var) was working before, but why it was a bad code (as b is then defined for all classes).

I think that this whole point is also missed in the diagram 4.5, page 146. The footnote talk about being a completist and adding Kernel and BasicObject. But I thik that what’s really missing is the Class and Module classes, on the top of #Object, on the top right. This way, it would be coherent and explaining both diagram 4.2 (page 139) and diagrams done in the first chapter (1.2 page 37, 1.4 page 44 and 1.5 page 45).

I think it’s important NOT to forget the ‘standard’ place of Class with eigenclass, that is as the “class” of any class object, even if the class object has eigenclass. Also, this would show that the eigenclass of the superclass of a class object are put on top of the class object own eigenclass, but still always UNDER the Class object. Without this, there’s a link missing between model in the first chapter (the class hierarchy of a class object is Class -> Module), and the model in the fifth chapter (the class hierarchy of a class object is a hierarchy of its own and its superclass eigenclass).

Not sure that what I wrote is crystal clear, I hope that you will still understand what I mean :)

“Bill tries to sums it all up”
Should be:
“Bill tries to sum it all up”

Description for the table example:
(That’s why there is no return before super: Nothing is ever returned).

Even if super returns a value, that would be fine, because the last expression is used by ruby as the default value. I think that the description about the missing “return” is a bit confusing

Example:

class Test

def does_nothing
“does nothing from Test”
end
end

class MyTest < Test

def does_nothing
var = “text from Mytest”
super
end
end

puts MyTest.new.does_nothing # => does nothing from Test

Out of curiosity, does Bob’s middle names include DROP TABLE Students?

You may want to change the link for online ruby to a newer site - the old web site seems to be one of the casualties from _why’s disappearance.

Are you sure you mean last-generation monitor, or do you mean latest-generation monitor?

I’m referring to the XKCD comic “Exploits of a Mom”, which featured Robert’); DROP TABLE Students;— . (The code on page 15 is SQL injection-unsafe, isn’t it?) I just found the coincidence in first names (Robert vs Bob) interesting. Also, thanks for the prompt replies to errata!

In the following code:

module MyModule
def my_method; ‘hello’ ; end
end

obj = Object.new
obj.extend MyModule
obj.my_method # => “my_method”

class MyClass
extend MyModule
end

MyClass.my_method # => “my_method”

The two invocations of my_method should probably resolve to “hello” as opposed to “my_method” unless I’ve misunderstood the example badly.

At the risk of being extremely pedantic, the “ctcw” in “ctcw/simple_eval.rb” (and elsewhere in the chapter) should be “ctwc”.

Is “klass” a more common variable name than “clazz”?

In the second paragraph, the one that follows the loop code, it says that “The infinite loop on the last line collects strings from the standard output…”. That should be “…from the standard input…”.

In the description of closures, the use of the variable name x in both the method and the local scope along with:

Still, the code in the block sees the x that was around when the block was defined, not the method’s x, that is not used at all.

could be understood to mean that the local variable is taking precedence over the one in the method, when in fact, the x in the method is not available at all.

I suggest:

Still, the code in the block sees the x that was around when the block was defined, not the method’s x, which is not available at all to the block.

Or perhaps another example that shows the error you would get if you tried to refer to a variable in the method, within the block.

I think the code splitting across the page in this example is particularly troublesome as it tends to obscure the fact that variable x is defined in two different scopes (the split being immediately after the assignment to x), and programmers with no fp experience may not notice the subtlety of the example.

I tend to disagree with the difference between programming, metaprogramming and DSL. As an old Lisp hack, we almost always “build the language we need to solve the problem at hand”. Put another way, we create a simple, clean syntax that expresses the problem. In some cases this syntax may be more verbose than the host language. There is nothing unusual or special about doing this, except that not many people do it today, few languages support this style of coding.

Ruby supports much of what Lisp can do and therefore metaprogramming and DSLs are really nothing more than using Ruby (or Lisp) properly. I expect (hope) that in a few years the term DSL dies; because not using core language features, where it is necessary, is considered poor style, just as not abstracting interfaces in OO is today.

Incorrect usage of the term fluke. “Bookworm itself should log this fluke and proceed.”

In footnote 2, the sentence is cut off: (collected and …?

Ok, can now see the problem, footnotes are flowing between pages. Footnote 6 has very odd justification/word spacing.

Last line on page extends beyond body text into the right margin:…), or method_undefined( ):12

any chance of mentioning Object vs BasicObject (1.8 vs 1.9) in figure 1.7?

First paragraph:

“Now look at self_test_assigns( ).”

should be

“Now look at set_test_assigns( ).”

Then again in the second paragraph:

“Then self_test_assigns( ) iterates…”

should be

“Then set_test_assigns( ) iterates…”

I am not sure of Ruby 1.8 but:

“…and it has to be the last argument in
the method (not considering the final “block” argument)."

is incorrect in Ruby 1.9. You can put the argument array wherever you want. You just may get an empty array as it will be filled last.

Monday: The Object Model >> Open Classes >> The Money example
There’s a code that says that “standard_price = 10000.to_money()” is equal to 100.00 US Dollars but later in the same text, the method Numeric#to_money is defined as “Money.new(self*100)”. Wouldn’t 10000.to_money be 10000.00 US Dollars then?

“You open an irb session and smoke-test the new Computer.”
It won’t run because we haven’t defined a file DS (or an in-memory string replacement for it). I suggest creating one making it downloadable by clicking on a link.

The two sentences seem inconsistent:
" The real mean of the & is: “This is a Proc that I want to use as a blcok.” Just drop the &, and you’ll be left with a Proc:"
Would seem consistent to say “Just drop the &, and you’ll be left with a block.”(implicitly the block that the previous sentence says you wanted_.
Or change the first sentence to read: “This real meaning of & is ”This is a block that I want to use as a Proc. Do so; drop the & and you’ll be left with a Proc."

The section on callable objects needs to be expanded to motivate the distinctions the language makes between procs, lambdas, blocks and methods. Having Bill say " Good luck finding a use for this exotic stuff" doesn’t help. I suggest that the author have a deeper discussion with the language designer about the rationale for the differences, and construct realistic examples of where you might want to use each.

In section 1.3 you learned that … a class is just a module with a couple of additional features ( a superclass and a new() method).
In ruby 1.9 at least, Module has a superclass: Object
puts “#{Module.superclass}” # Object

“So, a class is just a souped-up module with three additional methods—new(), allocate(), and superclass().”
At least in Ruby 1.9 Module supports the method superclass(). The superclass of Module is Object.

Please withdraw earlier erratum report, on this page and later reference to it.
‘Module.superclass’ returns Object, but only because the class of Module is Class, and Class defines the method ‘superclass()’ as your text says.

“To prove that all his theory
can come very useful, Bill shows you a trick called class instance
variables.” Text then goes off to describe class-level instance variables for next 3 pages. It is unclear what (if anything) these have to do with the class_eval() method Bill was describing.

“The superclass of #BasicObject is … Class. This fact explains why you can call MyClass#b() and MyClass#b=().”
Two issues: There has been no mention of MyClass#b(); did you mean MyClass#c()?
Second: I may be slow but it was not clear to my why the fact that class Class was the superclass of #BasicObject made these method calls possible. Is it that class Class makes ALL calls possible? Perhaps a bit more detailed unraveling.

Sorry. Withdraw the previous errata report also. You did mean MyClass#b — that was the method that was defined on class Class in an overly powerful attempt to define getters and setters for a class-level attribute. It still might be interesting in rev 2.0 to talk a bit about the very top of the class hierarchy — the fact that both the superclass and the class of #BasicObject are Class.

You might want to note that in the test suite for step 3 you had to drop the test cases for nil and false that were present in the test suite for step 2. The ‘>=’ method used in the validation block is not defined on either nil:NilClass or false:FalseClass.

In step 4(a) — when the method attr_checked is just defined on class Class — avoid name clash by using ‘value’ or ‘v’ in the block associated with attr_checked in Person rather than ‘val’
class Person
attr_checked: age do |value|
value >= 18
end
end

“How can a mixin like CacheMixin bend the rules and define class methods on the class that includes it?” I got the how. But when I started reading this section I had an antecedent question: Why do this? Why not simply extend Person with a module that defines the method attr_checked? And when I had finished this section 5 pages later, I was left with the same question. You need to motivate this trickery. Pick and example where the straightforward thing won’t work, and explain why you’ve moved to fancier trickery. Simple solution:
require ‘test/unit’

module CheckedAttributes

def attr_checked(attribute, &validation)
define_method “#{attribute}=” do |val|
raise ‘Invalid attribute’ unless validation.call(val)
instance_variable_set(“#{attribute}", val) end define_method "#{attribute}" do instance_variable_get("#{attribute}”)
end
end

end # module CheckedAttributes

class Person
extend CheckedAttributes
attr_checked :age do |value|
value >= 18
end
end

class TestCheckedAttribute < Test::Unit::TestCase

def setup
@bob=Person.new
end

def test_accepts_valid_values
bob.age=20 assert_equal 20, bob.age
end

def test_refuses_invalid_values
assert_raises RuntimeError,‘Invalid attribute’ do
@bob.age=17
end
end

1. def test_refuses_nil_values # Fails this test with error “undefined method ‘>=’ for nil:NilClass”
2. assert_raises RuntimeError, ‘Invalid attribute’ do
3. @bob.age=nil
4. end
5. end

1. def test_refuses_false_values # Fails this test with error “undefined method ‘>=’ for false:FalseClass”
2. assert_raises RuntimeError,‘Invalid attribute’ do
3. @bob.age=false
4. end
5. end

end # class TestCheckedAttribute

The test cases for the redflag example are too simple to preclude a number of more simplistic solutions to the problem. In particular there’s nothing that requires the “clean room” approach, e.g.., nothing in those test cases fails if you just put everything at the top level scope:

events = Hash.new setups = []

def event(name, &block)
@events[name] = block
# puts “ALERT: #{name}” if yield
end

def setup(&block)
@setups << block
end

Dir.glob(‘*events.rb’).each do |file|
load file
events.each do |name, event| setups.each { |setup| setup.call }
if event.call
puts “ALERT: #{name}”
end
end
end

I realize that you’ve just discussed things like clean room and instance_eval, so the reader might be inclined to use them, but it would be nice if the tests pushed the reader in that direction.

The spec for the Red Flag DSL is “The DSL stills checks events in the order they’re written”. Putting the events in a hash as is done in the given solutions doesn’t ensure that they’ll come out in the specified order if we use “each” like is done in the given solutions, correct?

Highlighting of code in example for find_by_description! is slightly off / misleading. At the end, we have:
result || raise(RecordNotFound, “Couldn’t find #{name} with
#{attributes.to_a.collect {|pair|
”#{pair.first} = #{pair.second}" }.join(‘, ’ )}")

where there is a mix of blue and green text as it appears the ‘#’ are mistakenly taken as comment starters,

Hi Paola, I am learning a lot from the book! Great content! A suggestion for the “The Top Level” sidebar: I would extend this a bit to mention irb subsessions which allow you to change the value of self used by the interpreter. You might also mention that this is a convenient technique for exercising private methods:

irb(main):007:0> s = “abc”
=> “abc”
irb(main):008:0> s.private_methods
=> [“rand”, … ]
irb(main):009:0> s.rand
NoMethodError: private method `rand’ called for abc
\tfrom (irb):9
\tfrom :0
irb(main):010:0> irb s
irb#1(abc):001:0> rand
=> 0.181140548984387

You should probably choose a name other than “play_with_self” due to its crude meaning. How about “test_self” or simply “return_self”?

I have a problem with the heading “Ruby Classes Are Special”. This is actually opposite of what you say in the following paragraph — that classes are NOT special in Ruby. Perhaps the intention was to note that Ruby classes are special from the perspective of other languages. But we already know that if for no reason other than that they’re open. How about “Ruby classes are not special” or “Ruby classes are first-class objects” or something like that.

In the sidebar on “Here Documents,” the result is shown as

puts

this is a “multi-line” string
wishing you a great 2010

However, leading spaces in the string are preserved by a here-doc string in Ruby 1.8.7:

puts

this is a “multi-line” string
wishing you a great 2010

The text says, “It [erb] … also creates a Clean Room (109) to execute the code in a separate scope.” P. 109 shows how to create a clean room by calling instance_eval on an object; p. 122 uses that technique again. I don’t see that happening in the ERB snippet at the top of p. 175. Is this code using a different method of making a clean room? Is the instance of ERB the clean room?

The sentence “The DSL stills checks events in the order…” has a typo. The word “stills” should be “still”

I like your example answer ( blocks/monitor_framework/redflag.rb ) but I see some issues … I’m sorry if I’m wrong in my assumptions.

- The event names could collide, silently. I know this is just a sample ( that you quickly replace but it was the first thing that popped into my head and distracted me from the following code for a while ).
- All of the setup blocks are iterated for each event in cleanroom objects, it really doesn’t just remove the “global” nature of the @variables in the setup blocks, it removes their shared nature between events.

A minor formatting issue (and possibly a matter of opinion): Footnote 6, “However, these days…”, looks odd with that much whitespace between the words.

On line 4,

“you’re ready to dive in this book.”

should be

“you’re ready to dive into this book.”

the line: “Module, so a class is also a module.”
I mean: Module is a superclass of Class and it is a class too;
Module is the name of a class not a module.

line: “of Kernel that every object inherits.”
I mean: Kernel is a module and has no instance_methods;
method_missing resides as a private_instance_method in BasicObject.

I think ‘class Txt < Fatty::Format’ should be ‘class Txt < Fatty::Formatter’

“which prides itself”

succinct is spelled incorrectly

at the very bottom of the page, you have ”…generated_methods() returns true…” but I think you want the boolean version of the method ‘generated_methods?()’.

Nill Guards do not work well with booleans.
a = false # a gets initialized
….
a ||= true # initialization gets overwritten
Effectively, it guards both against nil and false.
A pitfall that cost me quit some time, once….
Should be explained more clearly, I think.

… if Bill hadn’t called obj.my_method( ), …

should be

… if Bill hadn’t called obj.my_method, …

He actually calls obj.my_method, not the result of calling obj.my_method.

Not Found

The requested URL /titles/ppmetr/code/gems/rubygems-update-1.3.3/lib/rubygems.rb was not found on this server.

There are other examples that can’t be downloaded either…

[1, 2, 5].inject(0, &:+) # => 8

can even be written as

[1, 2, 5].inject(&:+) # => 8

Quit many (small) code examples extend over two pages.
I think they’d be more readable if they’d been on just one page.

In

if load_error.message =~ /#{Regexp.escape path}\\z/ and

everything to the right of the # is accidently marked as comment…

because @time_class( ) is always nil.
->
because time_class( ) is always nil.

because time_class( ) is always nil. -> because time_class is always nil.

“eRB” should be “ERB”.
“ERB” is the official name.

AcriveRecord::Base()
->
AcriveRecord::Base

Thus is the description=()
->
This is the description=()

The ‘lambda.call’ solution does not seem to clear the setups and events variables for each new events file, whereas the previous solution on page 97 did.

“my_method() is called on obj()”
should be
“my_method() is called on obj”

tryruby.sophrinix.com. has moved to tryruby.org

The author suggests that you can’t support methods that accept blocks, such as Array#find, with dynamic dispatch, and thus you’ll need to resort to eval(). I don’t agree; I’ve only been reading up on Ruby for a month so maybe I’m missing something? Surely the ability to convert a block into a Proc by having a third argument to a method with a preceding ‘&’, and then from this Proc to the block required by find() etc with another, allows this?

def explore_array(method,*args,&block)
[‘a’,‘b’,‘c’].send(method,*args,&block)
end

a = explore_array(:find,[]) do |x|
x 'b' end p (a ‘b’ ? “Book wrong - you can” : “Book right - you can’t”) + " support blocks without eval" # => Book wrong - you can support blocks without eval

Fantastic book either way, it’s almost brought me to an understanding of eigenclases, I’ve got that good brain ache feeling :)

Cheers,

Tim Ruffles

“The Stubby Lambda” may be “The Stabby Lambda” ?

“Integer() class” should be “Integer class”

I think “inclusor” is not a English word. Is it “includer” which includes module (so “include + r”) ???

“ActiveRecord::Validation” should be “ActiveRecord::Validations”

“ActiveRecord::Base#respond_to?” should be “ActiveRecord::Base#respond_to?()” according to your convention.

Bill points out the previous code implicitly calls ancestors() method, but the code says “ancestors # => [Book, Document, Printable, Object, Kernel, BasicObject] ” explicitly.

“On the other hand, if you don’t need to define instance methods on the including class, …”

might be

“On the other hand, if you don’t need to define class methods on the including class, …”

“In this example, the value to the right happens…” should be “In this example, the value to the left happens” ???

In The Top Level sidebar, "because it ‘s the object", space between t and ’.

In the epub version of the book, there are plenty of inconsistent - vs — vs —- vs actual em dashes. Some of my notes include the nearby words:

high, profile
method, related
donut, induced
stand, alone
kick, start

In some of them (donut-em-induced) a simple ‘-’ should have been used. In others, it’s just inconsistent: stand—alone vs kick-start.

But after a while I stopped keeping track of them, so an audit to find them all probably ought to be done.

Similar to comment #41674, I’m confused about all this extra machinery. I don’t see why module/mixin authors must go through such ridiculous contortions to make mixins. Ruby provides both include(foo) and extend(foo), and it seems silly to me that the whole point of all the included() hooks is just to turn around and call extend. The thing being extended is calling include! So why doesn’t the API author just say “please call ‘extend BlubberMixin’ to get access to Blubber”?

“opening database connections—-It’s also the base class”

s/It’s/it’s/

“But wait—-There is more”

s/There/there/

“I’ll go over it with you one piece at the time.”

s/at the time/at a time/

Class#new() -> Class.new()

Some of the limitations of arguments described in the book are made obsolete by Ruby 1.9 (for example, Array Arguments can be in the middle of other arguments)

“stubby lambda” vs. “stabby lambda”

In the book I say that lambdas are more tolerant than blocks when it comes to arity, but this has been tightened up in Ruby 1.9. Check.

“Hello, Bill!” should be “Hello, Bill”

“Your main code loads the files that end with event.rb.”
should be
“Your main code loads the files that end with events.rb.”

Constant lookup rules in Ruby 1.9 have changed. Check.

C# names (like conn.readStuff() and dispose()) should begin with an uppercase character by convention.

It might be useful to discuss the way that Dynamic Dispatch relates to Second-order predicates in mathematical logic.

The string “respond_to?” is used in a regular expression (twice). Given that ‘?’ is an RE metacharacter, this is asking for a match to either “respond_t” or “respond_to”.

More generally, the RE will match any method name which includes “method_missing” or “respond_t”. It should be tightened up, so that it only matches the desired methods.

A third problem with the Around Alias is that it pollutes the name space and might clash with an existing or future name.

Why not present the alternative formulation which captures a reference to the old method in a variable and uses that in the wrapped call?

a ||= []
is the same as
a || (a = [])
but
a = a || []

From Kado: a comment about “private” on the book:

there is one exception: it’s “setter” method.
“setter” always need “self” as literal.

def setter=(val)
 p val
end
private :Setter=

def getter
 p 123
end
private :getter

self.setter=(123) # => 123
self.getter       # => NoMethodError

Note that define_method( ) is executed inside the definition of Computer, […]

It should be define_component().

“gem install flickr” at footprint. But flickr gem does not maintenace.
stackoverflow.com/questions/976211/flickr-gem-how-to-access-user-details
So this page flickr example does not work. I do not know what gem is alternative most major flickr wrapper.

Not a big deal, but since Taboo is our family’s favorite game, thought I might correct one portion of the text in section 4.2: In Taboo you are not trying to have your teammate guess a “sentence,” but you have them try to guess a certain “Word” - the person has to get their teammates to guess the ‘word’ without saying any of the taboo words listed on the card.

In the GUT, rule 6 needs a little hint that the class of a class object will be class Class at the top of the eigenclass chain. Seeing figure 4.6 made rule 6 clear. The placement of the object Class isn’t mentioned until figure 4.6, which is a page too late (in v1.0).

Isn’t Pascal cased a better term here? Camel cased normally means mySpecialClass - with “humps” in the middle of the compound word. Pascal case is similar but starts with an initial capital letter.

Chap05:

> you can execute code in that scope by using the Binding object in conjunction with eval( ), instance_eval( ), or class_eval( ).

> You can evaluate code in the captured scope by passing the Binding as an additional argument to one of the eval*( ) methods:

Only eval method can accept binding (xxx_eval cannot).

One reader complained that the ToC is useless. Any ways to make it more informative?

“If you could call a method instead of using the class, ”. It should be “[…] using the class keyword, ”.

In the Loan class revisited example the class method Loan.time_class seems wrong.
It should be

def self.time_class
@time_class ||= Time
end

While actually is

def self.time_class
@time_class || Time
end

so the @time_class class instance variable in never really assigned.

“Note that define_method() is executed inside the definition of Computer…”

As the author noted, that should be:

“Note that define_component() is executed inside the definition of Computer..”

…which refers to the last three lines of the class—the lines where define_component() is called—not the definition of define_component().

However, why is that class method approach even taken? Why not simplify the example and call define_component() from inside initialize()? Inside initialize() self is the object, and if you called define_component() inside initialize(), then define_component() could be defined as a regular instance method.

Regressing for a moment, what the text fails to mention is that Module#define_method() is a private method. As the text explained earlier, private methods cannot be called explicitly by an object—private methods have to be called without a “receiver”. And when a private method is called, the receiver becomes whatever self is at that moment.

Now, because the goal is to define regular instance methods inside the Computer class using define_method(), when we call define_method(), at that instant self must be Computer. If self isn’t Computer, then define_method() won’t create instance methods in the Computer class.

When is self equal to Computer? Inside a class method! When a class is used to call a method, inside the method self is the class. That is exactly analogous to when you call an instance method with an instance/object of the class—inside the method, self is the instance/object.

As a result, if you create a wrapper method around define_method() and you make the wrapper method a class method, then the receiver for define_method() will be Computer, and Computer will be populated with regular instance methods.

The syntax for define_method() looks different on this page. Why?

Note that the method that is being defined takes no arguments. define_method() itself takes an argument, the name of the method, but in this case the method being defined doesn’t require any arguments. Therefore, you can forgo the “do |my arg|” part of the syntax.

This is in response to the previous comment which said there is a mistake in the line:

@time_class || Time

The comment says that || should be replaced by ||=. That is incorrect. The purpose of the method that contains that line is not to assign a value to time_class. Instead, the purpose of the method is to return the value of time_class if it exists, otherwise return the Time class.

The text explains that in production code, the variable time_class will always be nil because it is never set anywhere, and therefore the method will always return the Time class. It should be noted that time_class is not the same kind of variable as book and time, which are introduced in initialize(). time_class is introduced in a method where self = the Loan class, and book and time are introduced in a method where self = a Loan instance. As discussed on p. 106, time_class is a Class Instance Variable, which means you access it through the Loan class—not an instance of the Loan class.

The code on p.109 then creates a unit test that employs what the author calls a “Context Probe”. A Context Probe inserts some code into an object, and then evaluates the code in the context of the object. In this case, the object is the Loan class, and the evaluation of the code inside the Loan object is done with instance_eval(). The instance_eval() method sets the value of @time_class to FakeTime. As a result any subsequently calls to the method containing the line:

@time_class || Time

will now return the value of @time_class since it is no longer nil—as the author intended.

This error was also mentioned in comment #43465 with respect to pdf p. 185. However the correction offered in that comment is also incorrect.

The text claims:

On the other hand, if you don’t need to define instance methods on the including class, you can drop the inner module altogether and define all the methods in the mixin itself:

module MyMixin
def self.included(base)
base.extend(self)
end

def x
puts “x()” #I added puts because the text
#seems to run everything in irb
#which is NOT the way to run code

end
end
———

If you had been following the text up to that point, then that claim should be shocking, and in fact it is false:

class Person
include Mixin
end

Person.x #class method
Person.new.x #instance method

—output:—
x()
x()

If you understood the text up to that point, that is the result you would expect. I have no idea what the author was trying to demonstrate with that example, perhaps:

“On the other hand, if you drop the inner module altogether, and instead you define all the methods in the mixin itself, then you can simultaneously make the methods both class and instance methods.”

If you asked 100 programmers what they thought the following code did:

print Class.instance_methods(inherited)

…100 of them would say the line probably displays some inherited methods.

And if you asked those same programmers what the following code did:

print Class.instance_methods(not_inherited)

…all of them would say that the code probably displays some methods that aren’t inherited.

The point?? ‘inherited’ is a HORRIBLE CHOICE OF VARIABLE NAMES when the goal is to print the methods that ARE NOT inherited! The suggestion? Change this code:

inherited = false
Class.instance_methods(inherited)

to

not_inherited = false
Class.instance_methods(not_inherited)

Now the meaning of the second line of code is intuitive, which is the most important line of the two. The meaning of the first line of code is irrelevant.

Rewrite the Methods chapter to talk about the trade-offs of Ghost Methods vs. Dynamic Methods. Show the two main Ghost Method spells (the “difficult” case of Dynamic Proxy and a new spell, maybe named Convenience Ghost, for cases when you use method_missing() for convenience reasons). End by picking Dynamic Methods in the main example over Ghost Methods.

info = data_source.send("get_#{name}_info", args[0]) price = data_source.send(“get_#{name}_price”, args[0])

=>

info = data_source.send("get_#{name}_info", id)
price = data_source.send("get_#{name}_price", id)

broken_math.rb sample code is missing the following line.

require ‘test/unit’

require ‘using’ fails
maybe require_relative ‘../blocks/using’ is needed to be used.

module.rb sample does not work.
—
$ rails -v
Rails 2.3.2
$ ruby -v
ruby 1.9.2p180 (2011-02-18) [i686-linux]
$ ruby modules.rb
/usr/local/lib/ruby/gems/1.9.1/gems/activerecord-2.3.2/lib/active_record/validations.rb:92:in `generate_message’: undefined method `self_and_descendants_from_active_record’ for MyClass:Class (NoMethodError)
from /usr/local/lib/ruby/gems/1.9.1/gems/activerecord-2.3.2/lib/active_record/validations.rb:48:in `add’
from /usr/local/lib/ruby/gems/1.9.1/gems/activerecord-2.3.2/lib/active_record/validations.rb:602:in `block in validates_length_of’
from /usr/local/lib/ruby/gems/1.9.1/gems/activerecord-2.3.2/lib/active_record/validations.rb:399:in `block (2 levels) in validates_each’
from /usr/local/lib/ruby/gems/1.9.1/gems/activerecord-2.3.2/lib/active_record/validations.rb:396:in `each’
from /usr/local/lib/ruby/gems/1.9.1/gems/activerecord-2.3.2/lib/active_record/validations.rb:396:in `block in validates_each’
from /usr/local/lib/ruby/gems/1.9.1/gems/activesupport-2.3.2/lib/active_support/callbacks.rb:182:in `call’
from /usr/local/lib/ruby/gems/1.9.1/gems/activesupport-2.3.2/lib/active_support/callbacks.rb:182:in `evaluate_method’
from /usr/local/lib/ruby/gems/1.9.1/gems/activesupport-2.3.2/lib/active_support/callbacks.rb:166:in `call’
from /usr/local/lib/ruby/gems/1.9.1/gems/activesupport-2.3.2/lib/active_support/callbacks.rb:90:in `block in run’
from /usr/local/lib/ruby/gems/1.9.1/gems/activesupport-2.3.2/lib/active_support/callbacks.rb:90:in `each’
from /usr/local/lib/ruby/gems/1.9.1/gems/activesupport-2.3.2/lib/active_support/callbacks.rb:90:in `run’
from /usr/local/lib/ruby/gems/1.9.1/gems/activesupport-2.3.2/lib/active_support/callbacks.rb:276:in `run_callbacks’
from /usr/local/lib/ruby/gems/1.9.1/gems/activerecord-2.3.2/lib/active_record/validations.rb:1029:in `valid?’
from modules.rb:27:in `

The book says that you can use Class#new to define a new class. This is not correct, you use Class.new.

class D < C; end

absent in the code snippet.

From pwim on Twitter: “4.5 Quiz: Module Trouble seems to fall outside of The Great Unified Theory. Is including modules not part of the object model?”. Good point, the “theory” list needs to talk about module inclusion.

(from @jonclaus) The methods/dynamic_definition.rb code example in Chapter 5 didn’t convey define_method’s power or a reason to use it over the def built-in.

“They also call model objects to execute business logics,”

“logics” should be “logic”

Footnote is not numbered and not referenced on the page.

“Your main code loads the files that end with `event.rb`”.

This should be “(…) that end with `events.rb`” (plural events).

At the beginning of section 3.7, the boss writes a `test_events.rb` file that includes two events, both of which get triggered. The example would be more complete if it also had an event that did not get triggered, e.g.

event “Everything is OK!” do
sky_height > mountain_height
end

“[setups and events are] evaluated in the context of an `Object` that acts as a Clean Room”.

It would be very helpful if the example on page 96 failed if you don’t use a Clean Room. In the current version, it works if you use `block.call` for both setups and events.

Blocks are somewhat mind-bending, so it would be extremely useful to have an extensive failing test suite to force the reader to understand the subtleties and implications.

Mention (from the BasicObject documentation):
“BasicObject does not include Kernel (for methods like puts) and BasicObject is outside of the namespace of the standard library so common classes will not be found without a using a full class path. … Access to classes and modules from the Ruby standard library can be obtained in a BasicObject subclass by referencing the desired constant from the root like ::File or ::Enumerator.”

In the proc{ … }.call, the $SAFE works differently from normal global variable. I wrote a simple test like this:

$ABC = ‘abc’
puts $ABC # abc
proc {
$ABC = ‘cde’
puts $ABC # cde
}.call
puts $ABC # cde

Why is $SAFE different? I hope you can talk about it in the book.

I would appreciate if you can tell me why.

My email is: yzhang.wa@gmail.com

Thanks,
Yi Zhang

String#grep is mentioned when the author means Array#grep (or Enumerable#grep) in

“First, if you pass a block to String#grep(), the block is evaluated for each element that matches the regular expression…”

I believe this to be a very simple problem. On page 82 it is stated that, "Bill had to use Dynamic Dispatch (41) to access the private method define_method() on Kernel.) This is, in fact, not completely true. (Luckily you teach all the concepts so well, I was able to diagnose this.)

The statement can be corrected by saying, “Bill had to use Dynamic Dispatch (41) to access the private class method define_method on Kernel.” Allow me to explain.

If “define_method” was simply a private instance method of Kernel, then you should be able to call it with an implicit self from anywhere that contains Kernel in it’s ancestor chain. But this is not the case. Since it is a private class method of Kernel, it must be called with an implicit self equal to Kernel.

I hope what I am saying makes sense, because this caused a great deal of trouble for me. At first, I thought I was misunderstanding what you had written previously, but it turns out that you were entirely correct just not completely correct per se.

Thanks for a great book, I really love it!

“Kernel#method_missing() responded by raising a NoMethodError”

in 1.9, #method_missing was moved to BasicObject
this is mentioned a few paragraphs earlier in the book
i have also confirmed that it is indeed in BasicObject by looking at the docs

should read:
“BasicObject#method_missing() responded by raising a NoMethodError”

thank you

the switch from “info = data_source.send("get_#{name}_info", id)” to "info = data_source.send("get_#{name}_info", args[0])" in chapter Methods is a bit confusing. Kado suggested changing everything to the id form, which I did - but as a result, the *args argument of method_missing() is never really used. I should find a way to make this less confusing in the next edition.

When the ^ methods get added to the regex in more_blank.rb, the regex gets a little looser in other respects. The resultant regex does match respond_to?, but only because it matches the respond_t part (since the ? isn’t escaped). Also, the anchors got stripped from the final two method names.

I would probably use something like /^{$/. Others might use /}|^method_missing$|^{respond_to\\?$/ or /}|^{$/. My preference is for the first alternative since I find it the most explicit. The .* makes it clear that I mean followed by anything, I have one} and one $ at their respective ends of the regex and they are always used so I don’t have to waste cycles figuring out if I’m missing them somewhere or if they were omitted from one of the alternatives on purpose.

—Toby Ovod-Everett
toby@ovod-everett.org

`a ||= []` is not equivalent to `a || (a = [])`
`a || (a = [])` will throw a “undefined local variable or method ‘a’”

The correct equivalent is `a = (a || [])`

In the last paragraph, last sentence, you have an extra “-” between “get” and “ListUser()” in the Flickr#tags_getListUser() method reference.

In the paragraph right after the code fragment for mere_cache/merb_ext/controller.rb, second sentence, there is a “-” between “Class” and “Methods” that shouldn’t be there.

in the redflag.rb:

Dir.glob(‘*events.rb’).each do |file|
load file
each_event do |name, event|

the line above should be:
each_event do |event|

since the define_method :each_event above specifies only 1 block paramater.

In the method_missing definition, args[0] is being passed in the data_source.send call. However, the various methods being called actually need the id (as seen in previous pages/revs). Is there something I’m missing here? This implementation seems to imply that one must call my_computer.cpu 42 in order to get the cpu info for computer 42. But, the example farther down the page does not show an id being passed in the my_computer.cpu call.

In foot note #3, it says “There is also an Object#define_method() that defines a Singleton Method(101).”

There is no Object#define_method() method, but for ruby 1.9.X and 2.0 there is an Object#define_singleton_method(), defines a Singleton Method, taking a name and either a Proc, Method object or a block.

Great book! Thanks for putting it together

In paragraph 2.5, at the bottom of the page, it says “The drastic Module#undef_method() removes all methods, including the inherited ones.”

I found it a bit confusing in a first read. Module#undef_method does remove all the occurrences of a given method in the inheritance chain, but it seems to say that removes “all methods”, creating some kind of blank slate.

Not a big deal if you keep reading or look at Ruby API documentation…

The order of expected output for Frank and Bob is reversed from what it should be based on the order of the output statements.

“This fact explains why you can call MyClass#b() and MyClass#b=()”

Shouldn’t it by MyClass.b() and MyClass.b=() (with .’s instead of #"s) since b would be called on MyClass itself, not on an instance of MyClass?