Source Code in Database (SCID)

IInntteeggrraatteedd DDeevveellooppmmeenntt EEnnvviirroonnmmeenntt ffoorr JJaavvaa

Final Report

May 2003

By: Fahd Shariff Supervisor: Graham Knight

This report is submitted as part requirement of the BSc Degree in Mathematics and Computer Science at University College London. It is substantially the result of my own work except where explicitly indicated in the text. The report may be freely copied and distributed provided the source is explicitly acknowledged.

Abstract

i

AAbbssttrraacctt Software development requires the aid of many tools to accomplish a variety of tasks. Java development tools are a dime a dozen, but finding a good Integrated Development Environment (IDE) is rare. The purpose of this project is to design and develop a free, handy IDE to the Java community that can be used by both amateur and professional software engineers to write Java programs quickly and efficiently. The system uses an intuitive Graphical User Interface with dockable toolbars and workspace windows. It provides an editor with syntax highlighting and allows easy navigation through source code with the help of a single tree. It also has a code palette, which enables code templates, ranging from classes and applets to simple statements, to be inserted at the click of a button. The project also explores the area of Source Code In Database (SCID) and moves on to the design and implementation of a tool that parses source code and stores useful information (such as classes, interfaces, fields, methods and their locations) in a conventional SQL database which is accessible to user queries. The inability to locate a piece of information that you know is out there somewhere, but you cannot find it, can be extremely frustrating. SCID can ameliorate this problem. Finding errors has been made very easy, since the application has both a parser and compiler. The parser alerts users to syntax and lexical errors before compiling. This means that the compiler only returns semantic errors and the number of times the compiler has to be run is significantly reduced. All errors are linked to the source code, so users can jump right to the problem and correct it.

Acknowledgments

ii

AAcckknnoowwlleeddggeemmeennttss I wish to thank Mr Graham Knight, my project supervisor for his help, encouragement and advice throughout the year. Thanks must also go to my friends and colleagues for their useful comments and suggestions in the early stages of the project and also to all those who were kind enough to feign enthusiasm for my demonstrations. I would also like to thank my family and friends for their support, especially my brother for his professional proofreading. Finally, I would also like to thank the developers of the various tools and libraries that I have used and the Java community in general.

Contents

iii

CCoonntteennttss Abstract i Acknowledgements ii Contents iii

Chapter 1 - Introduction 1

1.1 What is an Integrated Development Environment? 1 1.2 Motivation 1 1.3 Features 2 1.4 The Database 2 1.5 Intended Audience 3 1.6 Structure of the Report 3 1.7 Summary 4

Chapter 2 - Background 5

2.1 General Area 5 2.2 Existing Tools 5 2.3 Tools and Libraries 6 2.4 Source Code in Database (SCID) 7 2.5 Implementation Language 7 2.6 Summary 8

Chapter 3 - Requirements Gathering 9

3.1 General Requirements of the System 9 3.2 The Requirements Table 9 3.3 Use Cases 12 3.3.1 Actor Specification 12 3.3.2 Use Case Specification 12 3.4 Use Case Diagram 14 3.5 Scenarios 15 3.6 Summary 16

Contents

iv

Chapter 4 - Analysis & Design 18

4.1 The Process 18 4.2 Identifying System Modules 18 4.3 Identifying Candidate Classes 20 4.3.1 The Editor 20 4.3.2 The Output Window 20 4.3.3 The Java Parser 20 4.3.4 The Database 21 4.3.5 Class Browser 21 4.3.6 Code Palette 22 4.3.7 Options 22 4.3.8 Printer 23 4.3.9 Pretty Printer 23 4.4 Class Diagrams 23 4.5 Activity Diagrams 27 4.6 Designing the GUI 29 4.7 Summary 31

Chapter 5 - Database Design 32

5.1 Kinds of Databases 32 5.2 Choosing a DBMS 32 5.3 Identifying What Goes in the Database 33 5.4 Data Flow Diagram 33 5.5 Entity Relation Diagram 34 5.6 Relations 35 5.7 Summary 35

Chapter 6 – Implementation 36

6.1 Choosing an Implementation Language 36 6.2 Package Hierarchy 36 6.3 The Parser 37 6.4 The Database 39 6.5 Executing System Commands 45 6.6 API Viewer 46 6.7 Code Palette 48 6.8 Class Browser 49 6.9 File Explorer 50

Contents

v

6.10 The Editor 50 6.11 User Options 52 6.12 Printing 53 6.13 Pretty Printing 54 6.14 Toolbars 54 6.15 Menus 55 6.16 Implementing Shared Actions 56 6.17 Window Management 57 6.18 Summary 57

Chapter 7 - Testing 58

7.1 Testing Strategy 58 7.2 Testing the Parser 58 7.3 Testing the Database 59 7.4 Unit Testing 60 7.5 Testing the GUI 61 7.6 Usability Testing 61 7.7 Testing Platform Independence 61 7.8 Summary 62

Chapter 8 - Conclusions 63

8.1 Evaluation 63 8.2 Performance 63 8.3 Further Work 64

8.3.1 Extending the Database 64 8.3.2 Extending the Code Palette 64 8.3.3 More Options 64 8.3.4 Code Completion 65 8.3.5 UML Visualisation 65 8.3.6 Refactoring 65 8.3.7 Wizards 65

8.4 Summary 66

Contents

vi

Chapter 9 - Endmatter 67

A System Manual 68 B User Manual 70 C Test Results 77 D Code Listing 81 E Project Plan 95 F Interim Report 100 G Bibliography 103 H Table of Figures 106 I Glossary 107

Chapter 1 Introduction

1

CChhaapptteerr 11

IInnttrroodduuccttiioonn

An apprentice carpenter may want only a hammer and saw, but a master craftsman employs many precision tools. Computer programming likewise requires sophisticated tools to cope with the complexity of real applications, and only practice with these tools will build skill in their use.

Robert L. Kruse, Data Structures and Program Design This project is about developing an Integrated Development Environment for Java. It not only has a great set of tools for writing programs, but also stores source code in a database. The project promises to deliver a handy, open-source and free IDE to the Java development community. It is entirely implemented in Java for excellent platform interoperability and performance on Windows®, Linux®, Solaris™ and any operating system that fully supports the Java 2 SDK 1.4.x.

1.1 What is an Integrated Development Environment? An Integrated Development Environment (IDE) is a collection of tools that allow you to do many common development tasks with a common interface. Most program development tasks involve:

• Editing source code • Compiling source code to create executable applications • Executing applications • Debugging applications.

Microsoft Visual C++ and JCreator are examples of popular IDEs.

1.2 Motivation Until recently, computer programs were written using simple text editors (e.g. Notepad and vi). They were compiled in external console windows and if there were any compilation errors, programmers would have to switch back to their editors, find the specified line and correct the error. After a successful compilation, programs would then be executed in the console window. The problem with this process is that amateur programmers face the daunting task of learning how to use their editors and learning obscure compile and execute commands. Another problem frequently encountered by programmers is the inability to find a particular programming construct such as a field or method. This gets worse as the number of files in a project increases. The programmer then has to inspect every file


2

for the missing construct. Storing the main constructs of a program into a database can solve this problem. Constructs can be found by querying the database. The primary aim of this project is to tie all these tools together in one nice package with a common interface. This will aid both amateur and professional software engineers and programmers in developing software.

1.3 Features The system uses an intuitive Graphical User Interface with dockable toolbars and workspace windows. As you might expect, it provides an editor with syntax highlighting. Syntax highlighting is the display of programming language tokens using different fonts and colors. This makes code easier to follow and errors such as misplaced quotes easier to find. Errors detected during compilation are linked to the source code, so users can jump right to the problem and correct it. It allows easy navigation through source code with the help of a single tree. It also allows code writing using templates and a documentation generator and viewer. The functionality of the system is extensible so other tools can be added at a later date. For example, a future final year project could involve extending the system to allow drag-and-drop GUI creation. The current breed of IDEs simply store source code in files. This system is also connected to a database as explained in the next section.

1.4 The Database The inability to locate a piece of information that you know is out there somewhere but you cannot find it can be extremely frustrating; particularly if you know you have seen it before. Databases can ameliorate this problem. In addition to storing source code in files, the system also parses java source files and stores important information in a database. Any errors during parsing are highlighted in the source code, so that users can fix them immediately. This significantly reduces the number of times users have to compile, since the program is already syntactically valid. After a successful parse, the following information is recorded in the tables of the database:

• Classes • Interfaces • Methods • Fields

This has several advantages:

• Since the locations of these constructs are also stored, you can easily find the declaration of any language construct.


3

• Programmers can concentrate on what they are editing instead of figuring out which file to edit and where the construct in question exists in that file.

• Programs can be displayed in a variety of ways.

1.5 Intended Audience This project is intended for students in Computer Science and for amateur and professional software engineers and programmers. It has much to offer for anyone interested in java programming. The powerful and easy to use tools that it provides are designed specifically to increase software development productivity.

1.6 Structure of the Report Chapter 2 Describes what research has been done in the field of IDEs, databases

and programming. It also reviews existing work in the IDE field. This provides motivation for the requirements gathering stage of the project.

Chapter 3 Describes the requirements of the system to be developed and

classifies them according to priorities. Also discusses how users will interact with the system, with the help of use cases and scenarios.

Chapter 4 Describes the analysis and design phase of the project. It starts by

analysing the requirements and splitting the system up into modules and classes. It also describes why particular decisions in the design were made. This chapter also illustrates the overall system structure.

Chapter 5 Describes the design of the database. In particular it discusses why this

kind of database was chosen and the structure of the tables in the database schema.

Chapter 6 Discusses the implementation of various components that were

designed in Chapter 4. Key parts are described with code details. Chapter 7 Describes how the implementation was tested using a variety of

methods such as unit testing and usability testing. Results can be found in the appendix.

Chapter 8 Analyses the system that has been presented and evaluates the work

that has been done in this project. Also describes how the work could be taken further.

Chapter 9 Contains other bits and pieces of information such as the appendices

and bibliography.

• System Manual: Includes technical details about the code and installation instructions.

• User Manual: Includes information for using the system designed.


4

• Test Results: Results of testing the code.

• Code Listing: Key code details. • Bibliography

• Glossary

Since each chapter builds on the preceding one, it is recommended that these chapters be read sequentially from start to finish.

1.7 Summary This chapter discussed some of the problems with existing IDEs and demonstrated the need of having a database to store source code. The structure of the report was also presented.

Chapter 2 Background

5

CChhaapptteerr 22

BBaacckkggrroouunndd This chapter presents an overview of the research done in the areas of programming, databases and Integrated Development Environments. The research was carried out by means of books, the Internet, newsgroups and conversations with both amateur and professional programmers and members of the java community in general. The aim of this research was to answer the following questions:

• What IDEs exist and what is their functionality? • What makes a good IDE? • What existing tools and libraries can be used to build a good IDE? • Source Code In Database (SCID)

2.1 General Area Over the years, systems have become increasingly complex. In order to handle large projects and reduce the time taken to write programs, many integrated development environments have been developed. However, there are still quite a few problems with existing IDEs:

• They are expensive. • Slow to run. • Complexity increased by trying to integrate multiple tools and functions. • Locked into a single vendor's proprietary strategy. • Developer's learning curve focused on terminology and feature location.

This project aims to solve these common problems by developing a handy, open-source and free IDE, which is extensible so other tools can be added at a later date. The user interface will be designed to be similar to existing applications, in terms of buttons, menus and shortcuts, in order to reduce the learning curve associated with a new application. It will be designed to run on multiple platforms and will be multi-threaded for quicker user response.

2.2 Existing Tools Several good IDEs have emerged recently. All of them provide the usual functionality of compiling, running and browsing projects. As part of the research for this project, some of the most prominent have been evaluated. The results are given below:

• Sun’s Forte for Java [1]: This IDE is implemented completely in Java and so runs on all platforms. It is open source and free. Has a nice auto-update feature and one of the best help facilities. However, the coding paradigm and overall


6

feel of Forte is not as high-level as other popular development tools. The major problem with Forte is the speed. Launching it can take up to a minute, so its safe to say that its pretty slow. Works well on a fast computer (500MHZ and 256MB RAM). A real resource hog.

• Microsoft Visual J++ [2]: Has some nice features if you are using it just for

editing; however, if you use its visual tools, COM tools, database (like RDO), or J/Direct, you will be stuck with a Windows only Java program. According to the java community, Microsoft feels threatened by Java's platform-independent features, and is designing tools such as Visual J++ and Internet Explorer in such a way as to sabotage its platform-independence.

• JBuilder [3]: This IDE provides a broad variety of components and is highly

customizable. It includes the Open Tools API that allows a development team to customize the IDE and add additional features not packed with it. According to research and personal use it was found that after extended use (around four or five hours), memory seems to increase out of control. At this point, you simply have to shut down JBuilder and restart; otherwise, typing becomes a tedious process, with constant "delays" every couple of lines.

This evaluation reiterates the need for a lightweight, inexpensive IDE that runs on a variety of platforms.

2.3 Tools and Libraries There are many tools and libraries available which might be useful in this project. If libraries are available to perform a particular task it is usually better to try to build on these libraries rather than re-implement them from scratch. One specific area in which use of an external library is important is that of parsing the Java source code itself. For this a parser generator is required. Parser Generator: A parser generator is a tool that reads a grammar specification and converts it to a Java program that can recognize matches to the grammar. The following parser generator tools were evaluated:

• ANTLR [4]: ANother Tool for Language Recognition (ANTLR) is a parser generator, which has grammars for several languages including Java. It is one of the more well-known and well-developed parser systems, especially since it has grammars for many different languages.

• SableCC [5]: This is another parser generator library for Java. It is quite

widely used in the Java community, and also has grammars for several different languages.

• JavaCC [6]: This is the most popular parser generator library for Java. In

addition to the parser generator itself, JavaCC provides other standard capabilities related to parser generation such as tree building (via a tool called JJTree included with JavaCC), actions, debugging, etc. JavaCC was used in


7

this project because it is easily available and comes with a javaCC grammar repository containing example grammars.

Advantages of a Parser: Whenever the parser encounters any “interesting” tokens such as class name, fields or methods, these can be stored in the database and at the same time a tree can be built representing the structure of what is being parsed. An additional advantage of the parser is that it can be used to detect errors in code. There are three types of errors that a compiler detects [7]: lexical, syntax and semantic errors. The first two types can be detected using a parser. This is easier from the point of view of the programmer, who only has to invoke the compiler to check for semantic errors. Another external resource that is important to this project is that of editing text. Clearly, the system must provide an effective text editor with basic word processor functions such as opening files, saving, cut, copy and paste, find and replace etc. To implement these features code samples were taken from the famous WordProcessor example in "Swing, 2nd Edition" by Robinson and Vorobiev [8].

2.4 Source Code In Database (SCID)

"I mean, source code in files; how quaint, how seventies!" Kent Beck, regarding Source Code In Database (SCID)

