liquid_lint 1.0.0

data/lib/liquid_lint/linter/tab.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Searches for tab indentation
+  class Linter::Tab < Linter
+    include LinterRegistry
+
+    MSG = 'Tab detected'
+
+    on_start do |_sexp|
+      dummy_node = Struct.new(:line)
+      document.source_lines.each_with_index do |line, index|
+        next unless line =~ /^( *)[\t ]*\t/
+
+        report_lint(dummy_node.new(index + 1), MSG)
+      end
+    end
+  end
+end

data/lib/liquid_lint/linter/tag_case.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Searches for tags with uppercase characters.
+  class Linter::TagCase < Linter
+    include LinterRegistry
+
+    on [:html, :tag] do |sexp|
+      _, _, name = sexp
+      next unless name[/[A-Z]/]
+
+      report_lint(sexp, "Tag `#{name}` should be written as `#{name.downcase}`")
+    end
+  end
+end

data/lib/liquid_lint/linter/trailing_blank_lines.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # This linter looks for trailing blank lines and a final newline.
+  class Linter::TrailingBlankLines < Linter
+    include LinterRegistry
+
+    on_start do |_sexp|
+      dummy_node = Struct.new(:line)
+      next if document.source.empty?
+
+      if !document.source.end_with?("\n")
+        report_lint(dummy_node.new(document.source_lines.size),
+                    'No blank line in the end of file')
+      elsif document.source.lines.last.blank?
+        report_lint(dummy_node.new(document.source.lines.size),
+                    'Multiple empty lines in the end of file')
+      end
+    end
+  end
+end

data/lib/liquid_lint/linter/trailing_whitespace.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Checks for trailing whitespace.
+  class Linter::TrailingWhitespace < Linter
+    include LinterRegistry
+
+    on_start do |_sexp|
+      dummy_node = Struct.new(:line)
+
+      document.source_lines.each_with_index do |line, index|
+        next unless line =~ /\s+$/
+
+        report_lint(dummy_node.new(index + 1),
+                    'Line contains trailing whitespace')
+      end
+    end
+  end
+end

data/lib/liquid_lint/linter/zwsp.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  class Linter::Zwsp < Linter
+    include LinterRegistry
+
+    MSG = 'Remove zero-width space'
+
+    on_start do |_sexp|
+      dummy_node = Struct.new(:line)
+      document.source_lines.each_with_index do |line, index|
+        next unless line.include?("\u200b")
+
+        report_lint(dummy_node.new(index + 1), MSG)
+      end
+    end
+  end
+end

