liquid_lint 1.0.0

data/lib/liquid_lint/rake_task.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'rake/tasklib'
+require 'liquid_lint/constants'
+
+module LiquidLint
+  # Rake task interface for liquid-lint command line interface.
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'liquid_lint/rake_task'
+  #
+  #   LiquidLint::RakeTask.new do |t|
+  #     t.config = 'path/to/custom/liquid-lint.yml'
+  #     t.files = %w[app/views/**/*.liquid custom/*.liquid]
+  #     t.quiet = true # Don't display output from liquid-lint
+  #   end
+  #
+  #   # ...and then execute from the command line:
+  #   rake liquid_lint
+  #
+  # You can also specify the list of files as explicit task arguments:
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'liquid_lint/rake_task'
+  #
+  #   LiquidLint::RakeTask.new
+  #
+  #   # ...and then execute from the command line (single quotes prevent shell
+  #   # glob expansion and allow us to have a space after commas):
+  #   rake 'liquid_lint[app/views/**/*.liquid, other_files/**/*.liquid]'
+  #
+  class RakeTask < Rake::TaskLib
+    # Name of the task.
+    # @return [String]
+    attr_accessor :name
+
+    # Configuration file to use.
+    # @return [String]
+    attr_accessor :config
+
+    # List of files to lint (can contain shell globs).
+    #
+    # Note that this will be ignored if you explicitly pass a list of files as
+    # task arguments via the command line or a task definition.
+    # @return [Array<String>]
+    attr_accessor :files
+
+    # Whether output from liquid-lint should not be displayed to the standard out
+    # stream.
+    # @return [true,false]
+    attr_accessor :quiet
+
+    # Create the task so it exists in the current namespace.
+    #
+    # @param name [Symbol] task name
+    def initialize(name = :liquid_lint)
+      @name = name
+      @files = ['.'] # Search for everything under current directory by default
+      @quiet = false
+
+      yield self if block_given?
+
+      define
+    end
+
+    private
+
+    # Defines the Rake task.
+    def define
+      desc default_description unless ::Rake.application.last_description
+
+      task(name, [:files]) do |_task, task_args|
+        # Lazy-load so task doesn't affect Rakefile load time
+        require 'liquid_lint'
+        require 'liquid_lint/cli'
+
+        run_cli(task_args)
+      end
+    end
+
+    # Executes the CLI given the specified task arguments.
+    #
+    # @param task_args [Rake::TaskArguments]
+    def run_cli(task_args)
+      cli_args = ['--config', config] if config
+
+      logger = quiet ? LiquidLint::Logger.silent : LiquidLint::Logger.new($stdout)
+      result = LiquidLint::CLI.new(logger).run(Array(cli_args) + files_to_lint(task_args))
+
+      fail "#{LiquidLint::APP_NAME} failed with exit code #{result}" unless result == 0
+    end
+
+    # Returns the list of files that should be linted given the specified task
+    # arguments.
+    #
+    # @param task_args [Rake::TaskArguments]
+    def files_to_lint(task_args)
+      # NOTE: we're abusing Rake's argument handling a bit here. We call the
+      # first argument `files` but it's actually only the first file--we pull
+      # the rest out of the `extras` from the task arguments. This is so we
+      # can specify an arbitrary list of files separated by commas on the
+      # command line or in a custom task definition.
+      explicit_files = Array(task_args[:files]) + Array(task_args.extras)
+
+      explicit_files.any? ? explicit_files : files
+    end
+
+    # Friendly description that shows the full command that will be executed.
+    #
+    # This allows us to change the information displayed by `rake --tasks` based
+    # on the options passed to the constructor which defined the task.
+    #
+    # @return [String]
+    def default_description
+      description = "Run `#{LiquidLint::APP_NAME}"
+      description += " --config #{config}" if config
+      description += " #{files.join(' ')}" if files.any?
+      description += ' [files...]`'
+      description
+    end
+  end
+end

data/lib/liquid_lint/report.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Contains information about all lints detected during a scan.
+  class Report
+    # List of lints that were found.
+    attr_accessor :lints
+
+    # List of files that were linted.
+    attr_reader :files
+
+    # Creates a report.
+    #
+    # @param lints [Array<LiquidLint::Lint>] lints that were found
+    # @param files [Array<String>] files that were linted
+    def initialize(lints, files)
+      @lints = lints.sort_by { |l| [l.filename, l.line] }
+      @files = files
+    end
+
+    def failed?
+      @lints.any?
+    end
+  end
+end