The concept of SCID was first developed by Roedy Green in the early 1970s [9]. Since then a lot of research has been done in this field and SCID-think is gradually catching on. The concept has not yet been implemented in full in any existing IDE. The basic idea is to pre-parse source code and put it in a database. This eventually leads to the elimination of java files, since all source code is stored exclusively in the database. This is an important step away from thinking of programs strictly as linear streams of ASCII characters. It would allow a GUI-based data entry system with all sorts of point and click features, extreme data validation, and ability to reuse that data, view it in many ways, and search it by any key. There are many possible kinds of data structures that could be used for this purpose. These include, but are not limited to, parse trees, xml files and traditional SQL databases. This is a very vast field. This project explores the idea of storing only important information extracted from source code, such as classes, fields and methods, in the form of rows and columns in an SQL database. Research was carried out in defining what tables would be required and normalizing them. It was decided to use MySQL [10]; the most popular open source database also available on departmental machines. Driver classes (package org.gjt.mm.mysql) had to be downloaded from the Internet [11].

2.5 Implementation Language


8

To implement the system a programming language had to be chosen. According to research, previous IDEs have been written in a variety of languages from LISP to C++. The choice was narrowed down to object-oriented languages since they allow modularity, modifiability and maintainability. The object-oriented language chosen was Java, mainly because it enjoys "write once run anywhere" flexibility and is highly secure, open and robust [12]. Java can tend to be quite slow. In order to match the speed of applications written in other languages, code must be optimised. A lot of research was done, in the different ways used to speed up Java [13]. The following ways were identified:

• Compile using optimizations turned on (e.g., javac -O) • Optimize algorithms, especially those involved in string manipulation (use a

string buffer instead) • Improve performance by multi-threading

2.6 Summary After reviewing the work that has been done already, one can conclude that it is within the scope of this project to create an IDE that not only provides basic functions but also stores source code in a database. There are several tools and libraries that might be employed to avoid re-implementing work which has already been done and allow the project to progress more quickly. Research has highlighted several points where decisions must be made about how a particular part of the framework should be implemented. The merits of the various options have been examined and decisions will be made in the design section later in the report.

Chapter 3 Requirements Gathering

9

CChhaapptteerr 33

RReeqquuiirreemmeennttss GGaatthheerriinngg To develop software projects on time and budget there is nothing more important than gathering and clearly defining the requirements. This chapter describes the requirements workflow of the system. To gather requirements, the functionality of existing systems and how they could be improved was studied, in order to determine the following:

• Functionality: the essential things that the system must do. • Interaction: how the system should work from the user's point of view. • Other Needs: time, space, performance, scalability, security, and disaster

recovery needs. After exploring and analysing the requirements, these were then articulated in the form of a Requirements Specification Document, which provides a common vocabulary, and understanding of the problem space and the desired system behaviour.

3.1 General Requirements of the System The main task is to build a fully functional Integrated Development Environment for Java. The system will allow java source code to be edited and will display it in a multi-coloured manner (Colours are representative of the different control constructs and keywords that can be found in the source code file.) It will parse, compile and execute java source files. The system will store source code in a MySQL database, which will allow searching. This will be implemented as a plug-in, so that users, who do not have MySQL installed on their computers, can still benefit from other features that the system provides. In addition, the system will speed up code writing by using templates and a point-and-click interface. It will also allow users to navigate through source code, by displaying it in the form of a single tree in which fields and methods are defined as nodes of the tree.

3.2 The Requirements Table The Requirements Table below sets out, in a bit more detail, the functional and non-functional requirements of the system. Each requirement is assigned a priority using the MoSCoW criteria [14]:


10

• M- must have (mandatory). These include the most import requirements such as editing code, the database for storing and searching code, parser and java features (compiling and running programs)

• S – should have. These include a file explorer and class navigator. • C – could have (optional) such as a help system • W – would have (these can wait), such as UML diagrams, an API Viewer etc

