devtools 0.1.0 → 0.1.5

data/spec/unit/devtools/config/yardstick_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe Devtools::Config::Yardstick do
+  let(:object) { described_class.new(Devtools.root.join('config')) }
+
+  describe '#options' do
+    subject { object.options }
+
+    specify do
+      should eql(
+        'threshold'               => 100,
+        'rules'                   => nil,
+        'verbose'                 => nil,
+        'path'                    => nil,
+        'require_exact_threshold' => nil
+      )
+    end
+  end
+end

data/spec/unit/devtools/config_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe Devtools::Config do
+
+  describe '.attribute' do
+    let(:raw) do
+      {
+        'a' => 'bar',
+        'c' => []
+      }
+
+    end
+
+    let(:config_path) { instance_double(Pathname) }
+
+    let(:class_under_test) do
+      expect(config_path).to receive(:file?)
+        .and_return(file?)
+      expect(config_path).to receive(:frozen?)
+        .and_return(true)
+      expect(config_path).to receive(:join)
+        .with('bar.yml')
+        .and_return(config_path)
+
+      Class.new(described_class) do
+        attribute :a, [String]
+        attribute :b, [Array], default: []
+        attribute :c, [TrueClass, FalseClass]
+
+        const_set(:FILE, 'bar.yml')
+      end
+    end
+
+    subject do
+      class_under_test.new(config_path)
+    end
+
+    context 'on present config' do
+      let(:class_under_test) do
+        # Setup message expectation in a lasy way, not in a before
+        # block to make sure the around hook setting timeouts from the
+        # code under test is not affected.
+        expect(YAML).to receive(:load_file)
+          .with(config_path)
+          .and_return(raw)
+
+        expect(IceNine).to receive(:deep_freeze)
+          .with(raw)
+          .and_return(raw)
+
+        super()
+      end
+
+      let(:file?) { true }
+
+      it 'allows to receive existing keys' do
+        expect(subject.a).to eql('bar')
+      end
+
+      it 'allows to receive absent keys with defaults' do
+        expect(subject.b).to eql([])
+      end
+
+      it 'executes checks when configured' do
+        expect { subject.c }.to raise_error(
+          Devtools::Config::TypeError,
+          'c: Got instance of Array expected TrueClass,FalseClass'
+        )
+      end
+    end
+
+    context 'on absent config' do
+      let(:file?) { false }
+
+      it 'defaults to absent keys' do
+        expect(subject.b).to eql([])
+      end
+    end
+  end
+end

data/spec/unit/devtools/flay/file_list/call_spec.rb

@@ -0,0 +1,19 @@
+describe Devtools::Flay::FileList, '.call' do
+  subject(:output) { described_class.call([tmpdir.to_s], [exclude]) }
+
+  let(:tmpdir)     { Dir.mktmpdir                     }
+  let(:one)        { Pathname(tmpdir).join('1.rb')    }
+  let(:two)        { Pathname(tmpdir).join('2.erb')   }
+  let(:three)      { Pathname(tmpdir).join('3.rb')    }
+  let(:exclude)    { Pathname(tmpdir).join('3*').to_s }
+
+  around(:each) do |example|
+    [one, two, three].map(&FileUtils.method(:touch))
+
+    example.run
+
+    FileUtils.rm_rf(tmpdir)
+  end
+
+  it { should eql(Set.new([one, two])) }
+end

data/spec/unit/devtools/flay/scale/flay_report_spec.rb

@@ -0,0 +1,17 @@
+describe Devtools::Flay::Scale, '#flay_report' do
+  subject(:instance) { described_class.new(minimum_mass: 0, files: []) }
+
+  let(:flay) do
+    instance_double(::Flay, process: nil, analyze: nil, masses: {})
+  end
+
+  before do
+    allow(::Flay).to receive(:new).with(mass: 0).and_return(flay)
+  end
+
+  specify do
+    allow(flay).to receive(:report)
+    instance.flay_report
+    expect(flay).to have_received(:report)
+  end
+end

data/spec/unit/devtools/flay/scale/measure_spec.rb

@@ -0,0 +1,43 @@
+describe Devtools::Flay::Scale, '#measure' do
+  subject(:measure) { instance.measure }
+
+  let(:minimum_mass) { 0        }
+  let(:files)        { [instance_double(File)] }
+  let(:flay_masses) { { 0 => 5, 1 => 10 } }
+
+  let(:instance) do
+    described_class.new(minimum_mass: minimum_mass, files: files)
+  end
+
+  let(:flay_hashes) do
+    {
+      0 => instance_double(Array, size: 3),
+      1 => instance_double(Array, size: 11)
+    }
+  end
+
+  let(:flay) do
+    instance_double(
+      ::Flay,
+      analyze: nil,
+      masses:  flay_masses,
+      hashes:  flay_hashes
+    )
+  end
+
+  before do
+    allow(::Flay).to receive(:new).with(mass: minimum_mass).and_return(flay)
+    allow(flay).to receive(:process).with(*files)
+  end
+
+  it { should eql([Rational(5, 3), Rational(10, 11)]) }
+
+  context 'when minimum mass is not 0' do
+    let(:minimum_mass) { 1 }
+
+    specify do
+      measure
+      expect(::Flay).to have_received(:new).with(mass: 1)
+    end
+  end
+end

data/spec/unit/devtools/project/initializer/rake_spec.rb

@@ -0,0 +1,21 @@
+describe Devtools::Project::Initializer::Rake do
+  describe '.call' do
+    subject do
+      described_class.call
+    end
+
+    it 'performs expected rake initialization' do
+      path_a = instance_double(Pathname)
+      path_b = instance_double(Pathname)
+
+      expect(FileList).to receive(:glob)
+        .with(Devtools.root.join('tasks/**/*.rake').to_s)
+        .and_return([path_a, path_b])
+
+      expect(Rake.application).to receive(:add_import).with(path_a)
+      expect(Rake.application).to receive(:add_import).with(path_b)
+
+      expect(subject).to be(described_class)
+    end
+  end
+end

data/spec/unit/devtools/project/initializer/rspec_spec.rb

@@ -0,0 +1,52 @@
+describe Devtools::Project::Initializer::Rspec do
+  let(:spec_root)         { Devtools.root.join('spec') }
+  let(:unit_test_timeout) { instance_double(Float)     }
+
+  let(:project) do
+    instance_double(
+      Devtools::Project,
+      spec_root: spec_root,
+      devtools:  instance_double(
+        Devtools::Config::Devtools,
+        unit_test_timeout: unit_test_timeout
+      )
+    )
+  end
+
+  describe '.call' do
+    subject do
+      described_class.call(project)
+    end
+
+    it 'performs expected rspec initialization' do
+      called = false
+      example = -> { called = true }
+
+      expect(Dir).to receive(:glob)
+        .with(Devtools.root.join('shared/spec/{shared,support}/**/*.rb'))
+        .and_return(%w[shared-a shared-b])
+
+      expect(Kernel).to receive(:require).with('shared-a')
+      expect(Kernel).to receive(:require).with('shared-b')
+
+      expect(Dir).to receive(:glob)
+        .with(Devtools.root.join('spec/{shared,support}/**/*.rb'))
+        .and_return(%w[support-a support-b])
+
+      expect(Kernel).to receive(:require).with('support-a')
+      expect(Kernel).to receive(:require).with('support-b')
+
+      expect(Timeout).to receive(:timeout).with(unit_test_timeout) do |&block|
+        block.call
+      end
+
+      expect(RSpec.configuration).to receive(:around)
+        .with(file_path: %r{\bspec/unit/})
+        .and_yield(example)
+
+      expect(subject).to be(described_class)
+
+      expect(called).to be(true)
+    end
+  end
+end

data/spec/unit/devtools/project_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe Devtools::Project do
+  let(:object) { described_class.new(Devtools.root) }
+
+  describe '#init_rspec' do
+    subject { object.init_rspec }
+
+    it 'calls the rspec initializer' do
+      expect(Devtools::Project::Initializer::Rspec).to receive(:call).with(Devtools.project)
+      expect(subject).to be(object)
+    end
+  end
+
+  {
+    devtools:  Devtools::Config::Devtools,
+    flay:      Devtools::Config::Flay,
+    flog:      Devtools::Config::Flog,
+    reek:      Devtools::Config::Reek,
+    mutant:    Devtools::Config::Mutant,
+    rubocop:   Devtools::Config::Rubocop,
+    yardstick: Devtools::Config::Yardstick
+  }.each do |name, klass|
+    describe "##{name}" do
+      subject { object.send(name) }
+
+      specify { should eql(klass.new(Devtools.root.join('config'))) }
+    end
+  end
+
+  describe '#spec_root' do
+    subject { object.spec_root }
+
+    specify { should eql(Devtools.root.join('spec')) }
+  end
+end

data/spec/unit/devtools_spec.rb

@@ -0,0 +1,14 @@
+describe Devtools do
+  describe '.project' do
+    specify do
+      expect(Devtools.project).to equal(Devtools::PROJECT)
+    end
+  end
+
+  describe '.init_rake_tasks' do
+    specify do
+      expect(Devtools::Project::Initializer::Rake).to receive(:call)
+      expect(Devtools.init_rake_tasks).to be(Devtools)
+    end
+  end
+end

data/tasks/metrics/ci.rake

@@ -1,7 +1,5 @@
-# encoding: utf-8
-
 desc 'Run all specs, metrics and mutant'
-task ci: %w[spec ci:metrics metrics:mutant]
+task ci: %w[ci:metrics metrics:mutant]
 
 namespace :ci do
   tasks = %w[
@@ -11,6 +9,7 @@ namespace :ci do
     metrics:flog
     metrics:flay
     metrics:reek
+    spec:integration
   ]
 
   desc 'Run metrics (except mutant)'

data/tasks/metrics/coverage.rake

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 namespace :metrics do
   desc 'Measure code coverage'
   task :coverage do

data/tasks/metrics/flay.rake

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 namespace :metrics do
   require 'flay'
 
@@ -12,37 +10,12 @@ namespace :metrics do
   task :flay do
     threshold   = config.threshold
     total_score = config.total_score
-    files       = Flay.expand_dirs_to_files(config.lib_dirs).sort
-
-    # Run flay first to ensure the max mass matches the threshold
-    flay = Flay.new(fuzzy: false, verbose: false, mass: 0)
-    flay.process(*files)
-    flay.analyze
-
-    masses = flay.masses.map do |hash, mass|
-      Rational(mass, flay.hashes[hash].size)
-    end
-
-    max = (masses.max || 0).to_i
-    unless max >= threshold
-      Devtools.notify_metric_violation "Adjust flay threshold down to #{max}"
-    end
-
-    total = masses.inject(:+).to_i
-    unless total == total_score
-      Devtools.notify_metric_violation "Flay total is now #{total}, but expected #{total_score}"
-    end
-
-    # Run flay a second time with the threshold set
-    flay = Flay.new(fuzzy: false, verbose: false, mass: threshold.succ)
-    flay.process(*files)
-    flay.analyze
-
-    mass_size = flay.masses.size
 
-    if mass_size.nonzero?
-      flay.report
-      Devtools.notify_metric_violation "#{mass_size} chunks have a duplicate mass > #{threshold}"
-    end
+    Devtools::Rake::Flay.call(
+      threshold:   threshold,
+      total_score: total_score,
+      lib_dirs:    config.lib_dirs,
+      excludes:    config.excludes
+    )
   end
 end

data/tasks/metrics/flog.rake

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 namespace :metrics do
   require 'flog'
   require 'flog_cli'

data/tasks/metrics/mutant.rake

@@ -1,50 +1,42 @@
-# encoding: utf-8
-
 namespace :metrics do
   config  = Devtools.project.mutant
 
-  if !ENV['DEVTOOLS_SELF']
-    desc 'Measure mutation coverage'
-    task mutant: :coverage do
-      require 'mutant'
+  desc 'Measure mutation coverage'
+  task mutant: :coverage do
+    require 'mutant'
 
-      namespace =
-        if config.zombify
-          Mutant.zombify
-          Zombie::Mutant
-        else
-          Mutant
-        end
+    namespace =
+      if config.zombify
+        Mutant.zombify
+        Zombie::Mutant
+      else
+        Mutant
+      end
 
-      namespaces = Array(config.namespace).map { |n| "#{n}*" }
+    namespaces = Array(config.namespace).map { |n| "#{n}*" }
 
-      ignore_subjects = config.ignore_subjects.flat_map do |matcher|
-        %W[--ignore #{matcher}]
-      end
+    ignore_subjects = config.ignore_subjects.flat_map do |matcher|
+      %W[--ignore #{matcher}]
+    end
 
-      since =
-        if config.since
-          %W[--since #{config.since}]
-        else
-          []
-        end
-
-      arguments  = %W[
-        --include lib
-        --require #{config.name}
-        --expect-coverage #{config.expect_coverage}
-        --use #{config.strategy}
-      ].concat(ignore_subjects).concat(namespaces).concat(since)
-
-      status = namespace::CLI.run(arguments)
-      if status.nonzero?
-        Devtools.notify_metric_violation 'Mutant task is not successful'
+    jobs = ENV.key?('CIRCLECI') ? %w[--jobs 4] : []
+
+    since =
+      if config.since
+        %W[--since #{config.since}]
+      else
+        []
       end
-    end
-  else
-    desc 'Measure mutation coverage'
-    task mutant: :coverage do
-      $stderr.puts 'Mutant is disabled'
+
+    arguments  = %W[
+      --include lib
+      --require #{config.name}
+      --expect-coverage #{config.expect_coverage}
+      --use #{config.strategy}
+    ].concat(ignore_subjects).concat(namespaces).concat(since).concat(jobs)
+
+    unless namespace::CLI.run(arguments)
+      Devtools.notify_metric_violation('Mutant task is not successful')
     end
   end
 end

data/tasks/metrics/reek.rake

@@ -1,7 +1,8 @@
-# encoding: utf-8
-
 namespace :metrics do
-  task :reek do
-    $stderr.puts 'Reek is disabled due defunct AST processing'
+  require 'reek/rake/task'
+
+  Reek::Rake::Task.new do |reek|
+    reek.source_files = '{app,lib}/**/*.rb'
+    reek.config_file  = 'config/reek.yml'
   end
 end

data/tasks/metrics/rubocop.rake

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 namespace :metrics do
   desc 'Check with code style guide'
   task :rubocop do

data/tasks/metrics/yardstick.rake

@@ -1,22 +1,8 @@
-# encoding: utf-8
-
 namespace :metrics do
   namespace :yardstick do
     require 'yardstick/rake/measurement'
     require 'yardstick/rake/verify'
 
-    # Enable the legacy parser for JRuby until ripper is fully supported
-    if Devtools.jruby?
-      # Remove when https://github.com/lsegal/yard/issues/681 is resolved
-      # This code first requires ripper, then removes the constant so
-      # that it does not trigger a bug in YARD where if it checks if Ripper
-      # is available and assumes other constants are defined, when JRuby's
-      # implementation does not yet.
-      require 'ripper'
-      Object.send(:remove_const, :Ripper)
-      YARD::Parser::SourceParser.parser_type = :ruby18
-    end
-
     options = Devtools.project.yardstick.options
 
     Yardstick::Rake::Measurement.new(:measure, options)

data/tasks/spec.rake

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 begin
   require 'rspec/core/rake_task'
 

data/tasks/yard.rake

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 begin
   require 'yard'