ashtonw-slather 1.8.2

data/lib/slather/coverage_service/gutter_json_output.rb

@@ -0,0 +1,50 @@
+module Slather
+  module CoverageService
+    module GutterJsonOutput
+
+      def coverage_file_class
+        Slather::CoverageFile
+      end
+      private :coverage_file_class
+
+      def post
+        output = { 'meta' => { 'timestamp' => DateTime.now.strftime('%Y-%m-%d %H:%M:%S.%6N') } }
+        symbols = {}
+
+        coverage_files.each do |coverage_file|
+          next unless coverage_file.gcov_data
+
+          filename = coverage_file.source_file_pathname.to_s
+          filename = filename.sub(Pathname.pwd.to_s, '').reverse.chomp("/").reverse
+
+          coverage_file.cleaned_gcov_data.split("\n").each do |line|
+            data = line.split(':')
+
+            line_number = data[1].to_i
+            next unless line_number > 0
+
+            coverage = data[0].strip
+
+            symbol = {  'line' => line_number,
+                        'long_text' => '',
+                        'short_text' => coverage }
+
+            if coverage != '-'
+              symbol['background_color'] = coverage.to_i > 0 ? '0x35CC4B' : '0xFC635E'
+            end
+
+            if symbols.has_key?(filename)
+              symbols[filename] << symbol
+            else
+              symbols[filename] = [ symbol ]
+            end
+          end
+        end
+
+        output['symbols_by_file'] = symbols
+        File.open('.gutter.json', 'w') { |file| file.write(output.to_json) }
+      end
+
+    end
+  end
+end

data/lib/slather/coverage_service/hardcover.rb

@@ -0,0 +1,61 @@
+module Slather
+  module CoverageService
+    module Hardcover
+
+      def coverage_file_class
+        Slather::CoverallsCoverageFile
+      end
+      private :coverage_file_class
+
+      def jenkins_job_id
+        "#{ENV['JOB_NAME']}/#{ENV['BUILD_NUMBER']}"
+      end
+      private :jenkins_job_id
+
+      def hardcover_coverage_data
+        if ci_service == :jenkins_ci
+          if jenkins_job_id
+            {
+              :service_job_id => jenkins_job_id,
+              :service_name => "jenkins-ci",
+              :repo_token => Project.yml["hardcover_repo_token"],
+              :source_files => coverage_files.map(&:as_json)
+            }.to_json
+          else
+            raise StandardError, "Environment variables `BUILD_NUMBER` and `JOB_NAME` are not set. Is this running on a Jenkins build?"
+          end
+        else
+          raise StandardError, "No support for ci named #{ci_service}"
+        end
+      end
+      private :hardcover_coverage_data
+
+      def post
+        f = File.open('hardcover_json_file', 'w+')
+        begin
+          f.write(hardcover_coverage_data)
+          f.close
+          `curl --form json_file=@#{f.path} #{hardcover_api_jobs_path}`
+        rescue StandardError => e
+          FileUtils.rm(f)
+          raise e
+        end
+        FileUtils.rm(f)
+      end
+
+      def hardcover_api_jobs_path
+        "#{hardcover_base_url}/v1/jobs"
+      end
+      private :hardcover_api_jobs_path
+
+      def hardcover_base_url
+        url = Project.yml["hardcover_base_url"]
+        unless url
+          raise "No `hardcover_base_url` configured. Please add it to your `.slather.yml`"
+        end
+        url
+      end
+      private :hardcover_base_url
+    end
+  end
+end

data/lib/slather/coverage_service/html_output.rb

