danger 0.7.4 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fcdcdc1039905ce7ed910c8e951042b5f2fd994c
-  data.tar.gz: 96f2dd059e8d700ca3965e36339183e027a2c080
+  metadata.gz: f195902ac5ec8dbc7c67059f6484d9c548fa1b9b
+  data.tar.gz: af4335f0b4691d17bc27b801b17885f01e9ead07
 SHA512:
-  metadata.gz: b7e6ad0524f308e7ecfdab0b80759dc123024f2a6bde3c141bdc6c9317f63ea36b95dd4964b12be97487247b24ca12f886b1effd52352735ea307b15eefd5d60
-  data.tar.gz: a1fc5b70bfbd76637b683b2944942109732650f400d0415726e9d803f0ebd4b45001444f2c202ff873ecddcaf445acd77454d19d17e3a0f20f634f1c2060253c
+  metadata.gz: 9948b94a2189dd1e4f131f2f0e2265aa666322edfb59f4df8c741d91296f01d684059f11ef67878f6957532f6edba115fbd16071c8b48db01924d36a08584dbe
+  data.tar.gz: 44c3f8b65bd973eb45175b0b494e07749508e91514e55e8179785edcd567fffc736974eeacda00f850671761e72607463788b70ad6e1bc865e2d821c02950f9b

data/README.md

@@ -8,12 +8,11 @@ Formalize your Pull Request etiquette.
 -------
 
 <p align="center">
-    <a href="#installation">Installation</a> &bull;
-    <a href="#usage">Usage</a> &bull;
+    <a href="#getting-started">Getting Started</a> &bull;
+    <a href="#usage-on-ci">Usage</a> &bull;
     <a href="#dsl">DSL</a> &bull;
-    <a href="#constraints">Constraints</a> &bull;
-    <a href="#advanced">Advanced</a> &bull;
-    <a href="#contributing">Contributing</a>
+    <a href="#plugins">Plugins</a> &bull;
+    <a href="#test-locally-with-danger-local">Local</a>
 </p>
 
 -------
@@ -32,6 +31,8 @@ To get up and running quickly, just run
 bundle exec danger init
 ```
 
+The guide will create a default `Dangerfile` and take you through the process of setting up an account for feedback on GitHub.
+
 ## Usage on CI
 
 ```
@@ -40,19 +41,9 @@ bundle exec danger
 
 This will look at your `Dangerfile` and update the pull request accordingly. While you are setting up Danger, you may want to use: `--verbose` for more debug information.
 
-**Supported CIs**: Travis CI, CircleCI, Jenkins, Xcode Server and Buildkite.
-
-### Making your own
-If the CI server you're using isn't available yet, you can build it yourself:
+## CI Support
 
-Take a look at some of the [already existing integrations](https://github.com/danger/danger/tree/master/lib/danger/ci_source). The class has 2 mandatory methods:
-
-- `self.validates?` which should detect if the CI is active (detecting via ENV variables, mostly)
-- `initialize` which should set 2 variables:
-  - `self.repo_slug` the repo slug, in `org/repo` or `user/repo` format.
-  - `self.pull_request_id` the number of the pull request that the CI is testing (often available in ENV variables)
-
-We'd love to see pull requests for new integrations!
+Danger currently is supported on Travis CI, Circle CI, Xcode Bots via Buildasaur, BuildKite, Jenkins, Semaphore, and Drone CI. These work via environment variables, so it's easy to extend to include your own.
 
 ## What happens?
 
@@ -127,7 +118,7 @@ Command | Description
 
 ## Plugins
 
-Danger was built with a platform in mind: It can be used with any kind of software project and allows you to write your own action to have structured source code.
+Danger was built with a platform in mind: she can be used with any kind of software project and allows you to write your own action to have structured source code.
 
 In your `Dangerfile` you can import local or remote actions using
 
@@ -150,10 +141,6 @@ danger new_plugin
 
 This will generate a new Ruby file which you can modify to fit your needs.
 
-## Support
-
-Danger currently is supported on Travis CI, Circle CI, BuildKite and Jenkins. These work via environment variables, so it's easy to extend to include your own.
-
 ## Advanced
 
 You can access more detailed information by accessing the following variables
@@ -169,12 +156,25 @@ open to turning useful bits into the official API.
 
 ## Test locally with `danger local`
 
-You can use `danger local` to run Danger in an environment similar to how it will be ran on CI. By default Danger will look
+You can use `danger local` to run Danger in an environment similar to how she will be ran on CI. By default Danger will look
 at the most recently merged PR, then run your `Dangerfile` against that Pull Request. This is really useful when making changes.
 
 If you have a specific PR in mind that you'd like to work against, make sure you have it merged in your current git
 history, then append `--use-merged-pr=[id]` to the command.
 
+### Adding a new CI
+If the CI server you're using isn't available yet, you can build it yourself:
+
+Take a look at some of the [already existing integrations](https://github.com/danger/danger/tree/master/lib/danger/ci_source). The class has 2 mandatory methods:
+
+- `self.validates?` which should detect if the CI is active (detecting via ENV variables, mostly)
+- `initialize` which should set 2 variables:
+  - `self.repo_slug` the repo slug, in `org/repo` or `user/repo` format.
+  - `self.pull_request_id` the number of the pull request that the CI is testing (often available in ENV variables)
+
+We'd love to see pull requests for new integrations!
+
+
 ## Suppress Violations
 
 You can tell Danger to ignore a specific warning or error by commenting on the PR body:
@@ -199,6 +199,11 @@ fail("PR needs labels", sticky: false) if pr_labels.empty?
 
 Here are some real-world Dangerfiles: [artsy/eigen](https://github.com/artsy/eigen/blob/master/Dangerfile), [danger/danger](https://github.com/danger/danger/blob/master/Dangerfile), [artsy/elan](https://github.com/artsy/elan/blob/master/Dangerfile) and more!
 
+## Usage with GitHub Enterprise
+Danger allows usage with GitHub Enterprise by setting 2 environment variables:
+- `DANGER_GITHUB_HOST` to the host that GitHub is running on
+- `DANGER_GITHUB_API_HOST` to the host that the GitHub Enterprise API is reachable on.
+
 ## License, Contributor's Guidelines and Code of Conduct
 
 [Join our Slack Group](https://danger-slack.herokuapp.com/)

data/lib/danger.rb

@@ -1,9 +1,8 @@
 require "danger/version"
-require "danger/dangerfile"
-require "danger/environment_manager"
+require "danger/danger_core/dangerfile"
+require "danger/danger_core/environment_manager"
 require "danger/commands/runner"
-require "danger/available_values"
-require "danger/plugin"
+require "danger/plugin_support/plugin"
 require "danger/core_ext/string"
 
 require "claide"

data/lib/danger/ci_source/circle.rb

@@ -1,6 +1,6 @@
 # https://circleci.com/docs/environment-variables
 require 'uri'
-require 'danger/circle_api'
+require 'danger/ci_source/circle_api'
 
 module Danger
   module CISource

data/lib/danger/ci_source/drone.rb

@@ -0,0 +1,18 @@
+# http://readme.drone.io/usage/variables/
+
+module Danger
+  module CISource
+    class Drone < CI
+      def self.validates?(env)
+        return !env["DRONE"].nil?
+      end
+
+      def initialize(env)
+        self.repo_slug = env["DRONE_REPO"]
+        if env["DRONE_PULL_REQUEST"].to_i > 0
+          self.pull_request_id = env["DRONE_PULL_REQUEST"]
+        end
+      end
+    end
+  end
+end

data/lib/danger/ci_source/semaphore.rb

@@ -0,0 +1,18 @@
+# https://semaphoreci.com/docs/available-environment-variables.html
+
+module Danger
+  module CISource
+    class Semaphore < CI
+      def self.validates?(env)
+        return !env["SEMAPHORE"].nil?
+      end
+
+      def initialize(env)
+        self.repo_slug = env["SEMAPHORE_REPO_SLUG"]
+        if env["PULL_REQUEST_NUMBER"].to_i > 0
+          self.pull_request_id = env["PULL_REQUEST_NUMBER"]
+        end
+      end
+    end
+  end
+end

data/lib/danger/commands/local.rb

@@ -11,7 +11,7 @@ module Danger
 
     def self.options
       [
-        ['--use-merged-pr=[#id]', 'The ID of an alreadty merged PR inside your history to use as a reference for the local run.']
+        ['--use-merged-pr=[#id]', 'The ID of an already merged PR inside your history to use as a reference for the local run.']
       ].concat(super)
     end
 
@@ -26,8 +26,9 @@ module Danger
       ENV["DANGER_USE_LOCAL_GIT"] = "YES"
       ENV["LOCAL_GIT_PR_ID"] = @pr_num if @pr_num
 
-      dm = Dangerfile.new
-      dm.env = EnvironmentManager.new(ENV)
+      env = EnvironmentManager.new(ENV)
+      dm = Dangerfile.new(env)
+      dm.init_plugins
 
       source = dm.env.ci_source
       if source.nil? or source.repo_slug.empty?
@@ -49,16 +50,24 @@ module Danger
       # We can use tokenless here, as it's running on someone's computer
       # and is IP locked, as opposed  to on the CI.
       gh.support_tokenless_auth = true
-      gh.fetch_details
 
-      dm.env.request_source = gh
+      begin
+        gh.fetch_details
+      rescue Octokit::NotFound
+        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
 
-      dm.env.scm = GitRepo.new
+      dm.env.request_source = gh
 
-      dm.env.ensure_danger_branches_are_setup
-      dm.env.scm.diff_for_folder(".", from: dm.env.ci_source.base_commit, to: dm.env.ci_source.head_commit)
-      dm.parse(Pathname.new(@dangerfile_path))
-      dm.print_results
+      begin
+        dm.env.ensure_danger_branches_are_setup
+        dm.env.scm.diff_for_folder(".", from: dm.env.ci_source.base_commit, to: dm.env.ci_source.head_commit)
+        dm.parse(Pathname.new(@dangerfile_path))
+        dm.print_results
+      ensure
+        dm.env.clean_up
+      end
     end
   end
 end

data/lib/danger/commands/runner.rb

@@ -6,11 +6,13 @@ module Danger
 
     self.summary = 'Run the Dangerfile.'
     self.command = 'danger'
+    self.version = Danger::VERSION
 
     self.plugin_prefixes = %w(claide danger)
 
     def initialize(argv)
-      @dangerfile_path = "Dangerfile" if File.exist? "Dangerfile"
+      dangerfile = argv.option('dangerfile', 'Dangerfile')
+      @dangerfile_path = dangerfile if File.exist? dangerfile
       @base = argv.option('base')
       @head = argv.option('head')
       super
@@ -26,37 +28,47 @@ module Danger
     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']
+        ['--head=[master|dev|stable]', 'A branch/tag/commit to use as the head'],
+        ['--dangerfile=<path/to/dangerfile>', 'The location of your Dangerfile']
       ].concat(super)
     end
 
     def run
-      # The order of the following commands is *really* important
-      dm = Dangerfile.new
-      dm.verbose = verbose
-      dm.env = EnvironmentManager.new(ENV)
-      return unless dm.env.ci_source # if it's not a PR
+      env = EnvironmentManager.new(ENV)
+      dm = Dangerfile.new(env)
 
-      dm.env.fill_environment_vars
-      dm.env.ensure_danger_branches_are_setup
+      if dm.env.pr?
+        dm.verbose = verbose
+        dm.init_plugins
 
-      # Offer the chance for a user to specify a branch through the command line
-      ci_base = @base || dm.env.danger_head_branch
-      ci_head = @head || dm.env.danger_base_branch
-      dm.env.scm.diff_for_folder(".", from: ci_base, to: ci_head)
+        dm.env.fill_environment_vars
 
-      dm.parse Pathname.new(@dangerfile_path)
+        begin
+          dm.env.ensure_danger_branches_are_setup
 
-      post_results(dm)
+          # Offer the chance for a user to specify a branch through the command line
+          ci_base = @base || dm.env.danger_head_branch
+          ci_head = @head || dm.env.danger_base_branch
+          dm.env.scm.diff_for_folder(".", from: ci_base, to: ci_head)
 
-      dm.env.clean_up
+          dm.parse Pathname.new(@dangerfile_path)
 
-      dm.print_results
+          post_results dm
+          dm.print_results
+        ensure
+          dm.env.clean_up
+        end
+      else
+        puts "Not a Pull Request - skipping `danger` run"
+      end
     end
 
     def post_results(dm)
       gh = dm.env.request_source
-      gh.update_pull_request!(warnings: dm.warnings, errors: dm.errors, messages: dm.messages, markdowns: dm.markdowns)
+      violations = dm.violation_report
+      status = dm.status_report
+
+      gh.update_pull_request!(warnings: violations[:warnings], errors: violations[:errors], messages: violations[:messages], markdowns: status[:markdowns])
     end
   end
 end

data/lib/danger/comment_generators/github.md.erb

@@ -36,6 +36,6 @@
 <%# the previous line has to be aligned far to the left, otherwise markdown can break easily %>
 <% end %>
 
-<p align="right" data-meta="generated_by_danger" data-base-commit="<%= @base_commit %>" data-head-commit="<%= @head_commit %>" >
+<p align="right" data-meta="generated_by_danger">
   Generated by :no_entry_sign: <a href="https://github.com/danger/danger/">danger</a>
 </p>

data/lib/danger/{scm_source → core_ext}/file_list.rb

@@ -2,6 +2,7 @@ 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)

data/lib/danger/danger_core/dangerfile.rb

@@ -0,0 +1,217 @@
+# So much was ripped direct from CocoaPods-Core - thanks!
+
+require 'danger/danger_core/dangerfile_dsl'
+require 'danger/danger_core/standard_error'
+
+require 'danger/danger_core/plugins/dangerfile_messaging_plugin'
+require 'danger/danger_core/plugins/dangerfile_import_plugin'
+require 'danger/danger_core/plugins/dangerfile_git_plugin'
+require 'danger/danger_core/plugins/dangerfile_github_plugin'
+
+require 'danger/danger_core/plugins/dangerfile_github_plugin'
+
+module Danger
+  class Dangerfile
+    include Danger::Dangerfile::DSL
+
+    attr_accessor :env, :verbose, :plugins
+
+    # @return [Pathname] the path where the Dangerfile was loaded from. It is nil
+    #         if the Dangerfile was generated programmatically.
+    #
+    attr_accessor :defined_in_file
+
+    # @return [String] a string useful to represent the Dangerfile in a message
+    #         presented to the user.
+    #
+    def to_s
+      'Dangerfile'
+    end
+
+    # These are the classes that are allowed to also use method_missing
+    # in order to provide broader plugin support
+    def core_plugin_classes
+      [
+        Danger::DangerfileMessagingPlugin,
+        Danger::DangerfileImportPlugin,
+        Danger::DangerfileGitHubPlugin,
+        Danger::DangerfileGitPlugin
+      ]
+    end
+
+    # Both of these methods exist on all objects
+    # http://ruby-doc.org/core-2.2.3/Kernel.html#method-i-warn
+    # http://ruby-doc.org/core-2.2.3/Kernel.html#method-i-fail
+    # However, as we're using using them in the DSL, they won't
+    # get method_missing called correctly.
+
+    def warn(*args, &blk)
+      method_missing(:warn, *args, &blk)
+    end
+
+    def fail(*args, &blk)
+      method_missing(:fail, *args, &blk)
+    end
+
+    # When an undefined method is called, we check to see if it's something
+    # that the DSLs have, then starts looking at plugins support.
+    def method_missing(method_sym, *arguments, &_block)
+      @core_plugins.each do |plugin|
+        if plugin.public_methods(false).include?(method_sym)
+          return plugin.send(method_sym, *arguments)
+        end
+      end
+      super
+    end
+
+    def initialize(env_manager)
+      @plugins = {}
+      @core_plugins = []
+
+      # Triggers the core plugins
+      @env = env_manager
+
+      # Triggers local plugins from the root of a project
+      Dir["./danger_plugins/*.rb"].each do |file|
+        require File.expand_path(file)
+      end
+
+      refresh_plugins if env_manager.pr?
+    end
+
+    # Iterate through available plugin classes and initialize them with
+    # a reference to this Dangerfile
+    def refresh_plugins
+      plugins = ObjectSpace.each_object(Class).select { |klass| klass < Danger::Plugin }
+      plugins.each do |klass|
+        next if klass.singleton_class?
+        plugin = klass.new(self)
+        next if plugin.nil? || @plugins[klass]
+
+        name = plugin.class.instance_name
+        self.class.send(:attr_reader, name)
+        instance_variable_set("@#{name}", plugin)
+
+        @plugins[klass] = plugin
+        @core_plugins << plugin if core_plugin_classes.include? klass
+      end
+    end
+    alias init_plugins refresh_plugins
+
+    def core_dsl_attributes
+      @core_plugins.map { |plugin| { plugin: plugin, methods: plugin.public_methods(false) } }
+    end
+
+    def external_dsl_attributes
+      plugins.values.reject { |plugin| @core_plugins.include? plugin } .map { |plugin| { plugin: plugin, methods: plugin.public_methods(false) } }
+    end
+
+    def method_values_for_plugin_hashes(plugin_hashes)
+      plugin_hashes.flat_map do |plugin_hash|
+        plugin = plugin_hash[:plugin]
+        methods = plugin_hash[:methods].reject { |name| plugin.method(name).arity != 0 }
+
+        methods.map do |method|
+          value = plugin.send(method)
+          value = value.scan(/.{,80}/).to_a.each(&:strip!).join("\n") if method == :pr_body
+
+          # So that we either have one value per row
+          # or we have [] for an empty array
+          value = value.join("\n") if value.kind_of?(Array) && value.count > 0
+          [method.to_s, value]
+        end
+      end
+    end
+
+    # Iterates through the DSL's attributes, and table's the output
+    def print_known_info
+      rows = []
+      rows += method_values_for_plugin_hashes(core_dsl_attributes)
+      rows << ["---", "---"]
+      rows += method_values_for_plugin_hashes(external_dsl_attributes)
+      rows << ["---", "---"]
+      rows << ["SCM", env.scm.class]
+      rows << ["Source", env.ci_source.class]
+      rows << ["Requests", env.request_source.class]
+      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 }
+      params[:title] = "Danger v#{Danger::VERSION}\nDSL Attributes".green
+
+      puts ""
+      puts Terminal::Table.new(params)
+      puts ""
+    end
+
+    # Parses the file at a path, optionally takes the content of the file for DI
+    #
+    def parse(path, contents = nil)
+      print_known_info if verbose
+
+      contents ||= File.open(path, 'r:utf-8', &:read)
+
+      # Work around for Rubinius incomplete encoding in 1.9 mode
+      if contents.respond_to?(:encoding) && contents.encoding.name != 'UTF-8'
+        contents.encode!('UTF-8')
+      end
+
+      if contents.tr!('“”‘’‛', %(""'''))
+        # Changes have been made
+        puts "Your #{path.basename} has had smart quotes sanitised. " \
+                    'To avoid issues in the future, you should not use ' \
+                    'TextEdit for editing it. If you are not using TextEdit, ' \
+                    'you should turn off smart quotes in your editor of choice.'.red
+      end
+
+      if contents.include?("puts")
+        puts "You used `puts` in your Dangerfile. To print out text to GitHub use `message` instead"
+      end
+
+      self.defined_in_file = path
+      instance_eval do
+        # rubocop:disable Lint/RescueException
+        begin
+          # rubocop:disable Eval
+          eval(contents, nil, path.to_s)
+          # rubocop:enable Eval
+        rescue Exception => e
+          message = "Invalid `#{path.basename}` file: #{e.message}"
+          raise DSLError.new(message, path, e.backtrace, contents)
+        end
+        # rubocop:enable Lint/RescueException
+      end
+    end
+
+    def print_results
+      status = status_report
+      return if (status[:errors] + status[:warnings] + status[:messages] + status[:markdowns]).count == 0
+
+      puts ""
+      puts "danger results:"
+      [:errors, :warnings, :messages].each do |current|
+        params = {}
+        params[:rows] = status[current].map { |item| [item] }
+        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 status[:markdowns].count > 0
+      status[:markdowns].each do |current_markdown|
+        puts current_markdown
+      end
+    end
+  end
+end