samples/animals/c++/Makefile samples/animals/c++/animal.h samples/animals/c++/cat.cc samples/animals/c++/cat.h samples/animals/c++/dog.cc samples/animals/c++/dog.h samples/animals/c++/main.cc samples/animals/c++/mammal.h samples/animals/java/Animal.java samples/animals/java/Cat.java samples/animals/java/Dog.java samples/animals/java/Main.java samples/animals/java/Makefile samples/animals/java/Mammal.java @@ -9,7 +9,6 @@ use Egypt::Model; our $QUIET = undef; -__PACKAGE__->mk_accessors(qw(model)); __PACKAGE__->mk_ro_accessors(qw(current_member)); sub alias { @@ -35,6 +34,14 @@ sub load { return $extractor; } +sub model { + my $self = shift; + if (!exists($self->{model})) { + $self->{model} = new Egypt::Model; + } + return $self->{model}; +} + sub current_module { my $self = shift; @@ -44,6 +51,9 @@ sub current_module { # read variable declarations $self->_read_variable_declarations(); + + #declare + $self->model->declare_module($self->{current_module}); } return $self->{current_module}; Egypt/Extractor.pm @@ -9,10 +9,7 @@ use File::Basename; sub new { my $package = shift; - my @defaults = ( - model => Egypt::Model->new, # temporary (?) - ); - return bless { @defaults, @_ }, $package; + return bless { @_ }, $package; } sub feed { @@ -31,21 +28,29 @@ sub feed { $self->{current_member} = $variable; } + # inheritance + if ($line =~ m/^\s{3}inherits from (.+)$/) { + $self->model->add_inheritance($self->current_module, $1); + } + # function calls/uses if ($line =~ m/^\s{6}uses function (\S+) defined in (\S+)$/) { my $function = _qualified_name($2, $1); $self->model->add_call($self->current_member, $function, 'direct'); } + # variable references elsif ($line =~ m/^\s{6}uses variable (\S+) defined in (\S+)$/) { my $variable = _qualified_name($2, $1); $self->model->add_variable_use($self->current_member, $variable); } + # public members if ($line =~ m/^\s{6}protection public$/) { $self->model->add_protection($self->current_member, 'public'); } + # method LOC if($line =~ m/^\s{6}(\d+) lines of code$/){ $self->model->add_loc($self->current_member, $1); } Egypt/Extractor/Doxyparse.pm @@ -66,10 +66,7 @@ use File::Find; sub new { my $package = shift; - my @defaults = ( - model => Egypt::Model->new, # temporary (?) - ); - return bless { @defaults, @_ }, $package; + return bless { @_ }, $package; } sub feed { Egypt/Extractor/GCC.pm @@ -130,6 +130,18 @@ sub amz_size { return ($count > 0) ? ($lines / $count) : 0; } +sub dit { + my ($self, $module) = @_; + my @parents = $self->model->inheritance($module); + if (@parents) { + my @parent_dits = map { $self->dit($_) } @parents; + my @sorted = reverse(sort(@parent_dits)); + return 1 + $sorted[0]; + } else { + return 0; + } +} + sub report { my $self = shift; my $result = ''; @@ -144,7 +156,7 @@ sub report { loc => 0 ); - for my $module (keys(%{$self->model->modules})) { + for my $module ($self->model->module_names) { my $coupling = $self->coupling($module); my $number_of_functions = $self->number_of_functions($module); my $lcom1 = $self->lcom1($module); @@ -153,6 +165,7 @@ sub report { my $public_functions = $self->public_functions($module); my $amz_size = amz_size($lines, $number_of_functions); my $public_variables = $self->public_variables($module); + my $dit = $self->dit($module); my %data = ( _module => $module, @@ -166,7 +179,8 @@ sub report { loc => $lines, max_mloc => $max_mloc, public_functions => $public_functions, - public_variables => $public_variables + public_variables => $public_variables, + dit => $dit, ); $result .= Dump(\%data); Egypt/Metrics.pm @@ -9,7 +9,9 @@ sub new { demangle => {}, calls => {}, lines => {}, - protection => {} + protection => {}, + inheritance => {}, + module_names => [], ); return bless { @defaults }, __PACKAGE__; } @@ -19,6 +21,30 @@ sub modules { return $self->{modules}; } +sub module_names { + my $self = shift; + return @{$self->{module_names}}; +} + +sub declare_module { + my ($self, $module) = @_; + if (! grep { $_ eq $module} @{$self->{module_names}}) { + push @{$self->{module_names}}, $module; + } +} + +sub inheritance { + my ($self, $module) = @_; + my $list = $self->{inheritance}->{$module}; + return $list ? @$list : (); +} + +sub add_inheritance { + my ($self, $child, $parent) = @_; + $self->{inheritance}->{$child} = [] if !exists($self->{inheritance}->{$child}); + push @{$self->{inheritance}->{$child}}, $parent; +} + sub members { my $self = shift; return $self->{members}; Egypt/Model.pm @@ -22,6 +22,16 @@ sub new { return bless $self, $package; } +sub _add_dependency { + my ($dependencies, $from, $to) = @_; + $dependencies->{$from} = { } if !exists($dependencies->{$from}); + if (exists $dependencies->{$from}->{$to}) { + $dependencies->{$from}->{$to} += 1; + } else { + $dependencies->{$from}->{$to} = 1; + } +} + sub string { my $self = shift; my $result = "digraph callgraph {\n"; @@ -38,14 +48,15 @@ sub string { my $calling_module = $self->_function_to_module($caller); my $called_module = $self->_function_to_module($callee); next unless (defined($calling_module) && defined($called_module) && ($calling_module ne $called_module)); - $modules_dependencies->{$calling_module} = { } if !exists($modules_dependencies->{$calling_module}); - if (exists $modules_dependencies->{$calling_module}->{$called_module}) { - $modules_dependencies->{$calling_module}->{$called_module} += 1; - } else { - $modules_dependencies->{$calling_module}->{$called_module} = 1; - } + _add_dependency($modules_dependencies, $calling_module, $called_module); } } + foreach my $subclass (keys(%{$self->model->{inheritance}})) { + foreach my $superclass ($self->model->inheritance($subclass)) { + _add_dependency($modules_dependencies, $subclass, $superclass); + } + } + foreach my $calling_module (sort(keys %{$modules_dependencies})) { foreach my $called_module (sort(keys %{$modules_dependencies->{$calling_module}})) { my $strength = $modules_dependencies->{$calling_module}->{$called_module}; Egypt/Output/DOT.pm @@ -15,7 +15,8 @@ sub list_metrics() public_methods => "Number of public methods", amz_size => "Average number of lines per method", max_mloc => "Max number of method lines", - public_variables => "Number of public variaveis" + public_variables => "Number of public variaveis", + dit => "Depth of Inheritance Tree", ); foreach my $key (sort keys %metrics){ egypt-metrics @@ -49,3 +49,18 @@ Feature: multi-language support | c++ | 2 | main | HelloWorld | 4 | | java | 2 | Main | HelloWorld | 4 | + Scenario Outline: inheritance data + Given I am in samples/animals/<language> + When I run "egypt graph --modules ." + Then egypt must report that "Cat" depends on "Mammal" + Then egypt must report that "Dog" depends on "Mammal" + Then egypt must report that "Mammal" depends on "Animal" + When I run "egypt metrics ." + And egypt must report that module Cat has dit = 2 + And egypt must report that module Dog has dit = 2 + And egypt must report that module Mammal has dit = 1 + And egypt must report that module Animal has dit = 0 + Examples: + | language | + | c++ | + | java | features/language_support.feature @@ -16,10 +16,6 @@ sub constructor : Tests { isa_ok(new Egypt::Extractor, 'Egypt::Extractor'); } -sub has_a_model : Tests { - can_ok('Egypt::Extractor', 'model'); -} - sub has_a_current_member : Tests { can_ok('Egypt::Extractor', 'current_member'); } @@ -28,7 +24,7 @@ sub has_a_current_member : Tests { # BEGIN test of indicating current module ############################################################################## sub current_module : Tests { - my $extractor = Egypt::Extractor->new; + my $extractor = new Egypt::Extractor; $extractor->current_module('module1.c'); is($extractor->current_module, 'module1.c', 'must be able to set the current module'); $extractor->current_module('module2.c'); t/02_extractor.t @@ -15,6 +15,26 @@ sub empty_object : Tests { isa_ok($model->members, 'HASH', 'must have members'); } +sub declaring_modules : Tests { + my $model = new Egypt::Model; + $model->declare_module('Module1'); + $model->declare_module('Module2'); + my @modules = $model->module_names; + is($modules[0], 'Module1'); + is($modules[1], 'Module2'); +} + +sub declaring_inheritance : Tests { + my $model = new Egypt::Model; + $model->add_inheritance('Child', 'Parent'); + my @parents = $model->inheritance('Child'); + is($parents[0], 'Parent', 'class with one superclass'); + + $model->add_inheritance('Child', 'AnotherParent'); + @parents = $model->inheritance("Child"); + is($parents[1], 'AnotherParent', 'class with two superclasses'); +} + sub declaring_function : Tests { my $model = new Egypt::Model; $model->declare_function('mymodule', 'myfunction'); t/03_model.t @@ -142,29 +142,52 @@ sub public_variables : Tests { } sub loc : Tests { - is($metrics->loc('mod1'), (0, 0), 'empty module has 0 LOC'); + my @result = $metrics->loc('mod1'); + is($result[0], 0, 'empty module has 0 LOC'); + is($result[1], 0, 'empty module has max LOC 0'); $model->declare_function('mod1', 'mod1::f1'); $model->add_loc('mod1::f1', 10); - eq_array($metrics->loc('mod1'), [10, 10], 'one module, with 10 LOC'); + @result = $metrics->loc('mod1'); + is($result[0], 10, 'one module, with 10 LOC'); + is($result[1], 10, 'one module, with 10 LOC, makes max LOC = 10'); - $model->declare_function('mod1', 'mod1::f1'); - $model->add_loc('mod1::f1', 20); - eq_array($metrics->loc('mod1'), [30, 20], 'other module, with 20 LOC'); + $model->declare_function('mod1', 'mod1::f2'); + $model->add_loc('mod1::f2', 20); + @result = $metrics->loc('mod1'); + is($result[0], 30, 'adding another module with 20 LOC makes the total equal 30'); + is($result[1], 20, 'adding another module with 20 LOC makes the max LOC equal 20'); } sub amz_size_with_no_functions_at_all : Tests { is($metrics->amz_size(0, 0), 0); } +sub dit : Tests { + $model->add_inheritance('Level1', 'Level2'); + $model->add_inheritance('Level2', 'Level3'); + is($metrics->dit('Level1'), 2, 'DIT = 2'); + is($metrics->dit('Level2'), 1, 'DIT = 1'); + is($metrics->dit('Level3'), 0, 'DIT = 0'); +} + +sub dit_with_multiple_inheritance : Tests { + $model->add_inheritance('Level1', 'Level2A'); + $model->add_inheritance('Level1', 'Level2B'); + $model->add_inheritance('Level2B', 'Level3B'); + is($metrics->dit('Level1'), 2, 'with multiple inheritance take the larger DIT between the parents'); +} + sub report : Tests { # first module + $model->declare_module('mod1'); $model->declare_function('mod1' , 'f1a'); $model->declare_function('mod1' , 'f1b'); $model->declare_variable('mod1' , 'v1'); $model->add_variable_use($_, 'v1') for qw(f1a f1b); # second module + $model->declare_module('mod2'); $model->declare_function('mod2', 'f2'); $model->add_call('f2', 'f1a'); $model->add_call('f2', 'f1b'); @@ -174,34 +197,6 @@ sub report : Tests { ok($output =~ /number_of_modules: 2/, 'reporting number of modules in YAML stream'); ok($output =~ /_module: mod1/, 'reporting module 1'); ok($output =~ /_module: mod2/, 'reporting module 2'); - - #s( -#'--- -#average_coupling: 0.5 -#average_coupling_times_lcom1: 0 -#average_coupling_times_lcom4: 0.5 -#average_lcom1: 0 -#average_lcom4: 1 -#number_of_functions: 3 -#number_of_modules: 2 -#--- -#_module: mod1 -#coupling: 0 -#coupling_times_lcom1: 0 -#coupling_times_lcom4: 0 -#interface_size: 2 -#lcom1: 0 -#lcom4: 1 -#--- -#_module: mod2 -#coupling: 1 -#coupling_times_lcom1: 0 -#coupling_times_lcom4: 1 -#interface_size: 1 -#lcom1: 0 -#lcom4: 1 -#', - #'must report metrics as a YAML stream'); } sub discard_external_symbols_for_coupling : Tests { t/04_metrics.t @@ -29,6 +29,14 @@ sub current_module : Tests { is($extractor->current_module, 'module2.c', 'must be able to change the current module'); } +sub inheritance : Tests { + my $extractor = Egypt::Extractor->load('Doxyparse'); + $extractor->current_module('Child'); + $extractor->feed(' inherits from Parent'); + my @result = $extractor->model->inheritance('Child'); + is($result[0], 'Parent', 'extractor detects inheritance'); +} + sub detect_function_declaration : Tests { my $extractor = Egypt::Extractor->load('Doxyparse', current_module => 'module1.c'); $extractor->feed(' function myfunction in line 5'); t/06_extractor_doxyparse.t 1ebd9453591046adbf1f969acf65f70e05938846 Antonio Terceiro terceiro@softwarelivre.org http://github.com/terceiro/egypt/commit/fb4d6eb39bd9f8e4e44f52b4c0aed9160ef5ff07 fb4d6eb39bd9f8e4e44f52b4c0aed9160ef5ff07 2009-10-12T18:04:42-07:00 2009-10-12T18:04:42-07:00 Implementing inheritance support Added: * sample Animals program in C++ and Java * new metric DIT * noticing dependency by inheritance Changed: * now there is an explicit list of modules in Egypt::Model. This way empty modules will be listed in metrics report. * refactored the module dependency calculation by extracting a method to populate the dependencies hashes. ac881702f5e87ac579758f7ed6b9913c16d9b49a Antonio Terceiro terceiro@softwarelivre.org