fukuzatsu 0.9.13 → 0.9.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33b9be43725bfc69fd427bc78857cb173db66586
-  data.tar.gz: 93eb38e086bcf10b4e38cccc9cec53e3a10bcd7b
+  metadata.gz: 2f84b5108ad126a90f2320712aa5c5ec01690969
+  data.tar.gz: 7b5d7114da4f187368fef32eaa46949c664cf41b
 SHA512:
-  metadata.gz: 0f42bf703830a6e88d468b0fc64c96f3de69c9b69a79557ebe59c6a0913b3858ed68c498685daddcdf454df3bbf1fa622a042b7632e568b09602dec6828299d6
-  data.tar.gz: 38fa1c7d5ecbd1be0725af017d162f58ef23f5c0b2cbd43014ac224461b56ead7df38dc08c596549e4b83c33782afa300a61dddf71bce645118f8bc27a246522
+  metadata.gz: 18a5e3e5352b534f2e9c1cd1de89c7dfa674e4281c58b36b4c5c973fa1f0d89bfd7bc14b8ad96e5ad3b676095ec50fb08330fe9182a55ef4ce70e0f7a1b43050
+  data.tar.gz: fdf63925b5cf99805c394674c7214a65f0f6c00a7ece731be10ccdbe06f295fea7ba768ef88ed7eda28764bd29f84aaa55d298816828e3e3724be6913b48e6fd

data/.gitignore

@@ -22,3 +22,4 @@ tmp
 mkmf.log
 .console_history
 *.swp
+coverage

data/Gemfile

@@ -1,4 +1,2 @@
 source 'https://rubygems.org'
-
-# Specify your gem's dependencies in fukuzatsu.gemspec
 gemspec

data/fukuzatsu.gemspec

@@ -22,10 +22,11 @@ Gem::Specification.new do |spec|
   spec.add_dependency "poro_plus"
   spec.add_dependency "haml"
   spec.add_dependency "parser"
+  spec.add_dependency "thor"
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "thor"
+  spec.add_development_dependency "simplecov"
 
 end

data/lib/fukuzatsu/analyzer.rb

@@ -50,13 +50,13 @@ class Analyzer
   end
 
   def methods_from(node, methods=[])
-    if node.type == :def || node.type == :defs
+    if node.type == :def || node.type == :defs || node.type == :class
       name = node.loc.name
       expression = node.loc.expression
       methods << ParsedMethod.new(
         name: content[name.begin_pos..name.end_pos - 1],
         content: content[expression.begin_pos..expression.end_pos - 1],
-        type: node.type == :defs ? :class : :instance
+        type: [:defs, :class].include?(node.type) ? :class : :instance
       )
     end
     node.children.each do |child|

data/lib/fukuzatsu/cli.rb

@@ -13,36 +13,31 @@ module Fukuzatsu
     method_option :threshold, :type => :numeric, :default => 0, :aliases => "-t"
 
     def check(path="./")
-
-      file_summary = []
-      file_complexities = []
-      last_file = {}
-
-      file_list(path).each do |path_to_file|
-        file = ParsedFile.new(path_to_file: path_to_file)
-        parser = formatter(options).new(file)
-        parser.export
-        file_summary << {
-          results_file: "#{parser.output_path}/#{parser.filename}",
-          path_to_file: path_to_file,
-          class_name: "#{file.class_name}",
-          complexity: file.complexity
-        }
-        file_complexities << file.complexity
-      end
-
-      last_file = handle_index(file_summary) if options['format'] == 'html'
-      report(last_file[:results_file], file_summary.map{|s| s[:results_file]})
-      handle_complexity(options, file_complexities.sort.last, options['threshold'])
-
+      file_list(path).each{ |path_to_file| parse(path_to_file) }
+      handle_index(summaries)
+      report
     end
 
     default_task :check
 
+    attr_accessor :summaries, :last_file
+
     private
 
-    def formatter(options)
-      formatter = case options['format']
+    def complexities
+      summaries.to_a.map{|s| s[:complexity]}
+    end
+
+    def file_list(start_file)
+      if File.directory?(start_file)
+        return Dir.glob(File.join(start_file, "**", "*")).select{|n| n =~ /\.rb$/}
+      else
+        return [start_file]
+      end
+    end
+
+    def formatter
+      case options['format']
       when 'html'
         Formatters::Html
       when 'csv'
@@ -53,30 +48,37 @@ module Fukuzatsu
     end
 
     def handle_index(file_summary)
+      return unless options['format'] == 'html'
       index = Formatters::HtmlIndex.new(file_summary)
+      self.last_file = "#{index.output_path}/#{index.filename}"
       index.export
-      {results_file: "#{index.output_path}/#{index.filename}"}
     end
 
