wtt-core 0.1.15

data/exe/wtt_cover

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'wtt'
+require 'simplecov'
+require 'simplecov-html'
+SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
+SimpleCov.command_name 'WTT'
+SimpleCov.coverage_dir('wtt_coverage')
+
+repo = Rugged::Repository.discover(Dir.pwd)
+storage = WTT::Core::Storage.new( repo )
+mapper = WTT::Core::Mapper.new( storage )
+
+coverage = Hash.new { |h, k| h[k] = [] }
+
+mapper.mapping.each do |_test, test_coverage|
+
+  test_coverage.each do |file, lines|
+    source_file = "#{WTT::Core.rake_root}/#{file}"
+    lines.each do |line_no|
+      old_count = coverage[source_file][line_no - 1].to_i
+      coverage[source_file][line_no - 1] = old_count + 1
+    end
+  end
+end
+
+result = SimpleCov::Result.new(coverage)
+result.format!
+puts 'WTT coverage report saved to ./wtt_coverage'

data/lib/wtt/core/anchor_task.rb

@@ -0,0 +1,30 @@
+require 'wtt/core'
+require 'rake'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    # Helper to declare take tasks for anchor raise/drop.
+    class AnchorTasks
+      include Rake::DSL
+      def initialize
+        define_anchor_tasks
+      end
+
+      def define_anchor_tasks
+        namespace :wtt do
+          desc 'Set the SHA for use in WTT'
+          task 'anchor_drop' do
+            WTT::Core.anchor_drop
+          end
+
+          desc 'Clear the SHA for use in WTT'
+          task 'anchor_raise' do
+            WTT::Core.anchor_raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wtt/core/mapper.rb

@@ -0,0 +1,138 @@
+require 'wtt'
+require 'rugged'
+require 'json'
+require 'set'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    # Mapping from test file to executed code (i.e. coverage without execution count).
+    #
+    # Terminologies:
+    #   spectra: { filename => [line, numbers, executed], ... }
+    #   mapping: { test_file => spectra }
+    class Mapper
+      STORAGE_SECTION = 'mapping'.freeze
+
+      attr_reader :mapping
+
+      # @param storage [WTT::Core::Storage] The storage object to read and write from.
+      def initialize(storage)
+        @storage = storage
+        read!
+      end
+
+      def matcher
+        @matcher ||= WTT.configuration.matcher
+      end
+
+      # Append the new mapping to test-to-code mapping file.
+      #
+      # @param test [String] test file for which the coverage data is produced
+      # @param coverage [Hash] coverage data generated using `Coverage.start` and `Coverage.result`
+      # @return [void]
+      def append_from_coverage(test, coverage)
+        spectra = normalize_paths(select_project_files(spectra_from_coverage(coverage)))
+        @mapping[test] = spectra
+      end
+
+      # Append the new mapping to test-to-code mapping file.
+      #
+      # @param test [String] test file for which the coverage data is produced
+      # @param coverage [Hash] coverage data generated using `Coverage.start` and `Coverage.result`
+      # @return [void]
+      def append_from_simplecov(test, coverage)
+        spectra = normalize_paths(select_project_files(spectra_from_simplecov(coverage)))
+        @mapping[test] = spectra
+      end
+
+      # Read test-to-code mapping from storage.
+      def read!
+        @mapping = @storage.read(STORAGE_SECTION)
+      end
+
+      # Write test-to-code mapping to storage.
+      def write!
+        @storage.write!(STORAGE_SECTION, @mapping)
+      end
+
+      # Get tests affected from change of file `file` at line number `lineno`
+      #
+      # @param file [String] file name which might have effects on some tests
+      # @param lineno [Integer] line number in the file which might have effects on some tests
+      # @return [Set] a set of test files which might be affected by the change in file at lineno
+      def get_tests(file, lineno)
+        tests = Set.new
+        @mapping.each do |test, spectra|
+          lines = spectra[file]
+          next unless lines
+          tests << test if matcher.match(lines, lineno)
+        end
+        warn "No tests found for #{file}:#{lineno}." if file.end_with?( '.rb' )
+        tests
+      end
+
+      private
+
+      # Convert absolute path to relative path from the project (Git repository) root.
+      #
+      # @param file [String] file name (absolute path)
+      # @return [String] normalized file path
+      def normalized_path(file)
+        File.expand_path(file).sub("#{WTT::Core.rake_root}/", '')
+      end
+
+      # Normalize all file names in a spectra.
+      #
+      # @param spectra [Hash] spectra data
+      # @return [Hash] spectra whose keys (file names) are normalized
+      def normalize_paths(spectra)
+        Hash[spectra.map { |k, v| [normalized_path(k), v] }]
+      end
+
+      # Filter out the files outside of the target project using file path.
+      #
+      # @param spectra [Hash] spectra data
+      # @return [Hash] spectra with only files inside the target project
+      def select_project_files(spectra)
+        spectra.select do |filename, _lines|
+          filename.start_with?(WTT::Core.rake_root)
+        end
+      end
+
+      # Generate spectra data from Ruby coverage library's data
+      #
+      # @param cov [Hash] coverage data generated using `Coverage.result`
+      # @return [Hash] spectra data
+      def spectra_from_coverage(cov)
+        spectra = Hash.new { |h, k| h[k] = [] }
+        cov.each do |filename, executions|
+
+          executions.each_with_index do |execution, i|
+            next if execution.nil? || execution == 0
+            spectra[filename] << i + 1
+          end
+        end
+        spectra
+      end
+
+      # Generate spectra data from Ruby coverage library's data
+      #
+      # @param cov [Hash] coverage data generated using `Simplecov.result`
+      # @return [Hash] spectra data
+      def spectra_from_simplecov(cov)
+
+        spectra = Hash.new { |h, k| h[k] = [] }
+        cov.files.each do |file|
+          filename = file.filename
+          file.coverage.each_with_index do |execution, i|
+            next if execution.nil? || execution == 0
+            spectra[filename] << i + 1
+          end
+        end
+        spectra
+      end
+    end
+  end
+end

data/lib/wtt/core/matchers/exact_matcher.rb

@@ -0,0 +1,17 @@
+require 'wtt/core'
+require 'rake'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    module Matchers
+      # Matches the extact line that changed
+      class Exact
+        def match(spectra, lineno)
+          true if spectra.include?(lineno) || lineno == 0
+        end
+      end
+    end
+  end
+end

data/lib/wtt/core/matchers/fuzzy_matcher.rb

@@ -0,0 +1,21 @@
+require 'wtt/core'
+require 'rake'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    module Matchers
+      # Matches if the line that changed is within "spread" distance
+      class Fuzzy
+        def initialize(spread=11)
+          @spread = spread
+        end
+
+        def match(spectra, lineno)
+          true if spectra.any? { |v| (v - lineno).abs <= @spread } || lineno == 0
+        end
+      end
+    end
+  end
+end

data/lib/wtt/core/matchers/touch_matcher.rb

@@ -0,0 +1,17 @@
+require 'wtt/core'
+require 'rake'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    module Matchers
+      # Matches the extact line that changed
+      class Touch
+        def match(spectra, lineno)
+          true if (spectra.first <= lineno && lineno <= spectra.last) || lineno == 0
+        end
+      end
+    end
+  end
+end

data/lib/wtt/core/matchers.rb

@@ -0,0 +1,3 @@
+require 'wtt/core/matchers/exact_matcher'
+require 'wtt/core/matchers/fuzzy_matcher'
+require 'wtt/core/matchers/touch_matcher'

data/lib/wtt/core/meta_data.rb

