🥮 mooncakes.io

moonbit-license-audit

A MoonBit license metadata auditor with SPDX expression checks.

spdx
license
compliance
audit
moonbit
moon add clbbbb/moonbit-license-audit@0.1.1
Download zip
Author
Version
0.1.1
License
MIT
Repository
Last updated
3 days ago
Downloads
4
README

#moonbit-license-audit

moonbit-license-audit is a small MoonBit library for auditing project license metadata. It checks moon.mod license declarations, source-file SPDX-License-Identifier headers, and SPDX expressions such as MIT OR Apache-2.0 or GPL-2.0-only WITH Classpath-exception-2.0.

#Features

  • extract SPDX license and copyright identifiers from line or block comments, validate them, and flag conflicting declarations
  • audit moon.mod license declarations against README text
  • tokenize and parse SPDX license expressions
  • support AND, OR, parentheses, and WITH exceptions
  • normalize common license and exception identifiers
  • use a compact built-in SPDX-oriented catalog for common open-source project licenses
  • list licenses, exceptions, operators, and expression depth
  • validate identifiers against a compact SPDX-oriented catalog
  • check expressions against allow/deny policies
  • parse simple policy configuration text
  • classify licenses by family and review risk
  • generate license obligation and notice checklists
  • build a source-file license inventory and flag divergence from the package license
  • validate a small hand-written third-party dependency manifest, including malformed records and duplicate fields
  • compare findings with a checked-in audit baseline for CI
  • produce project audit, release checklist, remediation, and evidence reports
  • render text, Markdown, CSV, and tree reports

#Install

moon add clbbbb/moonbit-license-audit@0.1.1

Local development:

moon check
moon test
moon run cmd/main

#Example

let expr = "MIT OR Apache-2.0"
println(normalize(expr))
println(validation_report(expr))
println(policy_report(expr, permissive_policy()))
println(policy_option_report(expr, permissive_policy()))
println(profile_table(expr))
println(scan_report("main.mbt", "// SPDX-License-Identifier: MIT\n"))
println(copyright_report("main.mbt", "// SPDX-FileCopyrightText: 2026 Example Contributors\n"))

SPDX identifiers embedded in ordinary source text are ignored. If a file carries more than one distinct SPDX identifier, the scanner reports a conflict instead of silently choosing one.

Project-level audit:

let moon_mod = "name = \"demo/pkg\"\nlicense = \"MIT\"\nrepository = \"https://example.invalid/demo/pkg\"\nreadme = \"README.mbt.md\"\n"
let readme = "# demo\n\nLicense: MIT\n"
let paths = ["src/a.mbt", "src/b.mbt"]
let sources = [
  "// SPDX-License-Identifier: MIT\n",
  "// SPDX-License-Identifier: Apache-2.0\n",
]
let audit = project_audit(moon_mod, readme, paths, sources, permissive_policy())
println(project_audit_report(audit))
println(remediation_report(audit))

Third-party manifest input is checked before it enters an evidence report. A record needs name, license, and source fields; unknown or repeated keys and non-boolean notice values are reported with line numbers.

let manifest = "name = \"demo-lib\"\nlicense = \"MIT\"\nsource = \"https://example.invalid/demo-lib\"\nnotice = true\n"
println(join_lines(third_party_manifest_errors(manifest)))

#Scope

This library is for engineering checks and metadata tooling. It does not provide legal advice and does not generate SPDX JSON documents. The catalog is compact by design; projects can still use the parser and policy layer while extending identifier coverage later.

#Difference from adjacent work

This project is not a general dependency visualizer, SBOM generator, or package registry scanner. Its boundary is deliberately smaller: parse and normalize license expressions, audit MoonBit project metadata, scan source SPDX headers, validate declared third-party inputs, and produce review-friendly CI evidence.

It also does not aim to be only a standalone SPDX-expression parser. The parser exists so MoonBit projects can run practical license metadata checks around moon.mod, README files, source headers, allow/deny policies, and release review notes.

#Data source

The built-in catalog intentionally covers common library licenses and common exceptions instead of embedding the full SPDX data set. This keeps the package reviewable and makes the project focus on audit behavior rather than a large generated table.

#License

MIT

#
AuditEvidence

source
pub struct AuditEvidence {
  project : ProjectAudit
  third_party_errors : Array[String]
  baseline_new : Array[AuditFinding]
  generated_files : Array[String]
} derive(Eq, 
Debug)

#
AuditFinding

source
pub struct AuditFinding {
  path : String
  kind : String
  detail : String
} derive(Eq, 
Debug)

#
CompatibilityCell

source
pub struct CompatibilityCell {
  left : String
  right : String
  compatible : Bool
  reason : String
} derive(Eq, 
Debug)

