danger 8.0.3

data/lib/danger/helpers/emoji_mapper.rb

@@ -0,0 +1,41 @@
+module Danger
+  class EmojiMapper
+    DATA = {
+      "github" => {
+        "no_entry_sign"    => "🚫",
+        "warning"          => "⚠️",
+        "book"             => "📖",
+        "white_check_mark" => "✅"
+      },
+      "bitbucket_server" => {
+        "no_entry_sign"    => ":no_entry_sign:",
+        "warning"          => ":warning:",
+        "book"             => ":book:",
+        "white_check_mark" => ":white_check_mark:"
+      }
+    }.freeze
+
+    TYPE_TO_EMOJI = {
+      error: "no_entry_sign",
+      warning: "warning",
+      message: "book",
+    }.freeze
+
+    def initialize(template)
+      @template = DATA.has_key?(template) ? template : "github"
+    end
+
+    def map(emoji)
+      emoji&.delete! ":"
+      DATA[template][emoji]
+    end
+
+    def from_type(type)
+      map(TYPE_TO_EMOJI[type])
+    end
+
+    private
+
+    attr_reader :template
+  end
+end

data/lib/danger/helpers/find_max_num_violations.rb

@@ -0,0 +1,31 @@
+# Find max_num_violations in lib/danger/comment_generators/github.md.erb.
+class FindMaxNumViolations
+  # Save ~ 5000 for contents other than violations to avoid exceeded 65536 max comment length limit.
+  LIMIT = 60_000
+
+  def initialize(violations)
+    @violations = violations
+  end
+
+  def call
+    total = 0
+    num_of_violations_allowed = 0
+
+    violations.each do |violation|
+      message_length = violation.message.length + 80 # 80 is ~ the size of html wraps violation message.
+
+      if total + message_length < LIMIT
+        total += message_length
+        num_of_violations_allowed += 1
+      else
+        break
+      end
+    end
+
+    num_of_violations_allowed
+  end
+
+  private
+
+  attr_reader :violations
+end

data/lib/danger/helpers/message_groups_array_helper.rb

@@ -0,0 +1,31 @@
+module Danger
+  module Helpers
+    module MessageGroupsArrayHelper
+      FakeArray = Struct.new(:count) do
+        def empty?
+          count.zero?
+        end
+      end
+
+      def fake_warnings_array
+        FakeArray.new(counts[:warnings])
+      end
+
+      def fake_errors_array
+        FakeArray.new(counts[:errors])
+      end
+
+      def counts
+        return @counts if @counts
+
+        @counts = { warnings: 0, errors: 0 }
+        each do |message_group, counts|
+          group_stats = message_group.stats
+          @counts[:warnings] += group_stats[:warnings_count]
+          @counts[:errors] += group_stats[:errors_count]
+        end
+        @counts
+      end
+    end
+  end
+end

data/lib/danger/plugin_support/gems_resolver.rb

@@ -0,0 +1,77 @@
+require "bundler"
+
+module Danger
+  class GemsResolver
+    def initialize(gem_names)
+      @gem_names = gem_names
+      @dir = Dir.mktmpdir # We want it to persist until OS cleans it on reboot
+    end
+
+    # Returns an Array of paths (plugin lib file paths) and gems (of metadata)
+    def call
+      path_gems = []
+
+      Bundler.with_clean_env do
+        Dir.chdir(dir) do
+          create_gemfile_from_gem_names
+          `bundle install --path vendor/gems`
+          path_gems = all_gems_metadata
+        end
+      end
+
+      return path_gems
+    end
+
+    private
+
+    attr_reader :gem_names, :dir
+
+    def all_gems_metadata
+      return paths, gems
+    end
+
+    def create_gemfile_from_gem_names
+      gemfile = File.new("Gemfile", "w")
+      gemfile.write "source 'https://rubygems.org'"
+
+      gem_names.each do |plugin|
+        gemfile.write "\ngem '#{plugin}'"
+      end
+
+      gemfile.close
+    end
+
+    # The paths are relative to dir.
+    def paths
+      relative_paths = gem_names.flat_map do |plugin|
+        Dir.glob("vendor/gems/ruby/*/gems/#{plugin}*/lib/**/**/**/**.rb")
+      end
+
+      relative_paths.map { |path| File.join(dir, path) }
+    end
+
+    def gems
+      real_gems.map { |gem| gem_metadata(gem) }
+    end
+
+    def real_gems
+      spec_paths = gem_names.flat_map do |plugin|
+        Dir.glob("vendor/gems/ruby/*/specifications/#{plugin}*.gemspec").first
+      end
+
+      spec_paths.map { |path| Gem::Specification.load path }
+    end
+
+    def gem_metadata(gem)
+      {
+        name: gem.name,
+        gem: gem.name,
+        author: gem.authors,
+        url: gem.homepage,
+        description: gem.summary,
+        license: gem.license || "Unknown",
+        version: gem.version.to_s
+      }
+    end
+  end
+end

data/lib/danger/plugin_support/plugin.rb

@@ -0,0 +1,49 @@
+module Danger
+  class Plugin
+    def initialize(dangerfile)
+      @dangerfile = dangerfile
+    end
+
+    def self.instance_name
+      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.
+    undef :warn, :fail
+
+    # 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
+
+    def self.all_plugins
+      @all_plugins ||= []
+    end
+
+    def self.clear_external_plugins
+      @all_plugins = @all_plugins.select { |plugin| Dangerfile.essential_plugin_classes.include? plugin }
+    end
+
+    def self.inherited(plugin)
+      Plugin.all_plugins.push(plugin)
+    end
+
+    private
+
+    # When using `danger local --pry`, every plugin had an unreasonable
+    # amount of text output due to the Dangerfile reference in every
+    # plugin. So, it is filtered out. Users will start out in the context
+    # of the Dangerfile, and can view it by just typing `self` into the REPL.
+    #
+    def pretty_print_instance_variables
+      super - [:@dangerfile]
+    end
+  end
+end

data/lib/danger/plugin_support/plugin_file_resolver.rb

@@ -0,0 +1,30 @@
+require "danger/plugin_support/gems_resolver"
+
+module Danger
+  class PluginFileResolver
+    # Takes an array of files, gems or nothing, then resolves them into
+    # paths that should be sent into the documentation parser
+    def initialize(references)
+      @refs = references
+    end
+
+    # When given existing paths, map to absolute & existing paths
+    # When given a list of gems, resolve for list of gems
+    # When empty, imply you want to test the current lib folder as a plugin
+    def resolve
+      if !refs.nil? and refs.select { |ref| File.file? ref }.any?
+        paths = refs.select { |ref| File.file? ref }.map { |path| File.expand_path(path) }
+      elsif refs and refs.kind_of? Array
+        paths, gems = GemsResolver.new(refs).call
+      else
+        paths = Dir.glob(File.join(".", "lib/**/*.rb")).map { |path| File.expand_path(path) }
+      end
+
+      { paths: paths, gems: gems || [] }
+    end
+
+    private
+
+    attr_reader :refs
+  end
+end

data/lib/danger/plugin_support/plugin_linter.rb

@@ -0,0 +1,161 @@
+module Danger
+  class PluginLinter
+    # An internal class that is used to represent a rule for the linter.
+    class Rule
+      attr_accessor :modifier, :description, :title, :function, :ref, :metadata, :type
+
+      def initialize(modifier, ref, title, description, function)
+        @modifier = modifier
+        @title = title
+        @description = description
+        @function = function
+        @ref = ref
+      end
+
+      def object_applied_to
+        metadata[:name].to_s.bold + " (" + type + ")"
+      end
+    end
+
+    attr_accessor :json, :warnings, :errors
+
+    def initialize(json)
+      @json = json
+      @warnings = []
+      @errors = []
+    end
+
+    # Lints the current JSON, looking at:
+    # * Class rules
+    # * Method rules
+    # * Attribute rules
+    #
+    def lint
+      json.each do |plugin|
+        apply_rules(plugin, "class", class_rules)
+
+        plugin[:methods].each do |method|
+          apply_rules(method, "method", method_rules)
+        end
+
+        plugin[:attributes].each do |method_hash|
+          method_name = method_hash.keys.first
+          method = method_hash[method_name]
+
+          value = method[:write] || method[:read]
+          apply_rules(value, "attribute", method_rules)
+        end
+      end
+    end
+
+    # Did the linter pass/fail?
+    #
+    def failed?
+      errors.count > 0
+    end
+
+    # Prints a summary of the errors and warnings.
+    #
+    def print_summary(ui)
+      # Print whether it passed/failed at the top
+      if failed?
+        ui.puts "\n[!] Failed\n".red
+      else
+        ui.notice "Passed"
+      end
+
+      # A generic proc to handle the similarities between
+      # 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}"
+              subtitles = [rule.description, link(rule.ref)]
+              subtitles += [rule.metadata[:files].join(":")] if rule.metadata[:files]
+              ui.labeled(title, subtitles)
+              ui.puts ""
+            end
+          end
+        end
+      end
+
+      # Run the rules
+      do_rules.call("Errors".red, errors)
+      do_rules.call("Warnings".yellow, warnings)
+    end
+
+    private
+
+    # Rules that apply to a class
+    #
+    def class_rules
+      [
+        Rule.new(:error, 4..6, "Description Markdown", "Above your class you need documentation that covers the scope, and the usage of your plugin.", proc do |json|
+          json[:body_md] && json[:body_md].empty?
+        end),
+        Rule.new(:warning, 30, "Tags", "This plugin does not include `@tags tag1, tag2` and thus will be harder to find in search.", proc do |json|
+          json[:tags] && json[:tags].empty?
+        end),
+        Rule.new(:warning, 29, "References", "Ideally, you have a reference implementation of your plugin that you can show to people, add `@see org/repo` to have the site auto link it.", proc do |json|
+          json[:see] && json[:see].empty?
+        end),
+        Rule.new(:error, 8..27, "Examples", "You should include some examples of common use-cases for your plugin.", proc do |json|
+          json[:example_code] && json[:example_code].empty?
+        end)
+      ]
+    end
+
+    # Rules that apply to individual methods, and attributes
+    #
+    def method_rules
+      [
+        Rule.new(:error, 40..41, "Description", "You should include a description for your method.", proc do |json|
+          json[:body_md] && json[:body_md].empty?
+        end),
+        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|
+          return_hash = json[:tags].find { |tag| tag[:name] == "return" }
+          !(return_hash && return_hash[:types] && !return_hash[:types].first.empty?)
+        end)
+      ]
+    end
+
+    # Generates a link to see an example of said rule
+    #
+    def link(ref)
+      if ref.kind_of?(Range)
+        "@see - " + "https://github.com/dbgrandi/danger-prose/blob/v2.0.0/lib/danger_plugin.rb#L#{ref.min}#-L#{ref.max}".blue
+      elsif ref.kind_of?(Integer)
+        "@see - " + "https://github.com/dbgrandi/danger-prose/blob/v2.0.0/lib/danger_plugin.rb#L#{ref}".blue
+      else
+        "@see - " + "https://github.com/dbgrandi/danger-prose/blob/v2.0.0/lib/danger_plugin.rb".blue
+      end
+    end
+
+    # Runs the rule, if it fails then additional metadata
+    # is added to the rule (for printing later) and it's
+    # added to either `warnings` or `errors`.
+    #
+    def apply_rules(json, type, rules)
+      rules.each do |rule|
+        next unless rule.function.call(json)
+        rule.metadata = json
+        rule.type = type
+
+        case rule.modifier
+        when :warning
+          warnings << rule
+        when :error
+          errors << rule
+        end
+      end
+    end
+  end
+end

data/lib/danger/plugin_support/plugin_parser.rb

