danger 0.7.4 → 0.8.0

data/lib/danger/danger_core/dangerfile_dsl.rb

@@ -0,0 +1,29 @@
+module Danger
+  class Dangerfile
+    # Anything inside this module is considered public API, and in the future
+    # documentation will be generated from it via rdoc.
+
+    module DSL
+      # @!group Danger Zone
+      # Provides access to the raw Travis/Circle/Buildkite/GitHub objects, which
+      # you can use to pull out extra bits of information. _Warning_
+      # the interfaces of these objects is **not** considered a part of the Dangerfile public
+      # API, and is viable to change occasionally on the whims of developers.
+      # @return [EnvironmentManager]
+
+      attr_reader :env
+
+      private
+
+      def initialize
+        load_default_plugins
+      end
+
+      def load_default_plugins
+        Dir["./danger_plugins/*.rb"].each do |file|
+          require File.expand_path(file)
+        end
+      end
+    end
+  end
+end

data/lib/danger/{environment_manager.rb → danger_core/environment_manager.rb}

@@ -1,5 +1,5 @@
 require "danger/ci_source/ci_source"
-require "danger/request_sources/github"
+require "danger/request_source/github"
 
 module Danger
   class EnvironmentManager
@@ -15,7 +15,6 @@ module Danger
         if self.ci_source.repo_slug and self.ci_source.pull_request_id
           break
         else
-          puts "Not a Pull Request - skipping `danger` run"
           self.ci_source = nil
           return nil
         end
@@ -25,18 +24,27 @@ module Danger
 
       # only GitHub for now, open for PRs adding more!
       self.request_source = GitHub.new(self.ci_source, ENV)
+      # Also Git only for now, also open for PRs adding more!
+      self.scm = GitRepo.new # For now
+    end
+
+    def pr?
+      self.ci_source != nil
     end
 
     def fill_environment_vars
       request_source.fetch_details
-
-      self.scm = GitRepo.new # For now
     end
 
     def ensure_danger_branches_are_setup
+      clean_up
+
       # As this currently just works with GitHub, we can use a github specific feature here:
       pull_id = ci_source.pull_request_id
-      test_branch = request_source.base_commit
+
+      # TODO: This isn't optimal, should be hidden behind some kind of facade, but the plugin makes that
+      # difficult to do without accessing the dangerfile
+      test_branch = request_source.pr_json[:base][:sha]
 
       # Next, we want to ensure that we have a version of the current branch at a known location
       scm.exec "branch #{danger_base_branch} #{test_branch}"
@@ -48,7 +56,7 @@ module Danger
 
     def clean_up
       [danger_base_branch, danger_base_branch].each do |branch|
-        scm.exec "branch -D #{branch}"
+        scm.exec("branch -D #{branch}") unless scm.exec("rev-parse --quiet --verify #{branch}").empty?
       end
     end
 

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

