xcov 0.1

data/lib/xcov/commands_generator.rb

@@ -0,0 +1,51 @@
+require "commander"
+require "fastlane_core"
+
+HighLine.track_eof = false
+
+module Xcov
+  class CommandsGenerator
+
+    include Commander::Methods
+
+    FastlaneCore::CommanderGenerator.new.generate(Xcov::Options.available_options)
+
+    def self.start
+      FastlaneCore::UpdateChecker.start_looking_for_update("xcov")
+      new.run
+    ensure
+      FastlaneCore::UpdateChecker.show_update_status("xcov", Xcov::VERSION)
+    end
+
+    def convert_options(options)
+      o = options.__hash__.dup
+      o.delete(:verbose)
+      o
+    end
+
+    def run
+      program :version, Xcov::VERSION
+      program :description, Xcov::DESCRIPTION
+      program :help, "Author", "Carlos Vidal <nakioparkour@gmail.com>"
+      program :help, "Website", "http://www.nakiostudio.com"
+      program :help, "GitHub", "https://github.com/nakiostudio/xcov"
+      program :help_formatter, :compact
+
+      global_option("--verbose") { $verbose = true }
+
+      command :report do |c|
+        c.syntax = "Xcov"
+        c.description = Xcov::DESCRIPTION
+        c.action do |_args, options|
+          config = FastlaneCore::Configuration.create(Xcov::Options.available_options, convert_options(options))
+          Xcov::Manager.new.work(config)
+        end
+      end
+
+      default_command :report
+
+      run!
+    end
+
+  end
+end

data/lib/xcov/error_handler.rb

@@ -0,0 +1,46 @@
+
+module Xcov
+  class ErrorHandler
+
+    class << self
+      # @param [String] The output of the errored build
+      # This method should raise an exception in any case, as the return code indicated a failed build
+      def handle_error(output)
+        # The order of the handling below is import
+        case output
+        when /US\-ASCII/
+          print "Your shell environment is not correctly configured"
+          print "Instead of UTF-8 your shell uses US-ASCII"
+          print "Please add the following to your '~/.bashrc':"
+          print ""
+          print "       export LANG=en_US.UTF-8"
+          print "       export LANGUAGE=en_US.UTF-8"
+          print "       export LC_ALL=en_US.UTF-8"
+          print ""
+          print "You'll have to restart your shell session after updating the file."
+          print "If you are using zshell or another shell, make sure to edit the correct bash file."
+          print "For more information visit this stackoverflow answer:"
+          print "https://stackoverflow.com/a/17031697/445598"
+        when /CoverageNotFound/
+          print "Unable to find any .xccoverage file."
+          print "Make sure you have enabled 'Gather code coverage' setting on your scheme settings."
+          print "Alternatively you can provide the full path to your .xccoverage file."
+        when /Executed/
+          # this is *really* important:
+          # we don't want to raise an exception here
+          # as we handle this in runner.rb at a later point
+          # after parsing the actual test results
+          return
+        end
+        raise "Error processing coverage file - see the log above".red
+      end
+
+      private
+
+      def print(text)
+        Helper.log.error text.red
+      end
+    end
+
+  end
+end

data/lib/xcov/manager.rb

@@ -0,0 +1,13 @@
+require "fastlane_core"
+
+module Xcov
+  class Manager
+
+    def work(options)
+      Xcov.config = options
+      FastlaneCore::PrintTable.print_values(config: options, hide_keys: [:slack_url], title: "Summary for xCov #{Xcov::VERSION}")
+      Runner.new.run
+    end
+
+  end
+end

data/lib/xcov/model/base.rb

@@ -0,0 +1,47 @@
+require 'erb'
+
+module Xcov
+  class Base
+
+    attr_accessor :name
+    attr_accessor :coverage
+    attr_accessor :displayable_coverage
+    attr_accessor :coverage_color
+
+    attr_accessor :id
+
+    def create_displayable_coverage
+      "%.0f%%" % [(@coverage*100)]
+    end
+
+    def create_coverage_color
+      if @coverage > 0.8
+        return "#1FCB32"
+      elsif @coverage > 0.65
+        return "#FCFF00"
+      elsif @coverage > 0.5
+        return "#FF9C00"
+      else
+        return "#FF0000"
+      end
+    end
+
+    def create_summary
+      if @coverage > 0.8
+        return "Overall coverage is good"
+      elsif @coverage > 0.65
+        return "There is room for improvement"
+      elsif @coverage > 0.5
+        return "Almost unmaintainable"
+      else
+        return "Keep calm and leave the boat"
+      end
+    end
+
+    # Class methods
+    def self.template(name)
+      ERB.new(File.read(File.join(File.dirname(__FILE__), "../../../views/", "#{name}.erb")))
+    end
+
+  end
+end

data/lib/xcov/model/function.rb