-    def report(last_file, file_list)
-     return if options['format'] == "text"
-     puts "Results written to:"
-     puts last_file.present? && "#{last_file}" || file_list.join("\r\n")
+    def parse(path_to_file, options={})
+      file = ParsedFile.new(path_to_file: path_to_file)
+      parser = formatter.new(file)
+      parser.export
+      self.summaries ||= []
+      self.summaries << file.summary.merge(results_file: parser.path_to_results)
+    end
+
+    def report
+      unless options['format'] == "text"
+        puts "Results written to:"
+        puts last_file.present? && "#{last_file}" || results_files.join("\r\n")
+      end
+      report_complexity
     end
 
-    def handle_complexity(options, highest_complexity, threshold)
+    def report_complexity
       return if options['threshold'].to_i == 0
-      return if highest_complexity <= options['threshold']
-      puts "Maximum complexity is #{highest_complexity}, which is greater than the threshold of #{options['threshold']}."
+      return if complexities.max.to_i <= options['threshold']
+      puts "Maximum complexity of #{complexities.max} exceeds #{options['threshold']} threshold!"
       exit 1
     end
 
-    def file_list(start_file)
-      if File.directory?(start_file)
-        return Dir.glob(File.join(start_file, "**", "*")).select{|n| n =~ /\.rb$/}
-      else
-        return [start_file]
-      end
+    def results_files
+      summaries.map{|s| s[:results_file]}
     end
 
   end

data/lib/fukuzatsu/formatters/base.rb

@@ -28,6 +28,10 @@ module Formatters
       output_path
     end
 
+    def path_to_results
+      "#{output_path}/#{filename}"
+    end
+
     def filename
       self.file.path_to_file.split('/')[-1] + file_extension
     end
@@ -38,7 +42,7 @@ module Formatters
 
     def export
       begin
-        outfile = File.open("#{output_path}/#{filename}", 'w')
+        outfile = File.open("#{path_to_results}", 'w')
         outfile.write(content)
       rescue Exception => e
         puts "Unable to write output: #{e} #{e.backtrace}"

data/lib/fukuzatsu/parsed_file.rb

@@ -3,7 +3,7 @@ class ParsedFile
   include PoroPlus
   include Ephemeral::Base
 
-  attr_accessor :path_to_file, :class_name
+  attr_accessor :complexity, :path_to_file, :class_name, :path_to_results
 
   def class_name
     @class_name ||= analyzer.extract_class_name
@@ -14,7 +14,7 @@ class ParsedFile
   end
 
   def analyzer
-    Analyzer.new(content)
+    @analyzer ||= Analyzer.new(content)
   end
 
   def complexity
@@ -25,4 +25,13 @@ class ParsedFile
     @methods ||= analyzer.extract_methods
   end
 
+  def summary
+    {
+      results_file: self.path_to_results,
+      path_to_file: self.path_to_file,
+      class_name: self.class_name,
+      complexity: complexity
+    }
+  end
+
 end

data/lib/fukuzatsu/parsed_method.rb

@@ -1,17 +1,19 @@
-require 'parser/current'
-
 class ParsedMethod
 
   include PoroPlus
 
-  attr_accessor :name, :content, :type
+  attr_accessor :name, :content, :type, :complexity
 
   def complexity
-    @complexity ||= Analyzer.new(content).complexity
+    @complexity ||= analyzer.complexity
   end
 
   def prefix
-    self.type == :class ? "." : "#"
+    self.type.to_s == 'class' ? "." : "#"
+  end
+
+  def analyzer
+    Analyzer.new(self.content)
   end
 
 end

data/lib/fukuzatsu/version.rb

@@ -1,3 +1,3 @@
 module Fukuzatsu
-  VERSION = "0.9.13"
+  VERSION = "0.9.14"
 end

data/spec/analyzer_spec.rb

@@ -36,24 +36,68 @@ describe Analyzer do
     end
   end
 
-  context "program_1" do
+  describe "#complexity" do
+    context "program_1" do
 
-    let(:analyzer)  { Analyzer.new(content_1) }
+      let(:analyzer)  { Analyzer.new(content_1) }
+
+      it "matches the manual calculation of complexity of 4" do
+        expect(analyzer.complexity).to eq(4)
+      end
 
-    it "matches the manual calculation of complexity of 4" do
-      expect(analyzer.complexity).to eq(4)
     end
 
-  end
+    context "program_2" do
 
-  context "program_2" do
+      let(:analyzer)  { Analyzer.new(content_2) }
 
-    let(:analyzer)  { Analyzer.new(content_2) }
+      it "matches the manual calculation of complexity of 5" do
+        expect(analyzer.complexity).to eq(5)
+      end
 
