coveralls-ruby 0.1.0

data/lib/coveralls/command.rb

@@ -0,0 +1,69 @@
+require "thor"
+
+module Coveralls
+  class CommandLine < Thor
+
+    desc "push", "Runs your test suite and pushes the coverage results to Coveralls."
+    def push
+      return unless ensure_can_run_locally!
+      ENV["COVERALLS_RUN_LOCALLY"] = "true"
+      cmds = "bundle exec rake"
+      if File.exist?('.travis.yml')
+        cmds = YAML.load_file('.travis.yml')["script"] || cmds rescue cmds
+      end
+      cmds.each { |cmd| system cmd }
+      ENV["COVERALLS_RUN_LOCALLY"] = nil
+    end
+
+    desc "report", "Runs your test suite locally and displays coverage statistics."
+    def report
+      ENV["COVERALLS_NOISY"] = "true"
+      exec "bundle exec rake"
+      ENV["COVERALLS_NOISY"] = nil
+    end
+
+    desc "open", "View this repository on Coveralls."
+    def open
+      open_token_based_url "https://coveralls.io/repos/%@"
+    end
+
+    desc "service", "View this repository on your CI service's website."
+    def service
+      open_token_based_url "https://coveralls.io/repos/%@/service"
+    end
+
+    desc "last", "View the last build for this repository on Coveralls."
+    def last
+      open_token_based_url "https://coveralls.io/repos/%@/last_build"
+    end
+
+    desc "version", "See version"
+    def version
+      Coveralls::Output.puts Coveralls::VERSION
+    end
+
+    private
+
+    def open_token_based_url url
+      config = Coveralls::Configuration.configuration
+      if config[:repo_token]
+        url = url.gsub("%@", config[:repo_token])
+        `open #{url}`
+      else
+        Coveralls::Output.puts "No repo_token configured."
+      end
+    end
+
+    def ensure_can_run_locally!
+      config = Coveralls::Configuration.configuration
+      if config[:repo_token].nil?
+        Coveralls::Output.puts "Coveralls cannot run locally because no repo_secret_token is set in .coveralls.yml", :color => "red"
+        Coveralls::Output.puts "Please try again when you get your act together.", :color => "red"
+
+        return false
+      end
+      true
+    end
+
+  end
+end

data/lib/coveralls/configuration.rb

