erb_lint 0.0.9 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ee1658d922ffcd67d6fac26d449d14af651c4d4
-  data.tar.gz: 23d7dabea75b0b9cfdd788ce547e33b2584ac240
+  metadata.gz: eb68fe352cf7b67dba7ec568ad6d40bc87e740f5
+  data.tar.gz: 6cafdb08d656bcfe14666a7e00b9f144e741b62a
 SHA512:
-  metadata.gz: 00322ff00a84d68edf04bbaf8041647b5291f1ad33543970309d3546e34018d11e3fc506be00f3ace186c473e88d7ea24a32f11af4fff0d1d124a87d9507083c
-  data.tar.gz: 532d556c69502798da046667b90c8fdfa8ce5782a8a0a6e4c88808ac145794a95a9ffbbf4cf4097da224076738035bed14ab6e2ea9b2fadd2ea91c221522e767
+  metadata.gz: 1fb5769c9cd386762eae39367c60ce941719017bf20eb911d478ca17e5d8dd5f923226408369a6b870707ee15eb5f3f5c8bc5b0133535346501190e998ca75da
+  data.tar.gz: fcd8c9009447122ded1b08a0855bd5a60a755a71fc341a03b84995d7cb7945c1a28338e5bb64f5368d021c2ee055ded8e2a1b906dd974ec11d6cc1f159f352ca

data/exe/erblint

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require 'erb_lint/cli'
+
+cli = ERBLint::CLI.new
+exit cli.run

data/lib/erb_lint.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require 'erb_lint/version'
+require 'erb_lint/linter_config'
 require 'erb_lint/linter_registry'
 require 'erb_lint/linter'
+require 'erb_lint/runner_config'
 require 'erb_lint/runner'
 require 'erb_lint/file_loader'
 

