danger 8.0.3

data/lib/danger/commands/local_helpers/http_cache.rb

@@ -0,0 +1,36 @@
+require "pstore"
+
+module Danger
+  class HTTPCache
+    attr_reader :expires_in
+    def initialize(cache_file = nil, options = {})
+      File.delete(cache_file) if options[:clear_cache]
+      @store = PStore.new(cache_file)
+      @expires_in = options[:expires_in] || 300 # 5 minutes
+    end
+
+    def read(key)
+      @store.transaction do
+        entry = @store[key]
+        return nil unless entry
+        return entry[:value] unless entry_has_expired(entry, @expires_in)
+        @store.delete key
+        return nil
+      end
+    end
+
+    def delete(key)
+      @store.transaction { @store.delete key }
+    end
+
+    def write(key, value)
+      @store.transaction do
+        @store[key] = { updated_at: Time.now.to_i, value: value }
+      end
+    end
+
+    def entry_has_expired(entry, ttl)
+      Time.now.to_i > entry[:updated_at].to_i + ttl.to_i
+    end
+  end
+end

data/lib/danger/commands/local_helpers/local_setup.rb

@@ -0,0 +1,46 @@
+module Danger
+  class LocalSetup
+    attr_reader :dm, :cork
+
+    def initialize(dangerfile, cork)
+      @dm = dangerfile
+      @cork = cork
+    end
+
+    def setup(verbose: false)
+      source = dm.env.ci_source
+      if source.nil? or source.repo_slug.empty?
+        cork.puts "danger local failed because it only works with GitHub and Bitbucket server projects at the moment. Sorry.".red
+        exit 0
+      end
+      gh = dm.env.request_source
+      # We can use tokenless here, as it's running on someone's computer
+      # and is IP locked, as opposed to on the CI. Only for Github PRs
+      if gh.instance_of? Danger::RequestSources::GitHub
+        gh.support_tokenless_auth = true
+      end
+
+      if gh.instance_of? Danger::RequestSources::BitbucketServer
+        cork.puts "Running your Dangerfile against this PR - #{gh.host}/projects/#{source.repo_slug.split('/').first}/repos/#{source.repo_slug.split('/').last}/pull-requests/#{source.pull_request_id}"
+      else
+        cork.puts "Running your Dangerfile against this PR - https://#{gh.host}/#{source.repo_slug}/pull/#{source.pull_request_id}"
+      end
+
+      unless verbose
+        cork.puts "Turning on --verbose"
+        dm.verbose = true
+      end
+
+      cork.puts
+
+      begin
+        gh.fetch_details
+      rescue Octokit::NotFound
+        cork.puts "Local repository was not found on GitHub. If you're trying to test a private repository please provide a valid API token through " + "DANGER_GITHUB_API_TOKEN".yellow + " environment variable."
+        return
+      end
+
+      yield
+    end
+  end
+end

data/lib/danger/commands/local_helpers/pry_setup.rb

@@ -0,0 +1,31 @@
+module Danger
+  class PrySetup
+    def initialize(cork)
+      @cork = cork
+    end
+
+    def setup_pry(dangerfile_path)
+      return dangerfile_path if dangerfile_path.empty?
+      validate_pry_available
+      FileUtils.cp dangerfile_path, DANGERFILE_COPY
+      File.open(DANGERFILE_COPY, "a") do |f|
+        f.write("\nbinding.pry; File.delete(\"#{DANGERFILE_COPY}\")")
+      end
+      DANGERFILE_COPY
+    end
+
+    private
+
+    attr_reader :cork
+
+    DANGERFILE_COPY = "_Dangerfile.tmp".freeze
+
+    def validate_pry_available
+      Kernel.require "pry"
+    rescue LoadError
+      cork.warn "Pry was not found, and is required for 'danger pr --pry'."
+      cork.print_warnings
+      abort
+    end
+  end
+end

data/lib/danger/commands/plugins/plugin_json.rb

@@ -0,0 +1,46 @@
+require "danger/plugin_support/plugin_parser"
+require "danger/plugin_support/plugin_file_resolver"
+
+module Danger
+  class PluginJSON < CLAide::Command::Plugins
+    self.summary = "Prints the JSON documentation representing a plugin"
+    self.command = "json"
+
+    attr_accessor :cork
+
+    def initialize(argv)
+      @refs = argv.arguments! unless argv.arguments.empty?
+      @cork = Cork::Board.new(silent: argv.option("silent", false),
+                              verbose: argv.option("verbose", false))
+      super
+    end
+
+    self.summary = "Lint plugins from files, gems or the current folder. Outputs JSON array representation of Plugins on success."
+
+    self.description = <<-DESC
+      Converts a collection of file paths of Danger plugins into a JSON format.
+    DESC
+
+    self.arguments = [
+      CLAide::Argument.new("Paths, Gems or Nothing", false, true)
+    ]
+
+    def run
+      file_resolver = PluginFileResolver.new(@refs)
+      data = file_resolver.resolve
+
+      parser = PluginParser.new(data[:paths])
+      parser.parse
+      json = parser.to_json
+
+      # Append gem metadata into every plugin
+      data[:gems].each do |gem_data|
+        json.each do |plugin|
+          plugin[:gem_metadata] = gem_data if plugin[:gem] == gem_data[:gem]
+        end
+      end
+
+      cork.puts json.to_json
+    end
+  end
+end

data/lib/danger/commands/plugins/plugin_lint.rb

@@ -0,0 +1,54 @@
+require "danger/plugin_support/plugin_parser"
+require "danger/plugin_support/plugin_file_resolver"
+require "danger/plugin_support/plugin_linter"
+
+module Danger
+  class PluginLint < CLAide::Command::Plugins
+    self.summary = "Lints a plugin"
+    self.command = "lint"
+
+    attr_accessor :cork
+
+    def initialize(argv)
+      @warnings_as_errors = argv.flag?("warnings-as-errors", false)
+      @refs = argv.arguments! unless argv.arguments.empty?
+      @cork = Cork::Board.new(silent: argv.option("silent", false),
+                              verbose: argv.option("verbose", false))
+      super
+    end
+
+    self.summary = "Lint plugins from files, gems or the current folder. Outputs JSON array representation of Plugins on success."
+
+    self.description = <<-DESC
+      Converts a collection of file paths of Danger plugins into a JSON format.
+      Note: Before 1.0, it will also parse the represented JSON to validate whether https://danger.systems would
+      show the plugin on the website.
+    DESC
+
+    self.arguments = [
+      CLAide::Argument.new("Paths, Gems or Nothing", false, true)
+    ]
+
+    def self.options
+      [
+        ["--warnings-as-errors", "Ensure strict linting."]
+      ].concat(super)
+    end
+
+    def run
+      file_resolver = PluginFileResolver.new(@refs)
+      data = file_resolver.resolve
+
+      parser = PluginParser.new(data[:paths], verbose: true)
+      parser.parse
+      json = parser.to_json
+
+      linter = PluginLinter.new(json)
+      linter.lint
+      linter.print_summary(cork)
+
+      abort("Failing due to errors\n".red) if linter.failed?
+      abort("Failing due to warnings as errors\n".red) if @warnings_as_errors && !linter.warnings.empty?
+    end
+  end
+end

data/lib/danger/commands/plugins/plugin_readme.rb

@@ -0,0 +1,45 @@
+require "danger/plugin_support/plugin_parser"
+require "danger/plugin_support/plugin_file_resolver"
+require "json"
+require "erb"
+
+module Danger
+  class PluginReadme < CLAide::Command::Plugins
+    self.summary = "Generates a README from a set of plugins"
+    self.command = "readme"
+
+    attr_accessor :cork, :json
+
+    def initialize(argv)
+      @refs = argv.arguments! unless argv.arguments.empty?
+      @cork = Cork::Board.new(silent: argv.option("silent", false),
+                              verbose: argv.option("verbose", false))
+      super
+    end
+
+    self.summary = "Lint plugins from files, gems or the current folder. Outputs JSON array representation of Plugins on success."
+
+    self.description = <<-DESC
+      Converts a collection of file paths of Danger plugins into a format usable in a README.
+      This is useful for Danger itself, but also for any plugins wanting to showcase their API.
+    DESC
+
+    self.arguments = [
+      CLAide::Argument.new("Paths, Gems or Nothing", false, true)
+    ]
+
+    attr_accessor :json, :markdown
+    def run
+      file_resolver = PluginFileResolver.new(@refs)
+      data = file_resolver.resolve
+
+      parser = PluginParser.new(data[:paths])
+      parser.parse
+
+      self.json = JSON.parse(parser.to_json_string)
+
+      template = File.join(Danger.gem_path, "lib/danger/plugin_support/templates/readme_table.html.erb")
+      cork.puts ERB.new(File.read(template), 0, "-").result(binding)
+    end
+  end
+end

data/lib/danger/commands/pr.rb

@@ -0,0 +1,92 @@
+require "danger/commands/local_helpers/http_cache"
+require "danger/commands/local_helpers/pry_setup"
+require "faraday/http_cache"
+require "fileutils"
+require "octokit"
+require "tmpdir"
+require "no_proxy_fix"
+
+module Danger
+  class PR < Runner
+    self.summary = "Run the Dangerfile locally against Pull Requests (works with forks, too). Does not post to the PR. Usage: danger pr <URL>".freeze
+    self.command = "pr".freeze
+
+    def self.options
+      [
+        ["--clear-http-cache", "Clear the local http cache before running Danger locally."],
+        ["--pry", "Drop into a Pry shell after evaluating the Dangerfile."],
+        ["--dangerfile=<path/to/dangerfile>", "The location of your Dangerfile"],
+        ["--verify-ssl", "Verify SSL in Octokit"]
+      ]
+    end
+
+    def initialize(argv)
+      show_help = true if argv.arguments == ["-h"]
+
+      @pr_url = argv.shift_argument
+      @clear_http_cache = argv.flag?("clear-http-cache", false)
+      dangerfile = argv.option("dangerfile", "Dangerfile")
+      @verify_ssl = argv.flag?("verify-ssl", true)
+
+      # Currently CLAide doesn't support short option like -h https://github.com/CocoaPods/CLAide/pull/60
+      # when user pass in -h, mimic the behavior of passing in --help.
+      argv = CLAide::ARGV.new ["--help"] if show_help
+
+      super
+
+      @dangerfile_path = dangerfile if File.exist?(dangerfile)
+
+      if argv.flag?("pry", false)
+        @dangerfile_path = PrySetup.new(cork).setup_pry(@dangerfile_path)
+      end
+    end
+
+    def validate!
+      super
+      unless @dangerfile_path
+        help! "Could not find a Dangerfile."
+      end
+      unless @pr_url
+        help! "Could not find a pull-request. Usage: danger pr <URL>"
+      end
+    end
+
+    def run
+      ENV["DANGER_USE_LOCAL_GIT"] = "YES"
+      ENV["LOCAL_GIT_PR_URL"] = @pr_url if @pr_url
+
+      configure_octokit(ENV["DANGER_TMPDIR"] || Dir.tmpdir)
+
+      env = EnvironmentManager.new(ENV, cork)
+      dm = Dangerfile.new(env, cork)
+
+      LocalSetup.new(dm, cork).setup(verbose: verbose) do
+        dm.run(
+          Danger::EnvironmentManager.danger_base_branch,
+          Danger::EnvironmentManager.danger_head_branch,
+          @dangerfile_path,
+          nil,
+          nil,
+          nil
+        )
+      end
+    end
+
+    private
+
+    def configure_octokit(cache_dir)
+      # setup caching for Github calls to hitting the API rate limit too quickly
+      cache_file = File.join(cache_dir, "danger_local_cache")
+      cache = HTTPCache.new(cache_file, clear_cache: @clear_http_cache)
+      Octokit.configure do |config|
+        config.connection_options[:ssl] = { verify: @verify_ssl }
+      end
+      Octokit.middleware = Faraday::RackBuilder.new do |builder|
+        builder.use Faraday::HttpCache, store: cache, serializer: Marshal, shared_cache: false
+        builder.use Octokit::Middleware::FollowRedirects
+        builder.use Octokit::Response::RaiseError
+        builder.adapter Faraday.default_adapter
+      end
+    end
+  end
+end

data/lib/danger/commands/runner.rb

@@ -0,0 +1,94 @@
+module Danger
+  class Runner < CLAide::Command
+    require "danger/commands/init"
+    require "danger/commands/local"
+    require "danger/commands/dry_run"
+    require "danger/commands/staging"
+    require "danger/commands/systems"
+    require "danger/commands/pr"
+
+    # manually set claide plugins as a subcommand
+    require "claide_plugin"
+    @subcommands << CLAide::Command::Plugins
+    CLAide::Plugins.config =
+      CLAide::Plugins::Configuration.new(
+        "Danger",
+        "danger",
+        "https://gitlab.com/danger-systems/danger.systems/raw/master/plugins-search-generated.json",
+        "https://github.com/danger/danger-plugin-template"
+      )
+
+    require "danger/commands/plugins/plugin_lint"
+    require "danger/commands/plugins/plugin_json"
+    require "danger/commands/plugins/plugin_readme"
+
+    require "danger/commands/dangerfile/init"
+    require "danger/commands/dangerfile/gem"
+
+    attr_accessor :cork
+
+    self.summary = "Run the Dangerfile."
+    self.command = "danger"
+    self.version = Danger::VERSION
+
+    self.plugin_prefixes = %w(claide danger)
+
+    def initialize(argv)
+      dangerfile = argv.option("dangerfile", "Dangerfile")
+      @dangerfile_path = dangerfile if File.exist?(dangerfile)
+      @base = argv.option("base")
+      @head = argv.option("head")
+      @fail_on_errors = argv.option("fail-on-errors", false)
+      @fail_if_no_pr = argv.option("fail-if-no-pr", false)
+      @new_comment = argv.flag?("new-comment")
+      @remove_previous_comments = argv.flag?("remove-previous-comments")
+      @danger_id = argv.option("danger_id", "danger")
+      @cork = Cork::Board.new(silent: argv.option("silent", false),
+                              verbose: argv.option("verbose", false))
+      adjust_colored2_output(argv)
+      super
+    end
+
+    def validate!
+      super
+      if self.class == Runner && !@dangerfile_path
+        help!("Could not find a Dangerfile.")
+      end
+    end
+
+    def self.options
+      [
+        ["--base=[master|dev|stable]", "A branch/tag/commit to use as the base of the diff"],
+        ["--head=[master|dev|stable]", "A branch/tag/commit to use as the head"],
+        ["--fail-on-errors=<true|false>", "Should always fail the build process, defaults to false"],
+        ["--fail-if-no-pr=<true|false>", "Should fail the build process if no PR is found (useful for CircleCI), defaults to false"],
+        ["--dangerfile=<path/to/dangerfile>", "The location of your Dangerfile"],
+        ["--danger_id=<id>", "The identifier of this Danger instance"],
+        ["--new-comment", "Makes Danger post a new comment instead of editing its previous one"],
+        ["--remove-previous-comments", "Removes all previous comment and create a new one in the end of the list"]
+      ].concat(super)
+    end
+
+    def run
+      Executor.new(ENV).run(
+        base: @base,
+        head: @head,
+        dangerfile_path: @dangerfile_path,
+        danger_id: @danger_id,
+        new_comment: @new_comment,
+        fail_on_errors: @fail_on_errors,
+        fail_if_no_pr: @fail_if_no_pr,
+        remove_previous_comments: @remove_previous_comments
+      )
+    end
+
+    private
+
+    def adjust_colored2_output(argv)
+      # disable/enable colored2 output
+      # consider it execution wide to avoid need to wrap #run and maintain state
+      # ARGV#options is non-destructive way to check flags
+      Colored2.public_send(argv.options.fetch("ansi", true) ? "enable!" : "disable!")
+    end
+  end
+end