scss_lint 0.41.0 → 0.42.0

data/lib/scss_lint/linter/trailing_semicolon.rb

@@ -8,7 +8,7 @@ module SCSSLint
     end
 
     def visit_variable(node)
-      check_semicolon(node)
+      check_semicolon(node.expr)
     end
 
     def visit_prop(node)
@@ -52,12 +52,26 @@ module SCSSLint
 
     # Checks that the node is ended by a semicolon (with no whitespace)
     def ends_with_semicolon?(node)
-      source_from_range(node.source_range) =~ /;(\s*})?$/
+      semicolon_after_parenthesis?(node) ||
+        # Otherwise just check for a semicolon
+        source_from_range(node.source_range) =~ /;(\s*})?$/
+    end
+
+    # Special case: Sass doesn't include the semicolon after an expression
+    # in the source range it reports, so we need a helper to check after the
+    # reported range.
+    def semicolon_after_parenthesis?(node)
+      last_char = character_at(node.source_range.end_pos)
+      char_after = character_at(node.source_range.end_pos, 1)
+      (last_char == ')' && char_after == ';') ||
+        ([last_char, char_after].include?("\n") &&
+         engine.lines[node.source_range.end_pos.line] =~ /\);(\s*})?$/)
     end
 
     def ends_with_multiple_semicolons?(node)
       # Look one character past the end to see if there's another semicolon
-      character_at(node.source_range.end_pos, 1) == ';'
+      character_at(node.source_range.end_pos) == ';' &&
+        character_at(node.source_range.end_pos, 1) == ';'
     end
 
     def has_space_before_semicolon?(node)

data/lib/scss_lint/linter/url_format.rb

@@ -18,7 +18,7 @@ module SCSSLint
 
     def visit_prop(node)
       if url_literal?(node.value)
-        url = node.value.to_sass.gsub(/^url\((.*)\)$/, '\\1')
+        url = node.value.to_sass.sub(/^url\((.*)\)$/, '\\1')
         check_url(url, node)
       end
 
@@ -32,7 +32,7 @@ module SCSSLint
       return unless prop_value.value.is_a?(Sass::Script::Value::String)
       return unless prop_value.value.type == :identifier
 