data/lib/liquid_lint/linter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Base implementation for all lint checks.
+  #
+  # @abstract
+  class Linter
+    # Include definitions for Sexp pattern-matching helpers.
+    include SexpVisitor
+    extend SexpVisitor::DSL
+
+    # List of lints reported by this linter.
+    #
+    # @todo Remove once spec/support/shared_linter_context returns an array of
+    #   lints for the subject instead of the linter itself.
+    attr_reader :lints
+
+    # Initializes a linter with the specified configuration.
+    #
+    # @param config [Hash] configuration for this linter
+    def initialize(config)
+      @config = config
+      @lints = []
+    end
+
+    # Runs the linter against the given Liquid document.
+    #
+    # @param document [LiquidLint::Document]
+    def run(document)
+      @document = document
+      @lints = []
+      @disabled_lines = nil
+      trigger_pattern_callbacks(document.sexp)
+      @lints
+    end
+
+    # Returns the simple name for this linter.
+    #
+    # @return [String]
+    def name
+      self.class.name.split('::').last
+    end
+
+    private
+
+    attr_reader :config, :document
+
+    # Record a lint for reporting back to the user.
+    #
+    # @param node [#line] node to extract the line number from
+    # @param message [String] error/warning to display to the user
+    def report_lint(node, message)
+      return if disabled_for_line?(node.line)
+
+      @lints << LiquidLint::Lint.new(self, @document.file, node.line, message)
+    end
+
+    # Parse Ruby code into an abstract syntax tree.
+    #
+    # @param source [String] Ruby code to parse
+    # @return [AST::Node]
+    def parse_ruby(source)
+      @ruby_parser ||= LiquidLint::RubyParser.new
+      @ruby_parser.parse(source)
+    end
+
+    def disabled_for_line?(line)
+      disabled_lines.include?(line)
+    end
+
+    def disabled_lines
+      @disabled_lines ||= begin
+        currently_disabled = false
+        @document.source_lines.each_with_index.each_with_object([]) do |pair, lines|
+          line = pair[0]
+          line_number = pair[1] + 1
+
+          if line =~ %r{/ liquid-lint:disable #{linter_name}}
+            currently_disabled = true
+          elsif line =~ %r{/ liquid-lint:enable #{linter_name}}
+            currently_disabled = false
+          elsif currently_disabled
+            lines << line_number
+          end
+        end
+      end
+    end
+
+    def linter_name
+      @linter_name ||= self.class.name.split('::').last
+    end
+  end
+end

data/lib/liquid_lint/linter_registry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  class NoSuchLinter < StandardError; end
+
+  # Stores all defined linters.
+  module LinterRegistry
+    @linters = []
+
+    class << self
+      # List of all registered linters.
+      attr_reader :linters
+
+      # Executed when a linter includes the {LinterRegistry} module.
+      #
+      # This results in the linter being registered with the registry.
+      #
+      # @param subclass [Class]
+      def included(subclass)
+        @linters << subclass
+      end
+
+      # Return a list of {LiquidLint::Linter} {Class}es corresponding to the
+      # specified list of names.
+      #
+      # @param linter_names [Array<String>]
+      # @return [Array<Class>]
+      def extract_linters_from(linter_names)
+        linter_names.map do |linter_name|
+          begin
+            LiquidLint::Linter.const_get(linter_name)
+          rescue NameError
+            raise NoSuchLinter, "Linter #{linter_name} does not exist"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/liquid_lint/linter_selector.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Chooses the appropriate linters to run given the specified configuration.
+  class LinterSelector
+    # Creates a selector using the given configuration and additional options.
+    #
+    # @param config [LiquidLint::Configuration]
+    # @param options [Hash]
+    def initialize(config, options)
+      @config = config
+      @options = options
+    end
+
+    # Returns the set of linters to run against the given file.
+    #
+    # @param file [String]
+    # @raise [LiquidLint::Exceptions::NoLintersError] when no linters are enabled
+    # @return [Array<LiquidLint::Linter>]
+    def linters_for_file(file)
+      @linters ||= extract_enabled_linters(@config, @options)
+      @linters.select { |linter| run_linter_on_file?(@config, linter, file) }
+    end
+
+    private
+
+    # Returns a list of linters that are enabled given the specified
+    # configuration and additional options.
+    #
+    # @param config [LiquidLint::Configuration]
+    # @param options [Hash]
+    # @return [Array<LiquidLint::Linter>]
+    def extract_enabled_linters(config, options)
+      included_linters =
+        LinterRegistry.extract_linters_from(options.fetch(:included_linters, []))
+
+      included_linters = LinterRegistry.linters if included_linters.empty?
+
+      excluded_linters =
+        LinterRegistry.extract_linters_from(options.fetch(:excluded_linters, []))
+
+      # After filtering out explicitly included/excluded linters, only include
+      # linters which are enabled in the configuration
+      linters = (included_linters - excluded_linters).map do |linter_class|
+        linter_config = config.for_linter(linter_class)
+        linter_class.new(linter_config) if linter_config['enabled']
+      end.compact
+
+      # Highlight condition where all linters were filtered out, as this was
+      # likely a mistake on the user's part
+      if linters.empty?
+        raise LiquidLint::Exceptions::NoLintersError, 'No linters specified'
+      end
+
+      linters
+    end
+
+    # Whether to run the given linter against the specified file.
+    #
+    # @param config [LiquidLint::Configuration]
+    # @param linter [LiquidLint::Linter]
+    # @param file [String]
+    # @return [Boolean]
+    def run_linter_on_file?(config, linter, file)
+      linter_config = config.for_linter(linter)
+
+      if linter_config['include'].any? &&
+         !LiquidLint::Utils.any_glob_matches?(linter_config['include'], file)
+        return false
+      end
+
+      if LiquidLint::Utils.any_glob_matches?(linter_config['exclude'], file)
+        return false
+      end
+
+      true
+    end
+  end
+end

data/lib/liquid_lint/logger.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Encapsulates all communication to an output source.
+  class Logger
+    # Whether colored output via ANSI escape sequences is enabled.
+    # @return [true,false]
+    attr_accessor :color_enabled
+
+    # Creates a logger which outputs nothing.
+    # @return [LiquidLint::Logger]
+    def self.silent
+      new(File.open('/dev/null', 'w'))
+    end
+
+    # Creates a new {LiquidLint::Logger} instance.
+    #
+    # @param out [IO] the output destination.
+    def initialize(out)
+      @out = out
+    end
+
+    # Print the specified output.
+    #
+    # @param output [String] the output to send
+    # @param newline [true,false] whether to append a newline
+    def log(output, newline = true)
+      @out.print(output)
+      @out.print("\n") if newline
+    end
+
+    # Print the specified output in bold face.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def bold(*args)
+      color('1', *args)
+    end
+
+    # Print the specified output in a color indicative of error.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def error(*args)
+      color(31, *args)
+    end
+
+    # Print the specified output in a bold face and color indicative of error.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def bold_error(*args)
+      color('1;31', *args)
+    end
+
+    # Print the specified output in a color indicative of success.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def success(*args)
+      color(32, *args)
+    end
+
+    # Print the specified output in a color indicative of a warning.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def warning(*args)
+      color(33, *args)
+    end
+
+    # Print the specified output in a color indicating information.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def info(*args)
+      color(36, *args)
+    end
+
+    # Print a blank line.
+    def newline
+      log('')
+    end
+
+    # Whether this logger is outputting to a TTY.
+    #
+    # @return [true,false]
+    def tty?
+      @out.respond_to?(:tty?) && @out.tty?
+    end
+
+    private
+
+    # Print output in the specified color.
+    #
+    # @param code [Integer,String] ANSI color code
+    # @param output [String] output to print
+    # @param newline [Boolean] whether to append a newline
+    def color(code, output, newline = true)
+      log(color_enabled ? "\033[#{code}m#{output}\033[0m" : output, newline)
+    end
+  end
+end

data/lib/liquid_lint/matcher/anything.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module LiquidLint::Matcher
+  # Will match anything, acting as a wildcard.
+  class Anything < Base
+    # @see {LiquidLint::Matcher::Base#match?}
+    def match?(*)
+      true
+    end
+  end
+end

data/lib/liquid_lint/matcher/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LiquidLint::Matcher
+  # Represents a Sexp pattern implementing complex matching logic.
+  #
+  # Subclasses can implement custom logic to create complex matches that can be
+  # reused across linters, DRYing up matching code.
+  #
+  # @abstract
+  class Base
+    # Whether this matcher matches the specified object.
+    #
+    # This must be implemented by subclasses.
+    #
+    # @param other [Object]
+    # @return [Boolean]
+    def match?(*)
+      raise NotImplementedError, 'Matcher must implement `match?`'
+    end
+  end
+end

data/lib/liquid_lint/matcher/capture.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module LiquidLint::Matcher
+  # Wraps a matcher, taking on the behavior of the wrapped matcher but storing
+  # the value that matched so it can be referred to later.
+  class Capture < Base
+    # @return [LiquidLint::Matcher::Base] matcher that this capture wraps
+    attr_accessor :matcher
+
+    # @return [Object] value that was captured
+    attr_accessor :value
+
+    # Creates a capture that wraps that given matcher.
+    #
+    # @param matcher [LiquidLint::Matcher::Base]
+    # @return [LiquidLint::Matcher::Capture]
+    def self.from_matcher(matcher)
+      new.tap do |cap_matcher|
+        cap_matcher.matcher = matcher
+      end
+    end
+
+    # @see {LiquidLint::Matcher::Base#match?}
+    def match?(object)
+      if result = @matcher.match?(object)
+        @value = object
+      end
+
+      result
+    end
+  end
+end

data/lib/liquid_lint/matcher/nothing.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LiquidLint::Matcher
+  # Does not match anything.
+  #
+  # This is used in specs.
+  class Nothing < Base
+    # @see {LiquidLint::Matcher::Base#match?}
+    def match?(*)
+      false
+    end
+  end
+end

data/lib/liquid_lint/options.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module LiquidLint
+  # Handles option parsing for the command line application.
+  class Options
+    # Parses command line options into an options hash.
+    #
+    # @param args [Array<String>] arguments passed via the command line
+    # @return [Hash] parsed options
+    def parse(args)
+      @options = {}
+
+      OptionParser.new do |parser|
+        parser.banner = "Usage: #{APP_NAME} [options] [file1, file2, ...]"
+
+        add_linter_options parser
+        add_file_options parser
+        add_info_options parser
+      end.parse!(args)
+
+      # Any remaining arguments are assumed to be files
+      @options[:files] = args
+
+      @options
+    rescue OptionParser::InvalidOption => e
+      raise Exceptions::InvalidCLIOption,
+            e.message,
+            e.backtrace
+    end
+
+    private
+
+    # Register linter-related flags.
+    def add_linter_options(parser)
+      parser.on('-i', '--include-linter linter,...', Array,
+                'Specify which linters you want to run') do |linters|
+        @options[:included_linters] = linters
+      end
+
+      parser.on('-x', '--exclude-linter linter,...', Array,
+                "Specify which linters you don't want to run") do |linters|
+        @options[:excluded_linters] = linters
+      end
+
+      parser.on('-r', '--reporter reporter', String,
+                'Specify which reporter you want to use to generate the output') do |reporter|
+        @options[:reporter] = load_reporter_class(reporter.capitalize)
+      end
+    end
+
+    # Returns the class of the specified Reporter.
+    #
+    # @param reporter_name [String]
+    # @raise [LiquidLint::Exceptions::InvalidCLIOption] if reporter doesn't exist
+    # @return [Class]
+    def load_reporter_class(reporter_name)
+      LiquidLint::Reporter.const_get("#{reporter_name}Reporter")
+    rescue NameError
+      raise LiquidLint::Exceptions::InvalidCLIOption,
+            "#{reporter_name}Reporter does not exist"
+    end
+
+    # Register file-related flags.
+    def add_file_options(parser)
+      parser.on('-c', '--config config-file', String,
+                'Specify which configuration file you want to use') do |conf_file|
+        @options[:config_file] = conf_file
+      end
+
+      parser.on('-e', '--exclude file,...', Array,
+                'List of file names to exclude') do |files|
+        @options[:excluded_files] = files
+      end
+
+      parser.on('--stdin-file-path file', String,
+                'Pipe source from STDIN, using file in offense reports.') do |file|
+        @options[:stdin_file_path] = file
+      end
+    end
+
+    # Register informational flags.
+    def add_info_options(parser)
+      parser.on('--show-linters', 'Display available linters') do
+        @options[:show_linters] = true
+      end
+
+      parser.on('--show-reporters', 'Display available reporters') do
+        @options[:show_reporters] = true
+      end
+
+      parser.on('--[no-]color', 'Force output to be colorized') do |color|
+        @options[:color] = color
+      end
+
+      parser.on_tail('-h', '--help', 'Display help documentation') do
+        @options[:help] = parser.help
+      end
+
+      parser.on_tail('-v', '--version', 'Display version') do
+        @options[:version] = true
+      end
+
+      parser.on_tail('-V', '--verbose-version', 'Display verbose version information') do
+        @options[:verbose_version] = true
+      end
+    end
+  end
+end