recheck 0.0.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8578dce5048ae30dfaf640ab2a34397adb449291a22d2e22183a8f89c6d9c6ea
-  data.tar.gz: 0411c8f0155ac01aba056dee3bb653f50c90f9765f8cbb8b56f961e3f3c89e5b
+  metadata.gz: 4d3abb8f0a8b65c31746964627a98cd5e713f77370797153268465e16a515646
+  data.tar.gz: 767cc703b8a396e486f2350d9f67e39c7d6b572b749dba5e1a9ef48e6394da7c
 SHA512:
-  metadata.gz: 8283f42451ce0ac8d7d8d91c7d5c68e860dfa38a10e34b2dd69068b8dbd0dd2abdf5f6f61f06104b3fb3c3c614179b7688131f38da2167f1da263bef47a8af12
-  data.tar.gz: 773a296cc7d2ba85ec8b265f42936217098d290b02f89ac3c974ee0dcd8f64d95c7af359784f1305073975db0e32c61a6f8e920e48eb2a800b1908420ce4d8c2
+  metadata.gz: 7509ef3cc281c76f022fd1c2599242a4cc5b758f8feb2975de6d70b8fa9756419d45d23740e16487b44b8088506ae8f5a11fc62bf25d77ec38255553d8d044f3
+  data.tar.gz: ec42bd74543f4ea2a8d884528005d3da2a2f302e1a987f16e15631f324d901f5e817da143151116a836a59b0e3c98aa81f438ccf0c67f29038411559a01737cf

data/exe/recheck

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(
+  "#{__dir__}/../lib"
+)
+
+require "recheck"
+Recheck::Cli.new(argv: ARGV).run

data/lib/recheck/checkers.rb

@@ -0,0 +1,33 @@
+module Recheck
+  module Checker
+    class Base
+      class << self
+        def checker_classes
+          @@checker_classes ||= Set.new
+          @@checker_classes
+        end
+
+        def inherited(klass)
+          register klass
+        end
+
+        # Call if you don't want to inherit from Recheck::Checker
+        def register klass
+          checker_classes << klass
+        end
+      end
+
+      # Reflect for a list of queries to run. Override this if you don't want to start all your
+      # query methods with `query` or you are metaprogramming query methods at runtime.
+      def self.query_methods
+        public_instance_methods(false).select { |m| m.to_s.start_with?("query") }
+      end
+
+      # Reflect for a list of checks to run. Override this if you don't want to start all your
+      # check methods with `check` or you are metaprogramming check methods at runtime.
+      def self.check_methods
+        public_instance_methods(false).select { |m| m.to_s.start_with?("check") }
+      end
+    end
+  end
+end

data/lib/recheck/cli.rb

@@ -0,0 +1,47 @@
+module Recheck
+  class Cli
+    EXIT_CODE = {
+      no_errors: 0,     # all checks passed
+      any_errors: 1,    # any check returns fail or threw an exception
+      load_error: 2,    # error loading checker/reporter
+      recheck_error: 3  # recheck itself encountered an error
+    }.freeze
+
+    COMMANDS = {
+      reporters: "List available reporters",
+      run: "Run checks",
+      setup: "Set up a new check suite in the current directory"
+    }.freeze
+
+    def initialize(argv: [])
+      @argv = argv
+    end
+
+    def run
+      global_options = Recheck::Optimist.options(@argv) do
+        version "recheck v#{Recheck::VERSION}"
+
+        banner "Usage:"
+        banner "  recheck [global options] [<command> [options]]"
+
+        banner "\nGlobal options:"
+        opt :version, "Print version and exit", short: :v
+        opt :help, "Print help", short: :h
+        stop_on COMMANDS.keys.map(&:to_s)
+
+        banner "\nCommands:"
+        COMMANDS.each { |c, desc| banner format("  %-10s %s", c, desc) }
+      end
+
+      command = global_options[:_leftovers].shift&.to_sym || :help
+      Recheck::Optimist.die "unknown command '#{command}'" unless COMMANDS.include? command
+
+      Recheck::Command.const_get(command.to_s.split("_").map(&:capitalize).join("")).new(argv: global_options[:_leftovers]).run
+
+      exit EXIT_CODE[:no_errors]
+    rescue Interrupt
+      puts "\nOperation cancelled by user."
+      exit EXIT_CODE[:recheck_error]
+    end
+  end
+end

