scss-lint-bliss 1.0.0

data/lib/scss_lint/linter/trailing_semicolon.rb

@@ -0,0 +1,67 @@
+module SCSSLint
+  # Checks for a trailing semicolon on statements within rule sets.
+  class Linter::TrailingSemicolon < Linter
+    include LinterRegistry
+
+    def visit_extend(node)
+      check_semicolon(node)
+    end
+
+    def visit_variable(node)
+      check_semicolon(node)
+    end
+
+    def visit_prop(node)
+      if node.children.any? { |n| n.is_a?(Sass::Tree::PropNode) }
+        yield # Continue checking children
+      else
+        check_semicolon(node)
+      end
+    end
+
+    def visit_mixin(node)
+      if node.children.any?
+        yield # Continue checking children
+      else
+        check_semicolon(node)
+      end
+    end
+
+    def visit_import(node)
+      # Ignore all but the last import for comma-separated @imports
+      return if source_from_range(node.source_range) =~ /,\s*$/
+      check_semicolon(node)
+    end
+
+  private
+
+    def check_semicolon(node)
+      if has_space_before_semicolon?(node)
+        line = node.source_range.start_pos.line
+        add_lint line,
+                 'Declaration should not have a space before ' \
+                 'the terminating semicolon'
+      elsif !ends_with_semicolon?(node)
+        line = node.source_range.start_pos.line
+        add_lint line, 'Declaration should be terminated by a semicolon'
+      elsif ends_with_multiple_semicolons?(node)
+        line = node.source_range.start_pos.line
+        add_lint line, 'Declaration should be terminated by a single semicolon'
+      end
+    end
+
+    # Checks that the node is ended by a semicolon (with no whitespace)
+    def ends_with_semicolon?(node)
+      source_from_range(node.source_range) =~ /;(\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) == ';'
+    end
+
+    def has_space_before_semicolon?(node)
+      source_from_range(node.source_range) =~ /\s;(\s*})?$/
+    end
+  end
+end

data/lib/scss_lint/linter/trailing_zero.rb

@@ -0,0 +1,41 @@
+module SCSSLint
+  # Checks for unnecessary trailing zeros in numeric values with decimal points.
+  class Linter::TrailingZero < 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|
+        next unless number = value[FRACTIONAL_DIGIT_REGEX, 1]
+        check_for_trailing_zeros(node, number)
+      end
+    end
+
+    def visit_script_number(node)
+      return unless number =
+        source_from_range(node.source_range)[FRACTIONAL_DIGIT_REGEX, 1]
+
+      check_for_trailing_zeros(node, number)
+    end
+
+  private
+
+    FRACTIONAL_DIGIT_REGEX = /^-?(\d*\.\d+)/
+
+    def check_for_trailing_zeros(node, original_number)
+      return unless match = /^(\d*\.\d*)0+$/.match(original_number)
+
+      fixed_number = match[1]
+
+      # Handle special case of 0 being the only trailing digit
+      fixed_number = fixed_number[0..-2] if fixed_number.end_with?('.')
+      fixed_number = 0 if fixed_number.empty? # Handle ".0" -> "0"
+
+      add_lint(node,
+               "`#{original_number}` should be written without a trailing " \
+               "zero as `#{fixed_number}`")
+    end
+  end
+end

data/lib/scss_lint/linter/unnecessary_mantissa.rb

@@ -0,0 +1,42 @@
+module SCSSLint
+  # Checks for the unnecessary inclusion of a zero-value mantissa in numbers.
+  # (e.g. `4.0` could be written as just `4`)
+  class Linter::UnnecessaryMantissa < Linter
+    include LinterRegistry
+
+    def visit_script_string(node)
+      return unless node.type == :identifier
+
+      node.value.scan(REAL_NUMBER_REGEX) do |number, integer, mantissa, units|
+        if unnecessary_mantissa?(mantissa)
+          add_lint(node, MESSAGE_FORMAT % [number, integer, units])
+        end
+      end
+    end
+
+    def visit_script_number(node)
+      return unless match = REAL_NUMBER_REGEX.match(source_from_range(node.source_range))
+      return unless unnecessary_mantissa?(match[:mantissa])
+
+      add_lint(node, MESSAGE_FORMAT % [match[:number], match[:integer],
+                                       match[:units]])
+    end
+
+  private
+
+    REAL_NUMBER_REGEX = /
+      \b(?<number>
+        (?<integer>\d*)
+        \.
+        (?<mantissa>\d+)
+        (?<units>\w*)
+      )\b
+    /ix
+
+    MESSAGE_FORMAT = '`%s` should be written without the mantissa as `%s%s`'
+
+    def unnecessary_mantissa?(mantissa)
+      mantissa !~ /[^0]/
+    end
+  end
+end

