mdl 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2ef1682330d4d7498e347b19aaa6a18c8006ac62b811e93dc4f1b87ba9e73ef
-  data.tar.gz: 4711609a70fdd931788e6c50b05c3a515c813f3bb0e52ba6716f9ea666ada0a5
+  metadata.gz: 870d0bc411951c203fcf0e352e6e903e4f7008b17543259dea919ea5780042fc
+  data.tar.gz: f796b7b245267e16f5e7e4d5be79b030b3f6775987f1df6838c526c4a7f7b58f
 SHA512:
-  metadata.gz: 4bef5fff1c8e926baa7299487a17d711b4c79368b0722fd990c2b1d6e5ffcc046c6385ae5d863e4ad3cc708bec77239167a41c4ae78c9064fe1f7a45f9fcaafb
-  data.tar.gz: e8275c46e8c465f849b9766178b17f02644165f5c20ef6fbb030281b7ff917dc870ff5443aa0a94b05c28e3d195c2093f6213f6177551587c7e7b87017d491a7
+  metadata.gz: 85bfc0cf05053e6bfc9aaa1c8f62c2fc1f99ba8f9b450c262fc1716de529e934e2cac5cb23c77c7a6c49ec33c7bddcc8c9e3cf17964c3b426695dafb4dbcd51f
+  data.tar.gz: '013659e46c8ec5ce00c4d8a096853badf15da2a0396cd33119f84a603eb525e62a4a44fadc04fc24c282c8a55cda90c811146b39a17db2eb28a744209ace5b15'

data/bin/mdl

@@ -3,8 +3,8 @@ begin
   require 'mdl'
 rescue LoadError
   # For running in development without bundler
-  $: << File.expand_path("../lib", File.dirname(__FILE__))
+  $LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
   require 'mdl'
 end
 
-MarkdownLint::run
+MarkdownLint.run

data/lib/mdl.rb

@@ -7,50 +7,55 @@ require_relative 'mdl/style'
 require_relative 'mdl/version'
 
 require 'kramdown'
+require 'mixlib/shellout'
 
+# Primary MDL container
 module MarkdownLint
-  def self.run(argv=ARGV)
+  def self.run(argv = ARGV)
     cli = MarkdownLint::CLI.new
     cli.run(argv)
     ruleset = RuleSet.new
-    unless Config[:skip_default_ruleset]
-      ruleset.load_default
-    end
-    unless Config[:rulesets].nil?
-      Config[:rulesets].each do |r|
-        ruleset.load(r)
-      end
+    ruleset.load_default unless Config[:skip_default_ruleset]
+    Config[:rulesets]&.each do |r|
+      ruleset.load(r)
     end
     rules = ruleset.rules
     Style.load(Config[:style], rules)
     # Rule option filter
     if Config[:rules]
-      rules.select! {|r, v| Config[:rules][:include].include?(r) or
-                     !(Config[:rules][:include] & v.aliases).empty? } \
-        unless Config[:rules][:include].empty?
-      rules.select! {|r, v| not Config[:rules][:exclude].include?(r) and
-                     (Config[:rules][:exclude] & v.aliases).empty? } \
-        unless Config[:rules][:exclude].empty?
+      unless Config[:rules][:include].empty?
+        rules.select! do |r, v|
+          Config[:rules][:include].include?(r) or
+            !(Config[:rules][:include] & v.aliases).empty?
+        end
+      end
+      unless Config[:rules][:exclude].empty?
+        rules.select! do |r, v|
+          !Config[:rules][:exclude].include?(r) and
+            (Config[:rules][:exclude] & v.aliases).empty?
+        end
+      end
     end
     # Tag option filter
     if Config[:tags]
-      rules.select! {|r, v| not (v.tags & Config[:tags][:include]).empty? } \
+      rules.reject! { |_r, v| (v.tags & Config[:tags][:include]).empty? } \
         unless Config[:tags][:include].empty?
-      rules.select! {|r, v| (v.tags & Config[:tags][:exclude]).empty? } \
+      rules.select! { |_r, v| (v.tags & Config[:tags][:exclude]).empty? } \
         unless Config[:tags][:exclude].empty?
     end
 
     if Config[:list_rules]
