scss-lint 0.6 → 0.6.5

data/lib/scss_lint/linter.rb

@@ -1,25 +1,27 @@
 module SCSSLint
-  class Linter
+  class Linter < Sass::Tree::Visitors::Base
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        [] # No lints
-      end
+    attr_reader :engine, :lints
 
-      def create_lint(node)
-        Lint.new(node.filename, node.line, description)
-      end
+    def initialize
+      @lints = []
+    end
+
+    def run(engine)
+      @engine = engine
+      visit(engine.tree)
+    end
 
-      def description
-        nil
-      end
+    def description
+      nil
+    end
 
-    protected
+  protected
 
-      def name
-        self.class.name
-      end
+    # Helper for creating lint from a parse tree node
+    def add_lint(node)
+      @lints << Lint.new(node.filename, node.line, description)
     end
   end
 end

data/lib/scss_lint/linter/debug_linter.rb

@@ -4,18 +4,12 @@ module SCSSLint
   class Linter::DebugLinter < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          lints << create_lint(node) if node.is_a?(Sass::Tree::DebugNode)
-        end
-        lints
-      end
+    def visit_debug(node)
+      add_lint(node)
+    end
 
-      def description
-        '@debug line'
-      end
+    def description
+      '@debug line'
     end
   end
 end

data/lib/scss_lint/linter/declaration_order_linter.rb

@@ -10,44 +10,30 @@ module SCSSLint
       Sass::Tree::RuleNode,
     ]
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::RuleNode)
-            lints << check_order_of_declarations(node)
-          end
-        end
-        lints.compact
-      end
+    def visit_rule(node)
+      children = node.children.select { |node| important_node?(node) }.
+                               map { |node| node.class }
 
-      def description
-        'Rule sets should start with @extend declarations, followed by ' <<
-        'properties and nested rule sets, in that order'
+      sorted_children = children.sort do |a, b|
+        DECLARATION_ORDER.index(a) <=> DECLARATION_ORDER.index(b)
       end
 
-    private
-
-      def important_node?(node)
-        case node
-        when *DECLARATION_ORDER
-          true
-        end
+      if children != sorted_children
+        add_lint(node.children.first)
       end
 
-      def check_order_of_declarations(rule_node)
-        children = rule_node.children.select { |node| important_node?(node) }.
-                                      map { |node| node.class }
+      yield # Continue linting children
+    end
+
+    def description
+      'Rule sets should start with @extend declarations, followed by ' <<
+      'properties and nested rule sets, in that order'
+    end
 
-        # Inefficient, but we're not sorting thousands of declarations
-        sorted_children = children.sort do |x,y|
-          DECLARATION_ORDER.index(x) <=> DECLARATION_ORDER.index(y)
-        end
+  private
 
-        if children != sorted_children
-          return create_lint(rule_node.children.first)
-        end
-      end
+    def important_node?(node)
+      DECLARATION_ORDER.include? node.class
     end
   end
 end

data/lib/scss_lint/linter/empty_rule_linter.rb

@@ -4,26 +4,13 @@ module SCSSLint
   class Linter::EmptyRuleLinter < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::RuleNode)
-            lints << check_empty_rule(node)
-          end
-        end
-        lints.compact
-      end
-
-      def description
-        'Empty rule'
-      end
-
-    private
+    def visit_rule(node)
+      add_lint(node) if node.children.empty?
+      yield # Continue linting children
+    end
 
-      def check_empty_rule(rule_node)
-        create_lint(rule_node) if rule_node.children.empty?
-      end
+    def description
+      'Empty rule'
     end
   end
 end

data/lib/scss_lint/linter/hex_linter.rb

@@ -4,42 +4,30 @@ module SCSSLint
   class Linter::HexLinter < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::PropNode)
-            lints << check_valid_hex_value(node)
-          end
-        end
-        lints.compact
-      end
-
-      def description
-        'Hexadecimal color codes should be lowercase and in 3-digit form where possible'
+    def visit_prop(node)
+      if node.value.is_a?(Sass::Script::String) &&
+         node.value.to_s =~ /#(\h{3,6})/
+        add_lint(node) unless valid_hex?($1)
       end
+    end
 
-    private
+    def description
+      'Hexadecimal color codes should be lowercase and in 3-digit form where possible'
+    end
 
-      def check_valid_hex_value(prop_node)
-        if prop_node.value.is_a?(Sass::Script::String) &&
-           prop_node.value.to_s =~ /#(\h{3,6})/
-          return create_lint(prop_node) unless valid_hex?($1)
-        end
-      end
+  private
 
-      def valid_hex?(hex)
-        [3,6].include?(hex.length) &&
-          hex.downcase == hex &&
-          !can_be_condensed(hex)
-      end
+    def valid_hex?(hex)
+      [3,6].include?(hex.length) &&
+        hex.downcase == hex &&
+        !can_be_condensed(hex)
+    end
 