#
Diagnostic

source
pub struct Diagnostic {
  severity : String
  message : String
  suggestion : String
} derive(Eq, 
Debug)

#
Expr

source
pub(all) enum Expr {
  License(String)
  LicenseWithException(String, String)
  And(Expr, Expr)
  Or(Expr, Expr)
} derive(Eq, 
Debug)

#
FileRule

source
pub struct FileRule {
  path : String
  kind : String
  should_scan : Bool
  reason : String
} derive(Eq, 
Debug)

#
FixSuggestion

source
pub struct FixSuggestion {
  target : String
  severity : String
  action : String
} derive(Eq, 
Debug)

#
LicenseProfile

source
pub struct LicenseProfile {
  id : String
  family : String
  osi : Bool
  copyleft : Bool
  risk : String
  note : String
} derive(Eq, 
Debug)

#
LicenseUse

source
pub struct LicenseUse {
  path : String
  expression : String
  licenses : Array[String]
  valid : Bool
} derive(Eq, 
Debug)

#
Obligation

source
pub struct Obligation {
  key : String
  title : String
  detail : String
  severity : String
} derive(Eq, 
Debug)

#
ParseResult

source
pub struct ParseResult {
  ok : Bool
  expr : Expr?
  error : String
} derive(Eq, 
Debug)

#
ParseState

source
pub struct ParseState {
  expr : Expr?
  index : Int
  error : String
} derive(Eq, 
Debug)

#
Policy

source
pub struct Policy {
  allowed : Array[String]
  denied : Array[String]
  allow_copyleft : Bool
  require_osi : Bool
} derive(Eq, 
Debug)

#
ProjectAudit

source
pub struct ProjectAudit {
  package_name : String
  package_license : String
  readme_ok : Bool
  source_count : Int
  missing_headers : Int
  invalid_headers : Int
  policy_errors : Array[String]
  warnings : Array[String]
} derive(Eq, 
Debug)

#
ReadmeAudit

source
pub struct ReadmeAudit {
  has_title : Bool
  has_license : Bool
  has_install : Bool
  has_usage : Bool
  has_example : Bool
  mentioned_licenses : Array[String]
} derive(Eq, 
Debug)

#
ReleaseItem

source
pub struct ReleaseItem {
  name : String
  passed : Bool
  detail : String
} derive(Eq, 
Debug)

#
SourceCopyright

source
pub struct SourceCopyright {
  path : String
  entries : Array[String]
  found : Bool
  valid : Bool
  message : String
} derive(Eq, 
Debug)

#
SourceLicense

source
pub struct SourceLicense {
  path : String
  expression : String
  found : Bool
  valid : Bool
  message : String
} derive(Eq, 
Debug)

#
ThirdPartyPackage

source
pub struct ThirdPartyPackage {
  name : String
  license : String
  source : String
  notice : Bool
} derive(Eq, 
Debug)

#
Token

source
pub struct Token {
  kind : TokenKind
  text : String
  offset : Int
} derive(Eq, 
Debug)

#
TokenKind

source
pub(all) enum TokenKind {
  Ident(String)
  AndTok
  OrTok
  WithTok
  LParen
  RParen
} derive(Eq, 
Debug)

#
WorkspaceAudit

source
pub struct WorkspaceAudit {
  project : ProjectAudit
  readme : ReadmeAudit
  inventory : Array[LicenseUse]
  ignored_paths : Array[String]
} derive(Eq, 
Debug)

#
action_for_error

source
fn action_for_error(error : String) -> String

#
add_third_party_if_complete

source
fn add_third_party_if_complete(rows : Array[ThirdPartyPackage], name : String, license : String, source : String, notice : Bool) -> Unit

#
allowed_policy_options

source
fn allowed_policy_options(text : String, policy : Policy) -> Array[String]

#
alternative_texts

source
fn alternative_texts(text : String) -> Array[String]

#
alternatives

source
fn alternatives(expr : Expr) -> Array[Expr]

#
and_expr

source
fn and_expr(left : Expr, right : Expr) -> Expr

#
apache_obligations

source
fn apache_obligations() -> Array[Obligation]

#
ascii_space

source
fn ascii_space(ch : Char) -> Bool

#
audit_baseline_report

source
fn audit_baseline_report(paths : Array[String], sources : Array[String], policy : Policy, baseline_text : String) -> String

#
audit_bundle_report

source
fn audit_bundle_report(audit : ProjectAudit) -> String

#
audit_evidence

source
fn audit_evidence(project : ProjectAudit, packages : Array[ThirdPartyPackage], current_findings : Array[AuditFinding], baseline : Array[AuditFinding], policy : Policy) -> AuditEvidence

