suzuko 0.1.7

data/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Wil Gieseler
+
+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/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/README.md

@@ -0,0 +1,3 @@
+# [Coveralls](http://coveralls.io) for Ruby [![Test Coverage](https://coveralls.io/repos/lemurheavy/coveralls-ruby/badge.svg?branch=master)](https://coveralls.io/r/lemurheavy/coveralls-ruby) [![Build Status](https://secure.travis-ci.org/lemurheavy/coveralls-ruby.svg?branch=master)](https://travis-ci.org/lemurheavy/coveralls-ruby) [![Gem Version](https://badge.fury.io/rb/coveralls.svg)](http://badge.fury.io/rb/coveralls)
+
+### [Read the docs →](https://coveralls.zendesk.com/hc/en-us/articles/201769485-Ruby-Rails)

data/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+# Travis!
+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/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/bin/coveralls

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'coveralls'
+require 'coveralls/command'
+
+Coveralls::CommandLine.start

data/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/coveralls-ruby.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'coveralls/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Nick Merwin", "Wil Gieseler"]
+  gem.email         = ["nick@lemurheavy.com", "supapuerco@gmail.com"]
+  gem.description   = "A Ruby implementation of the Coveralls API."
+  gem.summary       = "A Ruby implementation of the Coveralls API."
+  gem.homepage      = "https://coveralls.io"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "coveralls"
+  gem.require_paths = ["lib"]
+  gem.version       = Coveralls::VERSION
+
+  gem.required_ruby_version = '>= 1.8.7'
+
+  gem.add_dependency 'json', '~> 1.8'
+  gem.add_dependency 'rest-client', '>= 1.6.8', '< 2'
+  gem.add_dependency 'simplecov', '~> 0.10.0'
+  gem.add_dependency 'term-ansicolor', '~> 1.3'
+  gem.add_dependency 'thor', '~> 0.19.1'
+
+  gem.add_development_dependency 'bundler', '~> 1.7'
+end

data/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/lib/coveralls/api.rb

@@ -0,0 +1,73 @@
+require 'json'
+require 'rest_client'
+
+module Coveralls
+  class API
+    if ENV['COVERALLS_ENDPOINT']
+      API_HOST = ENV['COVERALLS_ENDPOINT']
+      API_DOMAIN = ENV['COVERALLS_ENDPOINT']
+    else
+      API_HOST = ENV['COVERALLS_DEVELOPMENT'] ? "localhost:3000" : "coveralls.io"
+      API_PROTOCOL = ENV['COVERALLS_DEVELOPMENT'] ? "http" : "https"
+      API_DOMAIN = "#{API_PROTOCOL}://#{API_HOST}"
+    end
+
+    API_BASE = "#{API_DOMAIN}/api/v1"
+
+    def self.post_json(endpoint, hash)
+      disable_net_blockers!
+      url = endpoint_to_url(endpoint)
+      Coveralls::Output.puts("#{ JSON.pretty_generate(hash) }", :color => "green") if ENV['COVERALLS_DEBUG']
+      hash = apified_hash hash
+      Coveralls::Output.puts("[Coveralls] Submitting to #{API_BASE}", :color => "cyan")
+      response = RestClient::Request.execute(:method => :post, :url => url, :payload => { :json_file => hash_to_file(hash) }, :ssl_version => 'TLSv1', :verify_ssl => false)
+      response_hash = JSON.load(response.to_str)
+      Coveralls::Output.puts("[Coveralls] #{ response_hash['message'] }", :color => "cyan")
+      if response_hash['message']
+        Coveralls::Output.puts("[Coveralls] #{ Coveralls::Output.format(response_hash['url'], :color => "underline") }", :color => "cyan")
+      end
+    rescue RestClient::ServiceUnavailable
+      Coveralls::Output.puts("[Coveralls] API timeout occured, but data should still be processed", :color => "red")
+    rescue RestClient::InternalServerError
+      Coveralls::Output.puts("[Coveralls] API internal error occured, we're on it!", :color => "red")
+    end
+
+    private
+
+    def self.disable_net_blockers!
+      if defined?(WebMock) &&
+        allow = WebMock::Config.instance.allow || []
+        WebMock::Config.instance.allow = [*allow].push API_HOST
+      end
+
+      if defined?(VCR)
+        VCR.send(VCR.version.major < 2 ? :config : :configure) do |c|
+          c.ignore_hosts API_HOST
+        end
+      end
+    end
+
+    def self.endpoint_to_url(endpoint)
+      "#{API_BASE}/#{endpoint}"
+    end
+
+    def self.hash_to_file(hash)
+      file = nil
+      Tempfile.open(['coveralls-upload', 'json']) do |f|
+        f.write(JSON.dump hash)
+        file = f
+      end
+      File.new(file.path, 'rb')
+    end
+
+    def self.apified_hash hash
+      config = Coveralls::Configuration.configuration
+      if ENV['CI'] || ENV['COVERALLS_DEBUG'] || Coveralls.testing
+        Coveralls::Output.puts "[Coveralls] Submitting with config:", :color => "yellow"
+        output = JSON.pretty_generate(config).gsub(/"repo_token": ?"(.*?)"/,'"repo_token": "[secure]"')
+        Coveralls::Output.puts output, :color => "yellow"
+      end
+      hash.merge(config)
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/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"
+      cmd = "bundle exec rake"
+      if File.exist?('.travis.yml')
+        cmd = YAML.load_file('.travis.yml')["script"] || cmd rescue cmd
+      end
+      exec 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/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/lib/coveralls/configuration.rb

@@ -0,0 +1,211 @@
+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['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']
+        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['COVERALLS_RUN_LOCALLY'] || Coveralls.testing
+        set_service_params_for_coveralls_local(config)
+      end
+
+      # standardized env vars
+      set_standard_service_params_for_generic_ci(config)
+
+      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'
+    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']
+    end
+
+    def self.set_service_params_for_jenkins(config)
+      config[:service_name]   = 'jenkins'
+      config[:service_number] = ENV['BUILD_NUMBER']
+    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_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']
+          }
+        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/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/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/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/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/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/lib/coveralls/simplecov.rb

@@ -0,0 +1,105 @@
+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 format(result)
+
+        unless Coveralls.should_run?
+          if Coveralls.noisy?
+            display_result result
+          end
+          return
+        end
+
+        # 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
+
+          # Get the group
+          # puts "result groups: #{result.groups}"
+          # result.groups.each do |group_name, grouped_files|
+          #   puts "Checking #{grouped_files.map(&:filename)} for #{file.filename}"
+          #   if grouped_files.map(&:filename).include?(file.filename)
+          #     properties[:group] = group_name
+          #     break
+          #   end
+          # end
+
+          source_files << properties
+        end
+
+        # Log which files are being submitted.
+        # puts "Submitting #{source_files.length} file#{source_files.length == 1 ? '' : 's'}:"
+        # source_files.each do |f|
+        #   puts "  => #{f[:name]}"
+        # end
+
+        # Post to Coveralls.
+        API.post_json "jobs", {:source_files => source_files, :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

data/vendor/bundle/ruby/2.0.0/gems/coveralls-0.8.3/lib/coveralls/version.rb

@@ -0,0 +1,3 @@
+module Coveralls
+ VERSION = "0.8.3"
+end