-      puts "Enabled rules:"
-        rules.each do |id, rule|
-          if Config[:verbose]
-            puts "#{id} (#{rule.aliases.join(', ')}) [#{rule.tags.join(', ')}] - #{rule.description}"
-          elsif Config[:show_aliases]
-            puts "#{rule.aliases.first || id} - #{rule.description}"
-          else
-            puts "#{id} - #{rule.description}"
-          end
+      puts 'Enabled rules:'
+      rules.each do |id, rule|
+        if Config[:verbose]
+          puts "#{id} (#{rule.aliases.join(', ')}) [#{rule.tags.join(', ')}] " +
+               "- #{rule.description}"
+        elsif Config[:show_aliases]
+          puts "#{rule.aliases.first || id} - #{rule.description}"
+        else
+          puts "#{id} - #{rule.description}"
         end
+      end
       exit 0
     end
 
@@ -59,7 +64,9 @@ module MarkdownLint
       if Dir.exist?(filename)
         if Config[:git_recurse]
           Dir.chdir(filename) do
-            cli.cli_arguments[i] = %x(git ls-files '*.md' '*.markdown').split("\n")
+            cli.cli_arguments[i] =
+              Mixlib::ShellOut.new("git ls-files '*.md' '*.markdown'")
+                              .run_command.stdout.lines
           end
         else
           cli.cli_arguments[i] = Dir["#{filename}/**/*.{md,markdown}"]
@@ -73,9 +80,9 @@ module MarkdownLint
     cli.cli_arguments.each do |filename|
       puts "Checking #{filename}..." if Config[:verbose]
       doc = Doc.new_from_file(filename, Config[:ignore_front_matter])
-      filename = '(stdin)' if filename == "-"
+      filename = '(stdin)' if filename == '-'
       if Config[:show_kramdown_warnings]
-        status = 2 if not doc.parsed.warnings.empty?
+        status = 2 unless doc.parsed.warnings.empty?
         doc.parsed.warnings.each do |w|
           puts "#{filename}: Kramdown Warning: #{w}"
         end
@@ -83,7 +90,8 @@ module MarkdownLint
       rules.sort.each do |id, rule|
         puts "Processing rule #{id}" if Config[:verbose]
         error_lines = rule.check.call(doc)
-        next if error_lines.nil? or error_lines.empty?
+        next if error_lines.nil? || error_lines.empty?
+
         status = 1
         error_lines.each do |line|
           line += doc.offset # Correct line numbers for any yaml front matter
@@ -96,7 +104,8 @@ module MarkdownLint
               'description' => rule.description,
             }
           elsif Config[:show_aliases]
-            puts "#{filename}:#{line}: #{rule.aliases.first || id} #{rule.description}"
+            puts "#{filename}:#{line}: #{rule.aliases.first || id} " +
+                 rule.description.to_s
           else
             puts "#{filename}:#{line}: #{id} #{rule.description}"
           end
@@ -108,8 +117,8 @@ module MarkdownLint
       require 'json'
       puts JSON.generate(results)
     elsif status != 0
-      puts "\nA detailed description of the rules is available at "\
-           "https://github.com/markdownlint/markdownlint/blob/master/docs/RULES.md"
+      puts "\nA detailed description of the rules is available at " +
+           'https://github.com/markdownlint/markdownlint/blob/master/docs/RULES.md'
     end
     exit status
   end

data/lib/mdl/cli.rb

@@ -2,124 +2,125 @@ require 'mixlib/cli'
 require 'pathname'
 
 module MarkdownLint
+  # Our Mixlib::CLI class
   class CLI
     include Mixlib::CLI
 
-    CONFIG_FILE = '.mdlrc'
+    CONFIG_FILE = '.mdlrc'.freeze
 
-    banner "Usage: #{File.basename($0)} [options] [FILE.md|DIR ...]"
+    banner "Usage: #{File.basename($PROGRAM_NAME)} [options] [FILE.md|DIR ...]"
 
     option :show_aliases,