data/lib/erb_lint/cli.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'erb_lint'
+require 'active_support'
+require 'active_support/inflector'
+require 'optparse'
+require 'psych'
+require 'yaml'
+require 'colorize'
+
+module ERBLint
+  class CLI
+    DEFAULT_CONFIG_FILENAME = '.erb-lint.yml'
+    DEFAULT_LINT_ALL_GLOB = "**/*.html{+*,}.erb"
+
+    class ExitWithFailure < RuntimeError; end
+    class ExitWithSuccess < RuntimeError; end
+
+    def initialize
+      @options = {}
+      @config = nil
+      @files = []
+    end
+
+    def run(args = ARGV)
+      load_options(args)
+      @files = args.dup
+
+      if lint_files.empty?
+        success!("no files given...\n#{option_parser}")
+      end
+
+      load_config
+      ensure_files_exist(lint_files)
+
+      puts "Linting #{lint_files.size} files with #{enabled_linter_classes.size} linters..."
+      puts
+
+      errors_found = false
+      runner_config = @config.merge(runner_config_override)
+      runner = ERBLint::Runner.new(file_loader, runner_config)
+      lint_files.each do |filename|
+        lint_result = runner.run(filename, File.read(filename))
+        errors = lint_result.map { |r| r[:errors] }.flatten
+        errors.each do |lint_error|
+          puts <<~EOF
+            #{lint_error[:message]}
+            In file: #{relative_filename(filename)}:#{lint_error[:line]}
+
+          EOF
+          errors_found = true
+        end
+      end
+
+      if errors_found
+        warn "Errors were found in ERB files".red
+      else
+        puts "No errors were found in ERB files".green
+      end
+
+      !errors_found
+    rescue OptionParser::InvalidOption, OptionParser::InvalidArgument, ExitWithFailure => e
+      warn e.message.red
+      false
+    rescue ExitWithSuccess => e
+      puts e.message
+      true
+    rescue => e
+      warn "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}".red
+      false
+    end
+
+    private
+
+    def config_filename
+      @config_filename ||= @options[:config] || DEFAULT_CONFIG_FILENAME
+    end
+
+    def load_config
+      if File.exist?(config_filename)
+        @config = RunnerConfig.new(file_loader.yaml(config_filename))
+      else
+        warn "#{config_filename} not found: using default config".yellow
+        @config = RunnerConfig.default
+      end
+    rescue Psych::SyntaxError => e
+      failure!("error parsing config: #{e.message}")
+    end
+
+    def file_loader
+      @file_loader ||= ERBLint::FileLoader.new(Dir.pwd)
+    end
+
+    def load_options(args)
+      option_parser.parse!(args)
+    end
+
+    def lint_files
+      if @options[:lint_all]
+        pattern = File.expand_path(DEFAULT_LINT_ALL_GLOB, Dir.pwd)
+        Dir[pattern]
+      else
+        @files.map { |f| f.include?('*') ? Dir[f] : f }.flatten.map { |f| File.expand_path(f, Dir.pwd) }
+      end
+    end
+
+    def failure!(msg)
+      raise ExitWithFailure, msg
+    end
+
+    def success!(msg)
+      raise ExitWithSuccess, msg
+    end
+
+    def ensure_files_exist(files)
+      files.each do |filename|
+        unless File.exist?(filename)
+          failure!("#{filename}: does not exist")
+        end
+      end
+    end
+
+    def known_linter_names
+      @known_linter_names ||= ERBLint::LinterRegistry.linters
+        .map(&:simple_name)
+        .map(&:underscore)
+    end
+
+    def enabled_linter_names
+      @enabled_linter_names ||=
+        @options[:enabled_linters] ||
+        known_linter_names.select { |klass| @config.for_linter(klass).enabled? }
+    end
+
+    def enabled_linter_classes
+      @enabled_linter_classes ||= ERBLint::LinterRegistry.linters
+        .select { |klass| enabled_linter_names.include?(klass.simple_name.underscore) }
+    end
+
+    def relative_filename(filename)
+      filename.sub("#{File.expand_path('.', Dir.pwd)}/", '')
+    end
+
+    def runner_config_override
+      if @options[:enabled_linters].present?
+        RunnerConfig.new(
+          linters: {}.tap do |linters|
+            ERBLint::LinterRegistry.linters.map do |klass|
+              linters[klass.simple_name] = { 'enabled' => enabled_linter_classes.include?(klass) }
+            end
+          end
+        )
+      else
+        RunnerConfig.new
+      end
+    end
+
+    def option_parser
+      OptionParser.new do |opts|
+        opts.banner = "Usage: erblint [options] [file1, file2, ...]"
+
+        opts.on("--config FILENAME", "Config file [default: #{DEFAULT_CONFIG_FILENAME}]") do |config|
+          if File.exist?(config)
+            @options[:config] = config
+          else
+            failure!("#{config}: does not exist")
+          end
+        end
+
+        opts.on("--lint-all", "Lint all files matching #{DEFAULT_LINT_ALL_GLOB}") do |config|
+          @options[:lint_all] = config
+        end
+
+        opts.on("--enable-all-linters", "Enable all known linters") do
+          @options[:enabled_linters] = known_linter_names
+        end
+
+        opts.on("--enable-linters LINTER[,LINTER,...]", Array,
+          "Only use specified linter", "Known linters are: #{known_linter_names.join(', ')}") do |linters|
+          linters.each do |linter|
+            unless known_linter_names.include?(linter)
+              failure!("#{linter}: not a valid linter name (#{known_linter_names.join(', ')})")
+            end
+          end
+          @options[:enabled_linters] = linters
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          success!(opts)
+        end
+
+        opts.on_tail("--version", "Show version") do
+          success!(ERBLint::VERSION)
+        end
+      end
+    end
+  end
+end

data/lib/erb_lint/linter.rb

@@ -5,6 +5,7 @@ module ERBLint
   class Linter
     class << self
       attr_accessor :simple_name
+      attr_accessor :config_schema
 
       # When defining a Linter class, define its simple name as well. This
       # assumes that the module hierarchy of every linter starts with
@@ -13,15 +14,31 @@ module ERBLint
       # `ERBLint::Linters::Foo.simple_name`          #=> "Foo"
       # `ERBLint::Linters::Compass::Bar.simple_name` #=> "Compass::Bar"
       def inherited(linter)
-        name_parts = linter.name.split('::')
-        name = name_parts.length < 3 ? '' : name_parts[2..-1].join('::')
-        linter.simple_name = name
+        linter.simple_name = if linter.name.start_with?('ERBLint::Linters::')
+          name_parts = linter.name.split('::')
+          name_parts[2..-1].join('::')
+        else
+          linter.name
+        end
+
+        linter.config_schema = LinterConfig
       end
     end
 
     # Must be implemented by the concrete inheriting class.
-    def initialize(file_loader, _config)
+    def initialize(file_loader, config)
       @file_loader = file_loader
