xcov 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e237c6cf2adb117d8ef52a834dda469ac74413d
-  data.tar.gz: 1f41de3cd2510bb12a3acb81675d99e31f2bb426
+  metadata.gz: e3471895be03f8b9d1f02805ac5a0e72775d67c9
+  data.tar.gz: fce99c62ab472f32c6db79659cbfc473aa5afa2d
 SHA512:
-  metadata.gz: a28236541164500f2a6db7110a2ee0ec347f7f7fdf66a46e57754f019dcf2226044740266e97c04fa573b7e3a3ed93c023e251eec7cf8cf9c80fd7c1e304ea53
-  data.tar.gz: 9bf9d031e572383bce6d7ffd53ae8a28819dd422bf8fde19d64b960892acb12d4932990b43546ee4076dde64eea888eb551397ac5a616e2bb27a89291095451f
+  metadata.gz: dca0119f6dfe20839137d471738a7a5d1ca275a49a89c05805db8daf6e8d2368f1747546d3c6f866395e07a9770421b2047f2ea44aa2b4a79459a536d131ead8
+  data.tar.gz: 944c9806c4f941d67c59463a3119ca50604673346fa68237437ad25a879015ea779a1b15c19e3dfb3aba14185146d0e3d7257c0e2a1b59510cce15d2a612d37f

data/README.md

