metric_fu 4.3.1 → 4.4.0

data/lib/metric_fu/metrics/saikuro/saikuro.rb

@@ -1,12 +1,17 @@
 module MetricFu
 
   class Saikuro < Generator
+
+    def self.metric
+      :saikuro
+    end
+
     def emit
-      options_string = MetricFu.saikuro.inject("") do |options, option|
+      options_string = options.inject("") do |options, option|
         option[0] == :input_directory ? options : options + "--#{option.join(' ')} "
       end
 
-      MetricFu.saikuro[:input_directory].each do |input_dir|
+      options[:input_directory].each do |input_dir|
         options_string += "--input_directory #{input_dir} "
       end
 
@@ -16,7 +21,7 @@ module MetricFu
     end
 
     def format_directories
-      dirs = MetricFu.saikuro[:input_directory].join(" | ")
+      dirs = options[:input_directory].join(" | ")
       "\"#{dirs}\""
     end
 

data/lib/metric_fu/metrics/stats/init.rb

@@ -1,7 +1,30 @@
-MetricFu::Configuration.run do |config|
-  if config.rails?
-    config.add_metric(:stats)
-    config.add_graph(:stats)
-    config.configure_metric(:stats,{})
+module MetricFu
+  class MetricStats < Metric
+
+    def name
+      :stats
+    end
+
+    def default_run_options
+      {
+        # returns a list of directories that contains the glob of files that have the file_pattern in the file names
+        :additional_test_directories => [{glob_pattern: File.join('.','spec','**','*_spec.rb'), file_pattern: 'spec'}],
+        :additional_app_directories  => [{glob_pattern: File.join('.','engines','**','*.rb'), file_pattern: ''}],
+      }
+    end
+
+    def has_graph?
+      true
+    end
+
+    def enable
+      super
+    end
+
+    def activate
+      activate_library 'code_metrics'
+      super
+    end
+
   end
 end

data/lib/metric_fu/metrics/stats/stats.rb

@@ -1,16 +1,20 @@
 module MetricFu
 
-  class Stats < Generator
+  class StatsGenerator < Generator
+
+    def self.metric
+      :stats
+    end
 
     def emit