@@ -0,0 +1,234 @@
+require 'yaml'
+require 'securerandom'
+
+module Coveralls
+  module Configuration
+
+    def self.configuration
+      config = {
+        :environment => self.relevant_env,
+        :git => git
+      }
+      yml = self.yaml_config
+      if yml
+        config[:configuration] = yml
+        config[:repo_token] = yml['repo_token'] || yml['repo_secret_token']
+      end
+      if ENV['COVERALLS_REPO_TOKEN']
+        config[:repo_token] = ENV['COVERALLS_REPO_TOKEN']
+      end
+      if ENV['COVERALLS_PARALLEL'] && ENV['COVERALLS_PARALLEL'] != "false"
+        config[:parallel] = true
+      end
+      if ENV['COVERALLS_FLAG_NAME']
+        config[:flag_name] = ENV['COVERALLS_FLAG_NAME']
+      end
+      if ENV['TRAVIS']
+        set_service_params_for_travis(config, yml ? yml['service_name'] : nil)
+      elsif ENV['CIRCLECI']
+        set_service_params_for_circleci(config)
+      elsif ENV['SEMAPHORE']
+        set_service_params_for_semaphore(config)
+      elsif ENV['JENKINS_URL'] || ENV['JENKINS_HOME']
+        set_service_params_for_jenkins(config)
+      elsif ENV['APPVEYOR']
+        set_service_params_for_appveyor(config)
+      elsif ENV['TDDIUM']
+        set_service_params_for_tddium(config)
+      elsif ENV['GITLAB_CI']
+        set_service_params_for_gitlab(config)
+      elsif ENV['COVERALLS_RUN_LOCALLY'] || Coveralls.testing
+        set_service_params_for_coveralls_local(config)
+      end
+
+      # standardized env vars
+      set_standard_service_params_for_generic_ci(config)
+
+      if service_name = ENV['COVERALLS_SERVICE_NAME']
+        config[:service_name] = service_name
+      end
+
+      config
+    end
+
+    def self.set_service_params_for_travis(config, service_name)
+      config[:service_job_id] = ENV['TRAVIS_JOB_ID']
+      config[:service_pull_request] = ENV['TRAVIS_PULL_REQUEST'] unless ENV['TRAVIS_PULL_REQUEST'] == 'false'
+      config[:service_name]   = service_name || 'travis-ci'
+      config[:service_branch] = ENV['TRAVIS_BRANCH']
+    end
+
+    def self.set_service_params_for_circleci(config)
+      config[:service_name]         = 'circleci'
+      config[:service_number]       = ENV['CIRCLE_BUILD_NUM']
+      config[:service_pull_request] = (ENV['CI_PULL_REQUEST'] || "")[/(\d+)$/,1]
+      config[:parallel]             = ENV['CIRCLE_NODE_TOTAL'].to_i > 1
+      config[:service_job_number]   = ENV['CIRCLE_NODE_INDEX']
+    end
+
+    def self.set_service_params_for_semaphore(config)
+      config[:service_name]         = 'semaphore'
+      config[:service_number]       = ENV['SEMAPHORE_BUILD_NUMBER']
+      config[:service_pull_request] = ENV['PULL_REQUEST_NUMBER']
+    end
+
+    def self.set_service_params_for_jenkins(config)
+      config[:service_name]   = 'jenkins'
+      config[:service_number] = ENV['BUILD_NUMBER']
+      config[:service_branch] = ENV['BRANCH_NAME']
+      config[:service_pull_request] = ENV['ghprbPullId']
+    end
+
+    def self.set_service_params_for_appveyor(config)
+      config[:service_name]   = 'appveyor'
+      config[:service_number] = ENV['APPVEYOR_BUILD_VERSION']
+      config[:service_branch] = ENV['APPVEYOR_REPO_BRANCH']
+      config[:commit_sha] = ENV['APPVEYOR_REPO_COMMIT']
+      repo_name = ENV['APPVEYOR_REPO_NAME']
+      config[:service_build_url]  = 'https://ci.appveyor.com/project/%s/build/%s' % [repo_name, config[:service_number]]
+    end
+
+    def self.set_service_params_for_tddium(config)
+      config[:service_name]         = 'tddium'
+      config[:service_number]       = ENV['TDDIUM_SESSION_ID']
+      config[:service_job_number]   = ENV['TDDIUM_TID']
+      config[:service_pull_request] = ENV['TDDIUM_PR_ID']
+      config[:service_branch]       = ENV['TDDIUM_CURRENT_BRANCH']
+      config[:service_build_url]    = "https://ci.solanolabs.com/reports/#{ENV['TDDIUM_SESSION_ID']}"
+    end
+
+    def self.set_service_params_for_gitlab(config)
+      config[:service_name]       = 'gitlab-ci'
+      config[:service_number]     = ENV['CI_PIPELINE_ID']
+      config[:service_job_number] = ENV['CI_BUILD_NAME']
+      config[:service_job_id]     = ENV['CI_BUILD_ID']
+      config[:service_branch]     = ENV['CI_BUILD_REF_NAME']
+      config[:commit_sha]         = ENV['CI_BUILD_REF']
+    end
+
+    def self.set_service_params_for_coveralls_local(config)
+      config[:service_job_id]     = nil
+      config[:service_name]       = 'coveralls-ruby'
+      config[:service_event_type] = 'manual'
+    end
+
+    def self.set_standard_service_params_for_generic_ci(config)
+      config[:service_name]         ||= ENV['CI_NAME']
+      config[:service_number]       ||= ENV['CI_BUILD_NUMBER']
+      config[:service_job_id]       ||= ENV['CI_JOB_ID']
+      config[:service_build_url]    ||= ENV['CI_BUILD_URL']
+      config[:service_branch]       ||= ENV['CI_BRANCH']
+      config[:service_pull_request] ||= (ENV['CI_PULL_REQUEST'] || "")[/(\d+)$/,1]
+    end
+
+    def self.yaml_config
+      if self.configuration_path && File.exist?(self.configuration_path)
+        YAML::load_file(self.configuration_path)
+      end
+    end
+
+    def self.configuration_path
+      File.expand_path(File.join(self.root, ".coveralls.yml")) if self.root
+    end
+
+    def self.root
+      pwd
+    end
+
+    def self.pwd
+      Dir.pwd
+    end
+
+    def self.simplecov_root
+      if defined?(::SimpleCov)
+        ::SimpleCov.root
+      end
+    end
+
+    def self.rails_root
+      Rails.root.to_s
+    rescue
+      nil
+    end
+
+    def self.git
+      hash = {}
+
+      Dir.chdir(root) do
+
+        hash[:head] = {
+          :id => ENV.fetch("GIT_ID", `git log -1 --pretty=format:'%H'`),
+          :author_name => ENV.fetch("GIT_AUTHOR_NAME", `git log -1 --pretty=format:'%aN'`),
+          :author_email => ENV.fetch("GIT_AUTHOR_EMAIL", `git log -1 --pretty=format:'%ae'`),
+          :committer_name => ENV.fetch("GIT_COMMITTER_NAME", `git log -1 --pretty=format:'%cN'`),
+          :committer_email => ENV.fetch("GIT_COMMITTER_EMAIL", `git log -1 --pretty=format:'%ce'`),
+          :message => ENV.fetch("GIT_MESSAGE", `git log -1 --pretty=format:'%s'`)
+        }
+
+        # Branch
+        hash[:branch] = ENV.fetch("GIT_BRANCH", `git rev-parse --abbrev-ref HEAD`)
+
+        # Remotes
+        remotes = nil
+        begin
+          remotes = `git remote -v`.split(/\n/).map do |remote|
+            splits = remote.split(" ").compact
+            {:name => splits[0], :url => splits[1]}
+          end.uniq
+        rescue
+        end
+        hash[:remotes] = remotes
+
+      end
+
+      hash
+
+    rescue Exception => e
+      Coveralls::Output.puts "Coveralls git error:", :color => "red"
+      Coveralls::Output.puts e.to_s, :color => "red"
+      nil
+    end
+
+    def self.relevant_env
+      hash = {
+        :pwd => self.pwd,
+        :rails_root => self.rails_root,
+        :simplecov_root => simplecov_root,
+        :gem_version => VERSION
+      }
+
+      hash.merge! begin
+        if ENV['TRAVIS']
+          {
+            :travis_job_id => ENV['TRAVIS_JOB_ID'],
+            :travis_pull_request => ENV['TRAVIS_PULL_REQUEST'],
+            :branch => ENV['TRAVIS_BRANCH']
+          }
+        elsif ENV['CIRCLECI']
+          {
+            :circleci_build_num => ENV['CIRCLE_BUILD_NUM'],
+            :branch => ENV['CIRCLE_BRANCH'],
+            :commit_sha => ENV['CIRCLE_SHA1']
+          }
+        elsif ENV['JENKINS_URL']
+          {
+            :jenkins_build_num => ENV['BUILD_NUMBER'],
+            :jenkins_build_url => ENV['BUILD_URL'],
+            :branch => ENV['GIT_BRANCH'],
+            :commit_sha => ENV['GIT_COMMIT']
+          }
+        elsif ENV['SEMAPHORE']
+          {
+            :branch => ENV['BRANCH_NAME'],
+            :commit_sha => ENV['REVISION']
+          }
+        else
+          {}
+        end
+      end
+
+      hash
+    end
+
+  end
+end