Priorities are used to distinguish user needs (features that are critical to the system's success) and user wants (features that would be nice to have but are not essential).

ID Requirements Priority

General

1 Platform Independent. M

2 Engaging user interface with switchable look-and-feel and theme support.

S

3 Support for application, applet and web application development M 4 Users should not have to leave the IDE at any stage. S 5 Built in file browser. S 6 Dockable toolbars and sidebars. S 7 Help system. C

Editor

8 Multi file editing S 9 Configurable syntax highlighting for Java M

10 Display the program using different fonts, font sizes, styles and alignments.

C

11 Search and replace M 12 Parentheses matching M 13 Auto indentation M 14 Line indicator M 15 Printing with Print Preview M

Output Window

16 Compile and execute java programs. M 17 The Javadoc command automates the generation of Javadoc. M 18 Run the applet viewer. M 19 Invoke custom commands of the user. C


11

Compilation and Error Detection

20 Both Parser and Compiler error detection M

21 Hyper linking of errors in the output window to positions in the source files.

M

22 Setting compiler options such as classpath etc. M

Database

23 Parse source code and insert important items into a database. M

24 Record locations of these important items so that they can be edited.

M

25 Find all declarations of methods, fields, classes or interfaces throughout a project

M

26 Search using special criteria such as access modifiers, types etc. M

27 Provide the user with the option of executing SQL queries directly instead of using the search dialog.

C

Class Browser

28 Display class information in a tree structure. S

29 Allow easy navigation for finding class, field and method declarations.

S

30 Classify Java source file member information such as method and fields by access levels (public, private, protected).

S

Coding Tools

31 Quick code insertion e.g. surrounding selected code with a try-catch clause.

M

32 Templates for easily writing classes, applets, desktop applications and web applications.

M

33 Comment and Uncomment blocks of selected code. M

34 Tight integration with JUnit, designed specifically to run and automate unit tests.

S

Java API Viewer

35 Browse java documentation for either specific project or the complete online API.

W

36 Search for the documentation of a specific class or interface using wildcards.

W


12

UML Code Visualization

37 Generate UML code diagrams for entire projects. W 38 Navigate in browser fashion through UML class diagrams. W

3.3 Use Cases Use case diagrams describe what a system does from the standpoint of the user. The emphasis is on what a system does rather than how. The diagrams produced are used during the analysis phase of the project to identify and partition system functionality. Items in use case models are linked to items in the requirements document, which enables requirements traceability. A use case diagram separates the system into actors and use cases.

3.3.1 Actor Specification Actors represent roles that are played by users of the system and must be external to the system. They could be humans or even other software systems. The actors of this system (i.e. the IDE) are programmers who could be either professionals or amateurs. They make use of the system for writing Java programs. In addition they can browse through class files, insert code templates, search the database and execute commands such as compiling and running.

3.3.2 Use Case Specification Use cases describe the behaviour of the system when an actor sends a particular stimulus. This system has a number of use cases. The ones that are vital to the system are listed below: Use Case 1: Open a File 1. User selects a file from the file chooser and clicks Open. 2. The system parses the file and updates the Database. 3. At the same time, it also creates a tree view of the class structure of the file and

displays it in the Class Browser. 4. The file is then opened in a new editor window. Error Case 1: File not found Error Case 2: File is not a valid java file. Error Case 3: File is already open. If after step 1, any of the above occur, the system informs User and returns. Use Case 2: Save a File


13

1. User presses Save or Ctrl-S. 2. If the file has not been saved before, the system prompts User to enter the

filename to save in. 3. The system then writes to the specified file. 4. The system re-parses the file. 5. The system updates the database and Class Browser. 6. File has been saved. Error case 1: Parse Error If after step 4, there is an error while parsing, the system highlights the error location, informs User and returns. Use Case 3: Compiling a File 1. User clicks on the Compile button. 2. The system runs the compile command on the specified file and displays any

errors. 3. The system adds hyperlinks to the errors to link them to the source code. Use Case 4: Add file(s) to the Database 1. User selects the Add File option from the Database menu. 2. User then selects a file or directory to add to the database. 3. The system parses the file or directory recursively and adds items (fields, methods

etc) to the database. Use Case 5: Search the Database 1. User selects Search Database from the menu. 2. User then enters what is being searched for and also enters any additional criteria

such as the type, parameters or modifiers. 3. The system builds an SQL query based on this input. 4. The system then returns a table with the results. Use Case 6: Insert Code 1. User writes a block of code into the editor. 2. User selects this code. 3. User clicks on the required code to be inserted e.g. while loop 4. The selected block of text is surrounded by the required text i.e. by a while loop. Use Case 7: Launch Java API Viewer 1. User clicks on the API Viewer button. 2. The system connects to the directory, which contains the API or Javadoc files. 3. The system parses the documentation files, which are in HTML format. 4. The system displays all the information in a new window. 5. User enters the class they are looking for in the search box. 6. The system displays the documentation for that class.


14

Error Case 1: If, after step 5, the class does not exist, the system informs the user and returns. Use Case 8: Modify Options 1. User selects Options from the Edit menu. 2. The system displays the options in a table. 3. User modifies options e.g. compiler command 4. User clicks Apply. 5. The system updates the options. 6. System writes the new options to the configuration file.

3.4 Use Case Diagram Below is an overall Use Case diagram for user's possible interactions with the system.

System

User

Open File

Change Look andFeel

Modify Options

Launch API Viewer

Insert Code

Database Operations

Execute Commands

Save File

Generate Javadoc

Run

Compile

Search Database

Add/Remove File(s)

«extends»

«extends»

«extends»

Figure 1 – Use Case Diagram


15

3.5 Scenarios A scenario is an instance of a use case and corresponds to a possible interaction between the system and its actors. Some scenarios of key use cases are listed below: Use Case 1: Open a File Scenario 1: John presses Ctrl-O and selects Program1.java from the file chooser. A new editor window pops up and displays the file. The file is added to the Class Browser tree, and John clicks on the items in tree to view the file’s structure. Scenario 2: John presses Ctrl-O and selects Program1.java from the file chooser. He gets a message that the file is already open. Scenario 3: Chris clicks on the Open button on the toolbar and enters Hello as the filename. He gets a message that it is not a valid java file. He tries again, but this time he types Hello.java. The file is displayed in a new window. Scenario 4: Sam clicks on the Open button on the toolbar and selects a directory. She gets a warning that the file he selected is a directory. She tries again. Use Case 2: Add file(s) to the Database Scenario 1: Peter has just installed this system. He wishes to continue work on an existing project and wants to upload all the classes in this project to the Database. He selects Add/Remove Files from the Database menu. A window is displayed which lists all the files currently in the Database. He clicks on the Add button and selects his project directory and clicks Ok. He watches, as all the files in his project are recursively added to the Database. Consequently the list grows. He receives a message that all the files have been successfully added to the Database. Use Case 3: Search the Database Scenario 1: Adam is working on a school-programming project. He has written a number of classes. He creates a new Object of class Person but cannot remember whether the method he wishes to call on that object is called getName or getFullName. He opens the Database Search Dialog and types “get%Name” in the method box and “Person” in the class box. He presses submit and the results show that the method he was looking for is called getFullName and the method returns a String. Scenario 2: James Gosling is working on a massive project. Fortunately, all his files are stored in the database. He is writing a subclass and wants a list of all the methods of the super class so that he can override them. He selects Search Database from the Database menu and selects method search. He enters the name of the super class and finally hits Search. A results table appears which shows him all the methods in the super class; their names, return types and parameters. He copies them into the subclass and overrides them.


16

Use Case 4: Compile a File Scenario 1: Jim presses the Compile button on the toolbar. An output window pops up with the compile command. Unfortunately, Jim finds he has forgotten a semicolon at the end of a statement on line 70. He clicks on the hyperlinked error in the output window and line 70 is highlighted. He adds the semicolon and recompiles. Scenario 2: Bob is writing his first program. He presses the Compile button and holds his breath. The output window does not display any errors. He sighs with relief. Use Case 5: Insert Code Scenario 1: Joe wishes to write a web application that makes use of servlets. He clicks New to open a blank editor. He then types the name of the servlet class, which he has chosen to be MyServlet. He then highlights this name and chooses Servlet from the Code Palette. A class containing the standard Servlet template, with the doGet and doPost methods, is displayed in the editor. He just fills it up. Scenario 2: Fatima thinks that a method in her program is redundant. To test her theory, she highlights the method and clicks on Comment in the Code Palette. Her method is commented out. She then saves the file and compiles. No errors are detected. She concludes that the method serves no purpose and so deletes it from the program. Use Case 6: Navigate Through Classes Scenario 1: Harry is working on a program, which has a few 100 lines of code so far. There are lots of fields and methods. He wants to view the code of a particular method called drawDiagram. He is pleased that he does not need to scroll up a 100 lines to find the method declaration. He simply scans the class tree and clicks on the node that says drawDiagram. Automatically, the method declaration is highlighted in the editor. Use Case 7: Modify Options Scenario 1: Ahmed wishes to use jikes instead of javac for compiling his programs. He selects Options from the Edit menu and changes the existing compile command. He then clicks Apply. After editing his program, he presses Compile on the toolbar and the jikes compiler is used. The next day he starts up the system again and is pleased to see that the change he made has been saved.

3.6 Summary Requirements are bound to change during the course of the project. Unmanaged changes, however, can be harmful to the project. They can cause delays, increase cost, decrease quality, or outright kill the project. Only with rigorous requirements definition and management is it possible to finish your project on time and on budget.


17

This chapter outlined the requirements workflow of the system. Each requirement had an associated priority in order to distinguish the important features from the less important ones. Key use cases and example scenarios for the system were outlined. These will be very useful in the analysis and design phase for partitioning the functionality of the system.

Chapter 4 Analysis & Design

18

CChhaapptteerr 44

AAnnaallyyssiiss aanndd DDeessiiggnn This chapter describes the analysis and design of the system. It is about refining and structuring the requirements to get a better understanding of them. It also seeks to explain the reasoning behind the decisions made and assess their effectiveness in solving the problems involved. An object-oriented (OO) approach has been used since it offers a more natural way of conceptualizing and developing software systems. Unified Modelling Language (UML) has been used as the means of expressing OO concepts.

4.1 The Process The system was designed in a spiral-like fashion, such that it was specified, designed, implemented and tested initially, then the process was repeated in a second phase to review the overall process and cater for any refinements required. It was not found to be necessary to continue the process beyond a second phase, as most of the improvements required were discovered during the implementation of the first phase. Each stage of the design process began before the previous stage was entirely complete, and as such resulted in alterations being made to the previous stage, such that some design decisions resulted in a slight change to the specification, and so on.

4.2 Identifying System Modules & Responsibilities The requirements set out in the previous chapter were analysed and the system was split the system into several parts or modules, which are as independent of each other as possible. Modularity is a way of coping with complexity. For each module, its responsibilities (what it does) and its collaborations (relationships with other modules) were identified and are as follows:

• Editor: Plays the role of a word processor. It is responsible for displaying files on the screen for handling edit commands such as cut, copy, paste, undo, redo, find and replace etc. It highlights source code according to syntax, matches parentheses and displays line numbers.

• Output Window: Is responsible for displaying the results of commands

executed by the user. Commands include compiling, running, generating Javadoc, launching the applet viewer or any other custom command. It links compilation errors to the correct position in the editor. Collaborator: Editor


19

• Java Parser: Parses java source files and highlights any errors that occur during parsing. It sends tokens (information about the file being parsed) to the Database and Class Browser, which are consequently updated. Collaborators: Database, Class Browser

• Database: Maintains a record of class information such as fields and methods.

This information is sent by the parser. Also returns results of user searches. Collaborator: Java Parser

• Class Browser: Displays class information in the form of a tree. How the tree

is built depends on the information is sent by the parser. The nodes of tree are coloured according to the access level of the item at that node. Collaborator: Java Parser

• Code Palette: Is responsible for code insertion.

Collaborator: Editor

• Options: Stores user preferences such as name, compile commands etc. Collaborators: Editor, Output Window

• Printer: Is responsible for printing files and for print previewing.

Collaborator: Editor

• Pretty Printer: Parses java files and converts them into HTML. These files can then be viewed as web pages. Collaborator: Editor

With these responsibilities and collaborations in mind, a basic system model can be drawn:

Editor

Parser

Database

Code Palette

Class Browser

Output Window

Options

Printer

Pretty Printer

Figure 2 – Basic System Model


20

4.3 Identifying Candidate Classes Each module described above was analysed and split further to give a set of possible classes and interfaces.

4.3.1 The Editor The following classes were identified for the editor module:

• LineNumber: A component used to display line numbers on the left hand side of the editor window.

• SyntaxDocument: The document on which text is written. It is responsible for inspecting words and highlighting them if they are keywords, strings or comments. Also responsible for indentation and parenthesis matching.

• CustomTextPane: A special text pane, which contains the Syntax Document and Line Number component. It is responsible for editing operations such as cut, copy, paste, undo, redo etc.

• JavaEditor: Provides a window for containing all of the above. It listens for window events. For example, it checks if a file has been saved when the window is closed. Is also responsible for file operations such as opening, closing, saving etc.

4.3.2 The Output Window The following classes were identified for the output window module:

• OutputFrame: Provides a window for displaying results after a command has been executed. In the case of compiling, it displays compilation errors and links them to their position in the source code.

4.3.3 The Java Parser JavaCC was used to generate a parser for the Java language. It provides the most popular parser generator library [15] for Java. In addition to the parser generator itself, JavaCC provides other standard capabilities related to parser generation such as tree building (via a tool called JJTree included with JavaCC), actions, debugging, etc. It was decided to use JavaCC because it is easily available and comes with a JavaCC grammar repository containing example grammars. Java1.4.jj is a grammar specifically used to generate java parsers using JavaCC. This grammar was modified, so that tokens (such as class names, interfaces, field names and types, method names, types and parameters) were sent to the Database and added to the Class Browser tree structure. JavaCC was then used to generate a parser for this extended grammar. The tool produced the following classes:

• JavaParser: The tool that does the actual parsing. It also informs the user of any errors during parsing and updates the Database and Class Browser.


21

• ASCII_UCodeESC_CharStream • ParseException • JavaParser • ParserManager • JavaParserConstants • Token • JavaParserTokenManager • TokenMgrError

4.3.4 The Database This part of the system uses JDBC to pass SQL statements to the Database Management System (DBMS), which in this case is MySQL. To connect to the database, a user needs to have a valid username, password, database driver and URL. The following classes were identified in the Database module:

• DBManager: Is responsible for connecting to the DBMS and executing SQL commands. All other modules must go through the DBManager to examine or update the database.

• DBInserter: Inserts information into the Database. It receives this information from the parser.

• DBExtracter: Extracts information from the Database and returns resultsets. • DBConnection: The database connection. Maintains information such as the

database driver name, URL etc. • DBStatement: Provides methods for executing general SQL commands such

as select, update and delete. • AddRemoveDBDialog: A dialog for adding and removing files from the

Database. • DBMenu: A menu allowing user interaction with the Database such as adding

and removing files and searching.

4.3.5 Class Browser This is useful for navigating through classes. The following classes were identified:

• TreeBuilder: The parser sends information about any class and the TreeBuilder is responsible for building a tree depicting the structure of the class. Items in the tree are coloured according to the access level. For example, private fields are coloured red whereas public ones are green.

• ClassBrowser: Provides a panel for displaying the tree built by the TreeBuilder. It is also responsible for handling tree events, so for instance, if a method node is clicked, the corresponding method is highlighted in the editor.

Generated by JavaCC

22

4.3.6 Code Palette This module is responsible for code insertion. There were a few options for designing this feature. Code could have been inserted on the fly i.e. while the user types. Alternatively, a toolbar could have been designed containing buttons for different code templates. The first option was discarded because it meant having to analyse every word that the user entered which would slow the system down. The second one, if carried out, would have resulted in an unmanageable toolbar because of the large number of buttons. In the end it was decided to display code templates in the form of a tree. This way different code items can be classified appropriately. For example, the tree would have a branch containing loop constructs such as while, for and do-while and another branch containing statements such as if, if-else and switch etc. Users can therefore expand only those branches that they are interested in. The code constructs and templates that were to be inserted had to be stored somewhere. It was decided to store them in XML format. An XML file can then be parsed using an XML DOM parser (part of the java swing library) [16] and the tree built during parsing. This is a flexible approach since more templates and constructs can be added at a later date. The user can also edit the existing file to change the layout (such as brace placing) of the code. An extract of the file is shown below: <codetype name="Comments"> <code name="//">//|</code> <code name="/* */">/*|*/</code> </codetype> <codetype name="Loops"> <code name="do" >do\n{\n|\n}\nwhile();</code> <code name="while" >while()\n{\n|\n}</code> <code name="for" >for( ; ; )\n{\n|\n}</code> </codetype>

(\n refers to the new line character)

Only one class called CodePalette seemed necessary for this feature. This class creates a new window, parses the XML file, builds the code tree and listens for user selections. It then inserts the selected template into the editor and highlighted by the syntax highlighter.

4.3.7 Options It was decided, for the sake of simplicity, to store user preferences in a simple text file. When the system is started up, this file is read and all of the system variables are initialised using the file data. If a user decides to change their options, this module updates the file. An extract of the options file is below: NAME:Fahd Shariff COMPILECMD:javac -classpath .:<dir> <filepath>

The following classes were identified to handle the options module:


23

• OptionsDialog: A dialog allowing users to change their preferences. • Options: Stores the user’s preferences.

4.3.8 Printer This module is responsible printing. It also allows print previewing. The following classes were identified to carry out the responsibilities of this module.

• Printer: Handles user’s requests for printing or print previewing. • PrintPreview: A component capable of displaying the results of printing

before actual printing occurs. • PrintView: A view for the printed pages.

4.3.9 Pretty Printer This module allows users to be able to save their code as a web file (in HTML format) in which code has been coloured according to its syntax. This is similar to the editor’s syntax highlighting feature. This module has been taken from the author’s previous year group project, in which it was implemented as a web application using JSP and Java Servlets. It parses java code and marks it up in HTML. It has the following classes:

• HTMLCompiler: Compiles Java Source code into HTML code. • Options: Determine how the code is displayed. • Token: Represents a token with a type and value. • HTMLEmitter: Emits HTML Code. • SourceBufferReader: Reads a String Buffer containing the source code. • TokenType: The type of the token. • Lexer: Converts syntactically correct Java code into tokens. • SymbolTable: Used by the Lexer for looking up symbols.

4.4 Class Diagrams Once all the modules and classes and their responsibilities have been identified, UML Class Diagrams for the system can be drawn. They represent the static structure of the system to be built and provide a way of recording conceptual capabilities and relationships independent of implementation. It is from these diagrams that the code will eventually be written. It is therefore possible to "virtually code the application" without having to be concerned with the specific details of the language. Some of the diagrams are shown below:


24

Figure 3 – Package Dependencies Fig 3 shows the associations between different packages in the system. It also lists all the classes that each package contains. It can be seen that the database communicates with the parser and is also connected with the options package in order to read the user’s database configuration. All packages are connected to the GUI in order to provide feedback to the user.


25

Figure 4 – Database Class Diagram

The class diagram for the database package is shown above. The DBManager class manages all operations of the database and liaises with the parser in order to receive information. The AddRemoveDialog class needs to know what files are in the database and is therefore connected to the extracter class.


26

Figure 5 – Parser Class Diagram

The class diagram for the parser package is shown above. Some classes are generated from the grammar using JavaCC so it is not very important to include their attributes and methods. The ParserManager class manages all parsing operations that are mainly carried out by the JavaParser. The JavaParser communicates with the external classes, DBInserter and TreeBuilder in order to keep the database and class browser up-to-date. Other class diagrams such as those of the Graphical User Interface, are not very important from the point of view of the reader since they just show how components are associated with each other.


27

4.5 Activity Diagrams Activity diagrams show dependencies between activities and therefore describe how activities are coordinated. There are many activities in the system. We are interested in what activities must be carried out in order to update the database. The two main activities are opening a file and saving a file.

Figure 6 - Open File Activity Diagram The figure above shows the sequence of activities taking place when a user wishes to open a file. If the file is a valid java file, then it is parsed and if there are no errors, the database and class browser are updated concurrently.


28

Figure 7 - Save File Activity Diagram This is another activity that updates the database. When the user saves a file, the system first checks to see whether there have been any changes to the file since the last time it was saved. If there are no changes then there is no need to reparse the file and update the database since the results of these operations would not make any difference. However is there have been changes, these are saved by writing the code to the file. The database and browser are updated to reflect these changes. (More about this in the implementation section).


29

Figure 8 - Search Database Activity Diagram

The diagram above shows the sequence of activities that take place when the user wants to search for an item in the database. The user’s search information is converted into an SQL query and executed. If there are no results, the user is informed about this via a dialog. If results are found, they are displayed to the user.

4.6 Designing the GUI A growing problem with today’s interfaces is that the display that is provided to the user is overly complex. As applications become more powerful and acquire more and more options, programmers have attempted to make the various options more convenient to use by placing more and more icons and buttons on the screen. For example, the default layout of Microsoft Word includes over fifty icon buttons and over one hundred and fifty menu items [17]. Users are often at a loss to find the one of interest for any particular task, especially when they are somewhat unfamiliar with the system. A good well-designed interface plays a major role in the success of any application. The application's interface should operate smoothly and as predicted, anticipating what the user will do next.


30

The interface of this system is designed to follow common sense. This means that the interface will interact with the user in a natural way that will meet the user’s expectations. It is also designed to be consistent with other applications by using the standard menu and windowing tools, button names and locations, dialog boxes, and so forth.

Figure 9 – Initial GUI Design As seen in the figure, the GUI has been made as intuitive as possible i.e. symbols and styles the user knows [18]. The interface will be designed to allow multiple look and feels. In this way, users can choose the look and feel that they feel most comfortable with. In order to avoid a cluttered interface, it was decided to use Tabbed Panes to contain the file explorer, class browser and code palette. These three features are represented as trees and so require sufficient height to expand. They were therefore placed on the extreme left of the main window. It is important that the system responds quickly when a user clicks a mouse button or types on the keyboard. If there is only one thread, when the system is busy (e.g. compiling etc), it ignores user actions, giving the user the impression that the system has crashed. In order to avoid this problem, it was decided to use multi-threading i.e. have one or more threads managing the user interface while others perform different background tasks.


31

It seemed a good idea to have two separate toolbars: one for formatting and the other for standard operations. In this way buttons can be categorised for easy identification and selection. Users have the option of removing the toolbar that they do not use frequently. Familiar icons were used on all buttons. Windows covered up by others can lead to “out of sight, out of mind” [19]. To allow multi-file editing and efficient window management a virtual desktop was designed. This is essentially a large panel holding multiple editors (as internal frames), which allows easy window management.

4.7 Summary This chapter described the Analysis and Design workflow of the system. It analysed the requirements gathered earlier and broke the system down into modules and then into classes according to their responsibilities and collaborations. In particular, the generation of a parser using JavaCC, the initial design of the database using JDBC and SQL and the design of the Code Palette using XML were discussed. A class diagram was presented that showed the association between classes. The next chapter focuses on the design of the database in totality.

Chapter 5 Database Design

32

CChhaapptteerr 55

DDaattaabbaassee DDeessiiggnn The design of the database is one of the key ingredients to a successful implementation. This chapter describes how the database was designed from the point of choosing a suitable database to the actual logical design.

5.1 Kinds of Databases A database is a collection of organized data (information). There are three main kinds of databases [20]:

• Flat: Store data in one big table. An example would be a phone book. • Relational: Instead of a single table, data is stored in many tables that relate to

each other. • Object-oriented: Support objects and classes. They allow structured sub

objects; each object has its own identity, or object-id (as opposed to a purely value-oriented approach) and provide support for methods and inheritance.

It was decided to use a relation database for the purpose of this project. Relational databases are the dominant paradigm for new applications, and have been used for most applications developed within the past decade. (Object-oriented databases are fading in the marketplace, so are only used for compelling situations in which they clearly surpass relational databases. For example, some engineering and multimedia applications can benefit from an object-oriented database [21].) The information we wish to store would fit well in a relational database too.

5.2 Choosing a DBMS A Database Management System (DBMS) is the program used to define, store and retrieve data in a database. The DBMS chosen to control a database is dependent on several factors, which includes the data model being used and how the data is to be entered and retrieved. A relational database is required for this project, which would make use of SQL to execute queries. There are a number of DBMSs suitable for managing relational databases. There are proprietary DBMSs, which are commercial products e.g. Microsoft’s SQL Server and Oracle’s Oracle 8i. There are also Open Source DBMSs, which are free of charge, normally under the GNU General Public License e.g. Interbase and MySQL. There was no other alternative but MySQL since it is readily available and installed on departmental machines. However, MySQL does not support stored procedures or nested statements.


33

5.3 Identifying What Goes in the Database The main aim at this stage is to identify what needs to be stored in the database. In other words we need to provide a clear view of why the database is used by the system. The purpose of the database is to store information about java source code. Since Java is a vast language and programs are becoming increasingly complex, it must be decided what information the tables in the database will hold. The initial database can then be extended at a later date to incorporate other information. It seemed appropriate to store the following pieces of information in the database:

• Classes (names, super classes, implementing interfaces and modifiers) • Interfaces (names, modifiers) • Fields (names, types and modifiers) • Methods (names, return types, parameters, exceptions and modifiers)

5.4 Data Flow Diagram A data flow diagram shows how information is passed between the users and subsystems of the system. The data flow diagram for this system is shown below:

User Save File

Add File toDatabase

Open File

Parser Parse File

Database

SearchDatabase

Get Location ofItem

ClassBrowser

Highlight inEditor

Store in

Search in

Return results

Figure 10 - Data Flow Diagram

Types


34

The diagram shows that: • Data is stored into the database when a file is parsed by the Parser. This

happens whenever a user opens a new file, saves a file or explicitly adds a file to the database.

• The database provides results of search queries executed by the user. • The Class Browser also uses the database to lookup locations of items that the

user clicks on. The database returns the specified location and this is highlighted by the ClassBrowser in the editor.

5.5 Entity Relation Diagram An Entity Relation Diagram (ER Diagram) shows the data entities of the system and the relations between these entities. It is shown below:

Figure 11 - Entity Relation Diagram

The diagram above illustrates the tables used to store information in the database. Each table consists of columns. PK is the primary key of the table.


35

5.6 Relations The relations used in the database can be read off from the ER-diagram above. All relations have to be normalized. Normalization is used to eliminate repeating groups by placing the repeating data in a separate relation. For example, a field can have zero, one or more modifiers. Instead of duplicating field information (such as name, type etc) in every row, a new relation is created called FieldModifiers, which contains the field identifier (FieldID) and the approporiate modifier (ModifierID). This minimizes duplication of data i.e. reduces storage space required and speeds up queries. The relations for the database in third normal form (3NF) are:

• Modifier (ModifierID, ModifierName): contains modifiers e.g. public, static… • Type (TypeID, TypeName): contains primitive types, classes & interfaces • Filepath (TypeID, Filepath): contains a list of files that are in the database • TypeModifiers (*TypeID, ModifierID) • Class (ClassID, ExtendsClassID, Location) • Interface (InterfaceID, Location) • ClassInterfaces (ClassID, InterfaceID) • Field (*FieldID, FieldName, TypeID, ClassID, Location) • FieldModifiers (*FieldID, ModifierID) • Function (FunctionID, ClassOrInterfaceID): this is a method or constructor • Method (MethodID, MethodName, ReturnTypeID, Location) • Constructor (ConstructorID, Location) • FunctionModifiers (*FunctionID, ModifierID) • FunctionExceptions (FunctionID, ExceptionName) • FunctionParameters (FunctionID, ParamName, ParamTypeID)

(The primary and foreign keys have been underlined. Where there are no foreign keys, the primary key is the one with the star (*) prefix.)

Some relations also have a column called “Location”. This is used by the ClassBrowser to navigate quickly to where the item is located in the file. For example, if the user clicks on a particular method in the browser, the browser looks up its location in the Database and then jumps to that location in the editor window.

5.7 Summary This chapter described the design of the database. A suitable data structure i.e. a relational database was chosen followed by a suitable DBMS (MySQL). The items that needed to be stored in the database were identified. A data flow diagram was designed to inspect how different parts of the system would interact with the database. Finally, an ER diagram was created to show the entities and relations between them.

Chapter 6 Implementation

36

CChhaapptteerr 66

IImmpplleemmeennttaattiioonn This chapter describes the implementation of the design models developed in the Design phase. The goal is to produce source code and ultimately the executable system.

6.1 Choosing an Implementation Language It was decided to implement the system using the Java programming language for excellent platform interoperability and performance on Windows®, Linux®, Solaris™ and any operating system that fully supports the Java 2 SDK 1.4.x. Another advantage of Java is that it contains JDBC technology, which allows it to connect to any kind of DBMS using a driver. There is also the java.sql package, which makes writing database applications easy. Apart from the above reasons, Java is free, flexible, robust and very popular in the programming community.

6.2 Package Hierarchy Java uses a package mechanism that allows the classes making up a software system to be arranged in directories called packages. This mechanism can be used to give the IDE system a logical structure, by separating classes according to their functionality. This can be achieved using a hierarchy such as the following, where the system is placed in a top-level package app:

Figure 12 - System Package Hierarchy

37

The packages are: • app: top level (root) package • app.gui : contains user interface classes • app.gui.prettyprinter: the java to html converter • app.gui.print: for printing files in color and for print previewing • app.gui.themes: contains different themes and look and feels • app.parser: contains the classes required for parsing • app.database: the database classes • app.database.dbsearcher: the classes needed for searching the database • app.options: user preferences classes

The following sections describe how the design of each part of the system was transformed into an implementation in Java. Only the most important and interesting aspects will be discussed.

6.3 The Parser The parser is responsible for parsing java files and storing important information in the database. As mentioned previously, JavaCC was used to generate the parser. It works by converting a grammar into source code. A complete Java grammar was obtained from an online grammar repository [15]. This was edited so that whenever any important tokens were encountered, they were sent to the database. At the same time, they were also sent to the class browser to be added to the tree representation of the class. The user would be informed of any errors during parsing. Since the parser also informs the user of syntax and lexical errors, the user only has to run the compiler to check for semantic errors. The three main aspects of parsing that we are interested in are: parsing class declarations, field declarations and method declarations. Parsing Class Declarations: The class declaration is usually the first line of the program and contains information such as the class name, modifiers, super class and implementing interfaces. An example is: public abstract class Student extends Person implements MouseListener

In this example: public, abstract – modifiers Student – class name Person – super class MouseListener – interface The Java grammar contains the following method for parsing class declarations: void UnmodifiedClassDeclaration() : { “class” <IDENTIFIER> [ “extends” Name() ][ “implements” NameList()] ClassBody() }

38

This is edited so that tokens are passed to the database. The code added is shown in bold: void UnmodifiedClassDeclaration() : { Token type ; //the class token Token extendToken=null; //superclass ArrayList interfaces = new ArrayList() ; //a list for interfaces } { “class” type=<IDENTIFIER> [ “extends” extendToken=Name() ] [“implements” interfaces =NameList() ] { try{ String className = type.toString() ; String extendsName ; if(extendToken == null) extendsName = “Object” ; else extendsName = extendToken.toString() ; dbInserter.clearOldData(className) ; dbInserter.addClass(className, extendsName, filepath, getLocation(type)) ; dbInserter.addClassInterfaces(interfaces,className) ; }catch(Exception e){System.out.println(e) ;} } ClassBody() }

In the code above, the values of tokens are stored in variables and then sent to the database using the appropriate methods of the dbInserter object. Parsing Field Declarations: An example field declaration is: private int var = 0 ; In this example: private – modifier int – field type var – field name

The Java grammar contains the following construct for parsing fields: void FieldDeclaration() : {} { (“public” | “protected” | “private” | “static” | “final” | “transient” | “volatile” )* Type() VariableDeclarator() ( “,” VariableDeclarator() )* “;” }

The grammar is edited so that information such as modifiers, name and type can be extracted and put in the database. This is similar to class declarations and the full code can be found in the code listing.


39

Parsing Method Declarations: An example method declaration is: public static Person getPerson (String name) throws SQLException

In this example: public, static – modifiers Person – return type getPerson – method name SQLException – exception name name – method parameter1name String – method parameter1 type

The Java grammar contains the following construct for parsing methods: void MethodDeclaration() : {} { (“public” | “protected” | “private” | “static” | “abstract” | “final” | “native” | “synchronized” )* ResultType() MethodDeclarator() [ “throws” NameList() ] ( Block() | “;” ) }

This construct is edited so that ResultType(), MethodDeclarator() and NameList() are stored in variables and then added to the database using the addMethod method. The code listing shows this in detail. Once the grammar has been edited in this way, JavaCC is used to generate the source code for the parser. Running the parser: The ParserManager class is responsible for sending files to the parser. This process is implemented in the following way: try{

FileInputStream in = new FileInputStream(filepath) ;

if(parser == null ) parser = new JavaParser(in) else parser.ReInit(in) ;

parser.setFilePath(filepath) ;//adds the file to the parser parser.settings(addToDB,buildTree) ;//tells the parser that the

//database,tree must be updated parser.CompilationUnit();//does the parsing

}catch(ParseException e){//highlight error and warn user} The user is informed of any errors during parsing.

6.4 The Database The database receives information from the parser and stores it in tables using SQL. This section describes:

• Establishing a connection • Inserting information


40

• Adding/removing files • Searching

Establishing a connection: The first thing that needs to be done (before SQL statements can be executed) is to establish a connection with the DBMS, in this case, MySQL. This involves two steps:

• Loading the driver • Making the connection

The DBConnection class is responsible for this. It reads the database settings, which include driver name, database URL, username and password from the configuration file and establishes a connection in the following way: Class.forName(driverName); Connection con = DriverManager.getConnection(url, username, passwd);

The default driver name is: org.gjt.mm.mysql.Driver A possible database URL is: jdbc:mysql://localhost:17149/mydatabase Without establishing a connection, the database cannot be accessed. Once connected, SQL statements are used to store information into the database. Creating Tables: The relations designed previously in the ER diagram were turned into tables using the SQL CREATE TABLE statement. In the Modifiers table, java modifiers had to be inserted and in the Types table, java primitive types were inserted. This was done using the INSERT INTO statement. The type of data that the columns can contain was declared, such as INT or VARCHAR etc and primary keys were defined. The statements used to create the tables are in an SQL script file. This file is executed when the system is first set up. The following statements set up all the required tables in the database, in accordance with the design plan. CREATE TABLE Modifier ( ModifierID INT NOT NULL AUTO_INCREMENT PRIMARY KEY, ModifierName VARCHAR(255) ); INSERT INTO Modifier (ModifierName) VALUES (“abstract”), (“final”), (“native”), (“private”), (“protected”), (“public”), (“static”), (“strictfp”), (“synchronized”), (“transient”), (“volatile”) ; CREATE TABLE Filepath( TypeID INT NOT NULL PRIMARY KEY,


41

Filepath VARCHAR(255) ); CREATE TABLE Type ( TypeID INT NOT NULL AUTO_INCREMENT PRIMARY KEY, TypeName VARCHAR(255) ); INSERT INTO Type (TypeName) VALUES (“boolean”), (“ char”), (“ byte”), (“ short”), (“ int”), (“ long”), (“ double”), (“ float”) ; CREATE TABLE TypeModifiers ( TypeID INT NOT NULL REFERENCES Type(TypeID), ModifierID INT NOT NULL REFERENCES Modifier(ModifierID), Location VARCHAR(255) NOT NULL ); CREATE TABLE Class ( ClassID INT NOT NULL PRIMARY KEY REFERENCES Type(TypeID), ExtendsClassID INT REFERENCES Class(ClassID), Location VARCHAR(255) NOT NULL ); CREATE TABLE Interface ( InterfaceID INT NOT NULL PRIMARY KEY REFERENCES Type(TypeID), Location VARCHAR(255) NOT NULL ); CREATE TABLE ClassInterfaces ( ClassID INT NOT NULL REFERENCES Class(ClassID), InterfaceID INT NOT NULL REFERENCES Interface(InterfaceID) ); CREATE TABLE Field ( FieldID INT NOT NULL AUTO_INCREMENT PRIMARY KEY, FieldName VARCHAR(255), TypeID INT NOT NULL REFERENCES Type(TypeID), ClassID INT NOT NULL REFERENCES Class(ClassID), Location VARCHAR(255) NOT NULL ); CREATE TABLE FieldModifiers ( FieldID INT NOT NULL REFERENCES Field (FieldID), ModifierID INT NOT NULL REFERENCES Modifier(ModifierID), Location VARCHAR(255) NOT NULL ); CREATE TABLE Function ( FunctionID INT NOT NULL AUTO_INCREMENT PRIMARY KEY, ClassOrInterfaceID INT NOT NULL REFERENCES Type(TypeID) ); CREATE TABLE Method ( MethodID INT NOT NULL PRIMARY KEY REFERENCES


42

Function(FunctionID), MethodName VARCHAR(255) NOT NULL, ReturnTypeID INT REFERENCES Type(TypeID), Location VARCHAR(255) NOT NULL ); CREATE TABLE Constructor ( ConstructorID INT NOT NULL PRIMARY KEY REFERENCES Function(FunctionID), Location VARCHAR(255) NOT NULL ); CREATE TABLE FunctionModifiers ( FunctionID INT NOT NULL REFERENCES Function(FunctionID), ModifierID INT NOT NULL REFERENCES Modifier(ModifierID), Location VARCHAR(255) NOT NULL ); CREATE TABLE FunctionParameters ( FunctionID INT NOT NULL REFERENCES Function(FunctionID), ParamName VARCHAR(255) NOT NULL, ParamTypeID INT NOT NULL REFERENCES Type(TypeID), Location VARCHAR(255) NOT NULL ); CREATE TABLE FunctionExceptions ( FunctionID INT NOT NULL REFERENCES Function(FunctionID), ExceptionName VARCHAR(255), Location VARCHAR(255) NOT NULL );

Inserting Data: The class that is responsible for inserting information is called DBInserter. It contains the following methods to add data into the database: addInterface(String interfaceName, String filepath, String location) addClass(String className, String extendsName, String filepath, String location) addFilePath(String filePath, int typeID) addClassInterfaces(ArrayList interfaces, String className) addTypeModifiers(ArrayList modifiers, String typeName) addField(String �ieldname, String className, String fieldType) addFieldModifiers(ArrayList modifiers, String �ieldname) addFunction(String typeName) addMethod(String methodName, String returnType, String typeName,String location) addConstructor(String typeName,String location) addFunctionModifiers(ArrayList modifiers, String typeName) addFunctionParameters(ArrayList parameters, String typeName) addFunctionExceptions(ArrayList exceptions, String typeName) clearOldData(String typeName) clearEverything()

For example, adding a method is: INSERT INTO Method (MethodID, MethodName, ReturnTypeID, Location) VALUES (id, methodName, returnType, location)

To clear everything in the database: Delete from Type ;


43

Delete from Class ; Delete from Method ; Delete from Field ;

and so on …

Other SQL statements are executed in a similar way. Searching the Database: A database search dialog was implemented which enables users to search the database by either filling in their search criteria into a form or by executing SQL statements directly. In the former case, user’s search criteria is converted by the system into complex SQL queries and executed. A result set is returned in the form of a table. The dialog is shown in the figure below: Users enter information into the slots in the table. In this case, the user is looking for all fields that have been declared private and contain the string name. Hence the user enters “%name%” as the Field Name and chooses “private” from the drop down menu under Access Modifiers. The user then presses Field Search.

Figure 13 - Database Search Dialog

The information is converted into an SQL statement. In this case, the statement generated is: SELECT Field.FieldName, T2.TypeName AS FieldType, T1.TypeName AS Class, Modifier.ModifierName FROM Field, Type T1, Type T2, Modifier, FieldModifiers WHERE Field.FieldName LIKE "%name%" AND Field.ClassID = T1.TypeID AND T1.TypeName LIKE "%" AND Field.TypeID = T2.TypeID AND T2.TypeName LIKE "%" AND Field.FieldID = FieldModifiers.FieldID AND FieldModifiers.ModifierID = Modifier.ModifierID AND (Modifier.ModifierName = "private")


44

In the query above, various the Field, Type, FieldModifiers and Modifier tables are joined using their primary keys. ‘%’ is used as a wildcard. After the statement is executed the following results are displayed:

Figure 14 - Database Search Results

The results table above has returned all fields that contain “name” and are “private”. It also returns the type of the field (in this case all of them are strings) and the class where they were found (firstName and lastName belong to the Person class, whereas name and courseName belong to Student). Other searches can be carried out in a similar way. Adding/Removing File(s) from the Database: A dialog was needed to show the user what files the database contains, so that the user can remove and add more files. The following dialog was created:

Figure 15 - Add/Remove File(s) Dialog

When this dialog is first loaded a query is executed in order to get all the files in the database: SELECT Filepath FROM Filepath The file list is displayed in the dialog. Users can click on any item in the list and then click Remove. A sequence of DELETE statements is then executed to remove it and all of its references from every table in the database. This means that all its fields and methods are removed too. Remove All clears all the tables in the database, except the Modifiers table and the Primitive Types. The statements used are shown below:


45

DELETE FROM Type WHERE TypeID>8 //leave the primitive types DELETE FROM Class DELETE FROM ClassInterfaces DELETE FROM TypeModifiers DELETE FROM Interface DELETE FROM Field DELETE FROM FieldModifiers DELETE FROM Function DELETE FROM Method DELETE FROM FunctionModifiers DELETE FROM FunctionExceptions DELETE FROM FunctionParameters DELETE FROM Constructor DELETE FROM Filepath

Finally, the dialog has an Add button. This button displays a JFileChooser, which allows users to select a file or directory to add to the database. If a directory is selected, all the files in it are recursively added. For example, in the figure above, the directory called “dbsearcher” was selected, which resulted in all the java files within it being parsed and added to the database.

6.5 Executing System Commands One of the requirements of the system is that it should be able to compile, run and generate javadoc for programs written by the user. To do this, commands such as javac, java and javadoc needed to be executed from within the application. This task was designated to the OutputFrame class. It uses the java Runtime classes to execute commands that belong to the operating system, in the following way: Process proc = Runtime.getRuntime().exec(command);

(command is any system command such as javac.) The results of executing a command are then displayed by using: InputStream istr = proc.getInputStream() ; //or proc.getErrorStream() BufferedReader br = new BufferedReader(new InputStreamReader(istr)); String str ; while ((str = br.readLine()) != null) { if(compiling) parseError(str) ;

else append(s,outputPane) ; }

In the code above, the input stream of the process (or the error stream if compiling) is obtained (which contains the results of the process) and a buffered reader put on it. A while loop is used to append each line onto the output window. If the command being executed was a compile command such as javac, then the error is parsed and is displayed in the form of hyperlinks. All compiler errors are of the general form: Filepath “:” linenumber ”:” error description


46

For example when compiling a file called Hello.java the following errors were displayed: Hello.java:36: ';' expected }

Since all errors have a fixed format, they can be parsed easily and can be broken down into the file path, line number and description. The file path and line number are displayed in the form of hyperlinks: Hello.java:36: ';' expected }

Users can click on these links to jump to the correct line in the source code. The error is highlighted in red. In this way the user can avoid delving through lots of lines of code looking for the error.

Figure 16- Ouput Window

6.6 The API Viewer The API Viewer enables users to browse through Java documentation. The documentation that can be viewed could either be the “API specification for the Java 2 Platform, Standard Edition” [22] which contains information about all the packages; classes and interfaces in the java libraries or the user could specify a different project. Documentation about classes is usually stored in a particular directory or URL. For example, the Java API reference at UCL is located at: http://www.cs.ucl.ac.uk/teaching/java/javadoc/api/index.html

Base URL The URLs for the packages and classes can be derived from the base URL by appending the following: Packages: http://www.cs.ucl.ac.uk/teaching/java/javadoc/api/overview-frame.html Classes: http://www.cs.ucl.ac.uk/teaching/java/javadoc/api/allclasses-frame.html

47

The API Viewer connects to all the URLs given above and parses the HTML files. It builds a hash map, which maps all the classes, packages and interfaces to their corresponding URLs. It then displays a list of all the items on the screen. When an item is clicked, its URL is looked up in the hash map and the page corresponding to the URL is displayed. Users can change the main URL of their documentation in the options window. In this way they can view the documentation of different projects with ease. The API Viewer has a search box in which users can search for specific items. Wildcards are matched too. This means that users do not need to scroll down a long list of classes to find the one that they are looking for (which is the case when viewing documentation via a web browser). So, for example, if the user enters “String*” into the search box, a list of possible matches is displayed including String, StringBuffer, StringContent and so on. The user can then choose the one s/he wishes to view. The code for matching wildcards is shown below: /** * Finds all matching words * @param text what we want to match e.g XML* */ public void findMatches(String text) { //create a new Pattern object and a vector to hold matches Pattern p = Pattern.compile(text) ; Vector v = new Vector(10) ; //we have to check for a match in the typeslist for(int i = 0 ; i< allTypes.size() ;i++){ //compare each type in the list to the pattern String s = (String)allTypes.get(i) ; Matcher m = p.matcher(s) ; if(m.matches()){ v.add(s) ; //if it matches add to vector } }… }

Figure 17 - API Viewer

48

6.7 The Code Palette This is a tool for inserting code into the editor quickly and efficiently. It is displayed in the form of a JTree, in which different nodes correspond to different code items. The tree is built by reading an XML file. An extract of the XML file is shown below: <codetype name="Comments"> <code name="//">//|</code> <code name="/* */">/*|*/</code> </codetype> <codetype name="Loops"> <code name="do" >do\n{\n|\n}\nwhile();</code> <code name="while" >while()\n{\n|\n}</code> <code name="for" >for( ; ; )\n{\n|\n}</code> </codetype>

The XML code above contains a special character ‘|’ in some places. For example, a print statement is represented as: <code name="print" >System.out.println(|);<code> This character is used to indicate where user’s selected text is to be inserted. Hence if the user selected the string “Hello World” in the editor and then clicked on the print item in the tree, the character would be replaced by the selection and the following would be displayed: System.out.println(“Hello World”) ;

If no text is selected: System.out.println(); is displayed. Building the tree: The XML code is parsed using an XML DOM Parser from the javax.xml.parsers and org.xml.sax libraries. A tree is built. A tree listener is added to the tree so that whenever a node is clicked, the corresponding item is inserted at the current position in the editor. (Example code for this feature was taken from JAXP Tutorial [23])

Figure 18 - Code Palette


49

6.8 The Class Browser When a file is opened or saved the Java Parser extracts all the important information and sends it to the Class Browser (and to the database). The Class Browser provides a frame for displaying a tree reflecting the structure of the class. The tree itself is built by a Tree Builder class. The Tree Builder builds a tree according to the information sent to it and then passes the finished tree to the Class Browser, which displays it on the screen. Information is displayed in the form of nodes, which display the file path, class name, super class, interfaces, methods and fields. Nodes are colored according to the traffic light scheme; items that are public are green, protected are yellow and private are red. The tree listens for mouse clicks. When the user clicks on a particular node, an SQL query is executed to find out the location of the item that was clicked. For example, if a field was clicked: String query = "SELECT Location FROM Field, Type WHERE "+ "Field.FieldName = \""+name+"\" AND "+ "Field.TypeID = Type.TypeID AND "+ "Type.TypeName = \""+type+"\" AND "+ "Field.ClassID = "+typeID ; ResultSet results = dbstmt.executeQuery(query) ; results.next() ; return results.getString("Location") ; This returns the location of the field. If the file is open, the location is highlighted in the editor. This feature will obviously not work if the database is not connected. The Class Browser also has a pop up menu, which appears when the user clicks with the right mouse button on the tree. This menu has three buttons:

• Open file: opens the file for editing

• Delete: removes this file from the tree

• Go to: Highlights the location as described above.

Fig 19 – Class Browser


50

6.9 The File Explorer The File Explorer is common to many applications. It presents the user’s file store in the form of a tree and enables them to browse their directories and open files. This is implemented by starting at the user’s home directory, which is obtained by using the statement: System.getProperty("user.home"); This statement returns the root directory, which is then recursively traversed using methods from the java.io package such as directory.list()(returns a list of all files in the directory). During this process a tree is built showing the file hierarchy. A filter is applied so that only directories and files with a “.java” extension are displayed in the tree. These files are displayed with a special icon so that can be easily identified. When a node representing a file is clicked, its path is obtained and the file is opened in a new editor, provided it is not already open. The file is parsed and the database and class browser are updated. The tree also has a pop up menu that is invoked whenever the user clicks using the right mouse button. The menu has four buttons:

• Open File: Opens the file. • Browse: Adds the file or directory

to the browser. • Add to Database: Adds the file or

directory to the database. • Reload: Refreshes the entire file

structure e.g. if the user creates a new file.

Figure 20 – File Explorer

6.10 The Editor Java code is typed into the editor. All editing actions such as cut, copy, paste, undo and redo etc take place in the editor. In addition, the editor also needs to know if the current file is saved or not, so that files can be closed safely. This was implemented


51

using a VetoableChangeListener, which listens for the window closing event and then checks to see if the file has been saved. Syntax Highlighting: The editor holds a SyntaxDocument, which is responsible for highlighting code as the user types. This is implemented using a document listener. Whenever a character is inserted into the document, the resulting word is looked up in a table of keywords and types. If it is found then it is highlighted in accordance with the keyword color scheme. It is then checked whether it is a String or part of comment and then colored accordingly. Line numbers: This is an external component that fits onto the side of the editor and displays line numbers. It uses a canvas to paint on which the numbers are painted. The spacing between numbers is determined by the font size of the editor. Bracket Matching: This was implemented using a CaretListener. Whenever the caret encountered a bracket it searched for the matching one. The code below shows how an opening bracket found is found given a closing bracket, the current position and the string to look in. /** * Finds an opening bracket that matches the closing bracket. * * @param closeBracket the closing bracket. * @param pos the position of the closing bracket. * @param data the string to look in. * @return the position of the opening bracket. */ public static int findOpeningBracket (char closeBracket, int pos, String data) { char openBracket; //find the opening bracket that matches this one switch(closeBracket) { case ')': openBracket = '(' ; break ; case '}': openBracket = '{' ; break ; default: openBracket = '[' ; break ; } //now iterate backwards along the string until you find the

//desired bracket int count = 0 ; for(int i = pos-2 ; i>=0 ; i--) { char c = data.charAt(i) ; if(c==')' || c=='}' || c==']') count++ ; else if(c=='(' || c=='{' || c=='[') { if(c==openBracket && count == 0 ) { return i ; } else count-- ; } } return -1 ; }

52

In this way the location of the opening bracket is found. There is a similar method for finding the closing bracket. Once a matching bracket is found, the region between the brackets is highlighted. Popup menu: Like any text editor, this editor has a popup menu, which is triggered when the user clicks on the text area using the right mouse button.

Figure 21 – Java Editor

6.11 User Options Options are stored in a configuration file. This file is read before the system starts up. An extract from the file is shown below: # IDE Preferences File # This is a generated file! Do not edit. NAME:Fahd Shariff COMPILECMD:javac -classpath .:<dir> <filepath> RUNCMD:java -classpath .:<dir> <classname> JAVADOCCMD:javadoc -d <dir> <filepath> APIURL:http://www.cs.ucl.ac.uk/teaching/java/javadoc/api/ USER:root PASSWORD: DRIVER:org.gjt.mm.mysql.Driver URL:jdbc:mysql://dundas.cs.ucl.ac.uk:17149/jde2

53

The file contains a variety of information including the name of the user, java commands and database settings. This gives the user freedom to execute different commands, for example, they can change their classpath in the compile command or their database URL in order to use a different database. The options file contains tags such as <dir>, <filepath> and <classname>. These are determined by the system during execution and refer to the directory, file name and class name of the java program currently being edited. Options Dialog: This is a dialog that allows users to change their preferences. It is built using a JTable.

Fig 22 – Options Dialog

When the Apply button is pressed, all the values in the second column of the table are written to the options file and the file is saved. Reset changes all the values to their defaults, which are coded within the system. Cancel closes the window.

6.12 Printing The system would not be complete without a printing facility. Files can be printed uses the Java Printing API [24] and syntax highlighting and user fonts are all retained on the paper version as well. Code for this operation and for print previewing was adapted from the famous WordProcessor example in "Swing, 2nd Edition" by Matthew Robinson and Pavel Vorobiev [8]. It had to be modified to work with this system. When the Print button is pressed a standard Java Print Dialog is displayed and the file is then printed. public void printData() { try { PrinterJob prnJob = PrinterJob.getPrinterJob(); prnJob.setPrintable(this); if (!prnJob.printDialog()) return; prnJob.print(); }

54

catch (PrinterException e) {System.out.println(e) ;}}

6.13 Pretty Printing This is used to mark up java code into HTML format, which can then be viewed as a webpage. This feature had already been implemented as a 2nd year group project using Mr. John Washbrook’s code. That project, however, had been web-based so a little work had to be done to plug it into this system. When the Save As Webpage button is clicked, the user is asked to enter the name of a web file to save the java file as. The java file is parsed, and HTML tags are emitted depending on the type of token encountered by the parser. For example, the statement: public void doSomething(); Becomes: <html> <head> <title>Pretty Printer Results </head> <body> public void doSomething() ; </body> </html> This HTML code can now be viewed in a web browser.

6.14 Toolbars The system has two toolbars located at the top of the screen. They can be removed if desired. The toolbars are: Standard Toolbar: This is a conventional toolbar, similar to that found in most applications. It contains buttons for file operations (open, save) and editing (cut, copy, paste, undo, redo, find). The extreme right of this toolbar contains buttons for java operations (compile, run, applet viewer, API viewer, java doc). It was decided to implement time-consuming tasks, such as opening a file and compiling, as separate threads. This enables the GUI to remain responsive while such tasks are being carried out in the background.

For example, compilation takes place in a separate thread in the following way:

outputFrame.setFile(file) ; Thread runner = new Thread() {

public void run() { try {

outputFrame.compileCode() ; } catch(Exception e) {System.out.println(e) ;}


55

} }; runner.start() ; //starts the thread

A new thread is created which compiles the file. If a new thread were not created, the user would have to wait until during the compilation process. This way, the user can continue working on the file while compilation takes place. Opening a file, saving, parsing and database operations run in separate threads too.

Formatting Toolbar: This holds buttons for formatting text. Users can change the font type, size and style of selected text. Text alignment can also be changed.

Once a new item (font name, size, style etc) is selected from a drop down menu, it is applied to the selected text through the use of an attached ActionListener. The item is assigned to a SimpleAttributeSet instance using the appropriate method from the StyleConstants class:

For example, to change the font family:

String fontName = fontCombo.getSelectedItem().toString(); MutableAttributeSet attr = new SimpleAttributeSet(); StyleConstants.setFontFamily(attr, m_fontName); setAttributeSet(attr);

The setAttributeSet() method is used to assign a given set of attributes to the currently selected text.

public void setAttributeSet(AttributeSet attr, JTextPane t) {

int xStart = t.getSelectionStart(); int xFinish = t.getSelectionEnd(); StyledDocument d = t.getStyledDocument();

d.setCharacterAttributes(xStart, xFinish - xStart, attr, true);

}

The setAttributeSet() method first determines the start and end positions of the selected text. The setCharacterAttributes() method is called to assign the given set of attributes to the selection.

6.15 Menus The system has menus that categorize the buttons on the toolbars and also provide additional features. The menus are similar to those found in other applications. Each menu item has a mnemonic and accelerator. For example, the code below creates a new menu item called Open. This is activated when the user presses Ctrl-O (accelerator) and also if the user presses Alt-O (mnemonic). item = new JMenuItem(“Open”) ; item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,

Event.CTRL_MASK)); item.setMnemonic(KeyEvent.VK_O); Other menu items were implemented in a similar fashion.


56

6.16 Implementing Shared Actions There are some actions, which are common to both the standard toolbar and the menus. For example, the toolbar contains buttons such as New, Open, Save, Cut, Copy and Paste etc. These are also present in the File and Edit menus. Instead of implementing these actions twice in the menu and toolbar classes, it was decided use action objects. Each action has its own class and all the actions are present in a single java file called AppAction.java. An extract of this file is shown below: public abstract class AppAction extends AbstractAction { protected AppDesktopPane desktop ; … public AppAction(String name, ImageIcon icon) { super(name, icon) ; //the name and icon to use desktop = App.getDesktop() ; } } //all actions extends AppAction /** * New File Action * Opens a New Blank Java Editor */ class NewAction extends AppAction { public NewAction() { super("New", new ImageIcon("app/images/New.gif")) ; } public void actionPerformed(ActionEvent e){ JavaEditor editor = new JavaEditor() ; desktop.addInternalFrame(editor) ; } } /** * Cut Action */ class CutAction extends AppAction { public CutAction() { super("Cut", new ImageIcon("app/images/Cut.gif")) ; } public void actionPerformed(ActionEvent e){ JavaEditor selected = desktop.getSelectedEditor() ; if(selected != null) selected.getCustomTextPane().cut() ; }}


57

In this way, all actions shared by different components are implemented as individual actions. Buttons and menu items that use these actions can then be created by: AppAction newAction = new NewAction() ; JButton button = new JButton(newAction) ;

This creates a button called New. When the button is pressed the actionPerformed method of class NewAction is invoked.

6.17 Window Management Programmers usually have a number of files open at the same time, which can be confusing. To handle this, a virtual desktop was implemented. This has a list to keep track of all the files opened so far. This list is updated if a new file is opened or an existing file is closed. The desktop also provides the facility for arranging (tiling), minimizing and restoring windows that it contains. Windows can be arranged horizontally or vertically. This is done by counting the windows in the desktop and then positioning them using the setLocation(x,y) method.

6.18 Summary This chapter described the implementation of the system based on the design given in previous chapters. In particular it discussed how the parser was implemented from a grammar using JavaCC and how the database was built. Various other major components of the system, such as the Code Palette, Class Browser and API Viewer were implemented. Minor components such as toolbars and menus used by the system were discussed briefly. The factors taken into account while implementing each feature were also presented. As a result of this process, an Integrated Java Development Environment has been created as intended.

Chapter 7 Testing

58

CChhaapptteerr 77

TTeessttiinngg This chapter describes testing phase of the software development cycle. Due to large number of components, only the important ones have been discussed below. The different strategies used and any bugs found have also been presented here. Test results can be found in the appendix.

7.1 Testing Strategy In order to test that the system behaves as intended, various testing methods have been employed. Individual java classes were tested using the JUnit framework [25]. The concept of using unit testing to drive design has been employed to a limited extent. Every method in each class of the system was tested for a variety of inputs and expected outputs. The testing of each part of the system was carried out as each method was written, so as to save time that would otherwise be used on a specific testing phase. This process identified several errors in the code mainly NullPointerExceptions. Throughout the development process, System.out.println() statements were inserted in different areas of code and results that were printed on the console were compared with expected values. GUI components and tools were mostly tested in an interactive fashion. User testing was carried out as well. Since, one of the major features of the system is to parse source code and add it to a database, the parser and database classes had to be tested thoroughly. These have been explained in some detail below.

7.2 Testing the Parser The first step is testing the parser. This is important because if the parser extracts the wrong information from the java source, the database will be affected. Testing a parser means running it over a challenging set of source files and verifying that the correct tokens are extracted. A set of dummy files was created. For thorough testing, each file contained many different constructs such as a super class, interfaces, exceptions, modifiers, parameters etc. One of these files is shown below: public class Test extends SuperTest implements Imp1, Imp2, Imp3 { private int age ;

Chapter 7 Testing

59

protected static String name, address ; public Test(String name) throws Exception {} public synchronized int getAge(String name, String address) {} private void setName(String n) throws AnotherException {} }

It is hard and time consuming to automate the testing of a parser, mainly because a grammar is used which is converted to java code by JavaCC. An alternative was to insert print statements at vital points in the code. The words printed out to the console were then compared with what was expected. Testing whether the correct information is extracted from the Class Declaration is shown below: void UnmodifiedClassDeclaration() : { Token type ; //the class token Token extendToken=null; //superclass ArrayList interfaces = new ArrayList() ; //a list for interfaces } { "class" type=<IDENTIFIER> [ "extends" extendToken=Name() ] ["implements" interfaces =NameList() ] { try{ String className = type.toString() ; String extendsName = extendToken.toString(); System.out.println(“Name:” +className) ; System.out.println(“SuperClass:” +extendsName) ; for(int i = 0 ; i < interfaces.size() ; i++)

System.out.println(“Interface:” +interfaces.get(i)) ; }catch(Exception e){System.out.println(e) ;} } ClassBody() }

