scss-lint 0.10.1 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69f5645967ac2ed4c054af95508d25ffb88328f7
-  data.tar.gz: b8d83cdd575da8e42307dedfdeb32d2bb264a210
+  metadata.gz: 62980ca32775a70ec7170fc8b7399eb13b304c7b
+  data.tar.gz: 76fa2ea621edad2ad9ebc9d0e2b302b57c43a70d
 SHA512:
-  metadata.gz: 4cd037b4f7b02d0b011e2fc0db246cdfafa8f69a78dc2ad49e66d81df3e470f07731b4d23c115fc700426fc2c5f4dd41578be8b937a8449e4a977ef308944a40
-  data.tar.gz: dffa479078fac884d6ead1759882a9d23b1f1212618418b89a78b9fce1b2e0cf061817a26f9b523ae246bb7bb16a6b2ec7da52107b1487cc560822f38e2ac778
+  metadata.gz: ce7dfa08c1c68044da63de6f376a3ce483e5145eaa7854668b616dbd0b1596c983e7dbc5f510c8cdbf3d27f47658b21cebe5f0caa63b9c9a888ef0d0df772729
+  data.tar.gz: dae5b62b186b24c851394b7e18c16e45f4f1281a2046c7f6a00513deb94d8300df30e8a5e7e1d3845c77f9efe68f1fef5c9e4f059239499b55e56cf4ff24f0c4

data/lib/sass/script.rb

@@ -1,12 +1,58 @@
-# Contains extensions of Sass::Script::Nodes to add support for accessing
-# various parts of the parse tree not provided out-of-the-box.
 module Sass::Script
-  class Variable
-    # When accessing keyword arguments, the Sass parser treats the underscored
-    # name as canonical. Since this only matters during the compilation step, we
-    # can safely override the behaviour to return the original name.
-    def underscored_name
-      @name
+  # Redefine some of the lexer helpers in order to store the original string
+  # with the created object so that the original string can be inspected rather
+  # than a typically normalized version.
+  class Lexer
+    def color
+      return unless color_string = scan(REGULAR_EXPRESSIONS[:color])
+
+      unless [4, 7].include?(color_string.length)
+        raise ::Sass::SyntaxError,
+              "Colors must have either three or six digits: '#{color_string}'"
+      end
+
+      [:color, Value::Color.from_string(color_string)]
+    end
+
+    def number
+      return unless scan(REGULAR_EXPRESSIONS[:number])
+      value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
+      value = -value if @scanner[1]
+
+      number = Value::Number.new(value, Array(@scanner[4])).tap do |num|
+        num.original_string = @scanner[0]
+      end
+      [:number, number]
+    end
+  end
+
+  class Parser
+    # We redefine the ident parser to specially handle color keywords.
+    def ident
+      return funcall unless @lexer.peek && @lexer.peek.type == :ident
+      return if @stop_at && @stop_at.include?(@lexer.peek.value)
+
+      name = @lexer.next
+      if (color = Value::Color::COLOR_NAMES[name.value.downcase])
+        return literal_node(Value::Color.from_string(name.value, color), name.source_range)
+      end
+      literal_node(Value::String.new(name.value, :identifier), name.source_range)
+    end
+  end
+
+  class Value::Base
+    attr_accessor :node_parent
+
+    def children
+      []
+    end
+
+    def line
+      @line || (node_parent && node_parent.line)
+    end
+
+    def source_range
+      @source_range || (node_parent && node_parent.source_range)
     end
   end
 
@@ -14,8 +60,8 @@ module Sass::Script
   # color string. This adds an attribute to the Color to keep track of the
   # original string and provides a method which the modified lexer can use to
   # set it.
-  class Color
-    attr_accessor :original
+  class Value::Color
+    attr_accessor :original_string
 
     def self.from_string(string, rgb = nil)
       unless rgb
@@ -24,41 +70,29 @@ module Sass::Script
                      map { |hex| hex.ljust(2, hex).to_i(16) }
       end
 
-      color = Color.new(rgb, false)
-      color.original = string
+      color = new(rgb, false)
+      color.original_string = string
       color
     end
   end
 
-  class Lexer
-    # We redefine the color lexer to store the original string with the created
-    # `Color` object so that we can inspect the original string before it is
-    # normalized.
-    #
-    # This is an adapted version from the original Sass source code.
-    def color
-      return unless color_string = scan(REGULAR_EXPRESSIONS[:color])
-
-      unless [4, 7].include?(color_string.length)
-        raise ::Sass::SyntaxError,
-              "Colors must have either three or six digits: '#{color_string}'"
-      end
-
-      [:color, Color.from_string(color_string)]
-    end
+  class Value::Number
+    attr_accessor :original_string
   end
 
-  class Parser
-    # We redefine the ident parser to specially handle color keywords.
-    def ident
-      return funcall unless @lexer.peek && @lexer.peek.type == :ident
-      return if @stop_at && @stop_at.include?(@lexer.peek.value)
+  # Contains extensions of Sass::Script::Tree::Nodes to add support for
+  # accessing various parts of the parse tree not provided out-of-the-box.
+  module Tree
+    class Node
+      attr_accessor :node_parent
+    end
 
-      name = @lexer.next
-      if color = Color::COLOR_NAMES[name.value.downcase]
-        return node(Color.from_string(name.value, color))
+    class Literal
+      # Literals wrap their underlying values. For sake of convenience, consider
+      # the wrapped value a child of the Literal.
+      def children
+        [value]
       end
-      node(Sass::Script::String.new(name.value, :identifier))
     end
   end
 end

data/lib/sass/tree.rb

@@ -5,6 +5,9 @@
 module Sass::Tree
   # Define some common helper code for use in the various monkey patchings.
   class Node
+    # Stores node for which this node is a direct child
+    attr_accessor :node_parent
+
     # The `args` field of some Sass::Tree::Node classes returns
     # Sass::Script::Variable nodes with no line numbers. This adds the line
     # numbers back in so lint reporting works for those nodes.
@@ -17,7 +20,7 @@ module Sass::Tree
     # The Sass parser sometimes doesn't assign line numbers in cases where it
     # should. This is a helper to easily correct that.
     def add_line_number(node)
-      node.line ||= line if node.is_a?(Sass::Script::Node)
+      node.line ||= line if node.is_a?(::Sass::Script::Tree::Node)
       node
     end
 
@@ -25,7 +28,7 @@ module Sass::Tree
     # the name of the variable. This helper takes that name and turns it back
     # into a Sass::Script::Variable that supports lint reporting.
     def create_variable(var_name)
-      Sass::Script::Variable.new(var_name).tap do |v|
+      ::Sass::Script::Tree::Variable.new(var_name).tap do |v|
         v.line = line # Use line number of the containing parse tree node
       end
     end
@@ -34,7 +37,7 @@ module Sass::Tree
     # Sass::Script::Nodes interspersed within them. This returns a filtered list
     # of just those nodes.
     def extract_script_nodes(list)
-      list.select { |item| item.is_a? Sass::Script::Node }
+      list.select { |item| item.is_a?(::Sass::Script::Tree::Node) }
     end
 
     # Takes a list of arguments, be they arrays or individual objects, and
@@ -70,7 +73,9 @@ module Sass::Tree
 
   class EachNode
     def children
-      concat_expr_lists super, create_variable(var), list
+      loop_vars = vars.map { |var| create_variable(var) }
+
+      concat_expr_lists super, loop_vars, list
     end
   end
 
@@ -114,9 +119,9 @@ module Sass::Tree
 
       # Keyword mapping is String -> Expr, so convert the string to a variable
       # node that supports lint reporting
-      keyword_exprs = keywords.map do |var_name, var_expr|
+      keyword_exprs = keywords.as_stored.map do |var_name, var_expr|
         [create_variable(var_name), var_expr]
-      end
+      end if keywords.any?
 
       concat_expr_lists super, args, keyword_exprs, splat
     end

data/lib/scss_lint/lint.rb

@@ -1,11 +1,16 @@
 module SCSSLint
   class Lint
-    attr_reader :filename, :line, :description
+    attr_reader :filename, :line, :description, :severity
 
-    def initialize(filename, line, description)
+    def initialize(filename, line, description, severity = :warning)
       @filename = filename
       @line = line
       @description = description
+      @severity = severity
+    end
+
+    def error?
+      severity == :error
     end
   end
 end

data/lib/scss_lint/linter.rb

@@ -20,17 +20,20 @@ module SCSSLint
     end
 
     # Helper for creating lint from a parse tree node
-    def add_lint(node, message = nil)
+    def add_lint(node_or_line, message = nil)
+      line = node_or_line.respond_to?(:line) ? node_or_line.line : node_or_line
+
       @lints << Lint.new(engine.filename,
-                         node.line,
+                         line,
                          message || description)
     end
 
     # Monkey-patched implementation that adds support for traversing
     # Sass::Script::Nodes (original implementation only supports
     # Sass::Tree::Nodes).
-    def node_name(node)
-      if node.is_a?(Sass::Script::Node)
+    def self.node_name(node)
+      case node
+      when Sass::Script::Tree::Node, Sass::Script::Value::Base
         "script_#{node.class.name.gsub(/.*::(.*?)$/, '\\1').downcase}"
       else
         super
@@ -46,5 +49,13 @@ module SCSSLint
 
       super
     end
+
+    # Redefine so we can set the `node_parent` of each node
+    def visit_children(parent)
+      parent.children.each do |child|
+        child.node_parent = parent
+        visit(child)
+      end
+    end
   end
 end

data/lib/scss_lint/linter/color_keyword.rb

@@ -3,7 +3,7 @@ module SCSSLint
     include LinterRegistry
 
     def visit_script_color(node)
-      add_color_lint(node, node.original) if color_keyword?(node.original)
+      add_color_lint(node, node.original_string) if color_keyword?(node.original_string)
     end
 
     def visit_script_string(node)
@@ -17,28 +17,21 @@ module SCSSLint
   private
 
     def add_color_lint(node, original)
-      hex_form = Sass::Script::Color.new(color_rgb(original)).inspect
+      hex_form = Sass::Script::Value::Color.new(color_rgb(original)).tap do |color|
+        color.options = {} # `inspect` requires options to be set
+      end.inspect
+
       add_lint(node,
                "Color `#{original}` should be written in hexadecimal form " <<
                "as `#{shortest_hex_form(hex_form)}`")
     end
 
     def color_keyword?(string)
-      !!color_rgb(string)
+      !!color_rgb(string) && string != 'transparent'
     end
 
     def color_rgb(string)
-      Sass::Script::Color::COLOR_NAMES[string]
-    end
-
-    # Takes a string like `hello "world" 'how are' you` and turns it into:
-    # `hello   you`.
-    # This is useful for scanning for keywords in shorthand properties or lists
-    # which can contain quoted strings but for which you don't want to inspect
-    # quoted strings (e.g. you care about the actual color keyword `red`, not
-    # the string "red").
-    def remove_quoted_strings(string)
-      string.gsub(/"[^"]*"|'[^']*'/, '')
+      Sass::Script::Value::Color::COLOR_NAMES[string]
     end
   end
 end

data/lib/scss_lint/linter/duplicate_property.rb

@@ -0,0 +1,23 @@
+module SCSSLint
+  class Linter::DuplicateProperty < Linter
+    include LinterRegistry
+
+    def visit_rule(node)
+      properties = node.children
+                       .select { |child| child.is_a?(Sass::Tree::PropNode) }
+                       .reject { |prop| prop.name.any? { |item| item.is_a?(Sass::Script::Node) } }
+
+      prop_names = {}
+
+      properties.each do |prop|
+        name = prop.name.join
+
+        if existing_prop = prop_names[name]
+          add_lint(prop, "Property '#{name}' already defined on line #{existing_prop.line}")
+        else
+          prop_names[name] = prop
+        end
+      end
+    end
+  end
+end

data/lib/scss_lint/linter/hex_format.rb

@@ -3,10 +3,10 @@ module SCSSLint
     include LinterRegistry
 
     def visit_script_color(node)
-      return unless node.original && node.original.match(HEX_REGEX)
+      return unless node.original_string && node.original_string.match(HEX_REGEX)
 
-      unless valid_hex_format?(node.original[HEX_REGEX, 1])
-        add_hex_lint(node, node.original)
+      unless valid_hex_format?(node.original_string[HEX_REGEX, 1])
+        add_hex_lint(node, node.original_string)
       end
     end
 

