danger-additional-logging 0.0.1

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

@@ -0,0 +1,275 @@
+require "danger/plugin_support/plugin"
+
+module Danger
+  # Handles interacting with GitLab inside a Dangerfile. Provides a few functions which wrap `mr_json` and also
+  # through a few standard functions to simplify your code.
+  #
+  # @example Warn when an MR is classed as work in progress.
+  #
+  #          warn "MR is classed as Work in Progress" if gitlab.mr_title.include? "[WIP]"
+  #
+  # @example Declare a MR to be simple to avoid specific Danger rules.
+  #
+  #          declared_trivial = (gitlab.mr_title + gitlab.mr_body).include?("#trivial")
+  #
+  # @example Ensure that labels have been applied to the MR.
+  #
+  #          failure "Please add labels to this MR" if gitlab.mr_labels.empty?
+  #
+  # @example Ensure that all MRs have an assignee.
+  #
+  #          warn "This MR does not have any assignees yet." unless gitlab.mr_json["assignee"]
+  #
+  # @example Ensure there is a summary for a MR.
+  #
+  #          failure "Please provide a summary in the Merge Request description" if gitlab.mr_body.length < 5
+  #
+  # @example Only accept MRs to the develop branch.
+  #
+  #          failure "Please re-submit this MR to develop, we may have already fixed your issue." if gitlab.branch_for_merge != "develop"
+  #
+  # @example Note when MRs don't reference a milestone, make the warning stick around on subsequent runs
+  #
+  #          has_milestone = gitlab.mr_json["milestone"] != nil
+  #          warn("This MR does not refer to an existing milestone", sticky: true) unless has_milestone
+  #
+  # @example Note when a MR cannot be manually merged
+  #
+  #          can_merge = gitlab.mr_json["mergeable"]
+  #          warn("This MR cannot be merged yet.") unless can_merge
+  #
+  # @example Highlight when a celebrity makes a merge request.
+  #
+  #          message "Welcome, Danger." if gitlab.mr_author == "dangermcshane"
+  #
+  # @example Send a message with links to a collection of specific files.
+  #
+  #          if git.modified_files.include? "config/*.js"
+  #            config_files = git.modified_files.select { |path| path.include? "config/" }
+  #            message "This MR changes #{ gitlab.html_link(config_files) }"
+  #          end
+  #
+  # @example Highlight with a clickable link if a Package.json is changed.
+  #
+  #         warn "#{gitlab.html_link("Package.json")} was edited." if git.modified_files.include? "Package.json"
+  #
+  # @example Select a random group member as assignee if no assignee is selected
+  #
+  #         if gitlab.mr_json["assignee"].nil?
+  #           reviewer = gitlab.api.group_members(gitlab.api.merge_request_approvals(project_id, mr_id).to_hash["approver_groups"].first["group"]["id"]).sample
+  #           if gitlab.api.group_members(gitlab.api.merge_request_approvals(project_id, mr_id).to_hash["approver_groups"].first["group"]["id"]).length > 1
+  #             while reviewer.to_hash["id"] == gitlab.mr_json["author"]["id"] do
+  #               reviewer = gitlab.api.group_members(gitlab.api.merge_request_approvals(project_id, mr_id).to_hash["approver_groups"].first["group"]["id"]).sample
+  #             end
+  #           end
+  #           message "Reviewer roulete rolled for: #{reviewer.to_hash['name']} (@#{reviewer.to_hash['username']})"
+  #           gitlab.api.update_merge_request(project_id, mr_id, { assignee_id: reviewer.to_hash["id"] })
+  #         end
+  #
+  #
+  # @see  danger/danger
+  # @tags core, gitlab
+  #
+  class DangerfileGitLabPlugin < Plugin
+    # So that this init can fail.
+    def self.new(dangerfile)
+      return nil if dangerfile.env.request_source.class != Danger::RequestSources::GitLab
+
+      super
+    end
+
+    # The instance name used in the Dangerfile
+    # @return [String]
+    #
+    def self.instance_name
+      "gitlab"
+    end
+
+    def initialize(dangerfile)
+      super(dangerfile)
+
+      @gitlab = dangerfile.env.request_source
+    end
+
+    # @!group MR Metadata
+    # The title of the Merge Request
+    # @return [String]
+    #
+    def mr_title
+      @gitlab.mr_json.title.to_s
+    end
+
+    # @!group MR Metadata
+    # The body text of the Merge Request
+    # @return [String]
+    #
+    def mr_body
+      @gitlab.mr_json.description.to_s
+    end
+
+    # @!group MR Metadata
+    # The username of the author of the Merge Request
+    # @return [String]
+    #
+    def mr_author
+      @gitlab.mr_json.author.username.to_s
+    end
+
+    # @!group MR Metadata
+    # The labels assigned to the Merge Request
+    # @return [String]
+    #
+    def mr_labels
+      @gitlab.mr_json.labels
+    end
+
+    # @!group MR Content
+    # The unified diff produced by GitLab for this MR
+    # see [Unified diff](https://en.wikipedia.org/wiki/Diff_utility#Unified_format)
+    # @return [String]
+    #
+    def mr_diff
+      @gitlab.mr_diff
+    end
+
+    # @!group MR Changes
+    # The array of changes
+    # @return [Array<Gitlab::ObjectifiedHash>]
+    #
+    def mr_changes
+      @gitlab.mr_changes.changes
+    end
+
+    # @!group MR Closes issues
+    # The array of issues that this MR closes
+    # @return [Array<Gitlab::ObjectifiedHash>]
+    #
+    def mr_closes_issues
+      @gitlab.mr_closes_issues
+    end
+
+    # @!group MR Commit Metadata
+    # The branch to which the MR is going to be merged into
+    # @deprecated Please use {#branch_for_base} instead
+    # @return [String]
+    #
+    def branch_for_merge
+      branch_for_base
+    end
+
+    # @!group MR Commit Metadata
+    # The branch to which the MR is going to be merged into.
+    # @return [String]
+    #
+    def branch_for_base
+      @gitlab.mr_json.target_branch
+    end
+
+    # @!group MR Commit Metadata
+    # The branch to which the MR is going to be merged from.
+    # @return [String]
+    #
+    def branch_for_head
+      @gitlab.mr_json.source_branch
+    end
+
+    # @!group MR Commit Metadata
+    # The base commit to which the MR is going to be merged as a parent
+    # @return [String]
+    #
+    def base_commit
+      @gitlab.mr_json.diff_refs.base_sha
+    end
+
+    # @!group MR Commit Metadata
+    # The head commit to which the MR is requesting to be merged from
+    # @return [String]
+    #
+    def head_commit
+      @gitlab.mr_json.diff_refs.head_sha
+    end
+
+    # @!group GitLab Misc
+    # The hash that represents the MR's JSON. See documentation for the
+    # structure [here](http://docs.gitlab.com/ce/api/merge_requests.html#get-single-mr)
+    # @return [Hash]
+    #
+    def mr_json
+      @gitlab.mr_json.to_hash
+    end
+
+    # @!group GitLab Misc
+    # Provides access to the GitLab API client used inside Danger. Making
+    # it easy to use the GitLab API inside a Dangerfile. See the gitlab
+    # gem's [documentation](http://www.rubydoc.info/gems/gitlab/Gitlab/Client)
+    # for accessible methods.
+    # @return [GitLab::Client]
+    #
+    def api
+      @gitlab.client
+    end
+
+    # @!group GitLab Misc
+    # Returns the web_url of the source project.
+    # @return [String]
+    #
+    def repository_web_url
+      @repository_web_url ||= begin
+        project = api.project(mr_json["source_project_id"])
+        project.web_url
+      end
+    end
+
+    # @!group GitLab Misc
+    # Returns a list of HTML anchors for a file, or files in the head repository. An example would be:
+    # `<a href='https://gitlab.com/artsy/eigen/blob/561827e46167077b5e53515b4b7349b8ae04610b/file.txt'>file.txt</a>`. It returns a string of multiple anchors if passed an array.
+    # @param    [String or Array<String>] paths
+    #           A list of strings to convert to gitlab anchors
+    # @param    [Bool] full_path
+    #           Shows the full path as the link's text, defaults to `true`.
+    #
+    # @return [String]
+    #
+    def html_link(paths, full_path: true)
+      paths = [paths] unless paths.kind_of?(Array)
+      commit = head_commit
+
+      paths = paths.map do |path|
+        url_path = path.start_with?("/") ? path : "/#{path}"
+        text = full_path ? path : File.basename(path)
+        create_link("#{repository_web_url}/blob/#{commit}#{url_path}", text)
+      end
+
+      return paths.first if paths.count < 2
+
+      paths.first(paths.count - 1).join(", ") + " & " + paths.last
+    end
+
+    # @!group Gitlab Misc
+    # Use to ignore inline messages which lay outside a diff's range, thereby not posting the comment.
+    # You can set hash to change behavior per each kinds. (ex. `{warning: true, error: false}`)
+    # @param    [Bool] or [Hash<Symbol, Bool>] dismiss
+    #           Ignore out of range inline messages, defaults to `true`
+    #
+    # @return   [void]
+    def dismiss_out_of_range_messages(dismiss = true)
+      if dismiss.kind_of?(Hash)
+        @gitlab.dismiss_out_of_range_messages = dismiss
+      elsif dismiss.kind_of?(TrueClass)
+        @gitlab.dismiss_out_of_range_messages = true
+      elsif dismiss.kind_of?(FalseClass)
+        @gitlab.dismiss_out_of_range_messages = false
+      end
+    end
+
+    %i(title body author labels json diff).each do |suffix|
+      alias_method "pr_#{suffix}".to_sym, "mr_#{suffix}".to_sym
+    end
+
+    private
+
+    def create_link(href, text)
+      "<a href='#{href}'>#{text}</a>"
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "danger/plugin_support/plugin"
+
+# Danger
+module Danger
+  # Handles interacting with local only plugin inside a Dangerfile.
+  # It is support plugin for dry_run command and does not expose any methods.
+  # But you can still use other plugins like git
+  #
+  # @example Check that added lines contains agreed form of words
+  #
+  #       git.diff.each do |chunk|
+  #         chunk.patch.lines.grep(/^\+/).each do |added_line|
+  #           if added_line.gsub!(/(?<cancel>cancel)(?<rest>[^l[[:space:]][[:punct:]]]+)/i, '>>\k<cancel>-l-\k<rest><<')
+  #             fail "Single 'L' for cancellation-alike words in '#{added_line}'"
+  #           end
+  #         end
+  #       end
+  #
+  # @see  danger/danger
+  # @tags core, local_only
+  #
+  class DangerfileLocalOnlyPlugin < Plugin
+    # So that this init can fail.
+    def self.new(dangerfile)
+      return nil if dangerfile.env.request_source.class != Danger::RequestSources::LocalOnly
+
+      super
+    end
+
+    def initialize(dangerfile)
+      super(dangerfile)
+
+      @local_repo = dangerfile.env.request_source
+    end
+
+    # The instance name used in the Dangerfile
+    # @return [String]
+    #
+    def self.instance_name
+      "local_repo"
+    end
+  end
+end

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

