scss_lint 0.38.0

data/lib/scss_lint/sass/script.rb

@@ -0,0 +1,78 @@
+# Ignore documentation lints as these aren't original implementations.
+# rubocop:disable Documentation
+
+module Sass::Script
+  # Since the Sass library is already loaded at this point.
+  # Define the `node_name` and `visit_method` class methods for each Sass Script
+  # parse tree node type so that our custom visitor can seamless traverse the
+  # tree.
+  # Define the `invalid_child_method_name` and `invalid_parent_method_name`
+  # class methods to make errors understandable.
+  #
+  # This would be easier if we could just define an `inherited` callback, but
+  # that won't work since the Sass library will have already been loaded before
+  # this code gets loaded, so the `inherited` callback won't be fired.
+  #
+  # Thus we are left to manually define the methods for each type explicitly.
+  {
+    'Value' => %w[ArgList Bool Color List Map Null Number String],
+    'Tree'  => %w[Funcall Interpolation ListLiteral Literal MapLiteral
+                  Operation Selector StringInterpolation UnaryOperation Variable],
+  }.each do |namespace, types|
+    types.each do |type|
+      node_name = type.downcase
+
+      eval <<-DECL
+        class #{namespace}::#{type}
+          def self.node_name
+            :script_#{node_name}
+          end
+
+          def self.visit_method
+            :visit_script_#{node_name}
+          end
+
+          def self.invalid_child_method_name
+            :"invalid_#{node_name}_child?"
+          end
+
+          def self.invalid_parent_method_name
+            :"invalid_#{node_name}_parent?"
+          end
+        end
+      DECL
+    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
+
+  # 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
+
+    class Literal
+      # Literals wrap their underlying values. For sake of convenience, consider
+      # the wrapped value a child of the Literal.
+      def children
+        [value]
+      end
+    end
+  end
+end

data/lib/scss_lint/sass/tree.rb

@@ -0,0 +1,168 @@
+# Contains extensions of Sass::Tree::Nodes to add support for traversing the
+# Sass::Script::Node parse trees contained within the nodes. This probably
+# breaks the Sass compiler, but since we're only doing lints this is fine for
+# now.
+module Sass::Tree
+  # Ignore documentation lints as these aren't original implementations.
+  # rubocop:disable Documentation
+
+  # 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.
+    def add_line_numbers_to_args(arg_list)
+      arg_list.each do |variable, _default_expr|
+        add_line_number(variable)
+      end
+    end
+
+    # 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::Tree::Node)
+      node
+    end
+
+    # Sometimes the parse tree doesn't return a Sass::Script::Variable, but just
+    # 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::Tree::Variable.new(var_name).tap do |v|
+        v.line = line # Use line number of the containing parse tree node
+      end
+    end
+
+    # A number of tree nodes return lists that have strings and
+    # 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::Tree::Node) }
+    end
+
+    # Takes a list of arguments, be they arrays or individual objects, and
+    # returns a single flat list that can be passed to
+    # Sass::Tree::Visitors::Base#visit_children.
+    def concat_expr_lists(*expr_lists)
+      expr_lists.flatten.compact
+    end
+  end
+
+  class CommentNode
+    def children
+      concat_expr_lists super, extract_script_nodes(value)
+    end
+  end
+
+  class DebugNode
+    def children
+      concat_expr_lists super, expr
+    end
+  end
+
+  class DirectiveNode
+    def children
+      begin
+        additional_children = extract_script_nodes(value)
+      rescue NotImplementedError # rubocop:disable HandleExceptions
+        # Directive nodes may not define `value`
+      end
+      concat_expr_lists super, additional_children
+    end
+  end
+
+  class EachNode
+    def children
+      loop_vars = vars.map { |var| create_variable(var) }
+
+      concat_expr_lists super, loop_vars, list
+    end
+  end
+
+  class ExtendNode
+    def children
+      concat_expr_lists super, extract_script_nodes(selector)
+    end
+  end
+
+  class ForNode
+    def children
+      concat_expr_lists super, create_variable(var), from, to
+    end
+  end
+
+  class FunctionNode
+    def children
+      add_line_numbers_to_args(args)
+
+      concat_expr_lists super, args, splat
+    end
+  end
+
+  class IfNode
+    def children
+      concat_expr_lists super, expr
+    end
+  end
+
+  class MixinDefNode
+    def children
+      add_line_numbers_to_args(args)
+
+      concat_expr_lists super, args, splat
+    end
+  end
+
+  class MixinNode
+    def children
+      add_line_numbers_to_args(args)
+
+      # Keyword mapping is String -> Expr, so convert the string to a variable
+      # node that supports lint reporting
+      keyword_exprs = keywords.as_stored.map do |var_name, var_expr|
+        [create_variable(var_name), var_expr]
+      end if keywords.any?
+
+      concat_expr_lists super, args, keyword_exprs, splat
+    end
+  end
+
+  class PropNode
+    def children
+      concat_expr_lists super, extract_script_nodes(name), add_line_number(value)
+    end
+  end
+
+  class ReturnNode
+    def children
+      concat_expr_lists super, expr
+    end
+  end
+
+  class RuleNode
+    def children
+      concat_expr_lists super, extract_script_nodes(rule)
+    end
+  end
+
+  class VariableNode
+    def children
+      concat_expr_lists super, expr
+    end
+  end
+
+  class WarnNode
+    def children
+      concat_expr_lists super, expr
+    end
+  end
+
+  class WhileNode
+    def children
+      concat_expr_lists super, expr
+    end
+  end
+end

data/lib/scss_lint/selector_visitor.rb

@@ -0,0 +1,34 @@
+module SCSSLint
+  # Provides functionality for conveniently visiting a Selector sequence.
+  module SelectorVisitor
+    def visit_selector(node)
+      visit_selector_node(node)
+    end
+
+  private
+
+    def visit_selector_node(node)
+      method = "visit_#{selector_node_name(node)}"
+      send(method, node) if respond_to?(method, true)
+
+      visit_members(node) if node.is_a?(Sass::Selector::AbstractSequence)
+    end
+
+    def visit_members(sequence)
+      sequence.members
+              .reject { |member| member.is_a?(String) } # Skip newlines in multi-line comma seqs
+              .each do |member|
+        visit_selector(member)
+      end
+    end
+
+    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
+    end
+  end
+end

data/lib/scss_lint/utils.rb

@@ -0,0 +1,112 @@
+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
+    # interpolation). For example:
+    #
+    # .selector-one, .selector-#{$var}-two
+    #
+    # becomes:
+    #
+    # .selector-one, .selector--two
+    #
+    # This is useful for lints that wish to ignore interpolation, since
+    # interpolation can't be resolved at this step.
+    def extract_string_selectors(selector_array)
+      selector_array.reject { |item| item.is_a? Sass::Script::Node }
+                    .join
+                    .split
+    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
+
+    def node_siblings(node)
+      return unless node && node.node_parent
+      node.node_parent
+          .children
+          .select { |child| child.is_a?(Sass::Tree::Node) }
+    end
+
+    # Return nth-ancestor of a node, where 1 is the parent, 2 is grandparent,
+    # etc.
+    #
+    # @param node [Sass::Tree::Node, Sass::Script::Tree::Node]
+    # @param level [Integer]
+    # @return [Sass::Tree::Node, Sass::Script::Tree::Node, nil]
+    def node_ancestor(node, levels)
+      while levels > 0
+        node = node.node_parent
+        return unless node
+        levels -= 1
+      end
+
+      node
+    end
+
+    def pluralize(value, word)
+      value == 1 ? "#{value} #{word}" : "#{value} #{word}s"
+    end
+
+    # Sass doesn't define an equality operator for Sass::Source::Position
+    # objects, so we define a helper for our own use.
+    def same_position?(pos1, pos2)
+      return unless pos1 && pos2
+      pos1.line == pos2.line && pos1.offset == pos2.offset
+    end
+  end
+end

data/lib/scss_lint/version.rb

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

data/spec/scss_lint/cli_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+require 'scss_lint/cli'
+
+describe SCSSLint::CLI do
+  let(:config_options) do
+    {
+      'linters' => {
+        'FakeTestLinter1' => { 'enabled' => true },
+        'FakeTestLinter2' => { 'enabled' => true },
+      },
+    }
+  end
+
+  let(:config) { SCSSLint::Config.new(config_options) }
+
+  class SCSSLint::Linter::FakeTestLinter1 < SCSSLint::Linter; end
+  class SCSSLint::Linter::FakeTestLinter2 < SCSSLint::Linter; end
+
+  before do
+    # Silence console output
+    @output = ''
+    STDOUT.stub(:write) { |*args| @output.<<(*args) }
+
+    SCSSLint::Config.stub(:load).and_return(config)
+    SCSSLint::LinterRegistry.stub(:linters)
+                            .and_return([SCSSLint::Linter::FakeTestLinter1,
+                                         SCSSLint::Linter::FakeTestLinter2])
+  end
+
+  describe '#run' do
+    let(:files) { ['file1.scss', 'file2.scss'] }
+    let(:flags) { [] }
+    subject     { SCSSLint::CLI.new }
+
+    before do
+      SCSSLint::FileFinder.any_instance.stub(:find).and_return(files)
+      SCSSLint::Runner.any_instance.stub(:find_lints)
+    end
+
+    def safe_run
+      subject.run(flags + files)
+    rescue SystemExit
+      # Keep running tests
+    end
+
+    context 'when there are no lints' do
+      before do
+        SCSSLint::Runner.any_instance.stub(:lints).and_return([])
+      end
+
+      it 'returns a successful exit code' do
+        safe_run.should == 0
+      end
+
+      it 'outputs nothing' do
+        safe_run
+        @output.should be_empty
+      end
+    end
+
+    context 'when there are only warnings' do
+      before do
+        SCSSLint::Runner.any_instance.stub(:lints).and_return([
+          SCSSLint::Lint.new(
+            SCSSLint::Linter::FakeTestLinter1.new,
+            'some-file.scss',
+            SCSSLint::Location.new(1, 1, 1),
+            'Some description',
+            :warning,
+          ),
+        ])
+      end
+
+      it 'returns a exit code indicating only warnings were reported' do
+        safe_run.should == 1
+      end
+
+      it 'outputs the warnings' do
+        safe_run
+        @output.should include 'Some description'
+      end
+    end
+
+    context 'when there are errors' do
+      before do
+        SCSSLint::Runner.any_instance.stub(:lints).and_return([
+          SCSSLint::Lint.new(
+            SCSSLint::Linter::FakeTestLinter1.new,
+            'some-file.scss',
+            SCSSLint::Location.new(1, 1, 1),
+            'Some description',
+            :error,
+          ),
+        ])
+      end
+
+      it 'exits with an error status code' do
+        safe_run.should == 2
+      end
+
+      it 'outputs the errors' do
+        safe_run
+        @output.should include 'Some description'
+      end
+    end
+
+    context 'when the runner raises an error' do
+      let(:backtrace) { %w[file1.rb file2.rb] }
+      let(:message) { 'Some error message' }
+
+      let(:error) do
+        StandardError.new(message).tap { |e| e.set_backtrace(backtrace) }
+      end
+
+      before { SCSSLint::Runner.stub(:new).and_raise(error) }
+
+      it 'exits with an internal software error status code' do
+        subject.should_receive(:halt).with(:software)
+        safe_run
+      end
+
+      it 'outputs the error message' do
+        safe_run
+        @output.should include message
+      end
+
+      it 'outputs the backtrace' do
+        safe_run
+        @output.should include backtrace.join("\n")
+      end
+
+      it 'outputs a link to the issue tracker' do
+        safe_run
+        @output.should include SCSSLint::BUG_REPORT_URL
+      end
+    end
+
+    context 'when a required library is not found' do
+      let(:flags) { ['--require', 'some_non_existent_library'] }
+
+      before do
+        Kernel.stub(:require).with('some_non_existent_library').and_raise(
+          SCSSLint::Exceptions::RequiredLibraryMissingError
+        )
+      end
+
+      it 'exits with an appropriate status code' do
+        subject.should_receive(:halt).with(:unavailable)
+        safe_run
+      end
+    end
+
+    context 'when specified SCSS file globs match no files' do
+      before do
+        SCSSLint::FileFinder.any_instance.stub(:find)
+          .and_raise(SCSSLint::Exceptions::NoFilesError)
+      end
+
+      it 'exits with an appropriate status code' do
+        subject.should_receive(:halt).with(:no_files)
+        safe_run
+      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
+  end
+end