data/lib/scss_lint/linter/indentation.rb

@@ -0,0 +1,71 @@
+module SCSSLint
+  class Linter::Indentation < Linter
+    include LinterRegistry
+
+    def visit_root(node)
+      @indent = 0
+      yield
+    end
+
+    def check_and_visit_children(node)
+      # Don't continue checking children as the moment a parent's indentation is
+      # off it's likely the children will be as will. We don't display the child
+      # indentation problems as that would likely make the lint too noisy.
+      return if check_indentation(node)
+
+      @indent += INDENT_WIDTH
+      yield
+      @indent -= INDENT_WIDTH
+    end
+
+    def check_indentation(node)
+      return unless node.line
+
+      # Ignore the case where the node is on the same line as its previous
+      # sibling or its parent, as indentation isn't possible
+      return if (previous = previous_node(node)) && previous.line == node.line
+
+      actual_indent = engine.lines[node.line - 1][/^(\s*)/, 1]
+
+      if actual_indent.length != @indent
+        add_lint(node.line,
+                 "Line should be indented #{@indent} spaces, " <<
+                 "but was indented #{actual_indent.length} spaces")
+        return true
+      end
+    end
+
+    # Deal with `else` statements
+    def visit_if(node, &block)
+      check_and_visit_children(node, &block)
+      visit(node.else) if node.else
+    end
+
+    # Define node types that increase indentation level
+    alias :visit_directive  :check_and_visit_children
+    alias :visit_each       :check_and_visit_children
+    alias :visit_for        :check_and_visit_children
+    alias :visit_function   :check_and_visit_children
+    alias :visit_media      :check_and_visit_children
+    alias :visit_mixin      :check_and_visit_children
+    alias :visit_mixindef   :check_and_visit_children
+    alias :visit_prop       :check_and_visit_children
+    alias :visit_rule       :check_and_visit_children
+    alias :visit_supports   :check_and_visit_children
+    alias :visit_while      :check_and_visit_children
+
+    # Define node types to check indentation of (notice comments are left out)
+    alias :visit_charset    :check_indentation
+    alias :visit_content    :check_indentation
+    alias :visit_cssimport  :check_indentation
+    alias :visit_extend     :check_indentation
+    alias :visit_import     :check_indentation
+    alias :visit_return     :check_indentation
+    alias :visit_variable   :check_indentation
+    alias :visit_warn       :check_indentation
+
+  private
+
+    INDENT_WIDTH = 2
+  end
+end

data/lib/scss_lint/linter/leading_zero.rb

@@ -0,0 +1,32 @@
+module SCSSLint
+  class Linter::LeadingZero < Linter
+    include LinterRegistry
+
+    def visit_script_string(node)
+      return unless node.type == :identifier
+
+      non_string_values = remove_quoted_strings(node.value).split
+
+      non_string_values.each do |value|
+        if number = value[/\b(0\.\d+)/, 1]
+          add_leading_zero_lint(node, number)
+        end
+      end
+    end
+
+    def visit_script_number(node)
+      if node.original_string =~ /^0\./
+        add_leading_zero_lint(node, node.original_string)
+      end
+    end
+
+  private
+
+    def add_leading_zero_lint(node, number)
+      trimmed_number = number[/^[^\.]+(.*)$/, 1]
+
+      add_lint(node, "`#{number}` should be written without a leading zero " <<
+                     "as `#{trimmed_number}`")
+    end
+  end
+end

data/lib/scss_lint/linter/shorthand.rb

@@ -3,47 +3,67 @@ module SCSSLint
     include LinterRegistry
 
     def visit_prop(node)
-      return unless SHORTHANDABLE_PROPERTIES.include? node.name.first.to_s
+      property_name = node.name.join
+      return unless SHORTHANDABLE_PROPERTIES.include?(property_name)
 
       case node.value
