danger 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1063da82f82263eede8fc418f7d85a7f1e4a2c4c
-  data.tar.gz: f7bb1935826bf866378aa91c79cb85255ebe25fb
+  metadata.gz: 961961730193f38ada39854b1e3b14a665534539
+  data.tar.gz: 161dfd213ef838bf04dc47c95cd3a59d5e745cc7
 SHA512:
-  metadata.gz: 15724839453717cca2a7ff70da0bc9cbf6940605defde3d713205690d54a4a2900aaf8dd3843e5a6a7e4cb4a4b2d9c3f7efed806490ad70bfed218a7fe126f76
-  data.tar.gz: 7c55ff88479f5aba1be83f0e0a70492f30186170b15bc3815e74f56f3807599219a88efadd6f92106987d4e7aeb3d72585887e6587854ba60e3d4bdc19a66bef
+  metadata.gz: 9c298a712a18d76022aba76603f6946f03ef5999a2203c06c4cc34013e2131d9657fa3ad2972b0bbf9c406f9d6922f5d2677160068482aaf0fbd3572444a31df
+  data.tar.gz: b657e664d71d270a6118bfe68033f039ac2604f969d9494b2e16631e4a9b65448b7e8de1842909e628da7a97aae65ba72939b7b9dc3e2783d8bd33ec62946056

data/README.md

@@ -43,7 +43,7 @@ This will look at your `Dangerfile` and update the pull request accordingly. Whi
 
 ## CI Support
 
-Danger currently is supported on Travis CI, Circle CI, Xcode Bots via Buildasaur, BuildKite, Jenkins, Semaphore, and Drone CI. These work via environment variables, so it's easy to extend to include your own.
+Danger currently is supported on Travis CI, Circle CI, Xcode Bots via Buildasaur, BuildKite, Jenkins, Semaphore, Drone CI and TeamCity. These work via environment variables, so it's easy to extend to include your own.
 
 ## What happens?
 
@@ -62,7 +62,7 @@ Danger runs at the end of a CI build, she will execute a `Dangerfile`. This file
 :busts_in_silhouette:  | `pr_author` | The author who submitted the PR
 :bookmark: | `pr_labels` | The labels added to the PR
 
-The `Dangerfile` is a ruby file, so really, you can do anything. However, at this stage you might need selling on the idea a bit more, so lets take some real examples:
+The `Dangerfile` is a Ruby file, so really, you can do anything. However, at this stage you might need selling on the idea a bit more, so lets take some real examples:
 
 #### Dealing with WIP pull requests
 
@@ -192,6 +192,20 @@ Danger will update the comment to cross it out. If you don't want this behavior,
 fail("PR needs labels", sticky: false) if pr_labels.empty?
 ```
 
+## Multiple Dangers
+
+If one Danger is not enough for you, you can run several ones on the same PR. Just use the `danger_id` param. For example: 
+
+```
+bundle exec danger --danger_id=unit_tests
+```
+
+You can have each instance of Danger running on a different CI provider and even doing different validations. An use case would be:
+
+* `basic` runs on a Linux environment (such as Circle CI) and validates the PR itself (title, etc)
+* `compilation` runs on a Mac after running unit tests for your iOS app and comments about warnings, test failures, etc
+* `uitests` runs on a Mac after running UI Unit tests and comments about test failures
+
 ## Useful bits of knowledge
 
 * You can set the base branch in the command line arguments see: `bundle exec danger --help`, if you commonly merge into non-master branches.
@@ -206,7 +220,7 @@ Danger allows usage with GitHub Enterprise by setting 2 environment variables:
 
 ## License, Contributor's Guidelines and Code of Conduct
 
-[Join our Slack Group](https://danger-slack.herokuapp.com/)
+We try to keep as much discussion as possible in GitHub issues, but also have a slack, if you'd like an invite ping [@Orta](https://twitter.com/orta/) a DM on twitter with your email. 
 
 > This project is open source under the MIT license, which means you have full access to the source code and can modify it to fit your own needs.
 

data/lib/danger/ci_source/buildkite.rb

@@ -5,17 +5,23 @@ module Danger
   module CISource
     class Buildkite < CI
       def self.validates?(env)
-        return !env["BUILDKITE"].nil?
+        return false unless env["BUILDKITE"]
+        return false unless env["BUILDKITE_REPO"]
+        return false unless env["BUILDKITE_PULL_REQUEST"]
+
+        return true
       end
 
       def initialize(env)
-        repo = env["BUILDKITE_REPO"]
-        unless repo.nil?
-          repo_matches = repo.match(%r{([\/:])([^\/]+\/[^\/.]+)(?:.git)?$})
-          self.repo_slug = repo_matches[2] unless repo_matches.nil?
-        end
-
+        self.repo_url = env["BUILDKITE_REPO"]
         self.pull_request_id = env["BUILDKITE_PULL_REQUEST"]
+
+        repo_matches = self.repo_url.match(%r{([\/:])([^\/]+\/[^\/.]+)(?:.git)?$})
+        self.repo_slug = repo_matches[2] unless repo_matches.nil?
+      end
+
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
       end
     end
   end

data/lib/danger/ci_source/ci_source.rb

@@ -2,7 +2,24 @@ module Danger
   module CISource
     # "abstract" CI class
     class CI
-      attr_accessor :repo_slug, :pull_request_id
+      attr_accessor :repo_slug, :pull_request_id, :repo_url, :supported_request_sources
+
+      def self.inherited(child_class)
+        available_ci_sources.add child_class
+        super
+      end
+
+      def self.available_ci_sources
+        @available_ci_sources ||= Set.new
+      end
+
+      def supported_request_sources
+        raise "CISource subclass must specify the supported request sources"
+      end
+
+      def supports?(request_source)
+        supported_request_sources.include? request_source
+      end
 
       def self.validates?(_env)
         false

data/lib/danger/ci_source/circle.rb

@@ -6,10 +6,16 @@ module Danger
   module CISource
     class CircleCI < CI
       def self.validates?(env)
-        return false if env["CIRCLE_BUILD_NUM"].nil?
-        return true unless env["CI_PULL_REQUEST"].nil?
+        return false unless env["CIRCLE_BUILD_NUM"]
+        return false unless env["CI_PULL_REQUEST"]
+        return false unless env["CIRCLE_PROJECT_USERNAME"]
+        return false unless env["CIRCLE_PROJECT_REPONAME"]
 
-        return !env["CIRCLE_PROJECT_USERNAME"].nil? && !env["CIRCLE_PROJECT_REPONAME"].nil?
+        return true
+      end
+
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
       end
 
       def client
@@ -33,6 +39,8 @@ module Danger
       end
 
       def initialize(env)
+        self.repo_url = GitRepo.new.origins # CircleCI doesn't provide a repo url env variable :/
+
         @circle_token = env["CIRCLE_CI_API_TOKEN"]
         url = pull_request_url(env)
 

data/lib/danger/ci_source/drone.rb

@@ -4,14 +4,21 @@ module Danger
   module CISource
     class Drone < CI
       def self.validates?(env)
-        return !env["DRONE"].nil?
+        return false unless env["DRONE"]
+        return false unless env["DRONE_REPO"]
+        return false unless env["DRONE_PULL_REQUEST"].to_i > 0
+
+        return true
+      end
+
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
       end
 
       def initialize(env)
         self.repo_slug = env["DRONE_REPO"]
-        if env["DRONE_PULL_REQUEST"].to_i > 0
-          self.pull_request_id = env["DRONE_PULL_REQUEST"]
-        end
+        self.pull_request_id = env["DRONE_PULL_REQUEST"]
+        self.repo_url = GitRepo.new.origins # Drone doesn't provide a repo url env variable :/
       end
     end
   end

data/lib/danger/ci_source/jenkins.rb

@@ -5,20 +5,22 @@ module Danger
   module CISource
     class Jenkins < CI
       def self.validates?(env)
-        return !env["ghprbPullId"].nil? && !env["GIT_URL"].nil?
+        return false unless env["ghprbPullId"].to_i > 0
+        return false unless env["GIT_URL"]
+
+        return true
+      end
+
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
       end
 
       def initialize(env)
-        repo = env["GIT_URL"]
-        unless repo.nil?
-          repo_matches = repo.match(%r{([\/:])([^\/]+\/[^\/.]+)(?:.git)?$})
-          self.repo_slug = repo_matches[2] unless repo_matches.nil?
-        end
+        self.repo_url = env["GIT_URL"]
+        self.pull_request_id = env["ghprbPullId"]
 
-        # from https://docs.travis-ci.com/user/pull-requests, as otherwise it's "false"
-        if env["ghprbPullId"].to_i > 0
-          self.pull_request_id = env["ghprbPullId"]
-        end
+        repo_matches = self.repo_url.match(%r{([\/:])([^\/]+\/[^\/.]+)(?:.git)?$})
+        self.repo_slug = repo_matches[2] unless repo_matches.nil?
       end
     end
   end

data/lib/danger/ci_source/local_git_repo.rb

@@ -20,6 +20,10 @@ module Danger
         git.exec command
       end
 
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
+      end
+
       def initialize(env = {})
         github_host = env["DANGER_GITHUB_HOST"] || "github.com"
 

data/lib/danger/ci_source/semaphore.rb

@@ -4,14 +4,21 @@ module Danger
   module CISource
     class Semaphore < CI
       def self.validates?(env)
-        return !env["SEMAPHORE"].nil?
+        return false unless env["SEMAPHORE"]
+        return false unless env["SEMAPHORE_REPO_SLUG"]
+        return false unless env["PULL_REQUEST_NUMBER"].to_i > 0
+
+        return true
+      end
+
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
       end
 
       def initialize(env)
         self.repo_slug = env["SEMAPHORE_REPO_SLUG"]
-        if env["PULL_REQUEST_NUMBER"].to_i > 0
-          self.pull_request_id = env["PULL_REQUEST_NUMBER"]
-        end
+        self.pull_request_id = env["PULL_REQUEST_NUMBER"]
+        self.repo_url = GitRepo.new.origins # Semaphore doesn't provide a repo url env variable :/
       end
     end
   end

data/lib/danger/ci_source/teamcity.rb

@@ -0,0 +1,22 @@
+module Danger
+  module CISource
+    class TeamCity < CI
+      def self.validates?(env)
+        env.key? 'TEAMCITY_VERSION'
+      end
+
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
+      end
+
+      def initialize(env)
+        # NB: Unfortunately TeamCity doesn't provide these variables
+        # automatically so you have to add these variables manually to your
+        # project or build configuration
+        self.repo_slug       = env['GITHUB_REPO_SLUG']
+        self.pull_request_id = env['GITHUB_PULL_REQUEST_ID'].to_i
+        self.repo_url        = env['GITHUB_REPO_URL']
+      end
+    end
+  end
+end

data/lib/danger/ci_source/travis.rb

@@ -5,15 +5,23 @@ module Danger
   module CISource
     class Travis < CI
       def self.validates?(env)
-        return !env["HAS_JOSH_K_SEAL_OF_APPROVAL"].nil?
+        return false unless env["HAS_JOSH_K_SEAL_OF_APPROVAL"]
+        return false unless env["TRAVIS_REPO_SLUG"]
+        return false unless env["TRAVIS_PULL_REQUEST"]
+
+        return true
+      end
+
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
       end
 
       def initialize(env)
         self.repo_slug = env["TRAVIS_REPO_SLUG"]
-        # from https://docs.travis-ci.com/user/pull-requests, as otherwise it's "false"
         if env["TRAVIS_PULL_REQUEST"].to_i > 0
           self.pull_request_id = env["TRAVIS_PULL_REQUEST"]
         end
+        self.repo_url = GitRepo.new.origins # Travis doesn't provide a repo url env variable :/
       end
     end
   end

data/lib/danger/ci_source/xcode_server.rb

@@ -4,7 +4,13 @@ module Danger
   module CISource
     class XcodeServer < CI
       def self.validates?(env)
-        return !env["XCS_BOT_NAME"].nil?
+        return false unless env["XCS_BOT_NAME"]
+
+        return true
+      end
+
+      def supported_request_sources
+        @supported_request_sources ||= [Danger::RequestSources::GitHub]
       end
 
       def initialize(env)
@@ -15,6 +21,7 @@ module Danger
         self.repo_slug = repo_matches[1] unless repo_matches.nil?
         pull_request_id_matches = bot_name.match(/#(\d+)/)
         self.pull_request_id = pull_request_id_matches[1] unless pull_request_id_matches.nil?
+        self.repo_url = GitRepo.new.origins # Xcode Server doesn't provide a repo url env variable :/
       end
     end
   end

data/lib/danger/commands/runner.rb

@@ -15,6 +15,7 @@ module Danger
       @dangerfile_path = dangerfile if File.exist? dangerfile
       @base = argv.option('base')
       @head = argv.option('head')
+      @danger_id = argv.option('danger_id', 'danger')
       super
     end
 
@@ -29,7 +30,8 @@ module Danger
       [
         ['--base=[master|dev|stable]', 'A branch/tag/commit to use as the base of the diff'],
         ['--head=[master|dev|stable]', 'A branch/tag/commit to use as the head'],
-        ['--dangerfile=<path/to/dangerfile>', 'The location of your Dangerfile']
+        ['--dangerfile=<path/to/dangerfile>', 'The location of your Dangerfile'],
+        ['--danger_id=<id>', 'The identifier of this Danger instance']
       ].concat(super)
     end
 
@@ -47,8 +49,8 @@ module Danger
           dm.env.ensure_danger_branches_are_setup
 
           # Offer the chance for a user to specify a branch through the command line
-          ci_base = @base || dm.env.danger_head_branch
-          ci_head = @head || dm.env.danger_base_branch
+          ci_base = @base || EnvironmentManager.danger_base_branch
+          ci_head = @head || EnvironmentManager.danger_head_branch
           dm.env.scm.diff_for_folder(".", from: ci_base, to: ci_head)
 
           dm.parse Pathname.new(@dangerfile_path)
@@ -68,7 +70,19 @@ module Danger
       violations = dm.violation_report
       status = dm.status_report
 
-      gh.update_pull_request!(warnings: violations[:warnings], errors: violations[:errors], messages: violations[:messages], markdowns: status[:markdowns])
+      gh.update_pull_request!(warnings: violations[:warnings], errors: violations[:errors], messages: violations[:messages], markdowns: status[:markdowns], danger_id: @danger_id)
+    end
+
+    def self.report_error(exception)
+      raise exception if exception.kind_of?(SystemExit)
+      message = "#{exception.message.red} (#{exception.class.to_s.yellow})"
+      if exception.backtrace
+        danger_lib = File.expand_path('../../..', __FILE__)
+        message << "\n\t" << exception.backtrace.reverse_each.
+                             drop_while { |bt| !bt.start_with?(danger_lib) }.reverse.
+                             join("\n\t")
+      end
+      abort(message)
     end
   end
 end

data/lib/danger/comment_generators/github.md.erb

@@ -1,41 +1,40 @@
-<% @tables.each do |table| %>
-  <% if table[:content].any? || table[:resolved].any? %>
+<%- @tables.each do |table| -%>
+  <%- if table[:content].any? || table[:resolved].any? -%>
 <table>
   <thead>
     <tr>
       <th width="50"></th>
       <th width="100%" data-kind="<%= table[:name] %>">
-        <% if table[:count] > 0 %>
-            <%= table[:count] %> <%= table[:name] %><%= "s" unless table[:count] == 1 %>
-        <% else %>
-            :white_check_mark: <%= random_compliment %>
-        <% end %>
+        <%- if table[:count] > 0 -%>
+          <%= table[:count] %> <%= table[:name] %><%= "s" unless table[:count] == 1 %>
+        <%- else -%>
+          :white_check_mark: <%= random_compliment %>
+        <%- end -%>
       </th>
      </tr>
   </thead>
   <tbody>
-    <% table[:content].each do |violation| -%>
+    <%- table[:content].each do |violation| -%>
     <tr>
       <td>:<%= table[:emoji] %>:</td>
       <td data-sticky="<%= violation.sticky %>"><%= violation.message %></td>
     </tr>
-    <% end %>
-    <% table[:resolved].each do |message| -%>
+    <%- end -%>
+    <%- table[:resolved].each do |message| -%>
       <tr>
         <td>:white_check_mark:</td>
         <td data-sticky="true"><del><%= message %></del></td>
       </tr>
-    <% end %>
+    <%- end -%>
   </tbody>
 </table>
-  <% end %>
-<% end %>
+  <%- end -%>
+<%- end -%>
 
-<% @markdowns.each do |current| %>
+<%- @markdowns.each do |current| -%>
 <%= current %>
 <%# the previous line has to be aligned far to the left, otherwise markdown can break easily %>
-<% end %>
-
-<p align="right" data-meta="generated_by_danger">
+<%- end -%>
+<p align="right" data-meta="generated_by_<%= @danger_id %>">
   Generated by :no_entry_sign: <a href="https://github.com/danger/danger/">danger</a>
 </p>

data/lib/danger/danger_core/dangerfile.rb

@@ -82,7 +82,7 @@ module Danger
     # Iterate through available plugin classes and initialize them with
     # a reference to this Dangerfile
     def refresh_plugins
-      plugins = ObjectSpace.each_object(Class).select { |klass| klass < Danger::Plugin }
+      plugins = Plugin.all_plugins
       plugins.each do |klass|
         next if klass.respond_to?(:singleton_class?) && klass.singleton_class?
         plugin = klass.new(self)

data/lib/danger/danger_core/environment_manager.rb

@@ -1,17 +1,15 @@
 require "danger/ci_source/ci_source"
-require "danger/request_source/github"
+require "danger/request_source/request_source"
 
 module Danger
   class EnvironmentManager
     attr_accessor :ci_source, :request_source, :scm
 
     def initialize(env)
-      CISource.constants.each do |symb|
-        c = CISource.const_get(symb)
-        next unless c.kind_of?(Class)
-        next unless c.validates?(env)
+      CISource::CI.available_ci_sources.each do |klass|
+        next unless klass.validates?(env)
 
-        self.ci_source = c.new(env)
+        self.ci_source = klass.new(env)
         if self.ci_source.repo_slug and self.ci_source.pull_request_id
           break
         else
@@ -20,12 +18,19 @@ module Danger
         end
       end
 
-      raise "Could not find a CI source".red unless self.ci_source
+      raise "Could not find a valid pull request within the known CI sources".red unless self.ci_source
 
-      # only GitHub for now, open for PRs adding more!
-      self.request_source = GitHub.new(self.ci_source, ENV)
-      # Also Git only for now, also open for PRs adding more!
-      self.scm = GitRepo.new # For now
+      RequestSources::RequestSource.available_request_sources.each do |klass|
+        next unless self.ci_source.supports?(klass)
+
+        request_source = klass.new(self.ci_source, ENV)
+        next unless request_source.validates?
+        self.request_source = request_source
+      end
+
+      raise "Could not find a Request Source".red unless self.request_source
+
+      self.scm = self.request_source.scm
     end
 
     def pr?
@@ -39,40 +44,28 @@ module Danger
     def ensure_danger_branches_are_setup
       clean_up
 
-      # As this currently just works with GitHub, we can use a github specific feature here:
-      pull_id = ci_source.pull_request_id
-
-      # TODO: This isn't optimal, should be hidden behind some kind of facade, but the plugin makes that
-      # difficult to do without accessing the dangerfile
-      test_branch = request_source.pr_json[:base][:sha]
-
-      # Next, we want to ensure that we have a version of the current branch at a known location
-      scm.exec "branch #{danger_base_branch} #{test_branch}"
-
-      # OK, so we want to ensure that we have a known head branch, this will always represent
-      # the head of the PR ( e.g. the most recent commit that will be merged. )
-      scm.exec "fetch origin +refs/pull/#{pull_id}/merge:#{danger_head_branch}"
+      self.request_source.setup_danger_branches
     end
 
     def clean_up
-      [danger_base_branch, danger_base_branch].each do |branch|
+      [EnvironmentManager.danger_base_branch, EnvironmentManager.danger_head_branch].each do |branch|
         scm.exec("branch -D #{branch}") unless scm.exec("rev-parse --quiet --verify #{branch}").empty?
       end
     end
 
     def meta_info_for_base
-      scm.exec("--no-pager log #{danger_base_branch} -n1")
+      scm.exec("--no-pager log #{EnvironmentManager.danger_base_branch} -n1")
     end
 
     def meta_info_for_head
-      scm.exec("--no-pager log #{danger_head_branch} -n1")
+      scm.exec("--no-pager log #{EnvironmentManager.danger_head_branch} -n1")
     end
 
-    def danger_head_branch
+    def self.danger_head_branch
       "danger_head"
     end
 
-    def danger_base_branch
+    def self.danger_base_branch
       "danger_base"
     end
   end

data/lib/danger/danger_core/plugins/dangerfile_github_plugin.rb

@@ -4,7 +4,7 @@ module Danger
   class DangerfileGitHubPlugin < Plugin
     def initialize(dangerfile)
       super(dangerfile)
-      return nil unless dangerfile.env.request_source.class == Danger::GitHub
+      return nil unless dangerfile.env.request_source.class == Danger::RequestSources::GitHub
 
       @github = dangerfile.env.request_source
     end

data/lib/danger/plugin_support/plugin.rb

@@ -5,7 +5,7 @@ module Danger
     end
 
     def self.instance_name
-      self.to_s.gsub("Danger", "").danger_underscore.split('/').last
+      to_s.gsub("Danger", "").danger_underscore.split('/').last
     end
 
     # Both of these methods exist on all objects
@@ -13,19 +13,20 @@ module Danger
     # http://ruby-doc.org/core-2.2.3/Kernel.html#method-i-fail
     # However, as we're using using them in the DSL, they won't
     # get method_missing called correctly.
+    undef :warn, :fail
 
-    def warn(*args, &blk)
-      method_missing(:warn, *args, &blk)
+    # Since we have a reference to the Dangerfile containing all the information
+    # We need to redirect the self calls to the Dangerfile
+    def method_missing(method_sym, *arguments, &block)
+      @dangerfile.send(method_sym, *arguments, &block)
     end
 
-    def fail(*args, &blk)
-      method_missing(:fail, *args, &blk)
+    def self.all_plugins
+      @all_plugins ||= []
     end
 
-    # Since we have a reference to the Dangerfile containing all the information
-    # We need to redirect the self calls to the Dangerfile
-    def method_missing(method_sym, *arguments, &_block)
-      @dangerfile.send(method_sym, *arguments)
+    def self.inherited(plugin)
+      Plugin.all_plugins.push(plugin)
     end
   end
 end

data/lib/danger/request_source/github.rb

@@ -3,201 +3,225 @@ require 'octokit'
 require 'redcarpet'
 
 module Danger
-  class GitHub
-    attr_accessor :ci_source, :pr_json, :issue_json, :environment, :support_tokenless_auth, :ignored_violations, :github_host
+  module RequestSources
+    class GitHub < RequestSource
+      attr_accessor :pr_json, :issue_json, :support_tokenless_auth
+
+      def initialize(ci_source, environment)
+        self.ci_source = ci_source
+        self.environment = environment
+        self.support_tokenless_auth = false
+
+        Octokit.auto_paginate = true
+        @token = @environment["DANGER_GITHUB_API_TOKEN"]
+        if @environment["DANGER_GITHUB_API_HOST"]
+          Octokit.api_endpoint = @environment["DANGER_GITHUB_API_HOST"]
+        end
+      end
 
-    def initialize(ci_source, environment)
-      self.ci_source = ci_source
-      self.environment = environment
-      self.support_tokenless_auth = false
+      def scm
+        @scm ||= GitRepo.new
+      end
 
-      Octokit.auto_paginate = true
-      @token = @environment["DANGER_GITHUB_API_TOKEN"]
-      self.github_host = @environment["DANGER_GITHUB_HOST"] || "github.com"
-      if @environment["DANGER_GITHUB_API_HOST"]
-        Octokit.api_endpoint = @environment["DANGER_GITHUB_API_HOST"]
+      def host
+        @host = @environment["DANGER_GITHUB_HOST"] || "github.com"
       end
-    end
 
-    def client
-      raise "No API token given, please provide one using `DANGER_GITHUB_API_TOKEN`" if !@token && !support_tokenless_auth
-      @client ||= Octokit::Client.new(access_token: @token)
-    end
+      def client
+        raise "No API token given, please provide one using `DANGER_GITHUB_API_TOKEN`" if !@token && !support_tokenless_auth
+        @client ||= Octokit::Client.new(access_token: @token)
+      end
 
-    def markdown_parser
-      @markdown_parser ||= Redcarpet::Markdown.new(Redcarpet::Render::HTML, no_intra_emphasis: true)
-    end
+      def markdown_parser
+        @markdown_parser ||= Redcarpet::Markdown.new(Redcarpet::Render::HTML, no_intra_emphasis: true)
+      end
 
-    def fetch_details
-      self.pr_json = client.pull_request(ci_source.repo_slug, ci_source.pull_request_id)
-      fetch_issue_details(self.pr_json)
-      self.ignored_violations = ignored_violations_from_pr(self.pr_json)
-    end
+      def setup_danger_branches
+        # we can use a github specific feature here:
+        pull_id = self.ci_source.pull_request_id
+        test_branch = self.pr_json[:base][:sha]
 
-    def ignored_violations_from_pr(pr_json)
-      pr_body = pr_json[:body]
-      return [] if pr_body.nil?
-      pr_body.chomp.scan(/>\s*danger\s*:\s*ignore\s*"(.*)"/i).flatten
-    end
+        # Next, we want to ensure that we have a version of the current branch at a known location
+        self.scm.exec "branch #{EnvironmentManager.danger_base_branch} #{test_branch}"
 
-    def fetch_issue_details(pr_json)
-      href = pr_json[:_links][:issue][:href]
-      self.issue_json = client.get(href)
-    end
+        # OK, so we want to ensure that we have a known head branch, this will always represent
+        # the head of the PR ( e.g. the most recent commit that will be merged. )
+        self.scm.exec "fetch origin +refs/pull/#{pull_id}/merge:#{EnvironmentManager.danger_head_branch}"
+      end
 
-    # Sending data to GitHub
-    def update_pull_request!(warnings: [], errors: [], messages: [], markdowns: [])
-      comment_result = {}
+      def fetch_details
+        self.pr_json = client.pull_request(ci_source.repo_slug, ci_source.pull_request_id)
+        fetch_issue_details(self.pr_json)
+        self.ignored_violations = ignored_violations_from_pr(self.pr_json)
+      end
 
-      issues = client.issue_comments(ci_source.repo_slug, ci_source.pull_request_id)
-      editable_issues = issues.reject { |issue| issue[:body].include?("generated_by_danger") == false }
+      def ignored_violations_from_pr(pr_json)
+        pr_body = pr_json[:body]
+        return [] if pr_body.nil?
+        pr_body.chomp.scan(/>\s*danger\s*:\s*ignore\s*"(.*)"/i).flatten
+      end
 
-      if editable_issues.empty?
-        previous_violations = {}
-      else
-        comment = editable_issues.first[:body]
-        previous_violations = parse_comment(comment)
+      def fetch_issue_details(pr_json)
+        href = pr_json[:_links][:issue][:href]
+        self.issue_json = client.get(href)
       end
 
-      if previous_violations.empty? && (warnings + errors + messages + markdowns).empty?
-        # Just remove the comment, if there's nothing to say.
-        delete_old_comments!
-      else
-        body = generate_comment(warnings: warnings,
-                                  errors: errors,
-                                messages: messages,
-                               markdowns: markdowns,
-                     previous_violations: previous_violations)
+      # Sending data to GitHub
+      def update_pull_request!(warnings: [], errors: [], messages: [], markdowns: [], danger_id: 'danger')
+        comment_result = {}
+
+        issues = client.issue_comments(ci_source.repo_slug, ci_source.pull_request_id)
+        editable_issues = issues.reject { |issue| issue[:body].include?("generated_by_#{danger_id}") == false }
 
         if editable_issues.empty?
-          comment_result = client.add_comment(ci_source.repo_slug, ci_source.pull_request_id, body)
+          previous_violations = {}
         else
-          original_id = editable_issues.first[:id]
-          comment_result = client.update_comment(ci_source.repo_slug, original_id, body)
+          comment = editable_issues.first[:body]
+          previous_violations = parse_comment(comment)
         end
-      end
 
-      # Now, set the pull request status.
-      # Note: this can terminate the entire process.
-      submit_pull_request_status!(warnings: warnings,
+        if previous_violations.empty? && (warnings + errors + messages + markdowns).empty?
+          # Just remove the comment, if there's nothing to say.
+          delete_old_comments!(danger_id: danger_id)
+        else
+          body = generate_comment(warnings: warnings,
                                     errors: errors,
-                               details_url: comment_result['html_url'])
-    end
+                                  messages: messages,
+                                 markdowns: markdowns,
+                       previous_violations: previous_violations,
+                                 danger_id: danger_id)
+
+          if editable_issues.empty?
+            comment_result = client.add_comment(ci_source.repo_slug, ci_source.pull_request_id, body)
+          else
+            original_id = editable_issues.first[:id]
+            comment_result = client.update_comment(ci_source.repo_slug, original_id, body)
+          end
+        end
 
-    def submit_pull_request_status!(warnings: nil, errors: nil, details_url: nil)
-      status = (errors.count == 0 ? 'success' : 'failure')
-      message = generate_github_description(warnings: warnings, errors: errors)
-      client.create_status(ci_source.repo_slug, latest_pr_commit_ref, status, {
-        description: message,
-        context: "danger/danger",
-        target_url: details_url
-      })
-    rescue
-      # This usually means the user has no commit access to this repo
-      # That's always the case for open source projects where you can only
-      # use a read-only GitHub account
-      if errors.count > 0
-        # We need to fail the actual build here
-        abort("\nDanger has failed this build. \nFound #{'error'.danger_pluralize(errors.count)} and I don't have write access to the PR set a PR status.")
-      else
-        puts message
+        # Now, set the pull request status.
+        # Note: this can terminate the entire process.
+        submit_pull_request_status!(warnings: warnings,
+                                      errors: errors,
+                                 details_url: comment_result['html_url'])
       end
-    end
 
-    # Get rid of the previously posted comment, to only have the latest one
-    def delete_old_comments!(except: nil)
-      issues = client.issue_comments(ci_source.repo_slug, ci_source.pull_request_id)
-      issues.each do |issue|
-        next unless issue[:body].include?("generated_by_danger")
-        next if issue[:id] == except
-        client.delete_comment(ci_source.repo_slug, issue[:id])
+      def submit_pull_request_status!(warnings: nil, errors: nil, details_url: nil)
+        status = (errors.count == 0 ? 'success' : 'failure')
+        message = generate_github_description(warnings: warnings, errors: errors)
+        client.create_status(ci_source.repo_slug, latest_pr_commit_ref, status, {
+          description: message,
+          context: "danger/danger",
+          target_url: details_url
+        })
+      rescue
+        # This usually means the user has no commit access to this repo
+        # That's always the case for open source projects where you can only
+        # use a read-only GitHub account
+        if errors.count > 0
+          # We need to fail the actual build here
+          abort("\nDanger has failed this build. \nFound #{'error'.danger_pluralize(errors.count)} and I don't have write access to the PR set a PR status.")
+        else
+          puts message
+        end
       end
-    end
 
-    def random_compliment
-      compliment = ["Well done.", "Congrats.", "Woo!",
-                    "Yay.", "Jolly good show.", "Good on 'ya.", "Nice work."]
-      compliment.sample
-    end
-
-    def generate_github_description(warnings: nil, errors: nil)
-      if errors.empty? && warnings.empty?
-        return "All green. #{random_compliment}"
-      else
-        message = "⚠ "
-        message += "#{'Error'.danger_pluralize(errors.count)}. " unless errors.empty?
-        message += "#{'Warning'.danger_pluralize(warnings.count)}. " unless warnings.empty?
-        message += "Don't worry, everything is fixable."
-        return message
+      # Get rid of the previously posted comment, to only have the latest one
+      def delete_old_comments!(except: nil, danger_id: 'danger')
+        issues = client.issue_comments(ci_source.repo_slug, ci_source.pull_request_id)
+        issues.each do |issue|
+          next unless issue[:body].include?("generated_by_#{danger_id}")
+          next if issue[:id] == except
+          client.delete_comment(ci_source.repo_slug, issue[:id])
+        end
       end
-    end
 
-    def generate_comment(warnings: [], errors: [], messages: [], markdowns: [], previous_violations: {})
-      require 'erb'
+      def random_compliment
+        compliment = ["Well done.", "Congrats.", "Woo!",
+                      "Yay.", "Jolly good show.", "Good on 'ya.", "Nice work."]
+        compliment.sample
+      end
 
-      md_template = File.join(Danger.gem_path, "lib/danger/comment_generators/github.md.erb")
+      def generate_github_description(warnings: nil, errors: nil)
+        if errors.empty? && warnings.empty?
+          return "All green. #{random_compliment}"
+        else
+          message = "⚠ "
+          message += "#{'Error'.danger_pluralize(errors.count)}. " unless errors.empty?
+          message += "#{'Warning'.danger_pluralize(warnings.count)}. " unless warnings.empty?
+          message += "Don't worry, everything is fixable."
+          return message
+        end
+      end
 
-      # erb: http://www.rrn.dk/rubys-erb-templating-system
-      # for the extra args: http://stackoverflow.com/questions/4632879/erb-template-removing-the-trailing-line
-      @tables = [
-        table("Error", "no_entry_sign", errors, previous_violations),
-        table("Warning", "warning", warnings, previous_violations),
-        table("Message", "book", messages, previous_violations)
-      ]
-      @markdowns = markdowns
+      def generate_comment(warnings: [], errors: [], messages: [], markdowns: [], previous_violations: {}, danger_id: 'danger')
+        require 'erb'
 
-      return ERB.new(File.read(md_template), 0, "-").result(binding)
-    end
+        md_template = File.join(Danger.gem_path, "lib/danger/comment_generators/github.md.erb")
 
-    def table(name, emoji, violations, all_previous_violations)
-      content = violations.map { |v| process_markdown(v) }
-      kind = table_kind_from_title(name)
-      previous_violations = all_previous_violations[kind] || []
-      messages = content.map(&:message)
-      resolved_violations = previous_violations.reject { |s| messages.include? s }
-      count = content.count
-      { name: name, emoji: emoji, content: content, resolved: resolved_violations, count: count }
-    end
+        # erb: http://www.rrn.dk/rubys-erb-templating-system
+        # for the extra args: http://stackoverflow.com/questions/4632879/erb-template-removing-the-trailing-line
+        @tables = [
+          table("Error", "no_entry_sign", errors, previous_violations),
+          table("Warning", "warning", warnings, previous_violations),
+          table("Message", "book", messages, previous_violations)
+        ]
+        @markdowns = markdowns
+        @danger_id = danger_id
 
-    def parse_comment(comment)
-      tables = parse_tables_from_comment(comment)
-      violations = {}
-      tables.each do |table|
-        next unless table =~ %r{<th width="100%"(.*?)</th>}im
-        title = Regexp.last_match(1)
-        kind = table_kind_from_title(title)
-        next unless kind
+        return ERB.new(File.read(md_template), 0, "-").result(binding)
+      end
 
-        violations[kind] = violations_from_table(table)
+      def table(name, emoji, violations, all_previous_violations)
+        content = violations.map { |v| process_markdown(v) }.uniq
+        kind = table_kind_from_title(name)
+        previous_violations = all_previous_violations[kind] || []
+        messages = content.map(&:message)
+        resolved_violations = previous_violations.uniq - messages
+        count = content.count
+        { name: name, emoji: emoji, content: content, resolved: resolved_violations, count: count }
       end
 
-      violations.reject { |_, v| v.empty? }
-    end
+      def parse_comment(comment)
+        tables = parse_tables_from_comment(comment)
+        violations = {}
+        tables.each do |table|
+          next unless table =~ %r{<th width="100%"(.*?)</th>}im
+          title = Regexp.last_match(1)
+          kind = table_kind_from_title(title)
+          next unless kind
 
-    def violations_from_table(table)
-      regex = %r{<td data-sticky="true">(?:<del>)?(.*?)(?:</del>)?\s*</td>}im
-      table.scan(regex).flatten.map(&:strip)
-    end
+          violations[kind] = violations_from_table(table)
+        end
 
-    def table_kind_from_title(title)
-      if title =~ /error/i
-        :error
-      elsif title =~ /warning/i
-        :warning
-      elsif title =~ /message/i
-        :message
+        violations.reject { |_, v| v.empty? }
       end
-    end
 
-    def parse_tables_from_comment(comment)
-      comment.split('</table>')
-    end
+      def violations_from_table(table)
+        regex = %r{<td data-sticky="true">(?:<del>)?(.*?)(?:</del>)?\s*</td>}im
+        table.scan(regex).flatten.map(&:strip)
+      end
 
-    def process_markdown(violation)
-      html = markdown_parser.render(violation.message)
-      match = html.match(%r{^<p>(.*)</p>$})
-      message = match.nil? ? html : match.captures.first
-      Violation.new(message, violation.sticky)
+      def table_kind_from_title(title)
+        if title =~ /error/i
+          :error
+        elsif title =~ /warning/i
+          :warning
+        elsif title =~ /message/i
+          :message
+        end
+      end
+
+      def parse_tables_from_comment(comment)
+        comment.split('</table>')
+      end
+
+      def process_markdown(violation)
+        html = markdown_parser.render(violation.message)
+        match = html.match(%r{^<p>(.*)</p>$})
+        message = match.nil? ? html : match.captures.first
+        Violation.new(message, violation.sticky)
+      end
     end
   end
 end

data/lib/danger/request_source/request_source.rb

@@ -0,0 +1,48 @@
+module Danger
+  module RequestSources
+    class RequestSource
+      attr_accessor :ci_source, :environment, :scm, :host, :ignored_violations
+
+      def self.inherited(child_class)
+        available_request_sources.add child_class
+        super
+      end
+
+      def self.available_request_sources
+        @available_request_sources ||= Set.new
+      end
+
+      def initialize(_ci_source, _environment)
+        raise "Subclass and overwrite initialize"
+      end
+
+      def validates?
+        !!self.scm.origins.match(%r{#{Regexp.escape self.host}(:|/)(?<repo_slug>.+/.+?)(?:\.git)?$})
+      end
+
+      def scm
+        @scm ||= nil
+      end
+
+      def host
+        @host ||= nil
+      end
+
+      def ignored_violations
+        @ignored_violations ||= []
+      end
+
+      def update_pull_request!(_warnings: [], _errors: [], _messages: [], _markdowns: [])
+        raise "Subclass and overwrite update_pull_request!"
+      end
+
+      def setup_danger_branches
+        raise "Subclass and overwrite setup_danger_branches"
+      end
+
+      def fetch_details
+        raise "Subclass and overwrite initialize"
+      end
+    end
+  end
+end

data/lib/danger/scm_source/git_repo.rb

@@ -15,5 +15,9 @@ module Danger
     def exec(string)
       `git #{string}`.strip
     end
+
+    def origins
+      exec "remote show origin -n | grep \"Fetch URL\" | cut -d ':' -f 2-"
+    end
   end
 end

data/lib/danger/version.rb

@@ -1,4 +1,4 @@
 module Danger
-  VERSION = "0.8.1".freeze
+  VERSION = "0.8.2".freeze
   DESCRIPTION = "Automate your PR etiquette.".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: danger
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - Orta Therox
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-02 00:00:00.000000000 Z
+date: 2016-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide
@@ -273,6 +273,7 @@ files:
 - lib/danger/ci_source/jenkins.rb
 - lib/danger/ci_source/local_git_repo.rb
 - lib/danger/ci_source/semaphore.rb
+- lib/danger/ci_source/teamcity.rb
 - lib/danger/ci_source/travis.rb
 - lib/danger/ci_source/xcode_server.rb
 - lib/danger/commands/init.rb
@@ -295,6 +296,7 @@ files:
 - lib/danger/plugin_support/plugin.rb
 - lib/danger/plugin_support/plugin_parser.rb
 - lib/danger/request_source/github.rb
+- lib/danger/request_source/request_source.rb
 - lib/danger/scm_source/git_repo.rb
 - lib/danger/version.rb
 homepage: http://github.com/danger/danger