///|
pub(all) enum CliCommand {
Help
Version
Inspect
Facts
Validate
Calc
Diff
} derive(Eq, @debug.Debug)
///|
pub(all) struct CliInvocation {
command : CliCommand
args : Array[String]
json : Bool
csv : Bool
help : Bool
} derive(Eq, @debug.Debug)
///|
pub(all) enum CliError {
UnknownCommand(String)
UnknownOption(String)
MissingArgument(String)
} derive(Eq, @debug.Debug)
///|
pub impl Show for CliError with fn output(self, logger) {
match self {
UnknownCommand(name) =>
logger.write_string("unknown command '" + name + "'")
UnknownOption(name) => logger.write_string("unknown option '" + name + "'")
MissingArgument(name) =>
logger.write_string("missing argument for '" + name + "'")
}
}
///|
pub(all) struct CliResult {
exit_code : Int32
stdout : String
stderr : String
} derive(Eq, @debug.Debug)
///|
pub fn CliResult::success(stdout : String) -> CliResult {
{ exit_code: 0, stdout, stderr: "", }
}
///|
pub fn CliResult::failure(code : Int32, stderr : String) -> CliResult {
{ exit_code: code, stdout: "", stderr, }
}
///|
pub fn cli_help_text() -> String {
(
$|XBRLens - auditable XBRL parsing and validation
$|
$|Usage:
$| xbrlens inspect
$| xbrlens facts [--csv]
$| xbrlens validate
$| xbrlens calc
$| xbrlens diff
$| xbrlens version
$|
$|Global options:
$| --json Emit machine-readable output where supported
$| --csv Emit CSV for the facts command
$| --help, -h Show help
)
}
///|
pub fn parse_invocation(
args : ArrayView[String],
) -> Result[CliInvocation, CliError] {
let positional : Array[String] = []
let mut json = false
let mut csv = false
let mut help = false
for arg in args {
match arg {
"--json" => json = true
"--csv" => csv = true
"--help" | "-h" => help = true
_ =>
if arg.has_prefix("-") {
return Err(UnknownOption(arg))
} else {
positional.push(arg)
}
}
}
if positional.is_empty() {
return Ok({ command: Help, args: [], json, csv, help, })
}
let command_name = positional[0]
let command = match command_name {
"help" => Help
"version" => Version
"inspect" => Inspect
"facts" => Facts
"validate" => Validate
"calc" => Calc
"diff" => Diff
_ => return Err(UnknownCommand(command_name))
}
let rest : Array[String] = []
for index in 1.. Result[Unit, CliError] {
if invocation.args.length() < count {
Err(MissingArgument(description))
} else {
Ok(())
}
}
///|
fn strict_instance(source : String) -> Result[XbrlInstance, XbrlError] {
parse_instance_xml(source, XbrlLimits::strict())
}
///|
fn run_inspect(invocation : CliInvocation) -> CliResult {
match require_cli_args(invocation, 1, "instance XML") {
Ok(_) => ()
Err(err) => return CliResult::failure(2, "xbrlens: " + err.to_string())
}
let instance = match strict_instance(invocation.args[0]) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
if invocation.json {
CliResult::success(
"{\"contexts\":" +
instance.contexts.length().to_string() +
",\"units\":" +
instance.units.length().to_string() +
",\"facts\":" +
instance.facts.length().to_string() +
",\"schemaRefs\":" +
instance.schema_refs.length().to_string() +
"}",
)
} else {
CliResult::success(
(
$|contexts: \{instance.contexts.length()}
$|units: \{instance.units.length()}
$|facts: \{instance.facts.length()}
$|schema_refs: \{instance.schema_refs.length()}
),
)
}
}
///|
fn run_facts(invocation : CliInvocation) -> CliResult {
match require_cli_args(invocation, 1, "instance XML") {
Ok(_) => ()
Err(err) => return CliResult::failure(2, "xbrlens: " + err.to_string())
}
let instance = match strict_instance(invocation.args[0]) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let output = if invocation.csv {
export_csv(instance)
} else {
export_json(instance)
}
match output {
Ok(value) => CliResult::success(value)
Err(err) => CliResult::failure(1, err.to_string())
}
}
///|
fn diagnostic_kind_name(kind : FactDiagnosticKind) -> String {
match kind {
ExactDuplicate => "exact-duplicate"
ConflictingDuplicate => "conflicting-duplicate"
NilConflict => "nil-conflict"
MultipleUnits => "multiple-units"
DecimalsPrecisionConflict => "decimals-precision-conflict"
InvalidDecimals => "invalid-decimals"
InvalidPrecision => "invalid-precision"
}
}
///|
fn run_validate(invocation : CliInvocation) -> CliResult {
match require_cli_args(invocation, 1, "instance XML") {
Ok(_) => ()
Err(err) => return CliResult::failure(2, "xbrlens: " + err.to_string())
}
let instance = match strict_instance(invocation.args[0]) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let report = instance.fact_integrity()
if invocation.json {
let builder = StringBuilder()
builder.write_string("{\"valid\":")
builder.write_string(if report.has_errors() { "false" } else { "true" })
builder.write_string(",\"errors\":")
builder.write_string(report.error_count().to_string())
builder.write_string(",\"warnings\":")
builder.write_string(report.warning_count().to_string())
builder.write_string(",\"diagnostics\":[")
let mut index = 0
while index < report.diagnostics.length() {
if index > 0 {
builder.write_char(',')
}
let diagnostic = report.diagnostics[index]
builder.write_string("{\"kind\":")
builder.write_string(json_quote(diagnostic_kind_name(diagnostic.kind)))
builder.write_string(",\"severity\":")
builder.write_string(
json_quote(
if diagnostic.severity == Error {
"error"
} else {
"warning"
},
),
)
builder.write_string(",\"message\":")
builder.write_string(json_quote(diagnostic.message))
builder.write_char('}')
index += 1
}
builder.write_string("]}")
CliResult::success(builder.to_string())
} else {
let builder = StringBuilder()
builder.write_string("errors: " + report.error_count().to_string() + "\n")
builder.write_string("warnings: " + report.warning_count().to_string())
for diagnostic in report.diagnostics {
builder.write_string("\n")
builder.write_string(
if diagnostic.severity == Error {
"error: "
} else {
"warning: "
},
)
builder.write_string(diagnostic_kind_name(diagnostic.kind))
builder.write_string(": ")
builder.write_string(diagnostic.message)
}
if report.has_errors() {
CliResult::failure(1, builder.to_string())
} else {
CliResult::success(builder.to_string())
}
}
} ///|
///|
fn run_calc(invocation : CliInvocation) -> CliResult {
match
require_cli_args(
invocation, 3, "instance XML, taxonomy XML, and linkbase XML",
) {
Ok(_) => ()
Err(err) => return CliResult::failure(2, "xbrlens: " + err.to_string())
}
let instance = match strict_instance(invocation.args[0]) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let schema = match
parse_taxonomy_xml(invocation.args[1], XbrlLimits::strict()) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let taxonomy : ResolvedTaxonomy = {
root_location: "inline-taxonomy.xsd",
schemas: [
{ location: "inline-taxonomy.xsd", schema, source: invocation.args[1], },
],
}
let linkbase = match
parse_linkbase_xml(invocation.args[2], XbrlLimits::strict()) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let report = match check_calculations(linkbase, taxonomy, instance) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
if invocation.json {
CliResult::success(
"{\"valid\":" +
(if report.is_valid() { "true" } else { "false" }) +
",\"checks\":" +
report.checks.length().to_string() +
",\"mismatches\":" +
report.mismatches().length().to_string() +
"}",
)
} else {
let builder = StringBuilder()
builder.write_string("checks: " + report.checks.length().to_string())
for check in report.checks {
builder.write_string("\n")
builder.write_string(if check.matched { "ok: " } else { "mismatch: " })
builder.write_string(check.parent.expanded())
builder.write_string(" context=")
builder.write_string(check.context_ref)
builder.write_string(" expected=")
builder.write_string(check.expected.to_canonical_string())
builder.write_string(" actual=")
builder.write_string(check.actual.to_canonical_string())
}
if report.is_valid() {
CliResult::success(builder.to_string())
} else {
CliResult::failure(1, builder.to_string())
}
}
}
///|
fn fact_diff_key(row : FactExportRow) -> String {
let value = match row.canonical_value {
Some(value) => value
None => row.value
}
let unit = match row.unit_ref {
Some(value) => value
None => ""
}
row.concept + "|" + row.context_ref + "|" + unit + "|" + value
}
///|
fn count_fact_key(rows : Array[FactExportRow], key : String) -> Int32 {
let mut count = 0
for row in rows {
if fact_diff_key(row) == key {
count += 1
}
}
count
}
///|
fn difference_count(
left : Array[FactExportRow],
right : Array[FactExportRow],
) -> Int32 {
let seen : Array[String] = []
let mut count = 0
for row in left {
let key = fact_diff_key(row)
let mut already_seen = false
for existing in seen {
if existing == key {
already_seen = true
}
}
if !already_seen {
seen.push(key)
let left_count = count_fact_key(left, key)
let right_count = count_fact_key(right, key)
if left_count > right_count {
count += left_count - right_count
}
}
}
count
}
///|
fn run_diff(invocation : CliInvocation) -> CliResult {
match require_cli_args(invocation, 2, "left and right instance XML") {
Ok(_) => ()
Err(err) => return CliResult::failure(2, "xbrlens: " + err.to_string())
}
let left_instance = match strict_instance(invocation.args[0]) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let right_instance = match strict_instance(invocation.args[1]) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let left = match export_rows(left_instance) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let right = match export_rows(right_instance) {
Ok(value) => value
Err(err) => return CliResult::failure(1, err.to_string())
}
let left_only = difference_count(left, right)
let right_only = difference_count(right, left)
let changed = left_only + right_only
if invocation.json {
CliResult::success(
"{\"leftFacts\":" +
left.length().to_string() +
",\"rightFacts\":" +
right.length().to_string() +
",\"leftOnly\":" +
left_only.to_string() +
",\"rightOnly\":" +
right_only.to_string() +
",\"changed\":" +
changed.to_string() +
"}",
)
} else {
CliResult::success(
"left_facts: " +
left.length().to_string() +
"\nright_facts: " +
right.length().to_string() +
"\nleft_only: " +
left_only.to_string() +
"\nright_only: " +
right_only.to_string() +
"\nchanged: " +
changed.to_string(),
)
}
}
///|
pub fn run(args : ArrayView[String]) -> CliResult {
let invocation = match parse_invocation(args) {
Ok(value) => value
Err(err) =>
return CliResult::failure(
2,
"xbrlens: " + err.to_string() + "\n\n" + cli_help_text(),
)
}
if invocation.help {
return CliResult::success(cli_help_text())
}
match invocation.command {
Help => CliResult::success(cli_help_text())
Version => CliResult::success("xbrlens " + version())
Inspect => run_inspect(invocation)
Facts => run_facts(invocation)
Validate => run_validate(invocation)
Calc => run_calc(invocation)
Diff => run_diff(invocation)
}
}
///|
pub extend CliCommand with Eq::{not_equal, equal}
///|
pub extend CliCommand with @debug.Debug::{to_repr}
///|
pub extend CliInvocation with Eq::{not_equal, equal}
///|
pub extend CliInvocation with @debug.Debug::{to_repr}
///|
pub extend CliError with Eq::{not_equal, equal}
///|
pub extend CliError with @debug.Debug::{to_repr}
///|
pub extend CliError with Show::{to_string, output}
///|
pub extend CliResult with Eq::{not_equal, equal}
///|
pub extend CliResult with @debug.Debug::{to_repr}