@@ -0,0 +1,42 @@
+require 'wtt'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    # Bucket for holding data in the wtt file
+    class MetaData
+      STORAGE_SECTION = 'meta'
+
+      # @param storage [Storage] Where to read//write
+      def initialize(storage)
+        @storage = storage
+        read!
+      end
+
+      def anchored_commit
+        @data['anchored_commit']
+      end
+
+      def anchored_commit=( val )
+        @data['anchored_commit'] = val
+      end
+
+      def [](name)
+        @data[name]
+      end
+
+      def []=(name, value)
+        @data[name] = value
+      end
+
+      def read!
+        @data = @storage.read(STORAGE_SECTION)
+      end
+
+      def write!
+        @storage.write!(STORAGE_SECTION, @data)
+      end
+    end
+  end
+end

data/lib/wtt/core/paths.rb

@@ -0,0 +1,21 @@
+require 'rake'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    class << self
+      def rake_root
+        @@root_dir ||= Rake.application.find_rakefile_location[1].freeze
+      end
+
+      def rake_root=(dir)
+        @@root_dir = dir
+      end
+
+      def wtt_root
+        "#{rake_root}/.wtt".freeze
+      end
+    end
+  end
+end

data/lib/wtt/core/selector.rb

@@ -0,0 +1,148 @@
+require 'wtt'
+require 'rugged'
+require 'set'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    # Select tests using Git information and a {Mapper}.
+    class Selector
+      attr_reader :tests
+      attr_writer :walker, :mapping
+
+      # @param opts [Hash] a hash with options
+      def initialize(opts)
+        @repo = opts[:repo]
+        @metadata = opts[:meta_data]
+        @walker = opts[:walker]
+        @test_files = opts[:test_files]
+        @mapping = opts[:mapping]
+        @target_revision = @repo.lookup(opts[:target_sha]) if opts[:target_sha]
+      end
+
+
+      # Select tests using differences in anchored commit and target commit
+      # (or current working tree) and {TestToCodeMapping}.
+      #
+      # @return [Set] a set of tests that might be affected by changes in base_sha...target_sha
+      def select_tests!
+        # Base should be the commit `anchor` has run on.
+        # NOT the one test-to-code mapping was committed to.
+        @base_obj = anchored_commit
+
+        # select all tests if anchored commit does not exist
+        return Set.new(@test_files) unless @base_obj
+
+        change_count = 0
+        
+        @tests = Set.new
+        diff.each_patch do |patch|
+          change_count += 1
+          file = patch.delta.old_file[:path]
+          if test_file?(file)
+            @tests << file
+          else
+            select_tests_from_patch(patch)
+          end
+        end
+        @tests.delete(nil)
+        puts "WTT found #{@tests.count} tests for #{change_count} changes."
+        @tests
+      end
+
+      private
+
+      def diff
+        opts = {
+            include_untracked: true,
+            recurse_untracked_dirs: true
+        }
+        defined?(@target_revision) ? @base_obj.diff(@target_revision, opts) : @base_obj.diff_workdir(opts)
+      end
+
+      def mapping
+        @mapping ||= begin
+          sha = defined?(@target_revision) && !@target_revision.nil? ? @target_revision.oid : @repo.head.target_id
+          Mapper.new(Storage.new(@repo, sha))
+        end
+      end
+
+      # Select tests which are affected by the change of given patch.
+      #
+      # @param patch [Rugged::Patch]
+      # @return [Set] set of selected tests
+      def select_tests_from_patch(patch)
+        target_lines = Set.new
+        file = patch.delta.old_file[:path]
+
+
+        patch.each_hunk do |hunk|
+          target_lines.merge target_lines_from_hunk(hunk)
+        end
+
+        target_lines.each do |line|
+          @tests += mapping.get_tests(file, line)
+        end
+      end
+
+      # Find lines within a hunk
+      #
+      # @param hunk [Rugged::Hunk]
+      # @return [Array] Lines that changed
+      def target_lines_from_hunk(hunk)
+        target_lines = []
+        prev_line = nil
+        hunk.each_line do |line|
+          line_no = hunk_line_no(line, prev_line, hunk)
+          target_lines << line_no unless line_no.nil?
+          prev_line = line
+        end
+        target_lines
+      end
+
+      # Figure out the line number for a change
+      #
+      # @param line [Rugged::Line]
+      # @param prev_line [Rugged::Line]
+      # @param hunk [Rugged::Hunk]
+      # @return [int] A line number or nil
+      def hunk_line_no(line, prev_line, hunk)
+        case line.line_origin
+          when :addition
+            if prev_line && !prev_line.addition?
+              return prev_line.old_lineno
+            elsif prev_line.nil?
+              return hunk.old_start
+            end
+          when :deletion
+            return line.old_lineno
+        end
+
+        nil
+      end
+
+      def walker
+        @walker ||= Rugged::Walker.new(@repo)
+      end
+
+      # Find the commit `anchor` has been run on, or the previous commit.
+      def anchored_commit
+        return @repo.lookup(@metadata.anchored_commit) if @metadata.anchored_commit
+        walker.sorting(Rugged::SORT_DATE)
+        walker.push(@repo.head.target)
+        commit = walker.find do |c|
+          c.parents.size == 1
+        end
+        @repo.lookup(commit.oid)
+      end
+
+      # Check if the given file is a test file.
+      #
+      # @param file_from_mapping [String]
+      def test_file?(file_from_mapping)
+        @test_files.any? { |f| file_from_mapping.include?(f) }
+      end
+    end
+  end
+end