-    it "matches the manual calculation of complexity of 5" do
-      expect(analyzer.complexity).to eq(5)
     end
-
+  end
+  
+  describe "extract_methods" do
+    # Note: should implicitly trust private method #methods_from
+    context "from a file with a single method" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/single_method.rb")) }
+      it "should return a single method" do
+        expect(analyzer.extract_methods.count).to eq 1
+      end
+      it "should extract the method name" do
+        expect(analyzer.extract_methods[0].name).to eq "read_poem"
+      end
+      it "should extract the method content" do
+        expect(analyzer.extract_methods[0].content).to eq 'def read_poem
+  return "I meant to find her when I came/Death had the same design"
+end'
+      end
+      it "should set type to :instance" do
+        expect(analyzer.extract_methods[0].type).to eq :instance
+      end
+    end
+    context "from a file with multiple methods" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/multiple_methods.rb")) }
+      it "should return multiple methods" do
+        expect(analyzer.extract_methods.map { |m| m.name }).to eq ["bake_treats", "lower_from_window"]
+      end
+    end
+    context "from a file with nested methods" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/nested_methods.rb")) }
+      it "should return the root method, and its child" do
+        expect(analyzer.extract_methods.map { |m| m.name }).to eq ["grow_flowers", "water_earth"]
+      end
+    end
+    context "from a file with a class" do
+      let(:analyzer) { Analyzer.new(File.read("spec/fixtures/single_class.rb")) }
+      it "should return the class and its methods" do
+        expect(analyzer.extract_methods.map { |m| m.name }).to eq ["Gown", "initialize", "color"]
+      end
+      it "should set the type of class to :class" do
+        expect(analyzer.extract_methods[0].type).to eq :class
+      end
+    end
   end
 
 end

data/spec/cli_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe "Fukuzatsu::CLI" do
+
+  let(:cli) { Fukuzatsu::CLI.new([
+      path: "foo/bar.rb",
+      format: 'text'
+    ]
+  )}
+
+  let(:summary_1) {
+    {
+      results_file: "doc/fukuzatsu/file_1.rb.htm",
+      path_to_file: "file_1.rb",
+      class_name: "File_1",
+      complexity: 13
+    }
+  }
+
+  let(:summary_2) {
+    {
+      results_file: "doc/fukuzatsu/file_2.rb.htm",
+      path_to_file: "file_2.rb",
+      class_name: "File_2",
+      complexity: 11
+    }
+  }
+
+  before do
+    allow(cli).to receive(:summaries) { [summary_1, summary_2] }
+  end
+
+  describe "#complexities" do
+    it "extracts complexities from its file summaries" do
+      expect(cli.send(:complexities)).to eq([13,11])
+    end
+  end
+
+  describe "#formatter" do
+    it "returns a csv formatter" do
+      allow(cli).to receive(:options) { {'format' => 'csv'} }
+      expect(cli.send(:formatter)).to eq Formatters::Csv
+    end
+    it "returns an html formatter" do
+      allow(cli).to receive(:options) { {'format' => 'html'} }
+      expect(cli.send(:formatter)).to eq Formatters::Html
+    end
+    it "returns a text formatter" do
+      allow(cli).to receive(:options) { {'format' => 'text'} }
+      expect(cli.send(:formatter)).to eq Formatters::Text
+    end
+  end
+
+  describe "#report" do
+    it "does not report if format is text" do
+      allow(cli).to receive(:options) { {'format' => 'text'} }
+      expect(cli.send(:report)).to be_nil
+    end
+  end
+
+  describe "#report_complexity" do
+    it "does not report if threshold is not set" do
+      expect(cli.send(:report_complexity)).to be_nil
+    end
+
+    it "does not report if threshold is respected" do
+      allow(cli).to receive(:options) { {'threshold' => 15} }
+      allow(cli).to receive(:complexities) { [0,13,11] }
+      expect(cli.send(:report_complexity)).to be_nil
+
+    end
+  end
+
+  describe "#results_files" do
+    it "extracts results files from its file summaries" do
+      expect(cli.send(:results_files)).to eq(
+        [
+          "doc/fukuzatsu/file_1.rb.htm",
+          "doc/fukuzatsu/file_2.rb.htm"
+        ]
+      )
+    end
+  end
+
+end

data/spec/fixtures/multiple_methods.rb

@@ -0,0 +1,7 @@
+def bake_treats
+  return :a_basket_of_cookies
+end
+
+def lower_from_window(window)
+  window.insert(bake_treats)
+end

data/spec/fixtures/nested_methods.rb

@@ -0,0 +1,8 @@
+def grow_flowers(seed, water, earth)
+  def water_earth(water, earth)
+    earth.insert(water)
+  end
+  
+  earth.insert.seed
+  50.times(water_earth(water, earth))
+end