@@ -13,9 +13,10 @@ sudo gem install xcov
 ```
 
 ## Features
-* Built on top of [Fastlane](https://fastlane.tools), you can easily plug it on to your CI environment.
+* Built on top of [fastlane](https://fastlane.tools), you can easily plug it on to your CI environment.
 * Blacklisting of those files which coverage you want to ignore.
 * Minimum acceptable coverage percentage.
+* Compatible with [Coveralls](https://coveralls.io).
 * Nice HTML reports.
 
 ![/assets_readme/report.png](/assets_readme/report.png)
@@ -34,7 +35,7 @@ In order to make *xcov* run you must:
 ![/assets_readme/gather_coverage.png](/assets_readme/gather_coverage.png)
 
 ## Usage
-*xcov* analyzes the `.xccoverage` files created after running your tests therefore, before executing xcov, you need to run your tests with either `Xcode`, `xcodebuild` or [scan](https://github.com/fastlane/scan). Once completed, obtain your coverage report by providing a few parameters:
+*xcov* analyzes the `.xccoverage` files created after running your tests therefore, before executing xcov, you need to run your tests with either `Xcode`, `xcodebuild` or [scan](https://github.com/fastlane/fastlane/tree/master/scan). Once completed, obtain your coverage report by providing a few parameters:
 ```
 xcov -w LystSDK.xcworkspace -s LystSDK -o xcov_output
 ```
@@ -47,7 +48,7 @@ xcov -w LystSDK.xcworkspace -s LystSDK -o xcov_output
 * `--output_directory` `-o`: Path for the output folder where the report files will be saved.
 * `--source_directory` `-r`: The path to project's root directory.
 * `--derived_data_path` `-j`: Path of your project `Derived Data` folder (optional).
-* `--minimum_coverage_percentage` `-m`: Raise exception if overall coverage percentage is under this value (ie. 75).
+* `--minimum_coverage_percentage` `-m`: Raise exception if overall coverage percentage is under this value (ie. 75.0).
 * `--include_test_targets`: Enables coverage reports for `.xctest` targets.
 * `--ignore_file_path` `-x`: Relative or absolute path to the file containing the list of ignored files.
 * `--exclude_targets`: Comma separated list of targets to exclude from coverage report.
@@ -59,6 +60,9 @@ xcov -w LystSDK.xcworkspace -s LystSDK -o xcov_output
 * `--markdown_report`: Enables the creation of a markdown report (optional).
 * `--skip_slack`: Add this flag to avoid publishing results on Slack (optional).
 * `--only_project_targets`: Display the coverage only for main project targets (e.g. skip Pods targets).
+* `--coveralls_service_name`: Name of the CI service compatible with Coveralls. i.e. travis-ci. This option must be defined along with coveralls_service_job_id.
+* `--coveralls_service_job_id`: Name of the current job running on a CI service compatible with Coveralls. This option must be defined along with coveralls_service_name.
+* `--coveralls_repo_token`: Repository token to be used by integrations not compatible with Coveralls.
 
 _**Note:** All paths you provide should be absolute and unescaped_
 

data/lib/xcov-core.rb

@@ -20,27 +20,26 @@ module Xcov
         JSON.parse(output_file)
       end
 
-      def self.execute_command (command, description)
-        FastlaneCore::CommandExecutor
-            .execute(
-                command: command,
-                print_all: true,
-                print_command: true,
-                prefix: description,
-                loading: "Loading...",
-                error: proc do |error_output|
-                  begin
-                    Xcov::ErrorHandler.handle_error(error_output)
-                  rescue => ex
-                    Xcov::SlackPoster.new.run({
-                      build_errors: 1
-                    })
-                    raise ex
-                  end
-                end
-            )
+      def self.execute_command(command, description)
+        FastlaneCore::CommandExecutor.execute(
+          command: command,
+          print_all: true,
+          print_command: true,
+          prefix: description,
+          loading: "Loading...",
+          error: proc do |error_output|
+            begin
+              Xcov::ErrorHandler.handle_error(error_output)
+            rescue => ex
+              Xcov::SlackPoster.new.run({
+                build_errors: 1
+              })
+              raise ex
+            end
+          end
+        )
       end
-      
+
     end
 
   end

data/lib/xcov.rb

@@ -2,9 +2,9 @@ require 'json'
 require 'xcov/version'
 require 'xcov/manager'
 require 'xcov/options'
-require 'xcov/runner'
 require 'xcov/ignore_handler'
 require 'xcov/error_handler'
+require 'xcov/coveralls_handler'
 require 'xcov/slack_poster'
 require 'xcov/model/base'
 require 'xcov/model/report'

data/lib/xcov/commands_generator.rb

@@ -38,7 +38,7 @@ module 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)
+          Xcov::Manager.new(config).run()
         end
       end
 

data/lib/xcov/coveralls_handler.rb

@@ -0,0 +1,98 @@
+require "tempfile"
+
+module Xcov
+  class CoverallsHandler
+
+    class << self
+
+      def submit(report)
+        coveralls_json_path = convert_and_store_coveralls_json(report)
+        perform_request(coveralls_json_path)
+      end
+
+      private
+
+      def convert_and_store_coveralls_json(report)
+        root_path = `git rev-parse --show-toplevel`
+        root_path.delete!("\n")
+        root_path << '/'
+
+        # Iterate through targets
+        source_files = []
+        report.targets.each do |target|
+          # Iterate through target files
+          target.files.each do |file|
+            next if file.ignored
+
+            # Iterate through file lines
+            lines = []
+            file.lines.each do |line|
+              lines << line.execution_count if line.executable
+              lines << nil unless line.executable
+            end
+
+            relative_path = file.location
+            relative_path.slice!(root_path)
+            source_files << {
+              name: relative_path,
+              source_digest: digest_for_file(relative_path),
+              coverage: lines
+            }
+          end
+        end
+
+        json = {
+          service_job_id: Xcov.config[:coveralls_service_job_id],
+          service_name: Xcov.config[:coveralls_service_name],
+          repo_token: Xcov.config[:coveralls_repo_token],
+          source_files: source_files
+        }
+
+        require "json"
+
+        # Persist
+        coveralls_json_file = Tempfile.new("coveralls_report.json")
+        File.open(coveralls_json_file.path, "wb") do |file|
+          file.puts JSON.pretty_generate(json)
+          file.close
+        end
+
+        # Return path
+        return coveralls_json_file.path
+      end
+
+      def perform_request(coveralls_json_path)
+        require 'net/http/post/multipart'
+
+        # Build request
+        url = URI.parse("https://coveralls.io/api/v1/jobs")
+        UI.message "Uploading coverage report to coveralls.io".yellow
+        request = Net::HTTP::Post::Multipart.new(
+          url.path,
+          "json_file" => UploadIO.new(File.new(coveralls_json_path), "text/plain", "coveralls_report.json")
+        )
+
+        # Perform request
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        response = http.request(request)
+
+        if response.code == "200"
+          UI.message "Submitted report to coveralls.io successfully".green
+        else
+          UI.message "There was an error submitting the report to coveralls.io".red
+          UI.message response.body.red
+        end
+      end
+
+      def digest_for_file(file_path)
+        hash = `git hash-object #{file_path}`
+        hash.delete!("\n")
+        return hash
+      end
+
+    end
+
+  end
+end

data/lib/xcov/error_handler.rb

@@ -3,36 +3,26 @@ 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/
+        when /XccoverageFileNotFound/
           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
