analyst 0.13.1 → 0.14.0

data/spec/formatters/csv_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe "Formatters::Csv" do
-
-  let (:method_1) { ParsedMethod.new(
-      name: "initialize",
-      complexity: 13,
-      type: :instance
-    )
-  }
-  let (:method_2) { ParsedMethod.new(
-      name: "report",
-      complexity: 11,
-      type: :instance
-    )
-  }
-
-  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(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"
-      )
-    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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe "Formatters::HtmlIndex" do
-
-  let(:file_summary) {
-    [
-      {
-        results_file: "doc/analyst/file_1.rb.htm",
-        path_to_file: "file_1.rb",
-        class_name: "File_1",
-        complexity: 13
-      },
-      {
-        results_file: "doc/analyst/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

@@ -1,48 +0,0 @@
-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
-    )
-  }
-  let (:method_2) { ParsedMethod.new(
-      name: "report",
-      complexity: 11,
-      type: :instance
-    )
-  }
-  let (:formatter) { Formatters::Html.new(mock_parsed_file) }
-
-  before do
-    allow(mock_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(mock_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

@@ -1,39 +0,0 @@
-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(: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 header array" do
-      expect(formatter.header).to eq ["Class/Module", "Method", "Complexity"]
-    end
-  end
-
-  describe "#rows" do
-    it "returns formatted rows" do
-      allow(mock_parsed_file).to receive(:methods) { [method_1, method_2] }
-      expect(formatter.rows).to eq(
-        [["\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
-
-end

data/spec/parsed_file_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe ParsedFile do
-
-  let(:parsed_file) { ParsedFile.new(path_to_file: "./spec/fixtures/eg_class.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("./spec/fixtures/eg_class.rb", "r") {
-        instance_double("File", read: "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.send(: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(: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/analyst/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/analyst/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
-  end
-
-
-end

data/spec/parsed_method_spec.rb

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