lumin 0.1.0

data/lib/lumin/config/validator.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+require "prism"
+
+module Lumin
+  class Config
+    class Validator
+      def initialize(data, registry)
+        @data = data
+        @registry = registry
+      end
+
+      def validate!
+        validate_top_level
+        validate_rules
+      end
+
+      private
+
+      attr_reader :data, :registry
+
+      def validate_top_level
+        unknown = data.keys - TOP_LEVEL_KEYS
+        raise ConfigError, "unknown configuration key: #{unknown.first}" unless unknown.empty?
+
+        raise ConfigError, "target_ruby must be a string" unless data["target_ruby"].is_a?(String)
+        validate_target_ruby(data["target_ruby"])
+        validate_string_array("include", data["include"])
+        validate_string_array("exclude", data["exclude"])
+        raise ConfigError, "rules must be a mapping" unless data["rules"].is_a?(Hash)
+      end
+
+      def validate_rules
+        data["rules"].each do |name, settings|
+          rule_class = registry.all[name]
+          raise ConfigError, unknown_rule_message(name) unless rule_class
+          raise ConfigError, "configuration for #{name} must be a mapping" unless settings.is_a?(Hash)
+
+          validate_rule_settings(name, settings, rule_class)
+        end
+      end
+
+      def validate_rule_settings(name, settings, rule_class)
+        allowed = RULE_CONTROL_KEYS + rule_class.default_config.keys.map(&:to_s)
+        unknown = settings.keys - allowed
+        raise ConfigError, "unknown setting #{unknown.first} for #{name}" unless unknown.empty?
+
+        settings.each do |key, value|
+          validate_leaf(name, value)
+          validate_control(name, key, value)
+          validate_parameter_type(name, key, value, rule_class)
+        end
+
+        message = rule_class.configuration_error(settings.transform_keys(&:to_sym))
+        raise ConfigError, "#{name} #{message}" if message
+      end
+
+      def validate_target_ruby(value)
+        version = Gem::Version.new(value)
+        raise ConfigError, "target_ruby must be 3.3 or newer" if version < Gem::Version.new("3.3")
+
+        prism_version = value.match?(/\A\d+\.\d+\z/) ? "#{value}.0" : value
+        Prism.parse("", version: prism_version)
+      rescue ArgumentError
+        raise ConfigError, "unsupported target_ruby: #{value.inspect}"
+      end
+
+      def validate_string_array(name, value)
+        valid = value.is_a?(Array) && value.all? { |entry| entry.is_a?(String) }
+        raise ConfigError, "#{name} must be an array of strings" unless valid
+      end
+
+      def validate_leaf(name, value)
+        valid = value.nil? || value.is_a?(String) || value.is_a?(Numeric) ||
+                value == true || value == false ||
+                (value.is_a?(Array) && value.all? { |entry| !entry.is_a?(Hash) && !entry.is_a?(Array) })
+        raise ConfigError, "#{name} settings must contain only scalar values or arrays" unless valid
+      end
+
+      def validate_control(name, key, value)
+        return unless RULE_CONTROL_KEYS.include?(key)
+        return if value == true || value == false
+
+        raise ConfigError, "#{name} #{key} must be true or false"
+      end
+
+      def validate_parameter_type(name, key, value, rule_class)
+        default = rule_class.default_config[key.to_sym]
+        return if default.nil? || RULE_CONTROL_KEYS.include?(key) || compatible_type?(value, default)
+
+        raise ConfigError, "#{name} #{key} must be a #{default.class}"
+      end
+
+      def compatible_type?(value, default)
+        return value == true || value == false if default == true || default == false
+        return value.is_a?(Integer) if default.is_a?(Integer)
+        return value.is_a?(Numeric) if default.is_a?(Numeric)
+
+        value.is_a?(default.class)
+      end
+
+      def unknown_rule_message(name)
+        suggestion = DidYouMean::SpellChecker.new(dictionary: registry.all.keys).correct(name).first
+        suffix = suggestion ? "; did you mean #{suggestion}?" : ""
+        "unknown rule: #{name}#{suffix}"
+      end
+    end
+  end
+end

data/lib/lumin/config.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require_relative "error"
+require_relative "registry"
+
+module Lumin
+  class Config
+    class ConfigError < Error; end
+
+    DEFAULTS = {
+      "target_ruby" => "3.3",
+      "include" => ["**/*.rb"],
+      "exclude" => ["vendor/**/*"],
+      "rules" => {}
+    }.freeze
+    TOP_LEVEL_KEYS = (DEFAULTS.keys + ["inherit_from"]).freeze
+    RULE_CONTROL_KEYS = %w[enabled autocorrect].freeze
+
+    attr_reader :data, :digest, :path
+
+    def self.load(path = ".lumin.yml", registry: Registry)
+      data = File.file?(path) ? Loader.new.load_file(File.expand_path(path)) : DEFAULTS
+      new(data, path: File.expand_path(path), registry: registry)
+    end
+
+    def self.from_hash(data = nil, registry: Registry, **values)
+      data ||= values
+      new(deep_merge(DEFAULTS, stringify_keys(data)), path: nil, registry: registry)
+    end
+
+    def self.deep_merge(base, override)
+      base.merge(override) do |_key, left, right|
+        left.is_a?(Hash) && right.is_a?(Hash) ? deep_merge(left, right) : right
+      end
+    end
+
+    def self.stringify_keys(value)
+      case value
+      when Hash then value.to_h { |key, child| [key.to_s, stringify_keys(child)] }
+      when Array then value.map { |child| stringify_keys(child) }
+      else value
+      end
+    end
+
+    def initialize(data, path:, registry: Registry)
+      @data = self.class.deep_merge(DEFAULTS, self.class.stringify_keys(data))
+      @path = path
+      Validator.new(@data, registry).validate!
+      @data = deep_freeze(@data)
+      @digest = Digest::SHA256.hexdigest(JSON.generate(canonical(@data)))
+    end
+
+    def target_ruby
+      data.fetch("target_ruby")
+    end
+
+    def include_patterns
+      data.fetch("include")
+    end
+
+    def exclude_patterns
+      data.fetch("exclude")
+    end
+
+    def rule_config(name)
+      data.fetch("rules").fetch(name, {}).transform_keys(&:to_sym)
+    end
+
+    def enabled_rules(registry = Registry)
+      registry.all.filter_map do |name, rule_class|
+        settings = rule_config(name)
+        [name, rule_class, settings] unless settings[:enabled] == false
+      end
+    end
+
+    private
+
+    def deep_freeze(value)
+      case value
+      when Hash then value.each { |key, child| key.freeze; deep_freeze(child) }
+      when Array then value.each { |child| deep_freeze(child) }
+      end
+      value.freeze
+    end
+
+    def canonical(value)
+      case value
+      when Hash then value.keys.sort.to_h { |key| [key, canonical(value[key])] }
+      when Array then value.map { |child| canonical(child) }
+      else value
+      end
+    end
+  end
+end
+
+require_relative "config/loader"
+require_relative "config/validator"

data/lib/lumin/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lumin
+  class Error < StandardError; end
+end

data/lib/lumin/formatters/github.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lumin
+  module Formatters
+    class Github
+      def format(offenses)
+        offenses.map do |offense|
+          location = offense.location
+          properties = "file=#{escape_property(offense.path)},line=#{location.start_line}," \
+                       "col=#{location.start_column + 1},title=#{escape_property(offense.rule_name)}"
+          "::error #{properties}::#{escape_data(offense.message)}"
+        end.join("\n")
+      end
+
+      private
+
+      def escape_property(value)
+        escape_data(value).gsub(":", "%3A").gsub(",", "%2C")
+      end
+
+      def escape_data(value)
+        value.to_s.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A")
+      end
+    end
+  end
+end

data/lib/lumin/formatters/json.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lumin
+  module Formatters
+    class Json
+      def format(offenses)
+        JSON.generate(offenses.map { |offense| serialize(offense) })
+      end
+
+      private
+
+      def serialize(offense)
+        location = offense.location
+        {
+          path: offense.path,
+          rule: offense.rule_name,
+          message: offense.message,
+          correctable: offense.correctable?,
+          safe: offense.safe,
+          location: {
+            start_line: location.start_line,
+            start_column: location.start_column,
+            end_line: location.end_line,
+            end_column: location.end_column
+          }
+        }
+      end
+    end
+  end
+end

data/lib/lumin/formatters/text.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lumin
+  module Formatters
+    class Text
+      def format(offenses)
+        @lines_by_path = {}
+        offenses.map { |offense| format_offense(offense) }.join("\n")
+      end
+
+      private
+
+      def format_offense(offense)
+        location = offense.location
+        marker = offense.correctable? ? " [correctable]" : ""
+        heading = "#{offense.path}:#{location.start_line}:#{location.start_column + 1}: " \
+                  "#{offense.rule_name}: #{offense.message}#{marker}"
+        source_line = offense.source_line || source_line_for(offense)
+        return heading unless source_line
+
+        width = [location.end_column - location.start_column, 1].max
+        "#{heading}\n  #{source_line}\n  #{' ' * location.start_column}#{'^' * width}"
+      end
+
+      def source_line_for(offense)
+        lines = @lines_by_path[offense.path] ||= File.readlines(offense.path, chomp: true)
+        lines[offense.location.start_line - 1]
+      rescue SystemCallError, EncodingError
+        nil
+      end
+    end
+  end
+end

data/lib/lumin/offense.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "astel"
+
+module Lumin
+  class Offense
+    attr_reader :path, :location, :rule_name, :message, :safe, :source_line, :correction
+
+    def initialize(path:, location:, rule_name:, message:, correctable: false, safe: true, source_line: nil,
+                   correction: nil)
+      @path = path.to_s.freeze
+      @location = Astel::Location.from(location)
+      @rule_name = rule_name.to_s.freeze
+      @message = message.to_s.freeze
+      @correctable = correctable
+      @safe = safe
+      @source_line = source_line&.freeze
+      @correction = correction
+    end
+
+    def correctable?
+      @correctable
+    end
+
+    def with_path(path)
+      self.class.new(**to_h.merge(path: path))
+    end
+
+    def to_h
+      {
+        path: path,
+        location: location,
+        rule_name: rule_name,
+        message: message,
+        correctable: correctable?,
+        safe: safe,
+        source_line: source_line
+      }
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && to_h == other.to_h
+    end
+    alias eql? ==
+
+    def hash
+      to_h.hash
+    end
+
+    def marshal_dump
+      to_h
+    end
+
+    def marshal_load(attributes)
+      initialize(**attributes)
+    end
+  end
+end

data/lib/lumin/parallel_executor.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "thread"
+require_relative "worker"
+
+module Lumin
+  class ParallelExecutor
+    Assignment = Data.define(:worker, :paths)
+
+    def initialize(config:, registry:, count:, worker_class: Worker)
+      @config = config
+      @registry = registry
+      @count = count
+      @worker_class = worker_class
+    end
+
+    def call(files, **options)
+      if Process.respond_to?(:fork)
+        process_parallel(files, options)
+      else
+        thread_parallel(files, options)
+      end
+    end
+
+    private
+
+    def process_parallel(files, options)
+      workers = []
+      queue = build_jobs(files)
+      active = {}
+      @count.times do
+        worker = spawn_worker(options)
+        workers << worker
+        assign(worker, queue.shift, active)
+      end
+
+      collect_process_results(active, queue, workers, options)
+    ensure
+      workers&.each { |worker| shutdown_worker(worker) }
+    end
+
+    def collect_process_results(active, queue, workers, options)
+      results = []
+      until active.empty?
+        ready, = IO.select(active.keys)
+        ready.each do |reader|
+          assignment = active.fetch(reader)
+          batch = receive_result(reader, assignment)
+          results.concat(batch)
+          if worker_failure?(batch)
+            retire_worker(assignment.worker, reader, active)
+            start_replacement(queue, active, workers, options) unless queue.empty?
+          elsif queue.empty?
+            stop_worker(assignment.worker, reader, active)
+          else
+            assign(assignment.worker, queue.shift, active)
+          end
+        end
+      end
+      results
+    end
+
+    def spawn_worker(options)
+      job_reader, job_writer = IO.pipe
+      result_reader, result_writer = IO.pipe
+      worker = @worker_class.new(config: @config, registry: @registry)
+      pid = fork do
+        job_writer.close
+        result_reader.close
+        run_child(worker, job_reader, result_writer, options)
+      end
+      job_reader.close
+      result_writer.close
+      { pid: pid, job_writer: job_writer, result_reader: result_reader }
+    end
+
+    def run_child(worker, job_reader, result_writer, options)
+      loop do
+        paths = Marshal.load(job_reader)
+        break if paths.nil?
+
+        Marshal.dump(paths.map { |path| worker.call(path, **options) }, result_writer)
+        result_writer.flush
+      end
+      exit! 0
+    rescue EOFError
+      exit! 0
+    rescue StandardError
+      exit! 1
+    end
+
+    def send_job(worker, path)
+      Marshal.dump(path, worker.fetch(:job_writer))
+      worker.fetch(:job_writer).flush
+    end
+
+    def assign(worker, paths, active)
+      send_job(worker, paths)
+      active[worker.fetch(:result_reader)] = Assignment.new(worker: worker, paths: paths)
+    end
+
+    def receive_result(reader, assignment)
+      Marshal.load(reader)
+    rescue EOFError, TypeError => error
+      assignment.paths.map do |path|
+        Worker::FileResult.new(
+          path: path,
+          offenses: [],
+          corrected: false,
+          diff: nil,
+          warnings: [],
+          error: "worker process ended before returning a result (#{error.class})",
+          content_digest: nil,
+          fingerprint: nil
+        )
+      end
+    end
+
+    def start_replacement(queue, active, workers, options)
+      worker = spawn_worker(options)
+      workers << worker
+      assign(worker, queue.shift, active)
+    end
+
+    def worker_failure?(batch)
+      batch.any? && batch.all? { |result| result.error&.start_with?("worker process") }
+    end
+
+    def build_jobs(files)
+      batch_size = [[files.length / (@count * 64), 1].max, 8].min
+      files.each_slice(batch_size).to_a
+    end
+
+    def stop_worker(worker, reader, active)
+      send_job(worker, nil)
+      worker.fetch(:job_writer).close
+      reader.close
+      wait_for(worker)
+      active.delete(reader)
+    end
+
+    def retire_worker(worker, reader, active)
+      worker.fetch(:job_writer).close unless worker.fetch(:job_writer).closed?
+      reader.close unless reader.closed?
+      wait_for(worker)
+      active.delete(reader)
+    end
+
+    def shutdown_worker(worker)
+      return if worker[:waited]
+
+      send_job(worker, nil) unless worker[:job_writer]&.closed?
+    rescue Errno::EPIPE, IOError
+      nil
+    ensure
+      worker[:job_writer]&.close unless worker[:job_writer]&.closed?
+      worker[:result_reader]&.close unless worker[:result_reader]&.closed?
+      wait_for(worker)
+    end
+
+    def wait_for(worker)
+      return if worker[:waited]
+
+      Process.wait(worker.fetch(:pid))
+      worker[:waited] = true
+    rescue Errno::ECHILD
+      worker[:waited] = true
+    end
+
+    def thread_parallel(files, options)
+      queue = Queue.new
+      build_jobs(files).each { |paths| queue << paths }
+      @count.times { queue << nil }
+      results = Queue.new
+      threads = Array.new(@count) do
+        Thread.new do
+          worker = @worker_class.new(config: @config, registry: @registry)
+          while (paths = queue.pop)
+            results << paths.map { |path| worker.call(path, **options) }
+          end
+        end
+      end
+      threads.each(&:join)
+      batches = Array.new(build_jobs(files).length) { results.pop }
+      batches.flatten
+    end
+  end
+end

data/lib/lumin/registry.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "set"
+require "thread"
+require_relative "error"
+
+module Lumin
+  module Registry
+    BUILTIN_RULE_NAMES = %w[
+      Style/FrozenStringLiteral
+      Style/LineLength
+      Lint/NoMethodMissing
+    ].freeze
+
+    class << self
+      def register(rule_class)
+        classes << rule_class unless classes.include?(rule_class)
+        rule_class
+      end
+
+      def all
+        load_builtin_rules
+        ordered_classes.to_h { |rule_class| [name_for(rule_class), rule_class] }.freeze
+      end
+
+      def fetch(name)
+        all.fetch(name)
+      end
+
+      def name_for(rule_class)
+        name = rule_class.name
+        raise Error, "anonymous rule classes cannot be registered" unless name
+
+        name.sub(/\ALumin::Rules::/, "").gsub("::", "/")
+      end
+
+      def register_namespace(namespace, visited = Set.new)
+        return if visited.include?(namespace.object_id)
+
+        visited << namespace.object_id
+        namespace.constants(false).each do |constant|
+          value = namespace.const_get(constant)
+          if value.is_a?(Class) && defined?(Lumin::Rule) && value < Lumin::Rule
+            register(value)
+          elsif value.is_a?(Module)
+            register_namespace(value, visited)
+          end
+        end
+      end
+
+      def reset!
+        load_builtin_rules
+        builtin_mutex.synchronize do
+          @classes = []
+          @builtins_loaded = true
+        end
+      end
+
+      private
+
+      def classes
+        @classes ||= []
+      end
+
+      def ordered_classes
+        builtins, extensions = classes.partition do |rule_class|
+          BUILTIN_RULE_NAMES.include?(name_for(rule_class))
+        end
+        builtins.sort_by! { |rule_class| BUILTIN_RULE_NAMES.index(name_for(rule_class)) }
+        builtins.concat(extensions)
+      end
+
+      def load_builtin_rules
+        return if @builtins_loaded
+
+        builtin_mutex.synchronize do
+          return if @builtins_loaded
+
+          require_relative "rule"
+          require_relative "rules/style/frozen_string_literal"
+          require_relative "rules/style/line_length"
+          require_relative "rules/lint/no_method_missing"
+          @builtins_loaded = true
+        end
+      end
+
+      def builtin_mutex
+        @builtin_mutex ||= Mutex.new
+      end
+    end
+  end
+end