danger-additional-logging 0.0.1

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

@@ -0,0 +1,274 @@
+require "danger/plugin_support/plugin"
+
+module Danger
+  # A way to interact with Danger herself. Offering APIs to import plugins,
+  # and Dangerfiles from multiple sources.
+  #
+  # @example Import a plugin available over HTTP
+  #
+  #          device_grid = "https://raw.githubusercontent.com/fastlane/fastlane/master/danger-device_grid/lib/device_grid/plugin.rb"
+  #          danger.import_plugin(device_grid)
+  #
+  # @example Import from a local file reference
+  #
+  #          danger.import_plugin("danger/plugins/watch_plugin.rb")
+  #
+  # @example Import all files inside a folder
+  #
+  #          danger.import_plugin("danger/plugins/*.rb")
+  #
+  # @example Run a Dangerfile from inside a sub-folder
+  #
+  #          danger.import_dangerfile(path: "path/to/Dangerfile")
+  #
+  # @example Run a Dangerfile from inside a gem
+  #
+  #          danger.import_dangerfile(gem: "ruby-grape-danger")
+  #
+  # @example Run a Dangerfile from inside a repo
+  #
+  #          danger.import_dangerfile(gitlab_project_id: 1345)
+  #
+  # @example Run a Dangerfile from inside a repo branch and path
+  #
+  #          danger.import_dangerfile(github: "ruby-grape/danger", branch: "custom", path: "path/to/Dangerfile")
+  #
+  # @example Import a plugin available over HTTP
+  #
+  #          custom_url = "https://custom.bitbucket.com/project-name/Dangerfile?raw"
+  #          danger.import_dangerfile(url: custom_url)
+  #
+  # @see  danger/danger
+  # @tags core, plugins
+
+  class DangerfileDangerPlugin < Plugin
+    # The instance name used in the Dangerfile
+    # @return [String]
+    #
+    def self.instance_name
+      "danger"
+    end
+
+    # @!group Danger
+    # Download a local or remote plugin and make it usable inside the Dangerfile.
+    #
+    # @param    [String] path_or_url
+    #           a local path or a https URL to the Ruby file to import
+    #           a danger plugin from.
+    # @return   [void]
+    #
+    def import_plugin(path_or_url)
+      raise "`import_plugin` requires a string" unless path_or_url.kind_of?(String)
+
+      if path_or_url.start_with?("http")
+        import_url(path_or_url)
+      else
+        import_local(path_or_url)
+      end
+    end
+
+    # @!group Danger
+    # Import a Dangerfile.
+    #
+    # @param    [Hash] opts
+    # @option opts [String] :github GitHub repo
+    # @option opts [String] :gitlab GitLab repo
+    # @option opts [String] :gem Gem name
+    # @option opts [String] :ref The name of branch, tag or commit
+    # @option opts [String] :branch Alias of :ref
+    # @option opts [String] :path Path to Dangerfile
+    # @return   [void]
+    def import_dangerfile(opts)
+      if opts.kind_of?(String)
+        warn "Use `import_dangerfile(github: '#{opts}')` instead of `import_dangerfile '#{opts}'`."
+        import_dangerfile_from_github(opts)
+      elsif opts.kind_of?(Hash)
+        if opts.key?(:github)
+          import_dangerfile_from_github(opts[:github], opts[:ref] || opts[:branch], opts[:path])
+        elsif opts.key?(:gitlab)
+          import_dangerfile_from_gitlab(opts[:gitlab], opts[:ref] || opts[:branch], opts[:path])
+        elsif opts.key?(:path)
+          import_dangerfile_from_path(opts[:path])
+        elsif opts.key?(:gem)
+          import_dangerfile_from_gem(opts[:gem])
+        elsif opts.key?(:url)
+          import_dangerfile_from_url(opts[:url])
+        else
+          raise "`import` requires a Hash with either :github, :gitlab, :gem, :path or :url"
+        end
+      else
+        raise "`import` requires a Hash"
+      end
+    end
+
+    # @!group Danger
+    # Returns the name of the current SCM Provider being used.
+    # @return [Symbol] The name of the SCM Provider used for the active repository.
+    def scm_provider
+      return :unknown unless env.request_source
+
+      case env.request_source
+      when Danger::RequestSources::GitHub
+        :github
+      when Danger::RequestSources::GitLab
+        :gitlab
+      when Danger::RequestSources::BitbucketServer
+        :bitbucket_server
+      when Danger::RequestSources::BitbucketCloud
+        :bitbucket_cloud
+      when Danger::RequestSources::VSTS
+        :vsts
+      else
+        :unknown
+      end
+    end
+
+    private
+
+    # @!group Danger
+    # Read and execute a local Dangerfile.
+    #
+    # @param    [String] path
+    #           A path to a Dangerfile.
+    # @return   [void]
+    #
+    def import_dangerfile_from_path(path)
+      raise "`import_dangerfile_from_path` requires a string" unless path.kind_of?(String)
+
+      local_path = File.file?(path) ? path : File.join(path, "Dangerfile")
+      @dangerfile.parse(Pathname.new(local_path))
+    end
+
+    # @!group Danger
+    # Read and execute a Dangerfile from a gem.
+    #
+    # @param    [String] name
+    #           The name of the gem that contains a Dangerfile.
+    # @return   [void]
+    #
+    def import_dangerfile_from_gem(name)
+      raise "`import_dangerfile_from_gem` requires a string" unless name.kind_of?(String)
+
+      spec = Gem::Specification.find_by_name(name)
+      import_dangerfile_from_path(spec.gem_dir)
+    rescue Gem::MissingSpecError
+      raise "`import_dangerfile_from_gem` tried to load `#{name}` and failed, did you forget to include it in your Gemfile?"
+    end
+
+    # @!group Danger
+    # Download and execute a remote Dangerfile.
+    #
+    # @param    [String] slug
+    #           A slug that represents the repo where the Dangerfile is.
+    # @param    [String] branch
+    #           A branch from repo where the Dangerfile is.
+    # @param    [String] path
+    #           The path at the repo where Dangerfile is.
+    # @return   [void]
+    #
+    def import_dangerfile_from_github(slug, branch = nil, path = nil)
+      raise "`import_dangerfile_from_github` requires a string" unless slug.kind_of?(String)
+
+      org, repo = slug.split("/")
+      download_url = env.request_source.file_url(organisation: org, repository: repo, branch: branch, path: path || "Dangerfile")
+      local_path = download(download_url)
+      @dangerfile.parse(Pathname.new(local_path))
+    end
+
+    # @!group Danger
+    # Download and execute a remote Dangerfile.
+    #
+    # @param    [Int] slug_or_project_id
+    #           The slug or id of the repo where the Dangerfile is.
+    # @param    [String] branch
+    #           A branch from repo where the Dangerfile is.
+    # @param    [String] path
+    #           The path at the repo where Dangerfile is.
+    # @return   [void]
+    #
+    def import_dangerfile_from_gitlab(slug_or_project_id, branch = nil, path = nil)
+      download_url = env.request_source.file_url(repository: slug_or_project_id, branch: branch, path: path || "Dangerfile")
+      local_path = download(download_url)
+      @dangerfile.parse(Pathname.new(local_path))
+    end
+
+    # @!group Danger
+    # Download and execute a remote Dangerfile.
+    #
+    # @param    [String] url
+    #           A https url where the Dangerfile is.
+    # @return   [void]
+    #
+    def import_dangerfile_from_url(url)
+      raise "`import_dangerfile_from_url` requires a string" unless url.kind_of?(String)
+
+      local_path = download(url)
+      @dangerfile.parse(Pathname.new(local_path))
+    end
+
+    # @!group Plugins
+    # Download a local or remote plugin or Dangerfile.
+    # This method will not import the file for you, use plugin.import instead
+    #
+    # @param    [String] path_or_url
+    #           a local path or a https URL to the Ruby file to import
+    #           a danger plugin from.
+    # @return [String] The path to the downloaded Ruby file
+    #
+    def download(path_or_url)
+      raise "`download` requires a string" unless path_or_url.kind_of?(String)
+      raise "URL is not https, for security reasons `danger` only supports encrypted requests" if URI.parse(path_or_url).scheme != "https"
+
+      require "tmpdir"
+      require "faraday"
+
+      @http_client ||= Faraday.new do |b|
+        b.adapter :net_http
+      end
+      content = @http_client.get(path_or_url)
+
+      path = File.join(Dir.mktmpdir, "temporary_danger.rb")
+      File.write(path, content.body)
+      return path
+    end
+
+    # @!group Plugins
+    # Download a remote plugin and use it locally.
+    #
+    # @param    [String] url
+    #           https URL to the Ruby file to use
+    # @return [void]
+    def import_url(url)
+      path = download(url)
+      import_local(path)
+    end
+
+    # @!group Plugins
+    # Import one or more local plugins.
+    #
+    # @param    [String] path
+    #           The path to the file to import
+    #           Can also be a pattern (./**/*plugin.rb)
+    # @return [void]
+    def import_local(path)
+      Dir[path].each do |file|
+        validate_file_contains_plugin!(file) do
+          # Without the expand_path it would fail if the path doesn't start with ./
+          require File.expand_path(file)
+        end
+
+        refresh_plugins
+      end
+    end
+
+    # Raises an error when the given block does not register a plugin.
+    def validate_file_contains_plugin!(file)
+      plugin_count_was = Danger::Plugin.all_plugins.length
+      yield
+
+      if Danger::Plugin.all_plugins.length == plugin_count_was
+        raise("#{file} doesn't contain any valid danger plugins.")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+require "danger/plugin_support/plugin"
+require "danger/core_ext/file_list"
+
+# Danger
+module Danger
+  # Handles interacting with git inside a Dangerfile. Providing access to files that have changed, and useful statistics. Also provides
+  # access to the commits in the form of [Git::Log](https://github.com/schacon/ruby-git/blob/master/lib/git/log.rb) objects.
+  #
+  # @example Do something to all new and edited markdown files
+  #
+  #          markdowns = (git.added_files + git.modified_files)
+  #          do_something markdowns.select{ |file| file.end_with? "md" }
+  #
+  # @example Don't allow a file to be deleted
+  #
+  #          deleted = git.deleted_files.include? "my/favourite.file"
+  #          failure "Don't delete my precious" if deleted
+  #
+  # @example Fail really big diffs
+  #
+  #          failure "We cannot handle the scale of this PR" if git.lines_of_code > 50_000
+  #
+  # @example Warn when there are merge commits in the diff
+  #
+  #          if git.commits.any? { |c| c.parents.count > 1 }
+  #            warn 'Please rebase to get rid of the merge commits in this PR'
+  #          end
+  #
+  # @example Warn when somebody tries to add nokogiri to the project
+  #
+  #          diff = git.diff_for_file("Gemfile.lock")
+  #          if diff && diff.patch =~ "nokogiri"
+  #            warn 'Please do not add nokogiri to the project. Thank you.'
+  #          end
+  #
+  # @see  danger/danger
+  # @tags core, git
+
+  class DangerfileGitPlugin < Plugin
+    # The instance name used in the Dangerfile
+    # @return [String]
+    #
+    def self.instance_name
+      "git"
+    end
+
+    def initialize(dangerfile)
+      super(dangerfile)
+      raise unless dangerfile.env.scm.class == Danger::GitRepo # rubocop:disable Style/ClassEqualityComparison
+
+      @git = dangerfile.env.scm
+    end
+
+    # @!group Git Files
+    # Paths for files that were added during the diff
+    # @return [FileList<String>] an [Array] subclass
+    #
+    def added_files
+      Danger::FileList.new(@git.diff.select { |diff| diff.type == "new" }.map(&:path))
+    end
+
+    # @!group Git Files
+    # Paths for files that were removed during the diff
+    # @return [FileList<String>] an [Array] subclass
+    #
+    def deleted_files
+      Danger::FileList.new(@git.diff.select { |diff| diff.type == "deleted" }.map(&:path))
+    end
+
+    # @!group Git Files
+    # Paths for files that changed during the diff
+    # @return [FileList<String>] an [Array] subclass
+    #
+    def modified_files
+      Danger::FileList.new(@git.diff.select { |diff| diff.type == "modified" }.map(&:path))
+    end
+
+    # @!group Git Metadata
+    # List of renamed files
+    # @return [Array<Hash>] with keys `:before` and `:after`
+    #
+    def renamed_files
+      @git.renamed_files
+    end
+
+    # @!group Git Metadata
+    # Whole diff
+    # @return [Git::Diff] from the gem `git`
+    #
+    def diff
+      @git.diff
+    end
+
+    # @!group Git Metadata
+    # The overall lines of code added/removed in the diff
+    # @return [Fixnum]
+    #
+    def lines_of_code
+      @git.diff.lines
+    end
+
+    # @!group Git Metadata
+    # The overall lines of code removed in the diff
+    # @return [Fixnum]
+    #
+    def deletions
+      @git.diff.deletions
+    end
+
+    # @!group Git Metadata
+    # The overall lines of code added in the diff
+    # @return [Fixnum]
+    #
+    def insertions
+      @git.diff.insertions
+    end
+
+    # @!group Git Metadata
+    # The log of commits inside the diff
+    # @return [Git::Log] from the gem `git`
+    #
+    def commits
+      @git.log.to_a
+    end
+
+    # @!group Git Metadata
+    # Details for a specific file in this diff
+    # @return [Git::Diff::DiffFile] from the gem `git`
+    #
+    def diff_for_file(file)
+      (added_files + modified_files + deleted_files).include?(file) ? @git.diff[file] : nil
+    end
+
+    # @!group Git Metadata
+    # Statistics for a specific file in this diff
+    # @return [Hash] with keys `:insertions`, `:deletions` giving line counts, and `:before`, `:after` giving file contents, or nil if the file has no changes or does not exist
+    #
+    def info_for_file(file)
+      return nil unless modified_files.include?(file) || added_files.include?(file) || deleted_files.include?(file)
+
+      stats = @git.diff.stats[:files][file]
+      diff = @git.diff[file]
+      {
+        insertions: stats[:insertions],
+        deletions: stats[:deletions],
+        before: added_files.include?(file) || deleted_files.include?(file) ? nil : diff.blob(:src).contents,
+        after: added_files.include?(file) || deleted_files.include?(file) ? nil : diff.blob(:dst).contents
+      }
+    end
+
+    # @!group Git Metadata
+    # List of remote tags
+    # @return [String]
+    #
+    def tags
+      @git.tags.each_line
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+require "danger/plugin_support/plugin"
+
+module Danger
+  # Handles interacting with GitHub inside a Dangerfile. Provides a few functions which wrap `pr_json` and also
+  # through a few standard functions to simplify your code.
+  #
+  # @example Warn when a PR is classed as work in progress
+  #
+  #          warn "PR is classed as Work in Progress" if github.pr_title.include? "[WIP]"
+  #
+  # @example Declare a PR to be simple to avoid specific Danger rules
+  #
+  #          declared_trivial = (github.pr_title + github.pr_body).include?("#trivial")
+  #
+  # @example Ensure that labels have been used on the PR
+  #
+  #          failure "Please add labels to this PR" if github.pr_labels.empty?
+  #
+  # @example Check if a user is in a specific GitHub org, and message them if so
+  #
+  #          unless github.api.organization_member?('danger', github.pr_author)
+  #            message "@#{github.pr_author} is not a contributor yet, would you like to join the Danger org?"
+  #          end
+  #
+  # @example Ensure there is a summary for a PR
+  #
+  #          failure "Please provide a summary in the Pull Request description" if github.pr_body.length < 5
+  #
+  # @example Only accept PRs to the develop branch
+  #
+  #          failure "Please re-submit this PR to develop, we may have already fixed your issue." if github.branch_for_base != "develop"
+  #
+  # @example Note when PRs don't reference a milestone, which goes away when it does
+  #
+  #          has_milestone = github.pr_json["milestone"] != nil
+  #          warn("This PR does not refer to an existing milestone", sticky: false) unless has_milestone
+  #
+  # @example Note when a PR cannot be manually merged, which goes away when you can
+  #
+  #          can_merge = github.pr_json["mergeable"]
+  #          warn("This PR cannot be merged yet.", sticky: false) unless can_merge
+  #
+  # @example Highlight when a celebrity makes a pull request
+  #
+  #          message "Welcome, Danger." if github.pr_author == "dangermcshane"
+  #
+  # @example Ensure that all PRs have an assignee
+  #
+  #          warn "This PR does not have any assignees yet." unless github.pr_json["assignee"]
+  #
+  # @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 PR changes #{ github.html_link(config_files) }"
+  #          end
+  #
+  # @example Highlight with a clickable link if a Package.json is changed
+  #
+  #         warn "#{github.html_link("Package.json")} was edited." if git.modified_files.include? "Package.json"
+  #
+  # @example Note an issue with a particular line on a file using the #L[num] syntax, e.g. `#L23`
+  #
+  #         linter_json = `my_linter lint "file"`
+  #         results = JSON.parse linter_json
+  #         unless results.empty?
+  #           file, line, warning = result.first
+  #           warn "#{github.html_link("#{file}#L#{line}")} has linter issue: #{warning}."
+  #         end
+  #
+  #
+  # @see  danger/danger
+  # @tags core, github
+  #
+  class DangerfileGitHubPlugin < Plugin
+    # So that this init can fail.
+    def self.new(dangerfile)
+      return nil if dangerfile.env.request_source.class != Danger::RequestSources::GitHub
+
+      super
+    end
+
+    def initialize(dangerfile)
+      super(dangerfile)
+
+      @github = dangerfile.env.request_source
+    end
+
+    # The instance name used in the Dangerfile
+    # @return [String]
+    #
+    def self.instance_name
+      "github"
+    end
+
+    # @!group PR Review
+    #
+    # In Beta. Provides access to creating a GitHub Review instead of a typical GitHub comment.
+    #
+    # To use you announce the start of your review, and the end via the `start` and `submit` functions,
+    # for example:
+    #
+    # github.review.start
+    # github.review.fail(message)
+    # github.review.warn(message)
+    # github.review.message(message)
+    # github.review.markdown(message)
+    # github.review.submit
+    #
+    # @return [ReviewDSL]
+    def review
+      @github.review
+    end
+
+    # @!group PR Metadata
+    # The title of the Pull Request.
+    # @return [String]
+    #
+    def pr_title
+      @github.pr_json["title"].to_s
+    end
+
+    # @!group PR Metadata
+    # The body text of the Pull Request.
+    # @return [String]
+    #
+    def pr_body
+      pr_json["body"].to_s
+    end
+
+    # @!group PR Metadata
+    # The username of the author of the Pull Request.
+    # @return [String]
+    #
+    def pr_author
+      pr_json["user"]["login"].to_s
+    end
+
+    # @!group PR Metadata
+    # The labels assigned to the Pull Request.
+    # @return [String]
+    #
+    def pr_labels
+      @github.issue_json["labels"].map { |l| l[:name] }
+    end
+
+    # @!group PR Metadata
+    # Whether the PR is a Draft.
+    # @return [Boolean]
+    #
+    def pr_draft?
+      pr_json["draft"] == true
+    end
+
+    # @!group PR Commit Metadata
+    # The branch to which the PR is going to be merged into.
+    # @return [String]
+    #
+    def branch_for_base
+      pr_json["base"]["ref"]
+    end
+
+    # @!group PR Commit Metadata
+    # The branch to which the PR is going to be merged from.
+    # @return [String]
+    #
+    def branch_for_head
+      pr_json["head"]["ref"]
+    end
+
+    # @!group PR Commit Metadata
+    # The base commit to which the PR is going to be merged as a parent.
+    # @return [String]
+    #
+    def base_commit
+      pr_json["base"]["sha"]
+    end
+
+    # @!group PR Commit Metadata
+    # The head commit to which the PR is requesting to be merged from.
+    # @return [String]
+    #
+    def head_commit
+      pr_json["head"]["sha"]
+    end
+
+    # @!group GitHub Misc
+    # The hash that represents the PR's JSON. For an example of what this looks like
+    # see the [Danger Fixture'd one](https://raw.githubusercontent.com/danger/danger/master/spec/fixtures/github_api/pr_response.json).
+    # @return [Hash]
+    #
+    def pr_json
+      @github.pr_json
+    end
+
+    # @!group GitHub Misc
+    # Provides access to the GitHub API client used inside Danger. Making
+    # it easy to use the GitHub API inside a Dangerfile.
+    # @return [Octokit::Client]
+    def api
+      @github.client
+    end
+
+    # @!group PR Content
+    # The unified diff produced by Github for this PR
+    # see [Unified diff](https://en.wikipedia.org/wiki/Diff_utility#Unified_format)
+    # @return [String]
+    def pr_diff
+      @github.pr_diff
+    end
+
+    # @!group GitHub Misc
+    # Returns a list of HTML anchors for a file, or files in the head repository. An example would be:
+    # `<a href='https://github.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 github 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
+      repo = pr_json["head"]["repo"]["html_url"]
+
+      paths = paths.map do |path|
+        url_path = path.start_with?("/") ? path : "/#{path}"
+        text = full_path ? path : File.basename(path)
+        create_link("#{repo}/blob/#{commit}#{url_path}", text)
+      end
+
+      return paths.first if paths.count < 2
+
+      paths.first(paths.count - 1).join(", ") + " & " + paths.last
+    end
+
+    # @!group GitHub Misc
+    # Use to ignore inline messages which lay outside a diff's range, thereby not posting them in the main 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)
+        @github.dismiss_out_of_range_messages = dismiss
+      elsif dismiss.kind_of?(TrueClass)
+        @github.dismiss_out_of_range_messages = true
+      elsif dismiss.kind_of?(FalseClass)
+        @github.dismiss_out_of_range_messages = false
+      end
+    end
+
+    %i(title body author labels json).each do |suffix|
+      alias_method "mr_#{suffix}".to_sym, "pr_#{suffix}".to_sym
+    end
+
+    private
+
+    def create_link(href, text)
+      "<a href='#{href}'>#{text}</a>"
+    end
+  end
+end