data/lib/scss_lint/linter/unnecessary_parent_reference.rb

@@ -0,0 +1,49 @@
+module SCSSLint
+  # Checks for unnecessary uses of the parent reference (&) in nested selectors.
+  class Linter::UnnecessaryParentReference < Linter
+    include LinterRegistry
+
+    MESSAGE = 'Unnecessary parent selector (&)'
+
+    def visit_comma_sequence(comma_sequence)
+      @multiple_sequences = comma_sequence.members.size > 1
+    end
+
+    def visit_sequence(sequence)
+      return unless sequence_starts_with_parent?(sequence.members.first)
+
+      # Allow concatentation, e.g.
+      # element {
+      #   &.foo {}
+      # }
+      return if sequence.members.first.members.size > 1
+
+      # Allow sequences that contain multiple parent references, e.g.
+      # element {
+      #   & + & { ... }
+      # }
+      return if sequence.members[1..-1].any? { |ss| sequence_starts_with_parent?(ss) }
+
+      # Special case: allow an isolated parent to appear if it is part of a
+      # comma sequence of more than one sequence, as this could be used to DRY
+      # up code.
+      return if @multiple_sequences && isolated_parent?(sequence)
+
+      add_lint(sequence.members.first.line, MESSAGE)
+    end
+
+  private
+
+    def isolated_parent?(sequence)
+      sequence.members.size == 1 &&
+        sequence_starts_with_parent?(sequence.members.first)
+    end
+
+    def sequence_starts_with_parent?(simple_sequence)
+      return unless simple_sequence.is_a?(Sass::Selector::SimpleSequence)
+      first = simple_sequence.members.first
+      first.is_a?(Sass::Selector::Parent) &&
+        first.suffix.nil? # Ignore concatenated selectors, like `&-something`
+    end
+  end
+end

data/lib/scss_lint/linter/url_format.rb

@@ -0,0 +1,56 @@
+require 'uri'
+
+module SCSSLint
+  # Checks the format of URLs for unnecessary protocols or domains.
+  class Linter::UrlFormat < Linter
+    include LinterRegistry
+
+    def visit_script_funcall(node)
+      return unless node.name == 'url'
+
+      if url_string?(node.args[0])
+        url = node.args[0].value.value.to_s
+        check_url(url, node)
+      end
+
+      yield
+    end
+
+    def visit_prop(node)
+      if url_literal?(node.value)
+        url = node.value.to_sass.gsub(/^url\((.*)\)$/, '\\1')
+        check_url(url, node)
+      end
+
+      yield
+    end
+
+  private
+
+    def url_literal?(prop_value)
+      return unless prop_value.is_a?(Sass::Script::Tree::Literal)
+      return unless prop_value.value.is_a?(Sass::Script::Value::String)
+      return unless prop_value.value.type == :identifier
+
+      prop_value.to_sass.match(/^url\(/)
+    end
+
+    def url_string?(arg)
+      return unless arg.is_a?(Sass::Script::Tree::Literal)
+      return unless arg.value.is_a?(Sass::Script::Value::String)
+
+      arg.value.type == :string
+    end
+
+    def check_url(url, node)
+      return if url.match(/^data:/)
+      uri = URI(url)
+
+      if uri.scheme || uri.host
+        add_lint(node, "URL `#{url}` should not contain protocol or domain")
+      end
+    rescue URI::Error => ex
+      add_lint(node, "Invalid URL `#{url}`: #{ex}")
+    end
+  end
+end

data/lib/scss_lint/linter/url_quotes.rb

@@ -0,0 +1,27 @@
+module SCSSLint
+  # Checks for quotes in URLs.
+  class Linter::UrlQuotes < Linter
+    include LinterRegistry
+
+    def visit_prop(node)
+      case node.value
+      when Sass::Script::Tree::Literal
+        check(node, node.value.value.to_s)
+      when Sass::Script::Tree::ListLiteral
+        node.value.children.select { |child| child.is_a?(Sass::Script::Tree::Literal) }
+                           .each { |child| check(node, child.value.to_s) }
+      end
+
+      yield
+    end
+
+  private
+
+    def check(node, string)
+      return unless string =~ /^\s*url\(\s*[^"']/
+      return if string =~ /^\s*url\(\s*data:/ # Ignore data URIs
+
+      add_lint(node, 'URLs should be enclosed in quotes')
+    end
+  end
+end

data/lib/scss_lint/linter/variable_for_property.rb

@@ -0,0 +1,30 @@
+module SCSSLint
+  # Reports the use of literals for properties where variables are prefered.
+  class Linter::VariableForProperty < Linter
+    include LinterRegistry
+
+    IGNORED_VALUES = %w[currentColor inherit transparent]
+
+    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 ignored_value?(node.value)
+      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
+
+  private
+
+    def ignored_value?(value)
+      value.respond_to?(:value) &&
+        IGNORED_VALUES.include?(value.value.to_s)
+    end
+  end
+end

data/lib/scss_lint/linter/vendor_prefix.rb

@@ -0,0 +1,64 @@
+module SCSSLint
+  # Checks for vendor prefixes.
+  class Linter::VendorPrefix < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @identifiers = Set.new(extract_identifiers_from_config)
+      @identifiers.merge(Set.new(config['additional_identifiers']))
+      @exclusions = Set.new(config['excluded_identifiers'])
+      yield
+    end
+
+    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 for values
+      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
+    alias_method :visit_pseudo, :check_node
+    alias_method :visit_directive, :check_node
+
+  private
+
+    def check_identifier(node, identifier)
+      return unless identifier =~ /^[_-]/
+
+      # Strip vendor prefix to check against identifiers.
+      # (Also strip closing parentheticals from values like linear-gradient.)
+      stripped_identifier = identifier.gsub(/(^[_-][a-zA-Z0-9_]+-|\(.*\)|;)/, '').strip
+      return if @exclusions.include?(stripped_identifier)
+      return unless @identifiers.include?(stripped_identifier)
+
+      add_lint(node, 'Avoid vendor prefixes.')
+    end
+
+    def extract_identifiers_from_config
+      case config['identifier_list']
+      when nil
+        nil
+      when Array
+        config['identifier_list']
+      when String
+        begin
+          file = File.open(File.join(SCSS_LINT_DATA,
+                                     'prefixed-identifiers',
+                                     "#{config['identifier_list']}.txt"))
+          file.read.split("\n").reject { |line| line =~ /^(#|\s*$)/ }
+        rescue Errno::ENOENT
+          raise SCSSLint::Exceptions::LinterError,
+                "Identifier list '#{config['identifier_list']}' does not exist"
+        end
+      else
+        raise SCSSLint::Exceptions::LinterError,
+              'Invalid identifier list specified -- must be the name of a '\
+              'preset or an array of strings'
+      end
+    end
+  end
+end

data/lib/scss_lint/linter/zero_unit.rb

@@ -0,0 +1,39 @@
+module SCSSLint
+  # Checks for unnecessary units on zero values.
+  class Linter::ZeroUnit < Linter
+    include LinterRegistry
+
+    def visit_script_string(node)
+      return unless node.type == :identifier
+
+      node.value.scan(ZERO_UNIT_REGEX) do |match|
+        next unless zero_with_length_units?(match.first)
+        add_lint(node, MESSAGE_FORMAT % match.first)
+      end
+    end
+
+    def visit_script_number(node)
+      length = source_from_range(node.source_range)[ZERO_UNIT_REGEX, 1]
+      return unless zero_with_length_units?(length)
+
+      add_lint(node, MESSAGE_FORMAT % length)
+    end
+
+  private
+
+    ZERO_UNIT_REGEX = /
+      \b
+      (?<!\.|\#)    # Ignore zeroes following `#` (colors) or `.` (decimals)
+      (0[a-z]+)     # Zero followed by letters indicating some sort of unit
+      \b
+    /ix
+
+    MESSAGE_FORMAT = '`%s` should be written without units as `0`'
+
+    LENGTH_UNITS = %w[em ex ch rem vw vh vmin vmax cm mm in pt pc px].to_set
+
+    def zero_with_length_units?(string)
+      string =~ /^0([a-z]+)/ && LENGTH_UNITS.include?(Regexp.last_match(1))
+    end
+  end
+end

data/lib/scss_lint/linter_registry.rb

@@ -0,0 +1,26 @@
+module SCSSLint
+  class NoSuchLinter < StandardError; end
+
+  # Stores all linters available to the application.
+  module LinterRegistry
+    @linters = []
+
+    class << self
+      attr_reader :linters
+
+      def included(base)
+        @linters << base
+      end
+
+      def extract_linters_from(linter_names)
+        linter_names.map do |linter_name|
+          begin
+            Linter.const_get(linter_name)
+          rescue NameError
+            raise NoSuchLinter, "Linter #{linter_name} does not exist"
+          end
+        end
+      end
+    end
+  end
+end