-      command = %Q(mf-stats > #{metric_directory + '/stats.txt'})
-      mf_debug "** #{command}"
-      @output = `#{command}`
+      require 'code_metrics/statistics'
+      @output = MfDebugger::Logger.capture_output do
+        CodeMetrics::Statistics.new(*dirs).to_s
+      end
     end
 
     def analyze
-      output = File.open(metric_directory + '/stats.txt').read
-      lines = remove_noise(output).compact
+      lines = remove_noise(@output).compact
 
       @stats = {}
 
@@ -57,5 +61,19 @@ module MetricFu
       end
     end
 
+    # @return [Array<[ 'Acceptance specs', 'spec/acceptance' ]>]
+    def dirs
+      require 'code_metrics/stats_directories'
+      require 'code_metrics/statistics'
+      stats_dirs = CodeMetrics::StatsDirectories.new
+      options.fetch(:additional_test_directories).each do |option|
+        stats_dirs.add_test_directories(option.fetch(:glob_pattern), option.fetch(:file_pattern))
+      end
+      options.fetch(:additional_app_directories).each do |option|
+        stats_dirs.add_directories(option.fetch(:glob_pattern), option.fetch(:file_pattern))
+      end
+      stats_dirs.directories
+    end
+
   end
 end

data/lib/metric_fu/metrics/stats/template_awesome/stats.html.erb

@@ -1,4 +1,4 @@
-<h3>Rake Stats  Results</h3>
+<h3>Lines of Code/Tests Metric Results</h3>
 
 <% graph_name = 'stats' %>
 <% if MetricFu.configuration.graph_engine == :gchart %>
@@ -9,7 +9,7 @@
 <% end %>
 
 
-<p>Rails rake stats results.</p>
+<p>Lines of Code/Tests Metrics Results</p>
 <table>
   <tr>
     <th>Lines of Code</th>

data/lib/metric_fu/parser_ext.rb

@@ -0,0 +1,15 @@
+# For Flog
+# TODO: Do we still need this?
+require 'ruby_parser'
+class RubyParser
+  alias_method :original_process, :process
+  def process(s,f,t)
+    original_process(s,f,t)
+  rescue => e
+    if e.message =~ /wrong number of arguments/
+      original_process(s,f)
+    else
+      raise
+    end
+  end
+end

data/lib/metric_fu/reporting/graphs/engines/gchart.rb

@@ -58,7 +58,7 @@ module MetricFu
   class Grapher
 
     def self.require_graphing_gem
-      if MetricFu.graph_engine == :gchart
+      if MetricFu.configuration.graph_engine == :gchart
         require 'gchart'
         include MetricFu::GchartGrapher
       end

data/lib/metric_fu/reporting/graphs/engines/init.rb

@@ -1,5 +1,19 @@
-MetricFu::Configuration.run do |config|
-  config.add_graph_engine(:bluff)
-  config.add_graph_engine(:gchart)
-  config.configure_graph_engine(:bluff) # can be :bluff or :gchart
+module MetricFu
+  class GraphEngine
+
+    attr_accessor :graph_engines, :graph_engine
+    def initialize
+      @graph_engines = [:bluff, :gchart]
+      @graph_engine = :bluff
+    end
+
+    def add_graph_engine(graph_engine)
+      self.graph_engines = (graph_engines << graph_engine).uniq
+    end
+
+    def configure_graph_engine(graph_engine)
+      self.graph_engine = graph_engine
+    end
+
+  end
 end

data/lib/metric_fu/reporting/graphs/grapher.rb

@@ -8,7 +8,7 @@ module MetricFu
     end
 
     def output_directory
-      @output_directory || MetricFu.output_directory
+      @output_directory || MetricFu::Io::FileSystem.directory('output_directory')
     end
 
     def self.require_graphing_gem

data/lib/metric_fu/reporting/result.rb

@@ -38,14 +38,21 @@ module MetricFu
     #   The hash to add to the aggregate result_hash
     def add(result_type)
       mf_debug "result requested #{result_type}"
-      clazz = MetricFu.const_get(result_type.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase })
-      mf_debug "result class found #{clazz}"
-      metric_options = MetricFu.send(result_type)
-      inst = clazz.new(metric_options)
+      metric_options = metric_options_for_result_type(result_type)
+      generator_class =  MetricFu::Generator.get_generator(result_type)
+      mf_debug "result class found #{generator_class}"
+      generator = generator_class.new(metric_options)
 
-      result_hash.merge!(inst.generate_result)
+      result_hash.merge!(generator.generate_result)
 
-      inst.per_file_info(per_file_data) if inst.respond_to?(:per_file_info)
+      generator.per_file_info(per_file_data) if generator.respond_to?(:per_file_info)
     end
+
+    private
+
+    def metric_options_for_result_type(result_type)
+      MetricFu::Metric.get_metric(result_type).run_options
+    end
+
   end
 end

data/lib/metric_fu/reporting/templates/awesome/awesome_template.rb

@@ -91,7 +91,7 @@ class AwesomeTemplate < MetricFu::Template
           out << "&nbsp;"
         end
         out << "</td>"
-        if MetricFu.configuration.syntax_highlighting
+        if MetricFu::Formatter::Templates.option('syntax_highlighting')
           line_for_display = convert_ruby_to_html(line, line_number)
         else
           line_for_display = "<a name='n#{line_number}' href='n#{line_number}'>#{line_number}</a>#{line}"

data/lib/metric_fu/run.rb

@@ -11,10 +11,8 @@ module MetricFu
       display_results if options[:open]
     end
 
-    # ensure :hotspots runs last
-    def report_metrics(metrics=MetricFu.metrics)
-      MetricFu.configuration.metrics.sort_by! {|x| x == :hotspots ? 1 : 0 }
-      MetricFu.configuration.metrics
+    def report_metrics(metrics=MetricFu::Metric.enabled_metrics)
+      metrics.map(&:name)
     end
     def measure
       reporter.start
@@ -45,24 +43,23 @@ module MetricFu
           mf_debug "using metric #{metric}"
         else
           mf_debug "disabling metric #{metric}"
-          MetricFu.configuration.metrics -= [ metric ]
-          MetricFu.configuration.graphs -= [ metric ]
-          mf_debug "active metrics are #{MetricFu.configuration.metrics.inspect}"
+          MetricFu::Metric.get_metric(metric).enabled = false
+          mf_debug "active metrics are #{MetricFu::Metric.enabled_metrics.inspect}"
         end
       end
     end
     def configure_formatters(options)
       # Configure from command line if any.
       if options[:format]