-      when Sass::Script::List
-        items = node.value.children
-        if (2..4).member?(items.count)
-          add_lint(node) unless valid_shorthand?(*items.map(&:to_sass))
-        end
-      when Sass::Script::String
-        if node.value.to_sass.strip =~ /\A(\S+\s+\S+(\s+\S+){0,2})\Z/
-          add_lint(node) unless valid_shorthand?(*$1.split(/\s+/))
-        end
+      when Sass::Script::Tree::Literal
+        # HACK: node_parent may not be initialized at this point, so we need to
+        # set it ourselves
+        node.value.value.node_parent = node.value
+        check_script_string(property_name, node.value.value)
+      when Sass::Script::Tree::ListLiteral
+        check_script_list(property_name, node.value)
       end
     end
 
-    def description
-      'Property values should use the shortest shorthand syntax allowed'
+  private
+
+    SHORTHANDABLE_PROPERTIES = %w[
+      border-color
+      border-radius
+      border-style
+      border-width
+      margin
+      padding
+    ]
+
+    def check_script_list(prop, list)
+      check_shorthand(prop, list, list.children.map(&:to_sass))
     end
 
-  private
+    def check_script_string(prop, script_string)
+      return unless script_string.type == :identifier
+
+      if values = script_string.value.strip[/\A(\S+\s+\S+(\s+\S+){0,2})\z/, 1]
+        check_shorthand(prop, script_string, values.split)
+      end
+    end
+
+    def check_shorthand(prop, node, values)
+      return unless (2..4).member?(values.count)
 
-    SHORTHANDABLE_PROPERTIES = %w[border-color
-                                  border-radius
-                                  border-style
-                                  border-width
-                                  margin
-                                  padding]
+      shortest_form = condensed_shorthand(*values)
+      return if values == shortest_form
+
+      add_lint(node, "Shorthand form for property `#{prop}` should be " <<
+                     "written more concisely as `#{shortest_form.join(' ')}` " <<
+                     "instead of `#{values.join(' ')}`")
+    end
 
-    def valid_shorthand?(top, right, bottom = nil, left = nil)
+    def condensed_shorthand(top, right, bottom = nil, left = nil)
       if top == right && right == bottom && bottom == left
-        false
+        [top]
       elsif top == right && bottom.nil? && left.nil?
-        false
+        [top]
       elsif top == bottom && right == left
-        false
+        [top, right]
       elsif top == bottom && left.nil?
-        false
+        top == right ? [top] : [top, right]
       elsif right == left
-        false
+        [top, right, bottom]
       else
-        true
+        [top, right, bottom, left].compact
       end
     end
   end

data/lib/scss_lint/linter/zero_unit.rb

@@ -2,21 +2,15 @@ module SCSSLint
   class Linter::ZeroUnit < Linter
     include LinterRegistry
 
-    def visit_prop(node)
-      if node.value.is_a?(Sass::Script::String) &&
-         node.value.type == :identifier
-
-        node.value.value.scan(/\b(0[a-z]+)\b/i) do |match|
-          add_lint(node, MESSAGE_FORMAT % match.first)
-        end
+    def visit_script_string(node)
+      node.value.scan(/\b(0[a-z]+)\b/i) do |match|
+        add_lint(node, MESSAGE_FORMAT % match.first)
       end
-
-      yield # Continue visiting children
     end
 
     def visit_script_number(node)
       if node.value == 0 && !node.unitless?
-        add_lint(node, MESSAGE_FORMAT % node.original)
+        add_lint(node, MESSAGE_FORMAT % node.original_string)
       end
     end
 

data/lib/scss_lint/reporter/default_reporter.rb

@@ -5,7 +5,9 @@ module SCSSLint
     def report_lints
       if lints.any?
         lints.map do |lint|
-          "#{lint.filename}:".yellow + "#{lint.line} - #{lint.description}"
+          type = lint.error? ? '[E]'.red : '[W]'.yellow
+          "#{lint.filename.cyan}:" << "#{lint.line}".magenta <<
+                                      " #{type} #{lint.description}"
         end.join("\n") + "\n"
       end
     end

data/lib/scss_lint/reporter/xml_reporter.rb

@@ -8,7 +8,9 @@ module SCSSLint
         output << "<file name='#{filename}'>"
 
         file_lints.each do |lint|
-          output << "<issue line='#{lint.line}' severity='warning' reason='#{lint.description}' />"
+          output << "<issue line='#{lint.line}' " <<
+                           "severity='#{lint.severity}' " <<
+                           "reason='#{lint.description}' />"
         end
 
         output << '</file>'