data/lib/coveralls/output.rb

@@ -0,0 +1,114 @@
+module Coveralls
+  #
+  # Public: Methods for formatting strings with Term::ANSIColor.
+  # Does not utilize monkey-patching and should play nicely when
+  # included with other libraries.
+  #
+  # All methods are module methods and should be called on
+  # the Coveralls::Output module.
+  #
+  # Examples
+  #
+  #   Coveralls::Output.format("Hello World", :color => "cyan")
+  #   # => "\e[36mHello World\e[0m"
+  #
+  #   Coveralls::Output.print("Hello World")
+  #   # Hello World => nil
+  #
+  #   Coveralls::Output.puts("Hello World", :color => "underline")
+  #   # Hello World
+  #   # => nil
+  #
+  # To silence output completely:
+  #
+  #   Coveralls::Output.silent = true
+  #
+  # or set this environment variable:
+  #
+  #   COVERALLS_SILENT
+  #
+  # To disable color completely:
+  #
+  #   Coveralls::Output.no_color = true
+
+  module Output
+    attr_accessor :silent, :no_color
+    attr_writer :output
+    extend self
+
+    def output
+      (defined?(@output) && @output) || $stdout
+    end
+
+    def no_color?
+      (defined?(@no_color)) && @no_color
+    end
+
+    # Public: Formats the given string with the specified color
+    # through Term::ANSIColor
+    #
+    # string  - the text to be formatted
+    # options - The hash of options used for formatting the text:
+    #           :color - The color to be passed as a method to
+    #                    Term::ANSIColor
+    #
+    # Examples
+    #
+    #   Coveralls::Output.format("Hello World!", :color => "cyan")
+    #   # => "\e[36mHello World\e[0m"
+    #
+    # Returns the formatted string.
+    def format(string, options = {})
+      unless no_color?
+        require 'term/ansicolor'
+        if options[:color]
+          options[:color].split(/\s/).reverse_each do |color|
+            if Term::ANSIColor.respond_to?(color.to_sym)
+              string = Term::ANSIColor.send(color.to_sym, string)
+            end
+          end
+        end
+      end
+      string
+    end
+
+    # Public: Passes .format to Kernel#puts
+    #
+    # string  - the text to be formatted
+    # options - The hash of options used for formatting the text:
+    #           :color - The color to be passed as a method to
+    #                    Term::ANSIColor
+    #
+    #
+    # Example
+    #
+    #   Coveralls::Output.puts("Hello World", :color => "cyan")
+    #
+    # Returns nil.
+    def puts(string, options = {})
+      return if silent?
+      (options[:output] || output).puts self.format(string, options)
+    end
+
+    # Public: Passes .format to Kernel#print
+    #
+    # string  - the text to be formatted
+    # options - The hash of options used for formatting the text:
+    #           :color - The color to be passed as a method to
+    #                    Term::ANSIColor
+    #
+    # Example
+    #
+    #   Coveralls::Output.print("Hello World!", :color => "underline")
+    #
+    # Returns nil.
+    def print(string, options = {})
+      return if silent?
+      (options[:output] || output).print self.format(string, options)
+    end
+
+    def silent?
+      ENV["COVERALLS_SILENT"] || (defined?(@silent) && @silent)
+    end
+  end
+end