@@ -0,0 +1,199 @@
+require "json"
+
+=begin
+
+  So you want to improve this? Great. Hard thing is getting yourself into a position where you
+  have access to all the tokens, so here's something you should run in `bundle exec pry` to dig in:
+
+      require 'danger'
+      require 'yard'
+      parser = Danger::PluginParser.new "spec/fixtures/plugins/example_fully_documented.rb"
+      parser.parse
+      plugins = parser.plugins_from_classes(parser.classes_in_file)
+      git = plugins.first
+      klass = git
+      parser.to_dict(plugins)
+
+  Then some helpers
+
+      attribute_meths = klass.attributes[:instance].values.map(&:values).flatten
+
+      methods = klass.meths - klass.inherited_meths - attribute_meths
+      usable_methods = methods.select { |m| m.visibility == :public }.reject { |m| m.name == :initialize }
+
+  the alternative, is to add
+
+      require 'pry'
+      binding.pry
+
+  anywhere inside the source code below.
+
+=end
+
+module Danger
+  class PluginParser
+    attr_accessor :registry
+
+    def initialize(paths, verbose = false)
+      raise "Path cannot be empty" if paths.empty?
+
+      setup_yard(verbose)
+
+      if paths.kind_of? String
+        @paths = [File.expand_path(paths)]
+      else
+        @paths = paths
+      end
+    end
+
+    def setup_yard(verbose)
+      require 'yard'
+
+      # Unless specifically asked, don't output anything.
+      unless verbose
+        YARD::Logger.instance.level = YARD::Logger::FATAL
+      end
+
+      # Add some of our custom tags
+      YARD::Tags::Library.define_tag('tags', :tags)
+      YARD::Tags::Library.define_tag('availability', :availability)
+    end
+
+    def parse
+      files = ["lib/danger/plugin_support/plugin.rb"] + @paths
+
+      # This turns on YARD debugging
+      # $DEBUG = true
+
+      self.registry = YARD::Registry.load(files, true)
+    end
+
+    def classes_in_file
+      registry.all(:class).select { |klass| @paths.include? klass.file }
+    end
+
+    def plugins_from_classes(classes)
+      classes.select { |klass| klass.inheritance_tree.map(&:name).include? :Plugin }
+    end
+
+    def to_json
+      plugins = plugins_from_classes(classes_in_file)
+      to_h(plugins)
+    end
+
+    def to_json_string
+      plugins = plugins_from_classes(classes_in_file)
+      to_h(plugins).to_json
+    end
+
+    # rubocop:disable Metrics/AbcSize
+
+    def method_return_string(meth)
+      return "" unless meth[:tags]
+
+      return_value = meth[:tags].find { |t| t[:name] == "return" && t[:types] }
+      return "" if return_value.nil?
+      return "" if return_value[:types].nil?
+      return "" unless return_value[:types].kind_of? Array
+
+      unless return_value.empty?
+        return "" if return_value[:types].first == "void"
+        return return_value[:types].first
+      end
+      ""
+    end
+
+    def method_params(method)
+      return {} unless method[:params]
+
+      params_names = method[:params].map { |param| param.compact.join("=").strip }
+      params_values = method[:tags].select { |t| t[:name] == "param" }
+
+      return {} if params_values.empty?
+      return {} if params_values.select { |p| p[:types] }.empty?
+
+      return params_names.map.with_index do |name, 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(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)
+
+      # Pull out some derived data
+      method[:param_couplets] = params_v
+      method[:return] = return_v
+
+      # Create the center params, `thing: OK, other: Thing`
+      string_params = params_v.map do |param|
+        name = param.keys.first
+        param[name].nil? ? name : name + ": " + param[name]
+      end.join ", "
+
+      # Wrap it in () if there _are_ params
+      string_params = "(" + string_params + ")" unless string_params.empty?
+      # Append the return type if we have one
+      suffix = return_v.empty? ? "" : " -> #{return_v}"
+
+      method[:one_liner] = meth.name.to_s + string_params + suffix
+      method
+    end
+
+    def attribute_parser(gem_path, attribute)
+      {
+        read: method_parser(gem_path, attribute[:read]),
+        write: method_parser(gem_path, attribute[:write])
+      }
+    end
+
+    def to_h(classes)
+      classes.map do |klass|
+        # Adds the class being parsed into the ruby runtime, so that we can access it's instance_name
+        require klass.file
+        real_klass = Danger.const_get klass.name
+        attribute_meths = klass.attributes[:instance].values.map(&:values).flatten
+
+        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 || m.name == :new }
+
+        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(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,
+        }
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end