data/spec/fixtures/single_class.rb

@@ -0,0 +1,9 @@
+class Gown
+  def initialize
+    @color = "White"
+  end
+  
+  def color
+    return @color
+  end
+end

data/spec/fixtures/single_method.rb

@@ -0,0 +1,3 @@
+def read_poem
+  return "I meant to find her when I came/Death had the same design"
+end

data/spec/formatters/base_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Formatters::Base" do
+
+  class Formatters::Sample; include Formatters::Base; end
+
+  let (:parsed_file) { ParsedFile.new(class_name: "Foo", path_to_file: "lib/foo.rb") }
+  let (:formatter) { Formatters::Sample.new(parsed_file) }
+
+  before do
+    allow(formatter).to receive(:header) { "class,method,complexity" }
+    allow(formatter).to receive(:rows) { "Foo,#initialize,24" }
+    allow(formatter).to receive(:footer) { "TOTAL,,24" }
+  end
+
+  describe "#columns" do
+    it "returns default columns" do
+      expect(formatter.columns).to eq(["class", "method", "complexity"])
+    end
+  end
+
+  describe "#content" do
+    it "returns expected content" do
+      expect(formatter.content).to eq "class,method,complexity\r\nFoo,#initialize,24\r\nTOTAL,,24"
+    end
+  end
+
+  describe "#filename" do
+    it "builds a filename" do
+      allow(formatter).to receive(:file_extension) { '.doc' }
+      expect(formatter.filename).to eq "foo.rb.doc"
+    end
+  end
+
+  describe "#output_path" do
+    it "builds a path" do
+      allow(FileUtils).to receive(:mkpath)
+      expect(formatter.output_path).to eq "doc/fukuzatsu/lib"
+    end
+  end
+
+  describe "#path_to_results" do
+    it "builds a path" do
+      allow(formatter).to receive(:file_extension) { '.doc' }
+      allow(formatter).to receive(:output_path) { 'doc/fukuzatsu/lib' }
+      expect(formatter.path_to_results).to eq "doc/fukuzatsu/lib/foo.rb.doc"
+    end
+  end
+
+  describe "#root_path" do
+    it "returns the expected path" do
+      expect(formatter.root_path).to eq "doc/fukuzatsu"
+    end
+  end
+
+end

data/spec/formatters/csv_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "Formatters::Csv" do
+
+  let (:parsed_file) { ParsedFile.new(class_name: "Foo") }
+  let (:method_1) { ParsedMethod.new(
+      name: "initialize",
+      complexity: 13,
+      type: "instance"
+    )
+  }
+  let (:method_2) { ParsedMethod.new(
+      name: "report",
+      complexity: 11,
+      type: "instance"
+    )
+  }
+  let (:formatter) { Formatters::Csv.new(parsed_file) }
+
+  describe "#header" do
+    it "returns a comma-separated header" do
+      expect(formatter.header).to eq "class,method,complexity"
+    end
+  end
+
+  describe "#rows" do
+    it "returns comma-separated rows" do
+      allow(parsed_file).to receive(:methods) { [method_1, method_2] }
+      expect(formatter.rows).to eq(
+        "Foo,#initialize,13\r\nFoo,#report,11"
+      )
+    end
+  end
+
+  describe "#file_extension" do
+    it "returns the proper extension" do
+      expect(formatter.file_extension).to eq ".csv"
+    end
+  end
+
+end

data/spec/formatters/html_index_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe "Formatters::HtmlIndex" do
+
+  let(:file_summary) {
+    [
+      {
+        results_file: "doc/fukuzatsu/file_1.rb.htm",
+        path_to_file: "file_1.rb",
+        class_name: "File_1",
+        complexity: 13
+      },
+      {
+        results_file: "doc/fukuzatsu/file_2.rb.htm",
+        path_to_file: "file_2.rb",
+        class_name: "File_2",
+        complexity: 11
+      }
+    ]
+  }
+
+  let (:formatter) { Formatters::HtmlIndex.new(file_summary) }
+
+  describe "#initialize" do
+    it "initializes with a file summary" do
+      expect(formatter.file_summary).to eq file_summary
+    end
+  end
+
+  describe "#filename" do
+    it "returns the expected filename" do
+      expect(formatter.filename).to eq "index.htm"
+    end
+  end
+
+end

data/spec/formatters/html_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Formatters::Text" do
+
+  let (:parsed_file) { ParsedFile.new(class_name: "Foo", complexity: 11) }
+  let (:method_1) { ParsedMethod.new(
+      name: "initialize",
+      complexity: 13,
+      type: "instance"
+    )
+  }
+  let (:method_2) { ParsedMethod.new(
+      name: "report",
+      complexity: 11,
+      type: "instance"
+    )
+  }
+  let (:formatter) { Formatters::Html.new(parsed_file) }
+
+  before do
+    allow(parsed_file).to receive(:methods) { [method_1, method_2] }
+  end
+
+  describe "#header" do
+    it "returns an HTML-formatted header" do
+      expect(formatter.header).to eq(
+        "<th>Class</th>\r\n<th>Method</th>\r\n<th>Complexity</th>"
+      )
+    end
+  end
+
+  describe "#rows" do
+    it "returns HTML-formatted rows" do
+      expected = "<tr class='even'>\r\n  <td>Foo</td>\r\n  <td>#initialize</td>\r\n  <td>13</td>\r\n</tr>\r\n"
+      expected << "<tr class='odd'>\r\n  <td>Foo</td>\r\n  <td>#report</td>\r\n  <td>11</td>\r\n</tr>"
+      allow(parsed_file).to receive(:methods) { [method_1, method_2] }
+      expect(formatter.rows).to eq(expected)
+    end
+  end
+
+  describe "#file_extension" do
+    it "returns the proper extension" do
+      expect(formatter.file_extension).to eq ".htm"
+    end
+  end
+
+end

data/spec/formatters/text_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "Formatters::Text" do
+
+  let (:parsed_file) { ParsedFile.new(class_name: "Foo", complexity: 11) }
+  let (:method_1) { ParsedMethod.new(
+      name: "initialize",
+      complexity: 13,
+      type: "instance"
+    )
+  }
+  let (:method_2) { ParsedMethod.new(
+      name: "report",
+      complexity: 11,
+      type: "instance"
+    )
+  }
+  let (:formatter) { Formatters::Text.new(parsed_file) }
+
+  describe "#header" do
+    it "returns a tab-separated header" do
+      expect(formatter.header).to eq "Foo\t\t11"
+    end
+  end
+
+  describe "#rows" do
+    it "returns tab-separated rows" do
+      allow(parsed_file).to receive(:methods) { [method_1, method_2] }
+      expect(formatter.rows).to eq(
+        ["Foo\t#initialize\t13", "Foo\t#report\t11"]
+      )
+    end
+  end
+
+end

data/spec/parsed_file_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe ParsedFile do
+
+  let(:parsed_file) { ParsedFile.new(path_to_file: "bar/foo.rb") }
+  let(:analyzer)    { Analyzer.new("class Foo; end") }
+
+  describe "#class_name" do
+    before do
+      allow(parsed_file).to receive(:analyzer) { analyzer }
+    end
+    it "retrieves class name from analyzer" do
+      expect(parsed_file.class_name).to eq "Foo"
+    end
+  end
+
+  describe "#content" do
+    it "reads from file" do
+      allow(File).to receive(:open).with("bar/foo.rb", "r") {
+        instance_double("File", read: "whatever")
+      }
+      expect(parsed_file.content).to eq("whatever")
+    end
+  end
+
+  describe "#analyzer" do
+    it "instantiates an Analyzer instance with content" do
+      allow(parsed_file).to receive("content") { "stuff" }
+      expect(parsed_file.analyzer.class.name).to eq "Analyzer"
+    end
+  end
+
+  describe "#complexity" do
+    before do
+      allow(parsed_file).to receive(:analyzer) { analyzer }
+    end
+    it "retrieves complexity score from analyzer" do
+      allow(analyzer).to receive(:complexity) { 13 }
+      expect(parsed_file.complexity).to eq 13
+    end
+  end
+
+  describe "methods" do
+    before do
+      allow(parsed_file).to receive(:analyzer) { analyzer }
+    end
+    it "retrieves methods from analyzer" do
+      allow(analyzer).to receive(:extract_methods) { [:talk, :walk] }
+      expect(parsed_file.methods).to eq([:talk, :walk])
+    end
+  end
+
+  describe "summary" do
+    it "builds a hash" do
+      allow(parsed_file).to receive(:path_to_results) { "doc/fukuzatsu/foo.rb.htm" }
+      allow(parsed_file).to receive(:path_to_file) { "foo.rb.htm" }
+      allow(parsed_file).to receive(:class_name) { "Foo" }
+      allow(parsed_file).to receive(:complexity) { 11 }
+      expect(parsed_file.summary[:results_file]).to eq "doc/fukuzatsu/foo.rb.htm"
+      expect(parsed_file.summary[:path_to_file]).to eq "foo.rb.htm"
+      expect(parsed_file.summary[:class_name]).to eq "Foo"
+      expect(parsed_file.summary[:complexity]).to eq 11
+    end
+  end
+
+
+end