#
audit_finding

source
fn audit_finding(path : String, kind : String, detail : String) -> AuditFinding

#
audit_grade

source
fn audit_grade(audit : ProjectAudit) -> String

#
audit_passes

source
fn audit_passes(audit : ProjectAudit) -> Bool

#
audit_project_report

source
fn audit_project_report(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], policy : Policy) -> String

#
audit_readme

source
fn audit_readme(readme : String) -> ReadmeAudit

#
audit_score

source
fn audit_score(audit : ProjectAudit) -> Int

#
audit_workspace_report

source
fn audit_workspace_report(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], policy : Policy) -> String

#
baseline_is_valid

source
fn baseline_is_valid(text : String) -> Bool

#
baseline_markdown

source
fn baseline_markdown(current : Array[AuditFinding], baseline : Array[AuditFinding]) -> String

#
baseline_parse_errors

source
fn baseline_parse_errors(text : String) -> Array[String]

#
baseline_passes

source
fn baseline_passes(current : Array[AuditFinding], baseline : Array[AuditFinding]) -> Bool

#
baseline_report

source
fn baseline_report(current : Array[AuditFinding], baseline : Array[AuditFinding]) -> String

#
bool_word

source
fn bool_word(value : Bool) -> String

#
build_inventory

source
fn build_inventory(paths : Array[String], sources : Array[String]) -> Array[LicenseUse]

#
canonical_exception

source
fn canonical_exception(id : String) -> String

#
canonical_license

source
fn canonical_license(id : String) -> String

#
check_mark

source
fn check_mark(passed : Bool) -> String

#
choice_count

source
fn choice_count(text : String) -> Int

#
ci_annotation

source
fn ci_annotation(evidence : AuditEvidence) -> String

#
ci_should_fail

source
fn ci_should_fail(evidence : AuditEvidence) -> Bool

#
classify_path

source
fn classify_path(path : String) -> FileRule

#
clean_comment_tail

source
fn clean_comment_tail(text : String) -> String

#
collect_manifest_findings

source
fn collect_manifest_findings(moon_mod : String, readme : String, package_license : String, warnings : Array[String], policy_items : Array[String], policy : Policy) -> Unit

#
collect_source_alignment

source
fn collect_source_alignment(results : Array[SourceLicense], package_license : String, warnings : Array[String]) -> Unit

#
collect_source_findings

source
fn collect_source_findings(results : Array[SourceLicense], warnings : Array[String], policy_items : Array[String], policy : Policy) -> Unit

#
combine_policy_options

source
fn combine_policy_options(left : Array[Expr], right : Array[Expr]) -> Array[Expr]

#
comment_text

source
fn comment_text(line : String) -> String?

#
common_license_alias

source
fn common_license_alias(value : String) -> String

#
compatibility_cell

source
fn compatibility_cell(left : String, right : String, compatible : Bool, reason : String) -> CompatibilityCell

#
compatibility_errors

source
fn compatibility_errors(text : String) -> Array[String]

#
compatibility_matrix

source
fn compatibility_matrix(ids : Array[String]) -> Array[CompatibilityCell]

#
compatibility_matrix_report

source
fn compatibility_matrix_report(cells : Array[CompatibilityCell]) -> String

#
compatibility_report

source
fn compatibility_report(text : String) -> String

#
compatibility_summary

source
fn compatibility_summary(cells : Array[CompatibilityCell]) -> String

#
compatible_for_distribution

source
fn compatible_for_distribution(text : String) -> Bool

#
config_pair

source
fn config_pair(line : String) -> (String, String)?

#
contains_exception

source
fn contains_exception(expr : Expr, id : String) -> Bool

#
contains_license

source
fn contains_license(expr : Expr, id : String) -> Bool

#
contains_obligation

source
fn contains_obligation(items : Array[Obligation], key : String) -> Bool

#
contains_public_domain_style

source
fn contains_public_domain_style(expr : Expr) -> Bool

#
contains_string

source
fn contains_string(values : Array[String], value : String) -> Bool

#
contains_strong_copyleft

source
fn contains_strong_copyleft(expr : Expr) -> Bool

#
copyleft_licenses

source
fn copyleft_licenses() -> Array[String]

fn copyright_report(path : String, source : String) -> String

#
count_invalid_headers

source
fn count_invalid_headers(results : Array[SourceLicense]) -> Int

#
count_missing_headers

source
fn count_missing_headers(results : Array[SourceLicense]) -> Int

#
csv_report

source
fn csv_report(text : String) -> String

#
deprecated_exceptions

source
fn deprecated_exceptions() -> Array[String]

#
deprecated_licenses

