slimembedcop 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e085bf2820cb1e136a62f6584721898d1177eb3cebda9e4735cd2f6ea5ab6ea8
-  data.tar.gz: e21faefb596375c8a30919fad86d5585037a41e8f9a84cbeca222d382ea0e586
+  metadata.gz: 2de74f977f0c9b3d8668fb691ea042033412e2feee2b77638dca4d60bbac30a4
+  data.tar.gz: 7aea53f38ce0c1c3965cdcda6ffd4ad0260b0242d09aaae610484114f0580f1b
 SHA512:
-  metadata.gz: 99f0354e919a707327ead19fa82335631d7b9b44fb938928ee425435c5816999577c79992ed35c08ba7b1accff42f9417ccd75bc5ae1158f8955258aa5a4741d
-  data.tar.gz: 2c54f363d17d4a101fbef514505d9315a3eb1c38988506172876c8d820b42df37892ac40143c502009c1534a00da820e9d6fbf305f1261007c8256596f57cf54
+  metadata.gz: 63bead9c81a50545c49bc6b039b1362109b59710cd45e50ab88f2375e77089182320e6c624f8297b355521d5b3f6a99758008f087db6d2c843aa5942a7e623dc
+  data.tar.gz: db4c9e49e42d4fa6157627e4ad0f9497c114072a22b4944181b9308ef9a749d6b49763c0f25644465c034044f5be48b016e226295660c2b2983c1c5454f252a7

data/.rubocop.yml

@@ -32,5 +32,3 @@ RSpec/NamedSubject:
 Style/Documentation:
   Enabled: false
 
-Style/StringLiterals:
-  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## Unreleased
 
+## 0.2.0 - 2023-09-16
+
+- Disable unnecessary cop for slimembedcop.
+- Add `--debug` option.
+- Remove .rubocop.yml for default implicit config path.
+
 ## 0.1.0 - 2023-09-07
 
 - Initial release

data/Rakefile

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
 
-task default: %i[spec]
+task default: %i[spec rubocop]

data/exe/slimembedcop

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "slimembedcop"
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'slimembedcop'
 
-exit Slimembedcop::Cli.run(ARGV)
+exit Slimembedcop::Cli.new(ARGV).run

data/lib/default.yml

@@ -1,8 +1,14 @@
-Style/FrozenStringLiteralComment:
-  Enabled: false
 Layout/TrailingEmptyLines:
   Enabled: false
+
 Layout/InitialIndentation:
   Enabled: false
-Lint/CircularArgumentReference:
-  Enabled: true
+
+Lint/UselessAssignment:
+  Enabled: false
+
+Naming/FileName:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/lib/slimembedcop/cli.rb

@@ -1,44 +1,21 @@
 # frozen_string_literal: true
 
-require "optparse"
-require "rubocop"
+require 'rubocop'
 
 module Slimembedcop
   # Command line interface for Slimembedcop.
   class Cli
-    class << self
-      DEFAULT_CONFIG_PATH = File.expand_path("../default.yml", __dir__)
-      DEFAULT_PATH_PATTERNS = %w[**/*.slim].freeze
-
-      def run(argv)
-        options = parse_options!(argv)
-        formatter = ::RuboCop::Formatter::ProgressFormatter.new($stdout, color: options[:color])
-        config = ConfigGenerator.run(DEFAULT_CONFIG_PATH, options[:forced_config_path])
-        paths = PathFinder.run(DEFAULT_PATH_PATTERNS, config.for_all_cops["Exclude"], argv)
-        offenses = Runner.run(paths, formatter, config, options[:autocorrect])
-        exit(offenses.empty? ? 0 : 1)
-      end
-
-      private
+    def initialize(argv)
+      @argv = argv
+    end
 
-      def parse_options!(argv)
-        options = {}
-        parser = ::OptionParser.new
-        parser.banner = "Usage: slimembedcop [options] [file1, file2, ...]"
-        parser.version = VERSION
-        parser.on("-a", "--autocorrect", "Autocorrect offenses.") do
-          p "autocorrect"
-          options[:autocorrect] = true
-        end
-        parser.on("-c", "--config=", "Specify configuration file. (default: #{DEFAULT_CONFIG_PATH} or .rubocop.yml)") do |file_path|
-          options[:forced_config_path] = file_path
-        end
-        parser.on("--[no-]color", "Force color output on or off.") do |value|
-          options[:color] = value
-        end
-        parser.parse!(argv)
-        options
-      end
+    def run
+      options = Option.new(@argv)
+      formatter = ::RuboCop::Formatter::ProgressFormatter.new($stdout, color: options.color)
+      config = ConfigGenerator.new(options).run
+      paths = PathFinder.new(options, config).run
+      offenses = Runner.new(paths, formatter, options, config).run
+      exit(offenses.empty? ? 0 : 1)
     end
   end
 end

data/lib/slimembedcop/config_generator.rb

@@ -1,57 +1,58 @@
 # frozen_string_literal: true
 
-require "rubocop"
+require 'rubocop'
 
 module Slimembedcop
   # Generates a configuration for RuboCop.
   class ConfigGenerator
-    class << self
-      def run(default_config_path, forced_config_path)
-        @default_config_path = default_config_path
-        @forced_config_path = forced_config_path
-        ::RuboCop::ConfigLoader.merge_with_default(merged_config, loaded_path)
-      end
+    def initialize(option)
+      @default_config_path = option.default_config_path
+      @forced_config_path = option.forced_config_path
+    end
 
-      private
+    def run
+      ::RuboCop::ConfigLoader.merge_with_default(merged_config, loaded_path)
+    end
 
-      def loaded_path
-        @forced_config_path || implicit_config_path || @default_config_path
-      end
+    private
 
-      def merged_config
-        ::RuboCop::Config.create(merged_config_hash, loaded_path)
-      end
+    def loaded_path
+      @forced_config_path || implicit_config_path || @default_config_path
+    end
 
-      def merged_config_hash
-        result = default_config
-        result = ::RuboCop::ConfigLoader.merge(result, user_config) if user_config
-        result
-      end
+    def merged_config
+      ::RuboCop::Config.create(merged_config_hash, loaded_path)
+    end
 
-      def user_config
-        if instance_variable_defined?(:@user_config)
-          @user_config
-        else
-          @user_config =
-            if @forced_config_path
-              ::RuboCop::ConfigLoader.load_file(@forced_config_path)
-            elsif (path = implicit_config_path)
-              ::RuboCop::ConfigLoader.load_file(path)
-            end
-        end
-      end
+    def merged_config_hash
+      result = default_config
+      result = ::RuboCop::ConfigLoader.merge(result, user_config) if user_config
+      result
+    end
 
-      def default_config
-        ::RuboCop::ConfigLoader.load_file(@default_config_path)
+    def user_config
+      if instance_variable_defined?(:@user_config)
+        @user_config
+      else
+        @user_config =
+          if @forced_config_path
+            ::RuboCop::ConfigLoader.load_file(@forced_config_path)
+          elsif (path = implicit_config_path)
+            ::RuboCop::ConfigLoader.load_file(path)
+          end
       end
+    end
 
-      def implicit_config_path
-        if instance_variable_defined?(:@implicit_config_path)
-          @implicit_config_path
-        else
-          @implicit_config_path = %w[.slimembedcop.yml .rubocop.yml].find do |path|
-            ::File.exist?(path)
-          end
+    def default_config
+      ::RuboCop::ConfigLoader.load_file(@default_config_path)
+    end
+
+    def implicit_config_path
+      if instance_variable_defined?(:@implicit_config_path)
+        @implicit_config_path
+      else
+        @implicit_config_path = %w[.slimembedcop.yml].find do |path|
+          ::File.exist?(path)
         end
       end
     end

data/lib/slimembedcop/extractor.rb

@@ -1,57 +1,54 @@
 # frozen_string_literal: true
 
-require "slimi"
-
 module Slimembedcop
   # Extract Ruby codes from Slim embedded code.
   class Extractor
-    class << self
-      def run(path, source)
-        @path = path
-        @source = source
+    def initialize(source)
+      @source = source
+    end
 
-        ranges.map do |(begin_, end_)|
-          { code: source[begin_...end_], offset: begin_ }
-        end
+    def run
+      ranges.map do |(begin_, end_)|
+        { code: @source[begin_...end_], offset: begin_ }
       end
+    end
 
-      private
-
-      def ranges
-        result = []
-        index = 0
-        begin_pos = 0
-        leading_spaces = 0
-        inside_ruby = false
-        @source.each_line do |line|
-          if block_start?(line)
-            leading_spaces = line.match(/^\s*/)[0].length
-            inside_ruby = true
-            begin_pos = index += line.length
-            next
-          end
-
-          if inside_ruby && block_end?(line, leading_spaces)
-            result << [begin_pos, index - 1]
-            inside_ruby = false
-          end
-
-          index += line.length
+    private
+
+    def ranges
+      result = []
+      index = 0
+      begin_pos = 0
+      leading_spaces = 0
+      inside_ruby = false
+      @source.each_line do |line|
+        if block_start?(line)
+          leading_spaces = line.match(/^\s*/)[0].length
+          inside_ruby = true
+          begin_pos = index += line.length
+          next
         end
 
-        result << [begin_pos, index - 1] if inside_ruby
+        if inside_ruby && block_end?(line, leading_spaces)
+          result << [begin_pos, index - 1]
+          inside_ruby = false
+        end
 
-        result
+        index += line.length
       end
 
-      def block_start?(line)
-        line.strip.start_with?("ruby:")
-      end
+      result << [begin_pos, index - 1] if inside_ruby
 
-      def block_end?(line, leading_spaces)
-        line.match(/^\s{#{leading_spaces}}\S/) ||
-          (leading_spaces.zero? && line.match(/^\S/))
-      end
+      result
+    end
+
+    def block_start?(line)
+      line.strip.start_with?('ruby:')
+    end
+
+    def block_end?(line, leading_spaces)
+      line.match(/^\s{#{leading_spaces}}\S/) ||
+        (leading_spaces.zero? && line.match(/^\S/))
     end
   end
 end

data/lib/slimembedcop/offense.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "forwardable"
+require 'forwardable'
 
-require "parser"
-require "rubocop"
+require 'parser'
+require 'rubocop'
 
 module Slimembedcop
   # Wraps a RuboCop offense.

data/lib/slimembedcop/offense_collector.rb

@@ -3,20 +3,26 @@
 module Slimembedcop
   # Collect RuboCop offenses from Template code.
   class OffenseCollector
-    class << self
-      def run(path, config, source, autocorrect)
-        snippets(path, source).flat_map do |snippet|
-          RubyOffenseCollector.run(path, config, snippet[:code], autocorrect).map do |offense|
-            Offense.new(path, snippet[:offset], offense, source)
-          end
+    def initialize(path, config, source, autocorrect, debug)
+      @path = path
+      @config = config
+      @source = source
+      @autocorrect = autocorrect
+      @debug = debug
+    end
+
+    def run
+      snippets.flat_map do |snippet|
+        RubyOffenseCollector.new(@path, @config, snippet[:code], @autocorrect, @debug).run.map do |offense|
+          Offense.new(@path, snippet[:offset], offense, @source)
         end
       end
+    end
 
-      private
+    private
 
-      def snippets(path, source)
-        Extractor.run(path, source)
-      end
+    def snippets
+      Extractor.new(@source).run
     end
   end
 end

data/lib/slimembedcop/option.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Slimembedcop
+  # Command line options.
+  class Option
+    attr_reader :version, :autocorrect, :forced_config_path, :color, :debug,
+                :args, :default_config_path, :default_path_patterns
+
+    def initialize(argv)
+      opt = OptionParser.new
+      @version = false
+      @autocorrect = false
+      @forced_config_path = nil
+      @color = nil
+      @debug = false
+      @default_config_path = File.expand_path('../default.yml', __dir__)
+      @default_path_patterns = %w[**/*.slim].freeze
+
+      opt.banner = 'Usage: slimembedcop [options] [file1, file2, ...]'
+      opt.on('-v', '--version', 'Display version.') { @version = true }
+      opt.on('-a', '--autocorrect', 'Autocorrect offenses.') { @autocorrect = true }
+      opt.on('-c', '--config=', 'Specify configuration file.') { |path| @forced_config_path = path }
+      opt.on('--[no-]color', 'Force color output on or off.') { |value| @color = value }
+      opt.on('-d', '--debug', 'Display debug info.') { |value| @debug = value }
+      @args = opt.parse(argv)
+    end
+  end
+end

data/lib/slimembedcop/path_finder.rb

@@ -1,52 +1,51 @@
 # frozen_string_literal: true
 
-require "pathname"
-require "set"
+require 'pathname'
+require 'set'
 
 module Slimembedcop
   # Collect file paths from given path patterns.
   class PathFinder
-    class << self
-      def run(default_patterns, exclude_patterns, path_patterns)
-        @default_patterns = default_patterns
-        @exclude_patterns = exclude_patterns || []
-        @path_patterns = path_patterns
-        matching_paths(patterns) do |path|
-          !excluded?(path)
-        end.sort
-      end
+    def initialize(options, config)
+      @default_patterns = options.default_path_patterns
+      @exclude_patterns = config.for_all_cops['Exclude'] || []
+      @path_patterns = options.args
+    end
 
-      private
+    def run
+      matching_paths(patterns) { |path| !excluded?(path) }.sort
+    end
 
-      def matching_paths(patterns, &block)
-        patterns.each_with_object(Set.new) do |pattern, set|
-          ::Pathname.glob(pattern) do |pathname|
-            next unless pathname.file?
+    private
 
-            path = pathname.expand_path.to_s
-            set.add(path) if block.nil? || yield(path)
-          end
+    def matching_paths(patterns, &block)
+      patterns.each_with_object(Set.new) do |pattern, set|
+        ::Pathname.glob(pattern) do |pathname|
+          next unless pathname.file?
+
+          path = pathname.expand_path.to_s
+          set.add(path) if block.nil? || yield(path)
         end
       end
+    end
 
-      def excluded?(path)
-        excluded.include?(path)
-      end
+    def excluded?(path)
+      excluded.include?(path)
+    end
 
-      def excluded
-        @excluded ||= matching_paths(@exclude_patterns)
-      end
+    def excluded
+      @excluded ||= matching_paths(@exclude_patterns)
+    end
 
-      def patterns
-        return @default_patterns if @path_patterns.empty?
+    def patterns
+      return @default_patterns if @path_patterns.empty?
 
-        @path_patterns.map do |pattern|
-          next pattern unless File.directory?(pattern)
+      @path_patterns.map do |pattern|
+        next pattern unless File.directory?(pattern)
 
-          @default_patterns.map do |default|
-            File.join(pattern, default)
-          end.flatten
-        end
+        @default_patterns.map do |default|
+          File.join(pattern, default)
+        end.flatten
       end
     end
   end

data/lib/slimembedcop/ruby_offense_collector.rb

@@ -1,47 +1,54 @@
 # frozen_string_literal: true
 
-require "rubocop"
+require 'rubocop'
 
 module Slimembedcop
   # Collect RuboCop offenses from Ruby code.
   class RubyOffenseCollector
-    class << self
-      def run(path, config, source, autocorrect)
-        return [] unless rubocop_processed_source(path, config, source).valid_syntax?
+    def initialize(path, config, source, autocorrect, debug)
+      @path = path
+      @config = config
+      @source = source
+      @autocorrect = autocorrect
+      @debug = debug
+    end
 
-        rubocop_team(config, autocorrect).investigate(rubocop_processed_source(path, config, source)).offenses.reject(&:disabled?)
-      end
+    def run
+      return [] unless processed_source.valid_syntax?
 
-      private
+      team.investigate(processed_source).offenses.reject(&:disabled?)
+    end
 
-      def registry
-        @registry ||= begin
-          all_cops = if ::RuboCop::Cop::Registry.respond_to?(:all)
-                       ::RuboCop::Cop::Registry.all
-                     else
-                       ::RuboCop::Cop::Cop.all
-                     end
+    private
 
-          ::RuboCop::Cop::Registry.new(all_cops)
-        end
+    def processed_source
+      ::RuboCop::ProcessedSource.new(@source, @config.target_ruby_version, @path).tap do |processed_source|
+        processed_source.config = @config if processed_source.respond_to?(:config)
+        processed_source.registry = registry if processed_source.respond_to?(:registry)
       end
+    end
 
-      def rubocop_processed_source(path, config, source)
-        ::RuboCop::ProcessedSource.new(source, config.target_ruby_version, path).tap do |processed_source|
-          processed_source.config = config if processed_source.respond_to?(:config)
-          processed_source.registry = registry if processed_source.respond_to?(:registry)
-        end
-      end
+    def team
+      ::RuboCop::Cop::Team.new(
+        registry,
+        @config,
+        autocorrect: @autocorrect,
+        debug: @debug,
+        display_cop_names: true,
+        extra_details: true,
+        stdin: ''
+      )
+    end
+
+    def registry
+      @registry ||= begin
+        all_cops = if ::RuboCop::Cop::Registry.respond_to?(:all)
+                     ::RuboCop::Cop::Registry.all
+                   else
+                     ::RuboCop::Cop::Cop.all
+                   end
 
-      def rubocop_team(config, autocorrect)
-        ::RuboCop::Cop::Team.new(
-          registry,
-          config,
-          autocorrect: autocorrect,
-          display_cop_names: true,
-          extra_details: true,
-          stdin: ""
-        )
+        ::RuboCop::Cop::Registry.new(all_cops)
       end
     end
   end

data/lib/slimembedcop/runner.rb

@@ -1,83 +1,87 @@
 # frozen_string_literal: true
 
-require "parallel"
-require "stringio"
+require 'parallel'
+require 'stringio'
 
 module Slimembedcop
   # Run investigation and auto-correction.
   class Runner
-    class << self
-      def run(paths, formatter, config, autocorrect)
-        @autocorrect = autocorrect
-
-        on_started(formatter, paths)
-        result = run_in_parallel(paths, formatter, config)
-        on_finished(paths, formatter, result)
-        result.flat_map { |(_, offenses)| offenses }
-      end
+    def initialize(paths, formatter, options, config)
+      @paths = paths
+      @formatter = formatter
+      @autocorrect = options.autocorrect
+      @debug = options.debug
+      @config = config
+    end
 
-      private
+    def run
+      on_started
+      result = run_in_parallel
+      on_finished(result)
+      result.flat_map { |(_, offenses)| offenses }
+    end
 
-      def on_started(formatter, paths)
-        formatter.started(paths)
-      end
+    private
 
-      def run_in_parallel(paths, formatter, config)
-        ::Parallel.map(paths) do |path|
-          offenses_per_file = []
-          max_trials_count.times do
-            on_file_started(formatter, path)
-            source = ::File.read(path)
-            offenses = investigate(path, config, source)
-            offenses_per_file |= offenses
-            break if offenses.none?(&:correctable?)
+    def on_started
+      @formatter.started(@paths)
+    end
 
-            next unless @autocorrect
+    def run_in_parallel
+      ::Parallel.map(@paths) do |path|
+        offenses_per_file = []
+        max_trials_count.times do
+          on_file_started(path)
+          source = ::File.read(path)
+          offenses = investigate(path, source)
+          offenses_per_file |= offenses
+          break if offenses.none?(&:correctable?)
 
-            correct(path, offenses, source)
-          end
+          next unless @autocorrect
 
-          on_file_finished(path, formatter, offenses_per_file)
-          [path, offenses_per_file]
+          correct(path, offenses, source)
         end
-      end
 
-      def max_trials_count
-        if @autocorrect
-          7
-        else
-          1
-        end
+        on_file_finished(path, offenses_per_file)
+        [path, offenses_per_file]
       end
+    end
 
-      def investigate(path, config, source)
-        OffenseCollector.run(path, config, source, @autocorrect)
+    def max_trials_count
+      if @autocorrect
+        7
+      else
+        1
       end
+    end
 
-      def correct(path, offenses, source)
-        rewritten_source = TemplateCorrector.new(path, offenses, source).run
-        ::File.write(path, rewritten_source)
-      end
+    def investigate(path, source)
+      OffenseCollector.new(path, @config, source, @autocorrect, @debug).run
+    end
 
-      def on_file_started(formatter, path)
-        formatter.file_started(path, {})
-      end
+    def correct(path, offenses, source)
+      rewritten_source = TemplateCorrector.new(path, offenses, source).run
+      ::File.write(path, rewritten_source)
+    end
 
-      def on_file_finished(path, formatter, offenses)
-        formatter.file_finished(path, offenses)
-      end
+    def on_file_started(path)
+      @formatter.file_started(path, {})
+    end
 
-      def on_finished(paths, formatter, result)
-        original = formatter.output
-        formatter.instance_variable_set(:@output, ::StringIO.new)
-        result.each do |(path, offenses)|
-          on_file_started(formatter, path)
-          on_file_finished(path, formatter, offenses)
-        end
-        formatter.instance_variable_set(:@output, original)
+    def on_file_finished(path, offenses)
+      @formatter.file_finished(path, offenses)
+    end
 
-        formatter.finished(paths)
+    def on_finished(result)
+      original = @formatter.output
+      @formatter.instance_variable_set(:@output, ::StringIO.new)
+      result.each do |(path, offenses)|
+        on_file_started(path)
+        on_file_finished(path, offenses)
       end
+      @formatter.instance_variable_set(:@output, original)
+
+      @formatter.finished(@paths)
     end
   end
 end

data/lib/slimembedcop/template_corrector.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "parser"
-require "rubocop/cop/legacy/corrector"
+require 'parser'
+require 'rubocop/cop/legacy/corrector'
 
 module Slimembedcop
   # Apply auto-corrections to Template file.
@@ -18,6 +18,10 @@ module Slimembedcop
 
     private
 
+    def source_buffer
+      ::Parser::Source::Buffer.new(@path, source: @source)
+    end
+
     def corrections
       @offenses.select(&:corrector).map do |offense|
         lambda do |corrector|
@@ -25,9 +29,5 @@ module Slimembedcop
         end
       end
     end
-
-    def source_buffer
-      ::Parser::Source::Buffer.new(@path, source: @source)
-    end
   end
 end

data/lib/slimembedcop/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slimembedcop
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

data/lib/slimembedcop.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "slimembedcop/version"
+require_relative 'slimembedcop/version'
 
 module Slimembedcop
-  autoload :Cli, "slimembedcop/cli"
-  autoload :ConfigGenerator, "slimembedcop/config_generator"
-  autoload :Extractor, "slimembedcop/extractor"
-  autoload :Offense, "slimembedcop/offense"
-  autoload :OffenseCollector, "slimembedcop/offense_collector"
-  autoload :PathFinder, "slimembedcop/path_finder"
-  autoload :RubyOffenseCollector, "slimembedcop/ruby_offense_collector"
-  autoload :Runner, "slimembedcop/runner"
-  autoload :TemplateCorrector, "slimembedcop/template_corrector"
+  autoload :Cli, 'slimembedcop/cli'
+  autoload :ConfigGenerator, 'slimembedcop/config_generator'
+  autoload :Extractor, 'slimembedcop/extractor'
+  autoload :Offense, 'slimembedcop/offense'
+  autoload :Option, 'slimembedcop/option'
+  autoload :OffenseCollector, 'slimembedcop/offense_collector'
+  autoload :PathFinder, 'slimembedcop/path_finder'
+  autoload :RubyOffenseCollector, 'slimembedcop/ruby_offense_collector'
+  autoload :Runner, 'slimembedcop/runner'
+  autoload :TemplateCorrector, 'slimembedcop/template_corrector'
 end

data/slimembedcop.gemspec

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require_relative "lib/slimembedcop/version"
+require_relative 'lib/slimembedcop/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "slimembedcop"
+  spec.name = 'slimembedcop'
   spec.version = Slimembedcop::VERSION
-  spec.authors = ["Yudai Takada"]
-  spec.email = ["t.yudai92@gmail.com"]
+  spec.authors = ['Yudai Takada']
+  spec.email = ['t.yudai92@gmail.com']
 
-  spec.summary = "RuboCop runner for Ruby code embedded in Slim."
-  spec.homepage = "https://github.com/ydah/slimembedcop"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.summary = 'RuboCop runner for Ruby code embedded in Slim.'
+  spec.homepage = 'https://github.com/ydah/slimembedcop'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.7.0'
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/releases"
-  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/releases"
+  spec.metadata['rubygems_mfa_required'] = 'true'
 
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
@@ -24,9 +24,9 @@ Gem::Specification.new do |spec|
         f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
     end
   end
-  spec.bindir = "exe"
+  spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "rubocop", "~> 1.0"
+  spec.add_dependency 'rubocop', '~> 1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slimembedcop
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yudai Takada
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-06 00:00:00.000000000 Z
+date: 2023-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -46,6 +46,7 @@ files:
 - lib/slimembedcop/extractor.rb
 - lib/slimembedcop/offense.rb
 - lib/slimembedcop/offense_collector.rb
+- lib/slimembedcop/option.rb
 - lib/slimembedcop/path_finder.rb
 - lib/slimembedcop/ruby_offense_collector.rb
 - lib/slimembedcop/runner.rb