@@ -0,0 +1,69 @@
+require 'danger/plugin_support/plugin'
+require 'danger/core_ext/file_list'
+
+module Danger
+  class DangerfileGitPlugin < Plugin
+    def initialize(dangerfile)
+      super(dangerfile)
+      raise  unless dangerfile.env.scm.class == Danger::GitRepo
+
+      @git = dangerfile.env.scm
+    end
+
+    # @!group Git Files
+    # Paths for files that were added during the diff
+    # @return [FileList] an [Array] subclass
+    #
+    def added_files
+      Danger::FileList.new(@git.diff.select { |diff| diff.type == "new" }.map(&:path))
+    end
+
+    # @!group Git Files
+    # Paths for files that were removed during the diff
+    # @return [FileList] an [Array] subclass
+    #
+    def deleted_files
+      Danger::FileList.new(@git.diff.select { |diff| diff.type == "deleted" }.map(&:path))
+    end
+
+    # @!group Git Files
+    # Paths for files that changed during the diff
+    # @return [FileList] an [Array] subclass
+    #
+    def modified_files
+      Danger::FileList.new(@git.diff.stats[:files].keys)
+    end
+
+    # @!group Git Metadata
+    # The overall lines of code added/removed in the diff
+    # @return Int
+    #
+    def lines_of_code
+      @git.diff.lines
+    end
+
+    # @!group Git Metadata
+    # The overall lines of code removed in the diff
+    # @return Int
+    #
+    def deletions
+      @git.diff.deletions
+    end
+
+    # @!group Git Metadata
+    # The overall lines of code added in the diff
+    # @return Int
+    #
+    def insertions
+      @git.diff.insertions
+    end
+
+    # @!group Git Metadata
+    # The log of commits inside the diff
+    # @return [Git::Log] from the gem `git`
+    #
+    def commits
+      @git.log.to_a
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'danger/plugin_support/plugin'
+
+module Danger
+  class DangerfileGitHubPlugin < Plugin
+    def initialize(dangerfile)
+      super(dangerfile)
+      return nil unless dangerfile.env.request_source.class == Danger::GitHub
+
+      @github = dangerfile.env.request_source
+    end
+
+    # @!group PR Metadata
+    # The title of the Pull Request
+    # @return String
+    #
+    def pr_title
+      @github.pr_json[:title].to_s
+    end
+
+    # @!group PR Metadata
+    # The body text of the Pull Request
+    # @return String
+    #
+    def pr_body
+      @github.pr_json[:body].to_s
+    end
+
+    # @!group PR Metadata
+    # The username of the author of the Pull Request
+    # @return String
+    #
+    def pr_author
+      @github.pr_json[:user][:login].to_s
+    end
+
+    # @!group PR Metadata
+    # The labels assigned to the Pull Request
+    # @return [String]
+    #
+    def pr_labels
+      @github.issue_json[:labels].map { |l| l[:name] }
+    end
+
+    # @!group PR Commit Metadata
+    # The branch to which the PR is going to be merged into
+    # @return String
+    #
+    def branch_for_merge
+      @github.pr_json[:base][:ref]
+    end
+
+    # @!group PR Commit Metadata
+    # The base commit to which the PR is going to be merged as a parent
+    # @return String
+    #
+    def base_commit
+      @github.pr_json[:base][:sha]
+    end
+
+    # @!group PR Commit Metadata
+    # The head commit to which the PR is requesting to be merged from
+    # @return String
+    #
+    def head_commit
+      @github.pr_json[:head][:sha]
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'danger/plugin_support/plugin'
+
+module Danger
+  class DangerfileImportPlugin < Plugin
+    # @!group Plugins
+    # Download a local or remote plugin and use it locally
+    #
+    # @param    [String] path
+    #           a local path or a https URL to the Ruby file to import
+    #           a danger plugin from.
+    def import(path)
+      raise "`import` requires a string" unless path.kind_of?(String)
+      path += ".rb" unless path.end_with?(".rb")
+
+      if path.start_with?("http")
+        import_url(path)
+      else
+        import_local(path)
+      end
+    end
+
+    # @!group Plugins
+    # Download a remote plugin and use it locally
+    #
+    # @param    [String] url
+    #           https URL to the Ruby file to use
+    def import_url(url)
+      raise "URL is not https, for security reasons `danger` only supports encrypted requests" unless url.start_with?("https://")
+
+      require 'tmpdir'
+      require 'faraday'
+
+      @http_client ||= Faraday.new do |b|
+        b.adapter :net_http
+      end
+      content = @http_client.get(url)
+
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, "temporary_remote_action.rb")
+        File.write(path, content.body)
+        import_local(path)
+      end
+    end
+
+    # @!group Plugins
+    # Import one or more local plugins
+    #
+    # @param    [String] path
+    #           The path to the file to import
+    #           Can also be a pattern (./**/*plugin.rb)
+    def import_local(path)
+      Dir[path].each do |file|
+        require File.expand_path(file) # without the expand_path it would fail if the path doesn't start with ./
+        refresh_plugins
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'danger/danger_core/violation'
+require 'danger/plugin_support/plugin'
+
+module Danger
+  class DangerfileMessagingPlugin < Plugin
+    def initialize(dangerfile)
+      super(dangerfile)
+
+      @warnings = []
+      @errors = []
+      @messages = []
+      @markdowns = []
+    end
+
+    # @!group Core
+    # Print markdown to below the table
+    #
+    # @param    [String] message
+    #           The markdown based message to be printed below the table
+    def markdown(message)
+      @markdowns << message
+      puts "Printing markdown #{message}"
+    end
+
+    # @!group Core
+    # Print out a generate message on the PR
+    #
+    # @param    [String] message The message to present to the user
+    # @param    [Boolean] sticky
+    #           Whether the message should be kept after it was fixed,
+    #           defaults to `true`.
+    def message(message, sticky: true)
+      @messages << Violation.new(message, sticky)
+      puts "Printing message '#{message}'"
+    end
+
+    # @!group Core
+    # Specifies a problem, but not critical
+    #
+    # @param    [String] message The message to present to the user
+    # @param    [Boolean] sticky
+    #           Whether the message should be kept after it was fixed,
+    #           defaults to `true`.
+    def warn(message, sticky: true)
+      return if should_ignore_violation(message)
+      @warnings << Violation.new(message, sticky)
+      puts "Printing warning '#{message}'"
+    end
+
+    # @!group Core
+    # Declares a CI blocking error
+    #
+    # @param    [String] message
+    #           The message to present to the user
+    # @param    [Boolean] sticky
+    #           Whether the message should be kept after it was fixed,
+    #           defaults to `true`.
+    def fail(message, sticky: true)
+      return if should_ignore_violation(message)
+      @errors << Violation.new(message, sticky)
+      puts "Raising error '#{message}'"
+    end
+
+    def status_report
+      {
+        errors: @errors.map(&:message).clone.freeze,
+        warnings: @warnings.map(&:message).clone.freeze,
+        messages: @messages.map(&:message).clone.freeze,
+        markdowns: @markdowns.clone.freeze
+      }
+    end
+
+    def violation_report
+      {
+        errors: @errors.clone.freeze,
+        warnings: @warnings.clone.freeze,
+        messages: @messages.clone.freeze
+      }
+    end
+
+    private
+
+    def should_ignore_violation(message)
+      env.request_source.ignored_violations.include? message
+    end
+  end
+end