source
fn deprecated_licenses() -> Array[String]

#
depth

source
fn depth(expr : Expr) -> Int

#
diagnostic

source
fn diagnostic(severity : String, message : String, suggestion : String) -> Diagnostic

#
diagnostics

source
fn diagnostics(text : String) -> Array[Diagnostic]

#
diagnostics_report

source
fn diagnostics_report(text : String) -> String

#
dominant_license

source
fn dominant_license(inventory : Array[LicenseUse]) -> String

#
duplicate_third_party_errors

source
fn duplicate_third_party_errors(packages : Array[ThirdPartyPackage], rows : Array[String]) -> Unit

#
evidence_error_count

source
fn evidence_error_count(evidence : AuditEvidence) -> Int

#
evidence_failures

source
fn evidence_failures(evidence : AuditEvidence) -> Array[String]

#
evidence_file_names

source
fn evidence_file_names() -> Array[String]

#
evidence_for_inputs

source
fn evidence_for_inputs(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], packages_text : String, baseline_text : String, policy : Policy) -> AuditEvidence

#
evidence_inputs_report

source
fn evidence_inputs_report(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], packages_text : String, baseline_text : String, policy : Policy) -> String

#
evidence_markdown

source
fn evidence_markdown(evidence : AuditEvidence) -> String

#
evidence_passes

source
fn evidence_passes(evidence : AuditEvidence) -> Bool

#
evidence_report

source
fn evidence_report(evidence : AuditEvidence) -> String

#
evidence_status

source
fn evidence_status(evidence : AuditEvidence) -> String

#
evidence_summary

source
fn evidence_summary(evidence : AuditEvidence) -> String

#
evidence_warning_count

source
fn evidence_warning_count(evidence : AuditEvidence) -> Int

#
evidence_warnings

source
fn evidence_warnings(evidence : AuditEvidence) -> Array[String]

#
exception_suggestion

source
fn exception_suggestion(id : String) -> String

#
exceptions

source
fn exceptions(expr : Expr) -> Array[String]

#
explain_expression

source
fn explain_expression(text : String) -> String

#
expression_shape

source
fn expression_shape(text : String) -> String

#
expression_shape_expr

source
fn expression_shape_expr(expr : Expr) -> String

#
expression_stats

source
fn expression_stats(text : String) -> String

#
extract_moon_mod_license

source
fn extract_moon_mod_license(text : String) -> String?

#
extract_moon_mod_name

source
fn extract_moon_mod_name(text : String) -> String?

#
extract_quoted_value

source
fn extract_quoted_value(text : String, field : String) -> String?

#
extract_quoted_value_line

source
fn extract_quoted_value_line(line : String, field : String) -> String?

fn extract_spdx_copyright_texts(source : String) -> Array[String]

#
extract_spdx_expression

source
fn extract_spdx_expression(source : String) -> String?

#
extract_spdx_expressions

source
fn extract_spdx_expressions(source : String) -> Array[String]

#
extract_spdx_tag_values

source
fn extract_spdx_tag_values(source : String, marker : String) -> Array[String]

#
fail

source
fn fail(message : String) -> ParseResult

#
file_copyleft_obligations

source
fn file_copyleft_obligations(id : String) -> Array[Obligation]

#
file_rule

source
fn file_rule(path : String, kind : String, should_scan : Bool, reason : String) -> FileRule

#
file_rules_report

source
fn file_rules_report(paths : Array[String]) -> String

#
files_using_license

source
fn files_using_license(inventory : Array[LicenseUse], id : String) -> Array[String]

#
filter_sources_by_rule

source
fn filter_sources_by_rule(paths : Array[String], sources : Array[String]) -> (Array[String], Array[String])

#
finding_in

source
fn finding_in(findings : Array[AuditFinding], target : AuditFinding) -> Bool

#
finding_key

source
fn finding_key(finding : AuditFinding) -> String

#
findings_from_project

source
fn findings_from_project(audit : ProjectAudit) -> Array[AuditFinding]

#
findings_from_sources

source
fn findings_from_sources(paths : Array[String], sources : Array[String], policy : Policy) -> Array[AuditFinding]

#
findings_lines

source
fn findings_lines(findings : Array[AuditFinding]) -> Array[String]

#
first_invalid_spdx_expression

source
fn first_invalid_spdx_expression(expressions : Array[String]) -> String?

#
fix_suggestion

source
fn fix_suggestion(target : String, severity : String, action : String) -> FixSuggestion

#
format

source
fn format(expr : Expr) -> String

#
format_prec

source
fn format_prec(expr : Expr, parent : Int) -> String

#
has_empty_string

source
fn has_empty_string(values : Array[String]) -> Bool

#
highest_risk

source
fn highest_risk(text : String) -> String

#
ignored_paths

source
fn ignored_paths(paths : Array[String]) -> Array[String]

#
ignored_paths_report

source
fn ignored_paths_report(paths : Array[String]) -> String

#
incompatible_pairs

source
fn incompatible_pairs(cells : Array[CompatibilityCell]) -> Array[CompatibilityCell]

#
invalid_spdx_count

source
fn invalid_spdx_count(paths : Array[String], sources : Array[String]) -> Int

#
inventory_compatibility_matrix

source
fn inventory_compatibility_matrix(inventory : Array[LicenseUse]) -> Array[CompatibilityCell]

#
inventory_from_source_results

source
fn inventory_from_source_results(results : Array[SourceLicense]) -> Array[LicenseUse]

#
inventory_licenses

source
fn inventory_licenses(inventory : Array[LicenseUse]) -> Array[String]

#
inventory_markdown

source
fn inventory_markdown(inventory : Array[LicenseUse]) -> String

#
inventory_policy_errors

source
fn inventory_policy_errors(inventory : Array[LicenseUse], policy : Policy) -> Array[String]

#
inventory_policy_report

source
fn inventory_policy_report(inventory : Array[LicenseUse], policy : Policy) -> String

#
inventory_report

source
fn inventory_report(inventory : Array[LicenseUse]) -> String

#
is_bool_config_value

source
fn is_bool_config_value(value : String) -> Bool

#
is_copyleft_license

source
fn is_copyleft_license(id : String) -> Bool

#
is_deprecated_exception

source
fn is_deprecated_exception(id : String) -> Bool

#
is_deprecated_license

source
fn is_deprecated_license(id : String) -> Bool

#
is_known_exception

source
fn is_known_exception(id : String) -> Bool

#
is_known_license

source
fn is_known_license(id : String) -> Bool

#
is_osi_license

source
fn is_osi_license(id : String) -> Bool

#
is_policy_config_key

source
fn is_policy_config_key(key : String) -> Bool

#
is_third_party_field

source
fn is_third_party_field(key : String) -> Bool

#
is_valid

source
fn is_valid(text : String) -> Bool

#
join_lines

source
fn join_lines(values : Array[String]) -> String

#
join_tail

source
fn join_tail(parts : Array[String], start : Int, separator : String) -> String

#
join_with

source
fn join_with(values : Array[String], sep : String) -> String

#
known_exceptions

source
fn known_exceptions() -> Array[String]

#
known_licenses

source
fn known_licenses() -> Array[String]

#
license

source
fn license(id : String) -> Expr

#
license_family

source
fn license_family(id : String) -> String

#
license_needs_notice

source
fn license_needs_notice(id : String) -> Bool

#
license_note

source
fn license_note(id : String) -> String

#
license_pair_compatibility

source
fn license_pair_compatibility(left : String, right : String) -> CompatibilityCell

#
license_profile

source
fn license_profile(id : String) -> LicenseProfile

#
license_risk

source
fn license_risk(id : String) -> String

#
license_suggestion

source
fn license_suggestion(id : String) -> String

#
license_use

source
fn license_use(path : String, expression : String, licenses : Array[String], valid : Bool) -> LicenseUse

#
licenses

source
fn licenses(expr : Expr) -> Array[String]

#
lower_ascii

source
fn lower_ascii(text : String) -> String

#
markdown_report

source
fn markdown_report(text : String) -> String

#
max_int

source
fn max_int(a : Int, b : Int) -> Int

#
mentioned_license_ids

source
fn mentioned_license_ids(readme : String) -> Array[String]

#
merge_policy

source
fn merge_policy(base : Policy, extra : Policy) -> Policy

#
min_int

source
fn min_int(a : Int, b : Int) -> Int

fn missing_copyright_count(paths : Array[String], sources : Array[String]) -> Int

#
missing_spdx_count

source
fn missing_spdx_count(paths : Array[String], sources : Array[String]) -> Int

#
mixed_license_warning

source
fn mixed_license_warning(inventory : Array[LicenseUse], package_license : String) -> String

#
moon_mod_has_readme

source
fn moon_mod_has_readme(text : String) -> Bool

#
moon_mod_has_repository

source
fn moon_mod_has_repository(text : String) -> Bool

#
moon_mod_license_report

source
fn moon_mod_license_report(text : String) -> String

#
moon_mod_metadata_report

source
fn moon_mod_metadata_report(text : String) -> String

#
new_findings

source
fn new_findings(current : Array[AuditFinding], baseline : Array[AuditFinding]) -> Array[AuditFinding]

#
normalize

source
fn normalize(text : String) -> String

#
normalize_license_list