-        MetricFu.formatters.clear # Command-line format takes precedence.
+        MetricFu.configuration.formatters.clear # Command-line format takes precedence.
         Array(options[:format]).each do |format, o|
-          MetricFu.configuration.add_formatter(format, o)
+          MetricFu.configuration.configure_formatter(format, o)
         end
       end
       # If no formatters specified, use defaults.
       if MetricFu.configuration.formatters.empty?
         Array(MetricFu::Formatter::DEFAULT).each do |format, o|
-          MetricFu.configuration.add_formatter(format, o)
+          MetricFu.configuration.configure_formatter(format, o)
         end
       end
     end

data/lib/metric_fu/sexp_ext.rb

@@ -0,0 +1,11 @@
+# until https://github.com/flyerhzm/code_analyzer/pull/4 is merged and released
+# see https://github.com/metricfu/metric_fu/issues/123
+require 'code_analyzer'
+class Sexp
+  begin
+    alias_method :block_type, :block
+    undef :block
+  rescue NameError
+    # we're a-okay
+  end
+end

data/lib/metric_fu/version.rb

@@ -1,3 +1,3 @@
 module MetricFu
-  VERSION = "4.3.1"
+  VERSION = "4.4.0"
 end

data/metric_fu.gemspec

@@ -1,39 +1,42 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
 require 'metric_fu/version'
-require 'metric_fu_requires'
 
 Gem::Specification.new do |s|
   s.name        = "metric_fu"
-  s.platform    = Gem::Platform::RUBY
-  s.version     = MetricFu::VERSION
+  s.homepage    = "https://github.com/metricfu/metric_fu"
   s.summary     = "A fistful of code metrics, with awesome templates and graphs"
+  s.description = "Code metrics from Flog, Flay, Saikuro, Churn, Reek, Roodi, Code Statistics, and Rails Best Practices. (and optionally RCov)"
   s.email       = "github@benjaminfleischer.com"
-  s.homepage    = "https://github.com/metricfu/metric_fu"
-  s.description = "Code metrics from Flog, Flay, Saikuro, Churn, Reek, Roodi, Rails' stats task and Rails Best Practices, and optionally RCov"
-  s.authors     = ["Jake Scruggs", "Sean Soper", "Andre Arko", "Petrik de Heus", "Grant McInnes", "Nick Quaranto", "Édouard Brière", "Carl Youngblood", "Richard Huang", "Dan Mayer", "Benjamin Fleischer"]
-  s.rubyforge_project = 'metric_fu'
-  s.required_ruby_version     = ">= 1.8.7"
-  s.required_rubygems_version = ">= 1.3.6"
-  s.files              = `git ls-files`.split($\)
-  s.test_files         =  s.files.grep(%r{^(test|spec|features)/})
-  s.default_executable = %q{metric_fu}
-  s.executables        =  s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  s.license     = 'MIT'
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["HISTORY.md", "CONTRIBUTING.md", "TODO.md", "MIT-LICENSE"]
-  s.rdoc_options = ["--main", "README.md"]
+  s.authors     = File.readlines('AUTHORS').map(&:strip)
+
+  s.rubyforge_project           = 'metric_fu'
+  s.license                     = 'MIT'
+  s.platform                    = Gem::Platform::RUBY
+  s.version                     = MetricFu::VERSION
+  s.required_ruby_version       = ">= 1.9.0"
+  s.required_rubygems_version   = ">= 1.3.6"
+
+  s.files                       = `git ls-files`.split($\)
+  s.test_files                  =  s.files.grep(%r{^(test|spec|features)/})
+  s.default_executable          = %q{metric_fu}
+  s.executables                 =  s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.require_paths               = ["lib"]
+
+  s.has_rdoc                    = true
+  s.extra_rdoc_files            = ["HISTORY.md", "CONTRIBUTING.md", "TODO.md", "MIT-LICENSE"]
+  s.rdoc_options                = ["--main", "README.md"]
 
   # metric dependencies
   s.add_runtime_dependency 'flay',                  ['~> 2.0.1']
   s.add_runtime_dependency 'churn',                 ['~> 0.0.28']
-  s.add_runtime_dependency 'flog',                  ['~> 3.2.2']
+  s.add_runtime_dependency 'flog',                  ['~> 4.1.1']
   s.add_runtime_dependency 'reek',                  ['~> 1.3.1']
   s.add_runtime_dependency 'cane',                  ['~> 2.5.2']
-  s.add_runtime_dependency 'rails_best_practices',  ['~> 1.13.2']
+  s.add_runtime_dependency 'rails_best_practices',  ['>= 1.14.1', '~> 1.14']
   s.add_runtime_dependency 'metric_fu-Saikuro',     ['>= 1.1.1.0']
   s.add_runtime_dependency 'metric_fu-roodi',       ['>= 2.2.1']
+  s.add_runtime_dependency 'code_metrics',          ['~> 0.1']
 
   # other dependencies
   # ruby version identification

data/spec/cli/helper_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 require 'metric_fu/cli/helper'
-MetricFu.run_rcov
+MetricFu.configuration.configure_metric(:rcov) do |rcov|
+  rcov.enabled = true
+end
+MetricFu.configure
 
 describe MetricFu::Cli::Helper do
 
@@ -55,25 +58,11 @@ describe MetricFu::Cli::Helper do
     end
 
     if MetricFu.configuration.mri?
-      context "on Ruby 1.8.7" do
-
-        before { helper.stub(:ruby).and_return("1.8.7") }
 
-        it "disables rails_best_practices" do
-          defaults[:rails_best_practices].should be_false
-        end
-
-      end
-
-      context "on Ruby 1.9" do
-
-        before { helper.stub(:ruby).and_return("1.9.3") }
-
-        xit "enables Rails Best Practices" do
+        it "enables Rails Best Practices" do
           defaults[:rails_best_practices].should be_true
         end
 
-      end
     end
 
   end

data/spec/metric_fu/configuration_spec.rb

@@ -6,34 +6,42 @@ describe MetricFu::Configuration do
     ENV['CC_BUILD_ARTIFACTS'] = nil
     @config = MetricFu.configuration
     @config.reset
+    MetricFu.configuration.configure_metric(:rcov) do |rcov|
+      rcov.enabled = true
+    end
     MetricFu.configure
-    MetricFu.run_rcov
-    @config.stub :create_directories # no need to create directories for the tests
+    mri_only_metrics = MetricFu.mri_only_metrics.reject {|metric| MetricFu::Metric.get_metric(metric).enabled }
+    MetricFu.stub(:mri_only_metrics).and_return(mri_only_metrics)
+    MetricFu::Io::FileSystem.stub(:create_directories) # no need to create directories for the tests
     @config
   end
 
+  def directory(name)
+    MetricFu::Io::FileSystem.directory(name)
+  end
+
   def base_directory
-    @config.send(:base_directory)
+    directory('base_directory')
   end
 
   def output_directory
-    @config.send(:output_directory)
+    directory('output_directory')
   end
 
   def scratch_directory
-    @config.send(:scratch_directory)
+    directory('scratch_directory')
   end
 
   def template_directory
-    @config.send(:template_directory)
+    directory('template_directory')
   end
 
   def template_class
-    @config.send(:template_class)
+    MetricFu::Formatter::Templates.option('template_class')
   end
 
   def metric_fu_root
-    @config.send(:metric_fu_root_directory)
+    directory('root_directory')
   end
   def load_metric(metric)
     load File.join(MetricFu.metrics_dir, metric, 'init.rb')
@@ -97,27 +105,31 @@ describe MetricFu::Configuration do
 
       it 'should set @flay to {:dirs_to_flay => @code_dirs}' do
         load_metric 'flay'
-        @config.send(:flay).
-                should == {:dirs_to_flay => ['lib'], :filetypes=>["rb"]}
+        expect(MetricFu::Metric.get_metric(:flay).run_options).to eq(
+                {:dirs_to_flay => ['lib'], :filetypes=>["rb"], :minimum_score=>nil}
+        )
       end
 
       it 'should set @reek to {:dirs_to_reek => @code_dirs}' do
         load_metric 'reek'
-        @config.send(:reek).
-                should == {:config_file_pattern=>nil, :dirs_to_reek => ['lib']}
+        expect(MetricFu::Metric.get_metric(:reek).run_options).to eq(
+                {:config_file_pattern=>nil, :dirs_to_reek => ['lib']}
+        )
       end
 
       it 'should set @roodi to {:dirs_to_roodi => @code_dirs}' do
         load_metric 'roodi'