+        when /UnableToParseXccoverageFile/
+          print "There was an error converting the .xccoverage file to json."
+        when /CoverageUnderThreshold/
+          print "The build has been marked as failed because minimum overall coverage has not been reached."
+        when /UnableToMapJsonToXcovModel/
+          print "There was an error converting the json file to xcov's model objects."
         end
-        raise "Error processing coverage file - see the log above".red
+        raise "Error creating your coverage report - see the log above".red
+      end
+
+      def handle_error_with_custom_message(error, custom_message)
+        print custom_message
+        handle_error error
       end
 
       private
@@ -40,6 +30,7 @@ module Xcov
       def print(text)
         UI.message text.red
       end
+
     end
 
   end

data/lib/xcov/ignore_handler.rb

@@ -25,7 +25,7 @@ module Xcov
       # Ignore specific files
       filename = File.basename(path)
       return true if should_ignore_file(filename)
-      
+
       # Also ignore the files from ignored folders
       relative = relative_path(path).downcase
       return @list.any? { |ignored_path| relative.start_with? ignored_path }

data/lib/xcov/manager.rb

@@ -1,9 +1,16 @@
-require "fastlane_core"
+require 'fastlane_core'
+require 'pty'
+require 'open3'
+require 'fileutils'
+require 'terminal-table'
+require 'xcov-core'
+require 'pathname'
+require 'json'
 
 module Xcov
   class Manager
 
-    def work(options)
+    def initialize(options)
       # Set command options
       Xcov.config = options
 
@@ -16,9 +23,125 @@ module Xcov
 
       # Print summary
       FastlaneCore::PrintTable.print_values(config: options, hide_keys: [:slack_url], title: "Summary for xcov #{Xcov::VERSION}")
+    end
 
+    def run
       # Run xcov
-      Runner.new.run
+      json_report = parse_xccoverage
+      report = generate_xcov_report(json_report)
+      validate_report(report)
+      submit_to_coveralls(report)
+    end
+
+    private
+
+    def parse_xccoverage
+      # Find .xccoverage file
+      test_logs_path = derived_data_path + "Logs/Test/"
+      xccoverage_files = Dir["#{test_logs_path}*.xccoverage"].sort_by { |filename| File.mtime(filename) }.reverse
+
+      unless test_logs_path.directory? && !xccoverage_files.empty?
+        ErrorHandler.handle_error("XccoverageFileNotFound")
+      end
+
+      # Convert .xccoverage file to json
+      json_report = Xcov::Core::Parser.parse(xccoverage_files.first)
+      ErrorHandler.handle_error("UnableToParseXccoverageFile") if json_report.nil?
+
+      json_report
+    end
+
+    def generate_xcov_report(json_report)
+      # Create output path
+      output_path = Xcov.config[:output_directory]
+      FileUtils.mkdir_p(output_path)
+
+      # Convert report to xcov model objects
+      report = Report.map(json_report)
+
+      # Raise exception in case of failure
+      ErrorHandler.handle_error("UnableToMapJsonToXcovModel") if report.nil?
+
+      if Xcov.config[:html_report] then
+        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
+
+        # Create HTML report
+        File.open(File.join(output_path, "index.html"), "wb") do |file|
+          file.puts report.html_value
+        end
+      end
+
+      # Create Markdown report
+      if Xcov.config[:markdown_report] then
+        File.open(File.join(output_path, "report.md"), "wb") do |file|
+          file.puts report.markdown_value
+        end
+      end
+
+      # Create JSON report
+      if Xcov.config[:json_report] then
+        File.open(File.join(output_path, "report.json"), "wb") do |file|
+          file.puts report.json_value.to_json
+        end
+      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 ""
+
+      report
+    end
+
+    def validate_report(report)
+      # Raise exception if overall coverage is under threshold
+      minimumPercentage = Xcov.config[:minimum_coverage_percentage] / 100
+      if minimumPercentage > report.coverage
+        error_message = "Actual Code Coverage (#{"%.2f%" % (report.coverage*100)}) below threshold of #{"%.2f%" % (minimumPercentage*100)}"
+        ErrorHandler.handle_error_with_custom_message("CoverageUnderThreshold", error_message)
+      end
+    end
+
+    def submit_to_coveralls(report)
+      if !Xcov.config[:coveralls_repo_token].nil? || !(Xcov.config[:coveralls_service_name].nil? && Xcov.config[:coveralls_service_job_id].nil?)
+        CoverallsHandler.submit(report)
+      end
+    end
+
+    # Auxiliar methods
+
+    def derived_data_path
+      # If DerivedData path was supplied, return
+      return Pathname.new(Xcov.config[:derived_data_path]) unless Xcov.config[:derived_data_path].nil?
+
+      # Otherwise check project file
+      product_builds_path = Pathname.new(Xcov.project.default_build_settings(key: "SYMROOT"))
+      return product_builds_path.parent.parent
     end
 
   end