+      @config = config
+      raise ArgumentError, "expect `config` to be #{self.class.config_schema} instance, "\
+        "not #{config.class}" unless config.is_a?(self.class.config_schema)
+    end
+
+    def enabled?
+      @config.enabled?
+    end
+
+    def excludes_file?(filename)
+      @config.excludes_file?(filename)
     end
 
     def lint_file(file_content)

data/lib/erb_lint/linter_config.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'smart_properties'
+
+module ERBLint
+  class LinterConfig
+    include SmartProperties
+
+    class Error < StandardError; end
+
+    class << self
+      def array_of?(klass)
+        lambda { |value| value.is_a?(Array) && value.all? { |s| s.is_a?(klass) } }
+      end
+
+      def to_array_of(klass)
+        lambda { |entries| entries.map { |entry| klass.new(entry) } }
+      end
+    end
+
+    property :enabled, accepts: [true, false], default: false, reader: :enabled?
+    property :exclude, accepts: array_of?(String), default: []
+
+    def initialize(config = {})
+      config = config.dup.deep_stringify_keys
+      allowed_keys = self.class.properties.keys.map(&:to_s)
+      given_keys = config.keys
+      if (extra_keys = given_keys - allowed_keys).any?
+        raise Error, "Given key is not allowed: #{extra_keys.join(', ')}"
+      end
+      super(config)
+    rescue SmartProperties::InitializationError => e
+      raise Error, "The following properties are required to be set: #{e.properties}"
+    rescue SmartProperties::InvalidValueError => e
+      raise Error, e.message
+    end
+
+    def [](name)
+      unless self.class.properties.key?(name)
+        raise Error, "No such property: #{name}"
+      end
+      super
+    end
+
+    def to_hash
+      {}.tap do |hash|
+        self.class.properties.to_hash.each_key do |key|
+          hash[key.to_s] = self[key]
+        end
+      end
+    end
+
+    def excludes_file?(filename)
+      exclude.any? do |path|
+        File.fnmatch?(path, filename)
+      end
+    end
+  end
+end

data/lib/erb_lint/linter_registry.rb

@@ -13,6 +13,10 @@ module ERBLint
         @linters << linter_class
       end
 
+      def find_by_name(name)
+        linters.detect { |linter| linter.simple_name == name }
+      end
+
       def load_custom_linters(directory = CUSTOM_LINTERS_DIR)
         ruby_files = Dir.glob(File.expand_path(File.join(directory, '**', '*.rb')))
         ruby_files.each { |file| require file }

data/lib/erb_lint/linters/deprecated_classes.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'better_html'
+require 'better_html/parser'
 
 module ERBLint
   module Linters
@@ -8,67 +8,79 @@ module ERBLint
     class DeprecatedClasses < Linter
       include LinterRegistry
 
-      def initialize(file_loader, config)
-        super
+      class RuleSet
+        include SmartProperties
+        property :suggestion, accepts: String, default: ''
+        property :deprecated, accepts: LinterConfig.array_of?(String), default: []
+      end
 
-        @deprecated_ruleset = []
-        config.fetch('rule_set', []).each do |rule|
-          suggestion = rule.fetch('suggestion', '')
-          rule.fetch('deprecated', []).each do |class_expr|
-            @deprecated_ruleset.push(
-              class_expr: class_expr,
-              suggestion: suggestion
-            )
-          end
-        end
-        @deprecated_ruleset.freeze
+      class ConfigSchema < LinterConfig
+        property :rule_set,
+          default: [],
+          accepts: array_of?(RuleSet),
+          converts: to_array_of(RuleSet)
+        property :addendum, accepts: String
+      end
+      self.config_schema = ConfigSchema
 
-        @addendum = config.fetch('addendum', '')
+      def initialize(file_loader, config)
+        super
+        @addendum = @config.addendum
       end
 
       def lint_file(file_content)
         errors = []
-        iterator = build_iterator(file_content)
-        each_class_name_with_line(iterator) do |class_name, line|
-          errors.push(*generate_errors(class_name, line))
+        parser = build_parser(file_content)
+        class_name_with_loc(parser).each do |class_name, loc|
+          errors.push(*generate_errors(class_name, loc.line))
         end
-        each_texthtml_script(iterator) do |text_node|
-          errors.push(*lint_file(text_node.content))
+        text_tags_content(parser).each do |content|
+          errors.push(*lint_file(content))
         end
         errors
       end
 
       private
 