data/lib/recheck/commands.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "erb"
+
+module Recheck
+  module Command
+    class Reporters
+      def initialize(argv: [])
+        @options = Optimist.options(argv) do
+          banner "recheck list_reporters: load and list reporters"
+          opt :location, "Show source location", short: :l, type: :boolean, default: false
+        end
+      end
+
+      def run
+        puts "Available reporters (add yours to recheck/reporter/):\n"
+        Recheck::Reporter::Base.subclasses.each do |reporter_class|
+          help = reporter_class.respond_to?(:help) ? reporter_class.help : nil
+          help ||= "No help avalable"
+          puts "#{reporter_class.name}   #{help}"
+          puts %(  #{Object.const_source_location(reporter_class.to_s).join(":")}) if @options[:location]
+        end
+      end
+    end # Reporters
+
+    class Run
+      def initialize(argv: [])
+        @options = {
+          reporters: []
+        }
+        @file_patterns = []
+
+        @argv = argv
+        @options = Optimist.options(@argv) do
+          banner "recheck run: run the suite"
+          opt :reporter, "<reporter>[:ARGS], can use multiple times", short: :r, multi: true, default: ["Recheck::Reporter::Default"]
+        end
+        @files_created = []
+
+        @file_patterns = @options[:_leftovers]
+      end
+
+      def run
+        checkers = load_checkers
+        reporters = load_reporters(@options[:reporter])
+
+        total_counts = Runner.new(checkers:, reporters:).run
+      rescue Interrupt
+        puts "\nOperation interrupted by user."
+      rescue => e
+        puts "\nAn error occurred in Recheck:"
+        puts e.full_message(highlight: false)
+        exit Cli::EXIT_CODE[:recheck_error]
+        # ensure
+        #  puts "ensure"
+        #  exit Cli::EXIT_CODE[total_counts&.all_pass? ? :no_errors : :any_errors]
+      end
+
+      def load_checkers
+        files = if @file_patterns.empty?
+          Dir.glob("recheck/**/*.rb").sort
+        else
+          check_missing_files
+          @file_patterns.flat_map do |pattern|
+            if File.directory?(pattern)
+              Dir.glob(File.join(pattern, "**/*.rb"))
+            else
+              Dir.glob(pattern)
+            end
+          end
+        end
+
+        files.each do |file|
+          # bug: if the file has a syntax error, Ruby silently exits instead of raising SyntaxError
+          require File.expand_path(file)
+        rescue LoadError => e
+          puts "Loading #{file} threw an exception: #{e.class}: #{e.message}, #{e.backtrace.first}"
+          unless file.start_with?("recheck/")
+            puts "that filename doesn't start with \"recheck/\", did you give the name of a model instead of its checker?"
+          end
+          exit Cli::EXIT_CODE[:load_error]
+        end
+
+        if Recheck::Checker::Base.checker_classes.empty?
+          error = "No checks detected." +
+            (@file_patterns.empty? ? " Did you run `bundle exec recheck setup`?" : "")
+          warn error
+          exit Cli::EXIT_CODE[:load_error]
+        end
+
+        Recheck::Checker::Base.checker_classes.map(&:new)
+      end
+
+      def check_missing_files
+        missing_files = @file_patterns.reject { |pattern| Dir.glob(pattern).any? }
+        unless missing_files.empty?
+          puts "Error: The following files do not exist:"
+          missing_files.each { |file| puts file }
+          exit Cli::EXIT_CODE[:load_error]
+        end
+      end
+
+      def load_reporters(reporters)
+        reporters.map { |option|
+          class_name, arg = option.split(/(?<!:):(?!:)/, 2)
+          resolve_reporter_class(class_name).new(arg:)
+        }
+      rescue ArgumentError => e
+        puts "Bad argument to Reporter (#{e.backtrace.first}): #{e.message}"
+        exit Cli::EXIT_CODE[:load_error]
+      rescue LoadError => e
+        puts "Loading #{file} threw an exception: #{e.class}: #{e.message}, #{e.backtrace.first}"
+        exit Cli::EXIT_CODE[:load_error]
+      end
+
+      def resolve_reporter_class(reporter_name)
+        [Object, Recheck::Reporter].each do |namespace|
+          return namespace.const_get(reporter_name)
+        rescue NameError
+          next
+        end
+        puts "Error: Reporter class '#{reporter_name}' not found globally or in Recheck::Reporter."
+        exit Cli::EXIT_CODE[:load_error]
+      end
+    end # Run
+
+    class Setup
+      def initialize(argv: [])
+        @argv = argv
+        @options = Optimist.options(@argv) do
+          banner "recheck setup: create a check suite"
+        end
+        @files_created = []
+      end
+
+      def run
+        create_helper
+        create_reporter_dir
+        create_site_checks
+        setup_model_checks
+        run_linter
+        vcs_message
+      end
+
+      def run_linter
+        if (linter_command = detect_linter)
+          puts "Detected linter, running `#{linter_command}` on created files..."
+          system("#{linter_command} #{@files_created.join(" ")}")
+        end
+      end
+
+      def detect_linter
+        return "bundle exec standardrb --fix-unsafely recheck" if File.exist?(".standard.yml") || gemfile_includes?("standard")
+        return "bundle exec rubocop --autocorrect-all recheck" if File.exist?(".rubocop.yml") || gemfile_includes?("rubocop")
+        nil
+      end
+
+      def gemfile_includes?(gem_name)
+        File.readlines("Gemfile").any? { |line| line.include?(gem_name) }
+      rescue Errno::ENOENT
+        false
+      end
+
+      private
+
+      def create_helper
+        copy_template("#{template_dir}/recheck_helper.rb", "recheck/recheck_helper.rb")
+      end
+
+      def create_reporter_dir
+        FileUtils.mkdir_p("recheck/reporter")
+      end
+
+      def create_site_checks
+        Dir.glob("#{template_dir}/site/*.rb").each do |filename|
+          copy_template(filename, "recheck/site/#{File.basename(filename)}")
+        end
+      end
+
+      ModelFile = Data.define(:path, :class_name, :readonly, :pk_info) do
+        def checker_path
+          "recheck/model/#{underscore(class_name.gsub("::", "/"))}_checker.rb"
+        end
+
+        def underscore(string)
+          string.gsub("::", "/")
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr("-", "_")
+            .downcase
+        end
+      end
+
+      # warning: the rails gem overrides this method because it can
+      # provide better checks with the rails env loaded
+      def setup_model_checks
+        puts "Scanning for ActiveRecord models..."
+        model_files.each do |mf|
+          if mf.readonly
+            puts "  #{mf.path} -> Skipped (readonly model, likely a view or uneditable record)"
+          elsif mf.pk_info.nil?
+            puts "  #{mf.path} -> Skipped (model without primary key, unable to report on it)"
+          else
+            FileUtils.mkdir_p(File.dirname(mf.checker_path))
+            File.write(mf.checker_path, model_check_content(mf.class_name, mf.pk_info))
+            @files_created << mf.checker_path
+            puts "  #{mf.path} -> #{mf.checker_path}"
+          end
+        end
+      end
+
+      def model_files
+        search_paths = Dir.glob("**/*.rb").reject { |f| f.start_with?(%r{db/migrate/|vendor/}) }
+        search_paths.map do |path|
+          content = File.read(path)
+          if content.match?(/class\s+\w+(::\w+)*\s+<\s+(ApplicationRecord|ActiveRecord::Base)/) &&
+              !content.match?(/^\s+self\.abstract_class\s*=\s*true/)
+            class_name = extract_class_name(content)
+            readonly = readonly_model?(content)
+            pk_info = extract_primary_key_info(content)
+            ModelFile.new(path, class_name, readonly, pk_info)
+          end
+        end.compact
+      rescue Errno::ENOENT => e
+        puts "Error reading file: #{e.message}"
+        []
+      end
+
+      PrimaryKeyInfo = Data.define(:query_method, :fetch_id_code) do
+        def compound?
+          fetch_id_code.include?(" + ")
+        end
+      end
+
+      def extract_primary_key_info(content)
+        if content.match?(/self\.primary_key\s*=/)
+          pk_definition = content.match(/self\.primary_key\s*=\s*(.+)$/)[1].strip
+          if pk_definition.start_with?("[")
+            keys = parse_array(pk_definition)
+            fetch_id_code = keys.map { |key| "record.#{key}" }.join(' + "-" + ')
+          else
+            key = parse_symbol_or_string(pk_definition)
+            fetch_id_code = "record.#{key}.to_s"
+          end
+          query_method = ".all"
+        elsif content.match?(/self\.primary_key\s*=\s*nil/)
+          return nil
+        else
+          fetch_id_code = "record.id.to_s"
+          query_method = ".find_each"
+        end
+        PrimaryKeyInfo.new(query_method: query_method, fetch_id_code: fetch_id_code)
+      end
+
+      def parse_array(str)
+        str.gsub(/[\[\]]/, "").split(",").map { |item| parse_symbol_or_string(item.strip) }
+      end
+
+      def parse_symbol_or_string(str)
+        if str.start_with?(":")
+          str[1..].to_sym
+        elsif str.start_with?('"', "'")
+          str[1..-2]
+        else
+          str
+        end
+      end
+
+      def active_record_model?(content)
+        content.match?(/class\s+\w+(::\w+)*\s+<\s+(ApplicationRecord|ActiveRecord::Base)/) &&
+          !content.match?(/^\s+self\.abstract_class\s*=\s*true/) &&
+          !readonly_model?(content)
+      end
+
+      def readonly_model?(content)
+        content.match?(/^\s*def\s+readonly\?\s*true\s*end/) ||
+          content.match?(/^\s*def\s+readonly\?\s*$\s*true\s*end/m)
+      end
+
+      def extract_class_name(content)
+        content.match(/class\s+(\w+(::\w+)*)\s+</)[1]
+      end
+
+      def copy_template(from, to)
+        content = File.read(from)
+        FileUtils.mkdir_p(File.dirname(to))
+        File.write(to, content)
+        @files_created << to
+        puts "Created: #{to}"
+      rescue Errno::ENOENT => e
+        puts "Error creating file: #{e.message}"
+      end
+
+      def model_check_content(class_name, pk_info)
+        template = File.read("#{template_dir}/active_record_model_check.rb.erb")
+        ERB.new(template).result(binding)
+      end
+
+      # surely there's a better way to find the gem's root
+      def template_dir
+        File.join(File.expand_path("../..", __dir__), "template")
+      end
+
+      def vcs_message
+        puts
+        puts "Run `git add --all` and `git commit` to checkpoint this setup, then `bundle exec recheck run` to check for the first time."
+      end
+    end # Setup
+  end
+end

data/lib/recheck/count_stats.rb

@@ -0,0 +1,66 @@
+module Recheck
+  class CountStats
+    attr_reader :counts, :queries
+
+    Recheck::RESULT_TYPES.each do |type|
+      define_method(type) do
+        @counts[type]
+      end
+    end
+
+    def initialize
+      @counts = RESULT_TYPES.map { [it, 0] }.to_h
+      @queries = 0
+    end
+
+    def <<(other)
+      @queries += other.queries
+      @counts.merge!(other.counts) { |type, self_v, other_v| self_v + other_v }
+      self
+    end
+
+    def all_pass?
+      @counts.slice(*Recheck::ERROR_TYPES).all? { |type, count| count.zero? }
+    end
+
+    def all_zero?
+      @counts.all? { |type, count| count.zero? }
+    end
+
+    def any_errors?
+      !all_pass?
+    end
+
+    def increment(type)
+      if type == :queries
+        @queries += 1
+      elsif !@counts.include? type
+        raise ArgumentError, "Unkown type #{type}"
+      else
+        @counts[type] += 1
+      end
+    end
+
+    def reached_blanket_failure?
+      pass == 0 && (fail == 20 || exception == 20)
+    end
+
+    def summary
+      "#{queries} #{(queries == 1) ? "query" : "queries"}, " + (
+        [:pass, :fail] +
+        [
+          :exception,
+          :blanket,
+          :no_query_methods,
+          :no_queries,
+          :no_check_methods,
+          :no_checks
+        ].filter { |type| @counts[type].nonzero? }
+      ).map { |type| "#{@counts[type]} #{type}" }.join(", ")
+    end
+
+    def total
+      @counts.values.sum
+    end
+  end
+end