C0 code coverage information.
7 |
8 | <%= render_partial 'graph', {:graph_name => 'rcov'} %>
9 |
10 | ]
6 | def self.graphers
7 | @graphers
8 | end
9 |
10 | def self.inherited(subclass)
11 | @graphers << subclass
12 | end
13 |
14 | def self.get_grapher(metric)
15 | graphers.find { |grapher|grapher.metric.to_s == metric.to_s }
16 | end
17 |
18 | attr_accessor :output_directory
19 |
20 | def initialize(opts = {})
21 | self.output_directory = opts[:output_directory]
22 | end
23 |
24 | def output_directory
25 | @output_directory || MetricFu::Io::FileSystem.directory("output_directory")
26 | end
27 |
28 | def get_metrics(_metrics, _sortable_prefix)
29 | not_implemented
30 | end
31 |
32 | def graph!
33 | labels = MultiJson.dump(@labels)
34 | content = <<-EOS
35 | var graph_title = '#{title}';
36 | #{build_data(data)}
37 | var graph_labels = #{labels};
38 | EOS
39 | File.open(File.join(output_directory, output_filename), "w") { |f| f << content }
40 | end
41 |
42 | def title
43 | not_implemented
44 | end
45 |
46 | def date
47 | not_implemented
48 | end
49 |
50 | def output_filename
51 | not_implemented
52 | end
53 |
54 | private
55 |
56 | def build_data(data)
57 | "var graph_series = [" << Array(data).map do |label, datum|
58 | "{name: '#{label}', data: [#{datum}]}"
59 | end.join(",") << "];"
60 | end
61 |
62 | def not_implemented
63 | raise "#{__LINE__} in #{__FILE__} from #{caller[0]}"
64 | end
65 | end
66 | end
67 |
--------------------------------------------------------------------------------
/spec/metric_fu/reporting/graphs/graph_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.reporting_require { "graphs/graph" }
3 |
4 | describe MetricFu do
5 | describe "responding to #graph" do
6 | it "should return an instance of Graph" do
7 | expect(MetricFu.graph).to be_a(Graph)
8 | end
9 | end
10 | end
11 |
12 | describe MetricFu::Graph do
13 | before(:each) do
14 | @graph = MetricFu::Graph.new
15 | end
16 |
17 | describe "setting the date on the graph" do
18 | # TODO better test
19 | it "should set the date once for one data point" do
20 | metric_file = "metric_fu/tmp/_data/20101105.yml"
21 | expect(MetricFu::Utility).to receive(:glob).and_return([metric_file].sort)
22 | expect(MetricFu::Utility).to receive(:load_yaml).with(metric_file).and_return("Metrics")
23 | double_grapher = double
24 | expect(double_grapher).to receive(:get_metrics).with("Metrics", "11/5")
25 | expect(double_grapher).to receive(:graph!)
26 |
27 | @graph.graphers = [double_grapher]
28 | @graph.generate
29 | end
30 |
31 | # TODO better test
32 | it "should set the date when the data directory isn't in the default place" do
33 | metric_file = "/some/kind/of/weird/directory/somebody/configured/_data/20101105.yml"
34 | expect(MetricFu::Utility).to receive(:glob).and_return([metric_file].sort)
35 | expect(MetricFu::Utility).to receive(:load_yaml).with(metric_file).and_return("Metrics")
36 | double_grapher = double
37 | expect(double_grapher).to receive(:get_metrics).with("Metrics", "11/5")
38 | expect(double_grapher).to receive(:graph!)
39 |
40 | @graph.graphers = [double_grapher]
41 | @graph.generate
42 | end
43 | end
44 | end
45 |
--------------------------------------------------------------------------------
/spec/metric_fu/reporting/result_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.reporting_require { "result" }
3 |
4 | describe MetricFu do
5 | describe "#result" do
6 | it "should return an instance of Result" do
7 | expect(MetricFu.result.instance_of?(Result)).to be(true)
8 | end
9 | end
10 | end
11 |
12 | describe MetricFu::Result do
13 | before(:each) do
14 | @result = MetricFu::Result.new
15 | end
16 |
17 | describe "#as_yaml" do
18 | it "should call #result_hash" do
19 | result_hash = double("result_hash")
20 | expect(result_hash).to receive(:to_yaml)
21 |
22 | expect(@result).to receive(:result_hash).and_return(result_hash)
23 | @result.as_yaml
24 | end
25 | end
26 |
27 | describe "#result_hash" do
28 | end
29 |
30 | describe "#add" do
31 | it "should add a passed hash to the result_hash instance variable" do
32 | result_type = double("result_type")
33 | allow(result_type).to receive(:to_s).and_return("type")
34 |
35 | result_inst = double("result_inst")
36 | expect(result_type).to receive(:new).and_return(result_inst)
37 |
38 | expect(result_inst).to receive(:generate_result).and_return(a: "b")
39 | expect(result_inst).to receive(:respond_to?).and_return(false)
40 |
41 | expect(MetricFu::Generator).to receive(:get_generator).
42 | with(result_type).and_return(result_type)
43 | result_hash = double("result_hash")
44 | expect(result_hash).to receive(:merge!).with(a: "b")
45 | expect(@result).to receive(:result_hash).and_return(result_hash)
46 | expect(@result).to receive(:metric_options_for_result_type).with(result_type)
47 | @result.add(result_type)
48 | end
49 | end
50 | end
51 |
--------------------------------------------------------------------------------
/lib/metric_fu/metrics/churn/report.html.erb:
--------------------------------------------------------------------------------
1 | Source Control Churn Results
2 | Files that change a lot in your project may be bad a sign.
3 | This task uses your source control log to identify those files.
4 |
5 |
6 |
7 | | File Path |
8 | Times Changed |
9 |
10 | <% count = 0 %>
11 | <% if @churn[:changes] %>
12 | <% @churn[:changes].each do |change| %>
13 |
14 | | <%= link_to_filename(change[:file_path]) %> |
15 | <%= change[:times_changed] %> |
16 |
17 | <% count += 1 %>
18 | <% end %>
19 | <% end %>
20 |
21 |
22 | <% if @churn[:class_churn] %>
23 | Classes that change a lot in your project may be bad a sign.
24 |
25 |
26 | | File Path |
27 | Times Changed |
28 |
29 | <% count = 0 %>
30 | <% @churn[:class_churn].each do |change| %>
31 |
32 | | <%= link_to_filename(change['klass']['file']) %> <%= change['klass']['klass'] %> |
33 | <%= change['times_changed'] %> |
34 |
35 | <% count += 1 %>
36 | <% end %>
37 |
38 | <% end %>
39 |
40 | <% if @churn[:method_churn] %>
41 | Methods that change a lot in your project may be bad a sign.
42 |
43 |
44 | | File Path |
45 | Times Changed |
46 |
47 | <% count = 0 %>
48 | <% @churn[:method_churn].each do |change| %>
49 |
50 | | <%= link_to_filename(change['method']['file']) %> <%= change['method']['method'] %> |
51 | <%= change['times_changed'] %> |
52 |
53 | <% count += 1 %>
54 | <% end %>
55 |
56 | <% end %>
57 |
58 | <%= render_partial 'report_footer' %>
59 |
--------------------------------------------------------------------------------
/spec/metric_fu/formatter/yaml_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.formatter_require { "yaml" }
3 |
4 | describe MetricFu::Formatter::YAML do
5 | before do
6 | setup_fs
7 |
8 | config = MetricFu.configuration
9 |
10 | if config.mri?
11 | @metric1 = :cane
12 | else
13 | @metric1 = :stats
14 | config.templates_configuration do |c|
15 | c.syntax_highlighting = false
16 | end
17 | end
18 | allow(MetricFu::Metric.get_metric(@metric1)).to receive(:run_external).and_return("")
19 | @metric2 = :hotspots
20 | MetricFu.result.add(@metric1)
21 | MetricFu.result.add(@metric2)
22 | end
23 |
24 | context "In general" do
25 | it "creates a report yaml file" do
26 | expect {
27 | MetricFu::Formatter::YAML.new.finish
28 | }.to create_file("#{directory('base_directory')}/report.yml")
29 | end
30 | end
31 |
32 | context "given a custom output file" do
33 | before do
34 | @output = "customreport.yml"
35 | end
36 |
37 | it "creates a report yaml file to the custom output path" do
38 | expect {
39 | MetricFu::Formatter::YAML.new(output: @output).finish
40 | }.to create_file("#{directory('base_directory')}/customreport.yml")
41 | end
42 | end
43 |
44 | context "given a custom output stream" do
45 | before do
46 | @output = $stdout
47 | end
48 |
49 | it "creates a report yaml in the custom stream" do
50 | out = MetricFu::Utility.capture_output {
51 | MetricFu::Formatter::YAML.new(output: @output).finish
52 | }
53 | expect(out).to include ":#{@metric1}:"
54 | expect(out).to include ":#{@metric2}:"
55 | end
56 | end
57 |
58 | after do
59 | cleanup_fs
60 | end
61 | end
62 |
--------------------------------------------------------------------------------
/lib/metric_fu/templates/layout.html.erb:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | metrics
7 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
30 |
31 | <%= @html %>
32 |
33 |
34 | <% graph_engine = MetricFu.configuration.graph_engine.to_s %>
35 |
36 |
37 |
38 |
--------------------------------------------------------------------------------
/.rubocop_todo.yml:
--------------------------------------------------------------------------------
1 | # This configuration was generated by `rubocop --auto-gen-config`
2 | # on 2015-01-27 12:05:28 -0600 using RuboCop version 0.28.0.
3 | # The point is for the user to remove these configuration records
4 | # one by one as the offenses are removed from the code base.
5 | # Note that changes in the inspected code, or installation of new
6 | # versions of RuboCop, may require this file to be generated again.
7 |
8 | # Offense count: 2
9 | # Configuration parameters: AlignWith, SupportedStyles.
10 | Lint/EndAlignment:
11 | Enabled: false
12 |
13 | # Offense count: 2
14 | Lint/EnsureReturn:
15 | Enabled: false
16 |
17 | # Offense count: 1
18 | Lint/RescueException:
19 | Enabled: false
20 |
21 | # Offense count: 10
22 | Lint/ShadowingOuterLocalVariable:
23 | Enabled: false
24 |
25 | # Offense count: 1
26 | Lint/UselessAccessModifier:
27 | Enabled: false
28 |
29 | # Offense count: 27
30 | Lint/UselessAssignment:
31 | Enabled: false
32 |
33 | # Offense count: 44
34 | Metrics/AbcSize:
35 | Max: 56
36 |
37 | # Offense count: 393
38 | # Configuration parameters: AllowURI, URISchemes.
39 | Metrics/LineLength:
40 | Max: 709
41 |
42 | # Offense count: 3
43 | Metrics/PerceivedComplexity:
44 | Max: 13
45 |
46 | # Offense count: 4
47 | # Cop supports --auto-correct.
48 | # Configuration parameters: EnforcedStyle, SupportedStyles.
49 | Style/AndOr:
50 | Enabled: false
51 |
52 | # Offense count: 2
53 | Style/EmptyElse:
54 | Enabled: false
55 |
56 | # Offense count: 2
57 | # Configuration parameters: NamePrefix, NamePrefixBlacklist.
58 | Style/PredicateName:
59 | Enabled: false
60 |
61 | # Offense count: 1
62 | Style/RescueModifier:
63 | Enabled: false
64 |
65 | # Offense count: 4
66 | # Cop supports --auto-correct.
67 | # Configuration parameters: AllowAsExpressionSeparator.
68 | Style/Semicolon:
69 | Enabled: false
70 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/flay/grapher_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.metrics_require { "flay/grapher" }
3 |
4 | describe FlayGrapher do
5 | before :each do
6 | @flay_grapher = MetricFu::FlayGrapher.new
7 | MetricFu.configuration
8 | end
9 |
10 | it "should respond to flay_score and labels" do
11 | expect(@flay_grapher).to respond_to(:flay_score)
12 | expect(@flay_grapher).to respond_to(:labels)
13 | end
14 |
15 | describe "responding to #initialize" do
16 | it "should initialise flay_score and labels" do
17 | expect(@flay_grapher.flay_score).to eq([])
18 | expect(@flay_grapher.labels).to eq({})
19 | end
20 | end
21 |
22 | describe "responding to #get_metrics" do
23 | context "when metrics were not generated" do
24 | before(:each) do
25 | @metrics = FIXTURE.load_metric("metric_missing.yml")
26 | @date = "1/2"
27 | end
28 |
29 | it "should not push to flay_score" do
30 | expect(@flay_grapher.flay_score).not_to receive(:push)
31 | @flay_grapher.get_metrics(@metrics, @date)
32 | end
33 |
34 | it "should not update labels with the date" do
35 | expect(@flay_grapher.labels).not_to receive(:update)
36 | @flay_grapher.get_metrics(@metrics, @date)
37 | end
38 | end
39 |
40 | context "when metrics have been generated" do
41 | before(:each) do
42 | @metrics = FIXTURE.load_metric("20090630.yml")
43 | @date = "1/2"
44 | end
45 |
46 | it "should push to flay_score" do
47 | expect(@flay_grapher.flay_score).to receive(:push).with(476)
48 | @flay_grapher.get_metrics(@metrics, @date)
49 | end
50 |
51 | it "should update labels with the date" do
52 | expect(@flay_grapher.labels).to receive(:update).with(0 => "1/2")
53 | @flay_grapher.get_metrics(@metrics, @date)
54 | end
55 | end
56 | end
57 | end
58 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/rcov/grapher_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.metrics_require { "rcov/grapher" }
3 |
4 | describe RcovGrapher do
5 | before :each do
6 | @rcov_grapher = MetricFu::RcovGrapher.new
7 | MetricFu.configuration
8 | end
9 |
10 | it "should respond to rcov_percent and labels" do
11 | expect(@rcov_grapher).to respond_to(:rcov_percent)
12 | expect(@rcov_grapher).to respond_to(:labels)
13 | end
14 |
15 | describe "responding to #initialize" do
16 | it "should initialise rcov_percent and labels" do
17 | expect(@rcov_grapher.rcov_percent).to eq([])
18 | expect(@rcov_grapher.labels).to eq({})
19 | end
20 | end
21 |
22 | describe "responding to #get_metrics" do
23 | context "when metrics were not generated" do
24 | before(:each) do
25 | @metrics = FIXTURE.load_metric("metric_missing.yml")
26 | @date = "1/2"
27 | end
28 |
29 | it "should not push to rcov_percent" do
30 | expect(@rcov_grapher.rcov_percent).not_to receive(:push)
31 | @rcov_grapher.get_metrics(@metrics, @date)
32 | end
33 |
34 | it "should not update labels with the date" do
35 | expect(@rcov_grapher.labels).not_to receive(:update)
36 | @rcov_grapher.get_metrics(@metrics, @date)
37 | end
38 | end
39 |
40 | context "when metrics have been generated" do
41 | before(:each) do
42 | @metrics = FIXTURE.load_metric("20090630.yml")
43 | @date = "1/2"
44 | end
45 |
46 | it "should push to rcov_percent" do
47 | expect(@rcov_grapher.rcov_percent).to receive(:push).with(49.6)
48 | @rcov_grapher.get_metrics(@metrics, @date)
49 | end
50 |
51 | it "should update labels with the date" do
52 | expect(@rcov_grapher.labels).to receive(:update).with(0 => "1/2")
53 | @rcov_grapher.get_metrics(@metrics, @date)
54 | end
55 | end
56 | end
57 | end
58 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/roodi/grapher_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.metrics_require { "roodi/grapher" }
3 |
4 | describe RoodiGrapher do
5 | before :each do
6 | @roodi_grapher = MetricFu::RoodiGrapher.new
7 | MetricFu.configuration
8 | end
9 |
10 | it "should respond to roodi_count and labels" do
11 | expect(@roodi_grapher).to respond_to(:roodi_count)
12 | expect(@roodi_grapher).to respond_to(:labels)
13 | end
14 |
15 | describe "responding to #initialize" do
16 | it "should initialise roodi_count and labels" do
17 | expect(@roodi_grapher.roodi_count).to eq([])
18 | expect(@roodi_grapher.labels).to eq({})
19 | end
20 | end
21 |
22 | describe "responding to #get_metrics" do
23 | context "when metrics were not generated" do
24 | before(:each) do
25 | @metrics = FIXTURE.load_metric("metric_missing.yml")
26 | @date = "1/2"
27 | end
28 |
29 | it "should not push to roodi_count" do
30 | expect(@roodi_grapher.roodi_count).not_to receive(:push)
31 | @roodi_grapher.get_metrics(@metrics, @date)
32 | end
33 |
34 | it "should not update labels with the date" do
35 | expect(@roodi_grapher.labels).not_to receive(:update)
36 | @roodi_grapher.get_metrics(@metrics, @date)
37 | end
38 | end
39 |
40 | context "when metrics have been generated" do
41 | before(:each) do
42 | @metrics = FIXTURE.load_metric("20090630.yml")
43 | @date = "1/2"
44 | end
45 |
46 | it "should push to roodi_count" do
47 | expect(@roodi_grapher.roodi_count).to receive(:push).with(13)
48 | @roodi_grapher.get_metrics(@metrics, @date)
49 | end
50 |
51 | it "should update labels with the date" do
52 | expect(@roodi_grapher.labels).to receive(:update).with(0 => "1/2")
53 | @roodi_grapher.get_metrics(@metrics, @date)
54 | end
55 | end
56 | end
57 | end
58 |
--------------------------------------------------------------------------------
/lib/metric_fu/reporting/result.rb:
--------------------------------------------------------------------------------
1 | module MetricFu
2 | # MetricFu.result memoizes access to a Result object, that will be
3 | # used throughout the lifecycle of the MetricFu app.
4 | def self.result
5 | @result ||= Result.new
6 | end
7 |
8 | # = Result
9 | #
10 | # The Result class is responsible for one thing:
11 | #
12 | # It tracks the results generated by each metric used in this test run.
13 | class Result
14 | # Renders the result of the result_hash into a yaml serialization
15 | # ready for writing out to a file.
16 | #
17 | # @return YAML
18 | # A YAML object containing the results of the result generation
19 | # process
20 | def as_yaml
21 | result_hash.to_yaml
22 | end
23 |
24 | def per_file_data
25 | @per_file_data ||= Hash.new do |hash, filename|
26 | hash[filename] = Hash.new do |h, line|
27 | h[line] = Array.new
28 | end
29 | end
30 | end
31 |
32 | def result_hash #:nodoc:
33 | @result_hash ||= {}
34 | end
35 |
36 | # Adds a hash from a passed result, produced by one of the Generator
37 | # classes to the aggregate result_hash managed by this hash.
38 | #
39 | # @param result_type Hash
40 | # The hash to add to the aggregate result_hash
41 | def add(result_type)
42 | mf_debug "result requested #{result_type}"
43 | metric_options = metric_options_for_result_type(result_type)
44 | generator_class = MetricFu::Generator.get_generator(result_type)
45 | mf_debug "result class found #{generator_class}"
46 | generator = generator_class.new(metric_options)
47 |
48 | result_hash.merge!(generator.generate_result)
49 |
50 | generator.per_file_info(per_file_data) if generator.respond_to?(:per_file_info)
51 | end
52 |
53 | private
54 |
55 | def metric_options_for_result_type(result_type)
56 | MetricFu::Metric.get_metric(result_type).run_options
57 | end
58 | end
59 | end
60 |
--------------------------------------------------------------------------------
/spec/metric_fu/templates/configuration_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | require "shared/configured"
3 |
4 | describe MetricFu::Configuration, "for templates" do
5 | it_behaves_like "configured" do
6 | describe "when there is no CC_BUILD_ARTIFACTS environment variable" do
7 | before(:each) do
8 | ENV["CC_BUILD_ARTIFACTS"] = nil
9 | get_new_config
10 | end
11 |
12 | it "should set @template_directory to the lib/templates relative " + "to @metric_fu_root_directory" do
13 | expected_template_dir = MetricFu.root.join("lib", "templates").to_s
14 | expect(template_directory).to eq(expected_template_dir)
15 | end
16 |
17 | it "should set @template_class to MetricFu::Templates::MetricsTemplate by default" do
18 | expect(template_class).to eq(MetricFu::Templates::MetricsTemplate)
19 | end
20 |
21 | describe "when a templates configuration is given" do
22 | before do
23 | class DummyTemplate; end
24 |
25 | @config.templates_configuration do |config|
26 | config.template_class = DummyTemplate
27 | config.link_prefix = "http:/"
28 | config.syntax_highlighting = false
29 | config.darwin_txmt_protocol_no_thanks = false
30 | end
31 | end
32 |
33 | it "should set given template_class" do
34 | expect(template_class).to eq(DummyTemplate)
35 | end
36 |
37 | it "should set given link_prefix" do
38 | expect(MetricFu::Formatter::Templates.option("link_prefix")).to eq("http:/")
39 | end
40 |
41 | it "should set given darwin_txmt_protocol_no_thanks" do
42 | expect(MetricFu::Formatter::Templates.option("darwin_txmt_protocol_no_thanks")).to be_falsey
43 | end
44 |
45 | it "should set given syntax_highlighting" do
46 | expect(MetricFu::Formatter::Templates.option("syntax_highlighting")).to be_falsey
47 | end
48 | end
49 | end
50 | end
51 | end
52 |
--------------------------------------------------------------------------------
/lib/metric_fu/metrics/flog/report.html.erb:
--------------------------------------------------------------------------------
1 | Flog Results
2 | Flog measures code complexity.
3 |
4 | <%= render_partial 'graph', {:graph_name => 'flog'} %>
5 |
6 | Total Flog score for all methods: <%= round_to_tenths @flog[:total]%>
7 | Average Flog score for all methods: <%= round_to_tenths @flog[:average]%>
8 |
9 |
10 |
11 | | File |
12 | Total score |
13 | Methods |
14 | Average score |
15 | Highest score |
16 |
17 | <% @flog[:method_containers].each do |method_container| %>
18 |
19 | | <%= method_container[:path] %> |
20 | <%= round_to_tenths method_container[:total_score] %> |
21 | <%= method_container[:methods].size %> |
22 | <%= round_to_tenths method_container[:average_score] %> |
23 | <%= round_to_tenths method_container[:highest_score] %> |
24 |
25 | <% end %>
26 |
27 |
28 | <% @flog[:method_containers].each do |method_container| %>
29 | <%= link_to_filename(method_container[:path]) %>
30 |
31 | <% method_container[:methods].each do |full_method_name, method_info| %>
32 | <% path, line = method_info[:path].split(":") if method_info[:path] %>
33 | <%= link_to_filename(path, line, full_method_name) %>
34 | Total Score: <%= round_to_tenths method_info[:score]%>
35 |
36 |
37 | | Score |
38 | Operator |
39 |
40 | <% method_info[:operators].each do |operator, score| %>
41 |
42 | | <%= round_to_tenths score %> |
43 | <%= operator %> |
44 |
45 | <% end %>
46 |
47 | <% end %>
48 | <% end %>
49 |
50 | <%= render_partial 'report_footer' %>
51 |
--------------------------------------------------------------------------------
/lib/metric_fu/metrics/rcov/generator.rb:
--------------------------------------------------------------------------------
1 | MetricFu.lib_require { "utility" }
2 | MetricFu.lib_require { "calculate" }
3 | MetricFu.data_structures_require { "line_numbers" }
4 | require_relative "rcov_format_coverage"
5 | require_relative "rcov_line"
6 | require_relative "external_client"
7 |
8 | module MetricFu
9 | class RcovGenerator < MetricFu::Generator
10 | def self.metric
11 | :rcov
12 | end
13 |
14 | def emit
15 | if run_rcov?
16 | mf_debug "** Running the specs/tests in the [#{options[:environment]}] environment"
17 | mf_debug "** #{command}"
18 | `#{command}`
19 | end
20 | end
21 |
22 | def command
23 | @command ||= default_command
24 | end
25 |
26 | def command=(command)
27 | @command = command
28 | end
29 |
30 | def reset_output_location
31 | MetricFu::Utility.rm_rf(metric_directory, verbose: false)
32 | MetricFu::Utility.mkdir_p(metric_directory)
33 | end
34 |
35 | def default_command
36 | require "rake"
37 | reset_output_location
38 | test_files = FileList[*options[:test_files]].join(" ")
39 | rcov_opts = options[:rcov_opts].join(" ")
40 | %(RAILS_ENV=#{options[:environment]} rcov #{test_files} #{rcov_opts} >> #{default_output_file})
41 | end
42 |
43 | def analyze
44 | rcov_text = load_output
45 | formatter = MetricFu::RCovFormatCoverage.new(rcov_text)
46 | @rcov = formatter.to_h
47 | end
48 |
49 | def to_h
50 | {
51 | rcov: @rcov
52 | }
53 | end
54 |
55 | private
56 |
57 | # We never run rcov anymore
58 | def run_rcov?
59 | false
60 | end
61 |
62 | def load_output
63 | MetricFu::RCovTestCoverageClient.new(output_file).load
64 | end
65 |
66 | def output_file
67 | options.fetch(:external)
68 | end
69 |
70 | # Only used if run_rcov? is true
71 | def default_output_file
72 | output_file || File.join(metric_directory, "rcov.txt")
73 | end
74 | end
75 | end
76 |
--------------------------------------------------------------------------------
/lib/metric_fu/templates/css/buttons.css:
--------------------------------------------------------------------------------
1 | /* --------------------------------------------------------------
2 |
3 | buttons.css
4 | * Gives you some great CSS-only buttons.
5 |
6 | Created by Kevin Hale [particletree.com]
7 | * particletree.com/features/rediscovering-the-button-element
8 |
9 | See Readme.txt in this folder for instructions.
10 |
11 | -------------------------------------------------------------- */
12 |
13 | button {
14 | display:block;
15 | float:left;
16 | margin:0 0.583em 0.667em 0;
17 | padding:5px 10px 5px 7px; /* Links */
18 |
19 | border:1px solid #dedede;
20 | border-top:1px solid #eee;
21 | border-left:1px solid #eee;
22 |
23 | background-color:#f5f5f5;
24 | font-family:"Lucida Grande", Tahoma, Arial, Verdana, sans-serif;
25 | font-size:100%;
26 | line-height:130%;
27 | text-decoration:none;
28 | font-weight:bold;
29 | color:#565656;
30 | cursor:pointer;
31 | }
32 | button {
33 | width:auto;
34 | overflow:visible;
35 | padding:4px 10px 3px 7px; /* IE6 */
36 | }
37 | button[type] {
38 | padding:4px 10px 4px 7px; /* Firefox */
39 | line-height:17px; /* Safari */
40 | }
41 | *:first-child+html button[type] {
42 | padding:4px 10px 3px 7px; /* IE7 */
43 | }
44 | button img {
45 | margin:0 3px -3px 0 !important;
46 | padding:0;
47 | border:none;
48 | width:16px;
49 | height:16px;
50 | float:none;
51 | }
52 |
53 |
54 | /* Button colors
55 | -------------------------------------------------------------- */
56 |
57 | /* Standard */
58 | button:hover {
59 | background-color:#dff4ff;
60 | border:1px solid #c2e1ef;
61 | color:#336699;
62 | }
63 |
64 | /* Positive */
65 | body .positive {
66 | color:#529214;
67 | }
68 | button.positive:hover {
69 | background-color:#E6EFC2;
70 | border:1px solid #C6D880;
71 | color:#529214;
72 | }
73 |
74 | /* Negative */
75 | body .negative {
76 | color:#d12f19;
77 | }
78 | button.negative:hover {
79 | background:#fbe3e4;
80 | border:1px solid #fbc2c4;
81 | color:#d12f19;
82 | }
83 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/rails_best_practices/configuration_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | require "shared/configured"
3 |
4 | describe MetricFu::Configuration, "for rails_best_practices" do
5 | it_behaves_like "configured" do
6 | describe "if #rails? is true " do
7 | before(:each) do
8 | @config = MetricFu.configuration
9 | allow(@config).to receive(:rails?).and_return(true)
10 | @config.reset
11 | MetricFu.configure
12 | %w(rails_best_practices).each do |metric|
13 | load_metric metric
14 | end
15 | end
16 |
17 | describe "#set_graphs " do
18 | it "should set the graphs to include rails_best_practices" do
19 | expect(MetricFu::Metric.get_metric(:rails_best_practices).has_graph?).to be_truthy
20 | end
21 | end
22 |
23 | it "should default @rails_best_practices to { :silent => true }" do
24 | load_metric "rails_best_practices"
25 | rbp = MetricFu::MetricRailsBestPractices.new
26 | expect(rbp.run_options).to eq(exclude: [], silent: true)
27 | end
28 |
29 | it "can configure @rails_best_practices 'exclude' using the sugar" do
30 | load_metric "rails_best_practices"
31 | rbp = MetricFu::Metric.get_metric(:rails_best_practices)
32 | rbp.exclude = ["config/chef"]
33 | expect(rbp.run_options).to eq(
34 | exclude: ["config/chef"],
35 | silent: true
36 | )
37 |
38 | end
39 | end
40 |
41 | describe "if #rails? is false " do
42 | before(:each) do
43 | get_new_config
44 | allow(@config).to receive(:rails?).and_return(false)
45 | %w(rails_best_practices).each do |metric|
46 | load_metric metric
47 | end
48 | end
49 |
50 | it "should set the registered code_dirs to ['lib']" do
51 | expect(directory("code_dirs")).to eq(["lib"])
52 | end
53 | end
54 | end
55 | end
56 |
--------------------------------------------------------------------------------
/lib/metric_fu/cli/helper.rb:
--------------------------------------------------------------------------------
1 | require "metric_fu"
2 | require "metric_fu/cli/parser"
3 | MetricFu.lib_require { "run" }
4 | # see https://github.com/grosser/pru/blob/master/bin/pru
5 | module MetricFu
6 | module Cli
7 | def self.immediate_shutdown!
8 | exit(1)
9 | end
10 | def self.complete!
11 | exit(0)
12 | end
13 | class Helper
14 | def initialize
15 | @metric_fu = MetricFu::Run.new
16 | end
17 |
18 | def run(options = {})
19 | @metric_fu.run(options)
20 | complete
21 | end
22 |
23 | def version
24 | MetricFu::VERSION
25 | end
26 |
27 | def shutdown
28 | out "\nShutting down. Bye"
29 | MetricFu::Cli.immediate_shutdown!
30 | end
31 |
32 | def banner
33 | "MetricFu: A Fistful of code metrics"
34 | end
35 |
36 | def usage
37 | <<-EOS
38 | #{banner}
39 | Use --help for help
40 | EOS
41 | end
42 |
43 | def executable_name
44 | "metric_fu"
45 | end
46 |
47 | def metrics
48 | MetricFu::Metric.metrics.map(&:name).sort_by(&:to_s)
49 | end
50 |
51 | def process_options(argv = [])
52 | options = MetricFu::Cli::MicroOptParse::Parser.new do |p|
53 | p.banner = banner
54 | p.version = version
55 | p.option :run, "Run all metrics with defaults", default: true
56 | metrics.each do |metric|
57 | p.option metric.to_sym, "Enables or disables #{metric}", default: true # , :value_in_set => [true, false]
58 | end
59 | p.option :open, "Open report in browser (if supported by formatter)", default: true
60 | end.process!(argv)
61 | options
62 | end
63 |
64 | private
65 |
66 | def out(text)
67 | STDOUT.puts text
68 | end
69 |
70 | def error(text)
71 | STDERR.puts text
72 | end
73 |
74 | def complete
75 | out "all done"
76 | MetricFu::Cli.complete!
77 | end
78 | end
79 | end
80 | end
81 |
--------------------------------------------------------------------------------
/lib/metric_fu/utility.rb:
--------------------------------------------------------------------------------
1 | require "yaml"
2 | require "fileutils"
3 | module MetricFu
4 | module Utility
5 | module_function
6 |
7 | ESCAPE_CODES_PATTERN = Regexp.new('\e\[(?:\d;)?\d{1,2}m')
8 |
9 | # Removes non-ASCII characters
10 | def clean_ascii_text(text)
11 | if text.respond_to?(:encode)
12 | # avoids invalid multi-byte escape error
13 | ascii_text = text.encode("ASCII", invalid: :replace, undef: :replace, replace: "")
14 | # see http://www.ruby-forum.com/topic/183413
15 | pattern = Regexp.new('[\x80-\xff]', nil, "n")
16 | ascii_text.gsub(pattern, "")
17 | else
18 | text
19 | end
20 | end
21 |
22 | def stringify_keys(hash)
23 | result = {}
24 | hash.each do |key, value|
25 | result[key.to_s] = value
26 | end
27 | result
28 | end
29 |
30 | def strip_escape_codes(text)
31 | text.gsub(ESCAPE_CODES_PATTERN, "")
32 | end
33 |
34 | def rm_rf(*args)
35 | FileUtils.rm_rf(*args)
36 | end
37 |
38 | def mkdir_p(dir, **args)
39 | FileUtils.mkdir_p(dir, **args)
40 | end
41 |
42 | def glob(*args)
43 | Dir.glob(*args)
44 | end
45 |
46 | def load_yaml(file)
47 | YAML.load_file(file)
48 | end
49 |
50 | def binread(file)
51 | File.binread(file)
52 | end
53 |
54 | # From episode 029 of Ruby Tapas by Avdi
55 | # https://rubytapas.dpdcart.com/subscriber/post?id=88
56 | def capture_output(stream = STDOUT, &_block)
57 | old_stdout = stream.clone
58 | pipe_r, pipe_w = IO.pipe
59 | pipe_r.sync = true
60 | output = ""
61 | reader = Thread.new do
62 | begin
63 | loop do
64 | output << pipe_r.readpartial(1024)
65 | end
66 | rescue EOFError
67 | end
68 | end
69 | stream.reopen(pipe_w)
70 | yield
71 | ensure
72 | stream.reopen(old_stdout)
73 | pipe_w.close
74 | reader.join
75 | pipe_r.close
76 | return output
77 | end
78 | end
79 | end
80 |
--------------------------------------------------------------------------------
/lib/metric_fu/metrics/saikuro/report.html.erb:
--------------------------------------------------------------------------------
1 | Saikuro Results
2 | Saikuro analyzes ruby code for cyclomatic complexity.
3 |
4 | Analyzed Methods
5 |
6 |
7 | | Method Name |
8 | Complexity |
9 | # Lines |
10 |
11 | <% @saikuro[:methods].each do |method| %>
12 |
13 | | <%= method[:name] %> |
14 | <%= method[:complexity] %> |
15 | <%= method[:lines] %> |
16 |
17 | <% end %>
18 |
19 |
20 |
21 |
22 | Analyzed Classes
23 |
24 |
25 | | Class Name |
26 | Complexity |
27 | # Lines |
28 |
29 | <% @saikuro[:classes].each do |klass| %>
30 |
31 | | <%= klass[:name] %> |
32 | <%= klass[:complexity] %> |
33 | <%= klass[:lines] %> |
34 |
35 | <% end %>
36 |
37 |
38 |
39 | Analyzed Files
40 | <% @saikuro[:files].each do |file| %>
41 | <% file[:classes].each do |klass| %>
42 | <% if !klass[:methods].empty? %>
43 | <%=link_to_filename(file[:filename])%>
44 | Class : <%= klass[:class_name] %>
45 | Total complexity : <%= klass[:complexity] %>
46 | Total lines : <%= klass[:lines] %>
47 |
48 |
49 | | Method |
50 | Complexity |
51 | # Lines |
52 |
53 | <% klass[:methods].each do |method| %>
54 |
55 | |
56 | <%= method[:name] %>
57 | |
58 |
59 | <%= method[:complexity] %>
60 | |
61 |
62 | <%= method[:lines] %>
63 | |
64 |
65 | <% end %>
66 |
67 | <% end %>
68 | <% end %>
69 | <% end %>
70 |
71 | <%= render_partial 'report_footer' %>
72 |
--------------------------------------------------------------------------------
/lib/metric_fu/constantize.rb:
--------------------------------------------------------------------------------
1 | module MetricFu
2 | module Constantize
3 | # Copied from ActiveSupport and modified so as not to introduce a dependency.
4 | # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L220
5 | def constantize(camel_cased_word)
6 | tries ||= 2
7 | names = camel_cased_word.split("::")
8 | names.shift if names.empty? || names.first.empty?
9 |
10 | names.inject(Object) do |constant, name|
11 | if constant == Object
12 | constant.const_get(name)
13 | else
14 | candidate = constant.const_get(name)
15 | next candidate if constant.const_defined?(name, false)
16 | next candidate unless Object.const_defined?(name)
17 |
18 | # Go down the ancestors to check it it's owned
19 | # directly before we reach Object or the end of ancestors.
20 | constant = constant.ancestors.inject do |const, ancestor|
21 | break const if ancestor == Object
22 | break ancestor if ancestor.const_defined?(name, false)
23 | const
24 | end
25 |
26 | # owner is in Object, so raise
27 | constant.const_get(name, false)
28 | end
29 | end
30 | rescue NameError
31 | # May need to attempt to require the file and try again.
32 | begin
33 | require underscore(camel_cased_word)
34 | rescue LoadError => e
35 | mf_log e.message
36 | end
37 |
38 | if (tries -= 1).zero?
39 | raise
40 | else
41 | retry
42 | end
43 | end
44 |
45 | # Copied from active_support
46 | # https://github.com/rails/rails/blob/51cd6bb829c418c5fbf75de1dfbb177233b1b154/activesupport/lib/active_support/inflector/methods.rb#L88
47 | def underscore(camel_cased_word)
48 | word = camel_cased_word.to_s.dup
49 | word.gsub!(/::/, "/")
50 | word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
51 | word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
52 | word.tr!("-", "_")
53 | word.downcase!
54 | word
55 | end
56 | end
57 | end
58 |
--------------------------------------------------------------------------------
/lib/metric_fu/tasks/metric_fu.rake:
--------------------------------------------------------------------------------
1 | require "rake"
2 | require "metric_fu/run"
3 | namespace :metrics do
4 | def options_tip(task_name)
5 | "with options, for example: rake metrics:#{task_name}['cane: {abc_max: 81}']"
6 | end
7 | desc "Generate all metrics reports, or #{options_tip('all')}"
8 | task :all, [:options] do |_t, args|
9 | MetricFu.run(process_options(args.options))
10 | end
11 |
12 | desc "Run only specified ;-separated metrics, for example, metrics:only[cane;flog] or #{options_tip('only')}"
13 | task :only, [:metrics, :options] do |_t, args|
14 | requested_metrics = args.metrics.to_s.split(";").map(&:strip)
15 | enabled_metrics = MetricFu::Metric.enabled_metrics.map(&:name)
16 | metrics_to_run = enabled_metrics.select { |metric| requested_metrics.include?(metric.to_s) }
17 | MetricFu.run_only(metrics_to_run, process_options(args.options))
18 | end
19 |
20 | MetricFu::Metric.enabled_metrics.each do |metric|
21 | name = metric.name
22 | desc "Generate report for #{name}, or #{options_tip('cane')}"
23 | task name, [:options] do |_t, args|
24 | MetricFu.run_only(name, process_options(args.options))
25 | end
26 | end
27 |
28 | private
29 |
30 | # from https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/keys.rb
31 | class Hash
32 | # Destructively, recursively convert all keys to symbols, as long as they respond
33 | # to +to_sym+.
34 | def recursively_symbolize_keys!
35 | keys.each do |key|
36 | value = delete(key)
37 | new_key = key.intern # rescue
38 | self[new_key] = (value.is_a?(Hash) ? value.dup.recursively_symbolize_keys! : value)
39 | end
40 | self
41 | end
42 | end
43 |
44 | def process_options(options)
45 | return {} if options.nil? or options.empty?
46 | options = YAML.load(options)
47 | if options.is_a?(Hash)
48 | p "Got options #{options.recursively_symbolize_keys!.inspect}"
49 | options
50 | else
51 | raise "Invalid options #{options.inspect}, is a #{options.class}, should be a Hash"
52 | end
53 | end
54 | end
55 |
--------------------------------------------------------------------------------
/lib/metric_fu/metrics/hotspots/analysis/ranked_problem_location.rb:
--------------------------------------------------------------------------------
1 | MetricFu.lib_require { "errors/analysis_error" }
2 | MetricFu.metrics_require { "hotspots/analysis/problems" }
3 | module MetricFu
4 | class HotspotRankedProblemLocation
5 | MetricFu.data_structures_require { "location" }
6 | attr_reader :sub_table, :granularity
7 | def initialize(sub_table, granularity)
8 | @sub_table = sub_table
9 | @granularity = granularity
10 | end
11 |
12 | def to_hash
13 | {
14 | "location" => location.to_hash,
15 | "details" => MetricFu::Utility.stringify_keys(problems),
16 | }
17 | end
18 |
19 | # @todo redo as item,value, options = {}
20 | # Note that the other option for 'details' is :detailed (this isn't
21 | # at all clear from this method itself
22 | def problems
23 | @problems ||= MetricFu::HotspotProblems.new(sub_table).problems
24 | end
25 |
26 | def location
27 | @location ||= case granularity
28 | when :class then class_location
29 | when :method then method_location
30 | when :file then file_location
31 | else raise ArgumentError, "Item must be :class, :method, or :file"
32 | end
33 | end
34 |
35 | def file_path
36 | first_row.file_path
37 | end
38 |
39 | def class_name
40 | first_row.class_name
41 | end
42 |
43 | def method_name
44 | first_row.method_name
45 | end
46 |
47 | def file_location
48 | MetricFu::Location.get(file_path, nil, nil)
49 | end
50 |
51 | def method_location
52 | MetricFu::Location.get(file_path, class_name, method_name)
53 | end
54 |
55 | def class_location
56 | MetricFu::Location.get(file_path, class_name, nil)
57 | end
58 |
59 | def first_row
60 | assert_sub_table_has_data
61 | @first_row ||= sub_table[0]
62 | end
63 |
64 | def assert_sub_table_has_data
65 | if (sub_table.length == 0)
66 | raise MetricFu::AnalysisError, "The #{item} '#{value}' does not have any rows in the analysis table"
67 | end
68 | end
69 | end
70 | end
71 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/hotspots/generator_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.metrics_require { "hotspots/generator" }
3 |
4 | describe MetricFu::HotspotsGenerator do
5 | describe "analyze method" do
6 | it "should be empty on error" do
7 | hotspots = MetricFu::HotspotsGenerator.new
8 | hotspots.instance_variable_set(:@analyzer, nil)
9 | result = hotspots.analyze
10 | expect(result).to eq(files: [], classes: [], methods: [])
11 | end
12 |
13 | it "should put the changes into a hash" do
14 | hotspots = MetricFu::HotspotsGenerator.new
15 | hotspots.analyze
16 | result = hotspots.to_h[:hotspots]
17 | expected = HOTSPOT_DATA["generator_analysis.yml"]
18 | # ensure expected granularities
19 | expect(result.keys).to eq(expected.keys)
20 |
21 | # for each granularity's location details
22 | result.each do |granularity, location_details|
23 | # map 2d array for this granularity of [details, location]
24 | expected_result = expected.fetch(granularity).map { |ld| [ld.fetch("details"), ld.fetch("location")] }
25 | # verify all the location details for this granularity match elements of expected_result
26 | location_details.each do |location_detail|
27 | location = location_detail.fetch("location")
28 | details = location_detail.fetch("details")
29 | # get the location_detail array where the where the locations (second element) match
30 | expected_location_details = expected_result.rassoc(location)
31 | # get the details (first element) from the expected location_details array
32 | expected_details = expected_location_details[0]
33 | expect(details).to eq(expected_details)
34 | end
35 | end
36 | end
37 |
38 | # really testing the output of analyzed_problems#worst_items
39 | it "should return the worst item granularities: files, classes, methods" do
40 | hotspots = MetricFu::HotspotsGenerator.new
41 | yaml = HOTSPOT_DATA["generator.yml"]
42 | analyzer = HotspotAnalyzer.new(yaml)
43 | expect(hotspots.analyze.keys).to eq([:files, :classes, :methods])
44 | end
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/lib/metric_fu/reporting/graphs/graph.rb:
--------------------------------------------------------------------------------
1 | module MetricFu
2 | def self.graph
3 | @graph ||= Graph.new
4 | end
5 |
6 | class Graph
7 | attr_accessor :graphers
8 |
9 | def initialize
10 | self.graphers = []
11 | end
12 |
13 | def add(metric_name, _graph_engine, output_directory = MetricFu::Io::FileSystem.directory("output_directory"))
14 | grapher = MetricFu::Grapher.get_grapher(metric_name).
15 | new.tap { |g| g.output_directory = output_directory }
16 | graphers.push grapher
17 | rescue NameError => e
18 | mf_log "#{e.message} called in MetricFu::Graph.add with #{graph_type}"
19 | end
20 |
21 | def generate
22 | return if graphers.empty?
23 | mf_log "Generating graphs"
24 | generate_graphs_for_files
25 | graph!
26 | rescue NameError => e
27 | mf_log "#{e.message} called in MetricFu::Graph generate"
28 | end
29 |
30 | private
31 |
32 | def metric_files
33 | MetricFu::Utility.glob(
34 | File.join(MetricFu::Io::FileSystem.directory("data_directory"), "*.yml")
35 | ).sort
36 | end
37 |
38 | def generate_graphs_for_files
39 | metric_files.each do |metric_file|
40 | generate_graphs_for_file(metric_file)
41 | end
42 | end
43 |
44 | def generate_graphs_for_file(metric_file)
45 | mf_log "Generating graphs for #{metric_file}"
46 | date_parts = year_month_day_from_filename(metric_file)
47 | metrics = MetricFu::Utility.load_yaml(metric_file)
48 |
49 | build_graph(metrics, "#{date_parts[:m]}/#{date_parts[:d]}")
50 | rescue NameError => e
51 | mf_log "#{e.message} called in MetricFu::Graph.generate with #{metric_file}"
52 | end
53 |
54 | def build_graph(metrics, sortable_prefix)
55 | graphers.each do |grapher|
56 | grapher.get_metrics(metrics, sortable_prefix)
57 | end
58 | end
59 |
60 | def graph!
61 | graphers.each(&:graph!)
62 | end
63 |
64 | def year_month_day_from_filename(path_to_file_with_date)
65 | date = path_to_file_with_date.match(/\/(\d+).yml$/)[1]
66 | { y: date[0..3].to_i, m: date[4..5].to_i, d: date[6..7].to_i }
67 | end
68 | end
69 | end
70 |
--------------------------------------------------------------------------------
/lib/metric_fu/metrics/hotspots/hotspot_analyzer.rb:
--------------------------------------------------------------------------------
1 | require "yaml"
2 | MetricFu.metrics_require do
3 | [
4 | "hotspots/hotspot",
5 | "hotspots/analysis/analyzer_tables",
6 | "hotspots/analysis/analyzed_problems",
7 | "hotspots/analysis/rankings"
8 | ]
9 | end
10 |
11 | module MetricFu
12 | class HotspotAnalyzer
13 | COMMON_COLUMNS = %w{metric}
14 | GRANULARITIES = %w{file_path class_name method_name}
15 |
16 | def tool_analyzers
17 | MetricFu::Hotspot.analyzers
18 | end
19 |
20 | def initialize(result_hash)
21 | # we can't depend on the result
22 | # returning a parsed yaml file as a hash?
23 | result_hash = YAML::load(result_hash) if result_hash.is_a?(String)
24 | setup(result_hash)
25 | end
26 |
27 | def hotspots
28 | analyzed_problems.worst_items
29 | end
30 |
31 | def analyzed_problems
32 | @analyzed_problems = MetricFu::HotspotAnalyzedProblems.new(@rankings, @analyzer_tables)
33 | end
34 |
35 | private
36 |
37 | # TODO clarify each of these steps in setup
38 | # extract into its own method
39 | # remove unnecessary constants,
40 | # turn into methods
41 | def setup(result_hash)
42 | # TODO There is likely a clash that will happen between
43 | # column names eventually. We should probably auto-prefix
44 | # them (e.g. "roodi_problem")
45 | analyzer_columns = COMMON_COLUMNS + GRANULARITIES + tool_analyzers.map(&:columns).flatten
46 | # though the tool_analyzers aren't returned, they are processed in
47 | # various places here, then by the analyzer tables
48 | # then by the rankings
49 | # to ultimately generate the hotspots
50 | @analyzer_tables = MetricFu::AnalyzerTables.new(analyzer_columns)
51 | tool_analyzers.each do |analyzer|
52 | analyzer.generate_records(result_hash[analyzer.name], @analyzer_tables.table)
53 | end
54 | @analyzer_tables.generate_records
55 | @rankings = MetricFu::HotspotRankings.new(@analyzer_tables.tool_tables)
56 | @rankings.calculate_scores(tool_analyzers, GRANULARITIES)
57 | # TODO does it not need to return something here?
58 | analyzed_problems
59 | end
60 | end
61 | end
62 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/reek/grapher_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.metrics_require { "reek/grapher" }
3 |
4 | describe ReekGrapher do
5 | before :each do
6 | @reek_grapher = MetricFu::ReekGrapher.new
7 | MetricFu.configuration
8 | end
9 |
10 | it "should respond to reek_count and labels" do
11 | expect(@reek_grapher).to respond_to(:reek_count)
12 | expect(@reek_grapher).to respond_to(:labels)
13 | end
14 |
15 | describe "responding to #initialize" do
16 | it "should initialise reek_count and labels" do
17 | expect(@reek_grapher.reek_count).to eq({})
18 | expect(@reek_grapher.labels).to eq({})
19 | end
20 | end
21 |
22 | describe "responding to #get_metrics" do
23 | context "when metrics were not generated" do
24 | before(:each) do
25 | @metrics = FIXTURE.load_metric("metric_missing.yml")
26 | @date = "1/2"
27 | end
28 |
29 | it "should not set a hash of code smells to reek_count" do
30 | @reek_grapher.get_metrics(@metrics, @date)
31 | expect(@reek_grapher.reek_count).to eq({})
32 | end
33 |
34 | it "should not update labels with the date" do
35 | expect(@reek_grapher.labels).not_to receive(:update)
36 | @reek_grapher.get_metrics(@metrics, @date)
37 | end
38 | end
39 |
40 | context "when metrics have been generated" do
41 | before(:each) do
42 | @metrics = FIXTURE.load_metric("20090630.yml")
43 | @date = "1/2"
44 | end
45 |
46 | it "should set a hash of code smells to reek_count" do
47 | @reek_grapher.get_metrics(@metrics, @date)
48 | expect(@reek_grapher.reek_count).to eq(
49 | "Uncommunicative Name" => [27],
50 | "Feature Envy" => [20],
51 | "Utility Function" => [15],
52 | "Long Method" => [26],
53 | "Nested Iterators" => [12],
54 | "Control Couple" => [4],
55 | "Duplication" => [48],
56 | "Large Class" => [1]
57 | )
58 | end
59 |
60 | it "should update labels with the date" do
61 | expect(@reek_grapher.labels).to receive(:update).with(0 => "1/2")
62 | @reek_grapher.get_metrics(@metrics, @date)
63 | end
64 | end
65 | end
66 | end
67 |
--------------------------------------------------------------------------------
/lib/metric_fu/metrics/hotspots/report.html.erb:
--------------------------------------------------------------------------------
1 | Hotspot Results
2 | Meta analysis of your metrics to find hotspots in your code.
3 |
4 |
5 | <% if @hotspots.nil? || @hotspots.size.zero? %>
6 | No Hotspots were found.
7 | <% else %>
8 |
9 | <% granularities = %w[files classes methods] %>
10 |
11 |
12 | <% granularities.each do |granularity| %>
13 | |
14 | <%= granularity.to_s.capitalize %> |
15 | <% end %>
16 |
17 |
18 | <% hotspots = [] %>
19 | <% granularities.each_index do |index| %>
20 | <% granularity = granularities[index] %>
21 | <% hotspots << @hotspots[granularity] %>
22 | <% end %>
23 |
24 | <% hotspots_length = 0 %>
25 | <% columns = [0, 1, 2] %>
26 | <% while (hotspots_length < hotspots[0].length || hotspots_length < hotspots[1].length || hotspots_length < hotspots[2].length) do %>
27 |
28 | <% columns.each do |column| %>
29 | <% item = hotspots[column].length >= hotspots_length ? hotspots[column][hotspots_length] : nil %>
30 | <% if item %>
31 | <% location = item.fetch('location') %>
32 | <% file, line = location.fetch('file_name'), location.fetch('line_number') %>
33 |
34 |
35 | <%= display_location(location) %>
36 |
37 | <% unless per_file_data[file].empty? %>
38 | «
39 | ">annotate
40 | »
41 | <% end %>
42 |
43 |
44 | <% item.fetch('details').each do |metric, info| %>
45 | <%#= metric_link(@stat, metric, h(metric.to_s.capitalize)) + ": " + h(info)%>
46 | <%= "#{metric.to_s.capitalize}: #{info}" %>
47 | <% end %>
48 | |
49 | <% else %>
50 | |
51 | <% end %>
52 | <% end %>
53 | <% hotspots_length += 1 %>
54 |
55 | <% end %>
56 |
57 |
58 | <% end %>
59 |
60 | <%= render_partial 'report_footer' %>
61 |
--------------------------------------------------------------------------------
/lib/metric_fu/gem_run.rb:
--------------------------------------------------------------------------------
1 | # encoding: utf-8
2 | require "open3"
3 | require "shellwords"
4 | require "metric_fu"
5 | MetricFu.lib_require { "logger" }
6 | MetricFu.lib_require { "gem_version" }
7 | module MetricFu
8 | class GemRun
9 | attr_reader :output, :gem_name, :library_name, :version, :arguments
10 | def initialize(arguments = {})
11 | @gem_name = arguments.fetch(:gem_name)
12 | @library_name = arguments.fetch(:metric_name)
13 | @version = arguments.fetch(:version) { MetricFu::GemVersion.for(library_name) }
14 | args = arguments.fetch(:args)
15 | @arguments = args.respond_to?(:scan) ? Shellwords.shellwords(args) : args
16 | @output = ""
17 | @errors = []
18 | end
19 |
20 | def summary
21 | "RubyGem #{gem_name}, library #{library_name}, version #{version}, arguments #{arguments}"
22 | end
23 |
24 | def run
25 | @output = execute
26 | end
27 |
28 | def execute
29 | mf_debug "Running #{summary}"
30 | captured_output = ""
31 | captured_errors = ""
32 | thread = ""
33 | Open3.popen3("#{library_name}", *arguments) do |_stdin, stdout, stderr, wait_thr|
34 | captured_output << stdout.read.chomp
35 | captured_errors << stderr.read.chomp
36 | thread = wait_thr
37 | end
38 | rescue StandardError => run_error
39 | handle_run_error(run_error)
40 | rescue SystemExit => system_exit
41 | handle_system_exit(system_exit)
42 | ensure
43 | print_errors
44 | return captured_output, captured_errors, thread.value
45 | end
46 |
47 | def handle_run_error(run_error)
48 | @errors << "ERROR: #{run_error.inspect}"
49 | end
50 |
51 | def handle_system_exit(system_exit)
52 | status = system_exit.success? ? "SUCCESS" : "FAILURE"
53 | message = "#{status} with code #{system_exit.status}: " <<
54 | "#{system_exit.message}: #{system_exit.backtrace.inspect}"
55 | if status == "SUCCESS"
56 | mf_debug message
57 | else
58 | @errors << message
59 | end
60 | end
61 |
62 | def print_errors
63 | return if @errors.empty?
64 | STDERR.puts "ERRORS running #{summary}"
65 | @errors.each do |error|
66 | STDERR.puts "\t" << error
67 | end
68 | end
69 | end
70 | end
71 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/rails_best_practices/grapher_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.metrics_require { "rails_best_practices/grapher" }
3 |
4 | describe RailsBestPracticesGrapher do
5 | before :each do
6 | @stats_grapher = MetricFu::RailsBestPracticesGrapher.new
7 | MetricFu.configuration
8 | end
9 |
10 | it "should respond to rails_best_practices_count and labels" do
11 | expect(@stats_grapher).to respond_to(:rails_best_practices_count)
12 | expect(@stats_grapher).to respond_to(:labels)
13 | end
14 |
15 | describe "responding to #initialize" do
16 | it "should initialise rails_best_practices_count and labels" do
17 | expect(@stats_grapher.rails_best_practices_count).to eq([])
18 | expect(@stats_grapher.labels).to eq({})
19 | end
20 | end
21 |
22 | describe "responding to #get_metrics" do
23 | context "when metrics were not generated" do
24 | before(:each) do
25 | @metrics = FIXTURE.load_metric("metric_missing.yml")
26 | @date = "01022003"
27 | end
28 |
29 | it "should not push to rails_best_practices_count" do
30 | expect(@stats_grapher.rails_best_practices_count).not_to receive(:push)
31 | @stats_grapher.get_metrics(@metrics, @date)
32 | end
33 |
34 | it "should not update labels with the date" do
35 | expect(@stats_grapher.labels).not_to receive(:update)
36 | @stats_grapher.get_metrics(@metrics, @date)
37 | end
38 | end
39 |
40 | context "when metrics have been generated" do
41 | before(:each) do
42 | @metrics = FIXTURE.load_metric("20090630.yml")
43 | @date = "01022003"
44 | end
45 |
46 | it "should push to rails_best_practices_count" do
47 | expect(@stats_grapher.rails_best_practices_count).to receive(:push).with(2)
48 | @stats_grapher.get_metrics(@metrics, @date)
49 | end
50 |
51 | it "should push 0 to rails_best_practices_count when no problems were found" do
52 | expect(@stats_grapher.rails_best_practices_count).to receive(:push).with(0)
53 | @stats_grapher.get_metrics({ rails_best_practices: {} }, @date)
54 | end
55 |
56 | it "should update labels with the date" do
57 | expect(@stats_grapher.labels).to receive(:update).with(0 => "01022003")
58 | @stats_grapher.get_metrics(@metrics, @date)
59 | end
60 | end
61 | end
62 | end
63 |
--------------------------------------------------------------------------------
/DEV.md:
--------------------------------------------------------------------------------
1 | ## Contracted Interfaces
2 |
3 | ```ruby
4 | MetricFu.run_dir #=> Dir.pwd
5 | MetricFu.run_dir = 'some_path'
6 | MetricFu.run_path #=> Pathname(Dir.pwd)
7 | MetricFu.root_dir
8 | MetricFu.loader.load_user_configuration
9 | MetricFu.loader.loaded_files
10 | MetricFu.lib_require { 'utility' }
11 | MetricFu.lib_dir #=> metric_fu/lib
12 | MetricFu.lib_require('metrics') { 'flog/metric' }
13 | MetricFu.metrics_require {'flog/metric' }
14 | MetricFu.metrics_dir #=> metric_fu/lib/metrics
15 | MetricFu.formatter_require { 'html' }
16 | MetricFu.formatter_dir #=> metric_fu/lib/formatter
17 | MetricFu.reporting_require { 'result' }
18 | MetricFu.reporting_dir #=> metric_fu/lib/reporting
19 | MetricFu.logging_require { 'mf_debugger' }
20 | MetricFu.lib_require { 'logger' }
21 | MetricFu.logging_dir #=> metric_fu/lib/logging
22 | MetricFu.errors_require { 'analysis_error' }
23 | MetricFu.errors_dir #=> metric_fu/lib/errors
24 | MetricFu.data_structures_require { 'line_numbers' }
25 | MetricFu.data_structures_dir #=> metric_fu/lib/data_structures
26 | MetricFu.tasks_require { } # Doesn't work as expected. Don't use
27 | MetricFu.tasks_dir #=> metric_fu/lib/tasks
28 |
29 | MetricFu.configuration #=> MetricFu::Configuration.new
30 | MetricFu.configuration.configure_metrics # for each metric, yield to block or runs enable, activate
31 | MetricFu.configuration.configure_metric(:flog) do |metric|
32 | metric.run_options #=> metric.default_run_options.merge(metric.configured_run_options)
33 | metric.enable
34 | metric.enabled = true
35 | metric.activate
36 | metric.activated = true
37 | metric.name #=> :flog
38 | end
39 | ```
40 |
41 | ## Templates
42 |
43 | ```ruby
44 | # Given
45 | template = MetricFu::Templates::MetricsTemplate.new
46 |
47 | # Render _report_footer.html.erb partial:
48 |
49 | template.render_partial('report_footer')
50 |
51 | # Render _graph.html.erb partial and set a graph_name instance variable:
52 |
53 | template.render_partial 'graph', {:graph_name => 'reek'}
54 | ```
55 |
56 | ## Testing
57 |
58 | `bundle exec rspec`
59 |
60 | ## Forking
61 |
62 | ## Issues / Pull Requests
63 |
64 | * see [CONTRIBUTING](CONTRIBUTING.md)
65 |
66 | ## Building
67 |
68 | `rake build` or `rake install`
69 |
70 | ## Releasing
71 |
72 | 0. Run `rake usage_test` to make sure the examples are still valid
73 | 1. Update lib/metric_fu/version.rb
74 | 2. Update HISTORY.md
75 | 3. Update CONTRIBUTORS and erd per README in etc
76 | 3. `rake release`
77 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/stats/grapher_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.metrics_require { "stats/grapher" }
3 |
4 | describe StatsGrapher do
5 | before :each do
6 | @stats_grapher = MetricFu::StatsGrapher.new
7 | MetricFu.configuration
8 | end
9 |
10 | it "should respond to loc_counts and lot_counts and labels" do
11 | expect(@stats_grapher).to respond_to(:loc_counts)
12 | expect(@stats_grapher).to respond_to(:lot_counts)
13 | expect(@stats_grapher).to respond_to(:labels)
14 | end
15 |
16 | describe "responding to #initialize" do
17 | it "should initialise loc_counts and lot_counts and labels" do
18 | expect(@stats_grapher.loc_counts).to eq([])
19 | expect(@stats_grapher.lot_counts).to eq([])
20 | expect(@stats_grapher.labels).to eq({})
21 | end
22 | end
23 |
24 | describe "responding to #get_metrics" do
25 | context "when metrics were not generated" do
26 | before(:each) do
27 | @metrics = FIXTURE.load_metric("metric_missing.yml")
28 | @date = "01022003"
29 | end
30 |
31 | it "should not push to loc_counts" do
32 | expect(@stats_grapher.loc_counts).not_to receive(:push)
33 | @stats_grapher.get_metrics(@metrics, @date)
34 | end
35 |
36 | it "should not push to lot_counts" do
37 | expect(@stats_grapher.lot_counts).not_to receive(:push)
38 | @stats_grapher.get_metrics(@metrics, @date)
39 | end
40 |
41 | it "should not update labels with the date" do
42 | expect(@stats_grapher.labels).not_to receive(:update)
43 | @stats_grapher.get_metrics(@metrics, @date)
44 | end
45 | end
46 |
47 | context "when metrics have been generated" do
48 | before(:each) do
49 | @metrics = FIXTURE.load_metric("20090630.yml")
50 | @date = "01022003"
51 | end
52 |
53 | it "should push to loc_counts" do
54 | expect(@stats_grapher.loc_counts).to receive(:push).with(15935)
55 | @stats_grapher.get_metrics(@metrics, @date)
56 | end
57 |
58 | it "should push to lot_counts" do
59 | expect(@stats_grapher.lot_counts).to receive(:push).with(7438)
60 | @stats_grapher.get_metrics(@metrics, @date)
61 | end
62 |
63 | it "should update labels with the date" do
64 | expect(@stats_grapher.labels).to receive(:update).with(0 => "01022003")
65 | @stats_grapher.get_metrics(@metrics, @date)
66 | end
67 | end
68 | end
69 | end
70 |
--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | How to contribute:
2 |
3 | ## Bug reports / Issues
4 |
5 | * Is something broken or not working as expected? Check for an existing issue or [create a new one](https://github.com/metricfu/metric_fu/issues/new)
6 | * See [Quick guide to writing good bug reports](https://github.com/metricfu/metric_fu/wiki/Issues:-Quick-guide-to-writing-good-bug-reports)
7 | * IMPORTANT: Include the output of `metric_fu --debug-info`
8 |
9 | ## Code
10 |
11 | 1. Fork and clone the repo: `git clone git://github.com/yourghname/metric_fu.git && cd metric_fu`
12 | 2. Install the gem dependencies: `bundle install`
13 | 3. Make the changes you want and back them up with tests.
14 | * Run the tests (`bundle exec rspec`)
15 | * Run metric_fu on itself (`bundle exec ruby -Ilib bin/metric_fu`)
16 | 4. Update the HISTORY.md file with your changes and give yourself credit
17 | 5. Commit and create a pull request with details as to what has been changed and why
18 | * Use well-described, small (atomic) commits.
19 | * Include links to any relevant github issues.
20 | * *Don't* change the VERSION file.
21 | 6. Extra Credit: [Confirm it runs and tests pass on the rubies specified in the travis config](.travis.yml). I will otherwise confirm it runs on these.
22 |
23 | How I handle pull requests:
24 |
25 | * If the tests pass and the pull request looks good, I will merge it.
26 | * If the pull request needs to be changed,
27 | * you can change it by updating the branch you generated the pull request from
28 | * either by adding more commits, or
29 | * by force pushing to it
30 | * I can make any changes myself and manually merge the code in.
31 |
32 | ### Commit Messages
33 |
34 | * [A Note About Git Commit Messages](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
35 | * [http://stopwritingramblingcommitmessages.com/](http://stopwritingramblingcommitmessages.com/)
36 | * [ThoughtBot style guide](https://github.com/thoughtbot/guides/tree/master/style#git)
37 |
38 | ### About Pull Requests (PR's)
39 |
40 | * [All Your Open Source Code Are Belong To Us](http://www.benjaminfleischer.com/2013/07/30/all-your-open-source-code-are-belong-to-us/)
41 | * [Using Pull Requests](https://help.github.com/articles/using-pull-requests)
42 | * [Github pull requests made easy](http://www.element84.com/github-pull-requests-made-easy.html)
43 |
44 | ## Documentation
45 |
46 | * If relevant, you may update [the metric_fu website](https://github.com/metricfu/metricfu.github.com) in a separate pull request to that repo
47 | * Update the wiki
48 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/rcov/rcov_line_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | require "metric_fu/metrics/rcov/rcov_line"
3 |
4 | describe MetricFu::RCovLine do
5 | describe "#to_h" do
6 | it "returns a hash with the content and was_run" do
7 | rcov_line = RCovLine.new("some content", 1)
8 |
9 | expect(rcov_line.to_h).to eq(content: "some content", was_run: 1)
10 | end
11 | end
12 |
13 | describe "#covered?" do
14 | it "returns true if was_run is 1" do
15 | rcov_line = RCovLine.new("", 1)
16 |
17 | expect(rcov_line.covered?).to eq(true)
18 | end
19 |
20 | it "returns false if was_run is 0" do
21 | rcov_line = RCovLine.new("", 0)
22 |
23 | expect(rcov_line.covered?).to eq(false)
24 | end
25 |
26 | it "returns false if was_run is nil" do
27 | rcov_line = RCovLine.new("", nil)
28 |
29 | expect(rcov_line.covered?).to eq(false)
30 | end
31 | end
32 |
33 | describe "#missed?" do
34 | it "returns true if was_run is 0" do
35 | rcov_line = RCovLine.new("", 0)
36 |
37 | expect(rcov_line.missed?).to eq(true)
38 | end
39 |
40 | it "returns false if was_run is 1" do
41 | rcov_line = RCovLine.new("", 1)
42 |
43 | expect(rcov_line.missed?).to eq(false)
44 | end
45 |
46 | it "returns false if was_run is nil" do
47 | rcov_line = RCovLine.new("", nil)
48 |
49 | expect(rcov_line.missed?).to eq(false)
50 | end
51 | end
52 |
53 | describe "#ignored?" do
54 | it "returns true if was_run is nil" do
55 | rcov_line = RCovLine.new("", nil)
56 |
57 | expect(rcov_line.ignored?).to eq(true)
58 | end
59 |
60 | it "returns false if was_run is 1" do
61 | rcov_line = RCovLine.new("", 1)
62 |
63 | expect(rcov_line.ignored?).to eq(false)
64 | end
65 |
66 | it "returns false if was_run is 0" do
67 | rcov_line = RCovLine.new("", 0)
68 |
69 | expect(rcov_line.ignored?).to eq(false)
70 | end
71 | end
72 |
73 | describe "#css_class" do
74 | it "returns 'rcov_run' for an ignored line" do
75 | rcov_line = RCovLine.new("", nil)
76 | expect(rcov_line.css_class).to eq("rcov_run")
77 | end
78 |
79 | it "returns 'rcov_not_run' for a missed line" do
80 | rcov_line = RCovLine.new("", 0)
81 | expect(rcov_line.css_class).to eq("rcov_not_run")
82 | end
83 |
84 | it "returns 'rcov_run' for a covered line" do
85 | rcov_line = RCovLine.new("", 1)
86 | expect(rcov_line.css_class).to eq("rcov_run")
87 | end
88 | end
89 | end
90 |
--------------------------------------------------------------------------------
/lib/metric_fu/metrics/flog/grapher.rb:
--------------------------------------------------------------------------------
1 | MetricFu.reporting_require { "graphs/grapher" }
2 | module MetricFu
3 | class FlogGrapher < Grapher
4 | attr_accessor :flog_average, :labels, :top_five_percent_average
5 |
6 | def self.metric
7 | :flog
8 | end
9 |
10 | def initialize
11 | super
12 | @flog_average = []
13 | @labels = {}
14 | @top_five_percent_average = []
15 | end
16 |
17 | def get_metrics(metrics, date)
18 | if metrics && metrics[:flog]
19 | @top_five_percent_average.push(calc_top_five_percent_average(metrics))
20 | @flog_average.push(metrics[:flog][:average])
21 | @labels.update(@labels.size => date)
22 | end
23 | end
24 |
25 | def title
26 | "Flog: code complexity"
27 | end
28 |
29 | def data
30 | [
31 | ["average", @flog_average.join(",")],
32 | ["top 5% average", @top_five_percent_average.join(",")]
33 | ]
34 | end
35 |
36 | def output_filename
37 | "flog.js"
38 | end
39 |
40 | private
41 |
42 | def calc_top_five_percent_average(metrics)
43 | return calc_top_five_percent_average_legacy(metrics) if metrics[:flog][:pages]
44 |
45 | method_scores = metrics[:flog][:method_containers].inject([]) do |method_scores, container|
46 | method_scores += container[:methods].values.map { |v| v[:score] }
47 | end
48 | method_scores.sort!.reverse!
49 |
50 | number_of_methods_that_is_five_percent = (method_scores.size * 0.05).ceil
51 |
52 | total_for_five_percent =
53 | method_scores[0...number_of_methods_that_is_five_percent].inject(0) { |total, score| total += score }
54 | if number_of_methods_that_is_five_percent == 0
55 | 0.0
56 | else
57 | total_for_five_percent / number_of_methods_that_is_five_percent.to_f
58 | end
59 | end
60 |
61 | def calc_top_five_percent_average_legacy(metrics)
62 | methods = metrics[:flog][:pages].inject([]) { |methods, page| methods << page[:scanned_methods] }
63 | methods.flatten!
64 | methods = methods.sort_by { |method| method[:score] }.reverse
65 |
66 | number_of_methods_that_is_five_percent = (methods.size * 0.05).ceil
67 |
68 | total_for_five_percent =
69 | methods[0...number_of_methods_that_is_five_percent].inject(0) { |total, method| total += method[:score] }
70 | if number_of_methods_that_is_five_percent == 0
71 | 0.0
72 | else
73 | total_for_five_percent / number_of_methods_that_is_five_percent.to_f
74 | end
75 | end
76 | end
77 | end
78 |
--------------------------------------------------------------------------------
/spec/metric_fu/metrics/saikuro/generator_spec.rb:
--------------------------------------------------------------------------------
1 | require "spec_helper"
2 | MetricFu.metrics_require { "saikuro/generator" }
3 |
4 | describe MetricFu::SaikuroGenerator do
5 | STUB_TEST_DATA = lambda do |generator|
6 | # set test data dir; ensure it doesn't get cleared
7 | def generator.metric_directory
8 | FIXTURE.fixtures_path.join("saikuro").to_s
9 | end
10 | def generator.clear_scratch_files!
11 | # no-op
12 | end
13 | end
14 | describe "to_h method" do
15 | before do
16 | options = {}
17 | saikuro = MetricFu::SaikuroGenerator.new(options)
18 | STUB_TEST_DATA[saikuro]
19 |
20 | saikuro.analyze
21 | @output = saikuro.to_h
22 | end
23 |
24 | it "should find the filename of a file" do
25 | expect(@output[:saikuro][:files].first[:filename]).to eq("app/controllers/users_controller.rb")
26 | end
27 |
28 | it "should find the name of the classes" do
29 | expect(@output[:saikuro][:classes].first[:name]).to eq("UsersController")
30 | expect(@output[:saikuro][:classes][1][:name]).to eq("SessionsController")
31 | end
32 |
33 | it "should put the most complex method first" do
34 | expect(@output[:saikuro][:methods].first[:name]).to eq("UsersController#create")
35 | expect(@output[:saikuro][:methods].first[:complexity]).to eq(4)
36 | end
37 |
38 | it "should find the complexity of a method" do
39 | expect(@output[:saikuro][:methods].first[:complexity]).to eq(4)
40 | end
41 |
42 | it "should find the lines of a method" do
43 | expect(@output[:saikuro][:methods].first[:lines]).to eq(15)
44 | end
45 | end
46 |
47 | describe "per_file_info method" do
48 | before :all do
49 | options = {}
50 | @saikuro = MetricFu::SaikuroGenerator.new(options)
51 | STUB_TEST_DATA[@saikuro]
52 | @saikuro.analyze
53 | @output = @saikuro.to_h
54 | end
55 |
56 | it "doesn't try to get information if the file does not exist" do
57 | expect(@saikuro).to receive(:file_not_exists?).at_least(:once).and_return(true)
58 | @saikuro.per_file_info("ignore_me")
59 | end
60 | end
61 |
62 | describe MetricFu::SaikuroScratchFile do
63 | describe "getting elements from a Saikuro result file" do
64 | it "should parse nested START/END sections" do
65 | path = FIXTURE.fixtures_path.join("saikuro_sfiles", "thing.rb_cyclo.html").to_s
66 | sfile = MetricFu::SaikuroScratchFile.new path
67 | expect(sfile.elements.map(&:complexity).sort).to eql(["0", "0", "2"])
68 | end
69 | end
70 | end
71 | end
72 |
--------------------------------------------------------------------------------