danger 0.10.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d02824eab3497550f11cb1f628aa5b3e94e31ad8
-  data.tar.gz: 5f17dbe1aec05cb99751f902f19f2c886893336d
+  metadata.gz: db32b8346a72c88968c63bae306a254f91484df2
+  data.tar.gz: df97dfe2ec512b2ee4fb0fa16161b6b4cffc2307
 SHA512:
-  metadata.gz: 2788c9f4aa4c1d30efd031a5279d0f64ac29e1f4e98706ba6172d568e5a17207065ea1df78918de37a14ffc956696d9208bcdd2128bb3ef20d10506d33e93daf
-  data.tar.gz: 869128a91bfb572210f952ec5ce98ad7dc28f65aa04af219055a0fbde073f2c57cc40776153183125c6f38dcea574bf3ede0d43434a82e8d36c6e0294db79980
+  metadata.gz: 3a6bb147cd045c067b5121200b26a301f30672b96986793af3290c3fcc94549ecfcddd82210f67c990a98cb0a472da0997eecc71103b92c70c5a4cf7ab703a54
+  data.tar.gz: 9580fb003244cda3738463ab8f0b50f404229f1cc5376bd9b9db27ddcdf5cb5fd98d87a0ef8ebcac2d69dcef450c948ae831b0b4ce5315a5c6584f0f02f36ba1

data/README.md

@@ -8,238 +8,84 @@ Formalize your Pull Request etiquette.
 -------
 
 <p align="center">
-    <a href="#getting-started">Getting Started</a> &bull;
-    <a href="#usage-on-ci">Usage</a> &bull;
-    <a href="#dsl">DSL</a> &bull;
-    <a href="#plugins">Plugins</a> &bull;
-    <a href="#test-locally-with-danger-local">Local</a>
+    <a href="#what-is-danger">What is Danger?</a> &bull;
+    <a href="#im-here-to-help-out">Helping Out</a> &bull;
+    <a href="#tell-me-of-these-plugins">Plugin Development</a> &bull;
 </p>
 
 -------
 
-## Getting Started
-
-Add this line to your application's [Gemfile](https://guides.cocoapods.org/using/a-gemfile.html):
-
-```ruby
-gem 'danger'
-```
-
-Next, use Bundler to install the gem.
-
-```shell
-bundle install
-```
-
-After the gem is installed, you can run Danger's interactive getting started guide:
-
-```
-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
-
-```
-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, Drone CI and TeamCity. 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.
-
-## DSL
-
-&nbsp;  | &nbsp; | Danger :no_entry_sign:
--------------: | ------------- | ----
-:sparkles: | `lines_of_code` | The total amount of lines of code in the diff
-:pencil2:  | `modified_files` |  The list of modified files
-:ship: | `added_files` | The list of added files
-:recycle: | `deleted_files` | The list of removed files
-:abc:  | `pr_title` | The title of the PR
-:book:  | `pr_body` | The body of the PR
-:busts_in_silhouette:  | `pr_author` | The author who submitted the PR
-:bookmark: | `pr_labels` | The labels added to the PR
-
-The `Dangerfile` is a Ruby file, so really, you can do anything. However, at this stage you might need selling on the idea a bit more, so lets take some real examples:
-
-#### Dealing with WIP pull requests
-
-```ruby
-# Sometimes its a README fix, or something like that - which isn't relevant for
-# including in a CHANGELOG for example
-declared_trivial = pr_title.include? "#trivial"
-
-# Just to let people know
-warn("PR is classed as Work in Progress", sticky: false) if pr_title.include? "[WIP]"
-```
-
-#### Being cautious around specific files
-
-``` ruby
-# Devs shouldn't ship changes to this file
-fail("Developer Specific file shouldn't be changed", sticky: false) if modified_files.include?("Artsy/View_Controllers/App_Navigation/ARTopMenuViewController+DeveloperExtras.m")
-
-# Did you make analytics changes? Well you should also include a change to our analytics spec
-made_analytics_changes = modified_files.include?("/Artsy/App/ARAppDelegate+Analytics.m")
-made_analytics_specs_changes = modified_files.include?("/Artsy_Tests/Analytics_Tests/ARAppAnalyticsSpec.m")
-if made_analytics_changes
-  fail("Analytics changes should have reflected specs changes") if !made_analytics_specs_changes
-
-  # And pay extra attention anyway
-  message('Analytics dict changed, double check for ?: `@""` on new entries')
-  message('Also, double check the [Analytics Eigen schema](https://docs.google.com/spreadsheets/u/1/d/1bLbeOgVFaWzLSjxLOBDNOKs757-zBGoLSM1lIz3OPiI/edit#gid=497747862) if the changes are non-trivial.')
-end
-```
+## What is Danger?
 
-#### Pinging people when a specific file has changed
+Danger runs after your CI, and gives teams the chance to automate common code review chores.
 
-```ruby
-markdown("@orta something changed in elan!") if modified_files.include? "/components/lib/variables/colors.json"
-```
+This provides another logical step in your process, through this Danger can help lint your rote tasks in daily code review.
 
-If you wish to ping a person on a PR you'll need to use the `markdown` method rather than the `message`, `warn` or `fail` methods.
-This is because the HTML generated by the latter methods doesn't trigger GitHub's notification detection.
+You can use Danger to codify your teams norms. Leaving humans to think about harder problems.
 
-#### Exposing aspects of CI logs into the PR discussion
+## For example?
 
-```ruby
-build_log = File.read(File.join(ENV["CIRCLE_ARTIFACTS"], "xcode_test_raw.log"))
-snapshots_url = build_log.match(%r{https://eigen-ci.s3.amazonaws.com/\d+/index.html})
-fail("There were [snapshot errors](#{snapshots_url})") if snapshots_url
-```
+* Enforce CHANGELOGs
+* Enforce links to Trello/JIRA in PR/MR bodies
+* Enforce using descriptive labels
+* Look out for common anti-patterns
+* Highlight interesting build artifacts
+* Give specific files have extra focus 
 
-#### Available commands
+Danger simply provides the glue to let _you_ build out the rules specific to your team's culture. Offering a lot of useful metadata, and a comprehensive plugin system to share common issues. 
 
-Command | Description
-------------- | ----
-`fail` | Causes the PR to fail and print out the error on the PR
-`warn` | Prints out a warning to the PR, but still enables the merge button
-`message` | Show neutral messages on the PR
-`markdown` | Print raw markdown below the summary tables on the PR
-
-## Plugins
-
-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.
+## Getting Started
 
-In your `Dangerfile` you can import local or remote actions using
+Alright. So, actually, you may be in the wrong place. From here on in, this README is going to be for people who are interested in working on / improving on Danger. 
 
-```ruby
-import "./danger_plugins/work_in_progress_warning"
-# or
-import "https://raw.githubusercontent.com/danger/danger/master/danger_plugins/work_in_progress_warning.rb"
+We keep all of the end-user documentation inside [http://danger.systems](http://danger.systems).
 
-# Call those actions using
-work_in_progress_warning
+Some quick links: [Guides Index](http://danger.systems/guides.html), [DSL Reference](http://danger.systems/reference.html), [Getting Started](http://danger.systems/guides/getting_started.html) and [What does Danger Do?](http://danger.systems/guides/what_does_danger_do.html). 
 
-custom_plugin(variable: "value")
-```
+## I'm here to help out!
 
-To create a new plugin run
+Brilliant. So, let's get you set up.
 
+``` sh
+git clone https://github.com/danger/danger.git
+cd danger
+bundle install
+bundle exec rake spec
 ```
-danger new_plugin
-```
-
-This will generate a new Ruby file which you can modify to fit your needs.
-
-## Advanced
 
-You can access more detailed information by accessing the following variables
+This sets everything up and runs all of the tests. 
 
-&nbsp; | Danger :no_entry_sign:
-------------- | ----
-`env.request_source.pr_json` | The full JSON for the pull request
-`env.scm.diff` | The full [Diff](https://github.com/mojombo/grit/blob/master/lib/grit/diff.rb) file for the diff.
-`env.ci_source` | To get information like the repo slug or pull request ID
+#### Theory
 
-These are considered implementation details though, and may be subject to change in future releases. We're very
-open to turning useful bits into the official API.
+Danger has a [VISION.md](https://github.com/danger/danger/blob/master/VISION.md) file, this sums up the ideas around what Danger is. It's the lower bounds of what Danger means. Orta has written on handling, and creating Danger [on the Artsy blog](http://artsy.github.io/blog/categories/danger/) too.
 
-## Test locally with `danger local`
+#### Documentation
 
-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.
+The code you write may end up in the public part of the website, the easiest way to tell is that it is vastly overdocumented. If you are working in a space that looks over-documented, please be extra considerate to add documentation. We expect the consumers of that documentation to be non-rubyists, thus avoid specific jargon and try to provide duplicate overlapping examples.  
 
-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.
+#### Testing
 
-### Adding a new CI
-If the CI server you're using isn't available yet, you can build it yourself:
+So far, we've not really figured out the right way to make tests for our CLI commands. When we have done so, they've ended up brittle. So ideally, try to move any logic that would go into a command into separate classes, and test those. We're OK with the command not having coverage, but ideally the classes that make up what it does do.
 
-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:
+I'd strongly recommend using `bundle exec guard` to run your tests as you work. Any changes you make in the lib, or specs will have corresponding tests run instantly.
 
-- `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)
+#### Debugging
 
