scrutinizer-ocular 1.0.0

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+vendor/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in scrutinizer-ocular.gemspec
+gemspec
+
+gem 'simplecov', :require => false
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Johannes M. Schmitt
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+# Scrutinizer Ocular
+
+Uploads Ruby code coverage data to [scrutinizer-ci.com](https://scrutinizer-ci.com). Internally, it relies on SimpleCov.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'scrutinizer-ocular'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install scrutinizer-ocular
+
+## Usage
+
+You need to initialize ocular at the very top of your ``test_helper.rb`` or ``spec_helper.rb`` file 
+before loading any of your code:
+
+```ruby
+# test_helper.rb or spec_helper.rb
+require 'scrutinizer/ocular'
+Scrutinizer::Ocular.watch!
+```
+
+When running your tests on a private repository, make sure you have your access token set:
+
+```bash
+SCRUTINIZER_ACCESS_TOKEN=abc123 bundle exec rspec spec
+```
+
+When you [create an access token](https://scrutinizer-ci.com/profile/applications), make sure to select ``READ`` permission only.
+Generally, it's a good idea to set-up a dedicated user for reporting code coverage only.
+
+## Advanced Use-Cases
+
+### Defining the SimpleCov Profile
+If you would like to have SimpleCov use a specific profile, you can pass it to the watch method:
+
+```ruby
+Scrutinizer::Ocular.watch! 'rails'
+```
+
+### Adding additional Formatters
+If you would like to run other formatters apart from Scrutinizer's Formatter, you can add these easily:
+
+```ruby
+require 'simplecov'
+require 'scrutinizer/ocular'
+
+# To avoid uploading coverage when running tests locally, you can use
+# Scrutinizer::Ocular.should_run? and add the formatter conditionally.
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Scrutinizer::Ocular::UploadFormatter
+]
+SimpleCov.start
+```
+
+### Merging Coverage from Parallelized Runs
+Scrutinizer supports merging coverage from parallelized runs natively. All you need to do is
+[adjust your .scrutinizer.yml](https://scrutinizer-ci.com/docs/tools/external-code-coverage/)
+to tell us how many submissions you are going to make; no further changes are necessary.
+
+## Credits
+Parts of this code were inspired by the Ruby Coveralls implementation and were received under the MIT license.

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run RSpec"
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+end
+
+task :default => :spec

data/lib/scrutinizer/ocular.rb

@@ -0,0 +1,48 @@
+require "scrutinizer/ocular/version"
+
+module Scrutinizer
+  module Ocular
+    extend self
+
+    attr_accessor :enabled
+    @enabled = false
+
+    def watch!(profile = nil, &block)
+      if self.should_run?
+        setup!
+        start! profile, &block
+      end
+    end
+
+    def setup!
+      require 'simplecov'
+      require "scrutinizer/ocular/formatter"
+
+      ::SimpleCov.formatter = create_formatter
+    end
+
+    def create_formatter
+      if ENV['SCRUTINIZER_CC_FILE']
+        return Scrutinizer::Ocular::LocalOutputFormatter
+      end
+
+      Scrutinizer::Ocular::UploadingFormatter
+    end
+
+    def start!(profile=nil, &block)
+      ::SimpleCov.add_filter 'vendor'
+
+      if profile
+        ::SimpleCov.start(profile)
+      elsif block
+        ::SimpleCov.start(profile) { instance_eval(block) }
+      else
+        ::SimpleCov.start
+      end
+    end
+
+    def should_run?
+      ENV["CI"] || ENV["JENKINS_URL"] || ENV["SCRUTINIZER_COVERAGE"] || ENV['SCRUTINIZER_CC_FILE'] || @enabled
+    end
+  end
+end

data/lib/scrutinizer/ocular/api_client.rb

@@ -0,0 +1,80 @@
+require 'uri'
+require 'net/https'
+require 'json'
+require 'base64'
+
+module Scrutinizer
+  module Ocular
+    class UploadFailed < StandardError
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+    end
+
+    class ApiClient
+      def initialize(api_url, repository_name, revision, parents, access_token)
+        @api_url = api_url
+        @repository_name = repository_name
+        @revision = revision
+        @parents = parents
+        @access_token = access_token
+        @http = create_http_service(@api_url)
+
+        disable_net_blockers!
+      end
+
+      def upload(format, data)
+        uri = URI.parse(@api_url + '/repositories/' + @repository_name + '/data/code-coverage')
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.add_field('Content-Type', 'application/json')
+        request.body = {
+            :revision => @revision,
+            :parents => @parents,
+            :coverage => {
+                :format => format,
+                :data => Base64.encode64(data)
+            }
+        }.to_json
+
+        response = @http.request(request)
+
+        if response.code.to_i < 200 || response.code.to_i >= 300
+          raise UploadFailed.new(response), "Upload failed with status #{response.code}"
+        end
+      end
+
+      private
+
+        def create_http_service(url)
+          uri = URI(url)
+          pem_file = File.absolute_path(File.dirname(__FILE__) + '/../../../res/cacert.pem')
+          pem = File.read(pem_file)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.cert = OpenSSL::X509::Certificate.new(pem)
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+          http
+        end
+
+        def disable_net_blockers!
+          host = URI(@api_url).host
+
+          if defined?(WebMock)
+            allow = WebMock::Config.instance.allow || []
+            WebMock::Config.instance.allow = [*allow].push host
+          end
+
+          if defined?(VCR)
+            VCR.send(VCR.version.major < 2 ? :config : :configure) do |c|
+              c.ignore_hosts host
+            end
+          end
+        end
+    end
+  end
+end
+

data/lib/scrutinizer/ocular/formatter.rb

@@ -0,0 +1,76 @@
+require 'scrutinizer/ocular/api_client'
+require 'scrutinizer/ocular/repository_introspector'
+require 'scrutinizer/ocular/output'
+require 'json'
+
+module Scrutinizer
+  module Ocular
+    class Serializer
+      def serialize(result)
+        files = []
+        result.files.each do |file|
+          files << {
+            :name => file.filename,
+            :lines => file.coverage
+          }
+        end
+
+        files.to_json
+      end
+    end
+
+    class LocalOutputFormatter
+      def initialize
+        @output_file = ENV['SCRUTINIZER_CC_FILE'] || "./coverage.json"
+        @serializer = Serializer.new
+      end
+
+      def format(result)
+        File.open(@output_file, 'w') do |file|
+          file.write(@serializer.serialize(result))
+        end
+      end
+    end
+
+    class UploadingFormatter
+      attr_accessor :output
+
+      def initialize
+        introspector = RepositoryIntrospector.new(Dir.pwd)
+
+        api_url = ENV['SCRUTINIZER_HOST'] || "https://scrutinizer-ci.com/api"
+        access_token = ENV['SCRUTINIZER_ACCESS_TOKEN'] || nil
+        @repository = ENV['SCRUTINIZER_REPOSITORY'] || introspector.get_repository_name
+        @revision = ENV['SCRUTINIZER_REVISION'] || introspector.get_current_revision
+
+        @api_client = ApiClient.new(
+          api_url,
+          @repository,
+          @revision,
+          introspector.get_current_parents,
+          access_token
+        )
+
+        @serializer = Serializer.new
+        @output = StdoutOutput.new
+      end
+
+      def format(result)
+        begin
+          @output.write("Uploading code coverage for '#{@repository}' and revision '#{@revision}'... ")
+          @api_client.upload("rb-cc", @serializer.serialize(result))
+          @output.write("Done!\n")
+        rescue UploadFailed => e
+          @output.write("Failed\n")
+
+          if e.response.code.to_i == 401 || e.response.code.to_i == 403
+            @output.write("Please make sure to set an access token via the environment variable 'SCRUTINIZER_ACCESS_TOKEN'\n")
+            @output.write("You can obtain access tokens with 'READ' permission on https://scrutinizer-ci.com/profile/applications")
+          else
+            @output.write(e.response.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scrutinizer/ocular/output.rb

@@ -0,0 +1,27 @@
+module Scrutinizer
+  module Ocular
+    class NullOutput
+      def write(message)
+        # Do nothing
+      end
+    end
+
+    class MemorizedOutput
+      attr_reader :output
+
+      def initialize
+        @output = ''
+      end
+
+      def write(message)
+        @output += message
+      end
+    end
+
+    class StdoutOutput
+      def write(message)
+        print(message)
+      end
+    end
+  end
+end

data/lib/scrutinizer/ocular/repository_introspector.rb

@@ -0,0 +1,64 @@
+require 'open3'
+
+module Scrutinizer
+  module Ocular
+    class RepositoryIntrospector
+      def initialize(dir)
+        @dir = dir
+      end
+
+      def get_repository_name()
+        stdout, status = Open3.capture2('git remote -v', :chdir => @dir)
+
+        raise 'Repository name could not be determined' unless status.exitstatus == 0
+
+        output = stdout.to_s
+        patterns = [
+            /^origin\s+(?:git@|(?:git|https?):\/\/)([^:\/]+)(?:\/|:)([^\/]+)\/([^\/\s]+?)(?:\.git)?(?:\s|\n)/,
+            /^[^\s]+\s+(?:git@|(?:git|https?):\/\/)([^:\/]+)(?:\/|:)([^\/]+)\/([^\/\s]+?)(?:\.git)?(?:\s|\n)/,
+        ]
+
+        patterns.each { |pattern|
+          if output =~ pattern
+            return get_repository_type($1) + '/' + $2 + '/' + $3
+          end
+        }
+
+        raise "Could not determine repository. Please set the 'SCRUTINIZER_REPOSITORY' environment variable"
+      end
+
+      def get_current_parents
+        stdout, status = Open3.capture2('git log --pretty=%P -n1 HEAD', :chdir => @dir)
+
+        raise 'Parents could not be determined' unless status.exitstatus == 0
+
+        output = stdout.to_s.strip
+        if output.empty?
+          return []
+        end
+
+        output.split(' ')
+      end
+
+      def get_current_revision
+        stdout, status = Open3.capture2('git rev-parse HEAD', :chdir => @dir)
+
+        raise 'Revision could not be determined' unless status.exitstatus == 0
+
+        stdout.to_s.strip
+      end
+
+      private
+        def get_repository_type(host)
+          if host == "github.com"
+              return "g"
+          elsif host == "bitbucket.org"
+              return "b"
+          end
+
+          raise "Unknown host " + host
+        end
+    end
+  end
+end
+