danger 0.5.1 → 0.7.0

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,14 +15,63 @@ module Danger
         self.warnings = []
         self.errors = []
         self.messages = []
+        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
+
+      # 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
+
+      def should_ignore_violation(message)
+        env.request_source.ignored_violations.include? message
       end
 
       # Declares a CI blocking error
       #
       # @param    [String] message
       #           The message to present to the user
-      def fail(message)
-        self.errors << 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 << Violation.new(message, sticky)
         puts "Raising error '#{message}'"
       end
 
@@ -28,8 +79,11 @@ module Danger
       #
       # @param    [String] message
       #           The message to present to the user
-      def warn(message)
-        self.warnings << 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 << Violation.new(message, sticky)
         puts "Printing warning '#{message}'"
       end
 
@@ -37,28 +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)
-        unless AvailableValues.all.include?(method_sym)
-          raise "Unknown method '#{method_sym}', please check out the documentation for available variables".red
-        end
-
+      # 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
+
+        # 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

@@ -0,0 +1,34 @@
+module Danger
+  class Dangerfile
+    module DSL
+      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
+
+          if fail_build
+            @dsl.errors << message
+          else
+            @dsl.warnings << message
+          end
+        end
+
+        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
+  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
+    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,24 +12,35 @@ 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
       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 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
 
     def fetch_issue_details(pr_json)
@@ -45,16 +56,20 @@ 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]
+      self.pr_json[:title].to_s
     end
 
     def pr_body
-      self.pr_json[:body]
+      self.pr_json[:body].to_s
     end
 
     def pr_author
-      self.pr_json[:user][:login]
+      self.pr_json[:user][:login].to_s
     end
 
     def pr_labels
@@ -62,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)
@@ -93,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
@@ -118,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?
@@ -132,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")
@@ -140,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.5.1"
-  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"