-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:
-
-```
-> Danger: Ignore "Developer Specific file shouldn't be changed"
-```
-
-## Sticky
-
-Danger can keep its history if a warning/error/message is marked as *sticky*. When the violation is resolved,
-Danger will update the comment to cross it out. If you don't want this behavior, just use `sticky: false`.
+Ruby is super dynamic, one of the best ways to debug is by using [pry](http://pryrepl.org/). We include pry for developers, when you have a problem copy these two lines just before your problem and follow the instructions from "[I Want To Be A Danger Wizard](http://danger.systems/guides/troubleshooting.html#i-want-to-be-a-danger-wizard)."
 
 ```ruby
-fail("PR needs labels", sticky: false) if pr_labels.empty?
+  require 'pry'      
+  binding.pry
 ```
 
-## Org-Wide Dangerfile
-
-To have consistent rules across the repos in your organisation, you can use a shared `Dangerfile`:
-
-1. create a repo on your GitHub organization called `danger` (or `Danger`)
-1. Add a `Dangerfile` to the root of that repo
-1. The new `Dangerfile` is ran after the current repo's `Dangerfile`
-
-The org `Dangerfile` will have access to all of the same plugins, and metadata. For an example, see [themoji/danger](https://github.com/Themoji/danger).
-
-## Multiple Dangers
-
-If one Danger is not enough for you, you can run several ones on the same PR. Just use the `danger_id` param. For example: 
-
-```
-bundle exec danger --danger_id=unit_tests
-```
-
-You can have each instance of Danger running on a different CI provider and even doing different validations. An use case would be:
-
-* `basic` runs on a Linux environment (such as Circle CI) and validates the PR itself (title, etc)
-* `compilation` runs on a Mac after running unit tests for your iOS app and comments about warnings, test failures, etc
-* `uitests` runs on a Mac after running UI Unit tests and comments about test failures
-
-## Useful bits of knowledge
-
-* You can set the base branch in the command line arguments see: `bundle exec danger --help`, if you commonly merge into non-master branches.
-* Appending `--verbose` to `bundle exec danger` will expose all of the variables that Danger provides, and their values in the shell.
-
-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!
+## Tell me of these Plugins
 
-## 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.
+* Make the "making a plugin" guide
+* Talk through the tech specs here
 
 ## License, Contributor's Guidelines and Code of Conduct
 
-We try to keep as much discussion as possible in GitHub issues, but also have a slack, if you'd like an invite ping [@Orta](https://twitter.com/orta/) a DM on twitter with your email. 
+We try to keep as much discussion as possible in GitHub issues, but also have a pretty inactive slack, if you'd like an invite ping [@Orta](https://twitter.com/orta/) a DM on twitter with your email. It's mostly interesting if you want to stay on top of Danger without all of the emails from GitHub. 
 
 > This project is open source under the MIT license, which means you have full access to the source code and can modify it to fit your own needs.
 

data/lib/danger/commands/init_helpers/interviewer.rb

@@ -72,7 +72,7 @@ module Danger
 
       print_info = proc do
         possible_answers.each_with_index do |answer, i|
-          the_answer = (i == 0) ? answer.underline : answer
+          the_answer = i.zero? ? answer.underline : answer
           ui.print " " + the_answer
           ui.print(" /") if i != possible_answers.length - 1
         end

data/lib/danger/commands/local.rb

@@ -61,7 +61,7 @@ module Danger
       # setup caching for Github calls to hitting the API rate limit too quickly
       cache_file = File.join(ENV["DANGER_TMPDIR"] || Dir.tmpdir, "danger_local_cache")
       cache = HTTPCache.new(cache_file, clear_cache: @clear_http_cache)
-      Octokit.middleware = Faraday::Builder.new do |builder|
+      Octokit.middleware = Faraday::RackBuilder.new do |builder|
         builder.use Faraday::HttpCache, store: cache, serializer: Marshal, shared_cache: false
         builder.use Octokit::Response::RaiseError
         builder.adapter Faraday.default_adapter

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

@@ -10,6 +10,7 @@ module Danger
     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))
