code_poetry 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4351c2bdcf92e1b45ec1dace93b7923afca53c3f
-  data.tar.gz: 753445520ef195ff57eecc8697e93486ebd370fe
+  metadata.gz: d4067a9440e714228bbb8e47e2ca38d7a9bb6f60
+  data.tar.gz: 3664dc167f75e0b183b7437e1ec1b92cb8d36448
 SHA512:
-  metadata.gz: 0756a302d0bd0b14477e6dbd36b77c7aa9fb5c86428b8171635fa245c1e9b985ce0a57bb0ee9902c0946f6b27a9e253a0fad15db5713238acdad948829deb5c3
-  data.tar.gz: 3ad8999a9690de69339b9af840f0e6a1733d206c3b18767873ed2b9477ff2864e0bcb8d59a29883a800708f6e00db75834305dec01d005e44529d924b80c843f
+  metadata.gz: 8e3ca8381b8338b0a31a7e2c79b7a57987e21db4821b8ebbeb2647d4611e02c046c078ff0c63822cef808a79c6c2cad226c270d4561b311f07de3ab4265e3046
+  data.tar.gz: 153fdd0e09f92ad22993e2d8800709b265ac0b29ddc5cae3fb65506c7dc72049e6778056bdf26c9dab0f8598731da7f9e04ada6e35db91f94d191e0ee22fb4e8

data/.hound.yml

@@ -0,0 +1,7 @@
+AccessModifierIndentation:
+  Description: Check indentation of private/protected visibility modifiers.
+  Enabled: false
+
+LineLength:
+  Description: 'Limit lines to 100 characters.'
+  Max: 100

data/README.md

@@ -10,7 +10,8 @@ Currently it uses the following metrics:
 
 * Lines of Code
 * Churns [[Churn][ch]]
-* Code Complexity [[Flog][fl]]
+* Code Complexity [[Flog][flog]]
+* Duplication [[Flay][flay]]
 
 ## Installation
 
@@ -47,4 +48,5 @@ This will generate a HTML report to ```metrics/index.html```.
 
 [cc]: https://codeclimate.com
 [ch]: https://github.com/danmayer/churn
-[fl]: https://github.com/seattlerb/flog
+[flog]: https://github.com/seattlerb/flog
+[flay]: https://github.com/seattlerb/flay

data/Rakefile

@@ -3,7 +3,7 @@ require 'bundler/gem_tasks'
 
 Rake::TestTask.new do |test|
   test.verbose = true
-  test.libs << "spec"
+  test.libs << 'spec'
   test.test_files = FileList['spec/**/*_spec.rb']
 end
 

data/code_poetry.gemspec

@@ -21,7 +21,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
 
-  spec.add_runtime_dependency 'code_poetry-html', ['~> 0.1']
+  spec.add_runtime_dependency 'code_poetry-html', ['~> 0.2']
   spec.add_runtime_dependency 'churn',            ['~> 0.0']
   spec.add_runtime_dependency 'flog',             ['~> 4.2']
+  spec.add_runtime_dependency 'flay',             ['~> 2.4']
 end

data/lib/code_poetry/calculator.rb

@@ -1,6 +1,6 @@
-require 'churn/churn_calculator'
-require 'flog_cli'
-require 'ripper'
+require 'churn/calculator'
+require 'code_poetry/complexity_calculator'
+require 'code_poetry/duplication_calculator'
 
 module CodePoetry
   class Calculator
@@ -14,18 +14,13 @@ module CodePoetry
       puts 'Calculating'
 
       measure_churns
+      measure_complexity
+      measure_duplication
 
-      @files.each do |file|
-        stat = Stat.new(file)
-
-        stat.set_churns(@churns[file])
-        measure_flog(stat)
+      @stats.each do |stat|
+        stat.set_churns(@churns[stat.file])
         stat.set_smells
-
-        @stats << stat
       end
-
-      @stats
     end
 
   private
@@ -38,23 +33,16 @@ module CodePoetry
       end
     end
 
-    def measure_flog(stat)
-      flogger = FlogCLI.new(all: true)
-      flogger.flog(stat.file)
-      flogger.calculate
-
-      unless flogger.scores.empty?
-        klass                      = flogger.scores.first[0]
-        stat.complexity            = flogger.total_score.round(0)
-        stat.complexity_per_method = flogger.average.round(0)
-
-        flogger.method_scores[klass].each do |name, score|
-          name = (name.match(/#(.+)/) || name.match(/::(.+)/))[1]
-          stat.set_method_complexity(name, score)
-        end
+    def measure_complexity
+      @files.each do |file|
+        stat = Stat.new(file)
+        ComplexityCalculator.new(stat).measure
+        @stats << stat
       end
+    end
 
-      stat.definition_complexity = stat.definition_complexity.round(0)
+    def measure_duplication
+      DuplicationCalculator.new(@files, @stats).measure
     end
   end
 end

data/lib/code_poetry/cli.rb

@@ -5,13 +5,26 @@ require 'code_poetry-html'
 
 module CodePoetry
   class CLI
-    def self.excecute
-      files = Array(FileList['app/**/*.rb']).compact
+    DIRECOTRIES = 'app,lib'
+    EXTENSIONS = 'rb,rake'
+
+    def self.excecute(path)
+      files = Array(expand_directories_to_files(path).sort).compact
       calculator = Calculator.new(files)
       stats = calculator.calculate
 
       formatter = CodePoetry::Formatter::HTMLFormatter.new
       formatter.format(stats)
     end
+
+  private
+
+    def self.expand_directories_to_files(path)
+      if path
+        Dir[File.join(path, "{#{DIRECOTRIES}}**", '**', "*.{#{EXTENSIONS}}")]
+      else
+        FileList[File.join("{#{DIRECOTRIES}}**", '**', "*.{#{EXTENSIONS}}")]
+      end
+    end
   end
 end

data/lib/code_poetry/complexity_calculator.rb

@@ -0,0 +1,42 @@
+require 'flog_cli'
+
+module CodePoetry
+  class ComplexityCalculator
+    def initialize(stat)
+      @stat    = stat
+      @flogger = FlogCLI.new(all: true)
+    end
+
+    def measure
+      flog_file
+
+      unless @flogger.scores.empty?
+        set_file_complexity
+        set_methods_complexity
+      end
+
+      @stat.round_definition_complexity
+    end
+
+  private
+
+    def flog_file
+      @flogger.flog(@stat.file)
+      @flogger.calculate
+    end
+
+    def set_file_complexity
+      @stat.complexity            = @flogger.total_score.round(0)
+      @stat.complexity_per_method = @flogger.average.round(0)
+    end
+
+    def set_methods_complexity
+      klass = @flogger.scores.first[0]
+
+      @flogger.method_scores[klass].each do |name, score|
+        name = (name.match(/#(.+)/) || name.match(/::(.+)/))[1]
+        @stat.set_method_complexity(name, score)
+      end
+    end
+  end
+end

data/lib/code_poetry/duplication_calculator.rb

@@ -0,0 +1,76 @@
+require 'flay'
+
+module CodePoetry
+  class DuplicationCalculator
+    def initialize(files, stats)
+      @files = files
+      @stats = stats
+      @flay  = Flay.new
+    end
+
+    def measure
+      flay_files
+
+      sorted_flays.each do |hash, mass|
+        evaluate_flay(hash, mass)
+      end
+    end
+
+  private
+
+    def flay_files
+      @flay.process(*@files)
+      @flay.analyze
+    end
+
+    def sorted_flays
+      @flay.masses.sort_by do |h, m|
+        [
+          -m,
+          @flay.hashes[h].first.file,
+          @flay.hashes[h].first.line,
+          @flay.hashes[h].first.first.to_s
+        ]
+      end
+    end
+
+    def evaluate_flay(hash, mass)
+      nodes = fetch_nodes(hash)
+
+      stats, methods = fetch_stats_and_methods(nodes)
+
+      stats.each do |stat, method|
+        stat.duplications << Duplication.new(severity(hash), note_type(nodes), mass, methods)
+      end
+    end
+
+    def fetch_nodes(hash)
+      @flay.hashes[hash].sort_by { |node| [node.file, node.line] }
+    end
+
+    def fetch_stats_and_methods(nodes)
+      nodes.inject([[], []]) do |result, node|
+        stat = find_stat(node.file)
+        result[0] << stat
+
+        method = stat.get_method_at_line(node.line)
+        method.increase_duplication_count
+        result[1] << method
+
+        result
+      end
+    end
+
+    def find_stat(filename)
+      @stats.detect { |stat| stat.file == filename }
+    end
+
+    def severity(hash)
+      @flay.identical[hash] ? 'Identical' : 'Similar'
+    end
+
+    def note_type(nodes)
+      nodes.first.first
+    end
+  end
+end

data/lib/code_poetry/method.rb

@@ -1,22 +1,38 @@
 module CodePoetry
   class Method
-    attr_accessor :node, :name, :first_line, :last_line, :complexity
-
-    def initialize(node, name, first_line, last_line)
-      @node       = node
-      @name       = name
-      @first_line = first_line
-      @last_line  = last_line
-      @complexity = 0
+    attr_reader :first_line, :last_line, :name
+    attr_accessor :complexity, :duplication_count, :node
+
+    def initialize(node, name, first_line, last_line, location)
+      @node              = node
+      @name              = name
+      @first_line        = first_line
+      @last_line         = last_line
+      @complexity        = 0
+      @duplication_count = 0
+
+      @location = location
     end
 
     def smelly?
-      complexity > 25
+      @complexity > 25
+    end
+
+    def duplicated?
+      @duplication_count > 0
     end
 
     def pretty_name
-      symbol = node == :def ? "." : "#"
-      name.prepend(symbol)
+      symbol = @node == :def ? '.' : '#'
+      "#{symbol}#{@name}"
+    end
+
+    def pretty_location
+      "#{@location}:#{@first_line}..#{@last_line}"
+    end
+
+    def increase_duplication_count
+      @duplication_count =+ 1
     end
 
   end

data/lib/code_poetry/railtie.rb

@@ -5,7 +5,7 @@ module CodePoetry
     railtie_name :code_poetry
 
     rake_tasks do
-      load "tasks/code_poetry.rake"
+      load 'tasks/code_poetry.rake'
     end
   end
 end

data/lib/code_poetry/stat.rb

@@ -1,18 +1,22 @@
 require 'code_poetry/method'
 require 'code_poetry/warning_scanner'
-require 'code_poetry/smell'
+require 'ripper'
 
 module CodePoetry
+  Duplication = Struct.new(:severity, :node, :mass, :methods)
+  Smell = Struct.new(:type, :object)
+
   class Stat
-    attr_accessor :file, :name, :lines, :lines_of_code, :churns, :complexity, :methods, :smells
-    attr_accessor :complexity_per_method, :definition_complexity
+    attr_reader :duplication, :file, :lines, :lines_of_code, :name, :methods
+    attr_accessor :churns, :complexity, :complexity_per_method, :definition_complexity
+    attr_accessor :duplications, :smells
 
     def initialize(file)
-      @lines_of_code, @churns, @complexity, @complexity_per_method, @definition_complexity = 0, 0, 0, 0, 0
-      @file    = file
-      @lines   = {}
-      @methods = []
-      @smells  = []
+      @file = file
+      @lines_of_code, @churns = 0, 0
+      @complexity, @complexity_per_method, @definition_complexity = 0, 0, 0
+      @methods, @smells, @duplications = [], [], []
+      @lines = {}
 
       parse_file
     end
@@ -22,7 +26,7 @@ module CodePoetry
     end
 
     def get_method(name)
-      @methods.find{|method| method.name == name}
+      @methods.detect { |method| method.name == name }
     end
 
     def set_method_complexity(name, score)
@@ -34,18 +38,27 @@ module CodePoetry
     end
 
     def get_method_at_line(line)
-      @methods.find{|method| method.first_line <= line && method.last_line >= line}
+      @methods.detect { |method| method.first_line <= line && method.last_line >= line }
     end
 
     def set_smells
       set_class_smells
       set_method_smells
+      set_duplication_smells
+    end
+
+    def duplication
+      @duplications.map { |duplication| duplication.mass / duplication.methods.count }.inject(0, :+)
+    end
+
+    def round_definition_complexity
+      @definition_complexity = @definition_complexity.round(0)
     end
 
   private
 
     def parse_file
-      @content = File.open(@file, "r").read
+      @content = File.open(@file, 'r').read
       @indentation_warnings = indentation_warnings
 
       set_name
@@ -54,7 +67,7 @@ module CodePoetry
     end
 
     def set_name
-      @content = File.open(@file, "r").read
+      @content = File.open(@file, 'r').read
 
       if match = /^\s*class\s+(\S+)/.match(@content) || /^\s*module\s+(\S+)/.match(@content)
         @name = match[1]
@@ -84,13 +97,13 @@ module CodePoetry
           name, first_line = find_method_params(element)
 
           if @indentation_warnings['def'] && @indentation_warnings['def'].any? { |first, last| first == first_line }
-            warning = @indentation_warnings['def'].find{|first, last| first == first_line}
+            warning = @indentation_warnings['def'].detect{ |first, last| first == first_line }
             last_line = warning[1]
           else
             last_line = find_last_line(name, first_line)
           end
 
-          @methods << Method.new(element.first, name, first_line, last_line)
+          @methods << Method.new(element.first, name, first_line, last_line, @file)
         else
           scan_sexp(element)
         end
@@ -105,6 +118,11 @@ module CodePoetry
       end
     end
 
+    def indentation_warnings
+      warning_scanner = WarningScanner.new
+      warning_scanner.scan(@content)
+    end
+
     def find_last_line(token_name, line)
       token_indentation = @lines[line].index('def')
 
@@ -112,19 +130,26 @@ module CodePoetry
       last_line ? last_line + line + 1 : nil
     end
 
-    def indentation_warnings
-      warning_scanner = WarningScanner.new
-      warning_scanner.scan(@content)
-    end
-
     def set_class_smells
-      @smells << Smell.new("ComplexClass")           if @complexity > 150
-      @smells << Smell.new("ComplexClassDefinition") if @definition_complexity > 40
+      @smells << Smell.new('complex_class', nil)            if @complexity > 150
+      @smells << Smell.new('complex_class_definition', nil) if @definition_complexity > 40
     end
 
     def set_method_smells
-      smelly_methods = @methods.select{|method| method.smelly?}
-      @smells.concat smelly_methods.map{|method| Smell.new("ComplexMethod", method)}
+      smelly_methods = @methods.select { |method| method.smelly? }
+      @smells.concat smelly_methods.map { |method| Smell.new('complex_method', method) }
+    end
+
+    def set_duplication_smells
+      unique_duplications = []
+
+      @duplications.each do |duplication|
+        unless unique_duplications.any? { |d| d.methods == duplication.methods }
+          unique_duplications << duplication
+        end
+      end
+
+      @smells.concat unique_duplications.map { |duplication| Smell.new('duplication', duplication) }
     end
   end
 end

data/lib/code_poetry/version.rb

@@ -1,3 +1,3 @@
 module CodePoetry
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

data/lib/code_poetry.rb

@@ -9,7 +9,6 @@ module CodePoetry
   end
 
   class << self
-
     def root
       return @root if defined? @root
       @root = File.expand_path(Dir.getwd)
@@ -29,6 +28,5 @@ module CodePoetry
     def project_name
       File.basename(root.split('/').last).capitalize.gsub('_', ' ')
     end
-
   end
 end

data/lib/tasks/code_poetry.rake

@@ -1,5 +1,8 @@
 desc "Generate code metrics"
-task :metrics do
+task :metrics, :path do |t, args|
   require 'code_poetry/cli'
-  CodePoetry::CLI.excecute
+
+  path = ARGV.last unless ARGV.last == 'metrics'
+
+  CodePoetry::CLI.excecute(path)
 end

data/spec/method_spec.rb

@@ -2,28 +2,52 @@ require 'spec_helper'
 require_relative '../lib/code_poetry/method'
 
 describe CodePoetry::Method do
-  let(:method) { CodePoetry::Method.new(:def, "smelly?", 8, 10) }
+  let(:method) { CodePoetry::Method.new(:def, 'smelly?', 8, 10, 'path') }
 
-  describe ".smell?" do
-    it "returns true if the complexity is greater 25" do
+  describe '#smelly?' do
+    it 'returns true if the complexity is greater 25' do
       method.complexity = 26
       expect(method.smelly?).to be_true
     end
 
-    it "returns false if the complexity is less or equal 25" do
+    it 'returns false if the complexity is less or equal 25' do
       method.complexity = 25
       expect(method.smelly?).to be_false
     end
   end
 
-  describe ".pretty_name" do
-    it "prepends a '.' to the name if the method is an instance method" do
-      expect(method.pretty_name).to eq(".smelly?")
+  describe '#duplicated?' do
+    it 'returns true if the duplication count is greater 0' do
+      method.duplication_count = 1
+      expect(method.duplicated?).to be_true
     end
 
-    it "prepends a '#' to the name if the method is an class method" do
+    it 'returns false if the duplication count is equal 0' do
+      method.duplication_count = 0
+      expect(method.duplicated?).to be_false
+    end
+  end
+
+  describe '#pretty_name' do
+    it 'prepends a "." to the name if the method is an instance method' do
+      expect(method.pretty_name).to eq('.smelly?')
+    end
+
+    it 'prepends a "#" to the name if the method is an class method' do
       method.node = :defs
-      expect(method.pretty_name).to eq("#smelly?")
+      expect(method.pretty_name).to eq('#smelly?')
+    end
+  end
+
+  describe '#pretty_location' do
+    it 'something' do
+      expect(method.pretty_location).to eq('path:8..10')
+    end
+  end
+
+  describe '#increase_duplication_count' do
+    it 'increases the duplication count by 1' do
+      expect { method.increase_duplication_count }.to change { method.duplication_count }.by(1)
     end
   end
 end

data/spec/stat_spec.rb

@@ -1,133 +1,145 @@
 require 'spec_helper'
-require 'ripper'
 require_relative '../lib/code_poetry/stat'
 
 describe CodePoetry::Stat do
-  let(:stat) { CodePoetry::Stat.new(test_file(1)) }
+  before(:all) { @stat = CodePoetry::Stat.new(test_file(2)) }
+  after(:each) { @stat.smells = [] }
 
-  describe ".initialize" do
-    it "sets the correct stat name" do
-      expect(stat.name).to eq("Foo")
+  describe '#initialize' do
+    it 'sets the correct stat name' do
+      expect(@stat.name).to eq('Foo')
     end
 
-    it "counts the correct number of lines and lines of code" do
-      expect(stat.lines.count).to   eq(11)
-      expect(stat.lines_of_code).to eq(8)
+    it 'counts the correct number of lines and lines of code' do
+      expect(@stat.lines.count).to eq(11)
+      expect(@stat.lines_of_code).to eq(8)
     end
 
-    it "sets the methods correctly" do
-      expect(stat.methods.count).to eq(2)
+    it 'sets the methods correctly' do
+      expect(@stat.methods.count).to eq(2)
 
-      method = stat.get_method("bar?")
-      expect(method.node).to       eq(:defs)
+      method = @stat.get_method('bar?')
+      expect(method.node).to eq(:defs)
       expect(method.first_line).to eq(3)
-      expect(method.last_line).to  eq(5)
+      expect(method.last_line).to eq(5)
 
-      method = stat.get_method("fooz?")
-      expect(method.node).to       eq(:def)
+      method = @stat.get_method('fooz?')
+      expect(method.node).to eq(:def)
       expect(method.first_line).to eq(7)
-      expect(method.last_line).to  eq(9)
+      expect(method.last_line).to eq(9)
     end
+  end
 
-    it "sets the methods correctly even if they have indentation errors" do
-      stat = CodePoetry::Stat.new(test_file(2))
-
-      expect(stat.methods.count).to eq(2)
+  describe '#set_churns' do
+    it 'sets the churns' do
+      @stat.set_churns(10)
 
-      method = stat.get_method("bar?")
-      expect(method.node).to       eq(:defs)
-      expect(method.first_line).to eq(3)
-      expect(method.last_line).to  eq(5)
+      expect(@stat.churns).to eq(10)
+    end
 
-      method = stat.get_method("fooz?")
-      expect(method.node).to       eq(:def)
-      expect(method.first_line).to eq(7)
-      expect(method.last_line).to  eq(9)
+    it 'leaves the churns alone, if the param is nil' do
+      expect { @stat.set_churns(nil) }.not_to change { @stat.churns }
     end
   end
 
-  describe ".set_churns" do
-    it "sets the churns" do
-      stat.set_churns(10)
-      expect(stat.churns).to eq(10)
+  describe '#get_method' do
+    it 'returns the method with the specified name' do
+      expect(@stat.get_method('bar?').first_line).to eq(3)
+      expect(@stat.get_method('fooz?').first_line).to eq(7)
     end
 
-    it "leaves the churns alone, if the param is nil" do
-      stat.churns = 10
-      stat.set_churns(nil)
-      expect(stat.churns).to eq(10)
+    it 'returns nil if there is no method with the specified name' do
+      expect(@stat.get_method('bar')).to eq(nil)
     end
   end
 
-  describe ".get_method" do
-    it "returns the method with the specified name" do
-      expect(stat.get_method("bar?").first_line).to  eq(3)
-      expect(stat.get_method("fooz?").first_line).to eq(7)
+  describe '#set_method_complexity' do
+    it 'sets the complexity of the method with the specified name' do
+      @stat.set_method_complexity('bar?', 200)
+
+      expect(@stat.get_method('bar?').complexity).to eq(200)
     end
 
-    it "returns nil if there is no mehtod with the specified name" do
-      expect(stat.get_method("bar")).to eq(nil)
+    it 'adds the complexity to the definition_complexity if there is no method with the specified name' do
+      @stat.definition_complexity = 25
+      @stat.set_method_complexity('baz', 120)
+
+      expect(@stat.definition_complexity).to eq(145)
     end
   end
 
-  describe ".set_method_complexity" do
-    it "sets the complexity of the method with the specified name" do
-      stat.set_method_complexity("bar?", 200)
-      expect(stat.get_method("bar?").complexity).to eq(200)
+  describe '#get_method_at_line' do
+    it 'return the method at the specified line' do
+      expect(@stat.get_method_at_line(3).name).to eq('bar?')
     end
 
-    it "adds the complexity to the definition_complexity if there is no method with the specified name" do
-      stat.definition_complexity = 25
-      stat.set_method_complexity("baz", 120)
-      expect(stat.definition_complexity).to eq(145)
+    it 'returns nil if there is no mehtod at the specified line' do
+      expect(@stat.get_method_at_line(20)).to eq(nil)
     end
   end
 
-  describe ".get_method_at_line" do
-    it "return the method at the specified line" do
-      expect(stat.get_method_at_line(3).name).to eq("bar?")
-      expect(stat.get_method_at_line(7).name).to eq("fooz?")
+  describe '#set_smells' do
+    it 'creates no complex_class smell if the overall complexity is less 151' do
+      @stat.complexity = 150
+      @stat.set_smells
+
+      expect(@stat.smells.detect { |smell| smell.type == 'complex_class' }).to be_nil
     end
 
-    it "returns nil if there is no mehtod at the specified line" do
-      expect(stat.get_method_at_line(20)).to eq(nil)
+    it 'creates a complex_class smell if the overall complexity is greater 150' do
+      @stat.complexity = 151
+      @stat.set_smells
+
+      expect(@stat.smells.detect { |smell| smell.type == 'complex_class' }).to_not be_nil
     end
-  end
 
-  describe ".set_smells" do
-    it "creates a 'ComplexClass' smell if the overall complexity is greater 150" do
-      stat.complexity = 151
-      stat.set_smells
-      expect(stat.smells.find{|smell| smell.type == "ComplexClass"}).to_not be_nil
+    it 'creates no complex_class_definition smell if the definition complexity is less 41' do
+      @stat.definition_complexity = 40
+      @stat.set_smells
+
+      expect(@stat.smells.detect { |smell| smell.type == 'complex_class_definition' }).to be_nil
     end
 
-    it "creates no 'ComplexClass' smell if the overall complexity is less 151" do
-      stat.complexity = 150
-      stat.set_smells
-      expect(stat.smells.find{|smell| smell.type == "ComplexClass"}).to be_nil
+    it 'creates a complex_class_definition smell if the definition complexity is greater 40' do
+      @stat.definition_complexity = 41
+      @stat.set_smells
+
+      expect(@stat.smells.detect { |smell| smell.type == 'complex_class_definition' }).to_not be_nil
+    end
+
+    it 'creates no complex_method smell if no methods complexity is greater 25' do
+      @stat.set_method_complexity('bar?', 2)
+      @stat.set_smells
+
+      expect(@stat.smells.detect { |smell| smell.type == 'complex_method' }).to be_nil
     end
 
-    it "creates a 'ComplexClassDefinition' smell if the definition complexity is greater 40" do
-      stat.definition_complexity = 41
-      stat.set_smells
-      expect(stat.smells.find{|smell| smell.type == "ComplexClassDefinition"}).to_not be_nil
+    it 'creates a complex_method smell if a methods complexity is greater 25' do
+      @stat.set_method_complexity('bar?', 26)
+      @stat.set_smells
+
+      expect(@stat.smells.detect { |smell| smell.type == 'complex_method' }).to_not be_nil
     end
 
-    it "creates no 'ComplexClassDefinition' smell if the definition complexity is less 41" do
-      stat.definition_complexity = 40
-      stat.set_smells
-      expect(stat.smells.find{|smell| smell.type == "ComplexClassDefinition"}).to be_nil
+    it 'creates no duplication smell if there is no duplication' do
+      @stat.set_smells
+
+      expect(@stat.smells.detect { |smell| smell.type == 'duplication' }).to be_nil
     end
 
-    it "creates a 'ComplexMethod' smell if a methods complexity is greater 25" do
-      stat.set_method_complexity("bar?", 26)
-      stat.set_smells
-      expect(stat.smells.find{|smell| smell.type == "ComplexMethod"}).to_not be_nil
+    it 'creates a duplication smell if there is duplication' do
+      @stat.duplications = [double]
+      @stat.set_smells
+
+      expect(@stat.smells.detect { |smell| smell.type == 'duplication' }).to_not be_nil
     end
+  end
+
+  describe '#duplication' do
+    it 'adds up the masses of the duplications' do
+      @stat.duplications = [double(mass: 10, methods: [double]), double(mass: 5, methods: [double])]
 
-    it "creates no 'ComplexMethod' smell if no methods complexity is greater 25" do
-      stat.set_smells
-      expect(stat.smells.find{|smell| smell.type == "ComplexMethod"}).to be_nil
+      expect(@stat.duplication).to eq(15)
     end
   end
 end

data/spec/warning_scanner_spec.rb

@@ -4,15 +4,15 @@ require_relative '../lib/code_poetry/warning_scanner'
 describe CodePoetry::WarningScanner do
   let(:scanner) { CodePoetry::WarningScanner.new }
 
-  describe ".scan" do
-    it "returns an array with warnings for every indendation in the source" do
-      source = File.open(test_file(1), "r").read
+  describe '#scan' do
+    it 'returns an array with warnings for every indendation in the source' do
+      source = File.open(test_file(1), 'r').read
       expect(scanner.scan(source).size).to eq(0)
 
-      source = File.open(test_file(2), "r").read
-      expect(scanner.scan(source)["def"].size).to eq(2)
-      expect(scanner.scan(source)["def"][0]).to   eq([3, 5])
-      expect(scanner.scan(source)["def"][1]).to   eq([7, 9])
+      source = File.open(test_file(2), 'r').read
+      expect(scanner.scan(source)['def'].size).to eq(2)
+      expect(scanner.scan(source)['def'][0]).to   eq([3, 5])
+      expect(scanner.scan(source)['def'][1]).to   eq([7, 9])
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_poetry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Bastian Bartmann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-01 00:00:00.000000000 Z
+date: 2014-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: churn
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: flay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
 description: Analyzes the code of your Rails app and generates a straightforward HTML
   report.
 email:
@@ -89,6 +103,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .hound.yml
 - .rspec
 - .travis.yml
 - Gemfile
@@ -99,10 +114,11 @@ files:
 - lib/code_poetry.rb
 - lib/code_poetry/calculator.rb
 - lib/code_poetry/cli.rb
+- lib/code_poetry/complexity_calculator.rb
+- lib/code_poetry/duplication_calculator.rb
 - lib/code_poetry/formatter.rb
 - lib/code_poetry/method.rb
 - lib/code_poetry/railtie.rb
-- lib/code_poetry/smell.rb
 - lib/code_poetry/stat.rb
 - lib/code_poetry/version.rb
 - lib/code_poetry/warning_scanner.rb
@@ -110,7 +126,6 @@ files:
 - spec/dummy_files/1.rb
 - spec/dummy_files/2.rb
 - spec/method_spec.rb
-- spec/smell_spec.rb
 - spec/spec_helper.rb
 - spec/stat_spec.rb
 - spec/warning_scanner_spec.rb
@@ -134,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: The poor men's Code Climate
@@ -142,7 +157,6 @@ test_files:
 - spec/dummy_files/1.rb
 - spec/dummy_files/2.rb
 - spec/method_spec.rb
-- spec/smell_spec.rb
 - spec/spec_helper.rb
 - spec/stat_spec.rb
 - spec/warning_scanner_spec.rb

data/lib/code_poetry/smell.rb

@@ -1,22 +0,0 @@
-module CodePoetry
-  class Smell
-    attr_accessor :type, :method
-
-    def initialize(type, method = nil)
-      @type   = type
-      @method = method
-    end
-
-    def complex_class?
-      @type == "ComplexClass"
-    end
-
-    def complex_class_definition?
-      @type == "ComplexClassDefinition"
-    end
-
-    def complex_method?
-      @type == "ComplexMethod"
-    end
-  end
-end

data/spec/smell_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require_relative '../lib/code_poetry/smell'
-
-describe CodePoetry::Smell do
-  let(:smell) { CodePoetry::Smell.new("ComplexClass") }
-
-  describe ".complex_class?" do
-    it "returns true if the smells type is 'ComplexClass'" do
-      expect(smell.complex_class?).to be_true
-    end
-
-    it "returns false if the smell type isn't 'ComplexClass'" do
-      smell.type = "ComplexClassDefinition"
-      expect(smell.complex_class?).to be_false
-    end
-  end
-
-  describe ".complex_class_definition?" do
-    it "returns true if the smells type is 'ComplexClassDefinition'" do
-      smell.type = "ComplexClassDefinition"
-      expect(smell.complex_class_definition?).to be_true
-    end
-
-    it "returns false if the smell type isn't 'ComplexClassDefinition'" do
-      expect(smell.complex_class_definition?).to be_false
-    end
-  end
-
-  describe ".complex_method?" do
-    it "returns true if the smells type is 'ComplexMethod'" do
-      smell.type = "ComplexMethod"
-      expect(smell.complex_method?).to be_true
-    end
-
-    it "returns false if the smell type isn't 'ComplexMethod'" do
-      expect(smell.complex_method?).to be_false
-    end
-  end
-end