ruby-watchr 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.2-p180@watchr

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in watchr.gemspec
+gemspec
+
+gem 'flog'
+gem 'flay'
+gem 'ruby2ruby'
+
+gem 'rspec'
+gem 'shoulda-matchers'
+gem 'mocha'

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/watchr.rb

@@ -0,0 +1,9 @@
+require "watchr/version"
+require 'watchr/flay_metric/report'
+require 'watchr/flog_metric/report'
+require 'watchr/paths'
+require 'watchr/analyse'
+
+module Watchr
+  # Your code goes here...
+end

data/lib/watchr/analyse.rb

@@ -0,0 +1,42 @@
+require 'watchr/paths'
+require 'watchr/flay_metric/report'
+require 'watchr/file_analyse'
+
+module Watchr
+
+  #
+  # Code analyse information for a given path. Returns list of files,
+  # each containing its own detailed data for used metrics.
+  #
+  class Analyse
+
+    #
+    # Analysed file data.
+    #
+    attr_reader :files
+
+    #
+    # Run the analyse.
+    #
+    # @param {String} Path to code folders.
+    #
+    def initialize(path)
+      files = Paths.files_by_dirs(path)
+
+      # Flay essentially cant be done on file level because its first class
+      # citizen is duplication of code between files. Its done once for all
+      # the files in the analyse and results are injected to the proper file
+      # later.
+      flay = Watchr::FlayMetric::Report.new(files)
+
+      # Create report for each file.
+      @files = files.map do |file|
+        file_report = Watchr::FileAnalyse.new(file)
+        file_report.flay(flay.duplications_by_file(file))
+
+        file_report
+      end
+    end
+  end
+end
+

data/lib/watchr/file_analyse.rb

@@ -0,0 +1,69 @@
+require 'watchr/flog_metric/report'
+require 'watchr/smell'
+require 'watchr/smells_collector'
+
+module Watchr
+  #
+  # Analyse for one given file. All the different metric analyse data are
+  # collected in order to output reasonable recommendations for a code
+  # improvements.
+  #
+  class FileAnalyse
+
+    attr_reader :path
+
+    #
+    # Craete new file analyse.
+    #
+    # @param {String} Path to file.
+    #
+    def initialize(path)
+      @path = path
+      @smells = SmellsCollector.new
+
+      flog_metric = FlogMetric::Report.new([path])
+      flog_metric.classes.each do |klass|
+        if klass.total_score > 150
+          @smells.add(
+            Smell.new(
+              Smell::VERY_COMPLEX_OBJECT,
+              klass.name,
+              [klass.location],
+              klass.total_score
+            )
+          )
+        end
+
+        if klass.total_score > 50
+          @smells.add(
+            Smell.new(
+              Smell::COMPLEX_OBJECT,
+              klass.name,
+              [klass.location],
+              klass.total_score
+            )
+          )
+        end
+      end
+    end
+
+    def smelly?
+      smells.any?
+    end
+
+    #
+    # Store the flay report, which was evaluated on global basis
+    # to check for duplications across multiple files.
+    #
+    # @param {Array.<Watchr::FlayMetric::Diff>} Duplication details.
+    # @return nil
+    #
+    def flay(report)
+      @flay_report = report
+    end
+
+    def smells
+      @smells.all
+    end
+  end
+end

data/lib/watchr/flay_metric/diff.rb

@@ -0,0 +1,27 @@
+module Watchr
+  module FlayMetric
+    class Diff
+      IDENTICAL = :identical
+
+      SIMILAR = :similar
+
+      attr_reader :locations, :match, :nodes, :bonus, :mass, :code
+
+      def initialize(same, nodes, bonus, mass)
+        @locations = []
+        @match = same ? IDENTICAL : SIMILAR
+        @nodes = nodes
+        @bonus = bonus
+        @mass = mass
+      end
+
+      def add_location(location)
+        @locations << location
+      end
+
+      def code=(code)
+        @code = code
+      end
+    end
+  end
+end

data/lib/watchr/flay_metric/report.rb