-      :short => '-a',
-      :long => '--[no-]show-aliases',
-      :description => 'Show rule alias instead of rule ID when viewing rules',
-      :boolean => true
+           :short => '-a',
+           :long => '--[no-]show-aliases',
+           :description =>
+             'Show rule alias instead of rule ID when viewing rules',
+           :boolean => true
 
     option :config_file,
-      :short => '-c',
-      :long => '--config FILE',
-      :description => 'The configuration file to use',
-      :default => "#{CONFIG_FILE}"
+           :short => '-c',
+           :long => '--config FILE',
+           :description => 'The configuration file to use',
+           :default => CONFIG_FILE.to_s
 
     option :verbose,
-      :short => '-v',
-      :long => '--[no-]verbose',
-      :description => 'Increase verbosity',
-      :boolean => true
+           :short => '-v',
+           :long => '--[no-]verbose',
+           :description => 'Increase verbosity',
+           :boolean => true
 
     option :ignore_front_matter,
-      :short => '-i',
-      :long => '--[no-]ignore-front-matter',
-      :boolean => true,
-      :description => 'Ignore YAML front matter'
+           :short => '-i',
+           :long => '--[no-]ignore-front-matter',
+           :boolean => true,
+           :description => 'Ignore YAML front matter'
 
     option :show_kramdown_warnings,
-      :short => '-w',
-      :long => '--[no-]warnings',
-      :description => 'Show kramdown warnings',
-      :boolean => true
+           :short => '-w',
+           :long => '--[no-]warnings',
+           :description => 'Show kramdown warnings',
+           :boolean => true
 
     option :tags,
-      :short => '-t',
-      :long => '--tags TAG1,TAG2',
-      :description => 'Only process rules with these tags',
-      :proc => Proc.new { |v| toggle_list(v, true) }
+           :short => '-t',
+           :long => '--tags TAG1,TAG2',
+           :description => 'Only process rules with these tags',
+           :proc => proc { |v| toggle_list(v, true) }
 
     option :rules,
-      :short => '-r',
-      :long => '--rules RULE1,RULE2',
-      :description => 'Only process these rules',
-      :proc => Proc.new { |v| toggle_list(v) }
+           :short => '-r',
+           :long => '--rules RULE1,RULE2',
+           :description => 'Only process these rules',
+           :proc => proc { |v| toggle_list(v) }
 
     option :style,
-      :short => '-s',
-      :long => '--style STYLE',
-      :description => "Load the given style"
+           :short => '-s',
+           :long => '--style STYLE',
+           :description => 'Load the given style'
 
     option :list_rules,
-      :short => '-l',
-      :long => '--list-rules',
-      :boolean => true,
-      :description => "Don't process any files, just list enabled rules"
+           :short => '-l',
+           :long => '--list-rules',
+           :boolean => true,
+           :description => "Don't process any files, just list enabled rules"
 
     option :git_recurse,
-      :short => '-g',
-      :long => '--git-recurse',
-      :boolean => true,
-      :description => "Only process files known to git when given a directory"
+           :short => '-g',
+           :long => '--git-recurse',
+           :boolean => true,
+           :description =>
+             'Only process files known to git when given a directory'
 
     option :rulesets,
-      :short => '-u',
-      :long => '--rulesets RULESET1,RULESET2',
-      :proc => Proc.new { |v| v.split(',') },
-      :description => "Specify additional ruleset files to load"
+           :short => '-u',
+           :long => '--rulesets RULESET1,RULESET2',
+           :proc => proc { |v| v.split(',') },
+           :description => 'Specify additional ruleset files to load'
 
     option :skip_default_ruleset,
-      :short => '-d',
-      :long => '--skip-default-ruleset',
-      :boolean => true,
-      :description => "Don't load the default markdownlint ruleset"
+           :short => '-d',
+           :long => '--skip-default-ruleset',
+           :boolean => true,
+           :description => "Don't load the default markdownlint ruleset"
 
     option :help,
-      :on => :tail,
-      :short => '-h',
-      :long => '--help',
-      :description => 'Show this message',
-      :boolean => true,
-      :show_options => true,
-      :exit => 0
+           :on => :tail,
+           :short => '-h',
+           :long => '--help',
+           :description => 'Show this message',
+           :boolean => true,
+           :show_options => true,
+           :exit => 0
 
     option :version,