In the code above, print statements were inserted to print out the class name, super class and interfaces. In the same way, they ere inserted into the FieldDeclaration and methodDeclaration constructs.

7.3 Testing the Database The next logical step after testing the parser is to test the database. The following functionality had to be tested:

• Adding a file • Removing a file • Removing all files • Updating a file • Searching

Chapter 7 Testing

60

Once again a set of dummy java files were created. They were sent to the parser, where they were parsed and added to the database. The database was then checked using SQL select statements to see whether items were indeed added in the correct tables and columns. The files were changed, by adding a new method or changing an existing file name, and then re-parsed. The database was checked again to ensure that it had been updated correctly. Using the system interface, files were removed from the database and the database was once again checked. Different combinations of database searches were carried out via the GUI and the results compared to expected results. Due to the complexity of some of the SQL queries a few minor bugs were encountered but were ironed out immediately.

7.4 Unit Testing Where appropriate Unit tests were constructed for all major components of the system using the JUnit framework. This was mainly used to test methods that made use of container objects such as Arrays and ArrayLists and those used for String manipulation. For example, the StringOperator class has a method for replacing all occurrences of a substring with another string. This method is shown below: /** * Returns a new string resulting from replacing all occurrences of * "repl" in this string with "with". */ public static String replaceString(String text, String repl,

String with) { StringBuffer buffer = new StringBuffer(text.length()); int start = 0; int end = 0; while( (end = text.indexOf(repl, start)) != -1 ) { buffer.append(text.substring(start, end)).append(with); start = end + repl.length(); } buffer.append(text.substring(start)); return buffer.toString(); } The method was tested using JUnit. The extract from the JUnit test class is shown below: public void testReplaceString() { assertEquals(StringOperator.replaceString("computer","put","abc"), "comabcer"); assertEquals(StringOperator.replaceString("abc","xyz","123"), ""); }

Chapter 7 Testing

61

Unit testing was useful in identifying errors due to boundary conditions such as ArrayIndexOutOfBoundsException and NullPointerException.

7.5 Testing the GUI Unfortunately there are not many commercial tools available for automated GUI testing. Manual testing of GUI based applications is slow, tedious, error-prone, non-repeatable and expensive. The main challenge is the great number of combinations involved. Each user choice opens a number of different options. For example, if the user clicks on SearchDatabase they can then decide to search for a Class, Field or Method. If they decide to search for a Field then they must enter the FieldName, FieldType and modifiers. So the number of different permutations and combinations is vast. To handle this problem, testing was carried out in two stages:

• Testing features that represent use case scenarios (described in the design phase).

• Random testing As a result of this process, some errors were found and corrected. Errors were mainly due to action events e.g. tree not responding, errors not highlighted etc.

7.6 Usability Testing In order to asses the quality and usefulness of the system's user interface, and to achieve some degree of testing of the system as a whole from a third-party viewpoint, it was decided that some basic user testing should be carried out. This would provide information about how users and systems perform in the real world context. Since the system is intended for programmers, it was decided that a computer science student at university would be an ideal candidate for user testing. The testing process involved observing users interacting with the system. Users were requested to open java files and try out the database, class browser, code palette and compiler. Other features were also tested in this way. Due to lack of users, user testing was also carried out by taking on the role of the user and walking through the system. The system was also used to work on the rest of the system i.e. to edit its own source code. Due to its multithreaded nature, the system may crash when carrying out large tasks e.g. opening a file.

7.7 Testing Platform-Independence The system has been implemented completely in Java 1.4.1, which enjoys “write once run anywhere” flexibility. It was still decided to test the system on different platforms. Since the system had been implemented completely on a UNIX operating system (in the departmental machines, due to the availability of MySQL), it had to be

Chapter 7 Testing

62

tested whether it worked as expected on Windows. Everything worked as planned but the system ran slower on Windows.

7.8 Summary The system was tested using a variety of methods such as JUnit testing, print statements and inspection. Usability testing was carried out to check whether the system performed well in the real world context. Any bugs found during testing were rectified immediately. The system works as expected. It may crash unexpectedly, very rarely, due to multithreading. In order to avoid this, a single thread could be used for the entire system, but this will slow things down tremendously.

Chapter 8 Conclusions

63

CChhaapptteerr 88

CCoonncclluussiioonnss The aim of this chapter is to evaluate the key achievements and limitations of the work undertaken, and to arrive at some conclusion about the overall worth of the project.

8.1 Evaluation The following main criteria were specified at the outset to define successful completion of the project:

• Develop a handy, open-source and free IDE to the Java development community.

• Explore the area of SCID and create a tool that allows information about the source code to be stored in a database, which is accessible to user queries.

• Implement a navigation tool to allow easy navigation through source code. • Build a tool to allow code insertion. • Allow users to jump to any error in the source code. • Develop an API Viewer with search capability. • Create an editor with syntax highlighting.

It can be said that these goals have been broadly achieved and the project does seem to have been largely successful. A fully working IDE has been produced that satisfies its goals to a large extent. It was used for further development of the project i.e. to edit its own source code and worked very well. The project made use of a number of different libraries and programming technologies including SQL for the database, JavaCC for generating a parser and XML for code insertion and tree building. Java was used as the main implementation language. MySQL was the only DBMS available in the department. It does not support a number of features such as stored procedures, transactions and most importantly nested SELECT statements. As a result, queries involving lots of tables became quite complex.

8.2 Performance The final system allows users to write programs quickly and easily. The speed is on par with (if not faster than) other development environments. This is due to the fact that tasks requiring lots of resources are started up in new threads. This keeps the system responsive to user actions. All implementation was performed on UNIX


64

Solaris Version 8 using Java 1.4.1. The program performed as expected in that environment but display and speed may differ on other operating systems.

8.3 Further Work Although the implementation of this project has been broadly successful, there are some areas, which might be improved upon, and many areas in which further work could be undertaken. The system is spread over a number of packages and all code is clearly documented. It is designed so that new components can easily be added at a later date. Improvements and extensions to the existing system are outlined below:

8.3.1 Extending the Database The current database only stores information about classes, interfaces, fields and methods. This can be extended to record other information such as that about packages, nested classes, object references, method bodies, where methods are invoked and so on. The final goal would be to extend the database so that it would store every single construct contained in a java source file. This would eventually lead to the extinction of .java files! One way of doing this would be to create new relations in the database to hold all the extra information. For example, another table would be created to hold nested classes and so on. As a result code will not be stored in files, but will be stored exclusively in the database. This is an important step away from thinking of programs strictly as linear streams of ASCII characters. This is what SCID hopes to achieve in the future. Once stored in the database, users can pick whatever information they wish to view and are not forced to view the whole file. For compiling source code, information would be extracted from the database, stored in a temporary file which would them be compiled normally.

8.3.2 Extending the Code Palette The existing code palette does not contain all the constructs and templates used in programming. In the future new templates could be added, such as those used in building swing applications, applets and in web applications like servlets and Java Server Pages. This could be carried out by simply extending the existing XML file to include these new templates and constructs. In addition, users could be given the option of entering information into dialog boxes when a code item is clicked. For instance, if the user presses the for loop button, then a dialog would appear prompting the user to enter the initial, terminator and increment expressions.

8.3.3 More User Options

65

In the future, the system could enable users to specify their formatting preferences and automatically format new source code or apply to existing source code. Preferences include indenting, tab size, braces, spacing, syntax highlighting colours etc. Users could also be allowed to customise their toolbars and menus. In addition a more efficient method could be developed for storing options. The current system uses a text file for this purpose; but in the future options could be stored in an XML file, perhaps in the following way: <options> <name>Fahd Shariff</name> <compilecommand>javac</compilecommand> </options>

8.3.4 Code Completion Many IDEs implement pop-up code completion. As the user types, possible completions are displayed in a list, allowing the user to select the appropriate one. This is also implemented in web browsers for completing URLs. This feature could be implemented by using a Document Listener, which compares words that the user types to a word list and returns possible matches. This is very useful and speeds up code writing by a great deal.

8.3.5 UML Visualisation This feature was set out in the requirements document but was not implemented due to its complex nature and lack of time. The idea is to create UML diagrams for a set of classes. The challenging aspect of this feature is layout. Once objects are drawn on a panel, they will have to be laid out in a “tidy” manner i.e. not overlapping and making best possible use of the panel in which they are drawn. Users would then be able to browse source code by clicking on objects in the UML diagrams.

8.3.6 Refactoring A refactoring is an operation, which modifies code to improve its design without affecting the meaning of the program [26]. Possible refactorings include: extract a method, introduce a variable, change a method, surround with try/catch, and automatically update all references to a package, class, or method being renamed or moved.

8.3.7 Wizards Wizards can speed up code writing.

• The New wizard could allow users to fill in information such as class name, super class, interfaces, fields and methods into a dialog box. Java source would be generated automatically from this information.


66

• The JUnit wizard could automatically generate test classes for java source code.

• The Javadoc wizard could automatically insert documentation above methods and fields by looking at their declarations.

• The Jar wizard could allow java projects to be zipped up into jar files.

8.4 Summary This project has achieved its aims – namely to create an Integrated Development Environment for Java that implements Source Code In Database, allows class and error navigation, code insertion and increases the productivity of programmers with a number of other tools. The project has resulted in the creation of a very useful piece of software with a database, code navigation, code insertion and error linking. There are many advantages of the database, which provides more motivation to develop this further in the future. Individual tools, such as the API Viewer, can be used separately if desired. The scope for further work on this IDE is immense. This chapter outlined some of the improvements to the existing system and new features that can be plugged into it. In particular it was discussed how the extension of the database could lead to the extinction of source code in files.

Chapter 9 Endmatter

68

CChhaapptteerr 99

EEnnddmmaatttteerr This chapter contains the various appendices, the bibliography and glossary.

Contents

• A System Manual • B User Manual • C Test Results • D Code Listing • E Project Plan • F Interim Report • G Bibliography • H Table of Figures • I Glossary

Appendix A System Manual

69

AAppppeennddiixx AA

SSyysstteemm MMaannuuaall This document contains all the technical details such as how the system should be compiled and run. It also describes where the code is stored, so that it can be modified in the future. The official homepage of this project is:

