lumin 0.1.0

data/lib/lumin/rule.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "astel"
+require_relative "offense"
+require_relative "registry"
+
+module Lumin
+  class Rule
+    class << self
+      def inherited(subclass)
+        super
+        Registry.register(subclass)
+      end
+
+      def on(node_type, &block)
+        raise ArgumentError, "callback is required" unless block
+
+        subscriptions << [node_type.to_sym, block]
+      end
+
+      def on_new_source(&block)
+        raise ArgumentError, "callback is required" unless block
+
+        source_callbacks << block
+      end
+
+      def subscriptions
+        @subscriptions ||= []
+      end
+
+      def source_callbacks
+        @source_callbacks ||= []
+      end
+
+      def default_config(values = nil)
+        @default_config = symbolize(values).freeze if values
+        @default_config ||= {}.freeze
+      end
+
+      def safe(value = nil)
+        @safe = value unless value.nil?
+        @safe.nil? ? true : @safe
+      end
+
+      def validate_config(&block)
+        @config_validator = block if block
+        @config_validator
+      end
+
+      def configuration_error(settings)
+        validator = validate_config
+        validator&.call(settings)
+      end
+
+      private
+
+      def symbolize(hash)
+        hash.to_h { |key, value| [key.to_sym, value] }
+      end
+    end
+
+    attr_reader :config, :offenses, :source
+
+    def initialize(config = {})
+      @config = self.class.default_config.merge(config.transform_keys(&:to_sym)).freeze
+      @offenses = []
+      @source = nil
+    end
+
+    def begin_source(source)
+      @source = source
+      @offenses = []
+      self.class.source_callbacks.each { |callback| instance_exec(source, &callback) }
+      self
+    end
+
+    def dispatch(node_type, node)
+      self.class.subscriptions.each do |subscribed_type, callback|
+        instance_exec(node, &callback) if subscribed_type == node_type
+      end
+    end
+
+    def add_offense(location, message:, &correction)
+      correction = nil if config[:autocorrect] == false
+      normalized = Astel::Location.from(location)
+      offenses << Offense.new(
+        path: source.path,
+        location: normalized,
+        rule_name: Registry.name_for(self.class),
+        message: message,
+        correctable: !correction.nil?,
+        safe: self.class.safe,
+        correction: correction
+      )
+    end
+  end
+end

data/lib/lumin/rules/lint/no_method_missing.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../../rule"
+
+module Lumin
+  module Rules
+    module Lint
+      class NoMethodMissing < Rule
+        MSG = "avoid defining method_missing"
+        PATTERN = Astel::NodePattern.compile("(def_node name: :method_missing)")
+
+        on :def_node do |node|
+          add_offense(node.name_loc, message: MSG) if PATTERN.match?(node)
+        end
+      end
+    end
+  end
+end