data/lib/xcov/model/base.rb

@@ -70,4 +70,3 @@ module Xcov
 
   end
 end
-

data/lib/xcov/model/function.rb

@@ -3,7 +3,7 @@ require 'cgi'
 module Xcov
   class Function < Xcov::Base
 
-    def initialize (name, coverage)
+    def initialize(name, coverage)
       @name = CGI::escapeHTML(name)
       @coverage = coverage
       @displayable_coverage = self.create_displayable_coverage
@@ -27,7 +27,7 @@ module Xcov
 
     # Class methods
 
-    def self.map (dictionary)
+    def self.map(dictionary)
       Function.new(dictionary["name"], dictionary["coverage"])
     end
 

data/lib/xcov/model/line.rb

@@ -5,7 +5,7 @@ module Xcov
     attr_reader :executable
     attr_reader :ranges
 
-    def initialize (execution_count, executable, ranges = nil)
+    def initialize(execution_count, executable, ranges = nil)
       @execution_count = execution_count
       @executable = executable
       @ranges = ranges
@@ -17,12 +17,12 @@ module Xcov
 
     # Class methods
 
-    def self.map (dictionary)
+    def self.map(dictionary)
       ranges = map_ranges(dictionary["ranges"])
       Line.new(dictionary["executionCount"], dictionary["executable"], ranges)
     end
 
-    def self.map_ranges (dictionaries)
+    def self.map_ranges(dictionaries)
       return nil if dictionaries.nil?
       dictionaries.map { |dictionary| Range.map(dictionary) }
     end

data/lib/xcov/model/range.rb

@@ -5,7 +5,7 @@ module Xcov
     attr_reader :location
     attr_reader :length
 
-    def initialize (execution_count, location, length)
+    def initialize(execution_count, location, length)
       @execution_count = execution_count
       @location = location
       @length = length
@@ -13,7 +13,7 @@ module Xcov
 
     # Class methods
 
-    def self.map (dictionary)
+    def self.map(dictionary)
       Range.new(
         dictionary["executionCount"],
         dictionary["location"],

data/lib/xcov/model/report.rb

@@ -7,7 +7,7 @@ module Xcov
     attr_accessor :summary
     attr_accessor :target_templates
 
-    def initialize (targets)
+    def initialize(targets)
       @targets = targets
       @coverage = average_coverage(targets)
       @displayable_coverage = self.create_displayable_coverage
@@ -61,7 +61,7 @@ module Xcov
 
     # Class methods
 
-    def self.map dictionary
+    def self.map(dictionary)
       targets = Report.filter_targets dictionary["targets"]
 
       # Create target objects
@@ -70,7 +70,7 @@ module Xcov
       Report.new(targets)
     end
 
-    def self.filter_targets targets
+    def self.filter_targets(targets)
       filtered_targets = Array.new(targets)
       filtered_targets = filtered_targets.select { |target| !target["name"].include?(".xctest") } if !Xcov.config[:include_test_targets]
 

data/lib/xcov/model/source.rb

@@ -12,7 +12,7 @@ module Xcov
     attr_accessor :function_templates
     attr_accessor :lines
 
-    def initialize (name, location, coverage, functions, lines = nil)
+    def initialize(name, location, coverage, functions, lines = nil)
       @name = CGI::escapeHTML(name)
       @location = CGI::escapeHTML(location)
       @coverage = coverage
@@ -74,7 +74,7 @@ module Xcov
 
     # Class methods
 
-    def self.map (dictionary)
+    def self.map(dictionary)
       name = dictionary["name"]
       location = dictionary["location"]
       coverage = dictionary["coverage"]
@@ -83,12 +83,12 @@ module Xcov
       Source.new(name, location, coverage, functions, lines)
     end
 
-    def self.map_lines (dictionaries)
+    def self.map_lines(dictionaries)
       return nil if dictionaries.nil?
       dictionaries.map { |line| Line.map(line) }
     end
 
-    def self.type (name)
+    def self.type(name)
       types_map = {
         ".swift" => "swift",
         ".m" => "objc",

data/lib/xcov/model/target.rb

@@ -9,7 +9,7 @@ module Xcov
     attr_accessor :files
     attr_accessor :file_templates
 
-    def initialize (name, executable, covered, files)
+    def initialize(name, executable, covered, files)
       @name = CGI::escapeHTML(name)
       @executable_lines = executable
       @covered_lines = covered
@@ -56,7 +56,7 @@ module Xcov
 
     # Class methods
 
-    def self.map (dictionary)
+    def self.map(dictionary)
       name = dictionary["name"]
       files = dictionary["files"].map { |file| Source.map(file)}
       files = files.sort &by_coverage_with_ignored_at_the_end
@@ -86,7 +86,7 @@ module Xcov
       files.select { |file| !file.ignored }
     end
 
-    def self.calculate_number_of_covered_lines (files)
+    def self.calculate_number_of_covered_lines(files)
       return 0 if files.nil? || files.empty?
 
       files.reduce(0) do |partial_result, file|
@@ -94,7 +94,7 @@ module Xcov
       end
     end
 
-    def self.calculate_number_of_executable_lines (files)
+    def self.calculate_number_of_executable_lines(files)
       return 0 if files.nil? || files.empty?
 
       files.reduce(0) do |partial_result, file|

data/lib/xcov/options.rb

@@ -7,131 +7,198 @@ module Xcov
     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: :configuration,
-                                     short_option: "-q",
-                                     env_name: "XCOV_CONFIGURATION",
-                                     description: "The configuration used when building the app. Defaults to 'Release'",
-                                     optional: true),
-        FastlaneCore::ConfigItem.new(key: :source_directory,
-                                     short_option: "-r",
-                                     optional: true,
-                                     env_name: "XCOV_SOURCE_DIRECTORY",
-                                     description: "The path to project's root directory",
-                                     verify_block: proc do |value|
-                                       v = File.expand_path(value.to_s)
-                                       raise "Specified source directory does not exist".red unless File.exist?(v)
-                                       raise "Invalid source directory path, it must point to a directory".red unless File.directory?(v)
-                                     end
-                                     ),
-        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,
-                                     verify_block: proc do |value|
-                                       v = File.expand_path(value.to_s)
-                                       raise "Specified derived data directory does not exist".red unless File.exist?(v)
-                                       raise "Invalid derived data path, it must point to a directory".red unless File.directory?(v)
-                                     end),
-        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: :html_report,
-                                     env_name: "XCOV_HTML_REPORT",
-                                     description: "Produce an HTML report",
-                                     optional: true,
-                                     is_string: false,
-                                     default_value: true),
-        FastlaneCore::ConfigItem.new(key: :markdown_report,
-                                     env_name: "XCOV_MARKDOWN_REPORT",
-                                     description: "Produce a Markdown report",
-                                     optional: true,
-                                     is_string: false,
-                                     default_value: false),
-        FastlaneCore::ConfigItem.new(key: :json_report,
-                                     env_name: "XCOV_JSON_REPORT",
-                                     description: "Produce a JSON report",
-                                     optional: true,
-                                     is_string: false,
-                                     default_value: false),
-        FastlaneCore::ConfigItem.new(key: :minimum_coverage_percentage,
-                                     short_option: "-m",
-                                     env_name: "XCOV_MINIMUM_COVERAGE_PERCENTAGE",
-                                     description: "Raise exception if overall coverage percentage is under this value (ie. 75)",
-                                     type: Float,
-                                     default_value: 0),
-       FastlaneCore::ConfigItem.new(key: :ignore_file_path,
-                                    short_option: "-x",
-                                    env_name: "XCOV_IGNORE_FILE_PATH",
-                                    description: "Relative or absolute path to the file containing the list of ignored files",
-                                    default_value: File.join(containing, ".xcovignore")),
-       FastlaneCore::ConfigItem.new(key: :include_test_targets,
-                                    env_name: "XCOV_INCLUDE_TEST_TARGETS",
-                                    description: "Enables coverage reports for .xctest targets",
-                                    is_string: false,
-                                    default_value: false),
-        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),
-        FastlaneCore::ConfigItem.new(key: :exclude_targets,
-                                     optional: true,
-                                     conflicting_options: [:include_targets, :only_project_targets],
-                                     description: "Comma separated list of targets to exclude from coverage report"),
-        FastlaneCore::ConfigItem.new(key: :include_targets,
-                                     optional: true,
-                                     conflicting_options: [:exclude_targets, :only_project_targets],
-                                     description: "Comma separated list of targets to include in coverage report. If specified then exlude_targets will be ignored"),
-        FastlaneCore::ConfigItem.new(key: :only_project_targets,
-                                     optional: true,
-                                     conflicting_options: [:exclude_targets, :include_targets],
-                                     description: "Display the coverage only for main project targets (e.g. skip Pods targets)",
-                                     is_string: false,
-                                     default_value: false)
+      return [
 
+        # Project options
+        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: :configuration,
+          short_option: "-q",
+          env_name: "XCOV_CONFIGURATION",
+          description: "The configuration used when building the app. Defaults to 'Release'",
+          optional: true
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :source_directory,
+          short_option: "-r",
+          optional: true,
+          env_name: "XCOV_SOURCE_DIRECTORY",
+          description: "The path to project's root directory",
+          verify_block: proc do |value|
+            v = File.expand_path(value.to_s)
+            raise "Specified source directory does not exist".red unless File.exist?(v)
+            raise "Invalid source directory path, it must point to a directory".red unless File.directory?(v)
+          end
+        ),
+        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,
+          verify_block: proc do |value|
+            v = File.expand_path(value.to_s)
+            raise "Specified derived data directory does not exist".red unless File.exist?(v)
+            raise "Invalid derived data path, it must point to a directory".red unless File.directory?(v)
+          end
+        ),
+        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")
+        ),
+
+        # Report options
+        FastlaneCore::ConfigItem.new(
+          key: :html_report,
+          env_name: "XCOV_HTML_REPORT",
+          description: "Produce an HTML report",
+          optional: true,
+          is_string: false,
+          default_value: true
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :markdown_report,
+          env_name: "XCOV_MARKDOWN_REPORT",
+          description: "Produce a Markdown report",
+          optional: true,
+          is_string: false,
+          default_value: false
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :json_report,
+          env_name: "XCOV_JSON_REPORT",
+          description: "Produce a JSON report",
+          optional: true,
+          is_string: false,
+          default_value: false
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :minimum_coverage_percentage,
+          short_option: "-m",
+          env_name: "XCOV_MINIMUM_COVERAGE_PERCENTAGE",
+          description: "Raise exception if overall coverage percentage is under this value (ie. 75)",
+          type: Float,
+          default_value: 0
+        ),
+
+        # Slack options
+        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
+        ),
+
+        # Exclusion options
+        FastlaneCore::ConfigItem.new(
+          key: :ignore_file_path,
+          short_option: "-x",
+          env_name: "XCOV_IGNORE_FILE_PATH",
+          description: "Relative or absolute path to the file containing the list of ignored files",
+          default_value: File.join(containing, ".xcovignore")
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :include_test_targets,
+          env_name: "XCOV_INCLUDE_TEST_TARGETS",
+          description: "Enables coverage reports for .xctest targets",
+          is_string: false,
+          default_value: false
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :exclude_targets,
+          optional: true,
+          conflicting_options: [:include_targets, :only_project_targets],
+          description: "Comma separated list of targets to exclude from coverage report"
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :include_targets,
+          optional: true,
+          conflicting_options: [:exclude_targets, :only_project_targets],
+          description: "Comma separated list of targets to include in coverage report. If specified then exlude_targets will be ignored"
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :only_project_targets,
+          optional: true,
+          conflicting_options: [:exclude_targets, :include_targets],
+          description: "Display the coverage only for main project targets (e.g. skip Pods targets)",
+          is_string: false,
+          default_value: false
+        ),
+
+        # Coveralls options
+        FastlaneCore::ConfigItem.new(
+          key: :coveralls_service_name,
+          env_name: "COVERALLS_SERVICE_NAME",
+          optional: true,
+          conflicting_options: [:coveralls_repo_token],
+          description: "Name of the CI service compatible with Coveralls. i.e. travis-ci. This option must be defined along with coveralls_service_job_id"
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :coveralls_service_job_id,
+          env_name: "COVERALLS_SERVICE_JOB_ID",
+          optional: true,
+          conflicting_options: [:coveralls_repo_token],
+          description: "Name of the current job running on a CI service compatible with Coveralls. This option must be defined along with coveralls_service_name"
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :coveralls_repo_token,
+          env_name: "COVERALLS_REPO_TOKEN",
+          optional: true,
+          conflicting_options: [:coveralls_service_name, :coveralls_service_job_id],
+          description: "Repository token to be used by integrations not compatible with Coveralls"
+        )
       ]
     end
 

data/lib/xcov/project_extensions.rb

@@ -10,14 +10,14 @@ module FastlaneCore
       return [] if project_path.nil?
 
       proj = Xcodeproj::Project.open(project_path)
-      
+
       proj.targets.map do |target|
        target.name
      end
     end
 
     private
-    
+
     def get_project_path
       # Given the workspace and scheme, we can compute project path
       if workspace?

data/lib/xcov/slack_poster.rb

@@ -25,9 +25,11 @@ module Xcov
         }
       end
 
-      result = notifier.ping "Your *xcov* coverage report",
-                             icon_url: 'https://s3-eu-west-1.amazonaws.com/fastlane.tools/fastlane.png',
-                             attachments: attachments
+      result = notifier.ping(
+        "Your *xcov* coverage report",
+        icon_url: 'https://s3-eu-west-1.amazonaws.com/fastlane.tools/fastlane.png',
+        attachments: attachments
+      )
 
       if result.code.to_i == 200
         UI.message 'Successfully sent Slack notification'.green

data/lib/xcov/version.rb

@@ -1,6 +1,6 @@
 module Xcov
 
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
   DESCRIPTION = "xcov is a friendly visualizer for Xcode's code coverage files"
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcov
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Carlos Vidal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-12 00:00:00.000000000 Z
+date: 2017-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fastlane
@@ -72,6 +72,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: multipart-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -212,6 +226,7 @@ files:
 - lib/xcov-core/version.rb
 - lib/xcov.rb
 - lib/xcov/commands_generator.rb
+- lib/xcov/coveralls_handler.rb
 - lib/xcov/error_handler.rb
 - lib/xcov/ignore_handler.rb
 - lib/xcov/manager.rb
@@ -224,7 +239,6 @@ files:
 - lib/xcov/model/target.rb
 - lib/xcov/options.rb
 - lib/xcov/project_extensions.rb
-- lib/xcov/runner.rb
 - lib/xcov/slack_poster.rb
 - lib/xcov/version.rb
 - views/file.erb

data/lib/xcov/runner.rb

@@ -1,123 +0,0 @@
-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
-      report = generate_xcov_report(report_json)
-      validate_report(report)
-    end
-
-    def parse_xccoverage
-      # Find .xccoverage file
-      test_logs_path = derived_data_path + "Logs/Test/"
-      xccoverage_files = Dir["#{test_logs_path}*.xccoverage"].sort_by { |filename| File.mtime(filename) }.reverse
-
-      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)
-
-      # Convert report to xCov model objects
-      report = Report.map(report_json)
-
-      if Xcov.config[:html_report] then
-        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
-
-        # Create HTML report
-        File.open(File.join(output_path, "index.html"), "wb") do |file|
-          file.puts report.html_value
-        end
-      end
-
-      # Create Markdown report
-      if Xcov.config[:markdown_report] then
-        File.open(File.join(output_path, "report.md"), "wb") do |file|
-          file.puts report.markdown_value
-        end
-      end
-
-      # Create JSON report
-      if Xcov.config[:json_report] then
-        File.open(File.join(output_path, "report.json"), "wb") do |file|
-          file.puts report.json_value.to_json
-        end
-      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?
-
-      report
-    end
-
-    def validate_report report
-      exit_status = 0
-
-      # Raise exception if overall coverage
-      minimumPercentage = Xcov.config[:minimum_coverage_percentage] / 100
-      if minimumPercentage > report.coverage
-        exit_status = 1
-
-        UI.user_error!("Actual Code Coverage (#{"%.2f%" % (report.coverage*100)}) below threshold of #{"%.2f%" % (minimumPercentage*100)}")
-      end
-
-      exit_status
-    end
-
-    # Auxiliar methods
-
-    def derived_data_path
-      # If DerivedData path was supplied, return
-      return Pathname.new(Xcov.config[:derived_data_path]) unless Xcov.config[:derived_data_path].nil?
-
-      # Otherwise check project file
-      product_builds_path = Pathname.new(Xcov.project.default_build_settings(key: "SYMROOT"))
-      return product_builds_path.parent.parent
-    end
-
-  end
-end