-      prop_value.to_sass.match(/^url\(/)
+      prop_value.to_sass.start_with?('url(')
     end
 
     def url_string?(arg)
@@ -43,7 +43,7 @@ module SCSSLint
     end
 
     def check_url(url, node)
-      return if url.match(/^data:/)
+      return if url.start_with?('data:')
       uri = URI(url)
 
       if uri.scheme || uri.host

data/lib/scss_lint/linter/variable_for_property.rb

@@ -15,6 +15,7 @@ module SCSSLint
       return unless @properties.include?(property_name)
       return if ignored_value?(node.value)
       return if node.children.first.is_a?(Sass::Script::Tree::Variable)
+      return if variable_property_with_important?(node.value)
 
       add_lint(node, "Property #{property_name} should use " \
                      'a variable rather than a literal value')
@@ -22,6 +23,13 @@ module SCSSLint
 
   private
 
+    def variable_property_with_important?(value)
+      value.is_a?(Sass::Script::Tree::ListLiteral) &&
+        value.children.length == 2 &&
+        value.children.first.is_a?(Sass::Script::Tree::Variable) &&
+        value.children.last.value.value == '!important'
+    end
+
     def ignored_value?(value)
       value.respond_to?(:value) &&
         IGNORED_VALUES.include?(value.value.to_s)

data/lib/scss_lint/linter/vendor_prefix.rb

@@ -13,7 +13,7 @@ module SCSSLint
     def check_node(node)
       name = node.name.is_a?(Array) ? node.name.join : node.name
       # Ignore '@' from @keyframes node name
-      check_identifier(node, name.gsub(/^@/, ''))
+      check_identifier(node, name.sub(/^@/, ''))
 
       # Check for values
       return unless node.respond_to?(:value) && node.value.respond_to?(:source_range)

data/lib/scss_lint/rake_task.rb

@@ -31,6 +31,10 @@ module SCSSLint
     # @return [String]
     attr_accessor :config
 
+    # Command-line args to use.
+    # @return [Array<String>]
+    attr_accessor :args
+
     # List of files to lint (can contain shell globs).
     #
     # Note that this will be ignored if you explicitly pass a list of files as
@@ -67,7 +71,7 @@ module SCSSLint
     def run_cli(task_args)
       cli_args = ['--config', config] if config
 
-      result = SCSSLint::CLI.new.run(Array(cli_args) + files_to_lint(task_args))
+      result = SCSSLint::CLI.new.run(Array(cli_args) + Array(args) + files_to_lint(task_args))
 
       message =
         case result
@@ -98,6 +102,7 @@ module SCSSLint
     def default_description
       description = 'Run `scss-lint'
       description += " --config #{config}" if config
+      description += " #{args}" if args
       description += " #{files.join(' ')}" if files.any?
       description += ' [files...]`'
       description

data/lib/scss_lint/runner.rb

@@ -8,7 +8,8 @@ module SCSSLint
     def initialize(config)
       @config  = config
       @lints   = []
-      @linters = LinterRegistry.linters.map(&:new)
+      @linters = LinterRegistry.linters.select { |linter| @config.linter_enabled?(linter) }
+      @linters.map!(&:new)
     end
 
     # @param files [Array]
@@ -44,7 +45,6 @@ module SCSSLint
 
     # For stubbing in tests.
     def run_linter(linter, engine, file)
-      return unless @config.linter_enabled?(linter)
       return if @config.excluded_file_for_linter?(file, linter)
       @lints += linter.run(engine, @config.linter_options(linter))
     end

data/lib/scss_lint/sass/tree.rb

@@ -104,7 +104,7 @@ module Sass::Tree
 
   class IfNode
     def children
-      concat_expr_lists super, expr, self.else
+      concat_expr_lists super, expr
     end
   end
 

data/lib/scss_lint/selector_visitor.rb

@@ -25,10 +25,10 @@ module SCSSLint
     def selector_node_name(node)
       # Converts the class name of a node into snake_case form, e.g.
       # `Sass::Selector::SimpleSequence` -> `simple_sequence`
-      node.class.name.gsub(/.*::(.*?)$/, '\\1')
-                      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                      .downcase
+      name = node.class.name.gsub(/.*::(.*?)$/, '\\1')
+      name.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      name.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      name.downcase!
     end
   end
 end

data/lib/scss_lint/version.rb

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

data/spec/scss_lint/cli_spec.rb

@@ -166,18 +166,6 @@ describe SCSSLint::CLI do
       end
     end
 
-    context 'when all specified SCSS files are filtered by exclusions' do
-      before do
-        SCSSLint::FileFinder.any_instance.stub(:find)
-          .and_raise(SCSSLint::Exceptions::AllFilesFilteredError)
-      end
-
-      it 'exits with an appropriate status code' do
-        subject.should_receive(:halt).with(:files_filtered)
-        safe_run
-      end
-    end
-
     context 'when a config file is specified' do
       let(:flags) { ['--config', 'custom_config.yml'] }
 

data/spec/scss_lint/file_finder_spec.rb

@@ -76,9 +76,7 @@ describe SCSSLint::FileFinder do
               config.exclude_file('some-dir/test.scss')
             end
 
-            it 'raises an error' do
-              expect { subject }.to raise_error SCSSLint::Exceptions::AllFilesFilteredError
-            end
+            it { should == [] }
           end
         end
 
@@ -103,9 +101,7 @@ describe SCSSLint::FileFinder do
               config.exclude_file('**/*.scss')
             end
 
-            it 'raises an error' do
-              expect { subject }.to raise_error SCSSLint::Exceptions::AllFilesFilteredError
-            end
+            it { should == [] }
           end
         end
 

data/spec/scss_lint/linter/color_variable_spec.rb

@@ -127,7 +127,7 @@ describe SCSSLint::Linter::ColorVariable do
       }
     SCSS
 
