slim_lint 0.1.0

data/lib/slim_lint/ruby_extractor.rb

@@ -0,0 +1,91 @@
+module SlimLint
+  # Utility class for extracting Ruby script from a Slim 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
+
+    attr_reader :source_map
+
+    # Extracts Ruby code from Sexp representing a Slim document.
+    #
+    # @param sexp [SlimLint::Sexp]
+    def extract(sexp)
+      trigger_pattern_callbacks(sexp)
+      @source_lines.join("\n")
+    end
+
+    on_start do |_sexp|
+      @source_lines = []
+      @source_map = {}
+      @line_count = 0
+    end
+
+    on [:html, :doctype] do |sexp|
+      append('puts', sexp)
+    end
+
+    on [:html, :tag] do |sexp|
+      append('puts', sexp)
+    end
+
+    on [:static] do |sexp|
+      append('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 [SlimLint::Sexp]
+    def append(code, sexp)
+      return if code.empty?
+
+      @source_lines << code
+      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.count("\n") + 1).times do
+        @line_count += 1
+        @source_map[@line_count] = original_line
+      end
+    end
+  end
+end

data/lib/slim_lint/ruby_parser.rb

@@ -0,0 +1,29 @@
+require 'astrolabe/builder'
+require 'parser/current'
+
+module SlimLint
+  # 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
+      @builder = ::Astrolabe::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/slim_lint/runner.rb

