Architectural_Design_with_SketchUp

Architectural Design with SketchUp
For the impatient: If you prefer to just get things going without learning the basics of
the language first, then skip this section and go to some of the code samples in the next section
(starting on page 245). Any of them work as they are when you run them in SketchUp.
You can always come back later and read up on the basics here.
236
How Does Ruby Work?
Objects, Objects, Objects
Ruby is essentially an object-oriented language. Everything in the language is an object, and
every object has properties and methods. You can always apply any appropriate method to
an object. You can even add more methods, if you like. Here’s what I mean.
Assume you have an object an_object and the object has a method a_method that does
something with it. You can then apply the method to the object simply by adding it with a
dot as in an_object.a_method. If you want to apply more than one method, you can simply
chain them, as in an_object.a_method.another_method (as long as they are compatible).
Here are some examples that make this a bit clearer.
“Hello World!” is a string, as we found out earlier. It is also a String object that has some
built-in methods. One of those is length. You can therefore enter “Hello World!”.length,
which yields 12, the length of the string in characters.
An example for chaining methods is 125.to_s.length, which gives the result 3. Now,
what happened here? We started with 125, which Ruby automatically interprets as a number
(an integer, actually). We then applied a conversion method to it (to_s), which converts
the number object to a string. Finally, we added the length method that tells us the length
of the string in characters, which, of course, is 3.
A similar operation in SketchUp is converting from one unit system to another. As you
know by now, internally SketchUp uses inches as its base unit, no matter which localized version
you are using. If you want to convert a number in inches to, say, centimeters, you can
simply use the built-in numeric function to_cm to get the correct value. Therefore, entering
1.to_cm results in 2.54.
As you learn more about methods, you will likely come across these two strange-looking
types of methods (shown here as examples):
NN
NN
String.upcase!—A method with an exclamation mark at the end modifies the original
object in place (in this example, we turn a string into uppercase). Therefore, you don’t
need to assign it to another variable.
String.include?—A method with a question mark checks something on the object and
results in a true or false (Boolean) answer. The example method shown here checks
whether a string includes a substring.
One important principle to understand about object-oriented programming languages like
Ruby is that objects (and the classes that define them) have one or more ancestors (parents).
Analogous to the way we receive our parents’ genes, objects in Ruby receive (inherit) their
parent’s methods and properties. For example, the Edge object in SketchUp, whose parent is
the Drawingelement object, has a bounds property that it inherits from that object, although
by itself it doesn’t have this property (as you can see in Appendix C). This may sound confusing
at first, but you will soon find that it is a very useful principle.