http://www.cs.ucl.ac.uk/students/f.shariff/projects/fyp/ All documents and code may be downloaded from here. For the purposes of this document, the software will be referred to as JIDE (Java Integrated Development Environment).

A.1 System Requirements

• This software requires Java 2 version 1.3 or 1.4. Before installing, make sure you have a compatible Java virtual machine.

• The recommended operating system is Unix.

• You will need approximately 4.5 MB of free disk space to complete the

installation.

• If you wish to use the database feature, you will need MySQL, which can be downloaded free from: http://www.mysql.com/downloads. You will not need to download database drivers since they are provided.

A.2 Installation Instructions

1. Create a directory for the software e.g. jide.

2. Copy the jide.zip file from the disk into this directory.

3. Execute the command to extract all the contents of the zip archive. This will vary according to which tool you use, but the command line format for using unzip would be: unzip jide.zip

4. The following files and directories are extracted: • jide.jar • src/ • ReadMe.txt • buildDB.txt

Appendix A System Manual

70

5. To install the database, first start up the MySQL daemon by typing: shell> safe_mysqld&

on UNIX machines.

6. Enter the following command:

shell> mysql –u root –p < buildDB.txt Enter password: *****

This command uses a batch file to build a database called jide and set up all the tables.

7. Installation Complete!

A.3 Running the Application To run the application simply type: shell> java –jar jide.jar

This command must be executed in the directory containing jide.jar

You will need to set up your preferences (particularly your database configuration) in the Options menu.

A.4 For Developers The src directory contains all the source code (including test classes) and documentation of the application. It also contains the following batch files:

• compileapp: used for compiling the application. • runapp: used for running the application. • doc: used for generating java documentation for the application.

Simply type the name of the batch file at the command prompt to execute it.

Appendix B User Manual

71

AAppppeennddiixx BB

UUsseerr MMaannuuaall This document attempts to provide help and assistance to programmers using this Integrated Java Development Environment. There are many advantages to using this IDE over other editors, although the biggest, may be that source code is parsed and information about classes, methods and fields are stored in a database. This has proven to be very useful when searching for something that you know is out there somewhere, but you don't know where. The application has a class browser for easy navigation through classes. It also has a code palette, which enables code templates ranging from classes and applets to simple statements to be inserted at the click of a button. Finding errors is very easy, since the application has both a parser and compiler. The parser alerts you to syntax and lexical errors (which make up approx 80% of errors) before you press the compile button. This means that the compiler only returns semantic errors and the number of times the compiler has to be run is significantly reduced. All errors are linked to the source code via hyperlinks so that they can be rectified easily. The sections below cover basic usage of the different features provided by the IDE.

B.1 Working with Java Files This section describes basic file commands such as Open, Save, Save As Webpage, Print and Print Preview. It also describes in more detail, how the file explorer is used and how files can be added to the browser and/or database. 1 Creating New Files

Menu: File>New Toolbar: New button Shortcut: Ctrl-N This opens a new, empty editor.

2 Opening Files

Menu: File>Open Toolbar: Open button Shortcut: Ctrl-O File Explorer: Popup>Open File This displays a file chooser dialog box and loads the specified file into a new editor. Alternatively, a file can be selected from the File Explorer. By default, opening a file also adds it to the class browser and to the database.


72

3 Saving Files Menu: File>Save File>Save As Toolbar: Save button or Save As button Shortcut: Ctrl-S This saves the current file to disk. If Save As is used, then the current file is saved to the new specified location. Saving a file, updates the class browser and the database.

4 Saving Files As WebPages

Menu: File>Save As Webpage This saves the current file into a coloured HTML format, which can be viewed in any standard web browser.

5 Printing and Previewing Files

Menu: File>Print or File>Print Preview Shortcut: Ctrl-P This prints the current file by displaying a Page Setup dialog first. The Print Preview feature can be used to preview the file before printing. Printing preserves syntax highlighting.

6 File Explorer

This is located on the extreme left of the application. The tab is named File Explorer and contains a list of all the files in the system in the form of a tree. The explorer can be closed by clicking on the X button in the top right hand corner. It can be viewed as a floating frame by clicking on the Pop button. It can be docked back into the main application by using the Dock button. To browse a directory double-click it. Java files are displayed with a ‘cup’ symbol. Unopened Java files can be displayed by double-clicking them. Clicking a file or directory with the right mouse button displays a popup menu containing various commands. The Open File button simply opens the file and is equivalent to clicking on the file. The Browse button adds the files to the class browser. The Add To Database button adds the selected file to the database. The Reload button refreshes the file explorer to show any new files or whether any files have been deleted from the system.

7 Closing Files and Exiting the Application

Menu: File>Close or File>Quit Shortcut: Ctrl-W or Ctrl-Q The Close button closes the current file. If it has unsaved changes, you will be prompted if they should be saved first. The Quit button will completely exit the application.

B.2 Using the Database This section describes how the database is to be used in terms of adding/removing files and searching.


73

1 Connecting to the Database Menu: Database>Connect All the features of the database will remain disabled until the Connect button is pressed. If your database is configured correctly, then you will see the message “Connected” on the console. If there is an error displayed, make sure that you have MySQL installed and that your server is running. (If it is not, type safe_mysqld& to start it) and check your options to make sure that you have entered the correct URL for the Database, which is of the form jdbc:mysql://hostname:17149/jide Once connected, you can disconnect from the database by pressing Database>Disconnect. This will close the connection and all other functionality will be disabled.

2 Adding and Removing Files from the Database

Menu: Database>Add/Remove File File Explorer: Popup>Add To Database A dialog is displayed that lists all the files currently in the database. To add more files to the database, click Add File(s) on the toolbar and select the file or directory you wish to add. If a directory is selected, all java files under that directory are added recursively to the database. The status bar displays what is currently being added. The list is refreshed to show the new files that ere added. Alternatively, files can also be added by right clicking on a file or directory in the file explorer and selecting Add to Database from the popup. To remove a file, select it from the list and press Remove. To remove everything in the database press Remove All. This will clear the database.

3 Searching the Database

Menu: Database>Search A search dialog is displayed. Search information is filled in the slots provided. The wildcard character is ‘%’. The Access Modifiers slot has a pull down menu from which the appropriate modifier can be selected. Other Modifiers must be comma separated. After filling in the search criteria, the appropriate search button on the toolbar should be pressed. The results are displayed in the Results tab in the form of a table. The SQL Search tab allows you to execute SQL queries on the database.

B.3 Navigating Source Code The class browser displays the structure of java files in the form of a tree and allows code navigation. It is present as a tab attached to the extreme left of the application. The browser can be shown in a floating window by pressing the Pop button and can be docked back again by using the Dock button. 4 Adding a File to the Browser

By default, whenever a file is opened via the file explorer, menus or toolbars, it is added to the browser. Files may also be added by selecting a file or directory in the file explorer and selecting Browse from the pop up menu. If a


74

directory is selected, all the java files under it are added to the browser recursively.

5 Refreshing the Browser

The browser is automatically refreshed whenever a file is saved, to reflect any changes in the file.

6 Navigating Source Code

The first line in the structure is the complete file path. When this is expanded, the name of the class, super class (if any) and implementing interfaces are shown. There is a collapsed node for Fields and another for Methods. These can be expanded to reveal all the fields and methods. For methods parameters and exceptions are displayed too. Items are displayed in different colours depending on what they are. The traffic light scheme has been used where green refers to all items that are public, red are private and yellow are protected. If the database is connected, clicking on an item will highlight where that item occurs in the source, provided the source file is open. This feature does not work if there is no database connection.

7 Deleting a File from the Browser

A popup menu is displayed when the browser is right clicked on. If the delete button is pressed and the file path to be deleted is selected then the file is removed from the browser.

8 Using the Popup Menu

The browser’s popup menu has an Open File button to open the selected file, Delete File button to the delete the selected file and a Go To button to jump to where the item occurs in the source provided the source is open and the database is connected.

B.4 Inserting Code Templates and Constructs The code palette is used to insert code templates and constructs into an editor. It is present as a tab attached to the extreme left of the application. The palette can be shown in a floating window by pressing the Pop button and can be docked back again by using the Dock button. Code has been categorised according to what it is e.g. loops, statements, comments etc. Code can be inserted by clicking on the desired node in the tree, which is inserted at the current caret position in the active file. Alternatively, code typed in the editor can be highlighted and then an item selected from the tree. This way the highlighted text is embedded within the code template.


75

B.5 Compiling and Executing Programs 1 Compiling Programs

Toolbar: Compile button This compiles the current file using javac. An output frame displays the errors during compiling. Click on the errors do jump to the problem in the source code, provided the source file is open. The compile command can be changed in the options dialog.

2 Running Programs

Toolbar: Run button This compiles the current file using java. An output frame displays the results of executing the program. The run command can be changed in the options dialog.

3 Executing Custom Commands

Output Frame Menu>New Command Enter your new command in the dialog box and press Enter. The command is executed and results are displayed in the output frame. To run the same command again, select it from the menu in the output frame.

4 Running Applets

Toolbar: Applet Viewer This will ask you to enter the URL of the applet. The applet is displayed using the applet viewer in a new window.

5 Generating Documentation

Toolbar: Javadoc button This generates documentation for the current file using javadoc. An output frame displays the results of executing the command.

B.6 Viewing Online API or Other Java Docs Clicking on the View API button on the standard toolbar starts the API Viewer. A new window appears, which displays the documentation. There is a drop down menu for browsing packages and a list of classes on the left hand side of the window. Clicking on any class in the list, displays its documentation in the window on the right. To see the documentation for a specific class or interface, enter its name in the search box below. Alternatively, to see the documentation for a set of classes (e.g. all classes beginning with “XML”), enter a pattern in the search box using ‘*’ as the wildcard character. This search box remembers previously entered strings. To view documentation of a different source (such as your own project), go to Edit>Options and change the API URL (e.g. to file: ~/project/docs/). Start the API Viewer again and now you can browse other documentation.

76

B.7 Working with Text Editing text takes place in the editor and is the same as other applications such as Notepad. Common editing functionality is present in the Edit menu and on the standard toolbar. They include:

• Cut (Ctrl-C), Copy (Ctrl-C), Paste (Ctrl-V), Select All (Ctrl-A) • Undo (Ctrl-Z), Redo (Ctrl-Y) • Find (Ctrl-F), Replace (Ctrl-H), Go To Line (Ctrl-G)]

The editor has line numbers along the left hand side of the window. It also highlights syntax while you type. The title bar of the editor contains the name of the file. If the file has unsaved changes, the title will have the word “(modified)” appended to it. This disappears when the file is saved. Bracket Matching: Positioning the caret immediately before or after a bracket will highlight the corresponding closing or opening bracket (assuming it is visible) and all the text within it. In this way it is easier to the bounds of, say loops. Formatting Text: The formatting toolbar contains buttons for changing the font face, style and size and for aligning text. The Popup Menu: The editor has an associated popup menu, which is invoked whenever the right mouse button is clicked on the editor. The menu contains simple text editing commands such as cut, copy and paste.

B.8 Setting Preferences Select Edit>Options. An options dialog appears which contains information about various commands and database configuration. After making any changed click Apply. Your changes are saved and will be used from this point onwards. Reset sets all the options back to their default values as set by the system vendor. The following tags may be used when specifying options:

• <filepath> - e.g. ~/project/Program.java • <dir> - e.g. ~/project/ • <classname> - e.g. Program

B.9 The Status Bar The Status Bar displays messages to inform you of what the system is doing. It is present at the bottom of the application and also has the time and date. The status of any task and any errors are displayed here.


77

B.10 Managing Windows Multiple files can be edited in separate editors, which are internal to the main application. There is a virtual desktop that holds all the editors. The Window menu has commands used for arranging all the editors, to avoid cluttering.

• Window>Cascade: overlaps windows • Window>Tile Horizontal: arranges windows horizontally • Window>Tile Vertical: arranges windows vertically • Window>Minimise All: minimises all the windows • Window>Restore All: restores all minimised windows • Window>Close All: closes all windows

B.11Customising the GUI The View menu contains buttons for adding and removing toolbars and the sidebar. For example, if you do not wish to use the Formatting toolbar, uncheck the formatting toolbar checkbox and the toolbar will disappear. The Look and Feel menu allows you to change the look and feel of the application. The default is the Metal Look and Feel. You can only select those that are supported by the system. This means that UNIX machines will not allow you to set a Windows look and feel. The Themes sub-menu allows you to change the colour coding of the toolbars, buttons and menus. Themes will only take effect if the Metal Look and Feel is selected.

Appendix C Test Results

78

AAppppeennddiixx CC

TTeesstt RReessuullttss This document contains the actual results of the tests carried out in the Testing Phase of the development process. In particular it contains the test results of the database and parser. Other classes were tested using JUnit and all tests were successful. The major part of the project is GUI based and hence there are no test results.

C.1 Dummy Files A set of challenging dummy files was created in order to test the parser and database. One of these is shown below: public class Dummy extends Parent implements Imp1, Imp2, Imp3 { private final int field1 ; private String s1, s2, s3 ; public Dummy(int f) throws Exception { field1 = f ; } public Dummy() { } public synchronized void method() { } protected String getName() { return s1 ; } public void setVars(int i, String s) throws SQLException { } }

The source code above is challenging since it contains all the constructs of the java language that we are interested in. It has a super class, interfaces, two kinds of field declarations, two constructors and methods with parameters and exceptions.

79

C.2 Results of Testing the Parser The parser was able to extract all of the important information from the file above: Class: Dummy Super class: Parent Implementing Interfaces: <Imp1, Imp2, Imp3> Class Modifiers: <public> Fields:

field1, int, <private, final> s1, String, <private> s2, String, <private> s3, String, <private>

Methods:

method, void, <public, synchronized> getName, String, <protected> setVars, void, <public>, <i:int, s:String>,<SQLException>

Constructors:

<public><f:int><Exception> <public>

Parsing successful.

C.3 Results of Testing the Database Dummy files were sent to the parser, which added information to the database. The file above gave the following results: +--------+----------+ | TypeID | TypeName | +--------+----------+ | 1 | boolean | | 2 | char | | 3 | byte | | 4 | short | | 5 | int | | 6 | long | | 7 | double | | 8 | float | | 9 | Dummy | | 10 | Parent | | 11 | Imp1 | | 12 | Imp2 | | 13 | Imp3 | | 14 | String | | 15 | void | +--------+----------+ +---------+----------------+-----------+ | ClassID | ExtendsClassID | Location | +---------+----------------+-----------+ | 9 | 10 | 2,14,2,18 | +---------+----------------+-----------+


80

