slimembedcop 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e085bf2820cb1e136a62f6584721898d1177eb3cebda9e4735cd2f6ea5ab6ea8
+  data.tar.gz: e21faefb596375c8a30919fad86d5585037a41e8f9a84cbeca222d382ea0e586
+SHA512:
+  metadata.gz: 99f0354e919a707327ead19fa82335631d7b9b44fb938928ee425435c5816999577c79992ed35c08ba7b1accff42f9417ccd75bc5ae1158f8955258aa5a4741d
+  data.tar.gz: 2c54f363d17d4a101fbef514505d9315a3eb1c38988506172876c8d820b42df37892ac40143c502009c1534a00da820e9d6fbf305f1261007c8256596f57cf54

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,36 @@
+require:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  NewCops: enable
+  SuggestExtensions: false
+  TargetRubyVersion: 2.7
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics:
+  Enabled: false
+
+RSpec/AnyInstance:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/ImplicitSubject:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/NamedSubject:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## Unreleased
+
+## 0.1.0 - 2023-09-07
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,7 @@
+# Slimembedcop
+
+RuboCop runner for Ruby code embedded in Slim.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

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

data/exe/slimembedcop

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

data/lib/default.yml

@@ -0,0 +1,8 @@
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Layout/TrailingEmptyLines:
+  Enabled: false
+Layout/InitialIndentation:
+  Enabled: false
+Lint/CircularArgumentReference:
+  Enabled: true

data/lib/slimembedcop/cli.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "optparse"
+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 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
+    end
+  end
+end

data/lib/slimembedcop/config_generator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+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
+
+      private
+
+      def loaded_path
+        @forced_config_path || implicit_config_path || @default_config_path
+      end
+
+      def merged_config
+        ::RuboCop::Config.create(merged_config_hash, loaded_path)
+      end
+
+      def merged_config_hash
+        result = default_config
+        result = ::RuboCop::ConfigLoader.merge(result, user_config) if user_config
+        result
+      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 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 .rubocop.yml].find do |path|
+            ::File.exist?(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slimembedcop/extractor.rb

@@ -0,0 +1,57 @@
+# 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
+
+        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
+        end
+
+        result << [begin_pos, index - 1] if inside_ruby
+
+        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
+end

data/lib/slimembedcop/offense.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "parser"
+require "rubocop"
+
+module Slimembedcop
+  # Wraps a RuboCop offense.
+  class Offense
+    extend ::Forwardable
+
+    attr_reader :path, :offset
+
+    delegate(
+      %i[column column_length cop_name correctable? corrected_with_todo?
+         corrected? corrector eql? hash highlighted_area line
+         message real_column severity] => :offense_with_real_location
+    )
+
+    def initialize(path, offset, offense, source)
+      @path = path
+      @offset = offset
+      @offense = offense
+      @source = source
+    end
+
+    def location
+      @location ||= ::Parser::Source::Range.new(
+        buffer,
+        @offense.location.begin_pos + @offset,
+        @offense.location.end_pos + @offset
+      )
+    end
+
+    def marshal_dump
+      {
+        begin_pos: @offense.location.begin_pos,
+        cop_name: @offense.cop_name,
+        end_pos: @offense.location.end_pos,
+        path: @path,
+        message: @offense.message.dup.force_encoding(::Encoding::UTF_8).scrub,
+        offset: @offset,
+        severity: @offense.severity.to_s,
+        source: @source,
+        status: @offense.status
+      }
+    end
+
+    def marshal_load(hash)
+      @path = hash[:path]
+      @offset = hash[:offset]
+      @offense = ::RuboCop::Cop::Offense.new(
+        hash[:severity],
+        ::Parser::Source::Range.new(
+          ::Parser::Source::Buffer.new(
+            @path,
+            source: @source
+          ),
+          hash[:begin_pos],
+          hash[:end_pos]
+        ),
+        hash[:message],
+        hash[:cop_name],
+        hash[:status].to_sym
+      )
+      @source = hash[:source]
+    end
+
+    private
+
+    def buffer
+      ::Parser::Source::Buffer.new(path, source: @source)
+    end
+
+    def offense_with_real_location
+      ::RuboCop::Cop::Offense.new(
+        @offense.severity.name,
+        location,
+        @offense.message,
+        @offense.cop_name,
+        @offense.status,
+        @offense.corrector
+      )
+    end
+  end
+end

data/lib/slimembedcop/offense_collector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+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
+        end
+      end
+
+      private
+
+      def snippets(path, source)
+        Extractor.run(path, source)
+      end
+    end
+  end
+end

data/lib/slimembedcop/path_finder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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
+
+      private
+
+      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
+        @excluded ||= matching_paths(@exclude_patterns)
+      end
+
+      def patterns
+        return @default_patterns if @path_patterns.empty?
+
+        @path_patterns.map do |pattern|
+          next pattern unless File.directory?(pattern)
+
+          @default_patterns.map do |default|
+            File.join(pattern, default)
+          end.flatten
+        end
+      end
+    end
+  end
+end

data/lib/slimembedcop/ruby_offense_collector.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+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?
+
+        rubocop_team(config, autocorrect).investigate(rubocop_processed_source(path, config, source)).offenses.reject(&:disabled?)
+      end
+
+      private
+
+      def registry
+        @registry ||= begin
+          all_cops = if ::RuboCop::Cop::Registry.respond_to?(:all)
+                       ::RuboCop::Cop::Registry.all
+                     else
+                       ::RuboCop::Cop::Cop.all
+                     end
+
+          ::RuboCop::Cop::Registry.new(all_cops)
+        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 rubocop_team(config, autocorrect)
+        ::RuboCop::Cop::Team.new(
+          registry,
+          config,
+          autocorrect: autocorrect,
+          display_cop_names: true,
+          extra_details: true,
+          stdin: ""
+        )
+      end
+    end
+  end
+end

data/lib/slimembedcop/runner.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+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
+
+      private
+
+      def on_started(formatter, paths)
+        formatter.started(paths)
+      end
+
+      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?)
+
+            next unless @autocorrect
+
+            correct(path, offenses, source)
+          end
+
+          on_file_finished(path, formatter, offenses_per_file)
+          [path, offenses_per_file]
+        end
+      end
+
+      def max_trials_count
+        if @autocorrect
+          7
+        else
+          1
+        end
+      end
+
+      def investigate(path, config, source)
+        OffenseCollector.run(path, config, source, @autocorrect)
+      end
+
+      def correct(path, offenses, source)
+        rewritten_source = TemplateCorrector.new(path, offenses, source).run
+        ::File.write(path, rewritten_source)
+      end
+
+      def on_file_started(formatter, path)
+        formatter.file_started(path, {})
+      end
+
+      def on_file_finished(path, formatter, offenses)
+        formatter.file_finished(path, offenses)
+      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)
+
+        formatter.finished(paths)
+      end
+    end
+  end
+end

data/lib/slimembedcop/template_corrector.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "parser"
+require "rubocop/cop/legacy/corrector"
+
+module Slimembedcop
+  # Apply auto-corrections to Template file.
+  class TemplateCorrector
+    def initialize(path, offenses, source)
+      @path = path
+      @offenses = offenses
+      @source = source
+    end
+
+    def run
+      ::RuboCop::Cop::Legacy::Corrector.new(source_buffer, corrections).rewrite
+    end
+
+    private
+
+    def corrections
+      @offenses.select(&:corrector).map do |offense|
+        lambda do |corrector|
+          corrector.import!(offense.corrector, offset: offense.offset)
+        end
+      end
+    end
+
+    def source_buffer
+      ::Parser::Source::Buffer.new(@path, source: @source)
+    end
+  end
+end

data/lib/slimembedcop/version.rb

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

data/lib/slimembedcop.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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"
+end

data/slimembedcop.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "lib/slimembedcop/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "slimembedcop"
+  spec.version = Slimembedcop::VERSION
+  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.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|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rubocop", "~> 1.0"
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: slimembedcop
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description:
+email:
+- t.yudai92@gmail.com
+executables:
+- slimembedcop
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/slimembedcop
+- lib/default.yml
+- lib/slimembedcop.rb
+- lib/slimembedcop/cli.rb
+- lib/slimembedcop/config_generator.rb
+- lib/slimembedcop/extractor.rb
+- lib/slimembedcop/offense.rb
+- lib/slimembedcop/offense_collector.rb
+- lib/slimembedcop/path_finder.rb
+- lib/slimembedcop/ruby_offense_collector.rb
+- lib/slimembedcop/runner.rb
+- lib/slimembedcop/template_corrector.rb
+- lib/slimembedcop/version.rb
+- slimembedcop.gemspec
+homepage: https://github.com/ydah/slimembedcop
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/slimembedcop
+  source_code_uri: https://github.com/ydah/slimembedcop
+  changelog_uri: https://github.com/ydah/slimembedcop/releases
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: RuboCop runner for Ruby code embedded in Slim.
+test_files: []