danger 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8bf96232696dca35c69a7d338d10bf16af6917a2
-  data.tar.gz: e5e7f69f74d8419ce1c0f2c0df2725aa8b1874bf
+  metadata.gz: f405c58b164cfb051f33ce62eff96d6954ccedf8
+  data.tar.gz: e487a8349af60005ce0f63ec429cd8e73a561055
 SHA512:
-  metadata.gz: c69c8d1096130a36a0749c55a6f1e7e90d2df55ee0048bfdd13d13f83760071e66c7a65ad188b3c12a4d71613f75d982698e3e7776438bc1dc3ec227a94fd445
-  data.tar.gz: 16a07e94b369b7da16ab0bab5c4d9935c40442a3284c43985254811f92da77439d81dc8c19dbb6f4a9893f1ea89fcac6155736f9dd07f9b000b1457c1d2d31ad
+  metadata.gz: 3ce00623811798d3bf0cb0e77bc788bc0c99fac1045d00a33cf3c68b297983e669de41544bae3f8310257e3a34a3e8704aedb2d9f9fc2064e4f0a3e443cdcbc5
+  data.tar.gz: e0cdd1d536430c45226a3638ff0a2cd659db62a19e643c931230961e00967e7705321ec561c2afd276c0e73f6570d2335f7126b82017be95f5dcd0de18d9c906

data/README.md

@@ -38,7 +38,7 @@ bundle exec danger init
 bundle exec danger
 ```
 
-This will look at your `Dangerfile` and update the pull request accordingly. While you are setting up Danger, you may want to use: `--verbose` for more debug information. 
+This will look at your `Dangerfile` and update the pull request accordingly. While you are setting up Danger, you may want to use: `--verbose` for more debug information.
 
 ## What happens?
 
@@ -49,9 +49,9 @@ Danger runs at the end of a CI build, she will execute a `Dangerfile`. This file
    |   | Danger :no_entry_sign:
 -------------: | ------------- | ----
 :sparkles: | `lines_of_code` | The total amount of lines of code in the diff
-:pencil2:  | `files_modified` |  The list of files modified
-:ship: | `files_added` | The list of files added
-:recycle: | `files_removed` | The list of files removed
+:pencil2:  | `modified_files` |  The list of modified files
+:ship: | `added_files` | The list of added files
+:recycle: | `deleted_files` | The list of removed files
 :abc:  | `pr_title` | The title of the PR
 :book:  | `pr_body` | The body of the PR
 :busts_in_silhouette:  | `pr_author` | The author who submitted the PR
@@ -67,18 +67,18 @@ The `Dangerfile` is a ruby file, so really, you can do anything. However, at thi
 declared_trivial = pr_title.include? "#trivial"
 
 # Just to let people know
-warn("PR is classed as Work in Progress") if pr_title.include? "[WIP]"
+warn("PR is classed as Work in Progress", sticky: false) if pr_title.include? "[WIP]"
 ```
 
 #### Being cautious around specific files
 
 ``` ruby
 # Devs shouldn't ship changes to this file
-fail("Developer Specific file shouldn't be changed") if files_modified.include?("Artsy/View_Controllers/App_Navigation/ARTopMenuViewController+DeveloperExtras.m")
+fail("Developer Specific file shouldn't be changed", sticky: false) if modified_files.include?("Artsy/View_Controllers/App_Navigation/ARTopMenuViewController+DeveloperExtras.m")
 
 # Did you make analytics changes? Well you should also include a change to our analytics spec
-made_analytics_changes = files_modified.include?("/Artsy/App/ARAppDelegate+Analytics.m")
-made_analytics_specs_changes = files_modified.include?("/Artsy_Tests/Analytics_Tests/ARAppAnalyticsSpec.m")
+made_analytics_changes = modified_files.include?("/Artsy/App/ARAppDelegate+Analytics.m")
+made_analytics_specs_changes = modified_files.include?("/Artsy_Tests/Analytics_Tests/ARAppAnalyticsSpec.m")
 if made_analytics_changes
   fail("Analytics changes should have reflected specs changes") if !made_analytics_specs_changes
 
@@ -91,7 +91,7 @@ end
 #### Pinging people when a specific file has changed
 
 ```ruby
-message("@orta something changed in elan!") if files_modified.include? "/components/lib/variables/colors.json"
+message("@orta something changed in elan!") if modified_files.include? "/components/lib/variables/colors.json"
 ```
 
 #### Exposing aspects of CI logs into the PR discussion
@@ -102,6 +102,40 @@ snapshots_url = build_log.match(%r{https://eigen-ci.s3.amazonaws.com/\d+/index.h
 fail("There were [snapshot errors](#{snapshots_url})") if snapshots_url
 ```
 
+#### Available commands
+
+Command | Description
+------------- | ----
+`fail` | Causes the PR to fail and print out the error on the PR
+`warn` | Prints out a warning to the PR, but still enables the merge button
+`message` | Show neutral messages on the PR
+`markdown` | Print raw markdown below the summary tables on the PR
+
+## Plugins
+
+Danger was built with a platform in mind: It can be used with any kind of software project and allows you to write your own action to have structured source code.
+
+In your `Dangerfile` you can import local or remote actions using
+
+```ruby
+import "./danger_plugins/work_in_progress_warning"
+# or
+import "https://raw.githubusercontent.com/danger/danger/master/danger_plugins/work_in_progress_warning.rb"
+
+# Call those actions using
+work_in_progress_warning
+
+custom_plugin(variable: "value")
+```
+
+To create a new plugin run
+
+```
+danger new_plugin
+```
+
+This will generate a new Ruby file which you can modify to fit your needs. 
+
 ## Support
 
 Danger currently is supported on Travis CI, Circle CI, BuildKite and Jenkins. These work via environment variables, so it's easy to extend to include your own.
@@ -132,6 +166,15 @@ You can tell Danger to ignore a specific warning or error by commenting on the P
 > Danger: Ignore "Developer Specific file shouldn't be changed"
 ```
 
+## Sticky
+
+Danger can keep its history if a warning/error/message is marked as *sticky*. When the violation is resolved,
+Danger will update the comment to cross it out. If you don't want this behavior, just use `sticky: false`.
+
+```ruby
+fail("PR needs labels", sticky: false) if pr_labels.empty?
+```
+
 ## 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.
@@ -141,6 +184,8 @@ Here are some real-world Dangerfiles: [artsy/eigen](https://github.com/artsy/eig
 
 ## License, Contributor's Guidelines and Code of Conduct
 
+[Join our Slack Group](https://danger-slack.herokuapp.com/)
+
 > 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.
 
 > This project subscribes to the [Moya Contributors Guidelines](https://github.com/Moya/contributors) which TLDR: means we give out push access easily and often.

data/lib/assets/PluginTemplate.rb.template

@@ -0,0 +1,20 @@
+module Danger
+  class Dangerfile
+    module DSL
+      class [[CLASS_NAME]] < Plugin
+        def run(parameter1: nil, parameter2: nil)
+          if (pr_body + pr_title).include?("WIP")
+            warn "Pull Request is Work in Progress"
+          end
+        end
+
+        def self.description
+          [
+            "Describe what this plugin does",
+            "and how the user can use it"
+          ].join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/danger/available_values.rb

@@ -8,9 +8,9 @@ module Danger
     def self.scm
       [
         :lines_of_code,
-        :files_modified,
-        :files_deleted,
-        :files_added,
+        :modified_files,
+        :deleted_files,
+        :added_files,
         :deletions,
         :insertions
       ]

data/lib/danger/ci_source/local_git_repo.rb

@@ -1,6 +1,6 @@
 # For more info see: https://github.com/schacon/ruby-git
 
-require 'grit'
+require 'git'
 require 'uri'
 
 module Danger
@@ -13,36 +13,38 @@ module Danger
       end
 
       def git
-        @git ||= Grit::Git.new(".")
+        @git ||= GitRepo.new
       end
 
       def run_git(command)
-        binary = Grit::Git.git_binary
-        git.sh "#{binary} #{command}"
+        git.exec command
       end
 
-      def initialize(*)
+      def initialize(env = {})
+        github_host = env["DANGER_GITHUB_HOST"] || "github.com"
+
         # get the remote URL
         remote = run_git "remote show origin -n | grep \"Fetch URL\" | cut -d ':' -f 2-"
         if remote
-          remote_url_matches = remote.first.chomp.match(%r{github\.com(:|/)(?<repo_slug>.+/.+?)(?:\.git)?$})
+          remote_url_matches = remote.match(%r{#{Regexp.escape github_host}(:|/)(?<repo_slug>.+/.+?)(?:\.git)?$})
           if !remote_url_matches.nil? and remote_url_matches["repo_slug"]
             self.repo_slug = remote_url_matches["repo_slug"]
           else
-            puts "Danger local requires a repository hosted on github."
+            puts "Danger local requires a repository hosted on GitHub.com or GitHub Enterprise."
           end
         end
 
         # get the most recent PR merge
-        logs = run_git "log --since='2 weeks ago' --merges --oneline | grep \"Merge pull request\" | head -n 1"
-        pr_merge = logs[0].strip
-        if pr_merge
-          self.pull_request_id = pr_merge.match("#[0-9]*")[0].delete("#")
-          sha = pr_merge.split(" ")[0]
-          parents = run_git "rev-list --parents -n 1 #{sha}"
-          self.base_commit = parents[0].strip.split(" ")[0]
-          self.head_commit = parents[0].strip.split(" ")[1]
+        pr_merge = run_git "log --since='2 weeks ago' --merges --oneline | grep \"Merge pull request\" | head -n 1".strip
+        if pr_merge.to_s.empty?
+          raise "No recent pull requests found for this repo, danger requires at least one PR for the local mode"
         end
+
+        self.pull_request_id = pr_merge.match("#([0-9]+)")[1]
+        sha = pr_merge.split(" ")[0]
+        parents = run_git("rev-list --parents -n 1 #{sha}").strip.split(" ")
+        self.base_commit = parents[0]
+        self.head_commit = parents[1]
       end
     end
   end

data/lib/danger/commands/init_helpers/interviewer.rb

@@ -56,7 +56,7 @@ module Danger
         show_prompt
         answer = STDIN.gets.chomp
 
-        break if answer.length > 0
+        break if answer.empty?
 
         print "\nYou need to provide an answer."
       end

data/lib/danger/commands/local.rb

@@ -22,12 +22,14 @@ module Danger
       dm.env = EnvironmentManager.new(ENV)
 
       source = dm.env.ci_source
-      unless source.repo_slug
-        puts "danger local".red " failed because it only works with GitHub projects at the moment. Sorry."
+      if source.nil? or source.repo_slug.empty?
+        puts "danger local failed because it only works with GitHub projects at the moment. Sorry.".red
         exit 0
       end
 
-      puts "Running your Dangerfile against this PR - https://github.com/#{source.repo_slug}/pull/#{source.pull_request_id}"
+      gh = dm.env.request_source
+
+      puts "Running your Dangerfile against this PR - https://#{gh.github_host}/#{source.repo_slug}/pull/#{source.pull_request_id}"
 
       if verbose != true
         puts "Turning on --verbose"
@@ -36,7 +38,6 @@ module Danger
 
       puts ""
 
-      gh = GitHub.new(dm.env.ci_source, ENV)
       # We can use tokenless here, as it's running on someone's computer
       # and is IP locked, as opposed  to on the CI.
       gh.support_tokenless_auth = true
@@ -47,7 +48,8 @@ module Danger
       dm.env.scm = GitRepo.new
 
       dm.env.scm.diff_for_folder(".", from: dm.env.ci_source.base_commit, to: dm.env.ci_source.head_commit)
-      dm.parse Pathname.new(@dangerfile_path)
+      dm.parse(Pathname.new(@dangerfile_path))
+      dm.print_results
     end
   end
 end

data/lib/danger/commands/new_plugin.rb

@@ -0,0 +1,43 @@
+module Danger
+  class NewPlugin < Runner
+    self.summary = 'Generate a new danger plugin.'
+    self.command = 'new_plugin'
+
+    def initialize(argv)
+      super
+    end
+
+    def validate!
+      super
+    end
+
+    def run
+      require 'fileutils'
+
+      puts "Must be lower case, and use a '_' between words. Do not use '.'".green
+      puts "examples: 'number_of_emojis', 'ensure_pr_title_contains_keyword'".green
+      puts "Name of your new plugin: "
+      name = STDIN.gets.strip
+
+      dir = Danger.gem_path
+      content = File.read(File.join(dir, "lib", "assets", "PluginTemplate.rb.template"))
+      content.gsub!("[[CLASS_NAME]]", name.danger_class)
+
+      plugins_path = "danger_plugins"
+      FileUtils.mkdir_p("plugins_path") unless File.directory?(plugins_path)
+
+      output_path = File.join(plugins_path, "#{name}.rb")
+      raise "File '#{output_path}' already exists!" if File.exist?(output_path)
+      File.write(output_path, content)
+
+      puts ""
+      puts "Successfully created new plugin at path '#{output_path}'".green
+      puts "Add this to your `Dangerfile` to use it:"
+      puts ""
+      puts "import \"#{output_path.gsub('.rb', '')}\"".blue
+      puts "#{name}(parameter1: 123, parameter2: \"Club Mate\")".blue
+      puts ""
+      puts "Enjoy ✨"
+    end
+  end
+end

data/lib/danger/commands/runner.rb

@@ -2,6 +2,7 @@ module Danger
   class Runner < CLAide::Command
     require 'danger/commands/init'
     require 'danger/commands/local'
+    require 'danger/commands/new_plugin'
 
     self.summary = 'Run the Dangerfile.'
     self.command = 'danger'
@@ -33,22 +34,27 @@ module Danger
       dm.verbose = verbose
       dm.env = EnvironmentManager.new(ENV)
       return unless dm.env.ci_source # if it's not a PR
-      dm.env.fill_environment_vars
 
-      gh = dm.env.request_source
-      ci_base = @base || gh.base_commit
-      ci_head = @head || gh.head_commit
+      dm.env.fill_environment_vars
+      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
       dm.env.scm.diff_for_folder(".", from: ci_base, to: ci_head)
 
       dm.parse Pathname.new(@dangerfile_path)
 
       post_results(dm)
+
+      dm.env.clean_up
+
+      dm.print_results
     end
 
     def post_results(dm)
       gh = dm.env.request_source
-      gh.update_pull_request!(warnings: dm.warnings, errors: dm.errors, messages: dm.messages)
+      gh.update_pull_request!(warnings: dm.warnings, errors: dm.errors, messages: dm.messages, markdowns: dm.markdowns)
     end
   end
 end

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

@@ -1,24 +1,41 @@
 <% @tables.each do |table| %>
-  <% if table[:content].any? %>
+  <% if table[:content].any? || table[:resolved].any? %>
 <table>
   <thead>
     <tr>
       <th width="50"></th>
-      <th width="100%"><%= table[:content].count %> <%= table[:name] %><%= "s" unless table[:content].count == 1 %></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 %>
+      </th>
      </tr>
   </thead>
   <tbody>
-    <% table[:content].each do |message| -%>
+    <% table[:content].each do |violation| -%>
     <tr>
       <td>:<%= table[:emoji] %>:</td>
-      <td><%= message %></td>
+      <td data-sticky="<%= violation.sticky %>"><%= violation.message %></td>
     </tr>
     <% end %>
+    <% table[:resolved].each do |message| -%>
+      <tr>
+        <td>:white_check_mark:</td>
+        <td data-sticky="true"><del><%= message %></del></td>
+      </tr>
+    <% end %>
   </tbody>
 </table>
   <% end %>
 <% end %>
 
+<% @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" data-base-commit="<%= @base_commit %>" data-head-commit="<%= @head_commit %>" >
   Generated by :no_entry_sign: <a href="https://github.com/danger/danger/">danger</a>
 </p>

data/lib/danger/core_ext/string.rb

@@ -0,0 +1,13 @@
+class String
+  def danger_class
+    split('_').collect!(&:capitalize).join
+  end
+
+  def danger_underscore
+    self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+      gsub(/([a-z\d])([A-Z])/, '\1_\2').
+      tr("-", "_").
+      downcase
+  end
+end

data/lib/danger/dangerfile.rb

@@ -7,7 +7,7 @@ module Danger
   class Dangerfile
     include Danger::Dangerfile::DSL
 
-    attr_accessor :env, :warnings, :errors, :messages, :verbose
+    attr_accessor :env, :warnings, :errors, :messages, :markdowns, :verbose
 
     # @return [Pathname] the path where the Dangerfile was loaded from. It is nil
     #         if the Dangerfile was generated programmatically.
@@ -26,8 +26,8 @@ module Danger
       rows = []
 
       AvailableValues.all.each do |key|
-        next if key == :pr_body
         value = self.send(key)
+        value = value.scan(/.{,80}/).to_a.each(&:strip!).join("\n") if key == :pr_body
 
         # So that we either have one value per row
         # or we have [] for an empty array
@@ -40,8 +40,8 @@ module Danger
       rows << ["SCM", env.scm.class]
       rows << ["Source", env.ci_source.class]
       rows << ["Requests", env.request_source.class]
-      rows << ["Base Commit", env.request_source.base_commit]
-      rows << ["Head Commit", env.request_source.head_commit]
+      rows << ["Base Commit", env.meta_info_for_base]
+      rows << ["Head Commit", env.meta_info_for_head]
 
       params = {}
       params[:rows] = rows.each { |current| current[0] = current[0].yellow }
@@ -49,8 +49,6 @@ module Danger
 
       puts ""
       puts Terminal::Table.new(params)
-      puts "PR Body:"
-      puts self.pr_body.cyan
       puts ""
     end
 
@@ -92,5 +90,34 @@ module Danger
         # rubocop:enable Lint/RescueException
       end
     end
+
+    def print_results
+      return if (self.errors + self.warnings + self.messages + self.markdowns).count == 0
+
+      puts ""
+      puts "danger results:"
+      [:errors, :warnings, :messages].each do |current|
+        params = {}
+        params[:rows] = self.send(current).collect { |a| [a.message] }
+        next unless params[:rows].count > 0
+        params[:title] = case current
+                         when :errors
+                           current.to_s.capitalize.red
+                         when :warnings
+                           current.to_s.capitalize.yellow
+                         else
+                           current.to_s.capitalize
+                         end
+
+        puts ""
+        puts Terminal::Table.new(params)
+        puts ""
+      end
+
+      puts "Markdown: ".green if self.markdowns.count > 0
+      self.markdowns.each do |current_markdown|
+        puts current_markdown
+      end
+    end
   end
 end

data/lib/danger/dangerfile_dsl.rb

@@ -1,3 +1,5 @@
+require 'danger/violation'
+
 module Danger
   class Dangerfile
     module DSL
@@ -13,12 +15,47 @@ module Danger
         self.warnings = []
         self.errors = []
         self.messages = []
-        load_plugins
+        self.markdowns = []
+
+        load_default_plugins
+      end
+
+      def import(path)
+        raise "`import` requires a string" unless path.kind_of?(String)
+        path += ".rb" unless path.end_with?(".rb")
+
+        if path.start_with?("http")
+          import_url(path)
+        else
+          import_local(path)
+        end
       end
 
-      def load_plugins
-        Dir['./lib/danger/plugins/*.rb'].each do |file|
-          require file
+      # Download a remote plugin and use it locally
+      #
+      # @param    [String] url
+      #           https URL to the Ruby file to use
+      def import_url(url)
+        raise "URL is not https, for security reasons `danger` only supports encrypted requests" unless url.start_with?("https://")
+
+        require 'tmpdir'
+        require 'faraday'
+        content = Faraday.get(url)
+        Dir.mktmpdir do |dir|
+          path = File.join(dir, "temporary_remote_action.rb")
+          File.write(path, content.body)
+          import_local(path)
+        end
+      end
+
+      # Import one or more local plugins
+      #
+      # @param    [String] path
+      #           The path to the file to import
+      #           Can also be a pattern (./**/*plugin.rb)
+      def import_local(path)
+        Dir[path].each do |file|
+          require File.expand_path(file) # without the expand_path it would fail if the path doesn't start with ./
         end
       end
 
@@ -30,9 +67,11 @@ module Danger
       #
       # @param    [String] message
       #           The message to present to the user
-      def fail(message)
+      # @param    [Boolean] sticky
+      #           Whether the message should be kept after it was fixed
+      def fail(message, sticky: true)
         return if should_ignore_violation(message)
-        self.errors << message
+        self.errors << Violation.new(message, sticky)
         puts "Raising error '#{message}'"
       end
 
@@ -40,9 +79,11 @@ module Danger
       #
       # @param    [String] message
       #           The message to present to the user
-      def warn(message)
+      # @param    [Boolean] sticky
+      #           Whether the message should be kept after it was fixed
+      def warn(message, sticky: true)
         return if should_ignore_violation(message)
-        self.warnings << message
+        self.warnings << Violation.new(message, sticky)
         puts "Printing warning '#{message}'"
       end
 
@@ -50,26 +91,61 @@ module Danger
       #
       # @param    [String] message
       #           The message to present to the user
-      def message(message)
-        self.messages << message
+      # @param    [Boolean] sticky
+      #           Whether the message should be kept after it was fixed
+      def message(message, sticky: true)
+        self.messages << Violation.new(message, sticky)
         puts "Printing message '#{message}'"
       end
 
+      # Print markdown to below the table
+      #
+      # @param    [String] message
+      #           The markdown based message to be printed below the table
+      def markdown(message)
+        self.markdowns << message
+        puts "Printing markdown #{message}"
+      end
+
       # When an undefined method is called, we check to see if it's something
       # that either the `scm` or the `request_source` can handle.
       # This opens us up to letting those object extend themselves naturally.
-      def method_missing(method_sym, *_arguments, &_block)
+      # This will also look for plugins
+      def method_missing(method_sym, *arguments, &_block)
+        # SCM Source
         if AvailableValues.scm.include?(method_sym)
-          # SCM Source
           return env.scm.send(method_sym)
         end
 
+        # Request Source
         if AvailableValues.request_source.include?(method_sym)
-          # Request Source
           return env.request_source.send(method_sym)
         end
 
-        raise "Unknown method '#{method_sym}', please check out the documentation for available variables".red
+        # Plugins
+        class_name = method_sym.to_s.danger_class
+        if Danger::Dangerfile::DSL.const_defined?(class_name)
+          plugin_ref = Danger::Dangerfile::DSL.const_get(class_name)
+          if plugin_ref < Plugin
+            plugin_ref.new(self).run(*arguments)
+          else
+            raise "'#{method_sym}' is not a valid danger plugin".red
+          end
+        else
+          raise "Unknown method '#{method_sym}', please check out the documentation for available plugins".red
+        end
+      end
+
+      private
+
+      def load_default_plugins
+        Dir["./lib/danger/plugins/*.rb"].each do |file|
+          require File.expand_path(file)
+        end
+
+        Dir["./danger_plugins/*.rb"].each do |file|
+          require File.expand_path(file)
+        end
       end
     end
   end

data/lib/danger/environment_manager.rb

@@ -32,5 +32,40 @@ module Danger
 
       self.scm = GitRepo.new # For now
     end
+
+    def ensure_danger_branches_are_setup
+      # As this currently just works with GitHub, we can use a github specific feature here:
+      pull_id = ci_source.pull_request_id
+      test_branch = request_source.base_commit
+
+      # Next, we want to ensure that we have a version of the current branch that at a know 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 ( e.g. the most recent commit that will be merged. )
+      scm.exec "fetch origin +refs/pull/#{pull_id}/merge:#{danger_head_branch}"
+    end
+
+    def clean_up
+      [danger_base_branch, danger_base_branch].each do |branch|
+        scm.exec "branch -d #{branch}"
+      end
+    end
+
+    def meta_info_for_base
+      scm.exec("--no-pager log #{danger_base_branch} -n1")
+    end
+
+    def meta_info_for_head
+      scm.exec("--no-pager log #{danger_head_branch} -n1")
+    end
+
+    def danger_head_branch
+      "danger_head"
+    end
+
+    def danger_base_branch
+      "danger_base"
+    end
   end
 end

data/lib/danger/plugins/plugin.rb

@@ -0,0 +1,26 @@
+module Danger
+  class Dangerfile
+    module DSL
+      class Plugin
+        def initialize(dsl)
+          @dsl = dsl
+        end
+
+        # Since we have a reference to the DSL containing all the information
+        # We need to redirect the self calls to the DSL
+        def method_missing(method_sym, *arguments, &_block)
+          return @dsl.send(method_sym, *arguments) if @dsl.respond_to?(method_sym)
+          return @dsl.method_missing(method_sym, *arguments)
+        end
+
+        def run
+          raise "run method must be implemented"
+        end
+
+        def self.description
+          "Add plugin description here"
+        end
+      end
+    end
+  end
+end

data/lib/danger/plugins/protect_files.rb

@@ -1,21 +1,32 @@
 module Danger
   class Dangerfile
     module DSL
-      # Protect a file from being changed. This can
-      # be used in combination with some kind of
-      # permission check if a user is inside the org
-      def protect_files(path: nil, message: nil, fail_build: true)
-        broken_rule = false
-        Dir.glob(path) do |current|
-          broken_rule = true if self.env.scm.files_modified.include?(current)
-        end
+      class ProtectFiles < Plugin
+        def run(path: nil, message: nil, fail_build: true)
+          raise "You have to provide a message" if message.to_s.length == 0
+          raise "You have to provide a path" if path.to_s.length == 0
+
+          broken_rule = false
+
+          Dir.glob(path) do |current|
+            broken_rule = true if self.env.scm.modified_files.include?(current)
+          end
 
-        return unless broken_rule
+          return unless broken_rule
+
+          if fail_build
+            @dsl.errors << message
+          else
+            @dsl.warnings << message
+          end
+        end
 
-        if fail_build
-          self.errors << message
-        else
-          self.messages << message
+        def self.description
+          [
+            "Protect a file from being changed. This can",
+            "be used in combination with some kind of",
+            "permission check if a user is inside the org"
+          ].join(" ")
         end
       end
     end

data/lib/danger/request_sources/github.rb

@@ -4,7 +4,7 @@ require 'redcarpet'
 
 module Danger
   class GitHub
-    attr_accessor :ci_source, :pr_json, :issue_json, :environment, :base_commit, :head_commit, :support_tokenless_auth, :ignored_violations
+    attr_accessor :ci_source, :pr_json, :issue_json, :environment, :base_commit, :head_commit, :support_tokenless_auth, :ignored_violations, :github_host
 
     def initialize(ci_source, environment)
       self.ci_source = ci_source
@@ -12,19 +12,23 @@ module Danger
       self.support_tokenless_auth = false
 
       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"]
+      end
     end
 
     def client
-      token = @environment["DANGER_GITHUB_API_TOKEN"]
-      raise "No API given, please provide one using `DANGER_GITHUB_API_TOKEN`" if !token && !support_tokenless_auth
+      raise "No API given, please provide one using `DANGER_GITHUB_API_TOKEN`" if !@token && !support_tokenless_auth
 
       @client ||= Octokit::Client.new(
-        access_token: token
+        access_token: @token
       )
     end
 
     def markdown_parser
-      @markdown_parser ||= Redcarpet::Markdown.new(Redcarpet::Render::HTML)
+      @markdown_parser ||= Redcarpet::Markdown.new(Redcarpet::Render::HTML, no_intra_emphasis: true)
     end
 
     def fetch_details
@@ -52,6 +56,10 @@ module Danger
       self.pr_json[:head][:sha]
     end
 
+    def branch_for_merge
+      self.pr_json[:base][:ref]
+    end
+
     def pr_title
       self.pr_json[:title].to_s
     end
@@ -69,16 +77,28 @@ module Danger
     end
 
     # Sending data to GitHub
-    def update_pull_request!(warnings: nil, errors: nil, messages: nil)
+    def update_pull_request!(warnings: [], errors: [], messages: [], markdowns: [])
       comment_result = {}
 
-      if (warnings + errors + messages).empty?
+      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 }
+
+      if editable_issues.empty?
+        previous_violations = {}
+      else
+        comment = editable_issues.first[:body]
+        previous_violations = parse_comment(comment)
+      end
+
+      if previous_violations.empty? && (warnings + errors + messages + markdowns).empty?
         # Just remove the comment, if there's nothing to say.
         delete_old_comments!
       else
-        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 }
-        body = generate_comment(warnings: warnings, errors: errors, messages: messages)
+        body = generate_comment(warnings: warnings,
+                                  errors: errors,
+                                messages: messages,
+                               markdowns: markdowns,
+                     previous_violations: previous_violations)
 
         if editable_issues.empty?
           comment_result = client.add_comment(ci_source.repo_slug, ci_source.pull_request_id, body)
@@ -100,7 +120,7 @@ module Danger
       message = generate_github_description(warnings: warnings, errors: errors)
       client.create_status(ci_source.repo_slug, latest_pr_commit_ref, status, {
         description: message,
-        context: "KrauseFx/danger",
+        context: "danger/danger",
         target_url: details_url
       })
     rescue
@@ -125,11 +145,15 @@ module Danger
       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?
-        compliment = ["Well done.", "Congrats.", "Woo!",
-                      "Yay.", "Jolly good show.", "Good on 'ya.", "Nice work."]
-        return "All green. #{compliment.sample}"
+        return "All green. #{random_compliment}"
       else
         message = "⚠ "
         message += "#{errors.count} Error#{errors.count == 1 ? '' : 's'}. " unless errors.empty?
@@ -139,7 +163,7 @@ module Danger
       end
     end
 
-    def generate_comment(warnings: [], errors: [], messages: [])
+    def generate_comment(warnings: [], errors: [], messages: [], markdowns: [], previous_violations: {})
       require 'erb'
 
       md_template = File.join(Danger.gem_path, "lib/danger/comment_generators/github.md.erb")
@@ -147,18 +171,64 @@ module Danger
       # 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 = [
-        { name: "Error", emoji: "no_entry_sign", content: errors.map { |s| process_markdown(s) } },
-        { name: "Warning", emoji: "warning", content: warnings.map { |s| process_markdown(s) } },
-        { name: "Message", emoji: "book", content: messages.map { |s| process_markdown(s) } }
+        table("Error", "no_entry_sign", errors, previous_violations),
+        table("Warning", "warning", warnings, previous_violations),
+        table("Message", "book", messages, previous_violations)
       ]
+      @markdowns = markdowns
+
       return ERB.new(File.read(md_template), 0, "-").result(binding)
     end
 
-    def process_markdown(string)
-      html = markdown_parser.render(string)
+    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
+
+    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
+
+        violations[kind] = violations_from_table(table)
+      end
+
+      violations.reject { |_, v| v.empty? }
+    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 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>$})
-      return match.captures.first unless match.nil?
-      html
+      message = match.nil? ? html : match.captures.first
+      Violation.new(message, violation.sticky)
     end
   end
 end

data/lib/danger/scm_source/file_list.rb

@@ -0,0 +1,12 @@
+module Danger
+  class FileList < Array
+    # Information about pattern: http://ruby-doc.org/core-2.2.0/File.html#method-c-fnmatch
+    # e.g. "**/something.*" for any file called something with any extension
+    def include?(pattern)
+      self.each do |current|
+        return true if File.fnmatch(pattern, current)
+      end
+      return false
+    end
+  end
+end

data/lib/danger/scm_source/git_repo.rb

@@ -1,38 +1,42 @@
 # For more info see: https://github.com/schacon/ruby-git
 
-require 'grit'
+require 'git'
 
 module Danger
   class GitRepo
     attr_accessor :diff
 
     def diff_for_folder(folder, from: "master", to: 'HEAD')
-      repo = Grit::Repo.new folder
+      repo = Git.open folder
       self.diff = repo.diff(from, to)
     end
 
-    def files_added
-      @diff.select(&:new_file).map(&:b_path)
+    def exec(string)
+      `git #{string}`.strip
     end
 