@@ -0,0 +1,72 @@
+module SlimLint
+  # Responsible for running the applicable linters against the desired files.
+  class Runner
+    # Make the list of applicable files available
+    attr_reader :files
+
+    # Runs the appropriate linters against the desired files given the specified
+    # options.
+    #
+    # @param options [Hash]
+    # @raise [SlimLint::Exceptions::NoLintersError] when no linters are enabled
+    # @return [SlimLint::Report] a summary of all lints found
+    def run(options = {})
+      config = load_applicable_config(options)
+      files = extract_applicable_files(options, config)
+      linters = extract_enabled_linters(config, options)
+
+      raise SlimLint::Exceptions::NoLintersError, 'No linters specified' if linters.empty?
+
+      @lints = []
+      files.each do |file|
+        find_lints(file, linters, config)
+      end
+
+      SlimLint::Report.new(@lints, files)
+    end
+
+    private
+
+    def load_applicable_config(options)
+      if options[:config_file]
+        SlimLint::ConfigurationLoader.load_file(options[:config_file])
+      else
+        SlimLint::ConfigurationLoader.load_applicable_config
+      end
+    end
+
+    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
+      (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
+    end
+
+    def find_lints(file, linters, config)
+      document = SlimLint::Document.new(File.read(file), file: file, config: config)
+
+      linters.each do |linter|
+        @lints += linter.run(document)
+      end
+    rescue Slim::Parser::SyntaxError => ex
+      @lints << Lint.new(nil, file, ex.line, ex.error, :error)
+    end
+
+    def extract_applicable_files(options, config)
+      included_patterns = options[:files]
+      excluded_files = options.fetch(:excluded_files, [])
+
+      SlimLint::FileFinder.new(config).find(included_patterns, excluded_files)
+    end
+  end
+end

data/lib/slim_lint/sexp.rb

@@ -0,0 +1,90 @@
+module SlimLint
+  # Symbolic expression which represents tree-structured data.
+  #
+  # The main use of this particular implementation is to provide a single
+  # location for defining convenience helpers when operating on Sexps.
+  class Sexp < Array
+    # Stores the line number of the code in the original document that
+    # corresponds to this Sexp.
+    attr_accessor :line
+
+    # Creates an {Sexp} from the given {Array}-based Sexp, performing a deep
+    # copy.
+    def initialize(sexp)
+      sexp.each do |child|
+        item =
+          case child
+          when Array
+            Sexp.new(child)
+          else
+            child
+          end
+
+        push(item)
+      end
+    end
+
+    # Returns whether this {Sexp} matches the given Sexp pattern.
+    #
+    # A Sexp pattern is simply an incomplete Sexp prefix.
+    #
+    # @example
+    #   The following Sexp:
+    #
+    #     [:html, :doctype, "html5"]
+    #
+    #   ...will match the given patterns:
+    #
+    #     [:html]
+    #     [:html, :doctype]
+    #     [:html, :doctype, "html5"]
+    #
+    # Note that nested Sexps will also be matched, so be careful about the cost
+    # of matching against a complicated pattern.
+    #
+    # @param sexp_pattern [Sexp]
+    # @return [Boolean]
+    def match?(sexp_pattern)
+      # If there aren't enough items to compare then this obviously won't match
+      return unless length >= sexp_pattern.length
+
+      sexp_pattern.each_with_index do |sub_pattern, index|
+        case sub_pattern
+        when Array
+          return false unless self[index].match?(sub_pattern)
+        else
+          return false unless self[index] == sub_pattern
+        end
+      end
+
+      true
+    end
+
+    def display(depth = 1) # rubocop:disable Metrics/AbcSize
+      indentation = ' ' * 2 * depth
+      output = indentation
+      output = '['
+      output << "\n"
+
+      each_with_index do |nested_sexp, index|
+        output += indentation
+
+        case nested_sexp
+        when Sexp
+          output += nested_sexp.display(depth + 1)
+        else
+          output += nested_sexp.inspect
+        end
+
+        if index < length - 1
+          output += ",\n"
+        end
+      end
+      output << "\n"
+      output << ' ' * 2 * (depth - 1)
+      output << ']'
+
+      output
+    end
+  end
+end

data/lib/slim_lint/sexp_visitor.rb

@@ -0,0 +1,105 @@
+module SlimLint
+  # Provides an interface which when included allows a class to visit nodes in
+  # the Sexp of a Slim document.
+  module SexpVisitor
+    SexpPattern = Struct.new(:sexp, :callback_method_name)
+
+    # Traverse the Sexp looking for matches with registered patterns, firing
+    # callbacks for all matches.
+    #
+    # @param sexp [Sexp]
+    def trigger_pattern_callbacks(sexp)
+      on_start sexp
+      traverse sexp
+    end
+
+    # Traverse the given Sexp, firing callbacks if they are defined.
+    #
+    # @param sexp [Sexp]
+    def traverse(sexp)
+      block_called = false
+
+      # Define a block within the closure of this method so that pattern matcher
+      # blocks can call `yield` within their block definitions to force
+      # traversal of their children.
+      block = ->(action = :descend) do
+        block_called = true
+        case action
+        when Sexp
+          # User explicitly yielded a Sexp, indicating they want to control the
+          # flow of traversal. Traverse the Sexp they returned.
+          traverse(action)
+        when :descend
+          traverse_children(sexp)
+        end
+      end
+
+      patterns.each do |pattern|
+        next unless sexp.match?(pattern.sexp)
+
+        result = method(pattern.callback_method_name).call(sexp, &block)
+
+        # Returning :stop indicates we should stop searching this Sexp
+        # (i.e. stop descending this branch of depth-first search).
+        # The `return` here is very intentional.
+        return if result == :stop # rubocop:disable Lint/NonLocalExitFromIterator
+      end
+
+      # If no pattern matchers called `yield` explicitly, continue traversing
+      # children by default (matchers can return `:stop` to not continue).
+      traverse_children(sexp) unless block_called
+    end
+
+    def traverse_children(sexp)
+      sexp.each do |nested_sexp|
+        traverse nested_sexp if nested_sexp.is_a?(Sexp)
+      end
+    end
+
+    # Returns the list of registered Sexp patterns.
+    def patterns
+      self.class.patterns || []
+    end
+
+    # Executed before searching for any pattern matches.
+    #
+    # @param sexp [SlimLint::Sexp]
+    def on_start(*)
+      # Overidden by DSL.on_start
+    end
+
+    # Exposes a convenient Domain-specific Language (DSL) that makes declaring
+    # Sexp match patterns very easy.
+    #
+    # Include them with `extend SlimLint::SexpVisitor::DSL`
+    module DSL
+      # Registered patterns that this visitor will look for when traversing the
+      # Sexp.
+      attr_reader :patterns
+
+      # DSL helper that defines a sexp pattern and block that will be executed if
+      # the given pattern is found.
+      #
+      # @param sexp_pattern [Sexp]
+      def on(sexp_pattern, &block)
+        # TODO: Index Sexps on creation so we can quickly jump to potential
+        # matches instead of checking array.
+        @patterns ||= []
+        @pattern_number ||= 1
+
+        # Use a monotonically increasing number to identify the method so that in
+        # debugging we can simply look at the nth defintion in the class.
+        unique_method_name = :"on_pattern_#{@pattern_number}"
+        define_method(unique_method_name, block)
+
+        @pattern_number += 1
+        @patterns << SexpPattern.new(sexp_pattern, unique_method_name)
+      end
+
+      # Define a block of code to run before checking for any pattern matches.
+      def on_start(&block)
+        define_method(:on_start, block)
+      end
+    end
+  end
+end

data/lib/slim_lint/version.rb

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

data/lib/slim_lint.rb

@@ -0,0 +1,40 @@
+# Load all slim-lint modules necessary to parse and lint a file.
+# Ordering here can be important depending on class references in each module.
+
+require 'slim_lint/constants'
+require 'slim_lint/exceptions'
+require 'slim_lint/configuration'
+require 'slim_lint/configuration_loader'
+require 'slim_lint/sexp'
+require 'slim_lint/file_finder'
+require 'slim_lint/linter_registry'
+require 'slim_lint/logger'
+require 'slim_lint/version'
+
+# Need to load slim before we can
+require 'slim'
+
+# Load all filters (required by SlimLint::Engine)
+Dir[File.expand_path('slim_lint/filters/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end
+
+require 'slim_lint/engine'
+require 'slim_lint/document'
+require 'slim_lint/sexp_visitor'
+require 'slim_lint/lint'
+require 'slim_lint/ruby_parser'
+require 'slim_lint/linter'
+require 'slim_lint/reporter'
+require 'slim_lint/report'
+require 'slim_lint/runner'
+
+# Load all linters
+Dir[File.expand_path('slim_lint/linter/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end
+
+# Load all reporters
+Dir[File.expand_path('slim_lint/reporter/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: slim_lint
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane da Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slim
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+- !ruby/object:Gem::Dependency
+  name: sysexits
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Configurable tool for writing clean and consistent Slim templates
+email:
+- shane@dasilva.io
+executables:
+- slim-lint
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/slim-lint
+- config/default.yml
+- lib/slim_lint.rb
+- lib/slim_lint/cli.rb
+- lib/slim_lint/configuration.rb
+- lib/slim_lint/configuration_loader.rb
+- lib/slim_lint/constants.rb
+- lib/slim_lint/document.rb
+- lib/slim_lint/engine.rb
+- lib/slim_lint/exceptions.rb
+- lib/slim_lint/file_finder.rb
+- lib/slim_lint/filters/inject_line_numbers.rb
+- lib/slim_lint/filters/sexp_converter.rb
+- lib/slim_lint/lint.rb
+- lib/slim_lint/linter.rb
+- lib/slim_lint/linter/line_length.rb
+- lib/slim_lint/linter/redundant_div.rb
+- lib/slim_lint/linter/rubocop.rb
+- lib/slim_lint/linter/trailing_whitespace.rb
+- lib/slim_lint/linter_registry.rb
+- lib/slim_lint/logger.rb
+- lib/slim_lint/options.rb
+- lib/slim_lint/rake_task.rb
+- lib/slim_lint/report.rb
+- lib/slim_lint/reporter.rb
+- lib/slim_lint/reporter/default_reporter.rb
+- lib/slim_lint/reporter/json_reporter.rb
+- lib/slim_lint/ruby_extract_engine.rb
+- lib/slim_lint/ruby_extractor.rb
+- lib/slim_lint/ruby_parser.rb
+- lib/slim_lint/runner.rb
+- lib/slim_lint/sexp.rb
+- lib/slim_lint/sexp_visitor.rb
+- lib/slim_lint/version.rb
+homepage: https://github.com/sds/slim-lint
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Slim template linting tool
+test_files: []