@@ -0,0 +1,220 @@
+require "danger/danger_core/messages/violation"
+require "danger/danger_core/messages/markdown"
+require "danger/plugin_support/plugin"
+
+module Danger
+  # Provides the feedback mechanism for Danger. Danger can keep track of
+  # messages, warnings, failure and post arbitrary markdown into a comment.
+  #
+  # The message within which Danger communicates back is amended on each run in a session.
+  #
+  # Each of `message`, `warn` and `fail` have a `sticky` flag, `false` by default, which
+  # when `true` means that the message will be crossed out instead of being removed.
+  # If it's not called again on subsequent runs.
+  #
+  # Each of `message`, `warn`, `fail` and `markdown` support multiple passed arguments
+  # @example
+  #
+  # message 'Hello', 'World', file: "Dangerfile", line: 1
+  # warn ['This', 'is', 'warning'], file: "Dangerfile", line: 1
+  # failure 'Ooops', 'bad bad error', sticky: false
+  # markdown '# And', '# Even', '# Markdown', file: "Dangerfile", line: 1
+  #
+  # By default, using `failure` would fail the corresponding build. Either via an API call, or
+  # via the return value for the danger command. Older code examples use `fail` which is an alias
+  # of `failure`, but the default Rubocop settings would have an issue with it.
+  #
+  # You can optionally add `file` and `line` to provide inline feedback on a PR in GitHub, note that
+  # only feedback inside the PR's diff will show up inline. Others will appear inside the main comment.
+  #
+  # It is possible to have Danger ignore specific warnings or errors by writing `Danger: Ignore "[warning/error text]"`.
+  #
+  # Sidenote: Messaging is the only plugin which adds functions to the root of the Dangerfile.
+  #
+  # @example Failing a build
+  #
+  #          failure "This build didn't pass tests"
+  #          failure "Ooops!", "Something bad happened"
+  #          failure ["This is example", "with array"]
+  #
+  # @example Failing a build, and note that on subsequent runs
+  #
+  #          failure("This build didn't pass tests", sticky: true)
+  #
+  # @example Passing a warning
+  #
+  #          warn "This build didn't pass linting"
+  #          warn "Hm...", "This is not really good"
+  #          warn ["Multiple warnings", "via array"]
+  #
+  # @example Displaying a markdown table
+  #
+  #          message = "### Proselint found issues\n\n"
+  #          message << "Line | Message | Severity |\n"
+  #          message << "| --- | ----- | ----- |\n"
+  #          message << "20 | No documentation | Error \n"
+  #          markdown message
+  #
+  #          markdown "### First issue", "### Second issue"
+  #          markdown ["### First issue", "### Second issue"]
+  #
+  # @example Adding an inline warning to a file
+  #
+  #          warn("You shouldn't use puts in your Dangerfile", file: "Dangerfile", line: 10)
+  #
+  #
+  # @see  danger/danger
+  # @tags core, messaging
+  #
+
+  class DangerfileMessagingPlugin < Plugin
+    def initialize(dangerfile)
+      super(dangerfile)
+
+      @warnings = []
+      @errors = []
+      @messages = []
+      @markdowns = []
+    end
+
+    # The instance name used in the Dangerfile
+    # @return [String]
+    #
+    def self.instance_name
+      "messaging"
+    end
+
+    # @!group Core
+    # Print markdown to below the table
+    #
+    # @param    [String, Array<String>] message
+    #           The markdown based message to be printed below the table
+    # @param    [String] file
+    #           Optional. Path to the file that the message is for.
+    # @param    [String] line
+    #           Optional. The line in the file to present the message in.
+    # @return   [void]
+    #
+    def markdown(*markdowns, **options)
+      file = options.fetch(:file, nil)
+      line = options.fetch(:line, nil)
+
+      markdowns.flatten.each do |markdown|
+        @markdowns << Markdown.new(markdown, file, line)
+      end
+    end
+
+    # @!group Core
+    # Print out a generate message on the PR
+    #
+    # @param    [String, Array<String>] message
+    #           The message to present to the user
+    # @param    [Boolean] sticky
+    #           Whether the message should be kept after it was fixed,
+    #           defaults to `false`.
+    # @param    [String] file
+    #           Optional. Path to the file that the message is for.
+    # @param    [String] line
+    #           Optional. The line in the file to present the message in.
+    # @return   [void]
+    #
+    def message(*messages, **options)
+      sticky = options.fetch(:sticky, false)
+      file = options.fetch(:file, nil)
+      line = options.fetch(:line, nil)
+
+      messages.flatten.each do |message|
+        @messages << Violation.new(message, sticky, file, line, type: :message) if message
+      end
+    end
+
+    # @!group Core
+    # Specifies a problem, but not critical
+    #
+    # @param    [String, Array<String>] message
+    #           The message to present to the user
+    # @param    [Boolean] sticky
+    #           Whether the message should be kept after it was fixed,
+    #           defaults to `false`.
+    # @param    [String] file
+    #           Optional. Path to the file that the message is for.
+    # @param    [String] line
+    #           Optional. The line in the file to present the message in.
+    # @return   [void]
+    #
+    def warn(*warnings, **options)
+      sticky = options.fetch(:sticky, false)
+      file = options.fetch(:file, nil)
+      line = options.fetch(:line, nil)
+
+      warnings.flatten.each do |warning|
+        next if should_ignore_violation(warning)
+
+        @warnings << Violation.new(warning, sticky, file, line, type: :warning) if warning
+      end
+    end
+
+    # @!group Core
+    # Declares a CI blocking error
+    #
+    # @param    [String, Array<String>] message
+    #           The message to present to the user
+    # @param    [Boolean] sticky
+    #           Whether the message should be kept after it was fixed,
+    #           defaults to `false`.
+    # @param    [String] file
+    #           Optional. Path to the file that the message is for.
+    # @param    [String] line
+    #           Optional. The line in the file to present the message in.
+    # @return   [void]
+    #
+    def fail(*failures, **options)
+      sticky = options.fetch(:sticky, false)
+      file = options.fetch(:file, nil)
+      line = options.fetch(:line, nil)
+
+      failures.flatten.each do |failure|
+        next if should_ignore_violation(failure)
+
+        @errors << Violation.new(failure, sticky, file, line, type: :error) if failure
+      end
+    end
+
+    alias failure fail
+
+    # @!group Reporting
+    # A list of all messages passed to Danger, including
+    # the markdowns.
+    #
+    # @visibility hidden
+    # @return     [Hash]
+    def status_report
+      {
+        errors: @errors.map(&:message).clone.freeze,
+        warnings: @warnings.map(&:message).clone.freeze,
+        messages: @messages.map(&:message).clone.freeze,
+        markdowns: @markdowns.clone.freeze
+      }
+    end
+
+    # @!group Reporting
+    # A list of all violations passed to Danger, we don't
+    # anticipate users of Danger needing to use this.
+    #
+    # @visibility hidden
+    # @return     [Hash]
+    def violation_report
+      {
+        errors: @errors.clone.freeze,
+        warnings: @warnings.clone.freeze,
+        messages: @messages.clone.freeze
+      }
+    end
+
+    private
+
+    def should_ignore_violation(message)
+      env.request_source.ignored_violations.include? message
+    end
+  end
+end