scss_lint 0.40.1 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d64ee14edbfefaee47bcf0b30500c2ee83231c0
-  data.tar.gz: 513d15bc52ea0f5d854972d661053c6ccc79f855
+  metadata.gz: 478b23880809f4fb5eeb95543b34534de05edf5a
+  data.tar.gz: 97f5d37498b751b7bdae0dd23032acc92de56fdf
 SHA512:
-  metadata.gz: 60cff3d31434509cb38dcee086f0f877f4346f5c9cb060d26897193e02b21e5c5109fe68dbc53f3bd99c4ca31ec09746a698ae5b8eed9ede9f57dd1dbf494777
-  data.tar.gz: 386501b6cb355a6924e1e2f6c0741a68dd54a7245fd28f7b71dac6488c32e79322d435bb1f5d69a419b680bdc30aefca0bfe604b104f697054e5ae6cc81a98ec
+  metadata.gz: 4808204c5756753ab99d9485590e034c6711f5b4ce67024c09dcfd281f6fa4199eb12331dd4a272933428c5991093bb4e6d2b5cf77743886df83488acc35651d
+  data.tar.gz: 951df4e1c90579ff4ebc55b61693bab102ba66761875781f6e0baf7d64232c0e95004f0de6eaacdc2db483a1c0d5d287aa79dd14d75d52220540f7cfbc129ee4

data/config/default.yml

@@ -36,6 +36,9 @@ linters:
   DeclarationOrder:
     enabled: true
 
+  DisableLinterReason:
+    enabled: false
+
   DuplicateProperty:
     enabled: true
 
@@ -111,6 +114,16 @@ linters:
     include_nested: false
     max_properties: 10
 
+  PropertySortOrder:
+    enabled: true
+    ignore_unspecified: false
+    min_properties: 2
+    separate_groups: false
+
+  PropertySpelling:
+    enabled: true
+    extra_properties: []
+
   PropertyUnits:
     enabled: true
     global: [
@@ -124,16 +137,6 @@ linters:
       '%']                                     # Other
     properties: {}
 
-  PropertySortOrder:
-    enabled: true
-    ignore_unspecified: false
-    min_properties: 2
-    separate_groups: false
-
-  PropertySpelling:
-    enabled: true
-    extra_properties: []
-
   QualifyingElement:
     enabled: true
     allow_element_with_attribute: false
@@ -172,6 +175,10 @@ linters:
   SpaceAfterVariableName:
     enabled: true
 
+  SpaceAroundOperator:
+    enabled: true
+    style: one_space # or 'no_space'
+
   SpaceBeforeBrace:
     enabled: true
     style: space # or 'new_line'
@@ -194,6 +201,9 @@ linters:
   TrailingZero:
     enabled: false
 
+  TransitionAll:
+    enabled: false
+
   UnnecessaryMantissa:
     enabled: true
 

data/data/property-sort-orders/recess.txt

@@ -8,6 +8,18 @@ bottom
 left
 z-index
 display
+align-content
+align-items
+align-self
+flex
+flex-basis
+flex-direction
+flex-flow
+flex-grow
+flex-shrink
+flex-wrap
+justify-content
+order
 float
 width
 height

data/data/property-sort-orders/smacss.txt

@@ -10,6 +10,19 @@ right
 bottom
 left
 
+flex
+flex-basis
+flex-direction
+flex-flow
+flex-grow
+flex-shrink
+flex-wrap
+align-content
+align-items
+align-self
+justify-content
+order
+
 width
 min-width
 max-width

data/lib/scss_lint/cli.rb

@@ -56,7 +56,7 @@ module SCSSLint
     def scan_for_lints(options, config)
       runner = Runner.new(config)
       runner.run(FileFinder.new(config).find(options[:files]))
-      report_lints(options, runner.lints)
+      report_lints(options, runner.lints, runner.files)
 
       if runner.lints.any?(&:error?)
         halt :error
@@ -159,10 +159,11 @@ module SCSSLint
 
     # @param options [Hash]
     # @param lints [Array<Lint>]
-    def report_lints(options, lints)
+    # @param files [Array<String>]
+    def report_lints(options, lints, files)
       sorted_lints = lints.sort_by { |l| [l.filename, l.location] }
       options.fetch(:reporters).each do |reporter, output|
-        results = reporter.new(sorted_lints).report_lints
+        results = reporter.new(sorted_lints, files).report_lints
         io = (output == :stdout ? $stdout : File.new(output, 'w+'))
         io.print results if results
       end

data/lib/scss_lint/control_comment_processor.rb

@@ -25,11 +25,11 @@ module SCSSLint
       linters = command[:linters]
       return unless linters.include?('all') || linters.include?(@linter.name)
 
-      process_command(command[:action], node)
+      process_command(command, node)
 
       # Is the control comment the only thing on this line?
       return if node.is_a?(Sass::Tree::RuleNode) ||
-                %r{^\s*(//|/\*)}.match(@linter.engine.lines[node.line - 1])
+                %r{^\s*(//|/\*)}.match(@linter.engine.lines[command[:line] - 1])
 
       # Otherwise, pop since we only want comment to apply to the single line
       pop_control_comment_stack(node)
@@ -39,7 +39,7 @@ module SCSSLint
     #
     # @param node [Sass::Tree::Node]
     def after_node_visit(node)
-      while @disable_stack.any? && @disable_stack.last.node_parent == node
+      while @disable_stack.any? && @disable_stack.last[:node].node_parent == node
         pop_control_comment_stack(node)
       end
     end
@@ -47,41 +47,50 @@ module SCSSLint
   private
 
     def extract_command(node)
-      comment =
-        case node
-        when Sass::Tree::CommentNode
-          node.value.first
-        when Sass::Tree::RuleNode
-          node.rule.select { |chunk| chunk.is_a?(String) }.join
+      return unless comment = retrieve_comment_text(node)
+
+      comment.split(/(?<=\n)/).each_with_index do |comment_line, line_no|
+        if match = %r{
+          (/|\*|^ \*)\s* # Comment start marker
+          scss-lint:
+          (?<action>disable|enable)\s+
+          (?<linters>.*?)
+          \s*(?:\*/|\n) # Comment end marker or end of line
+        }x.match(comment_line)
+          return {
+            action: match[:action],
+            linters: match[:linters].split(/\s*,\s*|\s+/),
+            line: node.line + line_no
+          }
         end
+      end
+
+      false
+    end
 
-      return unless match = %r{
-        (/|\*)\s* # Comment start marker
-        scss-lint:
-        (?<action>disable|enable)\s+
-        (?<linters>.*?)
-        \s*(?:\*/|\n) # Comment end marker or end of line
-      }x.match(comment)
-
-      {
-        action: match[:action],
-        linters: match[:linters].split(/\s*,\s*|\s+/),
-      }
+    def retrieve_comment_text(node)
+      case node
+      when Sass::Tree::CommentNode
+        node.value.first
+      when Sass::Tree::RuleNode
+        node.rule.select { |chunk| chunk.is_a?(String) }.join
+      end
     end
 
     def process_command(command, node)
-      case command
+      case command[:action]
       when 'disable'
-        @disable_stack << node
+        @disable_stack << { node: node, line: command[:line] }
       when 'enable'
         pop_control_comment_stack(node)
       end
     end
 
     def pop_control_comment_stack(node)
-      return unless comment_node = @disable_stack.pop
+      return unless command = @disable_stack.pop
 
-      start_line = comment_node.line
+      comment_node = command[:node]
+      start_line = command[:line]
       if comment_node.class.node_name == :rule
         end_line = start_line
       elsif node.class.node_name == :root

data/lib/scss_lint/linter/border_zero.rb

@@ -32,7 +32,7 @@ module SCSSLint
       return unless %w[0 none].include?(border)
       return if @preference[0] == border
 
-      add_lint(node, "`border: #{@preference[0]} is preferred over " \
+      add_lint(node, "`border: #{@preference[0]}` is preferred over " \
                      "`border: #{@preference[1]}`")
     end
   end

data/lib/scss_lint/linter/disable_linter_reason.rb

@@ -0,0 +1,39 @@
+module SCSSLint
+  # Checks for "reason" comments above linter-disabling comments.
+  class Linter::DisableLinterReason < Linter
+    include LinterRegistry
+
+    def visit_comment(node)
+      # No lint if the first line of the comment is not a command (because then
+      # either this comment has no commands, or the first line serves as a the
+      # reason for a command on a later line).
+      return unless comment_lines(node).first.match(COMMAND_REGEX)
+
+      # Maybe the previous node is the "reason" comment.
+      prev = previous_node(node)
+
+      if prev && prev.is_a?(Sass::Tree::CommentNode)
+        # No lint if the last line of the previous comment is not a command.
+        return unless comment_lines(prev).last.match(COMMAND_REGEX)
+      end
+
+      add_lint(node,
+               'scss-lint:disable control comments should be preceded by a ' \
+               'comment explaining why the linters need to be disabled.')
+    end
+
+  private
+
+    COMMAND_REGEX = %r{
+      (/|\*)\s* # Comment start marker
+      scss-lint:
+      (?<action>disable)\s+
+      (?<linters>.*?)
+      \s*(?:\*/|\n) # Comment end marker or end of line
+    }x
+
+    def comment_lines(node)
+      node.value.join.split("\n")
+    end
+  end
+end

data/lib/scss_lint/linter/mergeable_selector.rb

@@ -11,8 +11,10 @@ module SCSSLint
         seen_nodes << child_node
         next unless mergeable_node
 
+        rule_text = node_rule(child_node).gsub(/(\r?\n)+/, ' ')
+
         add_lint child_node.line,
-                 "Merge rule `#{node_rule(child_node)}` with rule " \
+                 "Merge rule `#{rule_text}` with rule " \
                  "on line #{mergeable_node.line}"
       end
 

data/lib/scss_lint/linter/nesting_depth.rb

@@ -30,6 +30,7 @@ module SCSSLint
 
     def ignore_selectors?(node)
       return unless config['ignore_parent_selectors']
+      return unless node.parsed_rules
 
       simple_selectors(node.parsed_rules).all? do |selector|
         IGNORED_SELECTORS.include?(selector.class)

data/lib/scss_lint/linter/selector_depth.rb

@@ -47,7 +47,7 @@ module SCSSLint
       # combinator, as these "combine" simple sequences such that they do not
       # increase depth.
       depth = simple_sequences.size -
-        separators.count { |item| item == '~' || item == '+'  }
+        separators.count { |item| item == '~' || item == '+' }
 
       if parent_selectors > 0
         # If parent selectors are present, add the current depth for each

data/lib/scss_lint/linter/single_line_per_property.rb

@@ -3,7 +3,7 @@ module SCSSLint
   class Linter::SingleLinePerProperty < Linter
     include LinterRegistry
 
-    def visit_rule(node) # rubocop:disable CyclomaticComplexity
+    def visit_rule(node)
       single_line = single_line_rule_set?(node)
       return if single_line && config['allow_single_line_rule_sets']
 

data/lib/scss_lint/linter/single_line_per_selector.rb

@@ -3,7 +3,7 @@ module SCSSLint
   class Linter::SingleLinePerSelector < Linter
     include LinterRegistry
 
-    MESSAGE = 'Each selector in a comma sequence should be on its own line'
+    MESSAGE = 'Each selector in a comma sequence should be on its own single line'
 
     def visit_comma_sequence(node)
       return unless node.members.count > 1
@@ -15,6 +15,14 @@ module SCSSLint
       end
     end
 
+    def visit_sequence(node)
+      node.members[1..-1].each_with_index do |item, index|
+        next unless item == "\n"
+
+        add_lint(node.line + index, MESSAGE)
+      end
+    end
+
   private
 
     def check_comma_on_own_line(node)

data/lib/scss_lint/linter/space_after_variable_name.rb

@@ -1,7 +1,7 @@
 module SCSSLint
   # Checks for spaces following the name of a variable and before the colon
   # separating the variables's name from its value.
-  class SpaceAfterVariableName < Linter
+  class Linter::SpaceAfterVariableName < Linter
     include LinterRegistry
 
     def visit_variable(node)

data/lib/scss_lint/linter/space_around_operator.rb

@@ -0,0 +1,86 @@
+module SCSSLint
+  # Checks for space around operators on values.
+  class Linter::SpaceAroundOperator < Linter
+    include LinterRegistry
+
+    def visit_script_operation(node) # rubocop:disable Metrics/AbcSize
+      source = normalize_source(source_from_range(node.source_range))
+      left_range = node.operand1.source_range
+      right_range = node.operand2.source_range
+
+      # We need to #chop at the end because an operation's operand1 _always_
+      # includes one character past the actual operand (which is either a
+      # whitespace character, or the first character of the operation).
+      left_source = normalize_source(source_from_range(left_range))
+      right_source = normalize_source(source_from_range(right_range))
+      operator_source = source_between(left_range, right_range)
+      left_source, operator_source = adjust_left_boundary(left_source, operator_source)
+
+      match = operator_source.match(/
+        (?<left_space>\s*)
+        (?<operator>\S+)
+        (?<right_space>\s*)
+      /x)
+
+      if config['style'] == 'one_space'
+        if match[:left_space] != ' ' || match[:right_space] != ' '
+          add_lint(node, SPACE_MSG % [source, left_source, match[:operator], right_source])
+        end
+      elsif match[:left_space] != '' || match[:right_space] != ''
+        add_lint(node, NO_SPACE_MSG % [source, left_source, match[:operator], right_source])
+      end
+
+      yield
+    end
+
+  private
+
+    SPACE_MSG = '`%s` should be written with a single space on each side of ' \
+                'the operator: `%s %s %s`'
+    NO_SPACE_MSG = '`%s` should be written without spaces around the ' \
+                   'operator: `%s%s%s`'
+
+    def source_between(range1, range2)
+      # We don't want to add 1 to range1.end_pos.offset for the same reason as
+      # the #chop comment above.
+      between_start = Sass::Source::Position.new(
+        range1.end_pos.line,
+        range1.end_pos.offset,
+      )
+      between_end = Sass::Source::Position.new(
+        range2.start_pos.line,
+        range2.start_pos.offset - 1,
+      )
+
+      source_from_range(Sass::Source::Range.new(between_start,
+                                                between_end,
+                                                range1.file,
+                                                range1.importer))
+    end
+
+    # Removes trailing parentheses and compacts newlines into a single space
+    def normalize_source(source)
+      source.chop.gsub(/\s*\n\s*/, ' ')
+    end
+
+    def adjust_left_boundary(left, operator)
+      # If the left operand is wrapped in parentheses, any right parens end up
+      # in the operator source. Here, we move them into the left operand
+      # source, which is awkward in any messaging, but it works.
+      if match = operator.match(/^(\s*\))+/)
+        left += match[0]
+        operator = operator[match.end(0)..-1]
+      end
+
+      # If the left operand is a nested operation, Sass includes any whitespace
+      # before the (outer) operator in the left operator's source_range's
+      # end_pos, which is not the case with simple, non-operation operands.
+      if match = left.match(/\s+$/)
+        left = left[0..match.begin(0)]
+        operator = match[0] + operator
+      end
+
+      [left, operator]
+    end
+  end
+end

data/lib/scss_lint/linter/space_between_parens.rb

@@ -1,36 +1,112 @@
 module SCSSLint
+  # rubocop:disable Metrics/AbcSize
+
   # Checks for the presence of spaces between parentheses.
   class Linter::SpaceBetweenParens < Linter
     include LinterRegistry
 
-    def visit_root(_node)
+    def check_node(node)
+      check(node, source_from_range(node.source_range))
+      yield
+    end
+
+    alias_method :visit_atroot,           :check_node
+    alias_method :visit_cssimport,        :check_node
+    alias_method :visit_function,         :check_node
+    alias_method :visit_media,            :check_node
+    alias_method :visit_mixindef,         :check_node
+    alias_method :visit_mixin,            :check_node
+    alias_method :visit_script_funcall,   :check_node
+
+    def feel_for_parens_and_check_node(node)
+      source = feel_for_enclosing_parens(node)
+      check(node, source)
+      yield
+    end
+
+    alias_method :visit_script_listliteral,  :feel_for_parens_and_check_node
+    alias_method :visit_script_mapliteral,  :feel_for_parens_and_check_node
+    alias_method :visit_script_operation,   :feel_for_parens_and_check_node
+    alias_method :visit_script_string,      :feel_for_parens_and_check_node
+
+  private
+
+    TRAILING_WHITESPACE = /\s*$/
+
+    def check(node, source) # rubocop:disable Metrics/MethodLength
       @spaces = config['spaces']
+      source = trim_right_paren(source)
+      return if source.count('(') != source.count(')')
+      source.scan(/
+          \(
+          (?<left>\s*)
+          (?<contents>.*)
+          (?<right>\s*)
+          \)
+      /x) do |left, contents, right|
+        right = contents.match(TRAILING_WHITESPACE)[0] + right
+        contents.gsub(TRAILING_WHITESPACE, '')
+
+        # We don't lint on multiline parenthetical source.
+        break if (left + contents + right).include? "\n"
 
-      engine.lines.each_with_index do |line, index|
-        line.gsub(%r{((//|/\*).*$)}, '').scan(/
-          (^(\t|\s)*\))?  # Capture leading spaces and tabs followed by a `)`
-          (
-            \([ ]*(?!$)   # Find `( ` as long as its not EOL )
-            |
-            [ ]*\)
-          )?
-        /x) do |match|
-          check(match[2], index) if match[2]
+        if contents.empty?
+          # If we're looking at empty parens (like `()`, `( )`, `(  )`, etc.),
+          # only report a possible lint on the left side.
+          right = ' ' * @spaces
+        end
+
+        if left != ' ' * @spaces
+          message = "#{expected_spaces} after `(` instead of `#{left}`"
+          add_lint(node, message)
+        end
+
+        if right != ' ' * @spaces
+          message = "#{expected_spaces} before `)` instead of `#{right}`"
+          add_lint(node, message)
         end
       end
-      yield
     end
 
-  private
+    # An expression enclosed in parens will include or not include each paren, depending
+    # on whitespace. Here we feel out for enclosing parens, and return them as the new
+    # source for the node.
+    def feel_for_enclosing_parens(node) # rubocop:disable Metrics/CyclomaticComplexity
+      range = node.source_range
+      original_source = source_from_range(range)
+      left_offset = -1
+      right_offset = 0
+
+      if original_source[-1] != ')'
+        right_offset += 1 while character_at(range.end_pos, right_offset) =~ /\s/
 
-    def check(str, index)
-      spaces = str.count ' '
-      return if spaces == @spaces
+        return original_source if character_at(range.end_pos, right_offset) != ')'
+      end
+
+      # At this point, we know that we're wrapped on the right by a ')'.
+      # Are we wrapped on the left by a '('?
+      left_offset -= 1 while character_at(range.start_pos, left_offset) =~ /\s/
+      return original_source if character_at(range.start_pos, left_offset) != '('
+
+      # At this point, we know we're wrapped on both sides by parens. However,
+      # those parens may be part of a parent function call. We don't care about
+      # such parens. This depends on whether the preceding character is part of
+      # a function name.
+      return original_source if character_at(range.start_pos, left_offset - 1) =~ /[A-Za-z0-9_]/
+
+      range.start_pos.offset += left_offset
+      range.end_pos.offset += right_offset
+      source_from_range(range)
+    end
+
+    # An unrelated right paren will sneak into the source of a node if there is no
+    # whitespace between the node and the right paren.
+    def trim_right_paren(source)
+      (source.count(')') == source.count('(') + 1) ? source[0..-2] : source
+    end
 
-      location = Location.new(index + 1)
-      message = "Expected #{pluralize(@spaces, 'space')} " \
-                "between parentheses instead of #{spaces}"
-      add_lint(location, message)
+    def expected_spaces
+      "Expected #{pluralize(@spaces, 'space')}"
     end
   end
 end

data/lib/scss_lint/linter/transition_all.rb

@@ -0,0 +1,30 @@
+module SCSSLint
+  # Checks for explicitly transitioned properties instead of transition all.
+  class Linter::TransitionAll < Linter
+    include LinterRegistry
+
+    TRANSITION_PROPERTIES = %w[
+      transition
+      transition-property
+    ]
+
+    def visit_prop(node)
+      property = node.name.first.to_s
+      return unless TRANSITION_PROPERTIES.include?(property)
+
+      check_transition(node, property, node.value.to_sass)
+    end
+
+  private
+
+    def check_transition(node, property, value)
+      return unless offset = value =~ /\ball\b/
+
+      pos = node.value_source_range.start_pos.after(value[0, offset])
+
+      add_lint(Location.new(pos.line, pos.offset, 3),
+               "#{property} should contain explicit properties " \
+                'instead of using the keyword all')
+    end
+  end
+end

data/lib/scss_lint/linter/unnecessary_mantissa.rb

@@ -6,6 +6,7 @@ module SCSSLint
 
     def visit_script_string(node)
       return unless node.type == :identifier
+      return if node.value =~ /^'|"/
 
       node.value.scan(REAL_NUMBER_REGEX) do |number, integer, mantissa, units|
         if unnecessary_mantissa?(mantissa)

data/lib/scss_lint/reporter/clean_files_reporter.rb

@@ -0,0 +1,10 @@
+module SCSSLint
+  # Reports a single line for each clean file (having zero lints).
+  class Reporter::CleanFilesReporter < Reporter
+    def report_lints
+      dirty_files = lints.map(&:filename).uniq
+      clean_files = files - dirty_files
+      clean_files.sort.join("\n") + "\n" if clean_files.any?
+    end
+  end
+end

data/lib/scss_lint/reporter.rb

@@ -1,14 +1,17 @@
 module SCSSLint
   # Responsible for displaying lints to the user in some format.
   class Reporter
-    attr_reader :lints
+    attr_reader :lints, :files
 
     def self.descendants
       ObjectSpace.each_object(Class).select { |klass| klass < self }
     end
 
-    def initialize(lints)
+    # @param lints [List<Lint>] a list of Lints sorted by file and line number
+    # @param files [List<String>] a list of the files that were linted
+    def initialize(lints, files)
       @lints = lints
+      @files = files
     end
 
     def report_lints

data/lib/scss_lint/runner.rb

@@ -2,7 +2,7 @@ module SCSSLint
   # Finds and aggregates all lints found by running the registered linters
   # against a set of SCSS files.
   class Runner
-    attr_reader :lints
+    attr_reader :lints, :files
 
     # @param config [Config]
     def initialize(config)
@@ -13,7 +13,8 @@ module SCSSLint
 
     # @param files [Array]
     def run(files)
-      files.each do |file|
+      @files = files
+      @files.each do |file|
         find_lints(file)
       end
     end