scss-lint 0.33.0 → 0.34.0

data/lib/scss_lint/linter/color_keyword.rb

@@ -4,11 +4,9 @@ module SCSSLint
   class Linter::ColorKeyword < Linter
     include LinterRegistry
 
-    COLOR_REGEX = /(#?[a-f0-9]{3,6}|[a-z]+)/i
-
     def visit_script_color(node)
-      color = source_from_range(node.source_range)[COLOR_REGEX, 1]
-      add_color_lint(node, color) if color_keyword?(color)
+      word = source_from_range(node.source_range)[/([a-z]+)/i, 1]
+      add_color_lint(node, word) if color_keyword?(word)
     end
 
     def visit_script_string(node)
@@ -22,7 +20,7 @@ module SCSSLint
   private
 
     def add_color_lint(node, original)
-      hex_form = Sass::Script::Value::Color.new(color_rgb(original)).tap do |color|
+      hex_form = Sass::Script::Value::Color.new(color_keyword_to_code(original)).tap do |color|
         color.options = {} # `inspect` requires options to be set
       end.inspect
 
@@ -30,13 +28,5 @@ module SCSSLint
                "Color `#{original}` should be written in hexadecimal form " \
                "as `#{hex_form}`")
     end
-
-    def color_keyword?(string)
-      color_rgb(string) && string != 'transparent'
-    end
-
-    def color_rgb(string)
-      Sass::Script::Value::Color::COLOR_NAMES[string]
-    end
   end
 end

data/lib/scss_lint/linter/color_variable.rb

@@ -0,0 +1,36 @@
+module SCSSLint
+  # Ensures color literals are used only in variable declarations.
+  class Linter::ColorVariable < Linter
+    include LinterRegistry
+
+    def visit_script_color(node)
+      return if in_variable_declaration?(node)
+
+      # Source range sometimes includes closing parenthesis, so extract it
+      color = source_from_range(node.source_range)[/(#?[a-z0-9]+)/i, 1]
+
+      record_lint(node, color)
+    end
+
+    def visit_script_string(node)
+      remove_quoted_strings(node.value)
+        .scan(/(^|\s)(#[a-f0-9]+|[a-z]+)(?=\s|$)/i)
+        .select { |_, word| color?(word) }
+        .each   { |_, color| record_lint(node, color) }
+    end
+
+  private
+
+    def record_lint(node, color)
+      add_lint node, "Color literals like `#{color}` should only be used in " \
+                     'variable declarations; they should be referred to via ' \
+                     'variable everywhere else.'
+    end
+
+    def in_variable_declaration?(node)
+      parent = node.node_parent
+      parent.is_a?(Sass::Script::Tree::Literal) &&
+        parent.node_parent.is_a?(Sass::Tree::VariableNode)
+    end
+  end
+end

data/lib/scss_lint/linter/declaration_order.rb

@@ -15,8 +15,8 @@ module SCSSLint
 
     MESSAGE =
       'Rule sets should be ordered as follows: '\
-      '@extends, @includes without @content, ' \
-      'properties, @includes with @content, ' \
+      '`@extends`, `@includes` without `@content`, ' \
+      'properties, `@includes` with `@content`, ' \
       'nested rule sets'
 
     MIXIN_WITH_CONTENT = 'mixin_with_content'

data/lib/scss_lint/linter/important_rule.rb

@@ -0,0 +1,12 @@
+module SCSSLint
+  # Reports the use of !important in properties.
+  class Linter::ImportantRule < Linter
+    include LinterRegistry
+
+    def visit_prop(node)
+      return unless source_from_range(node.source_range).include?('!important')
+
+      add_lint(node, '!important should not be used')
+    end
+  end
+end

data/lib/scss_lint/linter/indentation.rb

@@ -49,7 +49,7 @@ module SCSSLint
         return true
       end
 
-      unless actual_indent.length == @indent
+      unless allow_arbitrary_indent?(node) || actual_indent.length == @indent
         add_lint(node.line,
                  "Line should be indented #{@indent} #{character_name}s, " \
                  "but was indented #{actual_indent.length} #{character_name}s")
@@ -130,5 +130,11 @@ module SCSSLint
 
       same_position?(node.source_range.end_pos, first_child_source.start_pos)
     end
+
+    def allow_arbitrary_indent?(node)
+      @indent == 0 &&
+        config['allow_non_nested_indentation'] &&
+        node.is_a?(Sass::Tree::RuleNode)
+    end
   end
 end

data/lib/scss_lint/linter/property_count.rb

@@ -0,0 +1,44 @@
+module SCSSLint
+  # Checks that the number of properties in a rule set is under a defined limit.
+  class Linter::PropertyCount < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @property_count = {} # Lookup table of counts for rule sets
+      @max = config['max_properties']
+      yield # Continue linting children
+    end
+
+    def visit_rule(node)
+      count = property_count(node)
+
+      if count > @max
+        add_lint node,
+                 "Rule set contains (#{count}/#{@max}) properties" \
+                 "#{' (including properties in nested rule sets)' if config['include_nested']}"
+
+        # Don't lint nested rule sets as we already have them in the count
+        return if config['include_nested']
+      end
+
+      yield # Lint nested rule sets
+    end
+
+  private
+
+    def property_count(rule_node)
+      @property_count[rule_node] ||=
+        begin
+          count = rule_node.children.count { |node| node.is_a?(Sass::Tree::PropNode) }
+
+          if config['include_nested']
+            count += rule_node.children.inject(0) do |sum, node|
+              node.is_a?(Sass::Tree::RuleNode) ? sum + property_count(node) : sum
+            end
+          end
+
+          count
+        end
+    end
+  end
+end

data/lib/scss_lint/linter/property_sort_order.rb

@@ -1,48 +1,102 @@
 module SCSSLint
   # Checks the declaration order of properties.
-  class Linter::PropertySortOrder < Linter
+  class Linter::PropertySortOrder < Linter # rubocop:disable ClassLength
     include LinterRegistry
 
     def visit_root(_node)
       @preferred_order = extract_preferred_order_from_config
-      yield
+
+      if @preferred_order && config['separate_groups']
+        @group = assign_groups(@preferred_order)
+      end
+
+      yield # Continue linting children
     end
 
-    def check_sort_order(node)
+    def check_order(node)
       sortable_props = node.children.select do |child|
         child.is_a?(Sass::Tree::PropNode) && !ignore_property?(child)
       end
 
       sortable_prop_info = sortable_props
-        .map { |child| child.name.join }
-        .map do |name|
+        .map do |child|
+          name = child.name.join
           /^(?<vendor>-\w+(-osx)?-)?(?<property>.+)/ =~ name
-          { name: name, vendor: vendor, property: property }
+          { name: name, vendor: vendor, property: property, node: child }
+        end
+
+      if sortable_props.any?
+        check_sort_order(sortable_prop_info)
+        check_group_separation(sortable_prop_info) if @group
+      end
+
+      yield # Continue linting children
+    end
+
+    alias_method :visit_media, :check_order
+    alias_method :visit_mixin, :check_order
+    alias_method :visit_rule,  :check_order
+
+    def visit_if(node, &block)
+      check_order(node, &block)
+      visit(node.else) if node.else
+    end
+
+  private
+
+    # When enforcing whether a blank line should separate "groups" of
+    # properties, we need to assign those properties to group numbers so we can
+    # quickly tell traversing from one property to the other that a blank line
+    # is required (since the group number would change).
+    def assign_groups(order)
+      group_number = 0
+      last_was_empty = false
+
+      order.each_with_object({}) do |property, group|
+        # A gap indicates the start of the next group
+        if property.nil? || property.strip.empty?
+          group_number += 1 unless last_was_empty # Treat multiple gaps as single gap
+          last_was_empty = true
+          next
         end
 
+        last_was_empty = false
+
+        group[property] = group_number
+      end
+    end
+
+    def check_sort_order(sortable_prop_info)
       sorted_props = sortable_prop_info
         .sort { |a, b| compare_properties(a, b) }
 
       sorted_props.each_with_index do |prop, index|
         next unless prop != sortable_prop_info[index]
 
-        add_lint(sortable_props[index], lint_message(sorted_props))
+        add_lint(sortable_prop_info[index][:node], lint_message(sorted_props))
         break
       end
-
-      yield # Continue linting children
     end
 
-    alias_method :visit_media, :check_sort_order
-    alias_method :visit_mixin, :check_sort_order
-    alias_method :visit_rule,  :check_sort_order
+    def check_group_separation(sortable_prop_info) # rubocop:disable AbcSize
+      group_number = @group[sortable_prop_info.first[:property]]
 
-    def visit_if(node, &block)
-      check_sort_order(node, &block)
-      visit(node.else) if node.else
-    end
+      sortable_prop_info[0..-2].zip(sortable_prop_info[1..-1]).each do |first, second|
+        next unless @group[second[:property]] != group_number
 
-  private
+        # We're now in the next group
+        group_number = @group[second[:property]]
+
+        # The group number has changed, so ensure this property is separated
+        # from the previous property by at least a line (could be a comment,
+        # we don't care, but at least one line that isn't another property).
+        next if first[:node].line < second[:node].line - 1
+
+        add_lint second[:node], "Property #{second[:name]} should be " \
+                                'separated from the previous group of ' \
+                                "properties ending with #{first[:name]}"
+      end
+    end
 
     # Compares two properties which can contain a vendor prefix. It allows for a
     # sort order like:
@@ -100,11 +154,11 @@ module SCSSLint
                                      "#{config['order']}.txt"))
           file.read.split("\n").reject { |line| line =~ /^(#|\s*$)/ }
         rescue Errno::ENOENT
-          raise SCSSLint::LinterError,
+          raise SCSSLint::Exceptions::LinterError,
                 "Preset property sort order '#{config['order']}' does not exist"
         end
       else
-        raise SCSSLint::LinterError,
+        raise SCSSLint::Exceptions::LinterError,
               'Invalid property sort order specified -- must be the name of a '\
               'preset or an array of strings'
       end

data/lib/scss_lint/linter/string_quotes.rb

@@ -3,6 +3,15 @@ module SCSSLint
   class Linter::StringQuotes < Linter
     include LinterRegistry
 
+    def visit_comment(_node)
+      # Sass allows you to write Sass Script in non-silent comments (/* ... */).
+      # Unfortunately, it doesn't report correct source ranges for these script
+      # nodes.
+      # It's unlikely that a developer wanted to lint the script they wrote in a
+      # comment, so just ignore this case entirely and stop traversing the
+      # children of comment nodes.
+    end
+
     def visit_script_stringinterpolation(node)
       # We can't statically determine what the resultant string looks like when
       # string interpolation is used, e.g. "one #{$var} three" could be a very

data/lib/scss_lint/linter/variable_for_property.rb

@@ -0,0 +1,20 @@
+module SCSSLint
+  # Reports the use of literals for properties where variables are prefered.
+  class Linter::VariableForProperty < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @properties = Set.new(config['properties'])
+      yield if @properties.any?
+    end
+
+    def visit_prop(node)
+      property_name = node.name.join
+      return unless @properties.include? property_name
+      return if node.children.first.is_a?(Sass::Script::Tree::Variable)
+
+      add_lint(node, "Property #{property_name} should use " \
+                     'a variable rather than a literal value')
+    end
+  end
+end

data/lib/scss_lint/linter/vendor_prefixes.rb

@@ -16,8 +16,8 @@ module SCSSLint
       check_identifier(node, name.gsub(/^@/, ''))
 
       # Check for values
-      return unless node.respond_to?(:value) && node.value.respond_to?(:to_sass)
-      check_identifier(node, node.value.to_sass)
+      return unless node.respond_to?(:value) && node.value.respond_to?(:source_range)
+      check_identifier(node, source_from_range(node.value.source_range))
     end
 
     alias_method :visit_prop, :check_node
@@ -31,7 +31,7 @@ module SCSSLint
 
       # Strip vendor prefix to check against identifiers.
       # (Also strip closing parentheticals from values like linear-gradient.)
-      stripped_identifier = identifier.gsub(/(^[_-][a-zA-Z0-9_]+-|\(.*\))/, '')
+      stripped_identifier = identifier.gsub(/(^[_-][a-zA-Z0-9_]+-|\(.*\)|;)/, '').strip
       return if @exclusions.include?(stripped_identifier)
       return unless @identifiers.include?(stripped_identifier)
 

data/lib/scss_lint/runner.rb

@@ -31,12 +31,10 @@ module SCSSLint
     # @param file [String]
     def find_lints(file)
       engine = Engine.new(file)
-      config = @config.preferred ? @config : Config.for_file(file)
-      config ||= @config
 
       @linters.each do |linter|
         begin
-          run_linter(linter, engine, config, file)
+          run_linter(linter, engine, file)
         rescue => error
           raise SCSSLint::Exceptions::LinterError,
                 "#{linter.class} raised unexpected error linting file #{file}: " \
@@ -52,10 +50,10 @@ module SCSSLint
     end
 
     # For stubbing in tests.
-    def run_linter(linter, engine, config, file)
-      return unless config.linter_enabled?(linter)
-      return if config.excluded_file_for_linter?(file, linter)
-      linter.run(engine, config.linter_options(linter))
+    def run_linter(linter, engine, file)
+      return unless @config.linter_enabled?(linter)
+      return if @config.excluded_file_for_linter?(file, linter)
+      linter.run(engine, @config.linter_options(linter))
     end
   end
 end

data/lib/scss_lint/utils.rb

@@ -1,6 +1,40 @@
 module SCSSLint
   # Collection of helpers used across a variety of linters.
   module Utils
+    COLOR_REGEX = /^#[a-f0-9]{3,6}$/i
+
+    # Returns whether the given string is a color literal (keyword or hex code).
+    #
+    # @param string [String]
+    # @return [true,false]
+    def color?(string)
+      color_keyword?(string) || color_hex?(string)
+    end
+
+    # Returns whether the given string is a color hexadecimal code.
+    #
+    # @param string [String]
+    # @return [true,false]
+    def color_hex?(string)
+      string =~ COLOR_REGEX
+    end
+
+    # Returns whether the given string is a valid color keyword.
+    #
+    # @param string [String]
+    # @return [true,false]
+    def color_keyword?(string)
+      color_keyword_to_code(string) && string != 'transparent'
+    end
+
+    # Returns the hexadecimal code for the given color keyword.
+    #
+    # @param string [String]
+    # @return [String] 7-character hexadecimal code (includes `#` prefix)
+    def color_keyword_to_code(string)
+      Sass::Script::Value::Color::COLOR_NAMES[string]
+    end
+
     # Given a selector array which is a list of strings with Sass::Script::Nodes
     # interspersed within them, return an array of strings representing those
     # selectors with the Sass::Script::Nodes removed (i.e., ignoring

data/lib/scss_lint/version.rb

@@ -1,4 +1,4 @@
 # Defines the gem version.
 module SCSSLint
-  VERSION = '0.33.0'
+  VERSION = '0.34.0'
 end

data/spec/scss_lint/cli_spec.rb

@@ -33,7 +33,7 @@ describe SCSSLint::CLI do
     subject     { SCSSLint::CLI.new }
 
     before do
-      subject.stub(:extract_files_from).and_return(files)
+      SCSSLint::FileFinder.any_instance.stub(:find).and_return(files)
     end
 
     def safe_run

data/spec/scss_lint/config_spec.rb

@@ -62,7 +62,7 @@ describe SCSSLint::Config do
       let(:config_file) { '' }
 
       it 'returns the default configuration' do
-        subject.should == described_class.default
+        subject.options.should == described_class.default.options
       end
     end
 
@@ -70,7 +70,7 @@ describe SCSSLint::Config do
       let(:config_file) { '# This is a comment' }
 
       it 'returns the default configuration' do
-        subject.should == described_class.default
+        subject.options.should == described_class.default.options
       end
     end
 
@@ -88,7 +88,7 @@ describe SCSSLint::Config do
       let(:config_file) { default_file }
 
       it 'returns a configuration equivalent to the default' do
-        subject.should == described_class.default
+        subject.options.should == described_class.default.options
       end
     end
 
@@ -100,159 +100,7 @@ describe SCSSLint::Config do
       FILE
 
       it 'returns a configuration equivalent to the default' do
-        subject.should == described_class.default
-      end
-    end
-
-    context 'with a file that includes another configuration file' do
-      let(:included_file_path) { '../included_file.yml' }
-
-      let(:config_file) { <<-FILE }
-      inherit_from: #{included_file_path}
-
-      linters:
-        FakeConfigLinter:
-          enabled: true
-          some_other_option: some_other_value
-      FILE
-
-      before do
-        described_class.stub(:load_file_contents)
-                       .with("#{config_dir}/" + included_file_path)
-                       .and_return(included_file)
-      end
-
-      context 'and the included file has a different setting from the default' do
-        let(:included_file) { <<-FILE }
-          linters:
-            OtherFakeConfigLinter:
-              enabled: true
-              some_option: some_value
-        FILE
-
-        it 'reflects the different setting of the included file' do
-          subject.options['linters']['OtherFakeConfigLinter']
-            .should == { 'enabled' => true, 'some_option' => 'some_value' }
-        end
-
-        it 'reflects the different setting of the file that included the file' do
-          subject.options['linters']['FakeConfigLinter']
-            .should == { 'enabled' => true, 'some_other_option' => 'some_other_value' }
-        end
-      end
-
-      context 'and the included file has the same setting as the default' do
-        let(:included_file) { <<-FILE }
-          linters:
-            OtherFakeConfigLinter:
-              enabled: false
-        FILE
-
-        it 'does not alter the default configuration' do
-          subject.options['linters']['OtherFakeConfigLinter']
-            .should == { 'enabled' => false }
-        end
-
-        it 'reflects the different setting of the file that included the file' do
-          subject.options['linters']['FakeConfigLinter']
-            .should == { 'enabled' => true, 'some_other_option' => 'some_other_value' }
-        end
-      end
-
-      context 'and the included file includes another file' do
-        let(:other_included_file_path) { '/some/abs/other_included_file.yml' }
-
-        let(:other_included_file) { <<-FILE }
-          linters:
-            OtherFakeConfigLinter:
-              yet_another_option: yet_another_value
-        FILE
-
-        let(:included_file) { <<-FILE }
-          inherit_from: #{other_included_file_path}
-
-          linters:
-            OtherFakeConfigLinter:
-              enabled: true
-              some_option: some_value
-        FILE
-
-        before do
-          described_class.stub(:load_file_contents)
-                         .with(other_included_file_path)
-                         .and_return(other_included_file)
-        end
-
-        it "reflects the different setting of the included file's included file" do
-          subject.options['linters']['OtherFakeConfigLinter']
-            .should == {
-              'enabled' => true,
-              'some_option' => 'some_value',
-              'yet_another_option' => 'yet_another_value',
-            }
-        end
-
-        it 'reflects the different setting of the file that included the file' do
-          subject.options['linters']['FakeConfigLinter']
-            .should == { 'enabled' => true, 'some_other_option' => 'some_other_value' }
-        end
-      end
-    end
-
-    context 'with a file that includes multiple configuration files' do
-      let(:included_file_path) { '../included_file.yml' }
-      let(:other_included_file_path) { '/some/dir/other_included_file.yml' }
-
-      let(:config_file) { <<-FILE }
-      inherit_from:
-        - #{included_file_path}
-        - #{other_included_file_path}
-
-      linters:
-        FakeConfigLinter:
-          enabled: true
-          some_other_option: some_other_value
-      FILE
-
-      before do
-        described_class.stub(:load_file_contents)
-                       .with("#{config_dir}/" + included_file_path)
-                       .and_return(included_file)
-
-        described_class.stub(:load_file_contents)
-                       .with(other_included_file_path)
-                       .and_return(other_included_file)
-      end
-
-      context 'and the included files have settings different from each other' do
-        let(:included_file) { <<-FILE }
-          linters:
-            OtherFakeConfigLinter:
-              enabled: true
-              some_option: earlier_value
-              some_other_option: value
-        FILE
-
-        let(:other_included_file) { <<-FILE }
-          linters:
-            OtherFakeConfigLinter:
-              enabled: true
-              some_option: later_value
-        FILE
-
-        it 'uses the value of the file that was included last' do
-          subject.options['linters']['OtherFakeConfigLinter']['some_option']
-            .should == 'later_value'
-        end
-
-        it 'loads settings from both included files' do
-          subject.options['linters']['OtherFakeConfigLinter']
-            .should == {
-              'enabled' => true,
-              'some_option' => 'later_value',
-              'some_other_option' => 'value',
-            }
-        end
+        subject.options.should == described_class.default.options
       end
     end
 
@@ -284,53 +132,6 @@ describe SCSSLint::Config do
     end
   end
 
-  describe '.for_file' do
-    include_context 'isolated environment'
-
-    let(:linted_file) { File.join('foo', 'bar', 'baz', 'file-being-linted.scss') }
-    subject { described_class.for_file(linted_file) }
-
-    before do
-      described_class.instance_variable_set(:@dir_to_config, nil) # Clear cache
-      FileUtils.mkpath(File.dirname(linted_file))
-      FileUtils.touch(linted_file)
-    end
-
-    context 'when there are no configuration files in the directory hierarchy' do
-      it { should be_nil }
-    end
-
-    context 'when there is a configuration file in the same directory' do
-      let(:config_file) { File.join('foo', 'bar', 'baz', '.scss-lint.yml') }
-      before { FileUtils.touch(config_file) }
-
-      it 'loads that configuration file' do
-        described_class.should_receive(:load).with(File.expand_path(config_file))
-        subject
-      end
-    end
-
-    context 'when there is a configuration file in the parent directory' do
-      let(:config_file) { File.join('foo', 'bar', '.scss-lint.yml') }
-      before { FileUtils.touch(config_file) }
-
-      it 'loads that configuration file' do
-        described_class.should_receive(:load).with(File.expand_path(config_file))
-        subject
-      end
-    end
-
-    context 'when there is a configuration file in some ancestor directory' do
-      let(:config_file) { File.join('foo', '.scss-lint.yml') }
-      before { FileUtils.touch(config_file) }
-
-      it 'loads that configuration file' do
-        described_class.should_receive(:load).with(File.expand_path(config_file))
-        subject
-      end
-    end
-  end
-
   describe '#linter_options' do
     let(:config) { described_class.new(options) }