data/lib/liquid_lint/reporter/checkstyle_reporter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module LiquidLint
+  # Outputs report as a Checkstyle XML document.
+  class Reporter::CheckstyleReporter < Reporter
+    def display_report(report)
+      document = REXML::Document.new.tap do |d|
+        d << REXML::XMLDecl.new
+      end
+      checkstyle = REXML::Element.new('checkstyle', document)
+
+      report.lints.group_by(&:filename).map do |lint|
+        map_file(lint, checkstyle)
+      end
+
+      log.log document.to_s
+    end
+
+    private
+
+    def map_file(file, checkstyle)
+      REXML::Element.new('file', checkstyle).tap do |f|
+        path_name = file.first
+        path_name = relative_path(file) if defined?(relative_path)
+        f.attributes['name'] = path_name
+
+        file.last.map { |o| map_offense(o, f) }
+      end
+    end
+
+    def map_offense(offence, parent)
+      REXML::Element.new('error', parent).tap do |e|
+        e.attributes['line'] = offence.line
+        e.attributes['severity'] = offence.error? ? 'error' : 'warning'
+        e.attributes['message'] = offence.message
+        e.attributes['source'] = 'liquid-lint'
+      end
+    end
+  end
+end

data/lib/liquid_lint/reporter/default_reporter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Outputs lints in a simple format with the filename, line number, and lint
+  # message.
+  class Reporter::DefaultReporter < Reporter
+    def display_report(report)
+      sorted_lints = report.lints.sort_by { |l| [l.filename, l.line] }
+
+      sorted_lints.each do |lint|
+        print_location(lint)
+        print_type(lint)
+        print_message(lint)
+      end
+    end
+
+    private
+
+    def print_location(lint)
+      log.info lint.filename, false
+      log.log ':', false
+      log.bold lint.line, false
+    end
+
+    def print_type(lint)
+      if lint.error?
+        log.error ' [E] ', false
+      else
+        log.warning ' [W] ', false
+      end
+    end
+
+    def print_message(lint)
+      if lint.linter
+        log.success("#{lint.linter.name}: ", false)
+      end
+
+      log.log lint.message
+    end
+  end
+end

data/lib/liquid_lint/reporter/emacs_reporter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Outputs lints in format: {filename}:{line}:{column}: {kind}: {message}.
+  class Reporter::EmacsReporter < Reporter
+    def display_report(report)
+      sorted_lints = report.lints.sort_by { |l| [l.filename, l.line] }
+
+      sorted_lints.each do |lint|
+        print_location(lint)
+        print_type(lint)
+        print_message(lint)
+      end
+    end
+
+    private
+
+    def print_location(lint)
+      log.info lint.filename, false
+      log.log ':', false
+      log.bold lint.line, false
+      log.log ':', false
+      # TODO: change 1 to column number when linter will have this info.
+      log.bold 1, false
+      log.log ':', false
+    end
+
+    def print_type(lint)
+      if lint.error?
+        log.error ' E: ', false
+      else
+        log.warning ' W: ', false
+      end
+    end
+
+    def print_message(lint)
+      if lint.linter
+        log.success("#{lint.linter.name}: ", false)
+      end
+
+      log.log lint.message
+    end
+  end
+end

data/lib/liquid_lint/reporter/json_reporter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Outputs report as a JSON document.
+  class Reporter::JsonReporter < Reporter
+    def display_report(report)
+      lints = report.lints
+      grouped = lints.group_by(&:filename)
+
+      report_hash = {
+        metadata: metadata,
+        files: grouped.map { |l| map_file(l) },
+        summary: {
+          offense_count: lints.length,
+          target_file_count: grouped.length,
+          inspected_file_count: report.files.length,
+        },
+      }
+
+      log.log report_hash.to_json
+    end
+
+    private
+
+    def metadata
+      {
+        liquid_lint_version: LiquidLint::VERSION,
+        ruby_engine: RUBY_ENGINE,
+        ruby_patchlevel: RUBY_PATCHLEVEL.to_s,
+        ruby_platform: RUBY_PLATFORM,
+      }
+    end
+
+    def map_file(file)
+      {
+        path: file.first,
+        offenses: file.last.map { |o| map_offense(o) },
+      }
+    end
+
+    def map_offense(offense)
+      {
+        severity: offense.severity,
+        message: offense.message,
+        location: {
+          line: offense.line,
+        },
+        linter: offense.linter&.name,
+      }
+    end
+  end
+end