-    def files_deleted
-      @diff.select(&:deleted_file).map(&:a_path)
+    def added_files
+      Danger::FileList.new(@diff.select { |diff| diff.type == "new" }.map(&:path))
     end
 
-    def files_modified
-      @diff.reject(&:deleted_file).reject(&:new_file).map(&:a_path)
+    def deleted_files
+      Danger::FileList.new(@diff.select { |diff| diff.type == "deleted" }.map(&:path))
+    end
+
+    def modified_files
+      Danger::FileList.new(@diff.stats[:files].keys)
     end
 
     def lines_of_code
-      @diff.map(&:diff).map(&:lines).flatten.count { |l| l.start_with?("+") || l.start_with?("-") }
+      @diff.lines
     end
 
     def deletions
-      @diff.map(&:diff).map(&:lines).flatten.count { |l| l.start_with?("-") }
+      @diff.deletions
     end
 
     def insertions
-      @diff.map(&:diff).map(&:lines).flatten.count { |l| l.start_with?("+") }
+      @diff.insertions
     end
   end
 end

data/lib/danger/standard_error.rb

@@ -79,7 +79,7 @@ module Danger
         lines      = contents.lines
         indent     = ' #  '
         indicator  = indent.tr('#', '>')
-        first_line = (line_numer.zero?)
+        first_line = line_numer.zero?
         last_line  = (line_numer == (lines.count - 1))
 
         m << "\n"

data/lib/danger/version.rb

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

data/lib/danger/violation.rb

@@ -0,0 +1,10 @@
+module Danger
+  class Violation
+    attr_accessor :message, :sticky
+
+    def initialize(message, sticky)
+      self.message = message
+      self.sticky = sticky
+    end
+  end
+end

data/lib/danger.rb

@@ -3,6 +3,7 @@ require "danger/dangerfile"
 require "danger/environment_manager"
 require "danger/commands/runner"
 require "danger/available_values"
+require "danger/core_ext/string"
 
 require "claide"
 require "colored"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: danger
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Orta Therox
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-10 00:00:00.000000000 Z
+date: 2016-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide
@@ -26,19 +26,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: grit
+  name: git
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: colored
   requirement: !ruby/object:Gem::Requirement
@@ -185,14 +185,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.35.1
+        version: 0.38.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.35.1
+        version: 0.38.0
 description: Create a Dangerfile to introspect your pull request in CI, makes it easy
   to enforce social conventions like changelogs and tests.
 email:
@@ -207,6 +207,7 @@ files:
 - README.md
 - bin/danger
 - lib/assets/DangerfileTemplate
+- lib/assets/PluginTemplate.rb.template
 - lib/danger.rb
 - lib/danger/available_values.rb
 - lib/danger/ci_source/buildkite.rb
@@ -219,16 +220,21 @@ files:
 - lib/danger/commands/init.rb
 - lib/danger/commands/init_helpers/interviewer.rb
 - lib/danger/commands/local.rb
+- lib/danger/commands/new_plugin.rb
 - lib/danger/commands/runner.rb
 - lib/danger/comment_generators/github.md.erb
+- lib/danger/core_ext/string.rb
 - lib/danger/dangerfile.rb
 - lib/danger/dangerfile_dsl.rb
 - lib/danger/environment_manager.rb
+- lib/danger/plugins/plugin.rb
 - lib/danger/plugins/protect_files.rb
 - lib/danger/request_sources/github.rb
+- lib/danger/scm_source/file_list.rb
 - lib/danger/scm_source/git_repo.rb
 - lib/danger/standard_error.rb
 - lib/danger/version.rb
+- lib/danger/violation.rb
 homepage: http://github.com/danger/danger
 licenses:
 - MIT
@@ -249,9 +255,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Automate your PR etiquette.
 test_files: []
-has_rdoc: