fukuzatsu 1.0.6 → 2.1.1

data/lib/fukuzatsu/summary.rb

@@ -0,0 +1,101 @@
+module Fukuzatsu
+
+  class Summary
+
+    attr_reader :entity, :source_file, :container
+    attr_accessor :edges, :nodes, :exits, :summaries
+
+    BRANCHES = [
+      :if,
+      :or_asgn,
+      :and_sgn,
+      :or,
+      :and
+    ]
+
+    def self.from(content:, source_file:nil)
+      parser = Analyst.for_source(content)
+
+      containers = parser.top_level_entities.select{|e| e.respond_to? :all_methods}
+      containers << containers.map(&:classes)
+      containers.flatten!.reject!{ |container| container.all_methods.empty? }
+
+      containers.map do |container|
+        summary = Fukuzatsu::Summary.new(
+          container: container,
+          source: container.send(:source),
+          entity: container,
+          source_file: source_file
+        )
+        summary.summaries = container.all_methods.map do |method|
+          Fukuzatsu::Summary.new(
+            container: container,
+            source: method.send(:source),
+            entity: method,
+            source_file: source_file
+          )
+        end
+        summary
+      end
+    end
+
+    def initialize(source:, entity:, container:, source_file:nil, summaries:[])
+      @source = source
+      @entity = entity
+      @container = container
+      @source_file = source_file
+      @summaries = summaries
+      @edges, @nodes, @exits = [0, 1, 1]
+    end
+
+    def complexity
+      @complexity ||= begin
+        traverse(self.entity.ast)
+        self.edges - self.nodes + self.exits
+      end
+    end
+
+    def container_name
+      self.container.full_name
+    end
+
+    def is_class_or_module?
+      self.container == self.entity
+    end
+
+    def entity_name
+      return "*" if is_class_or_module?
+      self.entity.full_name.gsub(self.container.full_name, '')
+    end
+
+    def average_complexity
+      return 0 if self.summaries.blank?
+      self.summaries.map(&:complexity).reduce(&:+) / self.summaries.count.to_f
+    end
+
+    def raw_source
+      self.source_file && "\n#{File.open(self.source_file, "r").read}" || @source
+    end
+
+    private
+
+    def extend_graph
+      self.edges += 2
+      self.nodes += 2
+      self.exits += 1
+    end
+
+    def traverse(node, accumulator=[])
+      accumulator << node.type
+      extend_graph if BRANCHES.include?(node.type)
+      node.children.each do |child|
+        if child.respond_to?(:children) || child.respond_to?(:type)
+          accumulator << child.type
+          traverse(child, accumulator)
+        end
+      end
+      accumulator
+    end
+  end
+
+end

data/lib/fukuzatsu/version.rb

@@ -1,3 +1,3 @@
 module Fukuzatsu
-  VERSION = "1.0.6"
+  VERSION = "2.1.1"
 end

data/spec/cli_spec.rb

@@ -1,48 +1,15 @@
 require 'spec_helper'
 
-describe "Fukuzatsu::CLI" do
+describe Fukuzatsu::CLI do
 
-  let(:cli) { Fukuzatsu::CLI.new([
-      path: "foo/bar.rb",
-      format: 'text'
-    ]
-  )}
+  let(:cli) { Fukuzatsu::CLI.new }
 
-  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 "#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
+  describe "#check" do
+    it "invokes Fukuzatsu" do
+      expect(Fukuzatsu).to receive(:new) { Struct.new(:report).new("OK") }
+      cli.check("./fixtures")
     end
   end
 
 end
+

data/spec/fixtures/class.rb

@@ -0,0 +1,30 @@
+# complexity:5
+class Spaghetti
+
+  def toppings
+
+    if rand(10) < 5
+      return "meatball"
+    end
+
+    if 1 < 5
+      return 'tomato'
+    else
+      if 4 ==5
+        if 2 > 0
+          return "parmesan"
+        else
+          return "romano"
+        end
+      else
+        if 2 > 0
+          return "alfredo"
+        else
+          return "gravy"
+        end
+      end
+    end
+
+  end
+
+end