-      :on => :tail,
-      :short => "-V",
-      :long => "--version",
-      :description => "Show version",
-      :boolean => true,
-      :proc => Proc.new { puts MarkdownLint::VERSION },
-      :exit => 0
+           :on => :tail,
+           :short => '-V',
+           :long => '--version',
+           :description => 'Show version',
+           :boolean => true,
+           :proc => proc { puts MarkdownLint::VERSION },
+           :exit => 0
 
     option :json,
-      :short => '-j',
-      :long => '--json',
-      :description => "JSON output",
-      :boolean => true
+           :short => '-j',
+           :long => '--json',
+           :description => 'JSON output',
+           :boolean => true
 
-    def run(argv=ARGV)
+    def run(argv = ARGV)
       parse_options(argv)
 
       # Load the config file if it's present
       filename = CLI.probe_config_file(config[:config_file])
 
       # Only fall back to ~/.mdlrc if we are using the default value for -c
-      if filename.nil? and config[:config_file] == CONFIG_FILE
+      if filename.nil? && (config[:config_file] == CONFIG_FILE)
         filename = File.expand_path("~/#{CONFIG_FILE}")
       end
 
-      if not filename.nil? and File.exist?(filename)
+      if !filename.nil? && File.exist?(filename)
         MarkdownLint::Config.from_file(filename.to_s)
-        if config[:verbose]
-          puts "Loaded config from #{filename}"
-        end
+        puts "Loaded config from #{filename}" if config[:verbose]
       end
 
       # Put values in the config file
@@ -128,30 +129,31 @@ module MarkdownLint
       # Set the correct format for any rules/tags configuration loaded from
       # the config file. Ideally this would probably be done as part of the
       # config class itself rather than here.
-      MarkdownLint::Config[:rules] = CLI.toggle_list(
-        MarkdownLint::Config[:rules]) unless MarkdownLint::Config[:rules].nil?
-      MarkdownLint::Config[:tags] = CLI.toggle_list(
-        MarkdownLint::Config[:tags], true) \
-        unless MarkdownLint::Config[:tags].nil?
+      unless MarkdownLint::Config[:rules].nil?
+        MarkdownLint::Config[:rules] = CLI.toggle_list(
+          MarkdownLint::Config[:rules],
+        )
+      end
+      unless MarkdownLint::Config[:tags].nil?
+        MarkdownLint::Config[:tags] = CLI.toggle_list(
+          MarkdownLint::Config[:tags], true
+        )
+      end
 
       # Read from stdin if we didn't provide a filename
-      if cli_arguments.empty? and not config[:list_rules]
-        cli_arguments << "-"
-      end
+      cli_arguments << '-' if cli_arguments.empty? && !config[:list_rules]
     end
 
-    def self.toggle_list(parts, to_sym=false)
-      if parts.class == String
-        parts = parts.split(',')
-      end
+    def self.toggle_list(parts, to_sym = false)
+      parts = parts.split(',') if parts.class == String
       if parts.class == Array
-        inc = parts.select{|p| not p.start_with?('~')}
-        exc = parts.select{|p| p.start_with?('~')}.map{|p| p[1..-1]}
+        inc = parts.reject { |p| p.start_with?('~') }
+        exc = parts.select { |p| p.start_with?('~') }.map { |p| p[1..-1] }
         if to_sym
-          inc.map!{|p| p.to_sym}
-          exc.map!{|p| p.to_sym}
+          inc.map!(&:to_sym)
+          exc.map!(&:to_sym)
         end
-        {:include => inc, :exclude => exc}
+        { :include => inc, :exclude => exc }
       else
         # We already converted the string into a list of include/exclude
         # pairs, so just return as is

data/lib/mdl/config.rb

@@ -1,9 +1,10 @@
 require 'mixlib/config'
 
 module MarkdownLint
+  # our Mixlib::Config class
   module Config
     extend Mixlib::Config
 
-    default :style, "default"
+    default :style, 'default'
   end
 end

data/lib/mdl/doc.rb

@@ -4,7 +4,6 @@ require_relative 'kramdown_parser'
 module MarkdownLint
   ##
   # Representation of the markdown document passed to rule checks
-
   class Doc
     ##
     # A list of raw markdown source lines. Note that the list is 0-indexed,
@@ -12,32 +11,26 @@ module MarkdownLint
     # subtract 1 from a line number to get the correct line. The element_line*
     # methods take care of this for you.
 
-    attr_reader :lines
+    attr_reader :lines, :parsed, :elements, :offset
 
     ##
     # A Kramdown::Document object containing the parsed markdown document.
 
-    attr_reader :parsed
-
     ##
     # A list of top level Kramdown::Element objects from the parsed document.
 
-    attr_reader :elements
-
     ##
     # The line number offset which is greater than zero when the
     # markdown file contains YAML front matter that should be ignored.
 
-    attr_reader :offset
-
     ##
     # Create a new document given a string containing the markdown source
 
     def initialize(text, ignore_front_matter = false)
       regex = /^---\n(.*?)---\n\n?/m
-      if ignore_front_matter and regex.match(text)
+      if ignore_front_matter && regex.match(text)
         @offset = regex.match(text).to_s.split("\n").length
-        text.sub!(regex,'')
+        text.sub!(regex, '')
       else
         @offset = 0
       end
@@ -51,10 +44,10 @@ module MarkdownLint
     # Alternate 'constructor' passing in a filename
 
     def self.new_from_file(filename, ignore_front_matter = false)
-      if filename == "-"
-        self.new(STDIN.read, ignore_front_matter)
+      if filename == '-'
+        new($stdin.read, ignore_front_matter)
       else
-        self.new(File.read(filename, encoding: 'UTF-8'), ignore_front_matter)
+        new(File.read(filename, :encoding => 'UTF-8'), ignore_front_matter)
       end
     end
 
@@ -69,8 +62,8 @@ module MarkdownLint
     # If +nested+ is set to false, this returns only top level elements of a
     # given type.
 
-    def find_type(type, nested=true)
-      find_type_elements(type, nested).map { |e| e.options }
+    def find_type(type, nested = true)
+      find_type_elements(type, nested).map(&:options)
     end
 
     ##
@@ -83,14 +76,12 @@ module MarkdownLint
     # If +nested+ is set to false, this returns only top level elements of a
     # given type.
 
-    def find_type_elements(type, nested=true, elements=@elements)
+    def find_type_elements(type, nested = true, elements = @elements)
       results = []
-      if type.class == Symbol
-        type = [type]
-      end
+      type = [type] if type.class == Symbol
       elements.each do |e|
         results.push(e) if type.include?(e.type)
-        if nested and not e.children.empty?
+        if nested && !e.children.empty?
           results.concat(find_type_elements(type, nested, e.children))
         end
       end
@@ -107,19 +98,19 @@ module MarkdownLint
     # Unlike find_type_elements, this method will always search for nested
     # elements, and skip the element types given to nested_except.
 
-    def find_type_elements_except(type, nested_except=[], elements=@elements)
+    def find_type_elements_except(
+      type, nested_except = [], elements = @elements
+    )
       results = []
-      if type.class == Symbol
-        type = [type]
-      end
-      if nested_except.class == Symbol
-        nested_except = [nested_except]
-      end
+      type = [type] if type.class == Symbol
+      nested_except = [nested_except] if nested_except.class == Symbol
       elements.each do |e|
         results.push(e) if type.include?(e.type)
-        unless nested_except.include?(e.type) or e.children.empty?
-          results.concat(find_type_elements_except(type, nested_except, e.children))
-        end
+        next if nested_except.include?(e.type) || e.children.empty?
+
+        results.concat(
+          find_type_elements_except(type, nested_except, e.children),
+        )
       end
       results
     end
@@ -167,11 +158,12 @@ module MarkdownLint
 
     def header_style(header)
       if header.type != :header
-        raise "header_style called with non-header element"
+        raise 'header_style called with non-header element'
       end
+
       line = element_line(header)
