code_poetry 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb3462469131688d286ff7f768db70ae4de1e12a
-  data.tar.gz: 2c18647925f0741cb981670ad94a53890cacf7fd
+  metadata.gz: 4351c2bdcf92e1b45ec1dace93b7923afca53c3f
+  data.tar.gz: 753445520ef195ff57eecc8697e93486ebd370fe
 SHA512:
-  metadata.gz: 4c348c339d702a853aaa6cdf72c41bfb547f6d992223de44a20b2e28e6c5391ab4c861f4e72358eda2aa829b83e8dfd244d392137279c8e215ddd0bb75a5d1e9
-  data.tar.gz: d0e0ea9ffa4aa906eb797931e85e46502ad409e1152c0e4f48994fd15d44ff6fd9e02427a110a8eb5b5b626ab24af52ac6361550cc08678d057fe0dd9e45e369
+  metadata.gz: 0756a302d0bd0b14477e6dbd36b77c7aa9fb5c86428b8171635fa245c1e9b985ce0a57bb0ee9902c0946f6b27a9e253a0fad15db5713238acdad948829deb5c3
+  data.tar.gz: 3ad8999a9690de69339b9af840f0e6a1733d206c3b18767873ed2b9477ff2864e0bcb8d59a29883a800708f6e00db75834305dec01d005e44529d924b80c843f

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -2,3 +2,8 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in code_poetry.gemspec
 gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'simplecov', require: false
+end

data/README.md

@@ -1,5 +1,7 @@
 # Code Poetry
 
+[![Gem Version][rgb]][rgl] [![Build Status][trb]][trl] [![Code Climate][ccb]][ccl]
+
 The poor men's [Code Climate][cc].
 
 Analyzes the code of your Rails app and generates a straightforward HTML report.
@@ -36,6 +38,13 @@ This will generate a HTML report to ```metrics/index.html```.
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
+[rgb]: https://badge.fury.io/rb/code_poetry.png
+[rgl]: http://badge.fury.io/rb/code_poetry
+[trb]: https://travis-ci.org/coding-chimp/code_poetry.png?branch=master
+[trl]: https://travis-ci.org/coding-chimp/code_poetry
+[ccb]: https://codeclimate.com/github/coding-chimp/code_poetry.png
+[ccl]: https://codeclimate.com/github/coding-chimp/code_poetry
+
 [cc]: https://codeclimate.com
 [ch]: https://github.com/danmayer/churn
 [fl]: https://github.com/seattlerb/flog

data/Rakefile

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

data/code_poetry.gemspec

@@ -4,25 +4,24 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'code_poetry/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "code_poetry"
+  spec.name          = 'code_poetry'
   spec.version       = CodePoetry::VERSION
-  spec.authors       = ["Bastian Bartmann"]
-  spec.email         = ["babartmann@gmail.com"]
+  spec.authors       = ['Bastian Bartmann']
+  spec.email         = ['babartmann@gmail.com']
   spec.description   = %q{Analyzes the code of your Rails app and generates a straightforward HTML report.}
   spec.summary       = %q{The poor men's Code Climate}
-  spec.homepage      = "https://github.com/coding-chimp/code_poetry"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/coding-chimp/code_poetry'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
 
-  spec.add_runtime_dependency 'code_poetry-html', ['~> 0.0']
-  spec.add_runtime_dependency 'code_metrics',     ['~> 0.1']
+  spec.add_runtime_dependency 'code_poetry-html', ['~> 0.1']
   spec.add_runtime_dependency 'churn',            ['~> 0.0']
   spec.add_runtime_dependency 'flog',             ['~> 4.2']
 end

data/lib/code_poetry/calculator.rb

@@ -20,6 +20,7 @@ module CodePoetry
 
         stat.set_churns(@churns[file])
         measure_flog(stat)
+        stat.set_smells
 
         @stats << stat
       end
@@ -42,28 +43,18 @@ module CodePoetry
       flogger.flog(stat.file)
       flogger.calculate
 
-      outside_methods = 0
-
       unless flogger.scores.empty?
         klass                      = flogger.scores.first[0]
-        stat.complexity            = flogger.total_score.round(2)
-        stat.complexity_per_method = flogger.average.round(2)
+        stat.complexity            = flogger.total_score.round(0)
+        stat.complexity_per_method = flogger.average.round(0)
 
         flogger.method_scores[klass].each do |name, score|
-          next if score.nil?
-
           name = (name.match(/#(.+)/) || name.match(/::(.+)/))[1]
-          method = stat.get_method(name)
-
-          if method
-            method[:complexity] = score.round(2)
-          else
-            outside_methods += score
-          end
+          stat.set_method_complexity(name, score)
         end
       end
 
-      stat.set_outside_of_methods_complexity(outside_methods.round(2))
+      stat.definition_complexity = stat.definition_complexity.round(0)
     end
   end
 end

data/lib/code_poetry/method.rb

@@ -0,0 +1,23 @@
+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
+    end
+
+    def smelly?
+      complexity > 25
+    end
+
+    def pretty_name
+      symbol = node == :def ? "." : "#"
+      name.prepend(symbol)
+    end
+
+  end
+end

data/lib/code_poetry/smell.rb

@@ -0,0 +1,22 @@
+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/lib/code_poetry/stat.rb

@@ -1,14 +1,18 @@
+require 'code_poetry/method'
 require 'code_poetry/warning_scanner'
+require 'code_poetry/smell'
 
 module CodePoetry
   class Stat
-    attr_accessor :file, :name, :lines, :lines_of_code, :churns, :complexity, :details, :complexity_per_method
+    attr_accessor :file, :name, :lines, :lines_of_code, :churns, :complexity, :methods, :smells
+    attr_accessor :complexity_per_method, :definition_complexity
 
     def initialize(file)
-      @lines_of_code, @churns, @complexity, @complexity_per_method = 0, 0, 0, 0
+      @lines_of_code, @churns, @complexity, @complexity_per_method, @definition_complexity = 0, 0, 0, 0, 0
       @file    = file
       @lines   = {}
-      @details = []
+      @methods = []
+      @smells  = []
 
       parse_file
     end
@@ -18,41 +22,24 @@ module CodePoetry
     end
 
     def get_method(name)
-      method = details.select{|method| method[:name] == name}
-      method[0] unless method.empty?
+      @methods.find{|method| method.name == name}
     end
 
-    def set_method_complexity(name, complexity)
-      method = details.select{|method| method[:name] == name}
-      method[0][:complexity] = complexity unless method.empty?
-    end
-
-    def set_outside_of_methods_complexity(complexity)
-      @details.unshift({name: "none", complexity: complexity})
+    def set_method_complexity(name, score)
+      if method = get_method(name)
+        method.complexity = score.round(0)
+      else
+        @definition_complexity += score
+      end
     end
 
     def get_method_at_line(line)
-      @method = nil
-
-      @details.each do |detail|
-        next if detail[:first_line].nil?
-
-        if detail[:last_line].nil?
-          if detail[:first_line] == line
-            @method = detail
-            break
-          else
-            next
-          end
-        end
-
-        if detail[:first_line] <= line && detail[:last_line] >= line
-          @method = detail
-          break
-        end
-      end
+      @methods.find{|method| method.first_line <= line && method.last_line >= line}
+    end
 
-      @method
+    def set_smells
+      set_class_smells
+      set_method_smells
     end
 
   private
@@ -97,13 +84,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'].select{|first, last| first == first_line}[0]
+            warning = @indentation_warnings['def'].find{|first, last| first == first_line}
             last_line = warning[1]
           else
             last_line = find_last_line(name, first_line)
           end
 
-          @details << {name: name, first_line: first_line, last_line: last_line, complexity: 0}
+          @methods << Method.new(element.first, name, first_line, last_line)
         else
           scan_sexp(element)
         end
@@ -129,5 +116,15 @@ module CodePoetry
       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
+    end
+
+    def set_method_smells
+      smelly_methods = @methods.select{|method| method.smelly?}
+      @smells.concat smelly_methods.map{|method| Smell.new("ComplexMethod", method)}
+    end
   end
 end

data/lib/code_poetry/version.rb

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

data/lib/code_poetry/warning_scanner.rb

@@ -13,7 +13,7 @@ module CodePoetry
         status, @warnings, process = validate(source)
       end
 
-      @indentation_warnings = parse_warnings
+      parse_warnings
     end
 
   private

data/spec/dummy_files/1.rb

@@ -0,0 +1,11 @@
+class Foo
+
+  def self.bar?
+    true
+  end
+
+  def fooz?
+    false
+  end
+
+end

data/spec/dummy_files/2.rb

@@ -0,0 +1,11 @@
+class Foo
+
+  def self.bar?
+    true
+end
+
+  def fooz?
+    false
+    end
+
+end

data/spec/method_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require_relative '../lib/code_poetry/method'
+
+describe CodePoetry::Method do
+  let(:method) { CodePoetry::Method.new(:def, "smelly?", 8, 10) }
+
+  describe ".smell?" 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
+      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?")
+    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?")
+    end
+  end
+end

data/spec/smell_spec.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+end if ENV['COVERAGE']
+
+require 'rspec/autorun'
+
+def test_file(file_name)
+  File.join(
+    File.dirname(__FILE__), "dummy_files/#{file_name}.rb"
+  )
+end

data/spec/stat_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'ripper'
+require_relative '../lib/code_poetry/stat'
+
+describe CodePoetry::Stat do
+  let(:stat) { CodePoetry::Stat.new(test_file(1)) }
+
+  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)
+    end
+
+    it "sets the methods correctly" do
+      expect(stat.methods.count).to eq(2)
+
+      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)
+
+      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)
+    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)
+
+      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)
+
+      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)
+    end
+  end
+
+  describe ".set_churns" do
+    it "sets the churns" do
+      stat.set_churns(10)
+      expect(stat.churns).to eq(10)
+    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)
+    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)
+    end
+
+    it "returns nil if there is no mehtod with the specified name" do
+      expect(stat.get_method("bar")).to eq(nil)
+    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)
+    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)
+    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?")
+    end
+
+    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 ".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
+    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
+    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
+    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
+    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
+    end
+
+    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
+    end
+  end
+end

data/spec/warning_scanner_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+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
+      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])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_poetry
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Bastian Bartmann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-27 00:00:00.000000000 Z
+date: 2013-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -40,20 +40,6 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: code_poetry-html
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.0'
-- !ruby/object:Gem::Dependency
-  name: code_metrics
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
@@ -103,6 +89,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
@@ -112,11 +100,20 @@ files:
 - lib/code_poetry/calculator.rb
 - lib/code_poetry/cli.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
 - lib/tasks/code_poetry.rake
+- 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
 homepage: https://github.com/coding-chimp/code_poetry
 licenses:
 - MIT
@@ -141,5 +138,12 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: The poor men's Code Climate
-test_files: []
+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
 has_rdoc: