fukuzatsu 1.0.6 → 2.1.1

data/lib/fukuzatsu/parsed_file.rb

@@ -1,89 +0,0 @@
-class ParsedFile
-
-  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.class_name
-  end
-
-  def class_references
-    @class_references ||= analyzer.constants
-  end
-
-  def content
-    @content ||= File.open(path_to_file, "r").read
-  end
-
-  def average_complexity
-    methods.map(&:complexity).reduce(:+) / methods.count.to_f
-  end
-
-  def complexity
-    @complexity ||= analyzer.complexity
-  end
-
-  def 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
-    return @source if @source
-    end_pos = 0
-    self.lines_of_code = []
-    @source = 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
-
-  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
-
-  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,32 +0,0 @@
-class ParsedMethod
-
-  attr_reader :name, :content, :type, :complexity, :references
-
-  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
-  end
-
-  def name
-    return "" if self.type == :none
-    "#{prefix}#{@name}"
-  end
-
-  def prefix
-    return "." if self.type == :class
-    return "#" if self.type == :instance
-    return "*"
-  end
-
-  def analyzer
-    Analyzer.new(self.content)
-  end
-
-end

data/spec/analyzer_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-describe Analyzer do
-
-  let(:content_1)   { File.read("spec/fixtures/program_1.rb") }
-  let(:content_2)   { File.read("spec/fixtures/program_2.rb") }
-  let(:content_3)   { File.read("spec/fixtures/eg_class.rb") }
-  let(:content_4)   { File.read("spec/fixtures/eg_mod_class.rb") }
-  let(:content_5)   { File.read("spec/fixtures/eg_module.rb") }
-  let(:content_6)   { File.read("spec/fixtures/eg_mod_class_2.rb") }
-
-  context "#extract_class_name" do
-
-    context "from Class Foo" do
-      it "returns Foo" do
-        expect(Analyzer.new(content_3).extract_class_name).to eq("Foo")
-      end
-    end
-
-    context "from Module::Class Foo" do
-      it "returns Foo::Bar" 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")
-      end
-    end
-
-    context "from Module" do
-      it "returns Something" do
-        expect(Analyzer.new(content_5).extract_class_name).to eq("Something")
-      end
-    end
-  end
-
-  describe "#complexity" do
-    context "program_1" do
-
-      let(:analyzer)  { Analyzer.new(content_1) }
-
-      it "matches the manual calculation of complexity of 4" do
-        expect(analyzer.complexity).to eq(4)
-      end
-
-    end
-
-    context "program_2" do
-
-      let(:analyzer)  { Analyzer.new(content_2) }
-
-      it "matches the manual calculation of complexity of 5" do
-        expect(analyzer.complexity).to eq(5)
-      end
-
-    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")) }
-      it "should return the name of the class" do
-        expect(analyzer.extract_class_name).to eq "Gown"
-      end
-    end
-    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 "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 '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
-      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 ["#initialize", "#color"]
-      end
-    end
-  end
-
-end

data/spec/fixtures/eg_class.rb

@@ -1,8 +0,0 @@
-require 'fukuzatsu'
-
-class Foo
-  def say_hello
-    "Oh hi there."
-  end
-end
-

data/spec/fixtures/eg_mod_class.rb

@@ -1,2 +0,0 @@
-class Foo::Bar
-end

data/spec/fixtures/eg_mod_class_2.rb

@@ -1,5 +0,0 @@
-module Extracted
-  class Thing
-  end
-end
-

data/spec/fixtures/eg_module.rb

@@ -1,2 +0,0 @@
-module Something
-end

data/spec/fixtures/module_with_class.rb

@@ -1,9 +0,0 @@
-module Symbolics
-  module Insects
-    class Bee
-      def correspond(letter)
-        @letter = letter
-      end
-    end
-  end
-end

data/spec/fixtures/multiple_methods.rb

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

@@ -1,8 +0,0 @@
-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/program_1.rb

@@ -1,19 +0,0 @@
-def spaghetti
-  if 1 < 5
-    p 'hi'
-  else
-    if 4 ==5
-      if 2 > 0
-        p 'bye'
-      else
-        p 'see ya'
-      end
-    else
-      if 2 > 0
-        p 'bye'
-      else
-        p 'see ya'
-      end
-    end
-  end
-end

data/spec/fixtures/program_2.rb

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

data/spec/fixtures/program_3.rb

@@ -1,66 +0,0 @@
-require 'fukuzatsu'
-
-class Breathalizer
-
-  INDICATORS = [
-    :if,
-    :def,
-  ]
-
-  attr_accessor :path_to_file, :edges, :nodes, :exits, :accumulator
-
-  def self.parse!(path_to_file)
-    new(path_to_file).parse
-  end
-
-  def initialize(path_to_file)
-    self.accumulator = []
-    self.edges = 0
-    self.nodes = 1
-    self.exits = 1
-    self.path_to_file = path_to_file
-  end
-
-  def file_contents
-    contents ||= File.open(path_to_file, "r").read
-  end
-
-  def parsed
-    @parsed ||= Parser::CurrentRuby.parse(file_contents)
-  end
-
-  def parse!
-    traverse(parsed)
-    complexity
-  end
-
-  def traverse(node)#, accumulator=[])
-
-    accumulator << node.type
-
-    if node.type == :if || node.type == :begin
-      self.edges += 2
-      self.nodes += 2
-      self.exits += 1
-    elsif node.type == :def
-      self.edges += 1
-      self.nodes += 1
-      self.exits += 1
-    end
-
-    node.children.each do |child|
-      if child.respond_to?(:type) || child.respond_to?(:children)
-        accumulator << child.type
-        traverse(child, accumulator)
-      else
-      end
-    end
-  end
-
-  def complexity
-    p "edges = #{self.edges}, nodes = #{self.nodes}, exits = #{self.exits}"
-    self.edges - self.nodes + exits
-  end
-
-end
-

data/spec/fixtures/program_4.rb

@@ -1 +0,0 @@
-program_4.rb

data/spec/fixtures/single_class.rb

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

data/spec/fixtures/single_method.rb

@@ -1,3 +0,0 @@
-def read_poem
-  return "I meant to find her when I came/Death had the same design"
-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/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