@@ -0,0 +1,54 @@
+require 'flay'
+require 'watchr/flay_metric/diff'
+require 'watchr/location'
+
+module Watchr
+  module FlayMetric
+    class Report < Flay
+      attr_reader :duplications
+
+      def initialize(path)
+        super(:mass => 12, :diff => true)
+
+        files = Flay.expand_dirs_to_files(path)
+
+        process(*files)
+        process_result
+      end
+
+      def total_score
+        total
+      end
+
+      def duplications_by_file(path)
+        duplications.find_all do |duplication|
+          false
+#          duplication.locations.any? {|location| location.file == path}
+        end
+      end
+
+      def process_result
+        @duplications = []
+
+        masses.sort_by { |h,m| [-m, hashes[h].first.file] }.each do |hash, mass|
+          nodes = hashes[hash]
+
+          same = identical[hash]
+          node = nodes.first
+          bonus = same ? nodes.size : 0
+
+          diff = Diff.new(same, nodes, bonus, mass)
+
+          nodes.each do |x|
+            diff.add_location(Location.new(x.file, x.line))
+          end
+
+          r2r = Ruby2Ruby.new
+          diff.code = n_way_diff(*nodes.map { |s| r2r.process(s.deep_clone) })
+
+          @duplications << diff
+        end
+      end
+    end
+  end
+end

data/lib/watchr/flog_metric/class.rb

@@ -0,0 +1,24 @@
+module Watchr
+  class FlogReportClass
+    attr_reader :name, :methods, :total_score, :location
+
+    def initialize(name, score)
+      @name = name
+      @total_score = (10 * score).round / 10.0
+      @methods = []
+    end
+
+    def location
+      @location
+    end
+
+    def total_methods_score
+      @methods.reduce(0) {|sum, i| sum += i.total_score}
+    end
+
+    def add_method(method_report)
+      @methods << method_report
+      @location = Location.new(method_report.location.file)
+    end
+  end
+end

data/lib/watchr/flog_metric/method.rb