-      def build_iterator(file_content)
-        BetterHtml::NodeIterator.new(file_content, template_language: :html)
+      def build_parser(file_content)
+        BetterHtml::Parser.new(file_content, template_language: :html)
       end
 
-      def each_class_name_with_line(iterator)
-        each_element_with_index(iterator) do |element, _index|
-          klass = element.find_attr('class')
-          next unless klass
-          klass.value_without_quotes.split(' ').each do |class_name|
-            yield class_name, klass.name_parts.first.location.line
+      def class_name_with_loc(parser)
+        Enumerator.new do |yielder|
+          tags(parser).each do |tag|
+            class_value = tag.attributes['class']&.value
+            next unless class_value
+            class_value.split(' ').each do |class_name|
+              yielder.yield(class_name, tag.loc)
+            end
           end
         end
       end
 
-      def each_element_with_index(iterator)
-        iterator.nodes.each_with_index do |node, index|
-          yield node, index if node.element?
+      def text_tags_content(parser)
+        Enumerator.new do |yielder|
+          script_tags(parser)
+            .select { |tag| tag.attributes['type']&.value == 'text/html' }
+            .each do |tag|
+              index = parser.ast.to_a.find_index(tag.node)
+              next_node = parser.ast.to_a[index + 1]
+
+              yielder.yield(next_node.loc.source) if next_node.type == :text
+            end
         end
       end
 
-      def each_texthtml_script(iterator)
-        each_element_with_index(iterator) do |element, index|
-          type = element.find_attr('type')
-          next unless type
-          next unless type.value_without_quotes == 'text/html'
-          next_node = iterator.nodes[index + 1]
+      def script_tags(parser)
+        tags(parser).select { |tag| tag.name == 'script' }
+      end
 
-          yield next_node if next_node&.text?
-        end
+      def tags(parser)
+        tag_nodes(parser).map { |tag_node| BetterHtml::Tree::Tag.from_node(tag_node) }
+      end
+
+      def tag_nodes(parser)
+        parser.nodes_with_type(:tag)
       end
 
       def generate_errors(class_name, line_number)
@@ -83,8 +95,17 @@ module ERBLint
       end
 
       def violated_rules(class_name)
-        @deprecated_ruleset.select do |deprecated_rule|
-          /\A#{deprecated_rule[:class_expr]}\z/.match(class_name)
+        [].tap do |result|
+          @config.rule_set.each do |rule|
+            rule.deprecated.each do |deprecated|
+              next unless /\A#{deprecated}\z/ =~ class_name
+
+              result << {
+                suggestion: rule.suggestion,
+                class_expr: deprecated,
+              }
+            end
+          end
         end
       end
     end

data/lib/erb_lint/linters/erb_safety.rb

@@ -10,9 +10,15 @@ module ERBLint
       include LinterRegistry
       include BetterHtml::TestHelper::SafeErbTester
 
+      class ConfigSchema < LinterConfig
+        property :better_html_config, accepts: String
+      end
+
+      self.config_schema = ConfigSchema
+
       def initialize(file_loader, config)
         super
-        @config_filename = config['better-html-config']
+        @config_filename = @config.better_html_config
       end
 
       def lint_file(file_content)

data/lib/erb_lint/linters/final_newline.rb

@@ -6,9 +6,14 @@ module ERBLint
     class FinalNewline < Linter
       include LinterRegistry
 
+      class ConfigSchema < LinterConfig
+        property :present, accepts: [true, false], default: true, reader: :present?
+      end
+      self.config_schema = ConfigSchema
+
       def initialize(file_loader, config)
         super
-        @new_lines_should_be_present = config['present'].nil? ? true : config['present']
+        @new_lines_should_be_present = @config.present?
       end
 
       protected

data/lib/erb_lint/linters/rubocop.rb

@@ -10,27 +10,34 @@ module ERBLint
     class Rubocop < Linter
       include LinterRegistry
 
+      class ConfigSchema < LinterConfig
+        property :only, accepts: array_of?(String)
+        property :rubocop_config, accepts: Hash
+      end
+
+      self.config_schema = ConfigSchema
+
       # copied from Rails: action_view/template/handlers/erb/erubi.rb
       BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
-      def initialize(file_loader, config_hash)
+      def initialize(file_loader, config)
         super
-        @enabled_cops = config_hash.delete('only')
-        tempfile_from('.erblint-rubocop', config_hash.except('enabled').to_yaml) do |tempfile|
-          custom_config = RuboCop::ConfigLoader.load_file(tempfile.path)
-          @config = RuboCop::ConfigLoader.merge_with_default(custom_config, '')
-        end
+        @only_cops = @config.only
+        custom_config = config_from_hash(@config.rubocop_config)
+        @rubocop_config = RuboCop::ConfigLoader.merge_with_default(custom_config, '')
       end
 
       def lint_file(file_content)
         errors = []
-        erb = BetterHtml::NodeIterator::HtmlErb.new(file_content)
-        erb.tokens.each do |token|
-          next unless [:stmt, :expr_literal, :expr_escaped].include?(token.type)
-          ruby_code = token.code.sub(BLOCK_EXPR, '')
-          offenses = inspect_content(ruby_code)
+        parser = BetterHtml::Parser.new(file_content, template_language: :html)
+        parser.ast.descendants(:erb).each do |erb_node|
+          _, _, code_node, = *erb_node
+          code = code_node.loc.source.sub(/\A[[:blank:]]*/, '')
+          code = "#{' ' * erb_node.loc.column}#{code}"
+          code = code.sub(BLOCK_EXPR, '')
+          offenses = inspect_content(code)
           offenses&.each do |offense|
-            errors << format_error(token, offense)
+            errors << format_error(code_node, offense)
           end
         end
         errors
@@ -57,23 +64,61 @@ module ERBLint
       def processed_source(content)
         RuboCop::ProcessedSource.new(
           content,
-          @config.target_ruby_version,
+          @rubocop_config.target_ruby_version,
           '(erb)'
         )
       end
 
       def team
-        selected_cops = RuboCop::Cop::Cop.all.select { |cop| cop.match?(@enabled_cops) }
-        cop_classes = RuboCop::Cop::Registry.new(selected_cops)
-        RuboCop::Cop::Team.new(cop_classes, @config, extra_details: true, display_cop_names: true)
+        cop_classes =
+          if @only_cops.present?
+            selected_cops = RuboCop::Cop::Cop.all.select { |cop| cop.match?(@only_cops) }
+            RuboCop::Cop::Registry.new(selected_cops)
+          elsif @rubocop_config['Rails']['Enabled']
+            RuboCop::Cop::Registry.new(RuboCop::Cop::Cop.all)
+          else
+            RuboCop::Cop::Cop.non_rails
+          end
+        RuboCop::Cop::Team.new(cop_classes, @rubocop_config, extra_details: true, display_cop_names: true)
       end
 
-      def format_error(token, offense)
+      def format_error(code_node, offense)
         {
-          line: token.location.line + offense.line - 1,
+          line: code_node.loc.line + offense.line - 1,
           message: offense.message.strip
         }
       end
+
+      def config_from_hash(hash)
+        inherit_from = hash.delete('inherit_from')
+        resolve_inheritance(hash, inherit_from)
+
+        tempfile_from('.erblint-rubocop', hash.to_yaml) do |tempfile|
+          RuboCop::ConfigLoader.load_file(tempfile.path)
+        end
+      end
+
+      def resolve_inheritance(hash, inherit_from)
+        base_configs(inherit_from)
+          .reverse_each do |base_config|
+          base_config.each do |k, v|
+            hash[k] = hash.key?(k) ? RuboCop::ConfigLoader.merge(v, hash[k]) : v if v.is_a?(Hash)
+          end
+        end
+      end
+
+      def base_configs(inherit_from)
+        regex = URI::DEFAULT_PARSER.make_regexp(%w(http https))
+        configs = Array(inherit_from).compact.map do |base_name|
+          if base_name =~ /\A#{regex}\z/
+            RuboCop::ConfigLoader.load_file(RuboCop::RemoteConfig.new(base_name, Dir.pwd))
+          else
+            config_from_hash(@file_loader.yaml(base_name))
+          end
+        end
+
+        configs.compact
+      end
     end
   end
 end

data/lib/erb_lint/runner.rb

@@ -3,20 +3,20 @@
 module ERBLint
   # Runs all enabled linters against an html.erb file.
   class Runner
-    def initialize(file_loader, config = {})
+    def initialize(file_loader, config)
       @file_loader = file_loader
-      @config = default_config.merge(config || {})
+      @config = config || RunnerConfig.default
+      raise ArgumentError, 'expect `config` to be a RunnerConfig instance' unless @config.is_a?(RunnerConfig)
 
       LinterRegistry.load_custom_linters
-      @linters = LinterRegistry.linters.select { |linter_class| linter_enabled?(linter_class) }
-      @linters.map! do |linter_class|
-        linter_config = @config.dig('linters', linter_class.simple_name)
-        linter_class.new(@file_loader, linter_config)
+      linter_classes = LinterRegistry.linters.select { |klass| @config.for_linter(klass).enabled? }
+      @linters = linter_classes.map do |linter_class|
+        linter_class.new(@file_loader, @config.for_linter(linter_class))
       end
     end
 
     def run(filename, file_content)
-      linters_for_file = @linters.reject { |linter| linter_excludes_file?(linter, filename) }
+      linters_for_file = @linters.reject { |linter| linter.excludes_file?(filename) }
       linters_for_file.map do |linter|
         {
           linter_name: linter.class.simple_name,
@@ -24,31 +24,5 @@ module ERBLint
         }
       end
     end
-
-    private
-
-    def linter_enabled?(linter_class)
-      linter_config = @config.dig('linters', linter_class.simple_name)
-      return false if linter_config.nil?
-      linter_config['enabled'] || false
-    end
-
-    def linter_excludes_file?(linter, filename)
-      excluded_filepaths = @config.dig('linters', linter.class.simple_name, 'exclude') || []
-      excluded_filepaths.each do |path|
-        return true if File.fnmatch?(path, filename)
-      end
-      false
-    end
-
-    def default_config
-      {
-        'linters' => {
-          'FinalNewline' => {
-            'enabled' => true
-          }
-        }
-      }
-    end
   end
 end

data/lib/erb_lint/runner_config.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ERBLint
+  class RunnerConfig
+    class Error < StandardError; end
+
+    def initialize(config = nil)
+      @config = (config || {}).dup.deep_stringify_keys
+    end
+
+    def to_hash
+      @config.dup
+    end
+
+    def for_linter(klass)
+      klass_name = if klass.is_a?(String)
+        klass.to_s
+      elsif klass.is_a?(Class) && klass <= ERBLint::Linter
+        klass.simple_name
+      else
+        raise ArgumentError, 'expected String or linter class'
+      end
+      linter_klass = LinterRegistry.find_by_name(klass_name)
+      raise Error, "#{klass_name}: linter not found (is it loaded?)" unless linter_klass
+      linter_klass.config_schema.new(linters_config[klass_name] || {})
+    end
+
+    def merge(other_config)
+      self.class.new(@config.deep_merge(other_config.to_hash))
+    end
+
+    def merge!(other_config)
+      @config.deep_merge!(other_config.to_hash)
+      self
+    end
+
+    class << self
+      def default
+        new(
+          linters: {
+            FinalNewline: {
+              enabled: true,
+            },
+          },
+        )
+      end
+    end
+
+    private
+
+    def linters_config
+      @config['linters'] || {}
+    end
+  end
+end

data/lib/erb_lint/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ERBLint
+  VERSION = '0.0.11'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erb_lint
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.11
 platform: ruby
 authors:
 - Justin Chan
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2017-11-14 00:00:00.000000000 Z
+date: 2018-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: better_html
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.10
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.10
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: html_tokenizer
   requirement: !ruby/object:Gem::Requirement
@@ -40,6 +40,48 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.51'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.51'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: smart_properties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -83,19 +125,25 @@ dependencies:
 description: ERB Linter tool.
 email:
 - justin.the.c@gmail.com
-executables: []
+executables:
+- erblint
 extensions: []
 extra_rdoc_files: []
 files:
+- exe/erblint
 - lib/erb_lint.rb
+- lib/erb_lint/cli.rb
 - lib/erb_lint/file_loader.rb
 - lib/erb_lint/linter.rb
+- lib/erb_lint/linter_config.rb
 - lib/erb_lint/linter_registry.rb
 - lib/erb_lint/linters/deprecated_classes.rb
 - lib/erb_lint/linters/erb_safety.rb
 - lib/erb_lint/linters/final_newline.rb
 - lib/erb_lint/linters/rubocop.rb
 - lib/erb_lint/runner.rb
+- lib/erb_lint/runner_config.rb
+- lib/erb_lint/version.rb
 homepage: https://github.com/justinthec/erb-lint
 licenses:
 - MIT