smackdown 0.0.1.a

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c359ca40e55cfc3d71c61a0e9dad03a1bffbe98
+  data.tar.gz: bd66adafbada6ee911654fcfe06883e8ee2075ac
+SHA512:
+  metadata.gz: 7c9cdd325f82fc218614d52aee0b7c237d54f34d7756e1d3b7036dab18487862060f814ec2d077a91dfd6ff720b3676ff01ba82214217f986225c861f4467c9a
+  data.tar.gz: ac9be749f25cd7712cc3f33ad02b83e648f7399e2422cd04075f02ec6da603e03a454c5aa37abaec8eb09549d859f0ab5b13b567172ce72a76be76523055912d

data/lib/smackdown.rb

@@ -0,0 +1,20 @@
+require 'json'
+require 'rugged'
+
+require 'smackdown/uncovered_line'
+require 'smackdown/file_coverage_diff'
+require 'smackdown/coverage_diff_reporter'
+
+module Smackdown
+  class Tasks
+    if defined? Rake::DSL
+      include Rake::DSL
+
+      def install_tasks
+        import File.join(File.dirname(__FILE__), 'tasks/smackdown.rake')
+      end
+    end
+  end
+end
+
+Smackdown::Tasks.new.install_tasks if defined? Rake::DSL

data/lib/smackdown/coverage_diff_reporter.rb

@@ -0,0 +1,118 @@
+module Smackdown
+  class CoverageDiffReporter
+    DEFAULT_FILTERS = %w(
+      ^[^\/]*$
+      test/
+      features/
+      spec/
+      autotest/
+      config/
+      db/
+      vendor/bundle/
+      script
+      vendor
+      *.rake
+    )
+
+    attr_reader :file_coverage_diffs
+
+    def initialize(repo_path, opts = {})
+      raise "Repo path does not exist: #{repo_path}" unless Dir.exist?(repo_path)
+
+      if opts[:coverage_report_path] && opts[:coverage_json]
+        raise "Please pass only :coverage_report_path or :coverage_json, not both."
+      end
+
+      @coverage_json        = opts[:coverage_json] || nil
+
+      unless @coverage_json
+        @coverage_report_path = opts[:coverage_report_path] || File.join(repo_path, 'coverage', 'coverage.json')
+      end
+
+      @repo                 = Rugged::Repository.new(repo_path)
+      @report_path_prefix   = opts[:report_path_prefix] || repo_path
+      @head                 = opts[:head] || 'HEAD'
+      @merge_base           = opts[:merge_base] || 'master'
+      @context_lines        = opts[:context_lines] || 10000
+      @filters              = opts[:filters] || DEFAULT_FILTERS
+      @file_coverage_diffs  = {}
+    end
+
+    def run
+      process_coverage
+
+      @diff = @repo.diff(@repo.merge_base(@merge_base, @head), @head, context_lines: @context_lines)
+
+      process_diffs
+    end
+
+    def completely_covered?
+      @file_coverage_diffs.all? do |_relative_path, file_coverage_diff|
+        file_coverage_diff.covered?
+      end
+    end
+
+    def report(&block)
+      if block_given?
+        report_diffs(&block)
+      else
+        default_report
+      end
+    end
+
+    private
+
+    def parse_coverage_report
+      uri = URI(@coverage_report_path)
+      if ["http", "https"].include?(uri.scheme)
+        file_contents = Net::HTTP.get(uri)
+      else
+        raise "Coverage report path does not exist: #{@coverage_report_path}" unless File.exist?(@coverage_report_path)
+        file_contents = File.read(@coverage_report_path)
+      end
+
+      @parsed_coverage_json = JSON.parse(file_contents)
+    end
+
+    def process_coverage
+      if @coverage_json
+        @parsed_coverage_json = JSON.parse(@coverage_json)
+      else
+        parse_coverage_report
+      end
+      @coverage_json_hash = Hash.new
+      @parsed_coverage_json["files"].each do |file_diff|
+        @coverage_json_hash[file_diff["filename"]] = file_diff["coverage"]
+      end
+    end
+
+    def process_diffs
+      @diff.patches.each do |patch|
+        relative_path = patch.delta.new_file[:path]
+
+        next if @filters.any?{ |filter| /^#{filter}/.match relative_path }
+
+        full_path = File.join(@report_path_prefix, relative_path)
+        coverage = @coverage_json_hash[full_path]
+
+        @file_coverage_diffs[relative_path] = FileCoverageDiff.new(relative_path, full_path, coverage, patch)
+      end
+    end
+
+    def report_diffs(&block)
+      @file_coverage_diffs.each do |_relative_path, file_coverage_diff|
+        yield file_coverage_diff
+      end
+    end
+
+    def default_report
+      if completely_covered?
+        "All new and modified code is covered!"
+      else
+        @file_coverage_diffs.inject("") do |output, (_path, file_coverage_diff)|
+          "#{output}#{file_coverage_diff.to_s}"
+        end
+      end
+    end
+  end
+end

data/lib/smackdown/file_coverage_diff.rb

@@ -0,0 +1,65 @@
+module Smackdown
+  class FileCoverageDiff
+    attr_reader :uncovered_lines, :relative_path, :full_path
+
+    def initialize(relative_path, full_path, coverage, patch)
+      @relative_path = relative_path
+      @full_path = full_path
+      @coverage = coverage
+      @patch = patch
+      @uncovered_lines = []
+      @coverage_available = !coverage.nil?
+
+      record_coverage if @coverage_available
+    end
+
+    def coverage_available?
+      @coverage_available
+    end
+
+    def covered?
+      coverage_available? && @uncovered_lines.none?
+    end
+
+    def to_s
+      str = relative_path
+
+      if coverage_available?
+        if covered?
+          str += "\n100\% covered!"
+        else
+          uncovered_lines.each do |line|
+            str += "\n#{line.line_num}: #{line.line_content}"
+          end
+        end
+      else
+        str += "\nNo coverage for this file!"
+      end
+
+      str += "\n\n-----------------------------------------\n"
+
+      str
+    end
+
+    private
+
+    def record_coverage
+      @patch.hunks.each do |hunk|
+        added_lines = hunk.lines.select{ |line| line.line_origin == :addition }
+        added_lines.each do |line|
+          process_line(line)
+        end
+      end
+    end
+
+    def process_line(line)
+      line_number = line.new_lineno
+      single_line_hits = @coverage[line_number - 1]
+      if single_line_hits && single_line_hits < 1
+        line_content = line.content.gsub("\n", "")
+        @uncovered_lines << UncoveredLine.new(line_number, line_content)
+      end
+    end
+
+  end
+end

data/lib/smackdown/uncovered_line.rb

@@ -0,0 +1,10 @@
+module Smackdown
+  class UncoveredLine
+    attr_reader :line_num, :line_content
+
+    def initialize(line_num, line_content)
+      @line_num = line_num
+      @line_content = line_content
+    end
+  end
+end

data/lib/smackdown/version.rb

@@ -0,0 +1,3 @@
+module Smackdown
+  VERSION = "0.0.1.a"
+end

data/lib/tasks/smackdown.rake

@@ -0,0 +1,8 @@
+desc "Run smackdown on your current branch with the most common options"
+task :smackdown do
+  reporter = Smackdown::CoverageDiffReporter.new(File.expand_path('.'))
+  reporter.run
+  puts reporter.report
+
+  exit(reporter.completely_covered?)
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: smackdown
+version: !ruby/object:Gem::Version
+  version: 0.0.1.a
+platform: ruby
+authors:
+- Rob Esris
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+description: Identify and report on lines of code, introduced in a branch (e.g. a
+  pull request) that are not covered by tests.
+email:
+- resris@paperlesspost.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/smackdown.rb
+- lib/smackdown/coverage_diff_reporter.rb
+- lib/smackdown/file_coverage_diff.rb
+- lib/smackdown/uncovered_line.rb
+- lib/smackdown/version.rb
+- lib/tasks/smackdown.rake
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Identify and report on lines of code, introduced in a branch (e.g. a pull
+  request) that are not covered by tests.
+test_files: []