@@ -0,0 +1,17 @@
+module Watchr
+  class FlogReportMethod
+    attr_reader :clazz, :name, :total_score, :location
+
+    def initialize(clazz, name, score, location)
+      @clazz = clazz
+      @full_name = name
+      @name = name.split(/#|::/).last
+      @total_score = (10 * score).round / 10.0
+      @location = location
+    end
+
+    def full_name
+      @full_name
+    end
+  end
+end

data/lib/watchr/flog_metric/report.rb

@@ -0,0 +1,84 @@
+require 'flog'
+require 'watchr/flog_metric/class'
+require 'watchr/flog_metric/method'
+require 'watchr/location'
+
+module Watchr
+  module FlogMetric
+
+    #
+    # Seattle.rb Flog report.
+    #
+    class Report < Flog
+
+      #
+      # Generate flog report for a given files.
+      #
+      # @param {Array} Array of file paths.
+      #
+      def initialize(files)
+        super({})
+
+        flog(files)
+        process_result
+      end
+
+      #
+      # Get total complexity score.
+      #
+      # @return {Number} Score.
+      #
+      def total_score
+        (10 * total).round / 10.0
+      end
+
+      #
+      # Get list of class reports.
+      #
+      # @return {Array.<FlogReportClass>} List of class reports.
+      #
+      def classes
+        @classes
+      end
+
+      def classes_by_file(file)
+        classes.find_all {|klass| klass.file == file}
+      end
+
+      private
+
+      def process_result
+        @classes = []
+
+        scores  = Hash.new 0
+        methods = Hash.new { |h,k| h[k] = [] }
+
+        each_by_score(nil) do |class_method, score, call_list|
+          klass = class_method.split(/#|::/)[0..-2].join('::')
+
+          methods[klass] << [class_method, score]
+          scores[klass]  += score
+        end
+
+        scores.each do |klass, total|
+          clazz = FlogReportClass.new(klass, total)
+
+          methods[klass].each do |name, score|
+            next if name =~ /#none/
+
+            clazz.add_method(
+              FlogReportMethod.new(
+                clazz,
+                name,
+                score,
+                Location.from_path(method_locations[name])
+              )
+            )
+          end
+
+          @classes << clazz
+        end
+      end
+    end
+  end
+end

data/lib/watchr/location.rb

@@ -0,0 +1,18 @@
+module Watchr
+  class Location
+    attr_reader :file, :line
+
+    def initialize(file, line = nil)
+      @file = file
+      @line = line
+    end
+
+    def self.from_path(path)
+      file, line = path.split(':')
+      line = line && line.to_i
+
+      Location.new(file, line)
+    end
+  end
+end
+

data/lib/watchr/paths.rb

@@ -0,0 +1,15 @@
+module Watchr
+  module Paths
+    def self.files_by_dirs *dirs
+      extensions = ['rb']
+
+      dirs.flatten.map { |p|
+        if File.directory? p then
+          Dir[File.join(p, '**', "*.{#{extensions.join(',')}}")]
+        else
+          p
+        end
+      }.flatten.sort
+    end
+  end
+end

data/lib/watchr/smell.rb

@@ -0,0 +1,63 @@
+module Watchr
+  class Smell
+
+    #
+    # Method complexity is high.
+    #
+    COMPLEX_METHOD = :complex_method
+
+    #
+    # Method complexity is very high.
+    #
+    VERY_COMPLEX_METHOD = :very_complex_method
+
+    #
+    # Object (class / module) total complexity is high.
+    #
+    COMPLEX_OBJECT = :complex_object
+
+    #
+    # Object (class / module) total complexity is very high.
+    #
+    VERY_COMPLEX_OBJECT = :very_complex_object
+
+    #
+    # Code in multiple places is identical.
+    #
+    IDENTICAL_CODE = :identical_code
+
+    #
+    # Code in multiple places is similar (not identical).
+    #
+    SIMILAR_CODE = :similar_code
+
+    def initialize(type, context, description, locations)
+      @type = type
+      @context = context
+      @description = description
+      @locations = []
+
+      Array(locations).each {|l| add_location(l)}
+    end
+
+    def type
+      @type
+    end
+
+    def locations
+      @locations
+    end
+
+    def description
+      @description
+    end
+
+    def context
+      @context
+    end
+
+    def add_location(location)
+      @locations << location
+    end
+  end
+end

data/lib/watchr/smells_collector.rb

@@ -0,0 +1,19 @@
+module Watchr
+  class SmellsCollector
+    def initialize
+      @smells = Set.new
+    end
+
+    def add(smell)
+      @smells.add(smell)
+    end
+
+    def all
+      @smells
+    end
+
+    def empty?
+      @smells.empty?
+    end
+  end
+end

data/lib/watchr/version.rb

@@ -0,0 +1,3 @@
+module Watchr
+  VERSION = "0.0.1"
+end

data/spec/fixtures/class.rb

@@ -0,0 +1,21 @@
+module Baz
+  class Foo
+    attr_reader :bar
+
+    def bar
+      if true == false
+        return false
+      else
+        return true
+      end
+    end
+
+    def self.bar
+      if true == false
+        return false
+      else
+        return true
+      end
+    end
+  end
+end

data/spec/fixtures/module.rb

@@ -0,0 +1,9 @@
+class Module
+  def bar
+    if true == false
+      return false
+    else
+      return true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'rspec'
+require 'shoulda/matchers/active_model'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+# Include ActiveModel matchers from Shoulda into RSpec Matchers
+module RSpec::Matchers
+  include Shoulda::Matchers::ActiveModel
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/watchr/analyse_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'watchr/analyse'
+
+describe Watchr::Analyse do
+  let(:analyse) { Watchr::Analyse.new('spec/fixtures/') }
+
+  describe '#files' do
+    subject { analyse.files }
+
+    its(:count) { should == 2 }
+    its(:first) { subject.class.should == Watchr::FileAnalyse }
+  end
+end

data/spec/watchr/file_analyse_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'watchr/file_analyse'
+
+describe Watchr::FileAnalyse do
+  let(:path) { 'spec/fixtures/class.rb' }
+
+  let(:file_analyse) { Watchr::FileAnalyse.new(path) }
+
+  describe '#path' do
+    subject { file_analyse.path }
+
+    it { should == path }
+  end
+
+  describe '#smelly?' do
+    subject { file_analyse.smelly? }
+
+    context 'with no smells' do
+      it { should be_false }
+    end
+
+    context 'with smells' do
+      let(:smell) { stub('smell') }
+
+      before { file_analyse.stubs(:smells).returns([smell]) }
+
+      it { should be_true }
+    end
+  end
+end

data/spec/watchr/flay/report_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'watchr/flay_metric/report'
+
+describe Watchr::FlayMetric::Report do
+  let(:report) { 
+    Watchr::FlayMetric::Report.new('spec/fixtures/')
+  }
+
+  describe '#total_score' do
+    subject { report.total_score }
+
+    it { should == 52 }
+  end
+
+  describe '#duplications' do
+    describe '.first' do
+      subject { report.duplications.first }
+
+      describe 'locations' do
+        subject { report.duplications.first.locations }
+
+        its(:first) { subject.file.should == 'spec/fixtures/class.rb' }
+        its(:first) { subject.line.should == 5 }
+
+        its(:last) { subject.file.should == 'spec/fixtures/module.rb' }
+        its(:last) { subject.line.should == 2 }
+      end
+    end
+  end
+end

data/spec/watchr/flog_metric/flog_matric/flog_report_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'watchr/flog_metric/report'
+
+describe Watchr::FlogMetric::Report do
+  let(:flog_report) { 
+    Watchr::FlogMetric::Report.new([
+      'spec/fixtures/class.rb', 
+      'spec/fixtures/module.rb'
+    ])
+  }
+
+  describe '#total_score' do
+    subject { flog_report.total_score }
+
+    it { should == 6 }
+  end
+
+  describe '#classes' do
+    describe 'Foo' do
+      subject { flog_report.classes.first }
+
+      its(:name) { should == 'Baz::Foo' }
+      its(:total_score) { should == 4.5 }
+      its(:total_methods_score) { should == 3.4 }
+
+      describe '#location' do
+        subject { flog_report.classes.first.location }
+        
+        its(:file) { should == 'spec/fixtures/class.rb' }
+      end
+
+
+      describe '.methods' do
+        describe '.last' do
+          subject { flog_report.classes.first.methods.last }
+
+          its(:name) { should == 'bar' }
+          its(:full_name) { should == 'Baz::Foo#bar' }
+          its(:total_score) { should == 1.7 }
+          its(:clazz) { should == flog_report.classes.first }
+
+          describe '#location' do
+            subject { flog_report.classes.first.methods.last.location }
+
+            its(:file) { should == 'spec/fixtures/class.rb' }
+            its(:line) { should == 5 }
+          end
+        end
+
+        describe '.first' do
+          subject { flog_report.classes.first.methods.first }
+
+          its(:name) { should == 'bar' }
+          its(:full_name) { should == 'Baz::Foo::bar' }
+          its(:total_score) { should == 1.7 }
+          its(:clazz) { should == flog_report.classes.first }
+
+          describe '#location' do
+            subject { flog_report.classes.first.methods.first.location }
+
+            its(:file) { should == 'spec/fixtures/class.rb' }
+            its(:line) { should == 13 }
+          end
+
+        end
+      end
+    end
+  end
+
+  describe '#by_file' do
+    subject { flog_report.classes_by_file('fixture') }
+
+    let(:classes) { [klass] }
+
+    before { flog_report.stubs(:classes).returns(classes) }
+
+    context 'with matching file' do
+      let(:klass) { stub('klass', :file => 'fixture') }
+
+      it { should include(klass) }
+    end
+
+    context 'without matching file' do
+      let(:klass) { stub('klass', :file => 'blah') }
+
+      it { should_not include(klass) }
+    end
+  end
+end
+

data/spec/watchr/location_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'watchr/location'
+
+describe Watchr::Location do
+  let(:location) { Watchr::Location.new('foo.rb', 42) }
+
+  subject { location }
+
+  its(:file) { should == 'foo.rb' }
+  its(:line) { should == 42 }
+
+  describe '.from_path' do
+    subject { Watchr::Location.from_path(path) }
+
+    context 'with line' do
+      let(:path) { 'foo.rb:21' }
+
+      its(:file) { should == 'foo.rb' }
+      its(:line) { should == 21 }
+    end
+
+    context 'without line' do
+      let(:path) { 'foo.rb' }
+
+      its(:file) { should == 'foo.rb' }
+      its(:line) { should be_nil }
+    end
+  end
+end

data/spec/watchr/paths_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'watchr/paths'
+
+describe Watchr::Paths do
+  describe '.files_by_dirs' do
+
+    subject { Watchr::Paths.files_by_dirs('spec/fixtures/') }
+
+    it { should include('spec/fixtures/class.rb') }
+  end
+end

data/spec/watchr/smell_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'watchr/smell'
+
+describe Watchr::Smell do
+
+  let(:type) { 'foo' }
+
+  let(:location) { 'location' }
+
+  let(:locations) { location }
+
+  let(:description) { 'description' }
+
+  let(:context) { 'context' }
+
+  let(:smell) { Watchr::Smell.new(type, context, description, locations) }
+
+  subject { smell }
+
+  describe '#type' do
+    its(:type) { should == type }
+  end
+
+  describe '#locations' do
+    subject { smell.locations }
+
+    context 'one location' do
+      it { should == [location] }
+    end
+
+    context 'multiple locations' do
+      let(:locations) { [location, location] }
+
+      it { should == [location, location] }
+    end
+  end
+
+  describe '#description' do
+    its(:description) { should == description }
+  end
+
+  describe '#context' do
+    its(:context) { should == context }
+  end
+end

data/spec/watchr/smells_collector_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'watchr/smells_collector'
+
+describe Watchr::SmellsCollector do
+  let(:collector) { Watchr::SmellsCollector.new }
+
+  describe '#all' do
+
+    subject { collector.all }
+
+    context 'with no smells' do
+      it { should be_empty }
+    end
+
+    context 'with smells' do
+      let(:smell) { stub('smell') }
+
+      before { collector.add(smell) }
+
+      it { should_not be_empty }
+      its(:first) { should == smell }
+    end
+  end
+
+  describe '#empty?' do
+    subject { collector.empty? }
+
+    context 'with no smells' do
+      it { should be_true }
+    end
+
+    context 'with smells' do
+      let(:smell) { stub('smell') }
+
+      before { collector.add(smell) }
+
+      it { should be_false }
+    end
+  end
+
+
+end

data/watchr.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "watchr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ruby-watchr"
+  s.version     = Watchr::VERSION
+  s.authors     = ["Petr Janda"]
+  s.email       = ["petrjanda@me.com"]
+  s.homepage    = ""
+  s.summary     = 'Ruby static code analysis'
+  s.description = 'Utility to gather summary of code smells according to multiple analysers.'
+
+  s.rubyforge_project = "watchr"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.add_dependency 'flog'
+  s.add_dependency 'flay'
+  s.add_dependency 'ruby2ruby'
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-watchr
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Petr Janda
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-05 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: flog
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: flay
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: Utility to gather summary of code smells according to multiple analysers.
+email: 
+- petrjanda@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Rakefile
+- lib/watchr.rb
+- lib/watchr/analyse.rb
+- lib/watchr/file_analyse.rb
+- lib/watchr/flay_metric/diff.rb
+- lib/watchr/flay_metric/report.rb
+- lib/watchr/flog_metric/class.rb
+- lib/watchr/flog_metric/method.rb
+- lib/watchr/flog_metric/report.rb
+- lib/watchr/location.rb
+- lib/watchr/paths.rb
+- lib/watchr/smell.rb
+- lib/watchr/smells_collector.rb
+- lib/watchr/version.rb
+- spec/fixtures/class.rb
+- spec/fixtures/module.rb
+- spec/spec_helper.rb
+- spec/watchr/analyse_spec.rb
+- spec/watchr/file_analyse_spec.rb
+- spec/watchr/flay/report_spec.rb
+- spec/watchr/flog_metric/flog_matric/flog_report_spec.rb
+- spec/watchr/location_spec.rb
+- spec/watchr/paths_spec.rb
+- spec/watchr/smell_spec.rb
+- spec/watchr/smells_collector_spec.rb
+- watchr.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: watchr
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby static code analysis
+test_files: 
+- spec/fixtures/class.rb
+- spec/fixtures/module.rb
+- spec/spec_helper.rb
+- spec/watchr/analyse_spec.rb
+- spec/watchr/file_analyse_spec.rb
+- spec/watchr/flay/report_spec.rb
+- spec/watchr/flog_metric/flog_matric/flog_report_spec.rb
+- spec/watchr/location_spec.rb
+- spec/watchr/paths_spec.rb
+- spec/watchr/smell_spec.rb
+- spec/watchr/smells_collector_spec.rb