-        @config.send(:roodi).
-                should == { :dirs_to_roodi => MetricFu.code_dirs,
-                    :roodi_config => "#{MetricFu.root_dir}/config/roodi_config.yml"}
+        expect(MetricFu::Metric.get_metric(:roodi).run_options).to eq(
+                { :dirs_to_roodi => directory('code_dirs'),
+                    :roodi_config => "#{directory('root_directory')}/config/roodi_config.yml"}
+                )
       end
 
       it 'should set @churn to {}' do
         load_metric 'churn'
-        @config.send(:churn).
-                should == { :start_date => %q("1 year ago"), :minimum_churn_count => 10}
+        expect(MetricFu::Metric.get_metric(:churn).run_options).to eq(
+                { :start_date => %q("1 year ago"), :minimum_churn_count => 10}
+        )
       end
 
 
@@ -134,8 +146,8 @@ describe MetricFu::Configuration do
                               "-Ispec"
                             ]) do
         load_metric 'rcov'
-        @config.send(:rcov).
-                should ==  { :environment => 'test',
+        expect(MetricFu::Metric.get_metric(:rcov).run_options).to eq(
+                { :environment => 'test',
                             :test_files =>  Dir['{spec,test}/**/*_{spec,test}.rb'],
                             :rcov_opts => [
                               "--sort coverage",
@@ -148,6 +160,7 @@ describe MetricFu::Configuration do
                               "-Ispec"
                             ],
                             :external => nil}
+        )
       end
 
       it 'should set @saikuro to { :output_directory => @scratch_directory + "/saikuro",
@@ -158,33 +171,39 @@ describe MetricFu::Configuration do
                                    :error_cyclo => "7",
                                    :formater => "text" }' do
         load_metric 'saikuro'
