spiking on validate

Author: perryqh

Rakefile

@@ -4,4 +4,5 @@ GEMSPEC = Gem::Specification.load('code_ownership.gemspec')
 
 task build: 'pkg:ruby'
 
-task default: %w[env:dev compile spec]
+# task default: %w[env:dev compile spec]
+task default: %w[env:dev compile]

ext/code_ownership/src/lib.rs

@@ -31,11 +31,20 @@ fn for_file(file_path: String) -> Result<Option<Value>, Error> {
     }
 }
 
-// Needed for tests
+fn validate() -> Result<Value, Error> {
+    let run_config = build_run_config();
+    let run_result = runner::validate(&run_config, vec![]);
+    validate_result(&run_result)
+    
+}
+
 fn generate_and_validate() -> Result<Value, Error> {
     let run_config = build_run_config();
     let run_result = runner::generate_and_validate(&run_config, vec![]);
-    dbg!(&run_result);
+    validate_result(&run_result)
+}
+
+fn validate_result(run_result: &runner::RunResult) -> Result<Value, Error> {
     if !run_result.validation_errors.is_empty() {
         Err(Error::new(
             magnus::exception::runtime_error(),
@@ -73,41 +82,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("RustCodeOwners")?;
     module.define_singleton_method("for_file", function!(for_file, 1))?;
     module.define_singleton_method("generate_and_validate", function!(generate_and_validate, 0))?;
+    module.define_singleton_method("validate", function!(validate, 0))?;
 
     Ok(())
 }
-
-#[cfg(test)]
-mod tests {
-    use std::env::set_current_dir;
-
-    use super::*;
-
-    #[test]
-    #[should_panic]
-    fn test_for_file_with_invalid_path() {
-        // panics because not called from a ruby thread
-        let _result = for_file("invalid/path".to_string());
-    }
-
-    #[test]
-    fn test_for_file() {
-        let argv: [*mut c_char; 0] = [];
-        let argv = argv.as_ptr();
-        let mut argc = 1;
-
-        let manifest_dir = env!("CARGO_MANIFEST_DIR");
-        let fixture_path = PathBuf::from(manifest_dir).join("tests/fixtures/valid_project");
-        let _ = set_current_dir(&fixture_path).unwrap();
-
-        unsafe {
-            rb_sys::ruby_sysinit(&mut argc, argv as _);
-            rb_sys::ruby_init();
-
-            init();
-            let result = generate_and_validate();
-            assert!(result.is_ok());
-            rb_sys::ruby_cleanup(0);
-        }
-    }
-}

lib/code_ownership.rb

@@ -14,6 +14,13 @@
 require 'code_ownership/cli'
 require 'code_ownership/configuration'
 
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "code_ownership/#{Regexp.last_match(1)}/code_ownership"
+rescue LoadError
+  require 'code_ownership/code_ownership'
+end
+
 if defined?(Packwerk)
   require 'code_ownership/private/permit_pack_owner_top_level_key'
 end
@@ -95,15 +102,7 @@ def validate!(
     stage_changes: true,
     files: nil
   )
-    Private.load_configuration!
-
-    tracked_file_subset = if files
-                            files.select { |f| Private.file_tracked?(f) }
-                          else
-                            Private.tracked_files
-                          end
-
-    Private.validate!(files: tracked_file_subset, autocorrect: autocorrect, stage_changes: stage_changes)
+    Private.validate!(autocorrect: autocorrect, stage_changes: stage_changes)
   end
 
   # Given a backtrace from either `Exception#backtrace` or `caller`, find the

lib/code_ownership/code_ownership.bundle

@@ -44,22 +44,22 @@ def self.bust_caches!
       @glob_cache = nil
     end
 
-    sig { params(files: T::Array[String], autocorrect: T::Boolean, stage_changes: T::Boolean).void }
-    def self.validate!(files:, autocorrect: true, stage_changes: true)
-      CodeownersFile.update_cache!(files) if CodeownersFile.use_codeowners_cache?
-
-      errors = Validator.all.flat_map do |validator|
-        validator.validation_errors(
-          files: files,
-          autocorrect: autocorrect,
-          stage_changes: stage_changes
-        )
-      end
-
-      if errors.any?
-        errors << 'See https://github.com/rubyatscale/code_ownership#README.md for more details'
-        raise InvalidCodeOwnershipConfigurationError.new(errors.join("\n")) # rubocop:disable Style/RaiseArgs
-      end
+    sig { params(autocorrect: T::Boolean, stage_changes: T::Boolean).void }
+    def self.validate!(autocorrect: true, stage_changes: true)
+      puts 'begin....'
+      result = if autocorrect
+                 # T.let(::RustCodeOwners.generate_and_validate, T.nilable(T::Hash[Symbol, String]))
+                 ::RustCodeOwners.generate_and_validate
+               else
+                 # T.let(::RustCodeOwners.validate, T.nilable(T::Hash[Symbol, String]))
+                 ::RustCodeOwners.validate
+               end
+
+      puts result
+      # if errors.any?
+      # errors << 'See https://github.com/rubyatscale/code_ownership#README.md for more details'
+      # raise InvalidCodeOwnershipConfigurationError.new(errors.join("\n"))
+      # end
     end
 
     # Returns a string version of the relative path to a Rails constant,

lib/code_ownership/private.rb

@@ -1,3 +1,16 @@
 class Hash
-  def to_json; end
+  def to_json(*_args); end
+end
+
+module RustCodeOwners
+  class << self
+    def for_file(file)
+    end
+
+    def generate_and_validate
+    end
+
+    def validate
+    end
+  end
 end