data/lib/danger/{standard_error.rb → danger_core/standard_error.rb}

@@ -2,7 +2,7 @@ require 'claide'
 require 'claide/informative_error'
 
 module Danger
-  # Ripped direct from CocoaPods-Core - thanks!
+  # From below here - this entire file was taken verbatim for CocoaPods-Core.
 
   #-------------------------------------------------------------------------#
 

data/lib/danger/plugin_support/plugin.rb

@@ -0,0 +1,31 @@
+module Danger
+  class Plugin
+    def initialize(dangerfile)
+      @dangerfile = dangerfile
+    end
+
+    def self.instance_name
+      self.to_s.gsub("Danger", "").danger_underscore.split('/').last
+    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
+
+    # Since we have a reference to the Dangerfile containing all the information
+    # We need to redirect the self calls to the Dangerfile
+    def method_missing(method_sym, *arguments, &_block)
+      @dangerfile.send(method_sym, *arguments)
+    end
+  end
+end

data/lib/danger/plugin_support/plugin_parser.rb

@@ -0,0 +1,70 @@
+require 'yard'
+
+module Danger
+  class PluginParser
+    attr_accessor :registry
+
+    def initialize(path)
+      @path = path
+    end
+
+    def parse
+      # could this go in a singleton-y place instead?
+      # like class initialize?
+      YARD::Tags::Library.define_tag('tags', :tags)
+
+      files = ["lib/danger/plugin_support/plugin.rb", @path]
+      self.registry = YARD::Registry.load(files, true)
+    end
+
+    def classes_in_file
+      self.registry.all
+          .select { |thing| thing.type == :class }
+          .select { |klass| klass.file == @path }
+    end
+
+    def plugins_from_classes(classes)
+      classes.select { |klass| klass.inheritance_tree.map(&:name).include? :Plugin }
+    end
+
+    def to_dict(classes)
+      d_meth = lambda do |meth|
+        return nil if meth.nil?
+        {
+          name: meth.name,
+          body_md: meth.docstring,
+          tags: meth.tags.map do |t|
+            {
+               name: t.tag_name,
+               types: t.types
+            }
+          end
+        }
+      end
+
+      d_attr = lambda do |attribute|
+        {
+          read: d_meth.call(attribute[:read]),
+          write: d_meth.call(attribute[:write])
+        }
+      end
+
+      classes.map do |klass|
+        {
+        name: klass.name.to_s,
+        body_md: klass.docstring,
+        example_code: klass.tags.select { |t| t.tag_name == "example" }.map(&:text).compact,
+        attributes: klass.attributes[:instance].map do |pair|
+          {
+          pair.first => d_attr.call(pair.last)
+        }
+        end,
+        methods: (klass.meths - klass.inherited_meths).select { |m| m.visibility == :public }.map { |m| d_meth.call(m) },
+        tags: klass.tags.select { |t| t.tag_name == "tags" }.map(&:name).compact,
+        see: klass.tags.select { |t| t.tag_name == "see" }.map(&:name).map(&:split).flatten.compact,
+        file: klass.file
+      }
+      end
+    end
+  end
+end