-        @config.send(:saikuro).
-                should ==  { :output_directory => "#{scratch_directory}/saikuro",
+        expect(MetricFu::Metric.get_metric(:saikuro).run_options).to eq(
+                { :output_directory => "#{scratch_directory}/saikuro",
                       :input_directory => ['lib'],
                       :cyclo => "",
                       :filter_cyclo => "0",
                       :warn_cyclo => "5",
                       :error_cyclo => "7",
                       :formater => "text"}
+                      )
       end
 
       if MetricFu.configuration.mri?
         it 'should set @flog to {:dirs_to_flog => @code_dirs}' do
           load_metric 'flog'
-          @config.send(:flog).
-                  should == {:dirs_to_flog => ['lib']}
+          expect(MetricFu::Metric.get_metric(:flog).run_options).to eq({
+            :all => true,
+           :continue => true,
+           :dirs_to_flog => ["lib"],
+           :quiet => true
+           })
         end
         it 'should set @cane to ' +
                             %q(:dirs_to_cane => @code_dirs, :abc_max => 15, :line_length => 80, :no_doc => 'n', :no_readme => 'y') do
           load_metric 'cane'
-          @config.send(:cane).
-            should == {
-              :dirs_to_cane => MetricFu.code_dirs,
+          expect(MetricFu::Metric.get_metric(:cane).run_options).to eq(
+            {
+              :dirs_to_cane => directory('code_dirs'),
               :filetypes => ["rb"],
               :abc_max => 15,
               :line_length => 80,
               :no_doc => "n",
               :no_readme => "n"}
+              )
         end
       end
 
@@ -204,32 +223,33 @@ describe MetricFu::Configuration do
 
       describe '#set_metrics ' do
         it 'should set the metrics to include stats' do
-          @config.metrics.should include(:stats)
+          MetricFu::Metric.enabled_metrics.map(&:name).should include(:stats)
         end
       end
 
       describe '#set_graphs ' do
         it 'should set the graphs to include rails_best_practices' do
-          @config.graphs.should include(:rails_best_practices)
+          expect(MetricFu::Metric.get_metric(:rails_best_practices).has_graph?).to be_true
         end
       end
 
       describe '#set_code_dirs ' do
         it 'should set the @code_dirs instance var to ["app", "lib"]' do
-          @config.send(:code_dirs).
+          directory('code_dirs').
                   should == ['app','lib']
         end
       end
       it 'should set @stats to {}' do
         load_metric 'stats'
-        @config.send(:stats).
-                should == {}
+        expect(MetricFu::Metric.get_metric(:stats).run_options).to eq({
+          :additional_test_directories=>[{:glob_pattern=>"./spec/**/*_spec.rb", :file_pattern=>"spec"}],
+          :additional_app_directories=>[{:glob_pattern=>"./engines/**/*.rb", :file_pattern=>""}]
+        })
       end
 
       it 'should set @rails_best_practices to {}' do
         load_metric 'rails_best_practices'
-        @config.send(:rails_best_practices).
-                should == {}
+        expect(MetricFu::Metric.get_metric(:rails_best_practices).run_options).to eql({})
       end
     end
 
@@ -243,57 +263,11 @@ describe MetricFu::Configuration do
       end
 
       it 'should set the available metrics' do
-        @config.metrics.should =~ [:churn, :flog, :flay, :reek, :roodi, :rcov, :hotspots, :saikuro, :cane] - MetricFu.mri_only_metrics
-      end
-
-      it 'should set the @code_dirs instance var to ["lib"]' do
-        @config.send(:code_dirs).should == ['lib']
-      end
-    end
-  end
-
-  describe '#add_attr_accessors_to_self' do
-
-    before(:each) { get_new_config }
-
-    (
-      [:churn, :flog, :flay, :reek, :roodi, :rcov, :hotspots, :saikuro] -
-      MetricFu.mri_only_metrics
-    ).each do |metric|
-      it "should have a reader for #{metric}" do
-        expect {
-          @config.send(metric.to_sym)
-        }.to_not raise_error
+        MetricFu::Metric.enabled_metrics.map(&:name).should =~ [:churn, :flog, :flay, :reek, :roodi, :rcov, :hotspots, :saikuro, :cane, :stats] - MetricFu.mri_only_metrics
       end
 
-      it "should have a writer for #{metric}=" do
-        expect {
-          @config.send((metric.to_s + '=').to_sym, '')
-        }.to_not raise_error
-      end
-    end
-  end
-
-  describe '#add_class_methods_to_metric_fu' do
-
-    before(:each) { get_new_config }
-
-    (
-      [:churn, :flog, :flay, :reek, :roodi, :rcov, :hotspots, :saikuro, :cane] -
-      MetricFu.mri_only_metrics
-
-    ).each do |metric|
-      it "should add a #{metric} class method to the MetricFu module " do
-        MetricFu.should respond_to(metric)
-      end
-    end
-
-    (
-      [:churn, :flog, :flay, :reek, :roodi, :rcov, :hotspots, :saikuro, :cane] -
-      MetricFu.mri_only_metrics
-    ).each do |graph|
-      it "should add a #{graph} class metrhod to the MetricFu module" do
-        MetricFu.should respond_to(graph)
+      it 'should set the registered code_dirs to ["lib"]' do
+        directory('code_dirs').should == ['lib']
       end
     end
   end
@@ -330,12 +304,12 @@ describe MetricFu::Configuration do
     end
   end
 
-  describe '#add_formatter' do
+  describe '#configure_formatter' do
     before(:each) { get_new_config }
 
     context 'given a built-in formatter' do
       before do
-        @config.add_formatter('html')
+        @config.configure_formatter('html')
       end
 
       it 'adds to the list of formatters' do
@@ -346,7 +320,7 @@ describe MetricFu::Configuration do
     context 'given a custom formatter by class name' do
       before do
         stub_const('MyCustomFormatter', Class.new() { def initialize(*); end })
-        @config.add_formatter('MyCustomFormatter')
+        @config.configure_formatter('MyCustomFormatter')
       end
 
       it 'adds to the list of formatters' do
@@ -357,9 +331,9 @@ describe MetricFu::Configuration do
     context 'given multiple formatters' do
       before do
         stub_const('MyCustomFormatter', Class.new() { def initialize(*); end })
-        @config.add_formatter('html')
-        @config.add_formatter('yaml')
-        @config.add_formatter('MyCustomFormatter')
+        @config.configure_formatter('html')
+        @config.configure_formatter('yaml')
+        @config.configure_formatter('MyCustomFormatter')
       end
 
       it 'adds each to the list of formatters' do