data/lib/lumin/rules/style/frozen_string_literal.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../../rule"
+
+module Lumin
+  module Rules
+    module Style
+      class FrozenStringLiteral < Rule
+        MSG = "frozen_string_literal magic comment is missing"
+        BOM = "\uFEFF"
+        MAGIC_COMMENT_PATTERN =
+          /\A#[^\S\n]*frozen_string_literal[^\S\n]*:[^\S\n]*true\b/
+
+        on_new_source do |source|
+          code = source.source
+          next if magic_comment?(code)
+
+          add_offense(source.bof, message: MSG) do |rewriter|
+            offset = code.start_with?(BOM) ? BOM.bytesize : 0
+            line = 1
+            if code.getbyte(offset) == 0x23 && code.getbyte(offset + 1) == 0x21
+              newline = offset + 2
+              newline += 1 while newline < code.bytesize && code.getbyte(newline) != 0x0A
+              if newline < code.bytesize
+                offset = newline + 1
+                line = 2
+              end
+            end
+            location = Astel::Location.point(
+              offset: offset,
+              line: line,
+              column: 0
+            )
+            rewriter.insert_before(location, "# frozen_string_literal: true\n\n")
+          end
+        end
+
+        private
+
+        def magic_comment?(code)
+          lines_checked = 0
+          code.each_line do |line|
+            candidate = line.start_with?(BOM) ? line.delete_prefix(BOM) : line
+            return true if candidate.match?(MAGIC_COMMENT_PATTERN)
+
+            lines_checked += 1
+            break if lines_checked == 2
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/lumin/rules/style/line_length.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "../../rule"
+
+module Lumin
+  module Rules
+    module Style
+      class LineLength < Rule
+        MSG = "line is too long"
+        CHARACTER_BOUNDARY_PATTERN = /\G/
+        default_config max: 120
+        validate_config do |settings|
+          "max must be greater than zero" if settings.fetch(:max, 120) <= 0
+        end
+
+        on_new_source do |source|
+          code = source.source
+          max = Integer(config.fetch(:max))
+
+          if code.ascii_only?
+            inspect_ascii_lines(code, max)
+          else
+            inspect_multibyte_lines(code, max)
+          end
+        end
+
+        private
+
+        def inspect_ascii_lines(code, max)
+          byte_offset = 0
+          line_number = 1
+          source_bytesize = code.bytesize
+
+          while byte_offset < source_bytesize
+            newline = code.index("\n", byte_offset)
+            raw_end_byte = newline || source_bytesize
+            trailing_cr = raw_end_byte > byte_offset && code.getbyte(raw_end_byte - 1) == 0x0D
+            content_end_byte = raw_end_byte - (trailing_cr ? 1 : 0)
+            content_length = content_end_byte - byte_offset
+
+            if content_length > max
+              add_line_offense(byte_offset + max, content_end_byte, line_number, content_length, max)
+            end
+
+            byte_offset = newline ? newline + 1 : source_bytesize
+            line_number += 1
+          end
+        end
+
+        def inspect_multibyte_lines(code, max)
+          byte_offset = 0
+          line_number = 1
+
+          code.each_line do |line|
+            line_bytesize = line.bytesize
+            has_newline = line.getbyte(line_bytesize - 1) == 0x0A
+            content_bytesize = line_bytesize - (has_newline ? 1 : 0)
+            trailing_cr = content_bytesize.positive? && line.getbyte(content_bytesize - 1) == 0x0D
+            content_bytesize -= 1 if trailing_cr
+            content_length = line.length - (has_newline ? 1 : 0) - (trailing_cr ? 1 : 0)
+
+            if content_length > max
+              start_offset = if content_bytesize == content_length
+                               byte_offset + max
+                             elsif !line.valid_encoding?
+                               byte_offset + invalid_encoding_cutoff(line, max)
+                             else
+                               boundary = CHARACTER_BOUNDARY_PATTERN.match(line, max)
+                               byte_offset + boundary.byteoffset(0).fetch(1)
+                             end
+              add_line_offense(
+                start_offset, byte_offset + content_bytesize, line_number, content_length, max
+              )
+            end
+
+            byte_offset += line_bytesize
+            line_number += 1
+          end
+        end
+
+        def invalid_encoding_cutoff(line, max)
+          bytesize = 0
+          characters = 0
+          line.each_char do |character|
+            break if characters == max
+
+            bytesize += character.bytesize
+            characters += 1
+          end
+          bytesize
+        end
+
+        def add_line_offense(start_offset, end_offset, line_number, content_length, max)
+          add_offense(
+            Astel::Location.new(
+              start_offset: start_offset,
+              end_offset: end_offset,
+              start_line: line_number,
+              start_column: max,
+              end_line: line_number,
+              end_column: content_length
+            ),
+            message: "#{MSG} [#{content_length}/#{max}]"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/lumin/runner.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "etc"
+require "pathname"
+require_relative "parallel_executor"
+require_relative "registry"
+require_relative "worker"
+
+module Lumin
+  class Runner
+    RunResult = Data.define(:offenses, :diffs, :warnings, :errors, :files)
+    AUTO_PARALLEL_MIN_BYTES = 256 * 1024
+    AUTO_WORKER_SCALE_BYTES = 32 * 1024
+
+    def initialize(config:, registry: Registry, parallel: nil, cache: true, cache_dir: nil)
+      @config = config
+      @registry = registry
+      @parallel = parallel
+      @cache_enabled = cache
+      @cache_dir = cache_dir
+      @cache = build_cache if @cache_enabled
+    end
+
+    def clear_cache
+      cache.clear
+    end
+
+    def run(paths = [], fix: false, unsafe: false, dry_run: false)
+      files = enumerate(paths)
+      cached_results, pending = load_cached(files, use_cache: @cache_enabled && !fix)
+      executed_results = execute(pending, fix: fix, unsafe: unsafe, dry_run: dry_run)
+      results = cached_results + executed_results
+      if @cache_enabled && !dry_run
+        store_results(executed_results)
+        cache.flush
+      end
+
+      ordered = results.sort_by(&:path)
+      RunResult.new(
+        offenses: ordered.flat_map(&:offenses).sort_by { |offense| offense_key(offense) }.freeze,
+        diffs: ordered.filter_map(&:diff).freeze,
+        warnings: ordered.flat_map(&:warnings).freeze,
+        errors: ordered.filter_map { |result| "#{result.path}: #{result.error}" if result.error }.freeze,
+        files: files.freeze
+      )
+    end
+
+    private
+
+    def enumerate(paths)
+      candidates = if paths.empty?
+                     @config.include_patterns.flat_map { |pattern| Dir.glob(pattern, File::FNM_EXTGLOB) }
+                   else
+                     paths.flat_map { |path| expand_path(path) }
+                   end
+      candidates.select { |path| File.extname(path) == ".rb" }
+                .map { |path| clean_path(path) }
+                .reject { |path| excluded?(path) }
+                .uniq
+                .sort
+    end
+
+    def expand_path(path)
+      return [path] if File.file?(path)
+      return Dir.glob(File.join(path, "**", "*.rb"), File::FNM_EXTGLOB) if File.directory?(path)
+
+      Dir.glob(path, File::FNM_EXTGLOB)
+    end
+
+    def clean_path(path)
+      return path unless path.include?("/./") || path.include?("/../") || path.include?("//")
+
+      Pathname.new(path).cleanpath.to_s
+    end
+
+    def excluded?(path)
+      normalized = path.delete_prefix("./")
+      @config.exclude_patterns.any? do |pattern|
+        matches_pattern?(pattern, normalized)
+      end
+    end
+
+    def matches_pattern?(pattern, path)
+      flags = File::FNM_PATHNAME | File::FNM_EXTGLOB
+      return File.fnmatch?(pattern, path, flags) if Pathname.new(pattern).absolute?
+
+      File.fnmatch?(pattern, path, flags) || File.fnmatch?("**/#{pattern}", path.delete_prefix("/"), flags)
+    end
+
+    def load_cached(files, use_cache:)
+      return [[], files] unless use_cache
+
+      cached = []
+      pending = []
+      files.each do |path|
+        offenses = cache.fetch(path)
+        if offenses
+          cached << Worker::FileResult.new(
+            path: path, offenses: offenses, corrected: false, diff: nil, warnings: [], error: nil,
+            content_digest: nil, fingerprint: nil
+          )
+        else
+          pending << path
+        end
+      rescue StandardError
+        pending << path
+      end
+      [cached, pending]
+    end
+
+    def execute(files, fix:, unsafe:, dry_run:)
+      count = worker_count(files)
+      return serial(files, fix: fix, unsafe: unsafe, dry_run: dry_run) if count == 1
+
+      ParallelExecutor.new(config: @config, registry: @registry, count: count).call(
+        files, fix: fix, unsafe: unsafe, dry_run: dry_run
+      )
+    end
+
+    def worker_count(files)
+      return explicit_worker_count(files.length) unless @parallel.nil?
+
+      automatic_worker_count(files)
+    end
+
+    def explicit_worker_count(file_count)
+      return 1 if @parallel == false || file_count < 2
+
+      requested = [Integer(@parallel), 1].max
+
+      [requested, file_count].min
+    end
+
+    def automatic_worker_count(files)
+      return 1 if files.length < 2
+
+      workload_bytes = files.sum { |path| file_size(path) }
+      return 1 if workload_bytes <= AUTO_PARALLEL_MIN_BYTES
+
+      scaled_count = Math.sqrt(workload_bytes.fdiv(AUTO_WORKER_SCALE_BYTES)).ceil
+      available_count = [Etc.nprocessors, 1].max
+
+      [scaled_count, available_count, files.length].min
+    end
+
+    def file_size(path)
+      File.size(path)
+    rescue SystemCallError, ArgumentError
+      0
+    end
+
+    def serial(files, **options)
+      worker = Worker.new(config: @config, registry: @registry)
+      files.map { |path| worker.call(path, **options) }
+    end
+
+    def store_results(results)
+      results.each do |result|
+        next if result.error || !result.content_digest || !result.fingerprint
+
+        cache.put(
+          path: result.path,
+          content_digest: result.content_digest,
+          fingerprint: result.fingerprint,
+          offenses: result.offenses
+        )
+      rescue StandardError
+        next
+      end
+    end
+
+    def offense_key(offense)
+      [offense.path, offense.location.start_line, offense.location.start_column, offense.rule_name]
+    end
+
+    def cache
+      @cache ||= build_cache
+    end
+
+    def build_cache
+      require_relative "cache"
+      Cache.new(
+        config: @config,
+        registry: @registry,
+        directory: @cache_dir || Cache.default_directory
+      )
+    end
+  end
+end

data/lib/lumin/source_snapshot.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lumin
+  SourceSnapshot = Data.define(:source, :fingerprint) do
+    class ChangedError < StandardError; end
+
+    def self.read(path)
+      File.open(path, "rb") do |file|
+        before = fingerprint(file.stat)
+        source = file.read
+        after = fingerprint(file.stat)
+        raise ChangedError, "#{path} changed while it was being read" unless before == after
+
+        new(source: source, fingerprint: after)
+      end
+    end
+
+    def self.fingerprint(path_or_stat)
+      stat = path_or_stat.is_a?(File::Stat) ? path_or_stat : File.stat(path_or_stat)
+      [
+        stat.size,
+        stat.mtime.to_i,
+        stat.mtime.nsec,
+        stat.ctime.to_i,
+        stat.ctime.nsec,
+        stat.ino
+      ].freeze
+    end
+  end
+end

data/lib/lumin/version.rb

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

data/lib/lumin/worker.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "offense"
+require_relative "registry"
+require_relative "source_snapshot"
+
+module Lumin
+  class Worker
+    FileResult = Data.define(
+      :path, :offenses, :corrected, :diff, :warnings, :error, :content_digest, :fingerprint
+    )
+
+    attr_reader :config
+
+    def initialize(config:, registry: Registry)
+      @config = config
+      @registry = registry
+      @rules = build_rules
+      @dispatcher = build_dispatcher
+    end
+
+    def call(path, fix: false, unsafe: false, dry_run: false)
+      if fix
+        require_relative "autocorrector"
+        result = Autocorrector.new(self).call(path, unsafe: unsafe, dry_run: dry_run)
+        return FileResult.new(
+          path: path,
+          offenses: result.offenses,
+          corrected: result.corrected,
+          diff: result.diff,
+          warnings: result.warnings,
+          error: nil,
+          content_digest: result.content_digest,
+          fingerprint: result.fingerprint
+        )
+      end
+
+      snapshot = SourceSnapshot.read(path)
+      source = Astel::SourceFile.from_string(
+        snapshot.source, path: path, version: @config.target_ruby
+      )
+      FileResult.new(
+        path: path,
+        offenses: lint_source(source),
+        corrected: false,
+        diff: nil,
+        warnings: [],
+        error: nil,
+        content_digest: Digest::SHA256.hexdigest(snapshot.source),
+        fingerprint: snapshot.fingerprint
+      )
+    rescue StandardError => error
+      FileResult.new(
+        path: path,
+        offenses: [],
+        corrected: false,
+        diff: nil,
+        warnings: [],
+        error: "#{error.class}: #{error.message}",
+        content_digest: nil,
+        fingerprint: nil
+      )
+    end
+
+    def lint_source(source)
+      return syntax_offenses(source) unless source.valid?
+
+      @rules.each { |rule| rule.begin_source(source) }
+      @dispatcher.run(source.ast)
+      @rules.flat_map(&:offenses)
+    end
+
+    private
+
+    def build_rules
+      @config.enabled_rules(@registry).map do |_name, rule_class, settings|
+        rule_class.new(settings.reject { |key, _value| key == :enabled })
+      end
+    end
+
+    def build_dispatcher
+      dispatcher = Astel::Dispatcher.new
+      @rules.each do |rule|
+        rule.class.subscriptions.map(&:first).uniq.each do |node_type|
+          dispatcher.on(node_type) { |node| rule.dispatch(node_type, node) }
+        end
+      end
+      dispatcher
+    end
+
+    def syntax_offenses(source)
+      source.errors.map do |error|
+        Offense.new(
+          path: source.path,
+          location: error.location,
+          rule_name: "Lint/Syntax",
+          message: error.message
+        )
+      end
+    end
+  end
+end

data/lib/lumin.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lumin/version"
+require_relative "lumin/error"
+
+module Lumin
+  autoload :Offense, File.expand_path("lumin/offense", __dir__)
+  autoload :Registry, File.expand_path("lumin/registry", __dir__)
+  autoload :Rule, File.expand_path("lumin/rule", __dir__)
+  autoload :Config, File.expand_path("lumin/config", __dir__)
+  autoload :SourceSnapshot, File.expand_path("lumin/source_snapshot", __dir__)
+  autoload :CacheManifest, File.expand_path("lumin/cache_manifest", __dir__)
+  autoload :Cache, File.expand_path("lumin/cache", __dir__)
+  autoload :Autocorrector, File.expand_path("lumin/autocorrector", __dir__)
+  autoload :Worker, File.expand_path("lumin/worker", __dir__)
+  autoload :ParallelExecutor, File.expand_path("lumin/parallel_executor", __dir__)
+  autoload :Runner, File.expand_path("lumin/runner", __dir__)
+  autoload :CLI, File.expand_path("lumin/cli", __dir__)
+
+  module Formatters
+    autoload :Text, File.expand_path("lumin/formatters/text", __dir__)
+    autoload :Json, File.expand_path("lumin/formatters/json", __dir__)
+    autoload :Github, File.expand_path("lumin/formatters/github", __dir__)
+  end
+
+  module Rules
+    module Style
+      autoload :FrozenStringLiteral, File.expand_path("lumin/rules/style/frozen_string_literal", __dir__)
+      autoload :LineLength, File.expand_path("lumin/rules/style/line_length", __dir__)
+    end
+
+    module Lint
+      autoload :NoMethodMissing, File.expand_path("lumin/rules/lint/no_method_missing", __dir__)
+    end
+  end
+
+  def self.register_plugin(namespace)
+    Registry.register_namespace(namespace)
+  end
+end