@@ -28,6 +29,12 @@ module Danger
       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)
       paths = file_resolver.resolve_to_paths
@@ -40,7 +47,8 @@ module Danger
       linter.lint
       linter.print_summary(cork)
 
-      exit(1) if linter.failed?
+      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

@@ -8,7 +8,7 @@ module Danger
     self.summary = "Generates a README from a set of plugins"
     self.command = "readme"
 
-    attr_accessor :cork
+    attr_accessor :cork, :json
 
     def initialize(argv)
       @refs = argv.arguments! unless argv.arguments.empty?
@@ -37,7 +37,7 @@ module Danger
       parser.parse
 
       self.markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML, no_intra_emphasis: true)
-      self.json = JSON.parse(parser.to_json)
+      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)

data/lib/danger/danger_core/dangerfile.rb

@@ -8,8 +8,6 @@ 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
@@ -31,19 +29,14 @@ module Danger
     # These are the classes that are allowed to also use method_missing
     # in order to provide broader plugin support
     def self.core_plugin_classes
-      [
-        Danger::DangerfileMessagingPlugin,
-        Danger::DangerfileImportPlugin,
-        Danger::DangerfileGitHubPlugin,
-        Danger::DangerfileGitPlugin
-      ]
+      [Danger::DangerfileMessagingPlugin]
     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.
+    # get method_missing called correctly without overriding them.
 
     def warn(*args, &blk)
       method_missing(:warn, *args, &blk)
@@ -54,7 +47,10 @@ module Danger
     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.
+    # that the core DSLs have, then starts looking at plugins support.
+
+    # rubocop:disable Style/MethodMissing
+
     def method_missing(method_sym, *arguments, &_block)
       @core_plugins.each do |plugin|
         if plugin.public_methods(false).include?(method_sym)
@@ -201,7 +197,7 @@ module Danger
 
     def print_results
       status = status_report
-      return if (status[:errors] + status[:warnings] + status[:messages] + status[:markdowns]).count == 0
+      return if (status[:errors] + status[:warnings] + status[:messages] + status[:markdowns]).count.zero?
 
       ui.section("Results:") do
         [:errors, :warnings, :messages].each do |key|

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

@@ -8,6 +8,10 @@ module Danger
   #
   #          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
   #
   #          fail "Please add labels to this PR" if github.labels.empty?
@@ -15,13 +19,56 @@ module Danger
   # @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 "@#{pr_author} is not a contributor yet, would you like to join the Danger org?"
+  #            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
   #
   #          fail "Please provide a summary in the Pull Request description" if github.pr_body.length < 5
   #
+  # @example Only accept PRs to the develop branch
+  #
+  #          fail "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
 
@@ -104,7 +151,7 @@ module Danger
       pr_json[:head][:sha]
     end
 
-    # @!group GitHub Misca
+    # @!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/pr_response.json).
     # @return [Hash]