data/lib/liquid_lint/reporter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Abstract lint reporter. Subclass and override {#display_report} to
+  # implement a custom lint reporter.
+  #
+  # @abstract
+  class Reporter
+    # Creates the reporter that will display the given report.
+    #
+    # @param logger [LiquidLint::Logger]
+    def initialize(logger)
+      @log = logger
+    end
+
+    # Implemented by subclasses to display lints from a {LiquidLint::Report}.
+    #
+    # @param report [LiquidLint::Report]
+    def display_report(report)
+      raise NotImplementedError,
+            "Implement `display_report` to display #{report}"
+    end
+
+    # Keep tracking all the descendants of this class for the list of available
+    # reporters.
+    #
+    # @return [Array<Class>]
+    def self.descendants
+      @descendants ||= []
+    end
+
+    # Executed when this class is subclassed.
+    #
+    # @param descendant [Class]
+    def self.inherited(descendant)
+      descendants << descendant
+    end
+
+    private
+
+    # @return [LiquidLint::Logger] logger to send output to
+    attr_reader :log
+  end
+end

data/lib/liquid_lint/ruby_extract_engine.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Generates a {LiquidLint::Sexp} suitable for consumption by the
+  # {RubyExtractor}.
+  #
+  # This is mostly copied from Liquid::Engine, with some filters and generators
+  # omitted.
+  class RubyExtractEngine < Temple::Engine
+    filter :Encoding
+    filter :RemoveBOM
+
+    # Parse into S-expression using Liquid parser
+    use Liquid::Parser
+
+    # Perform additional processing so extracting Ruby code in {RubyExtractor}
+    # is easier. We don't do this for regular linters because some information
+    # about the original syntax tree is lost in the process, but that doesn't
+    # matter in this case.
+    use Liquid::Embedded
+    use Liquid::Interpolation
+    use LiquidLint::Filters::SplatProcessor
+    use Liquid::DoInserter
+    use Liquid::EndInserter
+    use LiquidLint::Filters::ControlProcessor
+    use LiquidLint::Filters::AttributeProcessor
+    filter :MultiFlattener
+    filter :StaticMerger
+
+    # Converts Array-based S-expressions into LiquidLint::Sexp objects, and gives
+    # them line numbers so we can easily map from the Ruby source to the
+    # original source
+    use LiquidLint::Filters::SexpConverter
+    use LiquidLint::Filters::InjectLineNumbers
+  end
+end

data/lib/liquid_lint/ruby_extractor.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Utility class for extracting Ruby script from a Liquid template that can then
+  # be linted with a Ruby linter (i.e. is "legal" Ruby).
+  #
+  # The goal is to turn this:
+  #
+  #    - if items.any?
+  #      table#items
+  #      - for item in items
+  #        tr
+  #          td.name = item.name
+  #          td.price = item.price
+  #    - else
+  #       p No items found.
+  #
+  # into (something like) this:
+  #
+  #    if items.any?
+  #      for item in items
+  #        puts item.name
+  #        puts item.price
+  #    else
+  #      puts 'No items found'
+  #    end
+  #
+  # The translation won't be perfect, and won't make any real sense, but the
+  # relationship between variable declarations/uses and the flow control graph
+  # will remain intact.
+  class RubyExtractor
+    include SexpVisitor
+    extend SexpVisitor::DSL
+
+    # Stores the extracted source and a map of lines of generated source to the
+    # original source that created them.
+    #
+    # @attr_reader source [String] generated source code
+    # @attr_reader source_map [Hash] map of line numbers from generated source
+    #   to original source line number
+    RubySource = Struct.new(:source, :source_map)
+
+    # Extracts Ruby code from Sexp representing a Liquid document.
+    #
+    # @param sexp [LiquidLint::Sexp]
+    # @return [LiquidLint::RubyExtractor::RubySource]
+    def extract(sexp)
+      trigger_pattern_callbacks(sexp)
+      RubySource.new(@source_lines.join("\n"), @source_map)
+    end
+
+    on_start do |_sexp|
+      @source_lines = []
+      @source_map = {}
+      @line_count = 0
+      @dummy_puts_count = 0
+    end
+
+    on [:html, :doctype] do |sexp|
+      append_dummy_puts(sexp)
+    end
+
+    on [:html, :tag] do |sexp|
+      append_dummy_puts(sexp)
+    end
+
+    on [:static] do |sexp|
+      append_dummy_puts(sexp)
+    end
+
+    on [:dynamic] do |sexp|
+      _, ruby = sexp
+      append(ruby, sexp)
+    end
+
+    on [:code] do |sexp|
+      _, ruby = sexp
+      append(ruby, sexp)
+    end
+
+    private
+
+    # Append code to the buffer.
+    #
+    # @param code [String]
+    # @param sexp [LiquidLint::Sexp]
+    def append(code, sexp)
+      return if code.empty?
+
+      original_line = sexp.line
+
+      # For code that spans multiple lines, the resulting code will span
+      # multiple lines, so we need to create a mapping for each line.
+      code.split("\n").each_with_index do |line, index|
+        @source_lines << line
+        @line_count += 1
+        @source_map[@line_count] = original_line + index
+      end
+    end
+
+    def append_dummy_puts(sexp)
+      append("_liquid_lint_puts_#{@dummy_puts_count}", sexp)
+      @dummy_puts_count += 1
+    end
+  end
+end

data/lib/liquid_lint/ruby_parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'rubocop/ast/builder'
+
+def require_parser(path)
+  prev = $VERBOSE
+$VERBOSE = nil
+  require "parser/#{path}"
+ensure
+  $VERBOSE = prev
+end
+
+module LiquidLint
+  # Parser for the Ruby language.
+  #
+  # This provides a convenient wrapper around the `parser` gem and the
+  # `astrolabe` integration to go with it. It is intended to be used for linter
+  # checks that require deep inspection of Ruby code.
+  class RubyParser
+    # Creates a reusable parser.
+    def initialize
+      require_parser('current')
+      @builder = ::RuboCop::AST::Builder.new
+      @parser = ::Parser::CurrentRuby.new(@builder)
+    end
+
+    # Parse the given Ruby source into an abstract syntax tree.
+    #
+    # @param source [String] Ruby source code
+    # @return [Array] syntax tree in the form returned by Parser gem
+    def parse(source)
+      buffer = ::Parser::Source::Buffer.new('(string)')
+      buffer.source = source
+
+      @parser.reset
+      @parser.parse(buffer)
+    end
+  end
+end

data/lib/liquid_lint/runner.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Responsible for running the applicable linters against the desired files.
+  class Runner
+    # Runs the appropriate linters against the desired files given the specified
+    # options.
+    #
+    # @param [Hash] options
+    # @option options :config_file [String] path of configuration file to load
+    # @option options :config [LiquidLint::Configuration] configuration to use
+    # @option options :excluded_files [Array<String>]
+    # @option options :included_linters [Array<String>]
+    # @option options :excluded_linters [Array<String>]
+    # @return [LiquidLint::Report] a summary of all lints found
+    def run(options = {})
+      config = load_applicable_config(options)
+      linter_selector = LiquidLint::LinterSelector.new(config, options)
+
+      if options[:stdin_file_path].nil?
+        files = extract_applicable_files(config, options)
+        lints = files.map do |file|
+          collect_lints(File.read(file), file, linter_selector, config)
+        end.flatten
+      else
+        files = [options[:stdin_file_path]]
+        lints = collect_lints($stdin.read, options[:stdin_file_path], linter_selector, config)
+      end
+
+      LiquidLint::Report.new(lints, files)
+    end
+
+    private
+
+    # Returns the {LiquidLint::Configuration} that should be used given the
+    # specified options.
+    #
+    # @param options [Hash]
+    # @return [LiquidLint::Configuration]
+    def load_applicable_config(options)
+      if options[:config_file]
+        LiquidLint::ConfigurationLoader.load_file(options[:config_file])
+      elsif options[:config]
+        options[:config]
+      else
+        LiquidLint::ConfigurationLoader.load_applicable_config
+      end
+    end
+
+    # Runs all provided linters using the specified config against the given
+    # file.
+    #
+    # @param file [String] path to file to lint
+    # @param linter_selector [LiquidLint::LinterSelector]
+    # @param config [LiquidLint::Configuration]
+    def collect_lints(file_content, file_name, linter_selector, config)
+      begin
+        document = LiquidLint::Document.new(file_content, file: file_name, config: config)
+      rescue LiquidLint::Exceptions::ParseError => e
+        return [LiquidLint::Lint.new(nil, file_name, e.lineno, e.error, :error)]
+      end
+
+      linter_selector.linters_for_file(file_name).map do |linter|
+        linter.run(document)
+      end.flatten
+    end
+
+    # Returns the list of files that should be linted given the specified
+    # configuration and options.
+    #
+    # @param config [LiquidLint::Configuration]
+    # @param options [Hash]
+    # @return [Array<String>]
+    def extract_applicable_files(config, options)
+      included_patterns = options[:files]
+      excluded_patterns = config['exclude']
+      excluded_patterns += options.fetch(:excluded_files, [])
+
+      LiquidLint::FileFinder.new(config).find(included_patterns, excluded_patterns)
+    end
+  end
+end