@@ -0,0 +1,28 @@
+require 'cgi'
+
+module Xcov
+  class Function < Xcov::Base
+
+    def initialize (name, coverage)
+      @name = CGI::escapeHTML(name)
+      @coverage = coverage
+      @displayable_coverage = self.create_displayable_coverage
+      @coverage_color = self.create_coverage_color
+    end
+
+    def print_description
+      puts "\t\t\t#{@name} (#{@displayable_coverage})"
+    end
+
+    def html_value
+      Function.template("function").result(binding)
+    end
+
+    # Class methods
+
+    def self.map (dictionary)
+      Function.new(dictionary["name"], dictionary["coverage"])
+    end
+
+  end
+end

data/lib/xcov/model/report.rb

@@ -0,0 +1,53 @@
+
+module Xcov
+  class Report < Xcov::Base
+
+    attr_accessor :coverage
+    attr_accessor :targets
+    attr_accessor :summary
+    attr_accessor :target_templates
+
+    def initialize (targets)
+      @targets = targets
+      @coverage = average_coverage(targets)
+      @displayable_coverage = self.create_displayable_coverage
+      @coverage_color = self.create_coverage_color
+      @summary = self.create_summary
+    end
+
+    def average_coverage targets
+      coverage = 0
+      targets.each do |target|
+        coverage = coverage + target.coverage
+      end
+      coverage / targets.count
+    end
+
+    def print_description
+      puts "Total coverage: (#{@coverage})"
+      @targets.each do |target|
+        target.print_description
+      end
+    end
+
+    def html_value
+      @target_templates = ""
+      @targets.each do |target|
+        @target_templates << target.html_value
+      end
+
+      Function.template("report").result(binding)
+    end
+
+    # Class methods
+
+    def self.map dictionary
+      targets = dictionary["targets"]
+        .select { |target| !target["name"].include?(".xctest") }
+        .map { |target| Target.map(target)}
+
+      Report.new(targets)
+    end
+
+  end
+end

data/lib/xcov/model/source.rb

@@ -0,0 +1,64 @@
+require 'cgi'
+
+module Xcov
+  class Source < Xcov::Base
+
+    attr_accessor :name
+    attr_accessor :type
+    attr_accessor :coverage
+    attr_accessor :functions
+    attr_accessor :function_templates
+
+    def initialize (name, coverage, functions)
+      @name = CGI::escapeHTML(name)
+      @coverage = coverage
+      @functions = functions
+      @displayable_coverage = self.create_displayable_coverage
+      @coverage_color = self.create_coverage_color
+      @id = Digest::SHA1.hexdigest(name)
+      @type = Source.type(name)
+    end
+
+    def print_description
+      puts "\t\t#{@name} (#{@coverage})"
+      @functions.each do |function|
+        function.print_description
+      end
+    end
+
+    def html_value
+      @function_templates = ""
+      @functions.each do |function|
+        @function_templates << function.html_value
+      end
+
+      Function.template("file").result(binding)
+    end
+
+    # Class methods
+
+    def self.map (dictionary)
+      name = dictionary["name"]
+      coverage = dictionary["coverage"]
+      functions = dictionary["functions"].map { |function| Function.map(function)}
+
+      Source.new(name, coverage, functions)
+    end
+
+    def self.type (name)
+      types_map = {
+        ".swift" => "swift",
+        ".m" => "objc",
+        ".cpp" => "cpp",
+        ".mm" => "cpp"
+      }
+
+      extension = File.extname(name)
+      type = types_map[extension]
+      type = "objc" if type.nil?
+
+      type
+    end
+
+  end
+end

data/lib/xcov/model/target.rb

@@ -0,0 +1,48 @@
+require 'cgi'
+
+module Xcov
+  class Target < Xcov::Base
+
+    attr_accessor :name
+    attr_accessor :coverage
+    attr_accessor :files
+    attr_accessor :file_templates
+
+    def initialize (name, coverage, files)
+      @name = CGI::escapeHTML(name)
+      @coverage = coverage
+      @files = files
+      @displayable_coverage = self.create_displayable_coverage
+      @coverage_color = self.create_coverage_color
+      @id = Digest::SHA1.hexdigest(name)
+    end
+
+    def print_description
+      puts "\t#{@name} (#{@coverage})"
+      @files.each do |file|
+        file.print_description
+      end
+    end
+
+    def html_value
+      @file_templates = ""
+      @files.each do |file|
+        @file_templates << file.html_value
+      end
+
+      Function.template("target").result(binding)
+    end
+
+    # Class methods
+
+    def self.map (dictionary)
+      name = dictionary["name"]
+      coverage = dictionary["coverage"]
+      files = dictionary["files"].map { |file| Source.map(file)}
+      files = files.sort! { |lhs, rhs| lhs.coverage <=> rhs.coverage }
+
+      Target.new(name, coverage, files)
+    end
+
+  end
+end

data/lib/xcov/options.rb