-      def can_be_condensed(hex)
-        hex.length == 6 &&
-          hex[0] == hex[1] &&
-          hex[2] == hex[3] &&
-          hex[4] == hex[5]
-      end
+    def can_be_condensed(hex)
+      hex.length == 6 &&
+        hex[0] == hex[1] &&
+        hex[2] == hex[3] &&
+        hex[4] == hex[5]
     end
   end
 end

data/lib/scss_lint/linter/property_format_linter.rb

@@ -4,38 +4,27 @@ module SCSSLint
   class Linter::PropertyFormatLinter < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::PropNode)
-            lints << check_property_format(node, engine.lines[node.line - 1]) if node.line
-          end
-        end
-        lints.compact
-      end
-
-      def description
-        'Property declarations should always be on one line of the form ' <<
-        '`name: value;` or `name: [value] {` ' <<
-        '(are you missing a trailing semi-colon?)'
-      end
+    def visit_prop(node)
+      line = engine.lines[node.line - 1] if node.line
+      add_lint(node) unless line =~ PROPERTY_RE
+    end
 
-    private
+    def description
+      'Property declarations should always be on one line of the form ' <<
+      '`name: value;` or `name: [value] {` ' <<
+      '(are you missing a trailing semi-colon?)'
+    end
 
-      VALUE_RE = %r{(\S+\s)*\S+} # eg. "10px", "10px normal"
-      PROPERTY_RE = %r{
-        ^\s*[\w-]+:\s           # property name, colon, one space
-          (                     # followed by
-          #{VALUE_RE};          # property and terminating semi-colon eg. a b c;
-          |                     # or
-          ((#{VALUE_RE}\s)?\{)  # nested property, optional value, trailing curly
-          )
-      }x
+  private
 
-      def check_property_format(prop_node, line)
-        return create_lint(prop_node) unless line =~ PROPERTY_RE
-      end
-    end
+    VALUE_RE = %r{(\S+\s)*\S+} # eg. "10px", "10px normal"
+    PROPERTY_RE = %r{
+      ^\s*[\w-]+:\s           # property name, colon, one space
+        (                     # followed by
+        #{VALUE_RE};          # property and terminating semi-colon eg. a b c;
+        |                     # or
+        ((#{VALUE_RE}\s)?\{)  # nested property, optional value, trailing curly
+        )
+    }x
   end
 end

data/lib/scss_lint/linter/shorthand_linter.rb

@@ -4,56 +4,45 @@ module SCSSLint
   class Linter::ShorthandLinter < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::PropNode)
-            lints << check_valid_shorthand_value(node)
-          end
-        end
-        lints.compact
+    def visit_prop(node)
+      unless SHORTHANDABLE_PROPERTIES.include? node.name.first.to_s
+        return
       end
 
-      def description
-        'Property values should use the shortest shorthand syntax allowed'
+      if node.value.to_sass.strip =~ /\A(\S+\s+\S+(\s+\S+){0,2})\Z/
+        add_lint(node) unless valid_shorthand?($1)
       end
+    end
 
-    private
-      SHORTHANDABLE_PROPERTIES = %w[border-color
-                                    border-radius
-                                    border-style
-                                    border-width
-                                    margin
-                                    padding]
-
-      def check_valid_shorthand_value(prop_node)
-        unless SHORTHANDABLE_PROPERTIES.include? prop_node.name.first.to_s
-          return
-        end
-
-        if prop_node.value.to_s.strip =~ /\A(\S+\s+\S+(\s+\S+){0,2})\Z/
-          return create_lint(prop_node) unless valid_shorthand?($1)
-        end
-      end
+    def description
+      'Property values should use the shortest shorthand syntax allowed'
+    end
 
-      def valid_shorthand?(shorthand)
-        values = shorthand.split(/\s+/)
-        top, right, bottom, left = values
-
-        if top == right && right == bottom && bottom == left
-          false
-        elsif top == right && bottom.nil? && left.nil?
-          false
-        elsif top == bottom && right == left
-          false
-        elsif top == bottom && left.nil?
-          false
-        elsif right == left
-          false
-        else
-          true
-        end
+  private
+
+    SHORTHANDABLE_PROPERTIES = %w[border-color
+                                  border-radius
+                                  border-style
+                                  border-width
+                                  margin
+                                  padding]
+
+    def valid_shorthand?(shorthand)
+      values = shorthand.split(/\s+/)
+      top, right, bottom, left = values
+
+      if top == right && right == bottom && bottom == left
+        false
+      elsif top == right && bottom.nil? && left.nil?
+        false
+      elsif top == bottom && right == left
+        false
+      elsif top == bottom && left.nil?
+        false
+      elsif right == left
+        false
+      else
+        true
       end
     end
   end

data/lib/scss_lint/linter/single_line_per_selector_linter.rb

@@ -4,26 +4,13 @@ module SCSSLint
   class Linter::SingleLinePerSelector < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::RuleNode)
-            lints << check_selector_format(node)
-          end
-        end
-        lints.compact
-      end
-
-      def description
-        'Each selector should be on its own line'
-      end
-
-    private
+    def visit_rule(node)
+      add_lint(node) unless node.rule.grep(/,[^\n]/).empty?
+      yield # Continue linting children
+    end
 
-      def check_selector_format(rule_node)
-        create_lint(rule_node) unless rule_node.rule.grep(/,[^\n]/).empty?
-      end
+    def description
+      'Each selector should be on its own line'
     end
   end
 end

data/lib/scss_lint/linter/sorted_properties_linter.rb

@@ -4,36 +4,24 @@ module SCSSLint
   class Linter::SortedPropertiesLinter < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::RuleNode)
-            lints << check_properties_sorted(node)
-          end
-        end
-        lints.compact
+    def visit_rule(node)
+      properties = node.children.select do |child|
+        child.is_a?(Sass::Tree::PropNode)
       end
 
-      def description
-        'Properties should be sorted in alphabetical order'
+      prop_names = properties.map do |prop_node|
+        prop_node.name.first.to_s
       end
 
-    private
-
-      def check_properties_sorted(rule_node)
-        properties = rule_node.children.select do |node|
-          node.is_a?(Sass::Tree::PropNode)
-        end
+      if prop_names.sort != prop_names
+        add_lint(properties.first)
+      end
 
-        prop_names = properties.map do |prop_node|
-          prop_node.name.first.to_s
-        end
+      yield # Continue linting children
+    end
 
-        if prop_names.sort != prop_names
-          create_lint(properties.first)
-        end
-      end
+    def description
+      'Properties should be sorted in alphabetical order'
     end
   end
 end

data/lib/scss_lint/linter/type_in_id_selector_linter.rb

@@ -4,32 +4,17 @@ module SCSSLint
   class Linter::TypeInIdSelectorLinter < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::RuleNode)