data/lib/coveralls/rake/task.rb

@@ -0,0 +1,19 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Coveralls
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    def initialize(*args, &task_block)
+      namespace :coveralls do
+        desc "Push latest coverage results to Coveralls.io"
+        task :push do
+          require 'coveralls'
+          Coveralls.push!
+        end
+      end
+    end # initialize
+
+  end # class
+end # module

data/lib/coveralls/simplecov.rb

@@ -0,0 +1,101 @@
+module Coveralls
+  module SimpleCov
+    class Formatter
+
+      def display_result(result)
+        # Log which files would be submitted.
+        if result.files.length > 0
+          Coveralls::Output.puts "[Coveralls] Some handy coverage stats:"
+        else
+          Coveralls::Output.puts "[Coveralls] There are no covered files.", :color => "yellow"
+        end
+        result.files.each do |f|
+          Coveralls::Output.print "  * "
+          Coveralls::Output.print short_filename(f.filename).to_s, :color => "cyan"
+          Coveralls::Output.print " => ", :color => "white"
+          cov = "#{f.covered_percent.round}%"
+          if f.covered_percent > 90
+            Coveralls::Output.print cov, :color => "green"
+          elsif f.covered_percent > 80
+            Coveralls::Output.print cov, :color => "yellow"
+          else
+            Coveralls::Output.print cov, :color => "red"
+          end
+          Coveralls::Output.puts ""
+        end
+        true
+      end
+
+      def get_source_files(result)
+        # Gather the source files.
+        source_files = []
+        result.files.each do |file|
+          properties = {}
+
+          # Get Source
+          properties[:source] = File.open(file.filename, "rb:utf-8").read
+
+          # Get the root-relative filename
+          properties[:name] = short_filename(file.filename)
+
+          # Get the coverage
+          properties[:coverage] = file.coverage.dup
+
+          # Skip nocov lines
+          file.lines.each_with_index do |line, i|
+            properties[:coverage][i] = nil if line.skipped?
+          end
+
+          source_files << properties
+        end
+        source_files
+      end
+
+      def format(result)
+
+        unless Coveralls.should_run?
+          if Coveralls.noisy?
+            display_result result
+          end
+          return
+        end
+
+        # Post to Coveralls.
+        API.post_json "jobs", 
+          :source_files => get_source_files(result),
+          :test_framework => result.command_name.downcase,
+          :run_at => result.created_at
+
+        Coveralls::Output.puts output_message result
+
+        true
+
+      rescue Exception => e
+        display_error e
+      end
+
+      def display_error(e)
+        Coveralls::Output.puts "Coveralls encountered an exception:", :color => "red"
+        Coveralls::Output.puts e.class.to_s, :color => "red"
+        Coveralls::Output.puts e.message, :color => "red"
+        e.backtrace.each do |line|
+          Coveralls::Output.puts line, :color => "red"
+        end if e.backtrace
+        if e.respond_to?(:response) && e.response
+          Coveralls::Output.puts e.response.to_s, :color => "red"
+        end
+        false
+      end
+
+      def output_message(result)
+        "Coverage is at #{result.covered_percent.round(2) rescue result.covered_percent.round}%.\nCoverage report sent to Coveralls."
+      end
+
+      def short_filename(filename)
+        filename = filename.gsub(::SimpleCov.root, '.').gsub(/^\.\//, '') if ::SimpleCov.root
+        filename
+      end
+
+    end
+  end
+end