@@ -0,0 +1,69 @@
+require "fastlane_core"
+require "credentials_manager"
+
+module Xcov
+  class Options
+
+    def self.available_options
+      containing = FastlaneCore::Helper.fastlane_enabled? ? './fastlane' : '.'
+
+      [
+        FastlaneCore::ConfigItem.new(key: :workspace,
+                                     short_option: "-w",
+                                     env_name: "XCOV_WORKSPACE",
+                                     optional: true,
+                                     description: "Path the workspace file",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       raise "Workspace file not found at path '#{v}'".red unless File.exist?(v)
+                                       raise "Workspace file invalid".red unless File.directory?(v)
+                                       raise "Workspace file is not a workspace, must end with .xcworkspace".red unless v.include?(".xcworkspace")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :project,
+                                     short_option: "-p",
+                                     optional: true,
+                                     env_name: "XCOV_PROJECT",
+                                     description: "Path the project file",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       raise "Project file not found at path '#{v}'".red unless File.exist?(v)
+                                       raise "Project file invalid".red unless File.directory?(v)
+                                       raise "Project file is not a project file, must end with .xcodeproj".red unless v.include?(".xcodeproj")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :scheme,
+                                     short_option: "-s",
+                                     optional: true,
+                                     env_name: "XCOV_SCHEME",
+                                     description: "The project's scheme. Make sure it's marked as `Shared`"),
+        FastlaneCore::ConfigItem.new(key: :derived_data_path,
+                                     short_option: "-j",
+                                     env_name: "XCOV_DERIVED_DATA_PATH",
+                                     description: "The directory where build products and other derived data will go",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :output_directory,
+                                     short_option: "-o",
+                                     env_name: "XCOV_OUTPUT_DIRECTORY",
+                                     description: "The directory in which all reports will be stored",
+                                     default_value: File.join(containing, "xcov_report")),
+        FastlaneCore::ConfigItem.new(key: :slack_url,
+                                     short_option: "-i",
+                                     env_name: "SLACK_URL",
+                                     description: "Create an Incoming WebHook for your Slack group to post results there",
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       raise "Invalid URL, must start with https://" unless value.start_with? "https://"
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :slack_channel,
+                                     short_option: "-e",
+                                     env_name: "XCOV_SLACK_CHANNEL",
+                                     description: "#channel or @username",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :skip_slack,
+                                     description: "Don't publish to slack, even when an URL is given",
+                                     is_string: false,
+                                     default_value: false)
+      ]
+    end
+
+  end
+end

data/lib/xcov/runner.rb

@@ -0,0 +1,79 @@
+require 'pty'
+require 'open3'
+require 'fileutils'
+require 'terminal-table'
+require 'xcov-core'
+require 'pathname'
+require 'json'
+
+module Xcov
+  class Runner
+
+    def run
+      report_json = parse_xccoverage
+      generate_xcov_report(report_json)
+    end
+
+    def parse_xccoverage
+      # Find .xccoverage file
+      product_builds_path = Pathname.new(Xcov.project.default_build_settings(key: "SYMROOT"))
+      test_logs_path = product_builds_path.parent.parent + "Logs/Test/"
+      xccoverage_files = Dir["#{test_logs_path}*.xccoverage"].sort_by { |filename| File.mtime(filename) }
+
+      unless test_logs_path.directory? && !xccoverage_files.empty?
+        ErrorHandler.handle_error("CoverageNotFound")
+      end
+
+      Xcov::Core::Parser.parse(xccoverage_files.first)
+    end
+
+    def generate_xcov_report report_json
+      # Create output path
+      output_path = Xcov.config[:output_directory]
+      FileUtils.mkdir_p(output_path)
+      resources_path = File.join(output_path, "resources")
+      FileUtils.mkdir_p(resources_path)
+
+      # Copy images to output resources folder
+      Dir[File.join(File.dirname(__FILE__), "../../assets/images/*")].each do |path|
+          FileUtils.cp_r(path, resources_path)
+      end
+
+      # Copy stylesheets to output resources folder
+      Dir[File.join(File.dirname(__FILE__), "../../assets/stylesheets/*")].each do |path|
+          FileUtils.cp_r(path, resources_path)
+      end
+
+      # Copy javascripts to output resources folder
+      Dir[File.join(File.dirname(__FILE__), "../../assets/javascripts/*")].each do |path|
+          FileUtils.cp_r(path, resources_path)
+      end
+
+      # Convert report to xCov model objects
+      report = Report.map(report_json)
+
+      # Create HTML report
+      File.open(File.join(output_path, "index.html"), "wb") do |file|
+          file.puts report.html_value
+      end
+
+      # Post result
+      SlackPoster.new.run(report)
+
+      # Print output
+      table_rows = []
+      report.targets.each do |target|
+        table_rows << [target.name, target.displayable_coverage]
+      end
+      puts Terminal::Table.new({
+        title: "xCov Coverage Report".green,
+        rows: table_rows
+      })
+      puts ""
+
+      # Raise exception in case of failure
+      raise "Unable to create coverage report" if report.nil?
+    end
+
+  end
+end