source
fn normalize_license_list(items : Array[String]) -> Array[String]

#
notice_checklist

source
fn notice_checklist(text : String) -> Array[String]

#
notice_checklist_report

source
fn notice_checklist_report(text : String) -> String

#
obligation

source
fn obligation(key : String, title : String, detail : String, severity : String) -> Obligation

#
obligations_for_expr

source
fn obligations_for_expr(expr : Expr) -> Array[Obligation]

#
obligations_for_license

source
fn obligations_for_license(id : String) -> Array[Obligation]

#
obligations_report

source
fn obligations_report(text : String) -> String

fn ok(expr : Expr) -> ParseResult

#
operators

source
fn operators(expr : Expr) -> Array[String]

#
option_or

source
fn option_or(value : String?, fallback : String) -> String

#
or_expr

source
fn or_expr(left : Expr, right : Expr) -> Expr

#
osi_approved

source
fn osi_approved() -> Array[String]

#
package_audit_report

source
fn package_audit_report(moon_mod : String, readme : String) -> String

#
parse

source
fn parse(text : String) -> ParseResult

#
parse_and

source
fn parse_and(tokens : Array[Token], start : Int) -> ParseState

#
parse_baseline

source
fn parse_baseline(text : String) -> Array[AuditFinding]

#
parse_baseline_line

source
fn parse_baseline_line(line : String) -> AuditFinding?

#
parse_bool

source
fn parse_bool(text : String) -> Bool

#
parse_license_tail

source
fn parse_license_tail(tokens : Array[Token], index : Int, id : String) -> ParseState

#
parse_or

source
fn parse_or(tokens : Array[Token], start : Int) -> ParseState

#
parse_or_panic

source
fn parse_or_panic(text : String) -> Expr

#
parse_policy_config

source
fn parse_policy_config(text : String) -> Policy

#
parse_primary

source
fn parse_primary(tokens : Array[Token], start : Int) -> ParseState

#
parse_third_party_manifest

source
fn parse_third_party_manifest(text : String) -> Array[ThirdPartyPackage]

#
parse_tree

source
fn parse_tree(text : String) -> String

#
paths_to_scan

source
fn paths_to_scan(paths : Array[String]) -> Array[String]

#
permissive_obligations

source
fn permissive_obligations(id : String) -> Array[Obligation]

#
permissive_policy

source
fn permissive_policy() -> Policy

#
policy_allows

source
fn policy_allows(text : String, policy : Policy) -> Bool

#
policy_config_errors

source
fn policy_config_errors(text : String) -> Array[String]

#
policy_config_report

source
fn policy_config_report(policy : Policy) -> String

#
policy_config_valid

source
fn policy_config_valid(text : String) -> Bool

#
policy_errors

source
fn policy_errors(text : String, policy : Policy) -> Array[String]

#
policy_errors_expr

source
fn policy_errors_expr(expr : Expr, policy : Policy) -> Array[String]

#
policy_errors_license

source
fn policy_errors_license(id : String, policy : Policy) -> Array[String]

#
policy_errors_with_exception

source
fn policy_errors_with_exception(id : String, ex : String, policy : Policy) -> Array[String]

#
policy_from_mode

source
fn policy_from_mode(mode : String) -> Policy

#
policy_option_expressions

source
fn policy_option_expressions(expr : Expr) -> Array[Expr]

#
policy_option_report

source
fn policy_option_report(text : String, policy : Policy) -> String

#
policy_report

source
fn policy_report(text : String, policy : Policy) -> String

#
prefix_errors

source
fn prefix_errors(prefix : String, errors : Array[String]) -> Array[String]

#
profile_row

source
fn profile_row(id : String) -> String

#
profile_table

source
fn profile_table(text : String) -> String

#
project_audit

source
fn project_audit(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], policy : Policy) -> ProjectAudit

#
project_audit_markdown

source
fn project_audit_markdown(audit : ProjectAudit) -> String

#
project_audit_report

source
fn project_audit_report(audit : ProjectAudit) -> String

#
public_domain_style_obligations

source
fn public_domain_style_obligations(id : String) -> Array[Obligation]

#
push_markdown_section

source
fn push_markdown_section(rows : Array[String], title : String, items : Array[String]) -> Unit

#
push_section

source
fn push_section(rows : Array[String], title : String, items : Array[String]) -> Unit

#
quick_fix

source
fn quick_fix(text : String) -> String

#
quoted_prefix

source
fn quoted_prefix(text : String) -> String?

#
readme_audit_report

source
fn readme_audit_report(readme : String) -> String

#
readme_audit_report_from_audit

source
fn readme_audit_report_from_audit(audit : ReadmeAudit) -> String

#
readme_audit_warnings

source
fn readme_audit_warnings(audit : ReadmeAudit) -> Array[String]

#
readme_has_code_block

source
fn readme_has_code_block(readme : String) -> Bool

#
readme_has_license_section

source
fn readme_has_license_section(readme : String) -> Bool

#
readme_has_section

source
fn readme_has_section(readme : String, title : String) -> Bool

#
readme_has_title

source
fn readme_has_title(readme : String) -> Bool

#
readme_matches_package_license

source
fn readme_matches_package_license(readme : String, package_license : String) -> Bool

#
readme_mentions_license

source
fn readme_mentions_license(readme : String, expr : String) -> Bool

#
readme_mentions_license_safe

source
fn readme_mentions_license_safe(readme : String, expr : String) -> Bool

#
release_checklist

source
fn release_checklist(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], policy : Policy) -> Array[ReleaseItem]

#
release_checklist_report

source
fn release_checklist_report(items : Array[ReleaseItem]) -> String

#
release_item

source
fn release_item(name : String, passed : Bool, detail : String) -> ReleaseItem

#
release_ready

source
fn release_ready(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], policy : Policy) -> Bool

#
release_report

source
fn release_report(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], policy : Policy) -> String

#
remediation_markdown

source
fn remediation_markdown(audit : ProjectAudit) -> String

#
remediation_report

source
fn remediation_report(audit : ProjectAudit) -> String

#
requirement_count

source
fn requirement_count(text : String) -> Int

#
requirement_texts

source
fn requirement_texts(text : String) -> Array[String]

#
requirements

source
fn requirements(expr : Expr) -> Array[Expr]

#
resolved_findings

source
fn resolved_findings(current : Array[AuditFinding], baseline : Array[AuditFinding]) -> Array[AuditFinding]

#
review_level

source
fn review_level(text : String) -> String

fn scan_copyright(path : String, source : String) -> SourceCopyright

#
scan_copyrights

source
fn scan_copyrights(paths : Array[String], sources : Array[String]) -> Array[SourceCopyright]

#
scan_report

source
fn scan_report(path : String, source : String) -> String

#
scan_source

source
fn scan_source(path : String, source : String) -> SourceLicense

#
scan_sources

source
fn scan_sources(paths : Array[String], sources : Array[String]) -> Array[SourceLicense]

#
scan_sources_report

source
fn scan_sources_report(paths : Array[String], sources : Array[String]) -> String

#
serialize_baseline

source
fn serialize_baseline(findings : Array[AuditFinding]) -> String

#
severity_for_error

source
fn severity_for_error(error : String) -> String

#
should_scan_path

source
fn should_scan_path(path : String) -> Bool

#
simplify_and

source
fn simplify_and(left : Expr, right : Expr) -> Expr

#
simplify_expr

source
fn simplify_expr(expr : Expr) -> Expr

#
simplify_or

source
fn simplify_or(left : Expr, right : Expr) -> Expr

#
simplify_text

source
fn simplify_text(text : String) -> String

fn source_copyright(path : String, entries : Array[String], found : Bool, valid : Bool, message : String) -> SourceCopyright

#
source_license

source
fn source_license(path : String, expression : String, found : Bool, valid : Bool, message : String) -> SourceLicense

#
spdx_expression_in_comment

source
fn spdx_expression_in_comment(line : String) -> String?

#
spdx_expressions_conflict

source
fn spdx_expressions_conflict(expressions : Array[String]) -> Bool

#
spdx_tag_value_in_comment

source
fn spdx_tag_value_in_comment(line : String, marker : String) -> String?

#
split_char

source
fn split_char(text : String, sep : Char) -> Array[String]

#
split_config_list

source
fn split_config_list(text : String) -> Array[String]

#
state

source
fn state(expr : Expr, index : Int) -> ParseState

#
state_error

source
fn state_error(message : String, index : Int) -> ParseState

#
strict_policy

source
fn strict_policy(allowed : Array[String]) -> Policy

#
strip_config_comment

source
fn strip_config_comment(line : String) -> String

#
strong_copyleft_obligations

source
fn strong_copyleft_obligations(id : String) -> Array[Obligation]

#
suggestion_suffix

source
fn suggestion_suffix(item : Diagnostic) -> String

#
suggestions_for_audit

source
fn suggestions_for_audit(audit : ProjectAudit) -> Array[FixSuggestion]

#
summary

source
fn summary(text : String) -> String

#
text_replace

source
fn text_replace(text : String, from : String, to : String) -> String

#
third_party_by_license

source
fn third_party_by_license(packages : Array[ThirdPartyPackage], license : String) -> Array[ThirdPartyPackage]

#
third_party_count_for_license

source
fn third_party_count_for_license(packages : Array[ThirdPartyPackage], license : String) -> Int

#
third_party_errors

source
fn third_party_errors(packages : Array[ThirdPartyPackage], policy : Policy) -> Array[String]

#
third_party_field

source
fn third_party_field(line : String) -> (String, String)?

#
third_party_invalid_licenses

source
fn third_party_invalid_licenses(packages : Array[ThirdPartyPackage]) -> Array[String]

#
third_party_license_summary

source
fn third_party_license_summary(packages : Array[ThirdPartyPackage]) -> String

#
third_party_licenses

source
fn third_party_licenses(packages : Array[ThirdPartyPackage]) -> Array[String]

#
third_party_manifest_errors

source
fn third_party_manifest_errors(text : String) -> Array[String]

#
third_party_manifest_valid

source
fn third_party_manifest_valid(text : String) -> Bool

#
third_party_markdown

source
fn third_party_markdown(packages : Array[ThirdPartyPackage], policy : Policy) -> String

#
third_party_names

source
fn third_party_names(packages : Array[ThirdPartyPackage]) -> Array[String]

#
third_party_needs_notice

source
fn third_party_needs_notice(item : ThirdPartyPackage) -> Bool

#
third_party_package

source
fn third_party_package(name : String, license : String, source : String, notice : Bool) -> ThirdPartyPackage

#
third_party_package_errors

source
fn third_party_package_errors(item : ThirdPartyPackage, policy : Policy) -> Array[String]

#
third_party_policy_passes

source
fn third_party_policy_passes(packages : Array[ThirdPartyPackage], policy : Policy) -> Bool

#
third_party_record_errors

source
fn third_party_record_errors(line : Int, name : String, license : String, source : String) -> Array[String]

#
third_party_release_ready

source
fn third_party_release_ready(packages : Array[ThirdPartyPackage], policy : Policy) -> Bool

#
third_party_release_report

source
fn third_party_release_report(packages : Array[ThirdPartyPackage], policy : Policy) -> String

#
third_party_report

source
fn third_party_report(packages : Array[ThirdPartyPackage], policy : Policy) -> String

#
third_party_risk_summary

source
fn third_party_risk_summary(packages : Array[ThirdPartyPackage]) -> String

#
third_party_sources_missing

source
fn third_party_sources_missing(packages : Array[ThirdPartyPackage]) -> Array[String]

#
third_party_without_notice

source
fn third_party_without_notice(packages : Array[ThirdPartyPackage]) -> Array[ThirdPartyPackage]

#
token_from_word

source
fn token_from_word(word : String, offset : Int) -> Token

#
tokenize

source
fn tokenize(text : String) -> Array[Token]

#
tokens_report

source
fn tokens_report(text : String) -> String

#
tree

source
fn tree(expr : Expr) -> String

#
trim_ascii

source
fn trim_ascii(text : String) -> String

#
trim_config_value

source
fn trim_config_value(value : String) -> String

#
unchanged_findings

source
fn unchanged_findings(current : Array[AuditFinding], baseline : Array[AuditFinding]) -> Array[AuditFinding]

#
unique_strings

source
fn unique_strings(values : Array[String]) -> Array[String]

#
unknown_exceptions

source
fn unknown_exceptions(text : String) -> Array[String]

#
unknown_licenses

source
fn unknown_licenses(text : String) -> Array[String]

#
upper_ascii

source
fn upper_ascii(text : String) -> String

#
validation_errors

source
fn validation_errors(text : String) -> Array[String]

#
validation_errors_expr

source
fn validation_errors_expr(expr : Expr) -> Array[String]

#
validation_report

source
fn validation_report(text : String) -> String

#
weak_copyleft_obligations

source
fn weak_copyleft_obligations(id : String) -> Array[Obligation]

#
with_exception

source
fn with_exception(id : String, exception : String) -> Expr

#
workspace_audit

source
fn workspace_audit(moon_mod : String, readme : String, paths : Array[String], sources : Array[String], policy : Policy) -> WorkspaceAudit

#
workspace_errors

source
fn workspace_errors(audit : WorkspaceAudit, policy : Policy) -> Array[String]

#
workspace_grade

source
fn workspace_grade(audit : WorkspaceAudit, policy : Policy) -> String

#
workspace_report

source
fn workspace_report(audit : WorkspaceAudit, policy : Policy) -> String

#
workspace_score

source
fn workspace_score(audit : WorkspaceAudit, policy : Policy) -> Int

#
workspace_warnings

source
fn workspace_warnings(audit : WorkspaceAudit) -> Array[String]

#
wrap_if

source
fn wrap_if(cond : Bool, text : String) -> String

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io