@@ -0,0 +1,244 @@
+require 'nokogiri'
+
+module Slather
+  module CoverageService
+    module HtmlOutput
+
+      def coverage_file_class
+        Slather::CoverageFile
+      end
+      private :coverage_file_class
+
+      def directory_path
+        is_path_valid = !output_directory.nil? && !output_directory.strip.eql?("")
+        is_path_valid ? File.expand_path(output_directory) : "html"
+      end
+      private :directory_path
+
+      def post
+        create_html_reports(coverage_files)
+        generate_reports(@docs)
+
+        index_html_path = File.join(directory_path, "index.html")
+        if show_html
+          open_coverage index_html_path
+        else
+          print_path_coverage index_html_path
+        end
+      end
+
+      def print_path_coverage(index_html)
+        path = File.expand_path index_html
+        puts "\nTo open the html reports, use \n\nopen '#{path}'\n\nor use '--show' flag to open it automatically.\n\n"
+      end
+
+      def open_coverage(index_html)
+        path = File.expand_path index_html
+        `open '#{path}'` if File.exist?(path)
+      end
+
+      def create_html_reports(coverage_files)
+        create_index_html(coverage_files)
+        create_htmls_from_files(coverage_files)
+      end
+
+      def generate_reports(reports)
+        FileUtils.rm_rf(directory_path) if Dir.exist?(directory_path)
+        FileUtils.mkdir_p(directory_path)
+
+        reports.each do |name, doc|
+          html_file = File.join(directory_path, "#{name}.html")
+          File.write(html_file, doc.to_html)
+        end
+      end
+
+      def create_index_html(coverage_files)
+        project_name = File.basename(self.xcodeproj)
+        template = generate_html_template(project_name, true, false)
+
+        total_relevant_lines = 0
+        total_tested_lines = 0
+        coverage_files.each { |coverage_file|
+          total_tested_lines += coverage_file.num_lines_tested
+          total_relevant_lines += coverage_file.num_lines_testable
+        }
+
+        builder = Nokogiri::HTML::Builder.with(template.at('#reports')) { |cov|
+          cov.h2 "Files for \"#{project_name}\""
+
+          cov.h4 {
+            percentage = (total_tested_lines / total_relevant_lines.to_f) * 100.0
+            cov.span "Total Coverage : "
+            cov.span '%.2f%%' % percentage, :class => class_for_coverage_percentage(percentage), :id => "total_coverage"
+          }
+
+          cov.input(:class => "search", :placeholder => "Search")
+
+          cov.table(:class => "coverage_list", :cellspacing => 0,  :cellpadding => 0) {
+
+            cov.thead {
+              cov.tr {
+                cov.th "%", :class => "col_num sort", "data-sort" => "data_percentage"
+                cov.th "File", :class => "sort", "data-sort" => "data_filename"
+                cov.th "Lines", :class => "col_percent sort", "data-sort" => "data_lines"
+                cov.th "Relevant", :class => "col_percent sort", "data-sort" => "data_relevant"
+                cov.th "Covered", :class => "col_percent sort", "data-sort" => "data_covered"
+                cov.th "Missed", :class => "col_percent sort", "data-sort" => "data_missed"
+              }
+            }
+
+            cov.tbody(:class => "list") {
+              coverage_files.each { |coverage_file|
+                filename = File.basename(coverage_file.source_file_pathname_relative_to_repo_root)
+                filename_link = "#{filename}.html"
+
+                cov.tr {
+                  percentage = coverage_file.percentage_lines_tested
+
+                  cov.td { cov.span '%.2f' % percentage, :class => "percentage #{class_for_coverage_percentage(percentage)} data_percentage" }
+                  cov.td(:class => "data_filename") {
+                    cov.a filename, :href => filename_link
+                  }
+                  cov.td "#{coverage_file.line_coverage_data.count}", :class => "data_lines"
+                  cov.td "#{coverage_file.num_lines_testable}", :class => "data_relevant"
+                  cov.td "#{coverage_file.num_lines_tested}", :class => "data_covered"
+                  cov.td "#{(coverage_file.num_lines_testable - coverage_file.num_lines_tested)}", :class => "data_missed"
+                }
+              }
+            }
+          }
+        }
+
+        @docs = Hash.new
+        @docs[:index] = builder.doc
+      end
+
+      def create_htmls_from_files(coverage_files)
+        coverage_files.map { |file| create_html_from_file file }
+      end
+
+      def create_html_from_file(coverage_file)
+        filepath = coverage_file.source_file_pathname_relative_to_repo_root
+        filename = File.basename(filepath)
+        percentage = coverage_file.percentage_lines_tested
+
+        cleaned_gcov_lines = coverage_file.cleaned_gcov_data.split("\n")
+        is_file_empty = (cleaned_gcov_lines.count <= 0)
+
+        template = generate_html_template(filename, false, is_file_empty)
+
+        builder = Nokogiri::HTML::Builder.with(template.at('#reports')) { |cov|
+          cov.h2(:class => "cov_title") {
+            cov.span("Coverage for \"#{filename}\"" + (!is_file_empty ? " : " : ""))
+            cov.span("#{'%.2f' % percentage}%", :class => class_for_coverage_percentage(percentage)) unless is_file_empty
+          }
+
+          cov.h4("(#{coverage_file.num_lines_tested} of #{coverage_file.num_lines_testable} relevant lines covered)", :class => "cov_subtitle")
+          cov.h4(filepath, :class => "cov_filepath")
+
+          if is_file_empty
+            cov.p "¯\\_(ツ)_/¯"
+            next
+          end
+
+          cov.table(:class => "source_code") {
+            cleaned_gcov_lines.each do |line|
+              data = line.split(':', 3)
+
+              line_number = data[1].to_i
+              next unless line_number > 0
+
+              coverage_data = data[0].strip
+              line_data = [line_number, data[2], hits_for_coverage_data(coverage_data)]
+              classes = ["num", "src", "coverage"]
+
+              cov.tr(:class => class_for_coverage_data(coverage_data)) {
+                line_data.each_with_index { |line, idx|
+                  if idx != 1
+                    cov.td(line, :class => classes[idx])
+                  else
+                    cov.td(:class => classes[idx]) {
+                      cov.pre { cov.code(line, :class => "objc") }
+                    }
+                  end
+                }
+              }
+            end
+          }
+        }
+
+        @docs[filename] = builder.doc
+      end
+
+      def generate_html_template(title, is_index, is_file_empty)
+        logo_path = File.join(gem_root_path, "docs/logo.jpg")
+        css_path = File.join(gem_root_path, "assets/slather.css")
+        highlight_js_path = File.join(gem_root_path, "assets/highlight.pack.js")
+        list_js_path = File.join(gem_root_path, "assets/list.min.js")
+
+        builder = Nokogiri::HTML::Builder.new do |doc|
+          doc.html {
+            doc.head {
+              doc.title "#{title} - Slather"
+              doc.link :href => css_path, :media => "all", :rel => "stylesheet"
+            }
+            doc.body {
+              doc.header {
+                doc.div(:class => "row") {
+                  doc.a(:href => "index.html") { doc.img(:src => logo_path, :alt => "Slather logo") }
+                }
+              }
+              doc.div(:class => "row") { doc.div(:id => "reports") }
+              doc.footer {
+                doc.div(:class => "row") {
+                  doc.p { doc.a("Fork me on Github", :href => "https://github.com/venmo/slather") }
+                  doc.p("© #{Date.today.year} Slather")
+                }
+              }
+
+              if is_index
+                doc.script :src => list_js_path
+                doc.script "var reports = new List('reports', { valueNames: [ 'data_percentage', 'data_filename', 'data_lines', 'data_relevant', 'data_covered', 'data_missed' ]});"
+              else
+                unless is_file_empty
+                  doc.script :src => highlight_js_path
+                  doc.script "hljs.initHighlightingOnLoad();"
+                end
+              end
+            }
+          }
+        end
+        builder.doc
+      end
+
+      def gem_root_path
+        File.expand_path File.join(File.dirname(__dir__), "../..")
+      end
+
+      def class_for_coverage_data(coverage_data)
+        case coverage_data
+        when /\d/ then "covered"
+        when /#/ then "missed"
+        else "never"
+        end
+      end
+
+      def hits_for_coverage_data(coverage_data)
+        case coverage_data
+        when /\d/ then (coverage_data.to_i > 0) ? "#{coverage_data}x" : ""
+        when /#/ then "!"
+        else ""
+        end
+      end
+
+      def class_for_coverage_percentage(percentage)
+        case
+        when percentage > 85 then "cov_high"
+        when percentage > 70 then "cov_medium"
+        else "cov_low"
+        end
+      end
+
+    end
+  end
+end

data/lib/slather/coverage_service/simple_output.rb

@@ -0,0 +1,31 @@
+module Slather
+  module CoverageService
+    module SimpleOutput
+
+      def coverage_file_class
+        Slather::CoverageFile
+      end
+      private :coverage_file_class
+
+      def post
+        total_project_lines = 0
+        total_project_lines_tested = 0
+        coverage_files.each do |coverage_file|
+          # ignore lines that don't count towards coverage (comments, whitespace, etc). These are nil in the array.
+
+          lines_tested = coverage_file.num_lines_tested
+          total_lines = coverage_file.num_lines_testable
+          percentage = '%.2f' % [coverage_file.percentage_lines_tested]
+
+          total_project_lines_tested += lines_tested
+          total_project_lines += total_lines
+
+          puts "#{coverage_file.source_file_pathname_relative_to_repo_root}: #{lines_tested} of #{total_lines} lines (#{percentage}%)"
+        end
+        total_percentage = '%.2f' % [(total_project_lines_tested / total_project_lines.to_f) * 100.0]
+        puts "Test Coverage: #{total_percentage}%"
+      end
+
+    end
+  end
+end

data/lib/slather/coveralls_coverage_file.rb

@@ -0,0 +1,13 @@
+module Slather
+  class CoverallsCoverageFile < CoverageFile
+
+    def as_json
+      {
+        :name => source_file_pathname_relative_to_repo_root.to_s,
+        :source => source_data,
+        :coverage => line_coverage_data
+      }
+    end
+
+  end
+end

data/lib/slather/project.rb