data/spec/fixtures/module.rb

@@ -0,0 +1,12 @@
+# complexity:1
+module HasToppings
+
+  def random_topping
+    if rand(10) < 5
+      return "meatball"
+    else
+      return "pepperoni"
+    end
+  end
+
+end

data/spec/fixtures/procedural.rb

@@ -0,0 +1,8 @@
+# complexity:2
+def spaghetti
+  if 1 < 5
+    p 'hi'
+  else
+    "hello" || "goodbye"
+  end
+end

data/spec/formatters/csv_spec.rb

@@ -1,36 +1,58 @@
 require 'spec_helper'
 
-describe "Formatters::Csv" do
+describe Fukuzatsu::Formatters::Csv do
 
-  let (:method_1) { ParsedMethod.new(
-      name: "initialize",
-      complexity: 13,
-      type: :instance
+  let (:method_summary_1) { Fukuzatsu::Summary.new(
+      :source => "",
+      :source_file => "foo.rb",
+      :entity => "::initialize",
+      :container => "Foo",
+      :summaries => []
     )
   }
-  let (:method_2) { ParsedMethod.new(
-      name: "report",
-      complexity: 11,
-      type: :instance
+
+  let (:method_summary_2) { Fukuzatsu::Summary.new(
+      :source => "",
+      :source_file => "foo.rb",
+      :entity => "#print",
+      :container => "Foo",
+      :summaries => []
     )
   }
 
-  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) }
+  let (:summary) { Fukuzatsu::Summary.new(
+      :source => "",
+      :source_file => "foo.rb",
+      :entity => "Foo",
+      :container => "Foo",
+      :summaries => [method_summary_1, method_summary_2]
+    )
+  }
+
+  let (:formatter) { Fukuzatsu::Formatters::Csv.new(summary: summary) }
 
   describe "#rows" do
-    it "returns comma-separated rows" do
-      allow(mock_parsed_file).to receive(:methods) { [method_1, method_2] }
-      expect(formatter.rows).to eq(
-        "fred/foo.rb,Foo,#initialize,13\r\nfred/foo.rb,Foo,#report,11"
-      )
+
+    before do
+      allow(summary).to receive(:container_name).and_return("Foo")
+      allow(summary).to receive(:entity_name).and_return("*")
+      allow(summary).to receive(:complexity).and_return(13)
+      allow(summary).to receive(:averge_complexity).and_return(11)
+      allow(method_summary_1).to receive(:container_name).and_return("Foo")
+      allow(method_summary_1).to receive(:entity_name).and_return("::initialize")
+      allow(method_summary_1).to receive(:complexity).and_return(13)
+      allow(method_summary_2).to receive(:container_name).and_return("Foo")
+      allow(method_summary_2).to receive(:entity_name).and_return("#report")
+      allow(method_summary_2).to receive(:complexity).and_return(11)
     end
-  end
 
-  describe "#file_extension" do
-    it "returns the proper extension" do
-      expect(formatter.file_extension).to eq ".csv"
+    it "returns formatted rows" do
+      expect(formatter.rows).to eq(
+        [
+          ["foo.rb","Foo","::initialize",13].join(","),
+          ["foo.rb","Foo","#report",11].join(","),
+        ].join("\r\n")
+      )
     end
   end
 

data/spec/formatters/html_spec.rb

@@ -1,26 +1,32 @@
 require 'spec_helper'
 
-describe "Formatters::Text" do
-
-  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
+describe "Fukuzatsu::Formatters::HTML" do
+
+  let (:method_summary_1) { Fukuzatsu::Summary.new(
+      :source => "foo.rb",
+      :entity => "::initialize",
+      :container => "Foo",
+      :summaries => []
     )
   }
-  let (:method_2) { ParsedMethod.new(
-      name: "report",
-      complexity: 11,
-      type: :instance
+
+  let (:method_summary_2) { Fukuzatsu::Summary.new(
+      :source => "foo.rb",
+      :entity => "#print",
+      :container => "Foo",
+      :summaries => []
     )
   }
-  let (:formatter) { Formatters::Html.new(mock_parsed_file) }
 
-  before do
-    allow(mock_parsed_file).to receive(:methods) { [method_1, method_2] }
-  end
+  let (:summary) { Fukuzatsu::Summary.new(
+      :source => "foo.rb",
+      :entity => "Foo",
+      :container => "Foo",
+      :summaries => [method_summary_1, method_summary_2]
+    )
+  }
+
+  let (:formatter) { Fukuzatsu::Formatters::Html.new(summary: summary) }
 
   describe "#header" do
     it "returns an HTML-formatted header" do
@@ -31,10 +37,23 @@ describe "Formatters::Text" do
   end
 
   describe "#rows" do
+
+    before do
+      allow(summary).to receive(:container_name).and_return("Foo")
+      allow(summary).to receive(:entity_name).and_return("*")
+      allow(summary).to receive(:complexity).and_return(13)
+      allow(summary).to receive(:averge_complexity).and_return(11)
+      allow(method_summary_1).to receive(:container_name).and_return("Foo")
+      allow(method_summary_1).to receive(:entity_name).and_return("::initialize")
+      allow(method_summary_1).to receive(:complexity).and_return(13)
+      allow(method_summary_2).to receive(:container_name).and_return("Foo")
+      allow(method_summary_2).to receive(:entity_name).and_return("#report")
+      allow(method_summary_2).to receive(:complexity).and_return(11)
+    end
+
     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='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(mock_parsed_file).to receive(:methods) { [method_1, method_2] }
       expect(formatter.rows).to eq(expected)
     end
   end
@@ -45,4 +64,4 @@ describe "Formatters::Text" do
     end
   end
 
-end
+end

data/spec/formatters/json_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe "Fukuzatsu::Formatters::Json" do
+
+  let (:method_summary_1) { Fukuzatsu::Summary.new(
+      :source => "",
+      :source_file => "foo.rb",
+      :entity => "::initialize",
+      :container => "Foo",
+      :summaries => []
+    )
+  }
+
+  let (:method_summary_2) { Fukuzatsu::Summary.new(
+      :source => "",
+      :source_file => "foo.rb",
+      :entity => "#print",
+      :container => "Foo",
+      :summaries => []
+    )
+  }
+
+  let (:summary) { Fukuzatsu::Summary.new(
+      :source => "",
+      :source_file => "foo.rb",
+      :entity => "Foo",
+      :container => "Foo",
+      :summaries => [method_summary_1, method_summary_2]
+    )
+  }
+
+  let (:formatter) { Fukuzatsu::Formatters::Json.new(summary: summary) }
+
+  describe "#to_json" do
+
+    before do
+      allow(summary).to receive(:container_name).and_return("Foo")
+      allow(summary).to receive(:entity_name).and_return("*")
+      allow(summary).to receive(:complexity).and_return(13)
+      allow(summary).to receive(:average_complexity).and_return(11)
+      allow(method_summary_1).to receive(:container_name).and_return("Foo")
+      allow(method_summary_1).to receive(:entity_name).and_return("::initialize")
+      allow(method_summary_1).to receive(:complexity).and_return(13)
+      allow(method_summary_2).to receive(:container_name).and_return("Foo")
+      allow(method_summary_2).to receive(:entity_name).and_return("#print")
+      allow(method_summary_2).to receive(:complexity).and_return(11)
+    end
+
+    it "returns JSON" do
+      expected = {
+        source_file: "foo.rb",
+        object: "Foo",
+        name: "*",
+        complexity: 13,
+        average_complexity: 11,
+        methods: [
+          {
+            source_file: "foo.rb",
+            object: "Foo",
+            name: "::initialize",
+            complexity: 13
+          },
+          {
+            source_file: "foo.rb",
+            object: "Foo",
+            name: "#print",
+            complexity: 11
+          },
+        ]
+      }.to_json
+      expect(formatter.content).to eq(expected)
+    end
+  end
+
+  describe "#file_extension" do
+    it "returns the proper extension" do
+      expect(formatter.file_extension).to eq ".json"
+    end
+  end
+
+end