282
APPENDIX A
BRIEF
INTRODUCTION
TO
R
UBY
important, it shows how you can use the eval keyword to run an arbitrary string and
execute that string as Ruby code.
If you run this program and type 1+2 followed by a return, you get the following:
Equation > 1+2
1+2 = 3
Equation > 
eval is at the core of the ERb template-handling package. ERb reads in the templates
and turns them into Ruby code. It then runs eval on that code at runtime to
“execute” the template.
Regular expressions
Regular expressions are invaluable to code generation and text handling in general.
A complete treatise on regular expressions is well beyond the scope of this book, but
you should get a sense of how Ruby handles regular expressions in the syntax.
You can define a regular expression using operators or objects. The operators are
merely shorthand for the object versions. A simple matching expression using opera-
tors is shown here:
myString = "My dog has fleas"
if ( myString =~ /dog/i )
print "Dog is in string '#{myString}\'\n"
end
Here you are checking for the existence of the pattern dog in a string using the =~
operator. This more complex search example extracts substrings from a string using
a pattern:
myString = "key:value"
if ( myString =~ /(\w+):(\w+)/ )
print "#{$1} => #{$2}\n"
end
Here you apply the regular expression (\w+):(\w+) to the string. The parentheses
delineate elements of the string that are to be extracted. These extracted substrings are
stored as the special values $1, $2, and so forth in the order of their appearance in the
regular expression.
Another common use of regular expressions is to replace substrings within a string
with new values. Here is an example substitution in Ruby:
myString = "My dog has fleas"
myString.sub!( /dog/, "cat" )
print "#{myString}\n"
Here you are replacing an occurrence of dog with cat. You do this using the sub!
method on the String class. The use of the ! symbol at the end of the method is a
Ruby convention that implies that the change will be made in place. The sub method
Adjust pdf size - Compress reduce PDF size in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
C# Code & .NET API to Compress & Decompress PDF Document
change font size pdf form; change font size in pdf form field
Adjust pdf size - VB.NET PDF File Compress Library: Compress reduce PDF size in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET PDF Document Compression and Decompression Control SDK
change page size pdf; pdf file size limit
A
N
ADVANCED
R
UBY
PRIMER
283
(without the !) does not change the string but instead returns a new string with the
altered value.
You can find more information about regular expressions in Mastering Regular
Expressions, by Jeffrey Friedl (O’Reilly, 2002).
A.2
A
N
ADVANCED
R
UBY
PRIMER
In this section, we examine more advanced Ruby topics, including exception handling,
file input/output, the p operator, and the yield keyword.
Exception handling
In Ruby, exception handling is built into the base language. To wrap some code in an
exception handler, you use the begin and rescue keywords, as shown here:
begin
... some risky stuff ...
rescue => myErr
print "Ran into some trouble:\n\n#{myErr}\n"
end
In this case, if any uncaught exceptions are thrown within the execution of the risky
stuff, they are caught in the rescue statement and an error is printed. Ruby supports
specification of the exception type in the rescue handler as well as the subclassing of
existing exception types.
File I/O
File I/O in Ruby is really simple. Ruby has a built-in File class that works across
various platforms and is easy to use. Here is an example of reading a file:
fh = File.open( "test.txt" )
print fh.read
fh.close()
Here you are opening the file using the 
open
class method on the File class. The
variable returned is a File object handle. You then call the 
read
function, which
reads all of the contents of the file. The contents are then printed and the file is closed.
Here is a slightly more Ruby-like style of reading the same file:
File.open( "test.txt" ) { |fh|
print fh.read
}
This is the same example as the previous one, with the exception that here the read is
performed only if the file is opened. Also, there is no requirement to have a close
method call because the file is closed automatically at the end of the block execution.
VB.NET Image: How to Draw Annotation on Doc Images with Image SDK
multi-page TIFF, Microsoft Office Word and PDF file that, you are also able to adjust various image control the annotation shapes, the outline size (width and
best way to compress pdf; adjust size of pdf file
C# Image: Zoom Image and Document Page in C#.NET Web Viewer
jpeg), gif, bmp (bitmap), tiff / multi-page tiff, PDF, etc. APIs for Visual C# .NET developers to adjust the image & document page viewing size with this
change font size in pdf fillable form; change font size in pdf text box
284
APPENDIX A
BRIEF
INTRODUCTION
TO
R
UBY
To open a file for writing, you use an optional second argument on the open
method, as you can see in this example:
File.open( "test.txt", "w" ) { |fh|
fh.print "Hello\n"
}
Again, the block is run only if the file is successfully opened, and the file is closed auto-
matically at the end of the execution of the block.
The p operator
Ruby has a clever operator named p, which can print to standard output a text version
of whatever object it is presented with. This comes in very handy when you are debug-
ging and you don’t know the variable’s value. For example, the code
myArray = [ 1, 5, "hi", "there" ]
p myArray
prints this to the standard output:
[1, 5, "hi", "there"]
The yield keyword
Iterators, like each and times, are not built into Ruby. These iterators are built in
Ruby using the yield keyword. Here is an example of an iterator that presents to the
block all of the odd numbers in a given range:
def myIterator( startValue, endValue )
curValue = startValue
while( curValue < endValue )
if ( curValue % 2 == 1 )
yield curValue
end     
curValue += 1 
end
end
myIterator( 10, 20 ) { |value| print "#{value}\n" } 
Running this Ruby code prints the values 11, 13, 15 17, and 
19
, just as it should.
The real trick is in the yield invocation in the middle of the while loop. yield
takes the supplied arguments and presents them to the block that was given to the
function. This block of code
{ |value| print "#{value}\n" }
then takes the value and prints it. If the block returns a value, it becomes the return
value of yield. Using an iterator/yield pattern, you can build a data filter, with your
code block not only receiving values but generating new values as well.
Generate and draw PDF 417 for Java
417 barcode image text in Java Class barcode.setData("PDF417 for Java"); //Adjust PDF 417 size with left, right, top and bottom margins barcode.setleftMargin(3
can pdf files be compressed; pdf custom paper size
VB.NET Image: VB.NET Code to Create Watermark on Images in .NET
font type "Times New Roman", size "16", and style "Bold"), and then adjust brush color provide powerful & profession imaging controls, PDF document, tiff
acrobat compress pdf; 300 dpi pdf file size
L
EARNING
MORE
ABOUT
R
UBY
285
The generators in this book use yield to build specialized iterators that allow
templates to easily generate similar code for multiple items. An example is generating
the column definitions for all of the columns in a table. The column definitions are
XML objects and the block code is actually an ERb template, but the resulting imple-
mentation is very clean because of the use of the yield keyword.
A.3
L
EARNING
MORE
ABOUT
R
UBY
Ruby is a language worth exploring. It has a clean syntax and is easy to read. It is purely
object-oriented, while at the same time being simple and fun to use. Here are some ref-
erences where you can learn more about Ruby:
• Programming Ruby, by Dave Thomas and Andrew Hunt (Addison-Wesley, 2000),
is the definitive work on Ruby and is commonly known as the “pick-axe” book in
the Ruby community. This book goes into detail on every aspect of Ruby, from
its syntax and operators to its class libraries. It also shows you how to embed
Ruby in other languages.
• Ruby in a Nutshell, by Yukihiro Matsumoto (O’Reilly, 2001), is a quick-reference
book for the Ruby enthusiast written by the master himself.
• The Ruby Way, Hal Fulton (Sams, 2001), is another good reference work on Ruby.
This book focuses more on programming style and method, as opposed to being
a strict reference.
In addition to these books, you can check out these online resources:
• Ruby Central (www.ruby-lang.org) is the central site for all things Ruby. It fea-
tures links to other Ruby resources and serves as a good jumping-off point.
• The Ruby Application Archive (http://raa.ruby-lang.org/) is Ruby’s answers to
Perl’s CPAN. Here you can find modules and libraries to use with Ruby.
• Ruby Garden (http://www.rubygarden.org/) is Dave Thomas’s Wiki dedicated to
Ruby. It is an invaluable technical and community resource for Ruby programmers.
C# PowerPoint: How to Set PowerPoint Rendering Parameters in C#
this SDK to render PowerPoint (2007 or above) slide into PDF document or Generally, you are allowed to set image resolution, image size, batch conversion and
adjust size of pdf; pdf page size limit
C# PDF: Use C# APIs to Control Fully on PDF Rendering Process
PDF document PDFDocument doc = new PDFDocument(@"c:\sample.pdf"); // compute zoom new Rectangle(0, 0, originalWidth, originalHeight), size); // adjust with a
pdf optimized format; .pdf printing in thumbnail size
286
A
P
P E N
D
I X
B
The simple system 
test framework 
System tests are particularly important when you are generating lots of code quickly.
One small bug in the generator can cause a lot of bad code to be generated. That is why
all of the case studies in this book include a section showing you how to use a system
test framework to test the generator.
You can find test frameworks for Ruby at these sites:
• RubyUnit (http://homepage1.nifty.com/markey/ruby/rubyunit/index_e.html)
• Test::Unit (http://testunit.talbott.ws/)
The system test framework we describe in this appendix is not meant to replace any of
these utilities. Our goal is to show you a convenient example of building a simple
framework to test command line-based code generators.
B.1
T
HE
BASIC
DESIGN
This simple system test runs command-line programs and compares the output of the
program against a stored known goods file. You specify the command lines through an
XML file that contains both command lines for running and naming the file or files
that are output from the command line. In this section, we’ll take a look at the basic
design of this system.
VB.NET Excel: VB Methods to Set and Customize Excel Rendering
on the fixed image size ration that the size is limited by Adjust Image Scaling Factor. supports converting Excel to other document files, like PDF with online
change font size in pdf comment box; reader compress pdf
C# PDF Convert: How to Convert Word, Excel, PowerPoint, Tiff
Support rendering image to a PDF document page, no change for image size. Able to adjust and customize image resolution to meet various C# PDF conversion
adjust pdf size; batch reduce pdf file size
T
HE
BASIC
DESIGN
287
B.1.1
Processing flows
There are two processing flows for the system test. The first is for building the known
goods, and the second is for testing against the known goods. 
Building known goods
The processing flow for building the known goods is shown here:
• Reads the XML file and builds the internal representation.
• For each test follows these steps:
•Runs the command line.
•For each output file, makes a copy of that file in the known goods directory.
Testing against the known goods
Here’s the processing flow for testing against the known goods:
• Reads the XML file and builds the internal representation.
• Initializes a list of test failures.
• For each test, follows these steps:
•Runs the command line.
•For each output file, compares it against the corresponding file in the known
goods directory. If the two files are not identical, then it adds this test to the fail-
ure list. If there is no known goods file, then it adds this test to the failure list.
• Prints a list of test failures.
B.1.2
The input file format
As we mentioned earlier, you specify the list of tests using XML. An example XML
definition is shown here:
<ut kgdir="kg">
<test cmd="ruby uigen.rb definitions/form1.def" out="output/form1.jsp" />
<test cmd="ruby uigen.rb definitions/form2.def" out="output/form2.jsp" />
<test cmd="ruby uigen.rb definitions/table1.def" out="output/table1.jsp" />
</ut>
The <ut> tag specifies the known goods directory using kgdir and contains all of
the tests. Tests are specified using the <test> tag. Each <test> tag specifies a com-
mand line using the cmd attribute and an output using the out attribute.
A test can also specify multiple output files for a single command-line test, as
shown here:
<ut kgdir="kg">
<test cmd="ruby -I../lp rpcgen.rb examples/Test.java">
<out>examples/TestHandler.java</out>
<out>examples/TestStubs.java</out>
C# Word: How to Draw Text, Line & Image in C#.NET Word Project
copy the sample codes below to adjust text properties such as image color, picture size, location of powerful & profession imaging controls, PDF document, image
adjust file size of pdf; pdf file compression
C# Word: Set Rendering Options with C# Word Document Rendering
& raster and vector images, such as PDF, tiff, png rendering application still enables users to adjust and set developers can choose a target size or resolution
can a pdf file be compressed; reader pdf reduce file size
288
APPENDIX B
T
HE
SIMPLE
SYSTEM
TEST
FRAMEWORK
</test>
</ut>
You can expand the 
<test>
tag to include multiple <out> tags. Each <out> tag
contains the name of the output file as text. In the previous example, the one invoca-
tion of ruby -I../lp rpcgen.rb examples/Test.java creates both
examples/TestHandler.java and examples/TestStubs.java.
B.1.3
The ut1.rb code
Here’s the code for our simple system test framework:
require 'rexml/document'
require 'getoptlong'
require 'ftools'
require 'ostruct'
@@xml_file = ""                                                       
@@is_making = false                                                   
begin                                                                 
opts = GetoptLong.new(
[ "--test", "-t", GetoptLong::NO_ARGUMENT ],
[ "--make", "-m", GetoptLong::NO_ARGUMENT ],
[ "--file", "-f", GetoptLong::REQUIRED_ARGUMENT ]
)
opts.each_option do |name, arg|
@@xml_file = arg if ( name == "--file" )
@@is_making = true if ( name == "--make" )
end
rescue
print "ut1 usage:\n";
print "  ruby ut1.rb -f xml_def_file - To run the tests against the known 
goods\n"
print "  ruby ut1.rb -m -f xml_def_file - To regenerate the known goods\n"
exit
end
begin
doc = REXML::Document.new( File.open( @@xml_file ) )              
rescue
print "Could not open or parse #{@@xml_file}"
exit
end
kgdir = doc.root.attributes[ 'kgdir' ]                              
unless kgdir
print "No known good directory defined on the 'ut' tag.\n"
Parses out the 
command line
q
Reads the 
XML file
Gets the known goods 
directory name
T
HE
BASIC
DESIGN
289
exit
end
tests = []
doc.root.elements.each( "test" ) { |test_node|                      
files = []                                                        
files.push( test_node.attributes[ 'out' ] ) if ( test_node.attributes-
[ 'out' ] )
test_node.elements.each( "out" ) { |out_node|
out = out_node.text.strip
files.push( out ) if ( out )
}
tests.push ( OpenStruct.new( {                                      
'command' => test_node.attributes[ 'cmd' ],                       
'output_files' => files                                           
} ) )                                                               
}
failures = []                                                       
tests.each { |test|                                                 
print "#{test.command}\n"
system( test.command )                                            
test.output_files.each { |file|
known_good_name = kgdir + "/" + File.basename( file )           
begin
current_result = File.open( file ).read()                     
rescue
print "Failure: No output file - #{file}\n"
next
end
if ( @@is_making )                                              
print "Storing #{file} to #{known_good_name}\n"
File.syscopy( file, known_good_name )                        
print "Known good #{known_good_name} stored\n"
else
print "Checking #{file} against #{known_good_name}\n"
begin
good_result = File.open( known_good_name ).read()          
if ( good_result != current_result )                         
print "Failure: Known good comparison failed\n"
failures.push test.command
end
rescue
print "Failure: No known good file - #{known_good_name}\n"
failures.push test.command
end
Adds the test to 
the list of tests
e
Gets all of the output filenames
w
Iterates through 
each test XML node
Checks output 
against the 
known goods
r
Reads the 
output file
Initializes a list 
of test failures
Iterates through 
each test
Runs the 
command
Builds a name 
for the known 
goods file
Reads in the 
known goods
Switches on testing or 
makes known goods
Copies the out-put file 
to the known goods file
290
APPENDIX B
T
HE
SIMPLE
SYSTEM
TEST
FRAMEWORK
end
}
print "\n"
}
unless ( @@is_making )
if ( failures.length > 0 )                                         
print "\n\nTests failed:\n\n"                                        
failures.each { |test| print "  #{test}\n" }                         
exit -1                                                              
else
print "\n\nNo test failures\n"
end
end
q
The output of the command-line processing section is the name of the input XML file
and the flag that defines whether you are testing against the known goods or creating
the known goods. The XML filename is stored as the global @@xml_file, and the
@@is_making flag is set to true when you are building the known goods.
w
In this section, you look for both the out attribute on the test node and any out
nodes for populating the files array. The files array stores the names of all the
out-put files.
e
You use OpenStruct to create an object for storing the test command and the test
out-put files. OpenStruct takes a hash table of values and creates a new object that
supports the 
.
syntax for the field names. In this case, if you have a reference to one of
these OpenStruct objects, you can use the obj.command method to return the
command name and obj.output_files to get the array of output files. Without
OpenStruct, you would use the regular hash table syntax of hash['command']
and hash['output_files'].
r
This code does a byte-by-byte comparison of the output file against the known goods
file. In some cases, this may be too sensitive. The addition of some white space, for
example, can have no semantic effect, yet it could cause a failure of the system test.
You may want to change the way the comparison is done in order to lessen the sen-
sitivity of the test. One possibility is to remove all white space before the comparison.
Although some errors may be overlooked, it is far more likely that common white-
space issues (e.g., extra returns) will be ignored and not result in a test failure.
If that solution is too drastic, you may want to go with a multistage test, whereby
the test with whitespace comparisons disabled can produce failures and a byte-by-byte
comparison can produce only warnings.
Prints out test 
failures
291
A
P
P E N
D
I X
C
EJBGen code and templates
In this appendix, we describe all of the code and templates for the EJBGen generator.
We show the output using the example definition files in the EJBGen case study
(chapter 10, section 10.5). You can find code that is not included here on the book’s
web site (www.codegeneration.net).
C.1
T
HE
GENERATOR
CODE
The next three sections examine the code for the EJBGen generator.
C.1.1
ejbgenRead.rb
The file in listing C.1 contains the code for reading the three input files: schema,
extensions, and samples. The schema file contains XML that describes all of the tables
and their relationships. The extensions file includes any extra data transfer object,
query, or custom method definitions. As you’d expect, the samples file contains sample
data that we want to load into the database to test the database access layer code.
def getXMLAttr( elem, attrName )   
attr = elem.attributes[attrName]
if !attr
raise "ERROR:  missing attribute [#{attrName}]"
end
return attr
end
def getXMLElemText( baseElem, elemName )   
elem = baseElem.elements[ elemName ]
Listing C.1 1 ejbgenRead.rb
Gets an XML attribute 
from a node
Gets the text from 
within a node
Documents you may be interested
Documents you may be interested