@@ -120,5 +167,36 @@ module Danger
     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 HTML anchor 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>`
+    # @return [String]
+    def html_link(paths)
+      paths = [paths] unless paths.kind_of?(Array)
+      commit = head_commit
+      repo = pr_json[:head][:repo][:html_url]
+      paths = paths.map do |path|
+        path_with_slash = "/#{path}" unless path.start_with? "/"
+        create_link("#{repo}/blob/#{commit}#{path_with_slash}", path)
+      end
+
+      return paths.first if paths.count < 2
+      paths.first(paths.count - 1).join(", ") + " & " + paths.last
+    end
+
+    private
+
+    def create_link(href, text)
+      "<a href='#{href}'>#{text}</a>"
+    end
   end
 end

data/lib/danger/plugin_support/plugin.rb

@@ -17,6 +17,8 @@ module Danger
 
     # Since we have a reference to the Dangerfile containing all the information
     # We need to redirect the self calls to the Dangerfile
+
+    # rubocop:disable Style/MethodMissing
     def method_missing(method_sym, *arguments, &block)
       @dangerfile.send(method_sym, *arguments, &block)
     end

data/lib/danger/plugin_support/plugin_file_resolver.rb

@@ -1,5 +1,6 @@
 require "bundler"
 require "pathname"
+require "fileutils"
 
 module Danger
   class PluginFileResolver
@@ -17,26 +18,25 @@ module Danger
       # When given a list of gems
       elsif @refs and @refs.kind_of? Array
         Bundler.with_clean_env do
-          Dir.mktmpdir do |dir|
-            gem_names = @refs
-            deps = gem_names.map { |name| Bundler::Dependency.new(name, ">= 0") }
+          # We don't use the block syntax as we want it to persist until the OS cleans it on reboot
+          # or whatever, it needs to persist outside this scope.
+          dir = Dir.mktmpdir
 
-            # Use Gems from rubygems.org
-            source = Bundler::SourceList.new
-            source.add_rubygems_remote("https://rubygems.org")
+          Dir.chdir(dir) do
+            gem_names = @refs
+            gemfile = File.new("Gemfile", "w")
+            gemfile.write "source 'https://rubygems.org'"
 
-            # Create a definition to bundle, make sure it always updates
-            # and uses the latest version from the server
-            bundler = Bundler::Definition.new(nil, deps, source, true)
-            bundler.resolve_remotely!
+            gem_names.each do |plugin|
+              gemfile.write "\ngem '#{plugin}'"
+            end
 
-            # Install the gems into a tmp dir
-            options = { path: dir }
-            Bundler::Installer.install(Pathname.new(dir), bundler, options)
+            gemfile.close
+            `bundle install --path vendor/gems`
 
-            # Get the name'd gems out of bundler, then pull out all their paths
-            gems = gem_names.flat_map { |name| bundler.specs[name] }
-            gems.flat_map { |gem| Dir.glob(File.join(gem.gem_dir, "lib/**/**/**.rb")) }
+            # the paths are relative to our current Chdir
+            relative_paths = gem_names.flat_map { |plugin| Dir.glob("vendor/gems/ruby/*/gems/#{plugin}*/lib/**/**/**/**.rb") }
+            relative_paths.map { |path| File.join(dir, path) }
           end
         end
       # When empty, imply you want to test the current lib folder as a plugin

data/lib/danger/plugin_support/plugin_linter.rb

@@ -65,14 +65,16 @@ module Danger
       end
 
       # A generic proc to handle the similarities between
-      # erros and warnings.
+      # errors and warnings.
       do_rules = proc do |name, rules|
         unless rules.empty?
           ui.puts ""
           ui.section(name.bold) do
             rules.each do |rule|
               title = rule.title.bold + " - #{rule.object_applied_to}"
-              ui.labeled(title, [rule.description, link(rule.ref)])
+              subtitles = [rule.description, link(rule.ref)]
+              subtitles += [rule.metadata[:files].join(":")] if rule.metadata[:files]
+              ui.labeled(title, subtitles)
               ui.puts ""
             end
           end
@@ -115,8 +117,12 @@ module Danger
         Rule.new(:warning, 43..45, "Params", "You should give a 'type' for the param, yes, ruby is duck-typey but it's useful for newbies to the language, use `@param [Type] name`.", proc do |json|
           json[:param_couplets] && json[:param_couplets].flat_map(&:values).include?(nil)
         end),
+        Rule.new(:warning, 43..45, "Unknown Param", "You should give a 'type' for the param, yes, ruby is duck-typey but it's useful for newbies to the language, use `@param [Type] name`.", proc do |json|
+          json[:param_couplets] && json[:param_couplets].flat_map(&:values).include?("Unknown")
+        end),
         Rule.new(:warning, 46, "Return Type", "If the function has no useful return value, use ` @return  [void]` - this will be ignored by documentation generators.", proc do |json|
-          json[:return] && json[:return].empty?
+          return_hash = json[:tags].find { |tag| tag[:name] == "return" }
+          !(return_hash && return_hash[:types] && !return_hash[:types].first.empty?)
         end)
       ]
     end

data/lib/danger/plugin_support/plugin_parser.rb

@@ -103,29 +103,37 @@ module Danger
       ""
     end
 
-    def method_params(params)
-      return {} unless params[:params]
+    def method_params(method)
+      return {} unless method[:params]
 
-      params_names = params[:params].compact.flat_map(&:first)
-      params_values = params[:tags].find { |t| t[:name] == "param" }
+      params_names = method[:params].map { |param| param.compact.join("=").strip }
+      params_values = method[:tags].select { |t| t[:name] == "param" }
 
-      return {} if params_values.nil?
-      return {} if params_values[:types].nil?
+      return {} if params_values.empty?
+      return {} if params_values.select { |p| p[:types] }.empty?
 
       return params_names.map.with_index do |name, index|
-        { name => params_values[:types][index] }
+        name = name.delete ":"
+        if index < params_values.length
+          type = params_values[index][:types]
+          { name => type ? type.first : "Unknown" }
+        else
+          { name => "Unknown" }
+        end
       end
     end
 
-    def method_parser(meth)
+    def method_parser(gem_path, meth)
       return nil if meth.nil?
       method = {
         name: meth.name,
         body_md: meth.docstring,
         params: meth.parameters,
+        files: meth.files.map { |item| [item.first.gsub(gem_path, ""), item.last] },
         tags: meth.tags.map { |t| { name: t.tag_name, types: t.types } }
       }
 
+
       return_v = method_return_string(method)
       params_v = method_params(method)
 
@@ -148,10 +156,10 @@ module Danger
       method
     end
 
-    def attribute_parser(attribute)
+    def attribute_parser(gem_path, attribute)
       {
-        read: method_parser(attribute[:read]),
-        write: method_parser(attribute[:write])
+        read: method_parser(gem_path, attribute[:read]),
+        write: method_parser(gem_path, attribute[:write])
       }
     end
 
@@ -165,16 +173,24 @@ module Danger
         methods = klass.meths - klass.inherited_meths - attribute_meths
         usable_methods = methods.select { |m| m.visibility == :public }.reject { |m| m.name == :initialize || m.name == :instance_name }
 
+        plugin_gem = klass.file.include?("gems") ? klass.file.split("gems/").last.split("-")[0..-2].join("-") : nil
+        # Pull out the gem's path ( to make relative file paths )
+        # if no gem is found, index  = 0, making gem_path = ""
+        index_of_gem_in_path = plugin_gem ? klass.file.split("/").index { |component| component.include? plugin_gem } : 0
+        gem_path = klass.file.split("/")[0..index_of_gem_in_path].join("/")
+
         {
           name: klass.name.to_s,
           body_md: klass.docstring,
           instance_name: real_klass.instance_name,
+          gem: plugin_gem,
+          gem_path: gem_path,
+          files: klass.files.map { |item| [item.first.gsub(gem_path, ""), item.last] },
           example_code: klass.tags.select { |t| t.tag_name == "example" }.map { |tag| { title: tag.name, text: tag.text } }.compact,
-          attributes: klass.attributes[:instance].map { |pair| { pair.first => attribute_parser(pair.last) } },
-          methods: usable_methods.map { |m| method_parser(m) },
+          attributes: klass.attributes[:instance].map { |pair| { pair.first => attribute_parser(gem_path, pair.last) } },
+          methods: usable_methods.map { |m| method_parser(gem_path, m) },
           tags: klass.tags.select { |t| t.tag_name == "tags" }.map(&:text).compact,
           see: klass.tags.select { |t| t.tag_name == "see" }.map(&:name).map(&:split).flatten.compact,
-          file: klass.file.gsub(File.expand_path("."), "")
         }
       end
     end

data/lib/danger/request_source/github.rb

@@ -36,6 +36,10 @@ module Danger
         @markdown_parser ||= Redcarpet::Markdown.new(Redcarpet::Render::HTML, no_intra_emphasis: true)
       end
 
+      def pr_diff
+        @pr_diff ||= client.pull_request(ci_source.repo_slug, ci_source.pull_request_id, accept: 'application/vnd.github.v3.diff')
+      end
+
       def setup_danger_branches
         # we can use a github specific feature here:
         base_commit = self.pr_json[:base][:sha]
@@ -107,7 +111,7 @@ module Danger
       end
 
       def submit_pull_request_status!(warnings: [], errors: [], details_url: [])
-        status = (errors.count == 0 ? 'success' : 'failure')
+        status = (errors.count.zero? ? 'success' : 'failure')
         message = generate_github_description(warnings: warnings, errors: errors)
 
         latest_pr_commit_ref = self.pr_json[:head][:sha]

data/lib/danger/version.rb

@@ -1,4 +1,4 @@
 module Danger
-  VERSION = "0.10.1".freeze
+  VERSION = "2.0.0".freeze
   DESCRIPTION = "Automate your PR etiquette.".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: danger
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Orta Therox
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-23 00:00:00.000000000 Z
+date: 2016-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide
@@ -29,16 +29,16 @@ dependencies:
   name: claide-plugins
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: git
   requirement: !ruby/object:Gem::Requirement
@@ -383,9 +383,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Automate your PR etiquette.
 test_files: []
-has_rdoc: