fukuzatsu 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65fa8bca4bbb758dc65c2689df39c7235f398280
-  data.tar.gz: 8a1008b8017f8a9affdf31e882b9de64ab9c4228
+  metadata.gz: 8428f57be028d8631c44a4918b3b45e5a975f723
+  data.tar.gz: fec178eca577f552ad69e8706f4767a21283a551
 SHA512:
-  metadata.gz: b2cff1c582f0e761a882a6aea091d532b81c9c4f77a98e6c612099ae9e2780a51bdf2017e649c066287dde9c6df7eb1afb150b81f612480ed9832bcdea9ada2f
-  data.tar.gz: 98a3185b4c93950fc2deada10c42c83a17e50d9b8180800dce657cdc01f611f0b287e32a517a3719f45381b8d30f2dd51eef0e184feac14b1bcbef0c6de94257
+  metadata.gz: 0538641fea2e818d9d696318e0f78410acbbe6429448d8254d53fddd236a9530ab41f13f4309268e23c8c41b53621356cdd04e4a5c131303ad9932bec4ef0a7e
+  data.tar.gz: 461e0e1ee4e169e86f9c314ef1d0985e8c7dc7f0922d810628cd8500603f0aa6c23f738612e1b0d4b60c7e07c702af4808b5f314bf7e7735a041fc07724a0188

data/lib/fukuzatsu/analyzer.rb

@@ -6,6 +6,8 @@ class Analyzer
 
   attr_accessor :content, :class_name, :edges, :nodes, :exits
 
+  DEFAULT_CLASS_NAME = "Unknown"
+
   def initialize(content)
     self.content = content
     self.edges = 0
@@ -18,17 +20,69 @@ class Analyzer
     self.edges - self.nodes + exits
   end
 
+  def class_name
+    find_class(parsed) || DEFAULT_CLASS_NAME
+  end
+
+  def methods
+    @methods ||= methods_from(parsed)
+  end
+
+  def constants
+    @constants ||= constants_from(parsed)
+  end
+
   def extract_methods
     @methods ||= methods_from(parsed)
   end
 
   def extract_class_name
-    return self.class_name if self.class_name
-    find_class(parsed) || "?"
+    return self.class_name if self.class_name && ! self.class_name.empty?
+    found = find_class(parsed)
+    self.class_name = ! found.empty? && found || DEFAULT_CLASS_NAME
   end
 
   private
 
+  def method_list
+    @method_list ||= method_names_from(parsed.children.first)
+  end
+
+  def method_names_from(node, found=[])
+    return found unless node.respond_to?(:type)
+    if node.type == :def || node.type == :defs
+      name = node.loc.name
+      found << content[name.begin_pos..name.end_pos - 1].to_sym
+    end
+    node.children.each do |child|
+      method_names_from(child, found) if parent_node?(child)
+    end
+    found
+  end
+
+  def constants_from(node, found=[])
+    if node.type == :const
+      expression = node.loc.expression
+      found << content[expression.begin_pos..expression.end_pos - 1]
+    end
+    node.children.each do |child|
+      constants_from(child, found) if parent_node?(child)
+    end
+    found.reject{ |constant| constant == class_name }
+  end
+
+  def extract_references_from(node, found=[])
+    return found unless node && node.respond_to?(:type)
+    if node.type == :send
+      reference = node.loc.expression
+      found << node.children.last
+    end
+    node.children.each do |child|
+      extract_references_from(child, found)
+    end
+    found.select{|name| method_list.include?(name)}
+  end
+
   def text_at(start_pos, end_pos)
     content[start_pos..end_pos - 1]
   end
@@ -50,7 +104,7 @@ class Analyzer
   end
 
   def methods_from(node, methods=[])
-    if node.type == :def || node.type == :defs || node.type == :class
+    if node.type == :def || node.type == :defs
       name = node.loc.name
       expression = node.loc.expression
       type = case(node.type)
@@ -64,7 +118,8 @@ class Analyzer
       methods << ParsedMethod.new(
         name: content[name.begin_pos..name.end_pos - 1],
         content: content[expression.begin_pos..expression.end_pos - 1],
-        type: type
+        type: type,
+        refs: extract_references_from(node)
       )
     end
     node.children.each do |child|
@@ -72,7 +127,7 @@ class Analyzer
         methods_from(child, methods)
       end
     end
-    methods
+    methods.reject{ |m| m.name.empty? }
   end
 
   def parent_node?(node)

data/lib/fukuzatsu/formatters/base.rb

@@ -8,7 +8,7 @@ module Formatters
       klass.send(:attr_accessor, :output_directory)
     end
 
-    def initialize(file, output_directory, source="")
+    def initialize(file, output_directory=nil, source="")
       self.file = file
       self.source = source
       self.output_directory = output_directory

data/lib/fukuzatsu/formatters/csv.rb

@@ -34,7 +34,7 @@ module Formatters
 
     def rows
       file.methods.map do |method|
-        "#{file.path_to_file},#{file.class_name},#{method.prefix}#{method.name},#{method.complexity}"
+        "#{file.path_to_file},#{file.class_name},#{method.name},#{method.complexity}"
       end.join("\r\n")
     end
 

data/lib/fukuzatsu/formatters/html_index.rb

@@ -6,7 +6,7 @@ module Formatters
 
     attr_reader :file_summary, :output_directory
 
-    def initialize(file_summary, output_directory)
+    def initialize(file_summary, output_directory=nil)
       @file_summary = file_summary
       @output_directory = output_directory
     end

data/lib/fukuzatsu/formatters/text.rb

@@ -47,7 +47,7 @@ module Formatters
 
     def wrap(string)
       return string if string.length < 25
-      string[0..24] << "..."
+      string[0..20] << "..."
     end
 
   end

data/lib/fukuzatsu/parsed_file.rb

@@ -1,21 +1,26 @@
 class ParsedFile
 
-  include PoroPlus
-  include Ephemeral::Base
-
-  attr_accessor :complexity, :path_to_file, :class_name, :path_to_results
   attr_accessor :lines_of_code, :source
+  attr_accessor :complexity, :path_to_file, :class_name, :path_to_results
+
+  def initialize(path_to_file: path_to_file, class_name: class_name=nil, complexity: complexity)
+    @path_to_file = path_to_file
+    @class_name = class_name
+    @lines_of_code = []
+    @complexity = complexity
+    @source = parse!
+  end
 
   def class_name
-    @class_name ||= analyzer.extract_class_name
+    @class_name ||= analyzer.class_name
   end
 
-  def content
-    @content ||= File.open(path_to_file, "r").read
+  def class_references
+    @class_references ||= analyzer.constants
   end
 
-  def analyzer
-    @analyzer ||= Analyzer.new(content)
+  def content
+    @content ||= File.open(path_to_file, "r").read
   end
 
   def average_complexity
@@ -27,7 +32,16 @@ class ParsedFile
   end
 
   def methods
-    @methods ||= analyzer.extract_methods
+    @methods ||= analyzer.methods
+  end
+
+  def method_counts
+    referenced_methods = methods.map(&:references).flatten
+    referenced_methods.inject({}) do |hash, method|
+      hash[method] ||= 0
+      hash[method] += 1
+      hash
+    end
   end
 
   def source
@@ -45,10 +59,31 @@ class ParsedFile
   def summary
     {
       path_to_file: self.path_to_file,
+      results_file: self.path_to_results,
       source: source,
       class_name: self.class_name,
       complexity: complexity
     }
   end
 
-end
+  private
+
+  def analyzer
+    @analyzer ||= Analyzer.new(content)
+  end
+
+  def content
+    @content ||= File.open(path_to_file, "r").read
+  end
+
+  def parse!
+    end_pos = 0
+    File.readlines(self.path_to_file).each_with_index do |line, index|
+      start_pos = end_pos + 1
+      end_pos += line.size
+      self.lines_of_code << LineOfCode.new(line_number: index + 1, range: (start_pos..end_pos))
+      line
+    end.join
+  end
+
+end

data/lib/fukuzatsu/parsed_method.rb

@@ -1,8 +1,14 @@
 class ParsedMethod
 
-  include PoroPlus
+  attr_reader :name, :content, :type, :complexity, :references
 
-  attr_accessor :name, :content, :type, :complexity
+  def initialize(name: name, content: content, type: type, refs: refs=[], complexity: complexity)
+    @name = name
+    @content = content
+    @type = type
+    @references = refs
+    @complexity = complexity
+  end
 
   def complexity
     @complexity ||= analyzer.complexity

data/lib/fukuzatsu/version.rb

@@ -1,3 +1,3 @@
 module Fukuzatsu
-  VERSION = "1.0.4"
+  VERSION = "1.0.5"
 end

data/spec/analyzer_spec.rb

@@ -22,7 +22,7 @@ describe Analyzer do
         expect(Analyzer.new(content_4).extract_class_name).to eq("Foo::Bar")
       end
     end
-  
+
     context "from Module; Class" do
       it "returns Extracted::Thing" do
         expect(Analyzer.new(content_6).extract_class_name).to eq("Extracted::Thing")
@@ -57,7 +57,7 @@ describe Analyzer do
 
     end
   end
-  
+
   describe "extract_class_name" do
     context "from a file with a class in it" do
       let(:analyzer) { Analyzer.new(File.read("spec/fixtures/single_class.rb")) }
@@ -68,18 +68,18 @@ describe Analyzer do
     context "from a file with a class inside a module" do
       let(:analyzer) { Analyzer.new(File.read("spec/fixtures/module_with_class.rb")) }
       it "should return the name of the class" do
-        expect(analyzer.extract_class_name).to eq "Bee"
+        expect(analyzer.extract_class_name).to eq "Symbolics::Insects::Bee"
       end
     end
     context "from a file with no class in it" do
       let(:analyzer) { Analyzer.new(File.read("spec/fixtures/single_method.rb")) }
-      it "should return '?'" do
-        expect(analyzer.extract_class_name).to eq "?"
+      it "should return 'Unknown'" do
+        expect(analyzer.extract_class_name).to eq "Unknown"
       end
     end
-    
+
   end
-  
+
   describe "extract_methods" do
     # Note: should implicitly trust private method #methods_from
     context "from a file with a single method" do
@@ -88,7 +88,7 @@ describe Analyzer 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"
+        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
@@ -102,22 +102,19 @@ 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"]
+        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"]
+        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
+        expect(analyzer.extract_methods.map { |m| m.name }).to eq ["#initialize", "#color"]
       end
     end
   end

data/spec/cli_spec.rb

@@ -30,12 +30,6 @@ describe "Fukuzatsu::CLI" 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'} }
@@ -51,35 +45,4 @@ describe "Fukuzatsu::CLI" do
     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/formatters/csv_spec.rb

@@ -2,32 +2,28 @@ 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"
+      type: :instance
     )
   }
   let (:method_2) { ParsedMethod.new(
       name: "report",
       complexity: 11,
-      type: "instance"
+      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
+  let(:parsed_file) { Struct.new(:path_to_file, :class_name) }
+  let(:mock_parsed_file) { parsed_file.new("fred/foo.rb", "Foo") }
+  let (:formatter) { Formatters::Csv.new(mock_parsed_file) }
 
   describe "#rows" do
     it "returns comma-separated rows" do
-      allow(parsed_file).to receive(:methods) { [method_1, method_2] }
+      allow(mock_parsed_file).to receive(:methods) { [method_1, method_2] }
       expect(formatter.rows).to eq(
-        "Foo,#initialize,13\r\nFoo,#report,11"
+        "fred/foo.rb,Foo,#initialize,13\r\nfred/foo.rb,Foo,#report,11"
       )
     end
   end

data/spec/formatters/html_spec.rb

@@ -2,23 +2,24 @@ require 'spec_helper'
 
 describe "Formatters::Text" do
 
-  let (:parsed_file) { ParsedFile.new(class_name: "Foo", complexity: 11) }
+  let(:parsed_file) { Struct.new(:path_to_file, :class_name)}
+  let(:mock_parsed_file) { parsed_file.new("fred/foo.rb", "Foo") }
   let (:method_1) { ParsedMethod.new(
       name: "initialize",
       complexity: 13,
-      type: "instance"
+      type: :instance
     )
   }
   let (:method_2) { ParsedMethod.new(
       name: "report",
       complexity: 11,
-      type: "instance"
+      type: :instance
     )
   }
-  let (:formatter) { Formatters::Html.new(parsed_file) }
+  let (:formatter) { Formatters::Html.new(mock_parsed_file) }
 
   before do
-    allow(parsed_file).to receive(:methods) { [method_1, method_2] }
+    allow(mock_parsed_file).to receive(:methods) { [method_1, method_2] }
   end
 
   describe "#header" do
@@ -33,7 +34,7 @@ describe "Formatters::Text" 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] }
+      allow(mock_parsed_file).to receive(:methods) { [method_1, method_2] }
       expect(formatter.rows).to eq(expected)
     end
   end

data/spec/formatters/text_spec.rb

@@ -15,19 +15,23 @@ describe "Formatters::Text" do
       type: "instance"
     )
   }
-  let (:formatter) { Formatters::Text.new(parsed_file) }
+
+
+  let(:parsed_file) { Struct.new(:path_to_file, :class_name, :average_complexity)}
+  let(:mock_parsed_file) { parsed_file.new("fred/foo.rb", "Foo", 12) }
+  let (:formatter) { Formatters::Text.new(mock_parsed_file) }
 
   describe "#header" do
-    it "returns a tab-separated header" do
-      expect(formatter.header).to eq "Foo\t\t11"
+    it "returns a header array" do
+      expect(formatter.header).to eq ["Class/Module", "Method", "Complexity"]
     end
   end
 
   describe "#rows" do
-    it "returns tab-separated rows" do
-      allow(parsed_file).to receive(:methods) { [method_1, method_2] }
+    it "returns formatted rows" do
+      allow(mock_parsed_file).to receive(:methods) { [method_1, method_2] }
       expect(formatter.rows).to eq(
-        ["Foo\t#initialize\t13", "Foo\t#report\t11"]
+        [["\e[31mFoo\e[0m", "\e[31m*initialize\e[0m", "\e[31m13\e[0m"], ["\e[33mFoo\e[0m", "\e[33m*report\e[0m", "\e[33m11\e[0m"]]
       )
     end
   end

data/spec/parsed_file_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ParsedFile do
 
-  let(:parsed_file) { ParsedFile.new(path_to_file: "bar/foo.rb") }
+  let(:parsed_file) { ParsedFile.new(path_to_file: "./spec/fixtures/eg_class.rb") }
   let(:analyzer)    { Analyzer.new("class Foo; end") }
 
   describe "#class_name" do
@@ -16,17 +16,17 @@ describe ParsedFile do
 
   describe "#content" do
     it "reads from file" do
-      allow(File).to receive(:open).with("bar/foo.rb", "r") {
+      allow(File).to receive(:open).with("./spec/fixtures/eg_class.rb", "r") {
         instance_double("File", read: "whatever")
       }
-      expect(parsed_file.content).to eq("whatever")
+      expect(parsed_file.send(: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"
+      expect(parsed_file.send(:analyzer).class.name).to eq "Analyzer"
     end
   end
 
@@ -45,19 +45,19 @@ describe ParsedFile do
       allow(parsed_file).to receive(:analyzer) { analyzer }
     end
     it "retrieves methods from analyzer" do
-      allow(analyzer).to receive(:extract_methods) { [:talk, :walk] }
+      allow(analyzer).to receive(: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(:path_to_results) { "doc/fukuzatsu/spec/fixtures/eg_class.rb" }
+      allow(parsed_file).to receive(:path_to_file) { "eg_class.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[:results_file]).to eq "doc/fukuzatsu/spec/fixtures/eg_class.rb"
+      expect(parsed_file.summary[:path_to_file]).to eq "eg_class.rb.htm"
       expect(parsed_file.summary[:class_name]).to eq "Foo"
       expect(parsed_file.summary[:complexity]).to eq 11
     end

data/spec/parsed_method_spec.rb

@@ -22,11 +22,11 @@ describe ParsedMethod do
 
   describe "#prefix" do
     it "returns '.' if its type is class" do
-      allow(parsed_method).to receive("type") { "class" }
+      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" }
+      allow(parsed_method).to receive("type") { :instance }
       expect(parsed_method.prefix).to eq "#"
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fukuzatsu
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Bantik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-07 00:00:00.000000000 Z
+date: 2014-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ephemeral
@@ -228,7 +228,6 @@ files:
 - 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
@@ -277,7 +276,6 @@ test_files:
 - 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
@@ -285,3 +283,4 @@ test_files:
 - spec/parsed_file_spec.rb
 - spec/parsed_method_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/spec/formatters/base_spec.rb

@@ -1,56 +0,0 @@
-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