data/lib/scss_lint/runner.rb

@@ -39,7 +39,7 @@ module SCSSLint
         linter.run(engine)
       end
     rescue Sass::SyntaxError => ex
-      @lints << Lint.new(ex.sass_filename, ex.sass_line, ex.to_s)
+      @lints << Lint.new(ex.sass_filename, ex.sass_line, ex.to_s, :error)
     end
 
     def lints?

data/lib/scss_lint/utils.rb

@@ -34,6 +34,27 @@ module SCSSLint
         hex[5] == hex[6]
     end
 
+    # Takes a string like `hello "world" 'how are' you` and turns it into:
+    # `hello   you`.
+    # This is useful for scanning for keywords in shorthand properties or lists
+    # which can contain quoted strings but for which you don't want to inspect
+    # quoted strings (e.g. you care about the actual color keyword `red`, not
+    # the string "red").
+    def remove_quoted_strings(string)
+      string.gsub(/"[^"]*"|'[^']*'/, '')
+    end
+
+    def previous_node(node)
+      return unless node && parent = node.node_parent
+      index = parent.children.index(node)
+
+      if index == 0
+        parent
+      else
+        parent.children[index - 1]
+      end
+    end
+
   private
 
     INVALID_NAME_CHARS = '[_A-Z]'

data/lib/scss_lint/version.rb

@@ -1,3 +1,3 @@
 module SCSSLint
-  VERSION = '0.10.1'
+  VERSION = '0.11.1'
 end

metadata

@@ -1,71 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: scss-lint
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.1
 platform: ruby
 authors:
 - Causes Engineering
+- Shane da Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-21 00:00:00.000000000 Z
+date: 2013-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.8
 - !ruby/object:Gem::Dependency
   name: sass
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.10
+        version: 3.3.0.rc.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.2.10
+        version: 3.3.0.rc.1
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.13.0
 description: Opinionated tool to help write clean and consistent SCSS
 email:
 - eng@causes.com
@@ -87,19 +88,21 @@ files:
 - lib/scss_lint/linter/property_format.rb
 - lib/scss_lint/linter/space_before_brace.rb
 - lib/scss_lint/linter/capitalization_in_selector.rb
+- lib/scss_lint/linter/indentation.rb
 - lib/scss_lint/linter/declared_name.rb
 - lib/scss_lint/linter/sorted_properties.rb
 - lib/scss_lint/linter/shorthand.rb
 - lib/scss_lint/linter/id_with_extraneous_selector.rb
 - lib/scss_lint/linter/declaration_order.rb
-- lib/scss_lint/linter/no_zero_before_decimal.rb
 - lib/scss_lint/linter/zero_unit.rb
 - lib/scss_lint/linter/placeholder_in_extend.rb
 - lib/scss_lint/linter/usage_name.rb
 - lib/scss_lint/linter/border_zero.rb
 - lib/scss_lint/linter/debug_statement.rb
+- lib/scss_lint/linter/duplicate_property.rb
 - lib/scss_lint/linter/hex_format.rb
 - lib/scss_lint/linter/color_keyword.rb
+- lib/scss_lint/linter/leading_zero.rb
 - lib/scss_lint/linter/comment.rb
 - lib/scss_lint/linter/empty_rule.rb
 - lib/scss_lint/linter/single_line_per_selector.rb

data/lib/scss_lint/linter/no_zero_before_decimal.rb

@@ -1,22 +0,0 @@
-module SCSSLint
-  class Linter::NoZeroBeforeDecimal < Linter
-    include LinterRegistry
-
-    def visit_prop(node)
-      # Misleading, but anything that isn't Sass Script is considered an
-      # `identifier` in the context of a Sass::Script::String.
-      return unless node.value.is_a?(Sass::Script::String) && node.value.type == :identifier
-
-      # Remove string chunks (e.g. `"hello" 3 'world'` -> `3`
-      non_string_values = node.value.value.gsub(/"[^"]*"|'[^']'/, '').split
-
-      non_string_values.each do |value|
-        add_lint(node) if value =~ /\b0\.\d+/
-      end
-    end
-
-    def description
-      'Leading zero should be omitted in fractional values'
-    end
-  end
-end