Architectural_Design_with_SketchUp

Chapter 6 Creating Geometry Using Ruby Scripting
NN
NN
NN
NN
A multiline comment starts with =begin and ends with =end.
Parentheses are optional in method calls (to enclose the arguments), though it might be
a good idea to add them for readability.
You can often make things easier in repetitive Ruby code by using ranges. A range
comes in a form like this: 1..5, which includes all integer numbers from 1 to 5. A
good example is (1..5).to_a, which creates an array like this: [1, 2, 3, 4, 5].
Other valid ranges are: 0.1..0.9 and ‘a’..’m’.
There are two ways to create code blocks: One uses curly brackets, { at the beginning
and } at the end; the other uses do at the beginning and end at the end. In many cases,
you can use either one to enclose code (e.g., for an each statement).
What Else Is There?
There is more—much more. Particularly when you need to define your own classes or use
some specialized Ruby classes and extensions, there is more to discover. But—as I’ve said
before—this is a pragmatic introduction and we’ll limit language functions to only what is
absolutely necessary to complete our tasks. There are several useful links at the end of this
section that will help you delve deeper into Ruby. We will also cover file operations in some
of the upcoming examples.
What’s in SketchUp’s Ruby API?
SketchUp’s Ruby API is an extension to plain Ruby (covered previously) and includes objects and
methods that are useful in SketchUp. Some of these allow you to interact with the SketchUp
application or the currently open model. Others allow you to add or modify geometry (entities).
There are also methods to attach observers to anything in the software. This is useful if
you need your code to spring into action when the user changes something. Look through
Appendix C to get an understanding of how extensive this API actually is.
The full API documentation can be viewed at https://developers.google.com/sketchup, where you
can also find numerous code examples and revision notes. The links in the next section give
you even more resources for finding documentation, code samples, and discussion forums.
You can use any of the SketchUp API’s objects and methods in your code whenever you
like. As long as your Ruby code runs inside SketchUp, there is no need to “include” or define
any external files. As demonstrated when you added a triangle to the model, one line is
enough to get things started. Let’s quickly look at this code again and take it apart:
Sketchup.active_model.entities.add_face [0,0,0],[0,10,0],[0,10,10]
Here we are accessing the currently open model (the active_model) through the Sketchup
object. If we want to add any geometry in there, we can’t simply add it to the model; we
need to add it to the Entities collection in the model. This makes sense, of course, because
everything in a model is somehow organized into collections (there are also layer, material,
241