-            lints << check_type_in_selector(node)
-          end
-        end
-        lints.compact
+    def visit_rule(node)
+      selectors = node.rule.first.to_s.split(',')
+      selectors.each do |selector|
+        add_lint(node) if selector.strip =~ /^[a-z0-9]+#.*/i
       end
 
-      def description
-        'Avoid ID names with unnecessary type selectors (e.g. prefer `#id` over `p#id`)'
-      end
-
-    private
-
-      def check_type_in_selector(rule_node)
-        selectors = rule_node.rule.first.to_s.split(',')
-
-        selectors.each do |selector|
-          return create_lint(rule_node) if selector.strip =~ /^[a-z0-9]+#.*/i
-        end
+      yield # Continue linting children
+    end
 
-        nil
-      end
+    def description
+      'Avoid ID names with unnecessary type selectors (e.g. prefer `#id` over `p#id`)'
     end
   end
 end

data/lib/scss_lint/linter/zero_unit_linter.rb

@@ -4,26 +4,13 @@ module SCSSLint
   class Linter::ZeroUnitLinter < Linter
     include LinterRegistry
 
-    class << self
-      def run(engine)
-        lints = []
-        engine.tree.each do |node|
-          if node.is_a?(Sass::Tree::PropNode)
-            lints << check_zero_unit(node, engine.lines[node.line - 1]) if node.line
-          end
-        end
-        lints.compact
-      end
-
-      def description
-        'Properties with a value of zero should be unit-less'
-      end
-
-    private
+    def visit_prop(node)
+      line = engine.lines[node.line - 1] if node.line
+      add_lint(node) if line =~ /^\s*[\w-]+:\s*0[a-z]+;$/i
+    end
 
-      def check_zero_unit(prop_node, line)
-        return create_lint(prop_node) if line =~ /^\s*[\w-]+:\s*0[a-z]+;$/i
-      end
+    def description
+      'Properties with a value of zero should be unit-less, e.g. "0" instead of "0px"'
     end
   end
 end

data/lib/scss_lint/runner.rb

@@ -16,6 +16,8 @@ module SCSSLint
 
       @linters = LinterRegistry.linters.reject do |linter|
         ignored_linters.include?(linter)
+      end.map do |linter_class|
+        linter_class.new
       end
     end
 
@@ -26,13 +28,17 @@ module SCSSLint
       files.each do |file|
         find_lints(file)
       end
+
+      linters.each do |linter|
+        @lints += linter.lints
+      end
     end
 
     def find_lints(file)
       engine = Engine.new(file)
 
       linters.each do |linter|
-        @lints += linter.run(engine)
+        linter.run(engine)
       end
     rescue Sass::SyntaxError => ex
       @lints << Lint.new(ex.sass_filename, ex.sass_line, ex.to_s)

data/lib/scss_lint/version.rb

@@ -1,3 +1,3 @@
 module SCSSLint
-  VERSION = '0.6'
+  VERSION = '0.6.5'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scss-lint
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: 0.6.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-15 00:00:00.000000000 Z
+date: 2013-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize