asp.net mvc display pdf : Adjust size of pdf file SDK Library API .net wpf html sharepoint Manning%20-%20Code%20Generation%20in%20Action16-part1335

132
CHAPTER 6
G
ENERATING
DOCUMENTATION
6.3.4
Building the code for the SQL generator
The case study generator is written in Ruby and uses the Tokenizer toolkit from
chapter 3 (“Code generation tools”) to read and parse the SQL file. The code then
stores the table definitions and comments in memory and uses this material to generate
the HTML pages. The generator creates the HTML pages with the help of templates
from ERb. Listing 6.2 shows the code for the documentation generator.
require "SQLTokenizer"                       
require "SQLLanguageScanner"                                           
require "JavaDoc"                                                      
require "erb/erb"                                        
def run_template( template_name, bind )                                  
erb = ERb.new( File.new( "templates/#{template_name}" ).read )      
erb.result( bind )                                      
end
def convert_comment( comment )                                       
cleaned = ""                                                
comment.each_line { |line|                                    
line.sub!( /\s*\-\-\s*/, "" )                                 
line.strip!                                            
cleaned += "#{line}\n" if ( line.length > 0 )                   
                                                             
converted = "/**\n"                                         
cleaned.each_line { |line| converted += " * #{line}" }              
converted += " */\n"                                        
converted                                                  
end                                                  
class ExtendedJavaDoc < JavaDoc                                     
def initialize()                                          
super()                                                  
@tableDescription = ""                                     
@fieldDescriptions = {}                                   
@relatesTo = []                                        
end
attr_reader :tableDescription  # The table description string
attr_reader :fieldDescriptions  # The hash of descriptions for each field
attr_reader :relatesTo  # The array of tables this table relates to
def add_to_tag( key, text )                                     
text.strip!                                          
if ( key == "@desc" )                                    
@tableDescription += text                              
elsif ( key == "@field" )                                  
text =~ /(.*?)\s/                                              
Listing 6.2 2 docgen.rb
Brings in the SQL Tokenizer
q
Includes support for JavaDoc
w
Brings in the ERb template system
e
Simple template
processor
r
JavaDoc subclass for 
SQL documentation
t
Adjust size of pdf file - Compress reduce PDF size in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
C# Code & .NET API to Compress & Decompress PDF Document
pdf custom paper size; change font size pdf document
Adjust size of pdf file - 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
advanced pdf compressor; pdf page size limit
CASE
STUDY
AUGMENTED
SQL 
CODE
133
field = $1                                                 
text.sub!( /^#{field}\s*/, "" )                             
@fieldDescriptions[ field.downcase.strip ] = text                
elsif ( key == "@relates_to" )                                   
@relatesTo.push( text )
end
end
end
def read_sql_file( file_name )
print "Parsing #{file_name}...\n"
fh = File.open( file_name
in_text = fh.read()
fh.close()
tokenizer = SQLTokenizer.new( )
tokenizer.parse( in_text )
languagescanner = SQLLanguageScanner.new()
languagescanner.parse( tokenizer.tokens )                              
tables = languagescanner.tables
tables.each { |table|          
print "Building #{table.name}.html\n" 
jd = ExtendedJavaDoc.new()                                        
jd.parse( convert_comment( table.comment ) )
table.fields.each { |field|
field.comment = jd.fieldDescriptions[ field.name.to_s.downcase.strip ]
}
table_comment = jd.tableDescription                               
relates_to = jd.relatesTo                                        
fh = File.new ("output/#{table.name}.html", "w" )                
fh.print run_template( "table_page.html.template", binding )     
fh.close()     
                             
print "Building tables.html\n"                                    
fh = File.new ("output/tables.html", "w" )                        
fh.print run_template( "tables.html.template", binding )          
fh.close()                                                                         
print "Building index.html\n"                                     
fh = File.new ("output/index.html", "w" )                         
fh.print run_template( "index.html.template", binding )           
fh.close()                                                        
end
if ARGV[0]                                                              
read_sql_file( ARGV[ 0 ] )  
else                                                                    
print "Must specify an input SQL file\n"                                
end                                                                
Tokenizes 
the SQL
Reads the SQL 
input file
Parses the SQL 
token stream
Iterates through each table
y
Gets the 
JavaDoc
u
Iterates over
each field
i
Builds the 
main index 
of tables
Builds the 
container 
frame
Creates the out-
put HTML file
a
Sends the argument 
to the SQL documen-
tation builder
VB.NET Image: How to Draw Annotation on Doc Images with Image SDK
like multi-page TIFF, Microsoft Office Word and PDF file). that, you are also able to adjust various image the annotation shapes, the outline size (width and
pdf optimized format; pdf edit text size
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
pdf file compression; pdf compression
134
CHAPTER 6
G
ENERATING
DOCUMENTATION
q
This code imports the Tokenizer and parser that reads the SQL. These are from the
language parsing toolkit described in chapter 3.
w
The JavaDoc class is also from the language parsing toolkit. It reads JavaDoc
comments and creates a hash of key value pairs that stores the data in the comment.
Later in this chapter you’ll create an ExtendedJavaDoc class that derives from the
JavaDoc class to handle your requirements.
e
ERb is the text-template handler.
r
run_template is a wrapper for the ERb template mechanism that takes the file-
name of a template and the binding object that contains the local variables for template.
t
The ExtendedJavaDoc class derives from the JavaDoc class and handles
the @field and @relates_to keys. The @field descriptions are stored in the
fieldDescriptions hash table; the @relates_to table names are stored in an
array called relatesTo.
y
This code iterates over every table. Within this loop the code reads the JavaDoc com-
ments attached to the table, then uses a template to create the HTML page for the table.
u
This code creates our ExtendedJavaDoc object for this table and passes along to it
the comments that are attributed to the table.
i
This code attaches a comment to every field by using the comment for the field in the
ExtendedJavaDoc object.
o
These two local variables—table_comment and relates_to—are passed to the
ERb template by using the binding method call on run_template.
a
This code runs the ERb template that generates the HTML page, which in turn
describes the table.
Next you need a template that uses basic ERb substitution to build the header at the
top of the page. This header describes the fundamentals of the table, including the
name, and the comment. The template then iterates over each field to create the
HTML table that describes the fields of the database table. The ERb template for the
generator is shown in Listing 6.3.
<html><head>
<title><%= table.name %></title>                
</head>
<body>
<table width=100%>
<tr>
<td width=10% nowrap valign=top><b>Table Name:</td><td><%= table.name %></
td></tr>                                       
Listing 6.3 3 table_page.html.template
Uses the table name as the title
Shows the table name and comment
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
change font size in pdf form field; can a pdf be compressed
C# PDF Convert: How to Convert Word, Excel, PowerPoint, Tiff
for image size. Able to adjust and customize image resolution to meet various C# PDF conversion requirements. Conversion from other files to PDF file can be
adjust file size of pdf; pdf change page size
CASE
STUDY
AUGMENTED
SQL 
CODE
135
<td width=10% nowrap valign=top><b>Description:</td><td><%= table_comment 
%></td></tr>
<td width=10% nowrap valign=top><b>Fields:</td><td>  
<table cellspacing=1 cellpadding=0 bgcolor=#bbbbbb width=100%>
<tr>
<td width=20% nowrap valign=top><b>Name</b></td>
<td width=20% nowrap valign=top><b>Type</b></td>
<td width=20% nowrap valign=top><b>Constraints</b></td>
<td width=40% valign=top><b>Comments</b></td>
</tr>
<% table.fields.each { |field| 
constraints = []
constraints.push( "Non-null" ) if ( field.not_null ) 
constraints.push( "Unique" ) if ( field.unique ) 
constraints.push( "Primary key" ) if ( field.primary_key ) 
%><tr>
<td bgcolor=white valign=top><%= field.name %></td>
<td bgcolor=white valign=top><%= field.type %></td>
<td bgcolor=white valign=top><%= constraints.join( ", " ) %></td>
<td bgcolor=white valign=top><%= field.comment %></td>
</tr><% } %>
</table>            
</td></tr>
<% if ( relates_to.length > 0 )              
rel_text = relates_to.map { |table| "<a href=\"#{table}.html\">#{table}" 
}.join( ", " )
%><td width=10% nowrap valign=top><b>Relates To:</td>
<td valign=top><%= rel_text %></td>
</tr><% end %></table>
</body>
</
html>
q
This code loops through each field and outputs the cells that contain the names, the
types, the constraints, and the comments.
w
This code prints a list of related tables. The map
creates the <a>
tags and the join
adds the comments between the completed <a> tags.
The tables.html file displays the left-hand menu in a framed layout (shown in figure 6.2).
The menu contains the names of all the tables. When the user clicks on one of the table
names, the right-hand frame shows the page specific to that table. The template for the
tables.html file is shown here:
<html>
<body>
<% tables.each { |table| %>                                               
<a href="<%= table.name %>.html" target="main"><%= table.name %></a><br>  
<% } %>                                                                   
</body>
</html>
Shows the 
beginning 
of the field 
table
Outputs each field
q
Outputs the related 
table links
w
Shows the end of 
the field table
Creates links to all
of the Table pages
C# PDF: Use C# APIs to Control Fully on PDF Rendering Process
0, 0, originalWidth, originalHeight), size); // adjust with a 0, originalWidth / 2, originalHeight), new Size(originalWidth / 2 tool to convert PDF document to
optimize scanned pdf; batch pdf compression
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
advanced pdf compressor online; change page size of pdf document
136
CHAPTER 6
G
ENERATING
DOCUMENTATION
Next you must write the template for the index.html file. No substitution is
required in this template. The resulting HTML is a frameset that places the menu on
the left-hand side and the table information in the right-hand panel. Here’s the code:
<frameset cols="20%,*">
<frame src="tables.html">
<frame name="main" src="tables.html">
</frameset>
Figure 6.2 shows the output of the generator for the Book table. The HTML shows the
name of the table, your description of it and all its fields, and the tables to which it relates.
6.3.5
Performing system tests
You are now ready to conduct system tests for your generator. You do this by using the
system test framework described in appendix B. It’s a simple process. The first time the
test system runs, the generator stores the output as a set of known goods. After that,
you run the generator and compare the outputs against the known goods. If there is a
discrepancy, then you know that your definition of a good result has changed, your
SQL has changed, or the generator is not creating the proper output. Once you iden-
tify the problem, you can re-create the known goods and start the process over again.
Here is the configuration file for the simple system test framework:
<ut kgdir="kg">
<test cmd="ruby -I../lp docgen.rb examples/tables.sql">
<out>output/Author.html</out>
<out>output/Book.html</out>
<out>output/Publisher.html</out>
<out>output/index.html</out>
<out>output/tables.html</out>
</test>
</ut>
Figure 6.2 2 The generator builds this documentation for the Author table 
View Images & Documents in Web Image Viewer | Online Tutorials
page document or image file, like Word, PDF or TIFF three different APIs for adjusting image viewing size. btnFitWidth API allows developers to adjust the width
best way to compress pdf; pdf page size dimensions
VB.NET Image: Image Resizer Control SDK to Resize Picture & Photo
VB.NET Code for Adjusting Image Size. In order to resizer control add-on, can I adjust the sizes of powerful & profession imaging controls, PDF document, image
change font size in fillable pdf; adjust pdf size preview
F
INDING
A
TOOL
TO
DO
IT
FOR
YOU
137
6.4
U
NDERSTANDING
THE
J
AVA
D
OC
AND
THE
D
OCLET
API
Long ago Sun realized the importance of embedded documentation in Java, and to
address that, it created the JavaDoc standard. The JavaDoc engine is designed to have a
replaceable back end. It reads and interprets the Java and creates a hierarchy of objects
that are sent to the Doclet. This hierarchy contains not only the JavaDoc comments,
but all of the information about the public, protected, and private member variables,
methods, and classes.
The standard Doclet uses this information to create HTML documentation. You
can write your own back end for JavaDoc using the Doclet API. Instead of you passing
the hierarchy of objects to the HTML writing code, the objects are sent to your Doclet
code, where you can use them however you like. A number of code generators have
been built upon the Doclet API. Here are some of the more popular Doclets:
• XDoclet (http://xdoclet.sourceforge.net) is a code generation engine based on the
Doclet standard. It is often used to build infrastructure beans around existing
entity beans based on the JavaDoc markup found in the entity beans.
• CastorDoclet (http://castordoclet.sourceforge.net) is a database-mapping Doclet
for Castor JDO.
• JELDoclet (http://jeldoclet.sourceforge.net/) converts the JavaDoc markup and
the class structure information to XML.
• JUnitDoclet (www.junitdoclet.org/) is a unit-test creation tool based on the
Doclet API.
• DocBookDoclet (freshmeat.net/projects/dbdoclet) generates DocBook docu-
mentation from JavaDoc.
If your generator requires input from a group of Java classes plus additional optional
commenting information, you should consider using the Doclet structure. As an alter-
native, you can have the Doclet create an XML representation of the classes and com-
ments, which you can then feed to the generator. This way, the generator is dependent
neither on Java or the Doclet API.
You can find more information on the Doclet API, including technical documen-
tation and tutorials, on Sun’s Java site at http://java.sun.com. Additional information
can be found at http://doclet.com/.
6.5
F
INDING
A
TOOL
TO
DO
IT
FOR
YOU
If you don’t want to build your own documentation generator, you can download one
of several free existing tools. Each popular language has at least one. We’ve listed a sam-
pling of what’s available here. Some of these generators have replaceable front or back
ends, allowing them to read multiple languages and to output not only documentation
but anything you require.
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
best online pdf compressor; change font size pdf form
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 pdf text box; change font size on pdf text box
138
CHAPTER 6
G
ENERATING
DOCUMENTATION
• Doxygen (www.doxygen.org) is an industry standard for inline documentation
of C++.
• JavaDoc (http://java.sun.com/j2se/javadoc/) has been with Java since the begin-
ning. It is used not only to generate HTML documentation but is integrated into
IDE tools and provides API documentation on the fly within pop-ups.
• Synopsis (http://synopsis.sourceforge.net/) is an inline code documentation tool
with support for multiple languages through a plug-and-play parser mechanism.
• ScanDoc (www.sylvantech.com/~talin/projects/scandoc/scandoc.html) is a Java-
Doc syntax inline code documentation tool written in Perl and targeted at C++.
• PHPDoc (www.phpdoc.de/demo.html) is a JavaDoc comment style inline docu-
mentation tool for documenting PHP classes and pages.
• RDoc (http://rdoc.sourceforge.net/) and RDtool (www2.pos.to/~tosh/ruby/rdtool/
en/index.html) are embedded source code documentation tools for Ruby.
6.6
S
UMMARY
The case study generator shown in this chapter provides a glimpse into the value of
tools that parse your code and comments to generate critical outputs such as documen-
tation. With the tools provided in this book, you can build generators to parse C, C++,
Java, and SQL, and from there use ERb to build whatever output you choose.
By using inline documentation, you add value to your code base because you
include vital API documentation directly in the code. By building generators that
further leverage the structure of the code base and its associated documentation, you
extend your investment in creating the code.
In the next chapter, we show you how to build generators that perform unit tests
of your applications.
139
C
H
A
P
T E R
7
Generating unit tests
7.1 The big picture e 140
7.2 Preparing for common concerns s 141
7.3 A case study: augmented C code e 143
7.4 Technique: the ordered test 
generator 150
7.5 Technique: the test data 
generator 152
7.6 Technique: the test robot 
generator 154
7.7 Finding a tool to do it for you u 157
7.8 Design tips s 158
7.9 Summary y 158
There is nothing like the feeling of editing your code with confidence. And that kind of
confidence can only come from knowing you have tests that check every aspect of the
code for defects. Unit tests are invaluable for performing this role and ensuring overall
code quality. They run against an API, which tests both valid and invalid use cases. A
robust unit test will invoke the system with a variety of methods and data, and then
report back as to the success or failure of the system. 
The downside of unit tests is that it takes a lot of work to create and maintain them.
The upside is that you can apply generation to solve that problem. 
In this chapter, we present a number of generators that make it easy to create and
maintain unit tests that ensure code quality. Because each unit test application has dif-
ferent requirements, you will need to customize the generators in this chapter to use
them effectively in your environment.
140
CHAPTER 7
G
ENERATING
UNIT
TESTS
7.1
T
HE
BIG
PICTURE
The case study from chapter 1 used several generated unit tests. The first of these tested
the database access interface through the EJB layer. The database unit test system uses
test data from the database to build a test data loader. This data loader uses the EJB
layer to set the database and to determine whether the data was properly written.
Figure 7.1 shows the unit test from chapter 1.
The second set of unit tests we showed was a set of web robots that comes in the
front door of the application through the web interface. Figure 7.2 shows how the user
agents are generated and how they relate to the production pages.
The web robots use the same data as the database unit test but load that data in
through the front end of the application. This tests the JSP pages, the database access
layer, and the database schema. Using the web robots gives you an end-to-end test of
your entire technology stack.
Figure 7.1 1 The database access layer unit test from the case study in chapter 1
P
REPARING
FOR
COMMON
CONCERNS
141
This chapter presents a case study that tests APIs in a manner similar to the database
loader from the case study. In addition, we provide an architecture for the web robot
unit test that was used in the study. 
But before we start building our case study, it’s useful to think about some of the
common concerns that you might come up against when implementing unit tests with
code generation.
7.2
P
REPARING
FOR
COMMON
CONCERNS
Who can argue with code quality? Because unit tests create higher quality, more reliable
code, it’s tough to argue against them, but the specter of time and money can cast a
shadow on the value of code meant for testing instead of production. Here are some of
the more common concerns about unit testing.
Figure 7.2 2 Testing the original case study system by loading data through the user interface
Documents you may be interested
Documents you may be interested