CA UI Implementation - Revision history

Manus: Manus moved page User:Stefan/Code Analysis/UI Implementation to CA UI Implementation without leaving a redirect

2014-06-03T23:21:58Z

Manus moved page User:Stefan/Code Analysis/UI Implementation to CA UI Implementation without leaving a redirect

Manus at 23:21, 3 June 2014

2014-06-03T23:21:44Z

Stefan: new name

2014-03-20T14:09:17Z

new name

Stefan: "EVE" -> "EiffelStudio"

2014-03-20T09:29:56Z

"EVE" -> "EiffelStudio"

Stefan: /* Command-line Interface */

2014-03-13T09:39:29Z

‎Command-line Interface

Stefan: /* Graphical User Interface */ + Example Command

2014-03-11T12:24:53Z

‎Graphical User Interface: + Example Command

Stefan: /* Graphical User Interface */ Caching

2014-03-07T17:28:45Z

‎Graphical User Interface: Caching

Stefan: /* Graphical User Interface */ + class diagram

2014-03-07T17:06:06Z

‎Graphical User Interface: + class diagram

Stefan: initial version - moved from former chapter 7

2014-03-07T11:09:22Z

initial version - moved from former chapter 7

New page

<center><small>[[User:Stefan/Code Analysis/Library Implementation|<< 7. Library Implementation]] |</small></center>
----
<br />

== Graphical User Interface ==

The classes of the graphical user interface of the code analyzer are all located in the ''interface'' cluster of ''EVE'', in the subfolder ''graphical > tools > code_analysis''. Here is a short overview of what the single classes do:

; <e>{ES_CODE_ANALYSIS_TOOL}</e> : Represents the code analysis GUI tool. Contains the tool title and icon, otherwise not much interesting stuff.
; <e>{ES_CODE_ANALYSIS_TOOL_PANEL}</e> : The graphical panel for the code analysis tool. It contains buttons, labels, the rule violations table view, and other user interface elements.
; <e>{ES_CODE_ANALYSIS_COMMAND}</e> : The command to launch the code analyzer. It can be added to toolbars and menus. It can be executed using stones. This class also handles the caching.
; <e>{ES_CODE_ANALYSIS_BENCH_HELPER}</e> : A helper class for the integration of the code analysis tool. It contains shared instances of <e>{CA_CODE_ANALYZER}</e> and <e>{ES_CODE_ANALYSIS_COMMAND}</e>, which are used by the GUI.
; <e>{ES_CA_SHOW_PREFERENCES_COMMAND}</e> : The command is used by the ''Preferences'' button in the panel.
; <e>{ES_CA_FIX_EXECUTOR}</e> : This class [[User:Stefan/Code Analysis/Using Analysis Results#Fixing Rule Violations|fixes]] a rule violation that has been found by the code analysis tool.

=== Caching ===

== Command-line Interface ==

The whole command-line functionality of the code analyzer is located in the class <e>{EWB_CODE_ANALYSIS}</e>. It is located in the ''tty'' cluster of ''EVE''. <e>{EWB_CODE_ANALYSIS}</e> is invoked by <e>{ES}</e>, the root class for the ''batch'' (command-line) version of EiffelStudio. In <e>{ES}</e>, the invocation looks as follows:

<e>
elseif option.is_equal ("-code-analysis") then
l_at_args := arguments_in_range (current_option + 1, argument_count)
current_option := argument_count + 1
create {EWB_CODE_ANALYSIS} command.make_with_arguments (l_at_args)
</e>

Any command-line arguments after ''-code-analysis'' are passed on to <e>{EWB_CODE_ANALYSIS}</e>. This class, in its creation procedure, processes the arguments as described in [[User:Stefan/Code_Analysis/Command Line Usage|Command Line Usage]]. Classes that were passed as command-line arguments are added to the analyzer. Then the actual execution happens in the procedure <e>execute</e>. <e>EWB_CODE_ANALYSIS</e> of course uses the ''code_analysis'' library and the previously described interface of <e>CA_CODE_ANALYZER</e>. After analysis a list of rule violations is output to the command-line. In the code it looks like this:

<e>
across l_code_analyzer.rule_violations as l_vlist loop
if not l_vlist.item.is_empty then
l_has_violations := True
-- Always sort the rule violations by the class they are referring to.
output_window.add (ca_messages.cmd_class + l_vlist.key.name + "':%N")

-- See `{CA_RULE_VIOLATION}.is_less' for information on the sorting.
across l_vlist.item as ic loop
l_rule_name := ic.item.rule.title
l_rule_id := ic.item.rule.id
if attached ic.item.location as l_loc then
l_line := ic.item.location.line.out
l_col := ic.item.location.column.out
output_window.add (" (" + l_line + ":" + l_col + "): "
+ l_rule_name + " (" + l_rule_id + "): ")
else -- No location attached. Print without location.
output_window.add (" " + l_rule_name + " (" + l_rule_id + "): ")
end
ic.item.format_violation_description (output_window)
output_window.add ("%N")
end
end
end

if not l_has_violations then output_window.add (ca_messages.no_issues + "%N") end
</e>

@@ Line 1: / Line 1: @@
-<center><small>[[User:Stefan/Code Analysis/Library Implementation|&lt;&lt; 7. Library Implementation]] |</small></center>
+[[Category:Code Analysis]]
-----
-<br />
 == Graphical User Interface ==

@@ Line 5: / Line 5: @@
 == Graphical User Interface ==
-The classes of the graphical user interface of the code analyzer are all located in the ''interface'' cluster of EiffelStudio, in the subfolder ''graphical > tools > code_analysis''. Here is a short overview of what the single classes do:
+The classes of the graphical user interface of Inspector Eiffel are all located in the ''interface'' cluster of EiffelStudio, in the subfolder ''graphical > tools > code_analysis''. Here is a short overview of what the single classes do:
 ; <e>{ES_CODE_ANALYSIS_TOOL}</e> : Represents the code analysis GUI tool. Contains the tool title and icon, otherwise not much interesting stuff.
@@ Line 14: / Line 14: @@
 ; <e>{ES_CA_FIX_EXECUTOR}</e> : This class [[User:Stefan/Code Analysis/Using Analysis Results#Fixing Rule Violations|fixes]] a rule violation that has been found by the code analysis tool.
-These are roughly the class relations for the code analysis GUI:
+These are roughly the class relations for the Inspector Eiffel GUI:
-[[File:CA GUI Diagram.png|thumb|center|650px|The most interesting class relations of the code analysis GUI.]]
+[[File:CA GUI Diagram.png|thumb|center|650px|The most interesting class relations of the Inspector Eiffel GUI.]]
 === Caching ===

@@ Line 5: / Line 5: @@
 == Graphical User Interface ==
-The classes of the graphical user interface of the code analyzer are all located in the ''interface'' cluster of ''EVE'', in the subfolder ''graphical > tools > code_analysis''. Here is a short overview of what the single classes do:
+The classes of the graphical user interface of the code analyzer are all located in the ''interface'' cluster of EiffelStudio, in the subfolder ''graphical > tools > code_analysis''. Here is a short overview of what the single classes do:
 ; <e>{ES_CODE_ANALYSIS_TOOL}</e> : Represents the code analysis GUI tool. Contains the tool title and icon, otherwise not much interesting stuff.
@@ Line 129: / Line 129: @@
 == Command-Line Interface ==
-The whole command-line functionality of the code analyzer is located in the class <e>{EWB_CODE_ANALYSIS}</e>. It is located in the ''tty'' cluster of ''EVE''. <e>{EWB_CODE_ANALYSIS}</e> is invoked by <e>{ES}</e>, the root class for the ''batch'' (command-line) version of EiffelStudio. In <e>{ES}</e>, the invocation looks as follows:
+The whole command-line functionality of the code analyzer is located in the class <e>{EWB_CODE_ANALYSIS}</e>. It is located in the ''tty'' cluster of EiffelStudio. <e>{EWB_CODE_ANALYSIS}</e> is invoked by <e>{ES}</e>, the root class for the ''batch'' (command-line) version of EiffelStudio. In <e>{ES}</e>, the invocation looks as follows:
 <e>

@@ Line 127: / Line 127: @@
 At the start of the routine the code analyzer instance is retrieved from the helper class. All classes that may have been addedbefore, are removed. All previous rule violations are removed as well. The if clause creates a stone for the ''Last Scope'' label in the graphical panel. Then, the button in the tool is disabled so that starting another analysis is prevented until the current one has completed. Finally, the analysis is started. As soon as the analysis has completed <e>{ES_CODE_ANALYSIS_COMMAND}.analysis_completed</e> is called. In this procedure the rule violations (and possibly the exceptions) are retrieved from the code analyzer and displayed in the list in the tool panel.
-== Command-line Interface ==
+== Command-Line Interface ==
 The whole command-line functionality of the code analyzer is located in the class <e>{EWB_CODE_ANALYSIS}</e>. It is located in the ''tty'' cluster of ''EVE''. <e>{EWB_CODE_ANALYSIS}</e> is invoked by <e>{ES}</e>, the root class for the ''batch'' (command-line) version of EiffelStudio. In <e>{ES}</e>, the invocation looks as follows:

← Older revision		Revision as of 12:24, 11 March 2014
Line 24:		Line 24:

	The caching functionality is implemented in <e>{ES_CODE_ANALYSIS_COMMAND}</e>. When the command for analyzing the system is executed, the timestamps of the last modification of the classes are stored in <e>analysis_timestamp : HASH_TABLE [INTEGER, CLASS_I]</e> before the analysis. Note that the cached results (the rule violations) themselves are managed by <e>{CA_CODE_ANALYZER}</e>. The only difference to a non-cached analysis is that the rule violations are not deleted by <e>{ES_CODE_ANALYSIS_COMMAND}</e> before the next analysis. Then, in case the next command is also for analyzing the whole system, the current timestamps are compared to the stored timestamps. Any class that has been changed in the meantime will be analyzed again; for any unchanged class the rule violations are taken from the cache.		The caching functionality is implemented in <e>{ES_CODE_ANALYSIS_COMMAND}</e>. When the command for analyzing the system is executed, the timestamps of the last modification of the classes are stored in <e>analysis_timestamp : HASH_TABLE [INTEGER, CLASS_I]</e> before the analysis. Note that the cached results (the rule violations) themselves are managed by <e>{CA_CODE_ANALYZER}</e>. The only difference to a non-cached analysis is that the rule violations are not deleted by <e>{ES_CODE_ANALYSIS_COMMAND}</e> before the next analysis. Then, in case the next command is also for analyzing the whole system, the current timestamps are compared to the stored timestamps. Any class that has been changed in the meantime will be analyzed again; for any unchanged class the rule violations are taken from the cache.
		+
		+	=== Example Command: Analyze One Class ===
		+
		+	We will now roughly go through the code that is executed on the GUI part when the user wants to analyze a single class. As mentioned in Chapter [[User:Stefan/Code Analysis/Running the Analyzer\|Running the Analyzer]], this can be done using the class context menu or by dropping the class stone on the button ''Analyze Item''.
		+
		+	In any case <e>{ES_CODE_ANALYSIS_COMMAND}.execute_with_stone</e> is called, which delegates to <e>execute_with_stone_content</e>:
		+
		+	<e>
		+	execute_with_stone (a_stone: STONE)
		+	-- Execute with `a_stone'.
		+	do
		+	execute_with_stone_content (a_stone, Void)
		+	end
		+
		+	execute_with_stone_content (a_stone: STONE; a_content: SD_CONTENT)
		+	-- Execute with `a_stone'.
		+	local
		+	l_save_confirm: ES_DISCARDABLE_COMPILE_SAVE_FILES_PROMPT
		+	l_classes: DS_ARRAYED_LIST [CLASS_I]
		+	do
		+	-- Show the tool right from the start.
		+	show_ca_tool
		+
		+	if not eiffel_project.is_compiling then
		+	if window_manager.has_modified_windows then
		+	create l_classes.make_default
		+	window_manager.all_modified_classes.do_all (agent l_classes.force_last)
		+	create l_save_confirm.make (l_classes)
		+	l_save_confirm.set_button_action (l_save_confirm.dialog_buttons.yes_button, agent save_compile_and_analyze (a_stone))
		+	l_save_confirm.set_button_action (l_save_confirm.dialog_buttons.no_button, agent compile_and_analyze (a_stone))
		+	l_save_confirm.show_on_active_window
		+	else
		+	compile_and_analyze (a_stone)
		+	end
		+	end
		+	end
		+	</e>
		+
		+	If there are modified, unsaved windows a save confirmation dialog is displayed. Eventually program flow passes on to <e>compile_and_analyze</e>:
		+
		+	<e>
		+	compile_and_analyze (a_stone: STONE)
		+	-- Compile project and perform analysis of stone `a_stone'.
		+	local
		+	l_helper: ES_CODE_ANALYSIS_BENCH_HELPER
		+	l_dialog: ES_INFORMATION_PROMPT
		+	do
		+	-- Compile the project and only analyze if the compilation was successful.
		+	eiffel_project.quick_melt (True, True, True)
		+	if eiffel_project.successful then
		+	create l_helper
		+	if l_helper.code_analyzer.is_running then
		+	create l_dialog.make_standard (ca_messages.already_running_long)
		+	l_dialog.show_on_active_window
		+	else
		+	perform_analysis (a_stone)
		+	end
		+	end
		+	end
		+	</e>
		+
		+	<e>eiffel_project.quick_melt</e> starts the compilation. A successful compilation is required for code analysis; otherwise nothing is analyzed. After compilation has succeeded we check if code analysis is already running. If this is the case then a dialog is displayed. If on the other hand this last possible obstacle is not present we finally start analyzing by calling <e>perform_analysis</e>.
		+
		+	<e>
		+	perform_analysis (a_stone: STONE)
		+	-- Analyze `a_stone' only.
		+	local
		+	l_helper: ES_CODE_ANALYSIS_BENCH_HELPER
		+	l_scope_label: EV_LABEL
		+	do
		+	-- For simplicity let us assume that `a_stone' does not
		+	-- correspond to the system or is equivalent to it.
		+	last_was_analyze_all := False
		+
		+	create l_helper
		+	code_analyzer := l_helper.code_analyzer
		+	code_analyzer.clear_classes_to_analyze
		+	code_analyzer.rule_violations.wipe_out
		+
		+	l_scope_label := ca_tool.panel.scope_label
		+
		+	if attached {CLASSC_STONE} a_stone as s then
		+	code_analyzer.add_class (s.class_i.config_class)
		+	l_scope_label.set_text (s.class_name)
		+	l_scope_label.set_foreground_color (create {EV_COLOR}.make_with_8_bit_rgb (140, 140, 255))
		+	l_scope_label.set_pebble (s)
		+	l_scope_label.set_pick_and_drop_mode
		+	l_scope_label.set_tooltip (ca_messages.class_scope_tooltip)
		+	elseif [...]
		+	[...]
		+	end
		+
		+	disable_tool_button
		+	window_manager.display_message (ca_messages.status_bar_running)
		+	code_analyzer.add_completed_action (agent analysis_completed)
		+	code_analyzer.analyze
		+	end
		+	</e>
		+
		+	(The code that deals with stones other than classes is omitted.)
		+
		+	At the start of the routine the code analyzer instance is retrieved from the helper class. All classes that may have been addedbefore, are removed. All previous rule violations are removed as well. The if clause creates a stone for the ''Last Scope'' label in the graphical panel. Then, the button in the tool is disabled so that starting another analysis is prevented until the current one has completed. Finally, the analysis is started. As soon as the analysis has completed <e>{ES_CODE_ANALYSIS_COMMAND}.analysis_completed</e> is called. In this procedure the rule violations (and possibly the exceptions) are retrieved from the code analyzer and displayed in the list in the tool panel.

	== Command-line Interface ==		== Command-line Interface ==

← Older revision	Revision as of 23:21, 3 June 2014
(No difference)

← Older revision		Revision as of 17:28, 7 March 2014
Line 18:		Line 18:

	=== Caching ===		=== Caching ===
		+
		+	It is a common case that GUI users run the code analyzer again after having made some changes to the code. We do not need to analyze the same unchanged code again and again. Therefore code analysis caches the results in memory. This only applies to the GUI mode.
		+
		+	Code analysis uses cached results exactly in one case: when the whole system is analyzed and the previous analysis was on the whole system, too.
		+
		+	The caching functionality is implemented in <e>{ES_CODE_ANALYSIS_COMMAND}</e>. When the command for analyzing the system is executed, the timestamps of the last modification of the classes are stored in <e>analysis_timestamp : HASH_TABLE [INTEGER, CLASS_I]</e> before the analysis. Note that the cached results (the rule violations) themselves are managed by <e>{CA_CODE_ANALYZER}</e>. The only difference to a non-cached analysis is that the rule violations are not deleted by <e>{ES_CODE_ANALYSIS_COMMAND}</e> before the next analysis. Then, in case the next command is also for analyzing the whole system, the current timestamps are compared to the stored timestamps. Any class that has been changed in the meantime will be analyzed again; for any unchanged class the rule violations are taken from the cache.

	== Command-line Interface ==		== Command-line Interface ==