slim_lint_standard 0.0.0

data/lib/slim_lint/parser.rb

@@ -0,0 +1,584 @@
+module SlimLint
+  # This version of the Slim::Parser makes the smallest changes it can to
+  # preserve newline informatino through the parse. This helps us keep better
+  # track of line numbers.
+  class Parser < Slim::Parser
+    @options = Slim::Parser.options
+
+    BLANK_LINE_RE = /\A\s*\Z/
+
+    def call(str)
+      reset(str.split(/\r?\n/))
+      push create_container(sexp(:multi, start: [1, 1]))
+
+      parse_line while next_line
+      result = pop until @stacks.empty?
+
+      reset
+      result
+    end
+
+    def append(sexp)
+      @stacks.last << sexp
+    end
+
+    def push(sexp)
+      @stacks << sexp
+    end
+
+    def pop
+      @stacks.last.finish = pos
+      @stacks.pop
+    end
+
+    def reset(lines = nil)
+      # Since you can indent however you like in Slim, we need to keep a list
+      # of how deeply indented you are. For instance, in a template like this:
+      #
+      #   doctype       # 0 spaces
+      #   html          # 0 spaces
+      #    head         # 1 space
+      #       title     # 4 spaces
+      #
+      # indents will then contain [0, 1, 4] (when it's processing the last line.)
+      #
+      # We uses this information to figure out how many steps we must "jump"
+      # out when we see an de-indented line.
+      @indents = []
+
+      # Whenever we want to output something, we'll *always* output it to the
+      # last stack in this array. So when there's a line that expects
+      # indentation, we simply push a new stack onto this array. When it
+      # processes the next line, the content will then be outputted into that
+      # stack.
+      @stacks = []
+
+      @lineno = 0
+      @lines = lines
+      @prev_line = @line = @orig_line = nil
+    end
+
+    def next_line
+      @prev_line = @orig_line
+      if @lines.empty?
+        @orig_line = @line = nil
+      else
+        @orig_line = @lines.shift
+        @lineno += 1
+        @line = @orig_line.dup
+      end
+    end
+
+    protected
+
+    def parse_line
+      if @line =~ BLANK_LINE_RE
+        @line = $'
+        return
+      end
+
+      indent = get_indent(@line)
+
+      # Choose first indentation yourself
+      if @indents.empty?
+        @indents << indent
+      end
+
+      # Remove the indentation
+      @line.lstrip!
+
+      # If there's more stacks than indents, it means that the previous
+      # line is expecting this line to be indented.
+      expecting_indentation = @stacks.size > @indents.size
+
+      if indent > @indents.last
+        # This line was actually indented, so we'll have to check if it was
+        # supposed to be indented or not.
+        syntax_error!("Unexpected indentation") unless expecting_indentation
+
+        @indents << indent
+      else
+        # This line was *not* indented more than the line before,
+        # so we'll just forget about the stack that the previous line pushed.
+        pop if expecting_indentation
+
+        # This line was deindented.
+        # Now we're have to go through the all the indents and figure out
+        # how many levels we've deindented.
+        while indent < @indents.last && @indents.size > 1
+          @indents.pop
+          pop
+        end
+
+        # This line's indentation happens to lie "between" two other line's
+        # indentation:
+        #
+        #   hello
+        #       world
+        #     this      # <- This should not be possible!
+        syntax_error!("Malformed indentation") if indent != @indents.last
+      end
+
+      case @line
+      when /\A\/!( ?)/
+        # HTML comment
+        comment = sexp(:html, :comment)
+
+        @line = $'
+        text = sexp(:slim, :text, :verbatim)
+        capture(text) { parse_text_block([:slim, :interpolate], @line, @indents.last + $1.size + 2) }
+        contains(comment, text)
+
+        append comment
+      when /\A\/(\[\s*(.*?)\s*\])\s*\Z/
+        # HTML conditional comment
+        block = create_container(sexp(:multi))
+        comment = create_container(sexp(:html, :condcomment))
+        @line.slice!(0, 2)
+        comment << atom($2) << block
+
+        append comment
+        push block
+      when /\A\//
+        # Slim comment
+        parse_comment_block
+      when /\A([|'])( ?)/
+        # Found verbatim text block.
+        trailing_ws = ($1 == "'") && sexp(:static, " ", width: 1)
+        text = sexp(:slim, :text, :verbatim)
+        @line = $'
+        capture(text) { parse_text_block([:slim, :interpolate], @line, @indents.last + $2.size + 1) }
+
+        append text
+        append trailing_ws if trailing_ws
+      when /\A</
+        # Inline html
+        block = sexp(:multi)
+        html = sexp(:multi)
+        interpolation = sexp(:slim, :interpolate)
+        capture(interpolation) { @line.tap { @line = "" } }
+        contains(html, interpolation)
+        contains(html, block)
+
+        append html
+        push block
+      when /\A-/
+        # Found a code block.
+        # We expect the line to be broken or the next line to be indented.
+        statement = sexp(:slim, :control)
+        @line = $'
+        block = sexp(:multi)
+        capture(statement) { parse_broken_line }
+        statement << block
+
+        append statement
+        push block
+      when /\A=(=?)(['<>]*)/
+        # Found an output block.
+        # We expect the line to be broken or the next line to be indented.
+        statement = sexp(:slim, :output, $1.empty?)
+        @line = $'
+        trailing_ws = $2.include?(">".freeze)
+        if $2.include?("'".freeze)
+          deprecated_syntax "=' for trailing whitespace is deprecated in favor of =>"
+          trailing_ws = true
+        end
+
+        block = sexp(:multi)
+        capture(statement) { parse_broken_line }
+        statement << block
+
+        append sexp(:static, " ") if $2.include?("<".freeze)
+        append statement
+        append sexp(:static, " ") if trailing_ws
+        push block
+      when @embedded_re
+        # Embedded template detected. It is treated as block.
+        block = sexp(:slim, :embedded, $1)
+        @line = $2
+        attrs = parse_attributes
+        capture(block) { parse_text_block([:static], $', @orig_line.size - $'.size + $2.size) }
+        capture(block) { attrs }
+
+        append block
+      when /\Adoctype\b/
+        # Found doctype declaration
+        append sexp(:html, :doctype, $'.strip, width: @line.size)
+      when @tag_re
+        # Found a HTML tag.
+        tag_start = pos
+        @line = $' if $1
+        parse_tag($&, tag_start)
+      else
+        unknown_line_indicator
+      end
+    end
+
+    # Unknown line indicator found. Overwrite this method if
+    # you want to add line indicators to the Slim parser.
+    # The default implementation throws a syntax error.
+    def unknown_line_indicator
+      syntax_error! "Unknown line indicator"
+    end
+
+    def parse_comment_block
+      while !@lines.empty? && (BLANK_LINE_RE.match?(@lines.first) || get_indent(@lines.first) > @indents.last)
+        next_line
+      end
+    end
+
+    def parse_text_block(type, first_line = nil, text_indent = nil)
+      result = sexp(:multi, start: [@lineno, @indents.last])
+      if !first_line || first_line.empty?
+        text_indent = nil
+      else
+        result << sexp(*type, first_line, width: first_line.chomp.size)
+        @line = ""
+      end
+
+      until @lines.empty?
+        if BLANK_LINE_RE.match?(@lines.first)
+          next_line
+          result << sexp(*type, "")
+        else
+          indent = get_indent(@lines.first)
+          break if indent <= @indents.last
+
+          next_line
+
+          # The text block lines must be at least indented
+          # as deep as the first line.
+          offset = text_indent ? indent - text_indent : 0
+          if offset < 0
+            text_indent += offset
+            offset = 0
+          end
+          @line.slice!(0, indent - offset)
+
+          result << sexp(*type, @line, width: @line.chomp.size)
+          @line = ""
+
+          # The indentation of first line of the text block
+          # determines the text base indentation.
+          text_indent ||= indent
+        end
+      end
+
+      result.finish = pos
+      result
+    end
+
+    def parse_broken_line
+      result = sexp(:multi)
+
+      ws = @orig_line[/\A[ \t]*/].size
+      @line.lstrip!
+
+      leader = column - ws - 1
+      indent = @indents.last + leader
+
+      result << sexp(:code, @line, width: @line.chomp.size)
+      while @line.strip =~ /[,\\]\Z/
+        expect_next_line
+        @line.slice!(0, indent)
+        result << sexp(:code, @line, width: @line.chomp.size)
+      end
+
+      result
+    end
+
+    def parse_tag(tag_name, tag_start)
+      if @tag_shortcut[tag_name]
+        @line.slice!(0, tag_name.size) unless @attr_shortcut[tag_name]
+        tag_name = @tag_shortcut[tag_name]
+      end
+
+      # Find any shortcut attributes
+      attributes = sexp(:html, :attrs)
+      while @line =~ @attr_shortcut_re
+        # The class/id attribute is :static instead of :slim :interpolate,
+        # because we don't want text interpolation in .class or #id shortcut
+        syntax_error!("Illegal shortcut") unless (shortcut = @attr_shortcut[$1])
+        shortcut.each { |a| attributes << sexp(:html, :attr, a, sexp(:static, $2)) }
+        if (additional_attr_pairs = @additional_attrs[$1])
+          additional_attr_pairs.each do |k, v|
+            attributes << sexp(:html, :attr, k.to_s, sexp(:static, v))
+          end
+        end
+        @line = $'
+      end
+
+      @line =~ /\A[<>']*/
+      @line = $'
+      trailing_ws = $&.include?(">".freeze)
+      if $&.include?("'".freeze)
+        deprecated_syntax "tag' for trailing whitespace is deprecated in favor of tag>"
+        trailing_ws = true
+      end
+
+      leading_ws = $&.include?("<".freeze)
+
+      tag = sexp(:html, :tag, tag_name, attributes, start: tag_start, finish: pos)
+      parse_attributes(attributes)
+
+      append sexp(:static, " ") if leading_ws
+      append tag
+      append sexp(:static, " ") if trailing_ws
+
+      case @line
+      when /\A\s*:\s*/
+        # Block expansion
+        @line = $'
+        if @line =~ @embedded_re
+
+          # Parse attributes
+          @line = $2
+          attrs = parse_attributes
+          tag << sexp(:slim, :embedded, $1, parse_text_block([:static], $', @orig_line.size - $'.size + $2.size), attrs)
+        else
+          (@line =~ @tag_re) || syntax_error!("Expected tag")
+          tag_start = pos
+          @line = $' if $1
+          content = sexp(:multi)
+          tag << content
+          push content
+          parse_tag($&, tag_start)
+          pop
+        end
+      when /\A\s*=(=?)(['<>]*)/
+        # Handle output code
+        statement = sexp(:slim, :output, $1 != "=")
+
+        @line = $'
+        trailing_ws2 = $2.include?(">".freeze)
+        if $2.include?("'".freeze)
+          deprecated_syntax "=' for trailing whitespace is deprecated in favor of =>"
+          trailing_ws2 = true
+        end
+        block = sexp(:multi)
+        capture(statement) { parse_broken_line }
+        statement << block
+
+        @stacks.last.insert(-2, sexp(:static, " ")) if !leading_ws && $2.include?("<".freeze)
+        tag << statement
+        append sexp(:static, " ") if !trailing_ws && trailing_ws2
+        push block
+      when /\A\s*\/\s*/
+        # Closed tag. Do nothing
+        @line = $'
+        syntax_error!("Unexpected text after closed tag") unless @line.empty?
+      when BLANK_LINE_RE
+        # Empty content
+        content = sexp(:multi)
+        tag << content
+        push content
+      when /\A ?/
+        # Text content
+        @line = $'
+        tag << sexp(:slim, :text, :inline)
+        tag.last << parse_text_block([:slim, :interpolate], $', @orig_line.size - $'.size)
+        tag.last.finish = pos
+      end
+    end
+
+    def parse_attributes(attributes = sexp(:html, :attrs))
+      # Check to see if there is a delimiter right after the tag name
+      delimiter = nil
+      if @line =~ @attr_list_delims_re
+        delimiter = @attr_list_delims[$1]
+        @line = $'
+      end
+
+      if delimiter
+        boolean_attr_re = /#{@attr_name}(?=(\s|#{Regexp.escape delimiter}|\Z))/
+        end_re = /\A\s*#{Regexp.escape delimiter}/
+      end
+
+      loop do
+        case @line.strip
+        when @splat_attrs_regexp
+          # Splat attribute
+          @line.lstrip!
+          splat = sexp(:slim, :splat)
+          @line = $'
+          capture(splat) { parse_ruby_code(delimiter) }
+          attributes << splat
+        when @quoted_attr_re
+          # Value is quoted (static)
+          @line.lstrip!
+          attr = sexp(:html, :attr, $1)
+          @line = $3 + $'
+
+          escape = sexp(:escape, $2.empty?)
+          interpolate = sexp(:slim, :interpolate)
+          value = parse_quoted_attribute($3)
+          attributes.finish = attr.finish = escape.finish = interpolate.finish = pos
+
+          attributes << attr
+          attr << escape
+          escape << interpolate
+          interpolate << value
+        when @code_attr_re
+          # Value is ruby code
+          @line.lstrip!
+          attr = sexp(:html, :attr, $1)
+          @line = $'
+
+          value = ""
+          attr_value = sexp(:slim, :attrvalue, $2.empty?)
+          capture(attr_value) { value = parse_ruby_code(delimiter) }
+          attr << attr_value
+          syntax_error!("Invalid empty attribute") if value.empty?
+          attributes << attr
+        else
+          break unless delimiter
+
+          case @line
+          when boolean_attr_re
+            # Boolean attribute
+            @line = $'
+            attributes << sexp(:html, :attr, $1, sexp(:multi))
+          when end_re
+            # Find ending delimiter
+            @line = $'
+            break
+          else
+            # Found something where an attribute should be
+            @line.lstrip!
+            syntax_error!("Expected attribute") unless @line.empty?
+
+            # Attributes span multiple lines
+            syntax_error!("Expected closing delimiter #{delimiter}") if @lines.empty?
+            next_line
+          end
+        end
+      end
+
+      attributes
+    end
+
+    def parse_ruby_code(outer_delimiter)
+      result = sexp(:multi)
+      count, delimiter, close_delimiter = 0, nil, nil
+
+      # Attribute ends with space or attribute delimiter
+      end_re = /\A[\s#{Regexp.escape outer_delimiter.to_s}]/
+
+      indent = column
+      code = ""
+      until @line.empty? || (count == 0 && @line =~ end_re)
+        if @line == "," || @line == "\\"
+          code << @line
+          result << sexp(:code, code, start: [@lineno, indent], width: code.size)
+          expect_next_line
+          code = ""
+          @line.sub!(/\A {,#{indent - 1}}/, "")
+        else
+          if count > 0
+            if @line[0] == delimiter[0]
+              count += 1
+            elsif @line[0] == close_delimiter[0]
+              count -= 1
+            end
+          elsif @line =~ @code_attr_delims_re
+            count = 1
+            delimiter, close_delimiter = $&, @code_attr_delims[$&]
+          end
+          code << @line.slice!(0)
+        end
+      end
+      syntax_error!("Expected closing delimiter #{close_delimiter}") if count != 0
+
+      result << sexp(:code, code, start: [@lineno, indent], width: code.size)
+      result.finish = result.last.finish
+      result
+    end
+
+    def parse_quoted_attribute(quote)
+      @line.slice!(0)
+      start_pos = pos
+      value, count = "", 0
+
+      until count == 0 && @line[0] == quote[0]
+        if @line =~ /\A(\\)?\Z/
+          value << ($1 ? " " : "\n")
+          expect_next_line
+          @line.strip!
+        else
+          if @line[0] == "{"
+            count += 1
+          elsif @line[0] == "}"
+            count -= 1
+          end
+          value << @line.slice!(0)
+        end
+      end
+
+      atom(value, pos: start_pos)
+    ensure
+      @line.slice!(0)
+    end
+
+    # Helper for raising exceptions
+    def syntax_error!(message)
+      raise SyntaxError.new(message, options[:file], @orig_line, @lineno, column)
+    rescue SyntaxError => ex
+      # HACK: Manipulate stacktrace for Rails and other frameworks
+      # to find the right file.
+      ex.backtrace.unshift "#{options[:file]}:#{@lineno}"
+      raise
+    end
+
+    def deprecated_syntax(message)
+      line = @orig_line.lstrip
+      warn %(Deprecated syntax: #{message}
+  #{options[:file]}, Line #{@lineno}, Column #{column}
+    #{line}
+    #{" " * column}^
+)
+    end
+
+    def expect_next_line
+      next_line || syntax_error!("Unexpected end of file")
+      @line
+    end
+
+    def pos
+      [@lineno, column]
+    end
+
+    def column
+      1 + (@orig_line&.size || 0) - (@line&.size || 0)
+    end
+
+    def sexp(*args, start: pos, finish: start, width: nil, lines: 0)
+      finish = [start[0] + lines, start[1] + width] if width
+      Sexp.new(*args, start: start, finish: finish)
+    end
+
+    def atom(value, pos: nil)
+      Atom.new(value, pos: pos || self.pos)
+    end
+
+    def capture(sexp)
+      start = pos
+      yielded = yield
+      yielded = Atom.new(yielded, pos: start) unless yielded.is_a?(Sexp)
+
+      sexp << yielded
+      sexp.finish = pos
+      sexp
+    end
+
+    def create_container(sexp)
+      sexp.tap do |container|
+        container.define_singleton_method(:finish) { last.finish }
+      end
+    end
+
+    def contains(container, content)
+      create_container(container)
+      container << content
+    end
+  end
+end

data/lib/slim_lint/rake_task.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rake/tasklib"
+require "slim_lint/constants"
+
+module SlimLint
+  # Rake task interface for slim-lint-standard command line interface.
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'slim_lint/rake_task'
+  #
+  #   SlimLint::RakeTask.new do |t|
+  #     t.config = 'path/to/custom/slim-lint.yml'
+  #     t.files = %w[app/views/**/*.slim custom/*.slim]
+  #     t.quiet = true # Don't display output from slim-lint-standard
+  #   end
+  #
+  #   # ...and then execute from the command line:
+  #   rake slim_lint
+  #
+  # You can also specify the list of files as explicit task arguments:
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'slim_lint/rake_task'
+  #
+  #   SlimLint::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 'slim_lint[app/views/**/*.slim, other_files/**/*.slim]'
+  #
+  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 slim-lint-standard 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 = :slim_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 "slim_lint"
+        require "slim_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 ? SlimLint::Logger.silent : SlimLint::Logger.new($stdout)
+      result = SlimLint::CLI.new(logger).run(Array(cli_args) + files_to_lint(task_args))
+
+      fail "#{SlimLint::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 `#{SlimLint::APP_NAME}"
+      description += " --config #{config}" if config
+      description += " #{files.join(" ")}" if files.any?
+      description += " [files...]`"
+      description
+    end
+  end
+end