danger 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bdced6826bdfbe8f06cdc77e9f6b58336140e17c
-  data.tar.gz: 669ebaaf2d49f985c70a485018ff4bf6e8f4360f
+  metadata.gz: f195902ac5ec8dbc7c67059f6484d9c548fa1b9b
+  data.tar.gz: af4335f0b4691d17bc27b801b17885f01e9ead07
 SHA512:
-  metadata.gz: adbef18ddcb2de50eb915991a82334bf8e559c1b6af8cc00230d8038a1440e09d268f1380aff7936411b9dd6c5d26bef8ae17f10f1a09f9b5a02c42d6b096b7e
-  data.tar.gz: c91f0a03be03e79d026b6b64c2da6bcc486eeb87883c00fe13d3869b64477bef72c121dd3b8f53c7e724fd341bd2285b884a1b2a16334148b1b960104a21e552
+  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,6 +41,10 @@ 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.
 
+## CI Support
+
+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?
 
 Danger runs at the end of a CI build, she will execute a `Dangerfile`. This file is given some special variables based on the git diff and the Pull Request being running. You can use these variables in Ruby to provide messages, warnings and failures for your build. You set up Danger with a GitHub user account and she will post updates via comments on the Pull Request, and can fail your build too.
@@ -113,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
 
@@ -134,11 +139,7 @@ To create a new plugin run
 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.
+This will generate a new Ruby file which you can modify to fit your needs.
 
 ## Advanced
 
@@ -155,8 +156,24 @@ open to turning useful bits into the official API.
 
 ## Test locally with `danger local`
 
-Using `danger local` will look for the last merged pull request in your git history, and apply your current
-`Dangerfile` against that Pull Request. Useful when editing.
+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
 
@@ -182,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/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/local_git_repo.rb

@@ -34,10 +34,19 @@ module Danger
           end
         end
 
+        specific_pr = env["LOCAL_GIT_PR_ID"]
+        pr_ref = specific_pr ? "##{specific_pr}" : ''
+        pr_command = "log --merges --oneline | grep \"Merge pull request #{pr_ref}\" | head -n 1"
+
         # get the most recent PR merge
-        pr_merge = run_git "log --since='2 weeks ago' --merges --oneline | grep \"Merge pull request\" | head -n 1".strip
+        pr_merge = run_git pr_command.strip
+
         if pr_merge.to_s.empty?
-          raise "No recent pull requests found for this repo, danger requires at least one PR for the local mode"
+          if specific_pr
+            raise "Could not find the pull request (#{specific_pr}) inside the git history for this repo."
+          else
+            raise "No recent pull requests found for this repo, danger requires at least one PR for the local mode."
+          end
         end
 
         self.pull_request_id = pr_merge.match("#([0-9]+)")[1]

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/init.rb

@@ -23,7 +23,7 @@ module Danger
 
     def run
       ui = Interviewer.new
-      ui.say "\nOK, thanks #{ENV['LOGNAME']}, grab a seat and we'll get you started.\n".yellow
+      ui.say "\nOK, thanks #{ENV['LOGNAME']}, have a seat and we'll get you started.\n".yellow
       ui.pause 1
 
       show_todo_state
@@ -43,11 +43,11 @@ module Danger
     end
 
     def show_todo_state
-      ui.say "We need to do the following steps:\n"
+      ui.say "We need to do the following:\n"
       ui.pause 0.6
       ui.say " - [ ] Create a Dangerfile and add a few simple rules."
       ui.pause 0.6
-      ui.say " - [#{@account_created ? 'x' : ' '}] Create a GitHub account for Danger use for messaging."
+      ui.say " - [#{@account_created ? 'x' : ' '}] Create a GitHub account for Danger to use, for messaging."
       ui.pause 0.6
       ui.say " - [ ] Set up an access token for Danger."
       ui.pause 0.6
@@ -71,7 +71,7 @@ module Danger
       ui.pause 2
 
       ui.say "There's a collection of small, simple ideas in here, but Danger is about being able to easily"
-      ui.say "iterate. The power comes from you have the ability to codify fixes to some of the problems"
+      ui.say "iterate. The power comes from you having the ability to codify fixes for some of the problems"
       ui.say "that come up in day to day programming. It can be difficult to try and see those from day 1."
 
       ui.say "\nIf you'd like to investigate the file, and make some changes - I'll wait here,"
@@ -113,7 +113,7 @@ module Danger
         ui.say "For Open Source projects, I'd recommend giving the token the smallest scope possible."
         ui.say "This means only providing access to " + "public_repo".yellow + " in the token.\n\n"
         ui.pause 1
-        ui.say "This token limits Danger's abilities to just to writing comments on OSS projects. I recommend"
+        ui.say "This token limits Danger's abilities to just writing comments on OSS projects. I recommend"
         ui.say "this because the token can quite easily be extracted from the environment via pull requests."
         ui.say "#{@bot_name} does not need admin access to your repo. So its ability to cause chaos is minimalized.\n"
 
@@ -148,7 +148,7 @@ module Danger
       ui.say "\nOK, I'll give you a moment to do this..."
       ui.wait_for_return
 
-      ui.say "Final step: exposing the GitHub token as an environment build variable."
+      ui.header "Final step: exposing the GitHub token as an environment build variable."
       ui.pause 0.4
       if considered_an_oss_repo?
         ui.say "As you have an Open Source repo, this token should be considered public, otherwise you cannot"
@@ -207,7 +207,7 @@ module Danger
       # https://travis-ci.org/artsy/eigen/settings
       ui.say "In order to add an environment variable, go to:"
       ui.link "https://travis-ci.org/#{current_repo_slug}/settings"
-      ui.say "\nThe name is " + "DANGER_GITHUB_API_TOKEN".yellow + " and the value is the GitHub Personal Acess Token."
+      ui.say "\nThe name is " + "DANGER_GITHUB_API_TOKEN".yellow + " and the value is the GitHub Personal Access Token."
       if @is_open_source
         ui.say "Make sure to have \"Display value in build log\" enabled."
       end
@@ -262,7 +262,7 @@ module Danger
       ui.say "\n\n🎉"
       ui.pause 0.6
 
-      ui.say "And you're set. Danger is a collaboration between Orta Therox, Gem 'Danger' McShane and Felix Krause."
+      ui.say "And you're good to go. Danger is a collaboration between Orta Therox, Gem 'Danger' McShane and Felix Krause."
       ui.say "If you like it, let others know. If you want to know more, follow " + "@orta".yellow + " and " + "@KrauseFx".yellow + " on Twitter."
       ui.say "If you don't like it, help us improve it! xxx"
     end

data/lib/danger/commands/local.rb

@@ -5,9 +5,16 @@ module Danger
 
     def initialize(argv)
       @dangerfile_path = "Dangerfile" if File.exist? "Dangerfile"
+      @pr_num = argv.option('use-merged-pr')
       super
     end
 
+    def self.options
+      [
+        ['--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
+
     def validate!
       super
       unless @dangerfile_path
@@ -17,9 +24,11 @@ module Danger
 
     def run
       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?
@@ -41,15 +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.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/new_plugin.rb

@@ -3,14 +3,6 @@ module Danger
     self.summary = 'Generate a new danger plugin.'
     self.command = 'new_plugin'
 
-    def initialize(argv)
-      super
-    end
-
-    def validate!
-      super
-    end
-
     def run
       require 'fileutils'
 

data/lib/danger/commands/runner.rb

@@ -6,9 +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
@@ -24,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/core_ext/string.rb

@@ -3,6 +3,10 @@ class String
     split('_').collect!(&:capitalize).join
   end
 
+  def danger_pluralize(count)
+    "#{count} #{self}#{'s' unless count == 1}"
+  end
+
   def danger_underscore
     self.gsub(/::/, '/').
       gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').

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