@@ -0,0 +1,132 @@
+require 'fileutils'
+require 'xcodeproj'
+require 'json'
+require 'yaml'
+
+module Xcodeproj
+  class Project
+
+    def slather_setup_for_coverage
+      build_configurations.each do |build_configuration|
+        build_configuration.build_settings["GCC_INSTRUMENT_PROGRAM_FLOW_ARCS"] = "YES"
+        build_configuration.build_settings["GCC_GENERATE_TEST_COVERAGE_FILES"] = "YES"
+      end
+    end
+
+  end
+end
+
+module Slather
+  class Project < Xcodeproj::Project
+
+    attr_accessor :build_directory, :ignore_list, :ci_service, :coverage_service, :coverage_access_token, :source_directory, :output_directory, :xcodeproj, :show_html
+
+    alias_method :setup_for_coverage, :slather_setup_for_coverage
+
+    def self.open(xcodeproj)
+      proj = super
+      proj.configure_from_yml
+      proj.xcodeproj = xcodeproj
+      proj
+    end
+
+    def derived_data_dir
+      File.expand_path('~') + "/Library/Developer/Xcode/DerivedData/"
+    end
+    private :derived_data_dir
+
+    def build_directory
+      @build_directory || derived_data_dir
+    end
+
+    def coverage_files
+      coverage_files = Dir["#{build_directory}/**/*.gcno"].map do |file|
+        coverage_file = coverage_file_class.new(self, file)
+        # If there's no source file for this gcno, it probably belongs to another project.
+        coverage_file.source_file_pathname && !coverage_file.ignored? ? coverage_file : nil
+      end.compact
+
+      if coverage_files.empty?
+        raise StandardError, "No coverage files found. Are you sure your project is setup for generating coverage files? Try `slather setup your/project.xcodeproj`"
+      else
+        dedupe(coverage_files)
+      end
+    end
+    private :coverage_files
+
+    def dedupe(coverage_files)
+      coverage_files.group_by(&:source_file_pathname).values.map { |cf_array| cf_array.max_by(&:percentage_lines_tested) }
+    end
+    private :dedupe
+
+    def self.yml_filename
+      '.slather.yml'
+    end
+
+    def self.yml
+      @yml ||= File.exist?(yml_filename) ? YAML.load_file(yml_filename) : {}
+    end
+
+    def configure_from_yml
+      configure_build_directory_from_yml
+      configure_ignore_list_from_yml
+      configure_ci_service_from_yml
+      configure_coverage_access_token_from_yml
+      configure_coverage_service_from_yml
+      configure_source_directory_from_yml
+      configure_output_directory_from_yml
+    end
+
+    def configure_build_directory_from_yml
+      self.build_directory = self.class.yml["build_directory"] if self.class.yml["build_directory"] && !@build_directory
+    end
+
+    def configure_source_directory_from_yml
+      self.source_directory ||= self.class.yml["source_directory"] if self.class.yml["source_directory"]
+    end
+
+    def configure_output_directory_from_yml
+      self.output_directory ||= self.class.yml["output_directory"] if self.class.yml["output_directory"]
+    end
+
+    def configure_ignore_list_from_yml
+      self.ignore_list ||= [(self.class.yml["ignore"] || [])].flatten
+    end
+
+    def configure_ci_service_from_yml
+      self.ci_service ||= (self.class.yml["ci_service"] || :travis_ci)
+    end
+
+    def ci_service=(service)
+      @ci_service = service && service.to_sym
+    end
+
+    def configure_coverage_service_from_yml
+      self.coverage_service ||= (self.class.yml["coverage_service"] || :terminal)
+    end
+
+    def configure_coverage_access_token_from_yml
+      self.coverage_access_token ||= (ENV["COVERAGE_ACCESS_TOKEN"] || self.class.yml["coverage_access_token"] || "")
+    end
+
+    def coverage_service=(service)
+      service = service && service.to_sym
+      if service == :coveralls
+        extend(Slather::CoverageService::Coveralls)
+      elsif service == :hardcover
+        extend(Slather::CoverageService::Hardcover)
+      elsif service == :terminal
+        extend(Slather::CoverageService::SimpleOutput)
+      elsif service == :gutter_json
+        extend(Slather::CoverageService::GutterJsonOutput)
+      elsif service == :cobertura_xml
+        extend(Slather::CoverageService::CoberturaXmlOutput)
+      elsif service == :html
+        extend(Slather::CoverageService::HtmlOutput)
+      else
+        raise ArgumentError, "`#{coverage_service}` is not a valid coverage service. Try `terminal`, `coveralls`, `gutter_json`, `cobertura_xml` or `html`"
+      end
+      @coverage_service = service
+    end
+  end
+end