data/spec/parsed_method_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe ParsedMethod do
+
+  let(:parsed_method) { ParsedMethod.new }
+  let(:analyzer)    { Analyzer.new("class Foo; end") }
+
+  describe "#complexity" do
+    it "retrieves complexity from its analyzer" do
+      allow(parsed_method).to receive(:analyzer) { analyzer }
+      allow(analyzer).to receive(:complexity) { 23 }
+      expect(parsed_method.complexity).to eq 23
+    end
+  end
+
+  describe "#analyzer" do
+    it "instantiates an Analyzer instance with content" do
+      allow(parsed_method).to receive("content") { "stuff" }
+      expect(parsed_method.analyzer.class.name).to eq "Analyzer"
+    end
+  end
+
+  describe "#prefix" do
+    it "returns '.' if its type is class" do
+      allow(parsed_method).to receive("type") { "class" }
+      expect(parsed_method.prefix).to eq "."
+    end
+    it "returns '#' if its type is instance" do
+      allow(parsed_method).to receive("type") { "instance" }
+      expect(parsed_method.prefix).to eq "#"
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,3 +1,7 @@
+require 'simplecov'
+
+SimpleCov.start
+
 require 'rubygems'
 require 'rspec'
 require 'fukuzatsu'

data/tags

@@ -0,0 +1,92 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME	Exuberant Ctags	//
+!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
+!_TAG_PROGRAM_VERSION	5.8	//
+Analyzer	lib/fukuzatsu/analyzer.rb	/^class Analyzer$/;"	c
+Base	lib/fukuzatsu/formatters/base.rb	/^  module Base$/;"	m	class:Formatters
+Breathalizer	spec/fixtures/program_3.rb	/^class Breathalizer$/;"	c
+CLI	lib/fukuzatsu/cli.rb	/^  class CLI < Thor$/;"	c	class:Fukuzatsu
+Csv	lib/fukuzatsu/formatters/csv.rb	/^  class Csv$/;"	c	class:Formatters
+Extracted	spec/fixtures/eg_mod_class_2.rb	/^module Extracted$/;"	m
+Foo	spec/fixtures/eg_class.rb	/^class Foo$/;"	c
+Foo	spec/fixtures/eg_mod_class.rb	/^class Foo::Bar$/;"	c
+Formatters	lib/fukuzatsu/formatters/base.rb	/^module Formatters$/;"	m
+Formatters	lib/fukuzatsu/formatters/csv.rb	/^module Formatters$/;"	m
+Formatters	lib/fukuzatsu/formatters/html.rb	/^module Formatters$/;"	m
+Formatters	lib/fukuzatsu/formatters/html_index.rb	/^module Formatters$/;"	m
+Formatters	lib/fukuzatsu/formatters/text.rb	/^module Formatters$/;"	m
+Fukuzatsu	lib/fukuzatsu.rb	/^module Fukuzatsu$/;"	m
+Fukuzatsu	lib/fukuzatsu/cli.rb	/^module Fukuzatsu$/;"	m
+Fukuzatsu	lib/fukuzatsu/version.rb	/^module Fukuzatsu$/;"	m
+Html	lib/fukuzatsu/formatters/html.rb	/^  class Html$/;"	c	class:Formatters
+HtmlIndex	lib/fukuzatsu/formatters/html_index.rb	/^  class HtmlIndex$/;"	c	class:Formatters
+ParsedFile	lib/fukuzatsu/parsed_file.rb	/^class ParsedFile$/;"	c
+ParsedMethod	lib/fukuzatsu/parsed_method.rb	/^class ParsedMethod$/;"	c
+Something	spec/fixtures/eg_module.rb	/^module Something$/;"	m
+Text	lib/fukuzatsu/formatters/text.rb	/^  class Text$/;"	c	class:Formatters
+Thing	spec/fixtures/eg_mod_class_2.rb	/^  class Thing$/;"	c	class:Extracted
+analyzer	lib/fukuzatsu/parsed_file.rb	/^  def analyzer$/;"	f	class:ParsedFile
+check	lib/fukuzatsu/cli.rb	/^    def check(path=".\/")$/;"	f	class:Fukuzatsu.CLI
+class_name	lib/fukuzatsu/parsed_file.rb	/^  def class_name$/;"	f	class:ParsedFile
+columns	lib/fukuzatsu/formatters/base.rb	/^    def columns$/;"	f	class:Formatters.Base
+complexity	lib/fukuzatsu/analyzer.rb	/^  def complexity$/;"	f	class:Analyzer
+complexity	lib/fukuzatsu/parsed_file.rb	/^  def complexity$/;"	f	class:ParsedFile
+complexity	lib/fukuzatsu/parsed_method.rb	/^  def complexity$/;"	f	class:ParsedMethod
+complexity	spec/fixtures/program_3.rb	/^  def complexity$/;"	f	class:Breathalizer
+content	lib/fukuzatsu/formatters/base.rb	/^    def content$/;"	f	class:Formatters.Base
+content	lib/fukuzatsu/formatters/html.rb	/^    def content$/;"	f	class:Formatters.Html
+content	lib/fukuzatsu/formatters/html_index.rb	/^    def content$/;"	f	class:Formatters.HtmlIndex
+content	lib/fukuzatsu/parsed_file.rb	/^  def content$/;"	f	class:ParsedFile
+export	lib/fukuzatsu/formatters/base.rb	/^    def export$/;"	f	class:Formatters.Base
+export	lib/fukuzatsu/formatters/text.rb	/^    def export$/;"	f	class:Formatters.Text
+extend_graph	lib/fukuzatsu/analyzer.rb	/^  def extend_graph$/;"	f	class:Analyzer
+extract_class_name	lib/fukuzatsu/analyzer.rb	/^  def extract_class_name$/;"	f	class:Analyzer
+extract_methods	lib/fukuzatsu/analyzer.rb	/^  def extract_methods$/;"	f	class:Analyzer
+file_contents	spec/fixtures/program_3.rb	/^  def file_contents$/;"	f	class:Breathalizer
+file_extension	lib/fukuzatsu/formatters/base.rb	/^    def file_extension$/;"	f	class:Formatters.Base
+file_extension	lib/fukuzatsu/formatters/csv.rb	/^    def file_extension$/;"	f	class:Formatters.Csv.rows
+file_extension	lib/fukuzatsu/formatters/html.rb	/^    def file_extension$/;"	f	class:Formatters.Html.rows
+file_list	lib/fukuzatsu/cli.rb	/^    def file_list(start_file)$/;"	f	class:Fukuzatsu
+filename	lib/fukuzatsu/formatters/base.rb	/^    def filename$/;"	f	class:Formatters.Base
+filename	lib/fukuzatsu/formatters/html_index.rb	/^    def filename$/;"	f	class:Formatters.HtmlIndex
+find_class	lib/fukuzatsu/analyzer.rb	/^  def find_class(node)$/;"	f	class:Analyzer
+footer	lib/fukuzatsu/formatters/csv.rb	/^    def footer$/;"	f	class:Formatters.Csv.rows
+footer	lib/fukuzatsu/formatters/html.rb	/^    def footer$/;"	f	class:Formatters.Html.rows
+footer	lib/fukuzatsu/formatters/text.rb	/^    def footer$/;"	f	class:Formatters.Text
+formatter	lib/fukuzatsu/cli.rb	/^    def formatter(options)$/;"	f	class:Fukuzatsu.CLI
+handle_complexity	lib/fukuzatsu/cli.rb	/^    def handle_complexity(options, highest_complexity, threshold)$/;"	f	class:Fukuzatsu
+handle_index	lib/fukuzatsu/cli.rb	/^    def handle_index(file_summary)$/;"	f	class:Fukuzatsu
+header	lib/fukuzatsu/formatters/csv.rb	/^    def header$/;"	f	class:Formatters.Csv
+header	lib/fukuzatsu/formatters/html.rb	/^    def header$/;"	f	class:Formatters.Html
+header	lib/fukuzatsu/formatters/text.rb	/^    def header$/;"	f	class:Formatters.Text
+included	lib/fukuzatsu/formatters/base.rb	/^    def self.included(klass)$/;"	F	class:Formatters.Base
+initialize	lib/fukuzatsu/analyzer.rb	/^  def initialize(content)$/;"	f	class:Analyzer
+initialize	lib/fukuzatsu/formatters/base.rb	/^    def initialize(file)$/;"	f	class:Formatters.Base
+initialize	lib/fukuzatsu/formatters/html_index.rb	/^    def initialize(file_summary)$/;"	f	class:Formatters.HtmlIndex
+initialize	spec/fixtures/program_3.rb	/^  def initialize(path_to_file)$/;"	f	class:Breathalizer
+methods	lib/fukuzatsu/parsed_file.rb	/^  def methods$/;"	f	class:ParsedFile
+methods_from	lib/fukuzatsu/analyzer.rb	/^  def methods_from(node, methods=[])$/;"	f	class:Analyzer
+output_path	lib/fukuzatsu/formatters/base.rb	/^    def output_path$/;"	f	class:Formatters.Base
+output_path	lib/fukuzatsu/formatters/html_index.rb	/^    def output_path$/;"	f	class:Formatters.HtmlIndex
+output_template	lib/fukuzatsu/formatters/html.rb	/^    def output_template$/;"	f	class:Formatters.Html
+output_template	lib/fukuzatsu/formatters/html_index.rb	/^    def output_template$/;"	f	class:Formatters.HtmlIndex
+parent_node?	lib/fukuzatsu/analyzer.rb	/^  def parent_node?(node)$/;"	f	class:Analyzer
+parse	spec/fixtures/program_3.rb	/^  def self.parse!(path_to_file)$/;"	F	class:Breathalizer
+parse!	lib/fukuzatsu/analyzer.rb	/^  def parse!$/;"	f	class:Analyzer
+parse!	spec/fixtures/program_3.rb	/^  def parse!$/;"	f	class:Breathalizer
+parsed	lib/fukuzatsu/analyzer.rb	/^  def parsed$/;"	f	class:Analyzer
+parsed	spec/fixtures/program_3.rb	/^  def parsed$/;"	f	class:Breathalizer
+prefix	lib/fukuzatsu/parsed_method.rb	/^  def prefix$/;"	f	class:ParsedMethod
+report	lib/fukuzatsu/cli.rb	/^    def report(last_file, file_list)$/;"	f	class:Fukuzatsu
+root_path	lib/fukuzatsu/formatters/base.rb	/^    def root_path$/;"	f	class:Formatters.Base
+rows	lib/fukuzatsu/formatters/csv.rb	/^    def rows$/;"	f	class:Formatters.Csv
+rows	lib/fukuzatsu/formatters/html.rb	/^    def rows$/;"	f	class:Formatters.Html
+rows	lib/fukuzatsu/formatters/text.rb	/^    def rows$/;"	f	class:Formatters.Text
+say_hello	spec/fixtures/eg_class.rb	/^  def say_hello$/;"	f	class:Foo
+spaghetti	spec/fixtures/program_1.rb	/^def spaghetti$/;"	f
+text_at	lib/fukuzatsu/analyzer.rb	/^  def text_at(start_pos, end_pos)$/;"	f	class:Analyzer
+toppings	spec/fixtures/program_2.rb	/^def toppings$/;"	f
+traverse	lib/fukuzatsu/analyzer.rb	/^  def traverse(node, accumulator=[], extract_methods=false)$/;"	f	class:Analyzer
+traverse	spec/fixtures/program_3.rb	/^  def traverse(node)#, accumulator=[])$/;"	f	class:Breathalizer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fukuzatsu
 version: !ruby/object:Gem::Version
-  version: 0.9.13
+  version: 0.9.14
 platform: ruby
 authors:
 - Bantik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-05 00:00:00.000000000 Z
+date: 2014-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ephemeral
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -109,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -156,15 +170,28 @@ files:
 - lib/fukuzatsu/parsed_method.rb
 - lib/fukuzatsu/version.rb
 - spec/analyzer_spec.rb
+- spec/cli_spec.rb
 - spec/fixtures/eg_class.rb
 - spec/fixtures/eg_mod_class.rb
 - spec/fixtures/eg_mod_class_2.rb
 - spec/fixtures/eg_module.rb
+- spec/fixtures/multiple_methods.rb
+- spec/fixtures/nested_methods.rb
 - spec/fixtures/program_1.rb
 - spec/fixtures/program_2.rb
 - spec/fixtures/program_3.rb
 - spec/fixtures/program_4.rb
+- spec/fixtures/single_class.rb
+- spec/fixtures/single_method.rb
+- spec/formatters/base_spec.rb
+- spec/formatters/csv_spec.rb
+- spec/formatters/html_index_spec.rb
+- spec/formatters/html_spec.rb
+- spec/formatters/text_spec.rb
+- spec/parsed_file_spec.rb
+- spec/parsed_method_spec.rb
 - spec/spec_helper.rb
+- tags
 homepage: https://gitlab.com/coraline/fukuzatsu/tree/master
 licenses:
 - MIT
@@ -191,12 +218,24 @@ specification_version: 4
 summary: A simple code complexity analyzer.
 test_files:
 - spec/analyzer_spec.rb
+- spec/cli_spec.rb
 - spec/fixtures/eg_class.rb
 - spec/fixtures/eg_mod_class.rb
 - spec/fixtures/eg_mod_class_2.rb
 - spec/fixtures/eg_module.rb
+- spec/fixtures/multiple_methods.rb
+- spec/fixtures/nested_methods.rb
 - spec/fixtures/program_1.rb
 - spec/fixtures/program_2.rb
 - spec/fixtures/program_3.rb
 - spec/fixtures/program_4.rb
+- spec/fixtures/single_class.rb
+- spec/fixtures/single_method.rb
+- spec/formatters/base_spec.rb
+- spec/formatters/csv_spec.rb
+- spec/formatters/html_index_spec.rb
+- spec/formatters/html_spec.rb
+- spec/formatters/text_spec.rb
+- spec/parsed_file_spec.rb
+- spec/parsed_method_spec.rb
 - spec/spec_helper.rb