fensu-cli 0.29.2__tar.gz → 0.30.0__tar.gz

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/Cargo.lock

@@ -388,7 +388,7 @@ checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "fensu-cli"
-version = "0.29.2"
+version = "0.30.0"
 dependencies = [
  "cap-fs-ext",
  "cap-std",
@@ -424,9 +424,10 @@ dependencies = [
 
 [[package]]
 name = "fensu-facts"
-version = "0.1.0"
+version = "0.30.0"
 dependencies = [
  "dunce",
+ "get-size2",
  "globset",
  "hex",
  "pyo3",
@@ -440,7 +441,7 @@ dependencies = [
 
 [[package]]
 name = "fensu-native"
-version = "0.1.0"
+version = "0.30.0"
 dependencies = [
  "fensu-facts",
  "flate2",
@@ -458,7 +459,7 @@ dependencies = [
 
 [[package]]
 name = "fensu-policy"
-version = "0.29.2"
+version = "0.30.0"
 dependencies = [
  "command-group",
  "globset",

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/Cargo.toml

@@ -16,6 +16,7 @@ command-group = "=5.0.1"
 dunce = "1.0"
 encoding_rs = "0.8"
 flate2 = { version = "1", default-features = false, features = ["zlib"] }
+get-size2 = { version = "=0.10.1", default-features = false }
 globset = "=0.4.19"
 hex = "0.4"
 ignore = "0.4"
@@ -35,7 +36,7 @@ rusqlite = { version = "0.38", features = ["bundled"] }
 serde_json = { version = "1", features = ["preserve_order"] }
 serde = { version = "1", features = ["derive"] }
 sha2 = "0.10"
-fensu-facts = { path = "crates/fensu-facts", default-features = false }
+fensu-facts = { path = "crates/fensu-facts", version = "0.30.0", default-features = false } # x-release-please-version
 fensu-native = { path = "crates/fensu-native", default-features = false }
 fensu-policy = { path = "crates/fensu-policy" }
 fensu-rust = { path = "crates/fensu-rust" }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fensu-cli
-Version: 0.29.2
+Version: 0.30.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fensu-cli"
-version = "0.29.2" # x-release-please-version
+version = "0.30.0" # x-release-please-version
 edition.workspace = true
 license.workspace = true
 publish = false

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/src/check/_helpers/evaluation.rs

@@ -2,10 +2,10 @@ use std::collections::{HashMap, HashSet};
 use std::path::Path;
 
 use fensu_facts::extension::models::ProgramHandle;
-use fensu_native::rules::main::evaluate_core_rules::evaluate_core_rules;
-use fensu_native::rules::main::plan_core_rule_queries::plan_core_rule_queries;
-use fensu_native::rules::main::plan_execution_owners::plan_execution_owners;
-use fensu_native::rules::models::{NativeExecutionRule, NativeExecutionTarget, NativeRuleContext};
+use fensu_native::evaluate_core_rules;
+use fensu_native::plan_core_rule_queries;
+use fensu_native::plan_execution_owners;
+use fensu_native::{NativeExecutionRule, NativeExecutionTarget, NativeRuleContext};
 use fensu_policy::lifecycle::models::FindingSeverity;
 use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator};
 
@@ -169,11 +169,7 @@ pub(crate) fn evaluate(request: EvaluationRequest<'_>) -> Result<TargetEvaluatio
             .iter()
             .map(|code| (*code).to_owned())
             .collect::<Vec<_>>();
-        for row in fensu_native::rules::main::evaluate_dead_code::evaluate_dead_code(
-            &codes,
-            &dead_code_context,
-            &project,
-        ) {
+        for row in fensu_native::evaluate_dead_code(&codes, &dead_code_context, &project) {
             let metadata = rule_metadata(&row.code)?
                 .ok_or_else(|| format!("Unknown native rule code: {}", row.code))?;
             faults.push(Fault {
@@ -239,10 +235,7 @@ pub(crate) fn evaluate(request: EvaluationRequest<'_>) -> Result<TargetEvaluatio
     })
 }
 
-fn dead_code_context(
-    config: &Config,
-    project_root: &Path,
-) -> fensu_native::rules::models::NativeDeadCodeContext {
+fn dead_code_context(config: &Config, project_root: &Path) -> fensu_native::NativeDeadCodeContext {
     const PYPROJECT_SOURCE: &str = "pyproject";
     if !config.dead_code.enabled {
         return Default::default();
@@ -256,7 +249,7 @@ fn dead_code_context(
     } else {
         "fensu.toml"
     };
-    fensu_native::rules::models::NativeDeadCodeContext {
+    fensu_native::NativeDeadCodeContext {
         enabled: config.dead_code.enabled,
         roots: config
             .dead_code
@@ -946,7 +939,7 @@ pub(crate) fn render_results(
     mut results: Vec<CheckResult>,
     root: &Path,
     color: bool,
-    show_warnings: bool,
+    (show_warnings, incomplete): (bool, bool),
 ) -> (String, i32) {
     let selected = results.iter().map(|result| result.selected).sum::<usize>();
     let excluded = results.iter().map(|result| result.excluded).sum::<usize>();
@@ -1009,6 +1002,7 @@ pub(crate) fn render_results(
         evaluation_summary: summary.as_deref(),
         applied_exceptions,
         threshold_uses: &threshold_uses,
+        incomplete,
     });
     (output, i32::from(!faults.is_empty()))
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/src/check/_helpers/execution.rs

@@ -44,7 +44,8 @@ pub(crate) fn render_check(
     let cacheable = results
         .iter()
         .all(|result| result.cacheable.unwrap_or(true));
-    let (output, exit_code) = render_results(results, &plan.root, plan.color, options.warn);
+    let (output, exit_code) =
+        render_results(results, &plan.root, plan.color, (options.warn, false));
     let mut stderr = String::new();
     stderr.push_str(&freshness(&plan));
     if options.cache_stats {

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/src/check/_helpers/project.rs

@@ -5,7 +5,7 @@ use std::fs;
 use std::path::{Component, Path, PathBuf};
 
 use fensu_facts::extension::models::ProgramHandle;
-use fensu_native::rules::models::{NativeProjectModule, NativeProjectPlane};
+use fensu_native::{NativeProjectModule, NativeProjectPlane};
 use globset::GlobBuilder;
 use serde_json::Value;
 use walkdir::DirEntry;
@@ -215,7 +215,7 @@ fn collect_entrypoint_values<'a>(value: &'a toml::Value, mut values: Vec<&'a str
 
 pub(crate) fn observe(
     root: &Path,
-    plans: &[fensu_native::rules::models::NativeProjectQuery],
+    plans: &[fensu_native::NativeProjectQuery],
     programs: &HashMap<&str, &ProgramHandle>,
     modules: &HashMap<String, &ProgramHandle>,
 ) -> Result<HashMap<String, Vec<String>>, String> {

fensu_cli-0.30.0/crates/fensu-cli/src/check/main/render_check_results.rs

@@ -0,0 +1,19 @@
+//! Render one aggregate set of analyzer check results, marked incomplete when a target could not run.
+
+use std::path::Path;
+
+use crate::check::models::CheckResult;
+
+pub(crate) fn render_check_results(
+    results: Vec<CheckResult>,
+    root: &Path,
+    color: bool,
+    (show_warnings, incomplete): (bool, bool),
+) -> (String, i32) {
+    crate::check::_helpers::evaluation::render_results(
+        results,
+        root,
+        color,
+        (show_warnings, incomplete),
+    )
+}

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/src/command/_helpers/check_partition/execution.rs

@@ -218,7 +218,7 @@ fn structured_check(request: StructuredCheckRequest<'_>) -> CliOutput {
     let (stdout, report_exit_code) = if command_error && results.is_empty() {
         (String::new(), 0)
     } else {
-        render_check_results(results, &root, color, show_warnings)
+        render_check_results(results, &root, color, (show_warnings, command_error))
     };
     let mut stderr = String::new();
     if show_cache_stats {

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/src/configuration/_helpers/parsing.rs

@@ -148,7 +148,7 @@ pub(crate) fn parse_dead_code(
     value: Option<&toml::Value>,
 ) -> Result<crate::models::DeadCodeConfig, String> {
     let value = serde_json::to_value(value).map_err(|error| error.to_string())?;
-    let (enabled, roots) = fensu_native::rules::main::parse_dead_code::parse_dead_code(&value)?;
+    let (enabled, roots) = fensu_native::parse_dead_code(&value)?;
     Ok(crate::models::DeadCodeConfig {
         enabled,
         roots: roots

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/src/reporting/main/report.rs

@@ -14,7 +14,14 @@ pub(crate) fn report(request: ReportRequest<'_>) -> String {
     } else {
         "faults"
     };
-    let mut summary = format!("Found {} {noun}", request.faults.len());
+    let mut summary = if request.incomplete {
+        format!(
+            "Check incomplete: found {} {noun} in the targets that ran",
+            request.faults.len()
+        )
+    } else {
+        format!("Found {} {noun}", request.faults.len())
+    };
     if request.show_warnings {
         let noun = if request.warnings.len() == 1 {
             "warning"
@@ -24,7 +31,7 @@ pub(crate) fn report(request: ReportRequest<'_>) -> String {
         summary.push_str(&format!(" and {} {noun}", request.warnings.len()));
     }
     if request.color {
-        let style = if request.faults.is_empty() {
+        let style = if request.faults.is_empty() && !request.incomplete {
             GREEN
         } else {
             ORANGE

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/src/reporting/models.rs

@@ -14,4 +14,6 @@ pub(crate) struct ReportRequest<'a> {
     pub(crate) evaluation_summary: Option<&'a str>,
     pub(crate) applied_exceptions: usize,
     pub(crate) threshold_uses: &'a [ThresholdUse],
+    /// Whether a target could not run, so the faults cover only the targets that did.
+    pub(crate) incomplete: bool,
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/src/tests/test_render.rs

@@ -44,6 +44,7 @@ fn given_colored_faults_when_rendering_then_uses_historical_orange_styles() {
             evaluation_summary: None,
             applied_exceptions: 0,
             threshold_uses: &[],
+            incomplete: false,
         });
 
         assert_eq!(

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/tests/command/test_check_mixed_targets.rs

@@ -46,3 +46,58 @@ fn given_custom_python_rust_and_web_rules_when_checking_then_native_and_hosted_t
         }
     }
 }
+
+#[test]
+fn given_custom_python_and_rust_targets_without_cargo_when_checking_then_the_summary_says_incomplete(
+) {
+    let test_cases = [crate::test_types::RustMixedTargetUnavailableTestCase {
+        description: "a Rust target that cannot run fails the check, and the summary of the \
+                      Python findings says the check is incomplete",
+        expected_exit_code: 2,
+        expected_error: "FPRSL902 Rust analysis cannot run: cargo not found",
+        expected_summary: "Check incomplete: found 1 fault in the targets that ran",
+    }];
+    for test_case in test_cases {
+        let repository = tempfile::tempdir().expect("temporary repository");
+        write(
+            repository.path().join("Cargo.toml"),
+            "[package]\nname = \"example\"\nversion = \"0.1.0\"\nedition = \"2021\"\n",
+        );
+        write(
+            repository.path().join("src/lib.rs"),
+            "pub fn sum(left: usize, right: usize) -> usize { left + right }\n",
+        );
+        write(
+            repository.path().join("python/value.py"),
+            "def value(item):\n    return item\n",
+        );
+        write(repository.path().join("rules/custom.py"), "import ast\nfrom fensu import Family, Fault, RuleContext, rule\n@rule(code='XMIX001', family=Family.CUSTOM, slug='mixed-python', message='mixed Python')\ndef mixed_python(module: ast.Module, ctx: RuleContext) -> list[Fault]:\n    return []\n");
+        write(repository.path().join("fensu.toml"), "[targets.python]\nanalyzer = \"python\"\nroots = [\"python\"]\ntests = []\ntooling = []\nselect = [\"FFA001\", \"XMIX001\"]\nrule_paths = [\"rules/custom.py\"]\n[targets.rust]\nanalyzer = \"rust\"\nroots = [\"src\"]\ntests = []\ntooling = []\nrule_packs = [\"rust\"]\nselect = [\"FPRSS010\"]\n");
+        let output = std::process::Command::new(env!("CARGO_BIN_EXE_fensu"))
+            .args(["check", "--no-color", "--no-cache"])
+            .current_dir(repository.path())
+            .env("FENSU_PYTHON", crate::helpers::workspace_python())
+            .env("CARGO", "/cargo-does-not-exist/cargo")
+            .env("PATH", "/cargo-does-not-exist")
+            .output()
+            .expect("mixed check runs");
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert_eq!(
+            output.status.code(),
+            Some(test_case.expected_exit_code),
+            "{}: {stdout} {stderr}",
+            test_case.description
+        );
+        assert!(
+            stderr.contains(test_case.expected_error),
+            "{}: {stderr}",
+            test_case.description
+        );
+        assert!(
+            stdout.contains(test_case.expected_summary) && !stdout.contains("Found "),
+            "{}: {stdout}",
+            test_case.description
+        );
+    }
+}

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-cli/tests/command/test_types.rs

@@ -80,6 +80,13 @@ pub(crate) struct RustMixedTargetTestCase {
     pub(crate) expected_codes: &'static [&'static str],
 }
 
+pub(crate) struct RustMixedTargetUnavailableTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) expected_exit_code: i32,
+    pub(crate) expected_error: &'static str,
+    pub(crate) expected_summary: &'static str,
+}
+
 pub(crate) struct RepositoryRuleTestCase {
     pub(crate) description: &'static str,
     pub(crate) expected_exit_code: i32,

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/Cargo.toml

@@ -1,9 +1,14 @@
 [package]
 name = "fensu-facts"
-version = "0.1.0"
+version = "0.30.0" # x-release-please-version
 edition.workspace = true
 license.workspace = true
-publish = false
+publish = true
+description = "Python source facts for Fensu: parsed modules, imports, symbols and file inventory"
+repository = "https://github.com/sqlstack-io/fensu"
+readme = "README.md"
+keywords = ["lint", "architecture", "python", "static-analysis"]
+categories = ["development-tools"]
 rust-version.workspace = true
 
 [lints]
@@ -16,6 +21,8 @@ crate-type = ["rlib"]
 
 [dependencies]
 dunce.workspace = true
+# Not used directly: ruff_python_ast 0.0.4 needs a get-size2 built on compact_str 0.9, and 0.10.2 moved to 0.10.
+get-size2.workspace = true
 globset.workspace = true
 hex.workspace = true
 pyo3 = { workspace = true, optional = true }

fensu_cli-0.30.0/crates/fensu-facts/README.md

@@ -0,0 +1,11 @@
+# fensu-facts
+
+Python source facts for [Fensu](https://github.com/sqlstack-io/fensu): parse a module once into a `ProgramHandle`, then read its fact rows.
+
+```toml
+fensu-facts = { version = "0.30", default-features = false }
+```
+
+`default-features = false` leaves out the Python bindings.
+
+The public API is `ProgramHandle` (built with `ProgramHandle::parse_source(source, major, minor)`), `ParseFailure`, and the row types in `facts`. Modules hidden from the documentation are shared with the rest of Fensu's workspace and may change in any release.

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/extension/models.rs

@@ -83,6 +83,11 @@ pub struct ProgramHandle {
 }
 
 impl ProgramHandle {
+    /// Parse `source` as a Python `major.minor` module.
+    pub fn parse_source(source: &str, major: u8, minor: u8) -> Result<Self, ParseFailure> {
+        Self::parse(source, PythonVersion { major, minor })
+    }
+
     pub(crate) fn parse(source: &str, version: PythonVersion) -> Result<Self, ParseFailure> {
         let parsed = parse_strict(source, version)?;
         Ok(Self {

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/facts/mod.rs

@@ -1,6 +1,8 @@
 //! CPython-shaped fact extraction over the ruff syntax tree.
 
+#[doc(hidden)]
 pub mod _helpers;
+#[doc(hidden)]
 pub mod main;
 pub mod models;
 pub mod types;

fensu_cli-0.30.0/crates/fensu-facts/src/lib.rs

@@ -0,0 +1,22 @@
+//! Python source facts for Fensu: [`ProgramHandle`] parses a module once and serves its fact rows.
+#![forbid(unsafe_code)]
+
+#[doc(hidden)]
+pub mod constants;
+#[doc(hidden)]
+pub mod dead_code;
+#[doc(hidden)]
+pub mod extension;
+pub mod facts;
+#[doc(hidden)]
+pub mod mapping;
+#[doc(hidden)]
+pub mod parsing;
+#[doc(hidden)]
+pub mod positions;
+#[doc(hidden)]
+pub mod snapshot;
+pub(crate) mod syntax;
+
+pub use extension::models::ProgramHandle;
+pub use parsing::models::ParseFailure;

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/breadth_first_from.rs

@@ -1,6 +1,6 @@
 //! Walk breadth first from one node.
 
 use crate::syntax::types::ShapeNode;
-pub fn breadth_first_from(root: ShapeNode<'_>) -> Vec<ShapeNode<'_>> {
+pub(crate) fn breadth_first_from(root: ShapeNode<'_>) -> Vec<ShapeNode<'_>> {
     crate::syntax::_helpers::breadth::breadth_first_from(root)
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/breadth_first_nodes.rs

@@ -3,6 +3,6 @@
 use ruff_python_ast::ModModule;
 
 use crate::syntax::types::ShapeNode;
-pub fn breadth_first_nodes(module: &ModModule) -> Vec<ShapeNode<'_>> {
+pub(crate) fn breadth_first_nodes(module: &ModModule) -> Vec<ShapeNode<'_>> {
     crate::syntax::_helpers::breadth::breadth_first_nodes(module)
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/breadth_first_with_parents.rs

@@ -3,6 +3,8 @@
 use ruff_python_ast::ModModule;
 
 use crate::syntax::types::ShapeNode;
-pub fn breadth_first_with_parents(module: &ModModule) -> (Vec<ShapeNode<'_>>, Vec<Option<usize>>) {
+pub(crate) fn breadth_first_with_parents(
+    module: &ModModule,
+) -> (Vec<ShapeNode<'_>>, Vec<Option<usize>>) {
     crate::syntax::_helpers::breadth::breadth_first_with_parents(module)
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/children.rs

@@ -3,6 +3,6 @@
 use crate::syntax::_helpers::children::ChildOutput;
 use crate::syntax::types::ShapeNode;
 
-pub fn children<'a>(node: &ShapeNode<'a>, out: &mut Vec<ShapeNode<'a>>) {
+pub(crate) fn children<'a>(node: &ShapeNode<'a>, out: &mut Vec<ShapeNode<'a>>) {
     ChildOutput { out }.collect(node);
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/kind_name.rs

@@ -1,6 +1,6 @@
 //! Name the syntax kind of a node.
 
 use crate::syntax::types::ShapeNode;
-pub fn kind_name(node: &ShapeNode<'_>) -> &'static str {
+pub(crate) fn kind_name(node: &ShapeNode<'_>) -> &'static str {
     crate::syntax::_helpers::nodes::kind_name(node)
 }

fensu_cli-0.30.0/crates/fensu-facts/src/syntax/main/mod.rs

@@ -0,0 +1,11 @@
+//! Syntax entries.
+
+pub(crate) mod breadth_first_from;
+pub(crate) mod breadth_first_nodes;
+pub(crate) mod breadth_first_with_parents;
+pub(crate) mod children;
+pub(crate) mod kind_name;
+pub(crate) mod push_clause_orelse;
+pub(crate) mod span;
+pub(crate) mod start_of;
+pub(crate) mod strict_reference_parts;

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/push_clause_orelse.rs

@@ -5,6 +5,6 @@ use ruff_python_ast::ElifElseClause;
 use crate::syntax::_helpers::statement_children::ClauseOutput;
 use crate::syntax::types::ShapeNode;
 
-pub fn push_clause_orelse<'a>(clauses: &'a [ElifElseClause], out: &mut Vec<ShapeNode<'a>>) {
+pub(crate) fn push_clause_orelse<'a>(clauses: &'a [ElifElseClause], out: &mut Vec<ShapeNode<'a>>) {
     ClauseOutput { out }.collect(clauses);
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/span.rs

@@ -3,6 +3,6 @@
 use crate::positions::models::{LineIndex, SourceSpan};
 
 use crate::syntax::types::ShapeNode;
-pub fn span(node: &ShapeNode<'_>, index: &LineIndex, source: &str) -> Option<SourceSpan> {
+pub(crate) fn span(node: &ShapeNode<'_>, index: &LineIndex, source: &str) -> Option<SourceSpan> {
     crate::syntax::_helpers::spans::span(node, index, source)
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/start_of.rs

@@ -3,6 +3,6 @@
 use crate::positions::models::LineIndex;
 
 use crate::syntax::types::ShapeNode;
-pub fn start_of(node: &ShapeNode<'_>, index: &LineIndex, source: &str) -> (u32, u32) {
+pub(crate) fn start_of(node: &ShapeNode<'_>, index: &LineIndex, source: &str) -> (u32, u32) {
     crate::syntax::_helpers::spans::start_of(node, index, source)
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/main/strict_reference_parts.rs

@@ -2,6 +2,6 @@
 
 use ruff_python_ast::Expr;
 
-pub fn strict_reference_parts(expression: &Expr) -> Vec<String> {
+pub(crate) fn strict_reference_parts(expression: &Expr) -> Vec<String> {
     crate::syntax::_helpers::references::strict_reference_parts(expression)
 }

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/mod.rs

@@ -1,5 +1,5 @@
 //! Python syntax primitives shared across fact extraction and call mapping.
 
-pub mod _helpers;
-pub mod main;
-pub mod types;
+pub(crate) mod _helpers;
+pub(crate) mod main;
+pub(crate) mod types;

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-facts/src/syntax/types.rs

@@ -9,7 +9,7 @@ use ruff_text_size::TextRange;
 
 /// One node of the CPython-equivalent syntax tree projected from ruff nodes.
 #[derive(Clone, Copy)]
-pub enum ShapeNode<'a> {
+pub(crate) enum ShapeNode<'a> {
     Module(&'a ModModule),
     Stmt(&'a Stmt),
     IfTail(&'a [ElifElseClause]),

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-native/Cargo.toml

@@ -1,9 +1,14 @@
 [package]
 name = "fensu-native"
-version = "0.1.0"
+version = "0.30.0" # x-release-please-version
 edition.workspace = true
 license.workspace = true
-publish = false
+publish = true
+description = "Fensu's core rule engine and Python rules, usable from Rust without the Python bindings"
+repository = "https://github.com/sqlstack-io/fensu"
+readme = "README.md"
+keywords = ["lint", "architecture", "python", "static-analysis"]
+categories = ["development-tools"]
 rust-version.workspace = true
 
 [lints]
@@ -15,13 +20,13 @@ path = "src/lib.rs"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-flate2.workspace = true
+flate2 = { workspace = true, optional = true }
 globset.workspace = true
 pyo3 = { workspace = true, optional = true }
 rayon.workspace = true
 ruff_python_ast.workspace = true
-rusqlite.workspace = true
-sha2.workspace = true
+rusqlite = { workspace = true, optional = true }
+sha2 = { workspace = true, optional = true }
 serde_json.workspace = true
 fensu-facts = { workspace = true, default-features = false }
 unicode-ident.workspace = true
@@ -29,7 +34,7 @@ unicode-ident.workspace = true
 [features]
 default = ["python"]
 extension-module = ["python", "pyo3/extension-module"]
-python = ["dep:pyo3", "fensu-facts/python"]
+python = ["dep:pyo3", "dep:rusqlite", "dep:flate2", "dep:sha2", "fensu-facts/python"]
 
 [dev-dependencies]
 serde.workspace = true

fensu_cli-0.30.0/crates/fensu-native/README.md

@@ -0,0 +1,26 @@
+# fensu-native
+
+[Fensu](https://github.com/sqlstack-io/fensu)'s Python rule engine: core rules and dead-code analysis over programs parsed by `fensu-facts`.
+
+```toml
+fensu-facts = { version = "0.30", default-features = false }
+fensu-native = { version = "0.30", default-features = false }
+```
+
+`default-features = false` leaves out the Python bindings and the cache, and their SQLite and compression dependencies.
+
+The public API is at the crate root: `evaluate_core_rules`, `evaluate_dead_code`, `parse_dead_code`, `plan_core_rule_queries`, `plan_execution_owners`, `generated_policy_owners`, and their models such as `NativeRuleContext`, `NativeProjectPlane` and `NativeFaultRow`. Rule codes are in `rules::constants`.
+
+```rust
+use fensu_facts::ProgramHandle;
+use fensu_native::{evaluate_core_rules, NativeProjectPlane, NativeRuleContext};
+use fensu_native::rules::constants::PARAMETER_ANNOTATION_CODE;
+
+let program = ProgramHandle::parse_source("def total(items):\n    return items\n", 3, 12)?;
+let faults = evaluate_core_rules(
+    &program,
+    &[PARAMETER_ANNOTATION_CODE.to_owned()],
+    &NativeRuleContext::default(),
+    &NativeProjectPlane::new(Vec::new(), Vec::new()),
+)?;
+```

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-native/src/extension/main/mod.rs

@@ -1,3 +1,3 @@
 //! Extension registration entry modules.
 
-pub mod register_module;
+pub(crate) mod register_module;

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-native/src/extension/main/register_module.rs

@@ -9,7 +9,7 @@ use pyo3::wrap_pyfunction;
 
 /// Register Fensu's private native Python module.
 #[pymodule]
-pub fn _native(module: &Bound<'_, PyModule>) -> PyResult<()> {
+pub(crate) fn _native(module: &Bound<'_, PyModule>) -> PyResult<()> {
     fensu_facts::extension::main::register_module::register_fact_functions(module)?;
     module.add_class::<rule_bindings::NativeExecutionBatch>()?;
     module.add_function(wrap_pyfunction!(

{fensu_cli-0.29.2 → fensu_cli-0.30.0}/crates/fensu-native/src/extension/mod.rs

@@ -2,4 +2,4 @@
 
 pub(crate) mod _helpers;
 pub(crate) mod constants;
-pub mod main;
+pub(crate) mod main;

fensu_cli-0.30.0/crates/fensu-native/src/lib.rs

@@ -0,0 +1,21 @@
+//! Fensu's Python rule engine over `fensu-facts` programs; use it with `default-features = false`.
+#![forbid(unsafe_code)]
+
+#[cfg(feature = "python")]
+pub(crate) mod cache;
+#[cfg(feature = "python")]
+pub(crate) mod extension;
+pub mod rules;
+
+pub use crate::rules::main::evaluate_core_rules::evaluate_core_rules;
+pub use crate::rules::main::evaluate_dead_code::evaluate_dead_code;
+pub use crate::rules::main::generated_policy_owners::generated_policy_owners;
+pub use crate::rules::main::parse_dead_code::parse_dead_code;
+pub use crate::rules::main::plan_core_rule_queries::plan_core_rule_queries;
+pub use crate::rules::main::plan_execution_owners::plan_execution_owners;
+pub use crate::rules::models::{
+    CustomRegistration, NativeDeadCodeContext, NativeExecutionPlan, NativeExecutionRule,
+    NativeExecutionTarget, NativeFaultRow, NativeProjectModule, NativeProjectPlane,
+    NativeProjectQuery, NativeRuleContext,
+};
+pub use crate::rules::types::NativeDeadCodeSettings;