-    it { should_not report_lint }
+    it { should report_lint line: 2 }
   end
 
   context 'when a color literal is used in a map declaration' do
@@ -164,4 +164,44 @@ describe SCSSLint::Linter::ColorVariable do
 
     it { should_not report_lint }
   end
+
+  context 'when a color function containing literals is used in a property' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: rgb(0, 100, 200);
+      }
+      a {
+        color: rgb(0%, 50%, 80%);
+      }
+      i {
+        color: rgba(0, 0, 0, .5);
+      }
+      span {
+        color: hsl(0, 100%, 50%);
+      }
+      .class {
+        color: hsla(0, 100%, 50%, .5);
+      }
+    SCSS
+
+    it { should report_lint line: 2 }
+    it { should report_lint line: 5 }
+    it { should report_lint line: 8 }
+    it { should report_lint line: 11 }
+    it { should report_lint line: 14 }
+  end
+
+  context 'when transforming a variable value in a function call' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: rgba($red, .5);
+      }
+
+      a {
+        color: lighten($red, 5%);
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
 end

data/spec/scss_lint/linter/space_after_comma_spec.rb

@@ -1,119 +1,856 @@
 require 'spec_helper'
 
 describe SCSSLint::Linter::SpaceAfterComma do
-  context 'in a mixin declaration' do
-    context 'where spaces do not follow commas' do
-      let(:scss) { <<-SCSS }
+  let(:linter_config) { { 'style' => style } }
+
+  context 'when one space is preferred' do
+    let(:style) { 'one_space' }
+
+    context 'in a mixin declaration' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        @mixin mixin($arg1,$arg2,$kwarg1: 'default',$kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should report_lint count: 3 }
+      end
+
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        @mixin mixin($arg1, $arg2, $kwarg1: 'default', $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        @mixin mixin($arg1 , $arg2 , $kwarg1: 'default' , $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        @mixin mixin($arg1,
+                     $arg2,
+                     $kwarg1: 'default',
+                     $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'definining a variable argument' do
+        context 'where spaces do not follow commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg,$args...) {
+          }
+          SCSS
+
+          it { should report_lint count: 1 }
+        end
+
+        context 'where spaces follow commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg, $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where spaces surround commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg , $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where commas are followed by a newline' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg,
+                       $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+      end
+    end
+
+    context 'in a mixin inclusion' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1,2,3,$args...,$kwarg1: 4,$kwarg2: 5,$kwargs...);
+        }
+        SCSS
+
+        it { should report_lint count: 6 }
+      end
+
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1, 2, 3, $args..., $kwarg1: 4, $kwarg2: 5, $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1 , 2 , 3 , $args... , $kwarg1: 4 , $kwarg2: 5 , $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1,
+                         2,
+                         3,
+                         $args...,
+                         $kwarg1: 4,
+                         $kwarg2: 5,
+                         $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+    end
+
+    context 'in a function declaration' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1,$arg2,$kwarg1: 'default',$kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should report_lint count: 3 }
+      end
+
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1, $arg2, $kwarg1: 'default', $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1 , $arg2 , $kwarg1: 'default' , $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1,
+                       $arg2,
+                       $kwarg1: 'default',
+                       $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'definining a variable argument' do
+        context 'where spaces do not follow commas' do
+          let(:scss) { <<-SCSS }
+          @function func($arg,$args...) {
+          }
+          SCSS
+
+          it { should report_lint count: 1 }
+        end
+
+        context 'where spaces follow commas' do
+          let(:scss) { <<-SCSS }
+          @function func($arg, $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where spaces surround commas' do
+          let(:scss) { <<-SCSS }
+          @function func($arg , $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where commas are followed by a newline' do
+          let(:scss) { <<-SCSS }
+          @function func($arg,
+                         $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+      end
+    end
+
+    context 'in a function invocation' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1,2,3,$args...,$kwarg1: 4,$kwarg2: 5,$kwargs...);
+        }
+        SCSS
+
+        it { should report_lint count: 6 }
+      end
+
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1, 2, 3, $args..., $kwarg1: 4, $kwarg2: 5, $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1 , 2 , 3 , $args... , $kwarg1: 4 , $kwarg2: 5 , $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1,
+                       2,
+                       3,
+                       $args...,
+                       $kwarg1: 4,
+                       $kwarg2: 5,
+                       $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+    end
+
+    context 'in a comma-separated literal list' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a,$b,$c,$d;
+        }
+        SCSS
+
+        it { should report_lint count: 3 }
+      end
+
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a, $b, $c, $d;
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a , $b , $c , $d;
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a,
+                    $b,
+                    $c,
+                    $d;
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'when commas are followed by a space and a newline' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a,\s
+                    $b;
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+    end
+
+    context 'when declaring list variables' do
+      context 'and one argument does not have a trailing comma' do
+        let(:scss) { <<-SCSS }
+        $z-list: (
+          (
+            name1
+          ),
+          (
+            name2,
+          )
+        );
+        SCSS
+
+        it { should_not report_lint }
+      end
+    end
+  end
+
+  context 'when more than one space is preferred' do
+    let(:style) { 'at_least_one_space' }
+
+    context 'in a mixin declaration' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
         @mixin mixin($arg1,$arg2,$kwarg1: 'default',$kwarg2: 'default') {
         }
-      SCSS
+        SCSS
+
+        it { should report_lint count: 3 }
+      end
+
+      context 'where one space follows commas' do
+        let(:scss) { <<-SCSS }
+        @mixin mixin($arg1, $arg2, $kwarg1: 'default', $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where more than one space follows commas' do
+        let(:scss) { <<-SCSS }
+        @mixin mixin($arg1,     $arg2,  $kwarg1: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        @mixin mixin($arg1 , $arg2 , $kwarg1: 'default' , $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        @mixin mixin($arg1,
+                     $arg2,
+                     $kwarg1: 'default',
+                     $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'definining a variable argument' do
+        context 'where spaces do not follow commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg,$args...) {
+          }
+          SCSS
+
+          it { should report_lint count: 1 }
+        end
+
+        context 'where spaces follow commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg, $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where multiple spaces follow commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg,    $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where spaces surround commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg , $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where commas are followed by a newline' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg,
+                       $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+      end
+    end
+
+    context 'in a mixin inclusion' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1,2,3,$args...,$kwarg1: 4,$kwarg2: 5,$kwargs...);
+        }
+        SCSS
+
+        it { should report_lint count: 6 }
+      end
+
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1, 2, 3, $args..., $kwarg1: 4, $kwarg2: 5, $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where multiple spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1,  2,  3,  $args...,  $kwarg1: 4,  $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1 , 2 , 3 , $args... , $kwarg1: 4 , $kwarg2: 5 , $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        p {
+          @include mixin(1,
+                         2,
+                         3,
+                         $args...,
+                         $kwarg1: 4,
+                         $kwarg2: 5,
+                         $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+    end
+
+    context 'in a function declaration' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1,$arg2,$kwarg1: 'default',$kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should report_lint count: 3 }
+      end
+
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1, $arg2, $kwarg1: 'default', $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where multiple spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1,   $kwarg1: 'default',    $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1 , $arg2 , $kwarg1: 'default' , $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        @function func($arg1,
+                       $arg2,
+                       $kwarg1: 'default',
+                       $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'definining a variable argument' do
+        context 'where spaces do not follow commas' do
+          let(:scss) { <<-SCSS }
+          @function func($arg,$args...) {
+          }
+          SCSS
+
+          it { should report_lint count: 1 }
+        end
+
+        context 'where spaces follow commas' do
+          let(:scss) { <<-SCSS }
+          @function func($arg, $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where multiple spaces follow commas' do
+          let(:scss) { <<-SCSS }
+          @function func($arg,      $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where spaces surround commas' do
+          let(:scss) { <<-SCSS }
+          @function func($arg , $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where commas are followed by a newline' do
+          let(:scss) { <<-SCSS }
+          @function func($arg,
+                         $args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+      end
+    end
+
+    context 'in a function invocation' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1,2,3,$args...,$kwarg1: 4,$kwarg2: 5,$kwargs...);
+        }
+        SCSS
+
+        it { should report_lint count: 6 }
+      end
+
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1, 2, 3, $args..., $kwarg1: 4, $kwarg2: 5, $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where multiple spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1,  $args...,    $kwarg1: 4,   $kwargs...);
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1 , 2 , 3 , $args... , $kwarg1: 4 , $kwarg2: 5 , $kwargs...);
+        }
+        SCSS
 
-      it { should report_lint count: 3 }
-    end
+        it { should_not report_lint }
+      end
 
-    context 'where spaces follow commas' do
-      let(:scss) { <<-SCSS }
-        @mixin mixin($arg1, $arg2, $kwarg1: 'default', $kwarg2: 'default') {
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        p {
+          margin: func(1,
+                       2,
+                       3,
+                       $args...,
+                       $kwarg1: 4,
+                       $kwarg2: 5,
+                       $kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
+        it { should_not report_lint }
+      end
     end
 
-    context 'where spaces surround commas' do
-      let(:scss) { <<-SCSS }
-        @mixin mixin($arg1 , $arg2 , $kwarg1: 'default' , $kwarg2: 'default') {
+    context 'in a comma-separated literal list' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a,$b,$c,$d;
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 3 }
+      end
 
-    context 'where commas are followed by a newline' do
-      let(:scss) { <<-SCSS }
-        @mixin mixin($arg1,
-                     $arg2,
-                     $kwarg1: 'default',
-                     $kwarg2: 'default') {
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a, $b, $c, $d;
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where multiple spaces follow commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a,   $b,   $c,      $d;
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a , $b , $c , $d;
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a,
+                    $b,
+                    $c,
+                    $d;
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'when commas are followed by a space and a newline' do
+        let(:scss) { <<-SCSS }
+        p {
+          property: $a,\s
+                    $b;
         }
-      SCSS
+        SCSS
+
+        it { should_not report_lint }
+      end
+    end
+
+    context 'when declaring list variables' do
+      context 'and one argument does not have a trailing comma' do
+        let(:scss) { <<-SCSS }
+        $z-list: (
+          (
+            name1
+          ),
+          (
+            name2,
+          )
+        );
+        SCSS
 
-      it { should_not report_lint }
+        it { should_not report_lint }
+      end
     end
+  end
+
+  context 'when no space is preferred' do
+    let(:style) { 'no_space' }
 
-    context 'definining a variable argument' do
+    context 'in a mixin declaration' do
       context 'where spaces do not follow commas' do
         let(:scss) { <<-SCSS }
-          @mixin mixin($arg,$args...) {
-          }
+        @mixin mixin($arg1,$arg2,$kwarg1: 'default',$kwarg2: 'default') {
+        }
         SCSS
 
-        it { should report_lint count: 1 }
+        it { should_not report_lint }
       end
 
       context 'where spaces follow commas' do
         let(:scss) { <<-SCSS }
-          @mixin mixin($arg, $args...) {
-          }
+        @mixin mixin($arg1, $arg2, $kwarg1: 'default', $kwarg2: 'default') {
+        }
         SCSS
 
-        it { should_not report_lint }
+        it { should report_lint count: 3 }
       end
 
       context 'where spaces surround commas' do
         let(:scss) { <<-SCSS }
-          @mixin mixin($arg , $args...) {
-          }
+        @mixin mixin($arg1 , $arg2 , $kwarg1: 'default' , $kwarg2: 'default') {
+        }
         SCSS
 
-        it { should_not report_lint }
+        it { should report_lint count: 3 }
       end
 
       context 'where commas are followed by a newline' do
         let(:scss) { <<-SCSS }
+        @mixin mixin($arg1,
+                     $arg2,
+                     $kwarg1: 'default',
+                     $kwarg2: 'default') {
+        }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'definining a variable argument' do
+        context 'where spaces do not follow commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg,$args...) {
+          }
+          SCSS
+
+          it { should_not report_lint }
+        end
+
+        context 'where spaces follow commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg, $args...) {
+          }
+          SCSS
+
+          it { should report_lint count: 1 }
+        end
+
+        context 'where spaces surround commas' do
+          let(:scss) { <<-SCSS }
+          @mixin mixin($arg , $args...) {
+          }
+          SCSS
+
+          it { should report_lint count: 1 }
+        end
+
+        context 'where commas are followed by a newline' do
+          let(:scss) { <<-SCSS }
           @mixin mixin($arg,
                        $args...) {
           }
-        SCSS
+          SCSS
 
-        it { should_not report_lint }
+          it { should_not report_lint }
+        end
       end
     end
-  end
 
-  context 'in a mixin inclusion' do
-    context 'where spaces do not follow commas' do
-      let(:scss) { <<-SCSS }
+    context 'in a mixin inclusion' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
         p {
           @include mixin(1,2,3,$args...,$kwarg1: 4,$kwarg2: 5,$kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should report_lint count: 6 }
-    end
+        it { should_not report_lint }
+      end
 
-    context 'where spaces follow commas' do
-      let(:scss) { <<-SCSS }
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
         p {
           @include mixin(1, 2, 3, $args..., $kwarg1: 4, $kwarg2: 5, $kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 6 }
+      end
 
-    context 'where spaces surround commas' do
-      let(:scss) { <<-SCSS }
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
         p {
           @include mixin(1 , 2 , 3 , $args... , $kwarg1: 4 , $kwarg2: 5 , $kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 6 }
+      end
 
-    context 'where commas are followed by a newline' do
-      let(:scss) { <<-SCSS }
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
         p {
           @include mixin(1,
                          2,
@@ -123,125 +860,125 @@ describe SCSSLint::Linter::SpaceAfterComma do
                          $kwarg2: 5,
                          $kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
+        it { should_not report_lint }
+      end
     end
-  end
 
-  context 'in a function declaration' do
-    context 'where spaces do not follow commas' do
-      let(:scss) { <<-SCSS }
+    context 'in a function declaration' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
         @function func($arg1,$arg2,$kwarg1: 'default',$kwarg2: 'default') {
         }
-      SCSS
+        SCSS
 
-      it { should report_lint count: 3 }
-    end
+        it { should_not report_lint }
+      end
 
-    context 'where spaces follow commas' do
-      let(:scss) { <<-SCSS }
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
         @function func($arg1, $arg2, $kwarg1: 'default', $kwarg2: 'default') {
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 3 }
+      end
 
-    context 'where spaces surround commas' do
-      let(:scss) { <<-SCSS }
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
         @function func($arg1 , $arg2 , $kwarg1: 'default' , $kwarg2: 'default') {
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 3 }
+      end
 
-    context 'where commas are followed by a newline' do
-      let(:scss) { <<-SCSS }
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
         @function func($arg1,
                        $arg2,
                        $kwarg1: 'default',
                        $kwarg2: 'default') {
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should_not report_lint }
+      end
 
-    context 'definining a variable argument' do
-      context 'where spaces do not follow commas' do
-        let(:scss) { <<-SCSS }
+      context 'definining a variable argument' do
+        context 'where spaces do not follow commas' do
+          let(:scss) { <<-SCSS }
           @function func($arg,$args...) {
           }
-        SCSS
+          SCSS
 
-        it { should report_lint count: 1 }
-      end
+          it { should_not report_lint }
+        end
 
-      context 'where spaces follow commas' do
-        let(:scss) { <<-SCSS }
+        context 'where spaces follow commas' do
+          let(:scss) { <<-SCSS }
           @function func($arg, $args...) {
           }
-        SCSS
+          SCSS
 
-        it { should_not report_lint }
-      end
+          it { should report_lint count: 1 }
+        end
 
-      context 'where spaces surround commas' do
-        let(:scss) { <<-SCSS }
+        context 'where spaces surround commas' do
+          let(:scss) { <<-SCSS }
           @function func($arg , $args...) {
           }
-        SCSS
+          SCSS
 
-        it { should_not report_lint }
-      end
+          it { should report_lint count: 1 }
+        end
 
-      context 'where commas are followed by a newline' do
-        let(:scss) { <<-SCSS }
+        context 'where commas are followed by a newline' do
+          let(:scss) { <<-SCSS }
           @function func($arg,
                          $args...) {
           }
-        SCSS
+          SCSS
 
-        it { should_not report_lint }
+          it { should_not report_lint }
+        end
       end
     end
-  end
 
-  context 'in a function invocation' do
-    context 'where spaces do not follow commas' do
-      let(:scss) { <<-SCSS }
+    context 'in a function invocation' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
         p {
           margin: func(1,2,3,$args...,$kwarg1: 4,$kwarg2: 5,$kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should report_lint count: 6 }
-    end
+        it { should_not report_lint }
+      end
 
-    context 'where spaces follow commas' do
-      let(:scss) { <<-SCSS }
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
         p {
           margin: func(1, 2, 3, $args..., $kwarg1: 4, $kwarg2: 5, $kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 6 }
+      end
 
-    context 'where spaces surround commas' do
-      let(:scss) { <<-SCSS }
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
         p {
           margin: func(1 , 2 , 3 , $args... , $kwarg1: 4 , $kwarg2: 5 , $kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 6 }
+      end
 
-    context 'where commas are followed by a newline' do
-      let(:scss) { <<-SCSS }
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
         p {
           margin: func(1,
                        2,
@@ -251,71 +988,71 @@ describe SCSSLint::Linter::SpaceAfterComma do
                        $kwarg2: 5,
                        $kwargs...);
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
+        it { should_not report_lint }
+      end
     end
-  end
 
-  context 'in a comma-separated literal list' do
-    context 'where spaces do not follow commas' do
-      let(:scss) { <<-SCSS }
+    context 'in a comma-separated literal list' do
+      context 'where spaces do not follow commas' do
+        let(:scss) { <<-SCSS }
         p {
           property: $a,$b,$c,$d;
         }
-      SCSS
+        SCSS
 
-      it { should report_lint count: 3 }
-    end
+        it { should_not report_lint }
+      end
 
-    context 'where spaces follow commas' do
-      let(:scss) { <<-SCSS }
+      context 'where spaces follow commas' do
+        let(:scss) { <<-SCSS }
         p {
           property: $a, $b, $c, $d;
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 3 }
+      end
 
-    context 'where spaces surround commas' do
-      let(:scss) { <<-SCSS }
+      context 'where spaces surround commas' do
+        let(:scss) { <<-SCSS }
         p {
           property: $a , $b , $c , $d;
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should report_lint count: 3 }
+      end
 
-    context 'where commas are followed by a newline' do
-      let(:scss) { <<-SCSS }
+      context 'where commas are followed by a newline' do
+        let(:scss) { <<-SCSS }
         p {
           property: $a,
                     $b,
                     $c,
                     $d;
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
-    end
+        it { should_not report_lint }
+      end
 
-    context 'when commas are followed by a space and a newline' do
-      let(:scss) { <<-SCSS }
+      context 'when commas are followed by a space and a newline' do
+        let(:scss) { <<-SCSS }
         p {
           property: $a,\s
                     $b;
         }
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
+        it { should_not report_lint }
+      end
     end
-  end
 
-  context 'when declaring list variables' do
-    context 'and one argument does not have a trailing comma' do
-      let(:scss) { <<-SCSS }
+    context 'when declaring list variables' do
+      context 'and one argument does not have a trailing comma' do
+        let(:scss) { <<-SCSS }
         $z-list: (
           (
             name1
@@ -324,9 +1061,10 @@ describe SCSSLint::Linter::SpaceAfterComma do
             name2,
           )
         );
-      SCSS
+        SCSS
 
-      it { should_not report_lint }
+        it { should_not report_lint }
+      end
     end
   end
 end