data/lib/wtt/core/storage.rb

@@ -0,0 +1,89 @@
+require 'rugged'
+
+module WTT
+  module Core
+    # A utility class to store WTT data such as test-to-code mapping and metadata.
+    class Storage
+      # Initialize the storage from given repo and sha. This reads contents from
+      # a `.wtt` file. When sha is not nil, contents of the file on that commit
+      # is read. Data can be written only when sha is nil (written to current
+      # working tree).
+      #
+      # @param repo [Rugged::Repository]
+      # @param sha [String] sha of the commit which data should be read from.
+      #   nil means reading from/writing to current working tree.
+      def initialize(repo = nil, sha = nil)
+        @repo = repo
+        @sha = sha
+      end
+
+      # Read data from the storage in the given section.
+      #
+      # @param section [String]
+      # @return [Hash]
+      def read(section)
+        data_from_str(read_storage_content)[section] || {}
+      end
+
+      # Write value to the given section in the storage.
+      # Locks the file so that concurrent write does not occur.
+      #
+      # @param section [String]
+      # @param value [Hash]
+      # rubocop:disable Metrics/AbcSize
+      def write!(section, value)
+        fail 'Data cannot be written to the storage back in git history' unless @sha.nil?
+        File.open(WTT::Core.wtt_root, File::RDWR | File::CREAT, 0644) do |f|
+          f.flock(File::LOCK_EX)
+          data = data_from_str( f.read )
+          data[section] = value
+          f.rewind
+          f.write(data.to_json)
+          f.flush
+          f.truncate(f.pos)
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def data_from_str(str)
+        str.length > 0 ? JSON.parse(str) : {}
+      end
+
+      def filename_from_repository_root
+        WTT::Core.wtt_root.gsub(@repo.workdir, '')
+      end
+
+      def storage_file_oid
+        paths = filename_from_repository_root.split(File::SEPARATOR)
+        obj = find_file_in_repo paths
+        return nil unless obj
+        obj[:oid]
+      end
+
+      def find_file_in_repo(paths)
+        tree = @repo.lookup(@sha).tree
+        dirs = paths[0...-1]
+        filename = paths[-1]
+
+        dirs.each do |dir|
+          obj = tree[dir]
+          return nil unless obj
+          tree = @repo.lookup(obj[:oid])
+        end
+        tree[filename]
+      end
+
+
+      def read_storage_content
+        if @sha
+          oid = storage_file_oid
+          oid.nil? ? '' : @repo.lookup(oid).content
+        else
+          File.exist?(WTT::Core.wtt_root) ? File.read(WTT::Core.wtt_root) : ''
+        end
+      end
+    end
+  end
+end

data/lib/wtt/core/trace_service.rb

@@ -0,0 +1,47 @@
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    # Service for gathering coverage information and sending it back via DRB.
+    class TraceService
+      attr_reader :coverage
+
+      def initialize
+        @coverage = Hash.new { |h, k| h[k] = [] }
+        @trace = TracePoint.new(:line) do |tp|
+          if should_include_file?( tp.path )
+            old_count = @coverage[tp.path][tp.lineno].to_i
+            @coverage[tp.path][tp.lineno] = old_count + 1
+          end
+        end
+      end
+
+      def start_trace
+        reset_coverage
+        @trace.enable
+      end
+
+      def stop_trace
+        @trace.disable
+      end
+
+      def coverage
+        stop_trace
+        results = @coverage.dup
+        start_trace
+        return results
+      end
+
+      private
+
+      def reset_coverage
+        @coverage = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def should_include_file?(path)
+        !WTT.configuration.reject_filters.any? {|f| f.match(path)}
+      end
+    end
+  end
+end

data/lib/wtt/core/tracer.rb

@@ -0,0 +1,95 @@
+require 'wtt/core'
+require 'drb/drb'
+
+# Top level namespace for What to Test
+module WTT
+  # Functionality core to WTT belongs here
+  module Core
+    # Helper class to gather coverage data via the Tracepoint API
+    class Tracer
+      def initialize
+        @remotes = []
+        reset_coverage
+        connect_remotes WTT.configuration.remotes
+      end
+
+      def start_trace
+        @debug = []
+        reset_coverage
+        start_remotes
+        tracepoint.enable
+      end
+
+      def stop_trace
+        stop_remotes
+        tracepoint.disable
+      end
+
+      def coverage
+        all_coverage = @coverage.dup
+        @remotes.each { |r| merge_remote_coverage!(all_coverage, r.coverage) }
+        all_coverage
+      end
+
+      private
+
+      def merge_remote_coverage!(local, remote)
+        remote.each do |filename, remote_coverage|
+          if local.has_key? (filename)
+            remote_coverage.each_with_index do |v, i |
+              # We have to do this dance because the arrays contain nils
+              current = local[filename][i].to_i
+              local[filename][i] = current + v.to_i
+            end
+          else
+            local[filename] = remote_coverage.dup
+          end
+        end
+      end
+
+
+      def start_remotes
+        @remotes.each { |r| r.start_trace }
+      end
+
+      def stop_remotes
+        @remotes.each { |r| r.stop_trace }
+      end
+
+      def reset_coverage
+        @coverage = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def should_include_file?(path)
+        !WTT.configuration.reject_filters.any? {|f| f.match(path)}
+      end
+
+      def tracepoint
+        @trace ||= TracePoint.new(:line, :call, :return) do |tp|
+
+          if should_include_file?( tp.path )
+            old_count = @coverage[tp.path][tp.lineno].to_i
+            @coverage[tp.path][tp.lineno] = old_count + 1
+          end
+        end
+      end
+
+      def connect_remotes(remote_uris)
+        remote_uris.each do |remote_uri|
+          connect_remote remote_uri
+        end
+      end
+
+      def connect_remote(remote_uri)
+        begin
+          service = DRbObject.new_with_uri(remote_uri)
+          # Ask for the (empty) coverage to see if the service is live
+          service.coverage
+          @remotes << service
+        rescue Exception => ex
+          warn "Could not connect to Traced at #{remote_uri}.  #{ex.message}"
+        end
+      end
+    end
+  end
+end