danger 8.0.3

data/lib/danger/danger_core/standard_error.rb

@@ -0,0 +1,143 @@
+require "claide"
+require "claide/informative_error"
+
+module Danger
+  # From below here - this entire file was taken verbatim for CocoaPods-Core.
+
+  #-------------------------------------------------------------------------#
+
+  # Wraps an exception raised by a DSL file in order to show to the user the
+  # contents of the line that raised the exception.
+  #
+  class DSLError < StandardError
+    # @return [String] the description that should be presented to the user.
+    #
+    attr_reader :description
+
+    # @return [String] the path of the dsl file that raised the exception.
+    #
+    attr_reader :dsl_path
+
+    # @return [Exception] the backtrace of the exception raised by the
+    #         evaluation of the dsl file.
+    #
+    attr_reader :backtrace
+
+    # @param [Exception] backtrace @see backtrace
+    # @param [String]    dsl_path  @see dsl_path
+    #
+    def initialize(description, dsl_path, backtrace, contents = nil)
+      @description = description
+      @dsl_path    = dsl_path
+      @backtrace   = backtrace
+      @contents    = contents
+    end
+
+    # @return [String] the contents of the DSL that cause the exception to
+    #         be raised.
+    #
+    def contents
+      @contents ||= begin
+        dsl_path && File.exist?(dsl_path) && File.read(dsl_path)
+      end
+    end
+
+    # The message of the exception reports the content of podspec for the
+    # line that generated the original exception.
+    #
+    # @example Output
+    #
+    #   Invalid podspec at `RestKit.podspec` - undefined method
+    #   `exclude_header_search_paths=' for #<Pod::Specification for
+    #   `RestKit/Network (0.9.3)`>
+    #
+    #       from spec-repos/master/RestKit/0.9.3/RestKit.podspec:36
+    #       -------------------------------------------
+    #           # because it would break: #import <CoreData/CoreData.h>
+    #    >      ns.exclude_header_search_paths = 'Code/RestKit.h'
+    #         end
+    #       -------------------------------------------
+    #
+    # @return [String] the message of the exception.
+    #
+    def message
+      @message ||= begin
+        description, stacktrace = parse.values_at(:description, :stacktrace)
+
+        msg = description
+        msg = msg.red if msg.respond_to?(:red)
+        msg << stacktrace if stacktrace
+        msg
+      end
+    end
+
+    def to_markdown
+      @markdown ||= begin
+        description, stacktrace = parse.values_at(:description, :stacktrace)
+
+        # Highlight failed method in markdown
+        description = description.tr("'", "`")
+
+        # Escape markdown brackets
+        description = description.gsub(/<|>/) { |bracket| "\\#{bracket}" }
+
+        md = "## Danger has errored"
+        md << "#{description}\n"
+        md << "```#{stacktrace}```" if stacktrace
+
+        Markdown.new(md, nil, nil)
+      end
+    end
+
+    private
+
+    def parse
+      result = {}
+
+      trace_line, description = parse_line_number_from_description
+      latest_version = Danger.danger_outdated?
+
+      result[:description] = "\n[!] #{description}"
+      result[:description] << upgrade_message(latest_version) if latest_version
+
+      return result unless backtrace && dsl_path && contents
+
+      trace_line = backtrace.find { |l| l.include?(dsl_path.to_s) } || trace_line
+      return result unless trace_line
+      line_numer = trace_line.split(":")[1].to_i - 1
+      return result unless line_numer
+
+      lines      = contents.lines
+      indent     = " #  "
+      indicator  = indent.tr("#", ">")
+      first_line = line_numer.zero?
+      last_line  = (line_numer == (lines.count - 1))
+
+      result[:stacktrace] = "\n"
+      result[:stacktrace] << "#{indent}from #{trace_line.gsub(/:in.*$/, '')}\n"
+      result[:stacktrace] << "#{indent}-------------------------------------------\n"
+      result[:stacktrace] << "#{indent}#{lines[line_numer - 1]}" unless first_line
+      result[:stacktrace] << "#{indicator}#{lines[line_numer]}"
+      result[:stacktrace] << "#{indent}#{lines[line_numer + 1]}" unless last_line
+      result[:stacktrace] << "\n" unless result[:stacktrace].end_with?("\n")
+      result[:stacktrace] << "#{indent}-------------------------------------------\n"
+
+      result
+    end
+
+    def parse_line_number_from_description
+      description = self.description
+      if dsl_path && description =~ /((#{Regexp.quote File.expand_path(dsl_path)}|#{Regexp.quote dsl_path.to_s}):\d+)/
+        trace_line = Regexp.last_match[1]
+        description = description.sub(/#{Regexp.quote trace_line}:\s*/, "")
+      end
+      [trace_line, description]
+    end
+
+    def upgrade_message(latest_version)
+      ". Updating the Danger gem might fix the issue. "\
+      "Your Danger version: #{Danger::VERSION}, "\
+      "latest Danger version: #{latest_version}\n"
+    end
+  end
+end

data/lib/danger/helpers/array_subclass.rb

@@ -0,0 +1,61 @@
+module Danger
+  module Helpers
+    module ArraySubclass
+      include Comparable
+
+      def initialize(array)
+        @__array__ = array
+      end
+
+      def kind_of?(compare_class)
+        return true if compare_class == self.class
+
+        dummy.kind_of?(compare_class)
+      end
+
+      def method_missing(name, *args, &block)
+        super unless __array__.respond_to?(name)
+
+        respond_to_method(name, *args, &block)
+      end
+
+      def respond_to_missing?(name)
+        __array__.respond_to?(name) || super
+      end
+
+      def to_a
+        __array__
+      end
+
+      def to_ary
+        __array__
+      end
+
+      def <=>(other)
+        return unless other.kind_of?(self.class)
+
+        __array__ <=> other.instance_variable_get(:@__array__)
+      end
+
+      private
+
+      attr_accessor :__array__
+
+      def dummy
+        Class.new(Array).new
+      end
+
+      def respond_to_method(name, *args, &block)
+        result = __array__.send(name, *args, &block)
+        return result unless result.kind_of?(Array)
+
+        if name =~ /!/
+          __array__ = result
+          self
+        else
+          self.class.new(result)
+        end
+      end
+    end
+  end
+end

data/lib/danger/helpers/comment.rb

@@ -0,0 +1,32 @@
+module Danger
+  class Comment
+    attr_reader :id, :body
+
+    def initialize(id, body, inline = nil)
+      @id = id
+      @body = body
+      @inline = inline
+    end
+
+    def self.from_github(comment)
+      self.new(comment["id"], comment["body"])
+    end
+
+    def self.from_gitlab(comment)
+      if comment.respond_to?(:id) && comment.respond_to?(:body)
+        type = comment.respond_to?(:type) ? comment.type : nil
+        self.new(comment.id, comment.body, type == "DiffNote")
+      else
+        self.new(comment["id"], comment["body"], comment["type"] == "DiffNote")
+      end
+    end
+
+    def generated_by_danger?(danger_id)
+      body.include?("\"generated_by_#{danger_id}\"")
+    end
+
+    def inline?
+      @inline.nil? ? body.include?("") : @inline
+    end
+  end
+end

data/lib/danger/helpers/comments_helper.rb

@@ -0,0 +1,178 @@
+require "kramdown"
+require "danger/helpers/comments_parsing_helper"
+require "danger/helpers/emoji_mapper"
+require "danger/helpers/find_max_num_violations"
+
+module Danger
+  module Helpers
+    module CommentsHelper
+      # This might be a bit weird, but table_kind_from_title is a shared dependency for
+      # parsing and generating. And rubocop was adamant about file size so...
+      include Danger::Helpers::CommentsParsingHelper
+
+      def markdown_parser(text)
+        Kramdown::Document.new(text, input: "GFM")
+      end
+
+      # !@group Extension points
+      # Produces a markdown link to the file the message points to
+      #
+      # request_source implementations are invited to override this method with their
+      # vendor specific link.
+      #
+      # @param [Violation or Markdown] message
+      # @param [Bool] Should hide any generated link created
+      #
+      # @return [String] The Markdown compatible link
+      def markdown_link_to_message(message, _)
+        "#{message.file}#L#{message.line}"
+      end
+
+      # !@group Extension points
+      # Determine whether two messages are equivalent
+      #
+      # request_source implementations are invited to override this method.
+      # This is mostly here to enable sources to detect when inlines change only in their
+      # commit hash and not in content per-se. since the link is implementation dependant
+      # so should be the comparison.
+      #
+      # @param [Violation or Markdown] m1
+      # @param [Violation or Markdown] m2
+      #
+      # @return [Boolean] whether they represent the same message
+      def messages_are_equivalent(m1, m2)
+        m1 == m2
+      end
+
+      def process_markdown(violation, hide_link = false)
+        message = violation.message
+        message = "#{markdown_link_to_message(violation, hide_link)}#{message}" if violation.file && violation.line
+
+        html = markdown_parser(message).to_html
+        # Remove the outer `<p>` and `</p>`.
+        html = html.strip.sub(%r{\A<p>(.*)</p>\z}m, '\1')
+        Violation.new(html, violation.sticky, violation.file, violation.line)
+      end
+
+      def table(name, emoji, violations, all_previous_violations, template: "github")
+        content = violations
+        content = content.map { |v| process_markdown(v) } unless ["bitbucket_server", "vsts"].include?(template)
+
+        kind = table_kind_from_title(name)
+        previous_violations = all_previous_violations[kind] || []
+        resolved_violations = previous_violations.reject do |pv|
+          content.count { |v| messages_are_equivalent(v, pv) } > 0
+        end
+
+        resolved_messages = resolved_violations.map(&:message).uniq
+        count = content.count
+
+        {
+          name: name,
+          emoji: emoji,
+          content: content,
+          resolved: resolved_messages,
+          count: count
+        }
+      end
+
+      def apply_template(tables: [], markdowns: [], danger_id: "danger", template: "github", request_source: template)
+        require "erb"
+
+        md_template = File.join(Danger.gem_path, "lib/danger/comment_generators/#{template}.md.erb")
+
+        # 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 = tables
+        @markdowns = markdowns.map(&:message)
+        @danger_id = danger_id
+        @emoji_mapper = EmojiMapper.new(request_source.sub("_inline",""))
+
+        return ERB.new(File.read(md_template), 0, "-").result(binding)
+      end
+
+      def generate_comment(warnings: [], errors: [], messages: [], markdowns: [], previous_violations: {}, danger_id: "danger", template: "github")
+        apply_template(
+          tables: [
+            table("Error", "no_entry_sign", errors, previous_violations, template: template),
+            table("Warning", "warning", warnings, previous_violations, template: template),
+            table("Message", "book", messages, previous_violations, template: template)
+          ],
+          markdowns: markdowns,
+          danger_id: danger_id,
+          template: template
+        )
+      end
+
+      # resolved is essentially reserved for future use - eventually we might
+      # have some nice generic resolved-thing going :)
+      def generate_message_group_comment(message_group:,
+                                         danger_id: "danger",
+                                         resolved: [],
+                                         template: "github")
+        # cheating a bit - I don't want to alter the apply_template API
+        # so just sneak around behind its back setting some instance variables
+        # to get them to show up in the template
+        @message_group = message_group
+        @resolved = resolved
+        request_source_name = template.sub("_message_group", "")
+
+
+        apply_template(danger_id: danger_id,
+                       markdowns: message_group.markdowns,
+                       template: template,
+                       request_source: request_source_name)
+          .sub(/\A\n*/, "")
+      end
+
+      def generate_inline_comment_body(emoji,
+                                       message,
+                                       danger_id: "danger",
+                                       resolved: false,
+                                       template: "github")
+        apply_template(
+          tables: [{ content: [message], resolved: resolved, emoji: emoji }],
+          danger_id: danger_id,
+          template: "#{template}_inline"
+        )
+      end
+
+      def generate_inline_markdown_body(markdown, danger_id: "danger", template: "github")
+        apply_template(
+          markdowns: [markdown],
+          danger_id: danger_id,
+          template: "#{template}_inline"
+        )
+      end
+
+      def generate_description(warnings: nil, errors: nil, template: "github")
+        emoji_mapper = EmojiMapper.new(template)
+        if errors.empty? && warnings.empty?
+          return "All green. #{random_compliment}"
+        else
+          message = "#{emoji_mapper.map('warning')} "
+          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
+
+      def random_compliment
+        ["Well done.", "Congrats.", "Woo!",
+         "Yay.", "Jolly good show.", "Good on 'ya.", "Nice work."].sample
+      end
+
+      private
+
+      def pluralize(string, count)
+        string.danger_pluralize(count)
+      end
+
+      def truncate(string)
+        max_message_length = 30
+        string.danger_truncate(max_message_length)
+      end
+    end
+  end
+end

data/lib/danger/helpers/comments_parsing_helper.rb

@@ -0,0 +1,70 @@
+module Danger
+  module Helpers
+    module CommentsParsingHelper
+      # !@group Extension points
+      # Produces a message-like from a row in a comment table
+      #
+      # @param [String] row
+      #        The content of the row in the table
+      #
+      # @return [Violation or Markdown] the extracted message
+      def parse_message_from_row(row)
+        Violation.new(row, true)
+      end
+
+      def parse_tables_from_comment(comment)
+        comment.split("</table>")
+      end
+
+      def violations_from_table(table)
+        row_regex = %r{<td data-sticky="true">(?:<del>)?(.*?)(?:</del>)?\s*</td>}im
+        table.scan(row_regex).flatten.map do |row|
+          parse_message_from_row(row.strip)
+        end
+      end
+
+      def parse_comment(comment)
+        tables = parse_tables_from_comment(comment)
+        violations = {}
+        tables.each do |table|
+          match = danger_table?(table)
+          next unless match
+          title = 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 table_kind_from_title(title)
+        if title =~ /error/i
+          :error
+        elsif title =~ /warning/i
+          :warning
+        elsif title =~ /message/i
+          :message
+        end
+      end
+
+      private
+
+      GITHUB_OLD_REGEX = %r{<th width="100%"(.*?)</th>}im
+      NEW_REGEX = %r{<th.*data-danger-table="true"(.*?)</th>}im
+
+      def danger_table?(table)
+        # The old GitHub specific method relied on
+        # the width of a `th` element to find the table
+        # title and determine if it was a danger table.
+        # The new method uses a more robust data-danger-table
+        # tag instead.
+        match = GITHUB_OLD_REGEX.match(table)
+        return match if match
+
+        return NEW_REGEX.match(table)
+      end
+    end
+  end
+end