+--------+---------------------------------+ | TypeID | Filepath | +--------+---------------------------------+ | 9 | ~/jide/src/app/tests/Dummy.java | +--------+---------------------------------+ +---------+-------------+ | ClassID | InterfaceID | +---------+-------------+ | 9 | 11 | | 9 | 12 | | 9 | 13 | +---------+-------------+ +--------+------------+----------+ | TypeID | ModifierID | Location | +--------+------------+----------+ | 9 | 6 | 2,1,2,6 | +--------+------------+----------+ +-------------+-----------+ | InterfaceID | Location | +-------------+-----------+ | 11 | 2,46,2,49 | | 12 | 2,52,2,55 | | 13 | 2,58,2,61 | +-------------+-----------+ +---------+-----------+--------+---------+-----------+ | FieldID | FieldName | TypeID | ClassID | Location | +---------+-----------+--------+---------+-----------+ | 1 | field1 | 5 | 9 | 4,17,4,22 | | 2 | s1 | 14 | 9 | 5,20,5,21 | | 3 | s2 | 14 | 9 | 5,24,5,25 | | 4 | s3 | 14 | 9 | 5,28,5,29 | +---------+-----------+--------+---------+-----------+ +---------+------------+----------+ | FieldID | ModifierID | Location | +---------+------------+----------+ | 1 | 4 | 4,5,4,11 | | 2 | 4 | 5,5,5,11 | | 3 | 4 | 5,5,5,11 | | 4 | 4 | 5,5,5,11 | +---------+------------+----------+ +------------+--------------------+ | FunctionID | ClassOrInterfaceID | +------------+--------------------+ | 1 | 9 | | 2 | 9 | | 3 | 9 | | 4 | 9 | | 5 | 9 | +------------+--------------------+ +----------+------------+--------------+-------------+ | MethodID | MethodName | ReturnTypeID | Location | +----------+------------+--------------+-------------+ | 3 | method | 15 | 16,30,16,35 | | 4 | getName | 14 | 20,22,20,28 | | 5 | setVars | 15 | 25,17,25,23 | +----------+------------+--------------+-------------+


81

+------------+------------+-------------+ | FunctionID | ModifierID | Location | +------------+------------+-------------+ | 1 | 6 | 7,5,7,10 | | 2 | 6 | 12,5,12,10 | | 3 | 6 | 16,5,16,10 | | 3 | 9 | 16,12,16,23 | | 4 | 5 | 20,5,20,13 | | 5 | 6 | 25,5,25,10 | +------------+------------+-------------+ +------------+---------------+-------------+ | FunctionID | ExceptionName | Location | +------------+---------------+-------------+ | 1 | Exception | 7,32,7,40 | | 5 | SQLException | 25,56,25,67 | +------------+---------------+-------------+ +------------+-----------+-------------+-------------+ | FunctionID | ParamName | ParamTypeID | Location | +------------+-----------+-------------+-------------+ | 1 | f | 5 | 7,22,7,22 | | 5 | i | 5 | 25,29,25,29 | | 5 | j | 5 | 25,36,25,36 | | 5 | s | 14 | 25,46,25,46 | +------------+-----------+-------------+-------------+ +---------------+-------------+ | ConstructorID | Location | +---------------+-------------+ | 1 | 7,12,7,16 | | 2 | 12,12,12,16 | +---------------+-------------+

From the results above the file was successfully added to the database. The file was then altered and the results inspected again. Finally another file was added to the database. The database passed all tests. It was also tested using the Search Dialog in the interface.

Appendix D Code Listing

82

AAppppeennddiixx DD

CCooddee LLiissttiinngg The application consists of a total of:

• 8 packages • 77 classes and interfaces

• 22588 lines of code (approximately)

Only the code for the named classes below is in this document. These classes were chosen because they deal with interesting and important aspects of the system such as the database and parser.

• DBStatement.java • DBInserter.java

• DBExtracter.java

• DBManager.java

• ParserManager.java

• OutputFrame.java

Appendix E Project Plan

95

AAppppeennddiixx EE

PPrroojjeecctt PPllaann This document was drafted in early November in collaboration with the project supervisor. It includes the:

• Aims and objectives of the project. • Expected outcomes and deliverables • Work plan – a pert chart showing how the workload was structured over the

project period (October – April)

Appendix F Interim Report

100

AAppppeennddiixx FF

IInntteerriimm RReeppoorrtt This document was outlined in January in collaboration with the project supervisor. It revisits the project's aims and objectives and describes the:

• Work accomplished to date • Main goals towards project completion


101

Name: Fahd Shariff Project Title: Integrated Development Environment for

Java Supervisor: Graham Knight Work Accomplished to Date The work that I have done so far can be categorised (in chronological order) as follows: 1. Research: I spent the first month heavily researching programming environments

such as JBuilder and MS Visual Basic. In my quest to find unique features for the project, I wrote to a number of newsgroups and even participated in web chats with fellow programmers. As a result, I found out what tools could be really useful for programmers. I also came across a great concept known as “Source Code In Database (SCID)”; programs are parsed and useful information stored in a database. This makes handling large projects very easy and is the basis for my project.

Finally, I drafted the “Requirements Specification Document”.

2. Design: I analysed the requirements document to identify potential packages,

classes, associations between classes etc. I also designed the database. It was then time to hand in the November Project Plan.

3. Implementation: To date, the vast majority of work has been done in

implementing the system.

� Parser & Database: I used the java-compiler-compiler (javacc) to generate a parser for java source code. I successfully set up a database using mySQL, which is populated with data by the parser.

� Java Editor: I developed an editor with word processing tools (font

manipulation, printing, find and replace etc). I added automatic syntax highlighting, auto-indentation and line numbering.

� Java Commands: Users can invoke the system compiler, appletviewer

and Java Runtime. They can click on a compiler error to go to the error in their code.

� Code Tools: Code writing by point-and-click.


102

Main Goals towards Project Completion The work that remains to be done can be categorised (in chronological order) as follows: 1. Continuation of Implementation:

� Code Browser: A navigation tool that “describes” java code. It allows easy navigation through the fields and methods of a class.

� Documentation: A Java API Viewer that helps users quickly find the

documentation of the classes they are looking for. The system will also allow automatic insertion of documentation.

� Wizards: The “New” wizard to generate code for classes given methods

and fields. The “Unit Test” wizard to generate code for JUnit test Classes. 2. Testing: Debugging and usability testing. 3. Final Report: Compilation of the final report will be carried out during the

beginning of March.

Supervisor’s Signature:

Appendix G Bibliography

103

AAppppeennddiixx GG

BBiibblliiooggrraapphhyy References cited in the text: [1] Sun Microsystems, Sun ONE Studio (formerly Forte Tools)

http://www.sun.com/software/sundev/ [2] Microsoft, Visual J++ Information

http://msdn.microsoft.com/vjsharp/productinfo/visualj/ [3] Borland, JBuilder

http://www.borland.com/jbuilder/ [4] T. Parr, The ANTLR Translator Generator

http://www.antlr.org/ [5] The Sable Researcher’s Group, SableCC

http://www.sablecc.org/ [6] Java Compiler Compiler, The Java Parser Generator

http://www.experimentalstuff.com/Technologies/JavaCC/ [7] Build your own Languages with JavaCC

http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-cooltools.html [8] Swing, Second Edition

Matthew Robinson, Pavel Vorobiev, Pavel A. Vorobiev, David Karr [9] Roedy Green, Source Code In Database (SCID)

http://www.mindprod.com/scid.html

[10] MySQL, The World’s Most Popular Open Source Database http://www.mysql.com/

[11] MySQL Database Driver Classes http://www.cs.ucl.ac.uk/staff/m.pias/project/alanImpl/implem/org/

[12] Sun Microsystems, Why Java?

http://www.sun.com/software/java/why.html

[13] Java Optimization http://www-2.cs.cmu.edu/~jch/java/optimization.html


104

[14] The Unified Software Development Process I. Jacobson, G. Booch, J. Rumbaugh, Addison-Wesley 1999

[15] JavaCC Grammar Repository

http://www.cobase.cs.ucla.edu/pub/javacc/

[16] Sun Microsystems, Working with XML http://java.sun.com/xml/jaxp/dist/1.1/docs/tutorial/TOC.html

[17] User Interface Design

http://www.cs.brown.edu/courses/cs032/resources/book/chap11.html

[18] Jeff Raskin, Intuitive Equals Familiar http://www.asktog.com/papers/raskinintuit.html

[19] Maximising Windows

http://www.asktog.com/columns/000maxscrns.html

[20] David K Every, Databases 101 http://www.igeek.com/articles/Software/Databases101.txt

[21] Whatever Happened to Object-Oriented Databases?

Neal Leavitt, IEEE Computer, August 2000

[22] Sun Microsystems, JavaTM 2 Platform Std. Ed. v1.4.1 http://www.cs.ucl.ac.uk/teaching/java/javadoc/api/index.html

[23] Sun Microsystems, XML and DOM

http://java.sun.com/xml/jaxp/dist/1.1/docs/tutorial/dom/

[24] Sun Microsystems, SDK 1.2 Printing API: A Tutorial http://java.sun.com/products/java-media/2D/forDevelopers/sdk12print.html

[25] E. G. Kent Beck, Junit Open-Source Testing Framework

http://www.junit.org

[26] Refactoring – Improving the Design of Existing Code M. Fowler, Addison Wesley 1999

Other Resources:

• Aubjex, an IDE that transforms Java code into an especially efficient and complete database form. http://www.alajava.com/aubjex/index.htm

• Object Oriented Databases and Their Applications to Software Engineering

Alan W. Brown

• Human Computer Interaction Alan J. Dix, et al


105

• Patterns in Java, Volume 2

Mark Grand

• Java Threads, Second Edition Scott Oaks, Henry Wong O’Reilly

• The JFC Swing Tutorial: A Guide to Constructing GUIs

Kathy Walrath, Mary Campione

• Java XBrowser http://www.xbrowser.sourceforge.net/

• Google Java Groups http://www.groups.google.com/groups?group=comp.lang.java

Appendix H Table of Figures

106

AAppppeennddiixx HH

TTaabbllee ooff FFiigguurreess

Design Models Figure 1 – Use Case Diagram .................................................................................. 14 Figure 2 – Basic System Model ............................................................................... 19 Figure 3 – Package Dependencies............................................................................ 24 Figure 4 – Database Class Diagram ......................................................................... 25 Figure 5 – Parser Class Diagram.............................................................................. 26 Figure 6 - Open File Activity Diagram .................................................................... 27 Figure 7 - Save File Activity Diagram ..................................................................... 28 Figure 8 - Search Database Activity Diagram .......................................................... 29 Figure 9 – Initial GUI Design .................................................................................. 30 Figure 10 - Data Flow Diagram ............................................................................... 33 Figure 11 - Entity Relation Diagram........................................................................ 34 Figure 12 - System Package Hierarchy .................................................................... 36

Screenshots Figure 13 - Database Search Dialog......................................................................... 43 Figure 14 - Database Search Results ........................................................................ 44 Figure 15 - Add/Remove File(s) Dialog................................................................... 44 Figure 16- Ouput Window....................................................................................... 46 Figure 17 - API Viewer ........................................................................................... 47 Figure 18 - Code Palette .......................................................................................... 48 Figure 19 – Class Browser....................................................................................... 49 Figure 20 – File Explorer......................................................................................... 50 Figure 21 – Java Editor............................................................................................ 52 Figure 22 – Options Dialog...................................................................................... 53

Appendix I Glossary

107

AAppppeennddiixx II

GGlloossssaarryy This appendix provides short definitions of the jargon terms used throughout the report. Accelerator A keystroke combination (usually a modifier key and a

character key, like Control-C) that activates a menu item from the keyboard.

API Viewer A tool used to view online java documentation and api. Auto indentation Automatically indenting code when the enter button is

pressed. Class Browser A tree representation of source code indicating class

information such as fields and methods and their accessibility. Used for navigating through source code.

Code Palette A tree representation of code that can be inserted into the document.

DBMS (Database Management System) A complex set of programs that control the organization, storage and retrieval of data.

Dockable Items that can be added or removed Driver Software that forms a bridge between the server hosting the

database and the client running the application.

Dummy file A file used for testing the parser and database. Editor The text area on which the code is actually written. File Explorer A tree representation of the file system. Flat Database Stores data in one big table. Formatting Toolbar

A toolbar used to change the way text looks.

Grammar A set of rules that define the structure of a language. GUI (Graphical User Interface) An interface that has windows,

buttons and menus used to carry out tasks.

IDE (Integrated Development Environment) A collection of tools that allow you to do many common programming tasks with a common interface.

JavaCC A parser generator library for Java JDBC (Java Database Connectivity) Connectivity between the Java

platform and a wide range of databases.

JUnit A framework to write automated repeatable tests. Line indicator A list of line numbers found on the side of the editor. Look and Feel Describes the appearance and behaviour of a complete set of

GUI components.

Appendix I Glossary

108

Mnemonic Shows the user which key to press (in conjunction with the Alt key) to activate a command.

Modifier Keywords used to modify code e.g. public, private, static etc. Multithreading Carrying out more than one task at a time. MySQL A true multi-user, multi-threaded SQL (Structured Query

Language) database server.

Object Oriented Database

Allows structured sub objects; each object has its own identity, or object-id (as opposed to a purely value-oriented approach).

Options User preferences. Output Window The text area which displays the results of executing java

commands such as javac and java. Compiler errors are linked to the source code.

Parentheses Matching

Positioning the caret immediately before or after a bracket will highlight the corresponding closing or opening bracket (assuming it is visible) and all the text within it.

Parse To analyse a sentence in order to extract tokens corresponding to syntax .

Parser A tool used for parsing programs. Parser Generator A program which, given a formal description of a language,

can generate a parser. E.g. JavaCC.

Platform Independent

Code that once written, can be run anywhere.

Popup menu A menu displayed when the right mouse button is clicked. Pretty Printer A module responsible for saving files as colourful web pages

in HTML format.

Print Preview A feature that shows how the document will look when printed.

Refactoring An operation which modifies code to improve its design without affecting the meaning of the program.

Relational Database

Stores data in many tables that relate to each other.

SCID (Source Code in Database) The process of storing source code in a database instead of files to aid searching and navigating.

Semantic error An error in the meaning of the statements in the program. Shared action An action used by more than one class e.g. toolbars and

menus. SQL (Structured Query Language) A language used to create,

maintain, and query relational databases.

Standard Toolbar A toolbar used for common operations such as file handling and java operations.

Status Bar A panel on the bottom of the main window which displays messages to inform the user of what the system is doing.

Syntax error An error in the use of the rules of language. Syntax Highlighting

Colouring text according to syntax

Appendix I Glossary

109

Highlighting Theme A feature that enables the user to specify alternative colours

and fonts across the entire application.

Toolbar A vertical or horizontal bar containing icons that represent the commands that can be used in an application.

Type A class or interface. UML Visualisation

Creating UML representations of projects.

Unit Test Test of one part of the system to see if remediation efforts were successful.

URL (Uniform Resource Locator) An Internet address which tells a browser where to find an Internet resource.

Virtual Desktop A feature allowing multiple windows to be opened within the application to prevent cluttering up the operating system's desktop.

Wildcard A character that can represent any group of characters e.g. '*'. Window Management

Arranging windows in the virtual desktop. They can be arranged in a number of ways including vertically and horizontally.

XML (Extensible Mark-up language) A way of storing data in files. Used by the code palette.

XML DOM Parser

An XML parser.

Source Code in Database (SCID)

Documents

Transcript of Source Code in Database (SCID)