-      if line.start_with?("#")
-        if line.strip.end_with?("#")
+      if line.start_with?('#')
+        if line.strip.end_with?('#')
           :atx_closed
         else
           :atx
@@ -187,10 +179,9 @@ module MarkdownLint
     # item. You can pass in either the element itself or an options hash here.
 
     def list_style(item)
-      if item.type != :li
-        raise "list_style called with non-list element"
-      end
-      line = element_line(item).strip.gsub(/^>\s+/,'')
+      raise 'list_style called with non-list element' if item.type != :li
+
+      line = element_line(item).strip.gsub(/^>\s+/, '')
       if line.start_with?('*')
         :asterisk
       elsif line.start_with?('+')
@@ -211,22 +202,24 @@ module MarkdownLint
     # indent of 8 spaces. You need to pass in the raw string here.
 
     def indent_for(line)
-      return line.match(/^\s*/)[0].gsub("\t", " " * 8).length
+      line.match(/^\s*/)[0].gsub("\t", ' ' * 8).length
     end
 
     ##
     # Returns line numbers for lines that match the given regular expression
 
-    def matching_lines(re)
-      @lines.each_with_index.select{|text, linenum| re.match(text)}.map{
-        |i| i[1]+1}
+    def matching_lines(regex)
+      @lines.each_with_index.select { |text, _linenum| regex.match(text) }
+            .map do |i|
+              i[1] + 1
+            end
     end
 
     ##
     # Returns line numbers for lines that match the given regular expression.
     # Only considers text inside of 'text' elements (i.e. regular markdown
     # text and not code/links or other elements).
-    def matching_text_element_lines(re, exclude_nested=[:a])
+    def matching_text_element_lines(regex, exclude_nested = [:a])
       matches = []
       find_type_elements_except(:text, exclude_nested).each do |e|
         first_line = e.options[:location]
@@ -234,9 +227,10 @@ module MarkdownLint
         # the current element. It's better to just not match in these cases
         # rather than crash.
         next if first_line.nil?
+
         lines = e.value.split("\n")
         lines.each_with_index do |l, i|
-          matches << first_line + i if re.match(l)
+          matches << first_line + i if regex.match(l)
         end
       end
       matches
@@ -246,31 +240,29 @@ module MarkdownLint
     # Extracts the text from an element whose children consist of text
     # elements and other things
 
-    def extract_text(element, prefix="", restore_whitespace = true)
+    def extract_text(element, prefix = '', restore_whitespace = true)
       quotes = {
         :rdquo => '"',
         :ldquo => '"',
         :lsquo => "'",
-        :rsquo => "'"
+        :rsquo => "'",
       }
       # If anything goes amiss here, e.g. unknown type, then nil will be
       # returned and we'll just not catch that part of the text, which seems
       # like a sensible failure mode.
-      lines = element.children.map { |e|
+      lines = element.children.map do |e|
         if e.type == :text
           e.value
-        elsif [:strong, :em, :p, :codespan].include?(e.type)
+        elsif %i{strong em p codespan}.include?(e.type)
           extract_text(e, prefix, restore_whitespace).join("\n")
         elsif e.type == :smart_quote
           quotes[e.value]
         end
-      }.join.split("\n")
+      end.join.split("\n")
       # Text blocks have whitespace stripped, so we need to add it back in at
       # the beginning. Because this might be in something like a blockquote,
       # we optionally strip off a prefix given to the function.
-      if restore_whitespace
-        lines[0] = element_line(element).sub(prefix, "")
-      end
+      lines[0] = element_line(element).sub(prefix, '') if restore_whitespace
       lines
     end
 
@@ -280,13 +272,12 @@ module MarkdownLint
     # Adds a 'level' and 'parent' option to all elements to show how nested they
     # are
 
-    def add_annotations(elements, level=1, parent=nil)
+    def add_annotations(elements, level = 1, parent = nil)
       elements.each do |e|
         e.options[:element_level] = level
         e.options[:parent] = parent
-        add_annotations(e.children, level+1, e)
+        add_annotations(e.children, level + 1, e)
       end
     end
-
   end
 end