README
- ::to_reprSieveError::to_repr
- ::equalAssessment::equal
- ::not_equalAssessment::not_equal
- ::to_jsonAssessment::to_json
- ::to_reprAssessment::to_repr
- ::equalAudit::equal
- ::not_equalAudit::not_equal
- ::to_jsonAudit::to_json
- ::to_reprAudit::to_repr
- ::equalCapability::equal
- ::not_equalCapability::not_equal
- ::to_jsonCapability::to_json
- ::to_reprCapability::to_repr
- ::equalCapabilityFinding::equal
- ::not_equalCapabilityFinding::not_equal
- ::to_jsonCapabilityFinding::to_json
- ::to_reprCapabilityFinding::to_repr
- ::equalCertainty::equal
- ::not_equalCertainty::not_equal
- ::to_jsonCertainty::to_json
- ::to_reprCertainty::to_repr
- ::equalCheckState::equal
- ::not_equalCheckState::not_equal
- ::to_jsonCheckState::to_json
- ::to_reprCheckState::to_repr
- ::equalCheckedOperation::equal
- ::not_equalCheckedOperation::not_equal
- ::to_jsonCheckedOperation::to_json
- ::to_reprCheckedOperation::to_repr
- ::equalContentTypeIndex::equal
- ::not_equalContentTypeIndex::not_equal
- ::to_jsonContentTypeIndex::to_json
- ::to_reprContentTypeIndex::to_repr
- ::equalContractDisposition::equal
- ::not_equalContractDisposition::not_equal
- ::to_jsonContractDisposition::to_json
- ::to_reprContractDisposition::to_repr
- ::equalCoverage::equal
- ::not_equalCoverage::not_equal
- ::to_jsonCoverage::to_json
- ::to_reprCoverage::to_repr
- ::equalDecision::equal
- ::not_equalDecision::not_equal
- ::to_jsonDecision::to_json
- ::to_reprDecision::to_repr
- ::equalDisposition::equal
- ::not_equalDisposition::not_equal
- ::to_jsonDisposition::to_json
- ::to_reprDisposition::to_repr
- ::equalFinding::equal
- ::not_equalFinding::not_equal
- ::to_jsonFinding::to_json
- ::to_reprFinding::to_repr
- ::equalGraphNode::equal
- ::not_equalGraphNode::not_equal
- ::to_jsonGraphNode::to_json
- ::to_reprGraphNode::to_repr
- ::equalImplicitReference::equal
- ::not_equalImplicitReference::not_equal
- ::to_jsonImplicitReference::to_json
- ::to_reprImplicitReference::to_repr
- ::defaultLimits::default
- ::equalLimits::equal
- ::not_equalLimits::not_equal
- ::to_jsonLimits::to_json
- ::to_reprLimits::to_repr
- ::equalOperation::equal
- ::not_equalOperation::not_equal
- ::to_jsonOperation::to_json
- ::to_reprOperation::to_repr
- ::equalPackageGraph::equal
- ::not_equalPackageGraph::not_equal
- ::to_jsonPackageGraph::to_json
- ::to_reprPackageGraph::to_repr
- ::equalPartRecord::equal
- ::not_equalPartRecord::not_equal
- ::to_jsonPartRecord::to_json
- ::to_reprPartRecord::to_repr
- ::equalPlanOperationKind::equal
- ::not_equalPlanOperationKind::not_equal
- ::to_jsonPlanOperationKind::to_json
- ::to_reprPlanOperationKind::to_repr
- ::equalPolicyAction::equal
- ::not_equalPolicyAction::not_equal
- ::to_jsonPolicyAction::to_json
- ::to_reprPolicyAction::to_repr
- ::equalPolicyDecision::equal
- ::not_equalPolicyDecision::not_equal
- ::to_jsonPolicyDecision::to_json
- ::to_reprPolicyDecision::to_repr
- ::equalPreparedPlan::equal
- ::not_equalPreparedPlan::not_equal
- ::to_jsonPreparedPlan::to_json
- ::to_reprPreparedPlan::to_repr
- ::equalPresence::equal
- ::not_equalPresence::not_equal
- ::to_jsonPresence::to_json
- ::to_reprPresence::to_repr
- ::equalPreservationKind::equal
- ::not_equalPreservationKind::not_equal
- ::to_jsonPreservationKind::to_json
- ::to_reprPreservationKind::to_repr
- ::equalRebuildSupport::equal
- ::not_equalRebuildSupport::not_equal
- ::to_jsonRebuildSupport::to_json
- ::to_reprRebuildSupport::to_repr
T
Rebuilt
- ::equalReceipt::equal
- ::not_equalReceipt::not_equal
- ::to_jsonReceipt::to_json
- ::to_reprReceipt::to_repr
- ::equalRelationship::equal
- ::not_equalRelationship::not_equal
- ::to_jsonRelationship::to_json
- ::to_reprRelationship::to_repr
- ::equalResultStatus::equal
- ::not_equalResultStatus::not_equal
- ::to_jsonResultStatus::to_json
- ::to_reprResultStatus::to_repr
- ::equalRewritePlan::equal
- ::not_equalRewritePlan::not_equal
- ::to_jsonRewritePlan::to_json
- ::to_reprRewritePlan::to_repr
- ::equalRuleCoverage::equal
- ::not_equalRuleCoverage::not_equal
- ::to_jsonRuleCoverage::to_json
- ::to_reprRuleCoverage::to_repr
- ::equalVerificationCheck::equal
- ::not_equalVerificationCheck::not_equal
- ::to_jsonVerificationCheck::to_json
- ::to_reprVerificationCheck::to_repr
T
VerifiedRebuilt
- ::equalVerifiedReceipt::equal
- ::not_equalVerifiedReceipt::not_equal
- ::to_jsonVerifiedReceipt::to_json
- ::to_reprVerifiedReceipt::to_repr
- ::equalXmlReference::equal
- ::not_equalXmlReference::not_equal
- ::to_jsonXmlReference::to_json
- ::to_reprXmlReference::to_repr
V
assess
V
audit
V
digest
V
inspect_graph
V
plan
V
prepare
V
rebuild
V
rebuild_verified
V
rebuild_verified_with_plan
V
rebuild_with_plan
V
resolve_target
V
verify
V
verify_contract

partsieve

OOXML capability audit and verified rebuild; restricted Word and spreadsheet profiles

ooxml

xlsx

docx

vba

audit

verified-rebuild

Download zip

Author

zlhahaha

Version

0.2.0-spike

License

Apache-2.0

Repository

github.com/zlhahaha/partsieve.git

Last updated

14 hours ago

Downloads

Dependencies

#zlhahaha/partsieve

See README.md for the implemented spike, commands, limits, evidence, and unsupported features. The first prototype version is 0.1.0-spike.

SieveError

source

pub(all) suberror SieveError {
  Refused(String)
  Incomplete(String)
  Invalid(String)
} derive(@moonbitlang/core/debug.Debug
Debug)

SieveError::to_repr

source

fn SieveError::to_repr(SieveError) -> @moonbitlang/core/debug.Repr
Repr

Assessment

source

pub(all) struct Assessment {
  schema : String
  input_hash : String?
  findings : Array[CapabilityFinding]
  coverage : Coverage
  decision : Decision
  graph : PackageGraph?
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Assessment::equal

source

fn Assessment::equal(Assessment, Assessment) -> Bool

Assessment::not_equal

source

fn Assessment::not_equal(x : Assessment, y : Assessment) -> Bool

Assessment::to_json

source

fn Assessment::to_json(Assessment) -> Json

Assessment::to_repr

source

fn Assessment::to_repr(Assessment) -> @moonbitlang/core/debug.Repr
Repr

Audit

source

pub(all) struct Audit {
  schema : String
  input_hash : String
  format : String
  main_part : String
  coverage : String
  profile : String
  checked_rules : Array[String]
  limitations : Array[String]
  parts : Array[PartRecord]
  relationships : Array[Relationship]
  findings : Array[Finding]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Audit::equal

source

fn Audit::equal(Audit, Audit) -> Bool

Audit::not_equal

source

fn Audit::not_equal(x : Audit, y : Audit) -> Bool

Audit::to_json

source

fn Audit::to_json(Audit) -> Json

Audit::to_repr

source

fn Audit::to_repr(Audit) -> @moonbitlang/core/debug.Repr
Repr

Capability

source

pub(all) enum Capability {
  Vba
  HttpHyperlink
  RemoteTemplate
  ExternalResource
  ExternalData
  Ole
  ActiveX
  UnknownExternalRelationship
  UnknownPotentiallyActiveExtension
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Capability::equal

source

fn Capability::equal(Capability, Capability) -> Bool

Capability::not_equal

source

fn Capability::not_equal(x : Capability, y : Capability) -> Bool

Capability::to_json

source

fn Capability::to_json(self : Capability) -> Json

Capability::to_repr

source

fn Capability::to_repr(Capability) -> @moonbitlang/core/debug.Repr
Repr

CapabilityFinding

source

pub(all) struct CapabilityFinding {
  rule_id : String
  capability : Capability
  source : String
  part : String
  certainty : Certainty
  rebuild_support : RebuildSupport
  evidence : Array[String]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

CapabilityFinding::equal

source

fn CapabilityFinding::equal(CapabilityFinding, CapabilityFinding) -> Bool

CapabilityFinding::not_equal

source

fn CapabilityFinding::not_equal(x : CapabilityFinding, y : CapabilityFinding) -> Bool

CapabilityFinding::to_json

source

fn CapabilityFinding::to_json(CapabilityFinding) -> Json

CapabilityFinding::to_repr

source

fn CapabilityFinding::to_repr(CapabilityFinding) -> @moonbitlang/core/debug.Repr
Repr

Certainty

source

pub(all) enum Certainty {
  Declared
  Uncertain
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Certainty::equal

source

fn Certainty::equal(Certainty, Certainty) -> Bool

Certainty::not_equal

source

fn Certainty::not_equal(x : Certainty, y : Certainty) -> Bool

Certainty::to_json

source

fn Certainty::to_json(self : Certainty) -> Json

Certainty::to_repr

source

fn Certainty::to_repr(Certainty) -> @moonbitlang/core/debug.Repr
Repr

CheckState

source

pub(all) enum CheckState {
  Checked
  NotChecked
  IncompleteCheck
  Opaque
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

CheckState::equal

source

fn CheckState::equal(CheckState, CheckState) -> Bool

CheckState::not_equal

source

fn CheckState::not_equal(x : CheckState, y : CheckState) -> Bool

CheckState::to_json

source

fn CheckState::to_json(self : CheckState) -> Json

CheckState::to_repr

source

fn CheckState::to_repr(CheckState) -> @moonbitlang/core/debug.Repr
Repr

CheckedOperation

source

pub(all) struct CheckedOperation {
  operation_id : String
  kind : PlanOperationKind
  part : String
  source : String
  relationship_id : String
  rule_id : String
  decision_id : String
  before_hash : String
  expected_after_hash : String?
  depends_on : Array[String]
  reason : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

CheckedOperation::equal

source

fn CheckedOperation::equal(CheckedOperation, CheckedOperation) -> Bool

CheckedOperation::not_equal

source

fn CheckedOperation::not_equal(x : CheckedOperation, y : CheckedOperation) -> Bool

CheckedOperation::to_json

source

fn CheckedOperation::to_json(CheckedOperation) -> Json

CheckedOperation::to_repr

source

fn CheckedOperation::to_repr(CheckedOperation) -> @moonbitlang/core/debug.Repr
Repr

ContentTypeIndex

source

pub(all) struct ContentTypeIndex {
  content_type : String
  parts : Array[String]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

ContentTypeIndex::equal

source

fn ContentTypeIndex::equal(ContentTypeIndex, ContentTypeIndex) -> Bool

ContentTypeIndex::not_equal

source

fn ContentTypeIndex::not_equal(x : ContentTypeIndex, y : ContentTypeIndex) -> Bool

ContentTypeIndex::to_json

source

fn ContentTypeIndex::to_json(ContentTypeIndex) -> Json

ContentTypeIndex::to_repr

source

fn ContentTypeIndex::to_repr(ContentTypeIndex) -> @moonbitlang/core/debug.Repr
Repr

ContractDisposition

source

pub(all) struct ContractDisposition {
  part : String
  classification : PreservationKind
  before_hash : String
  after_hash : String?
  decision_id : String?
  rule_id : String?
  reason : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

ContractDisposition::equal

source

fn ContractDisposition::equal(ContractDisposition, ContractDisposition) -> Bool

ContractDisposition::not_equal

source

fn ContractDisposition::not_equal(x : ContractDisposition, y : ContractDisposition) -> Bool

ContractDisposition::to_json

source

fn ContractDisposition::to_json(ContractDisposition) -> Json

ContractDisposition::to_repr

source

fn ContractDisposition::to_repr(ContractDisposition) -> @moonbitlang/core/debug.Repr
Repr

Coverage

source

pub(all) struct Coverage {
  declared_profile : String
  rules : Array[RuleCoverage]
  checked_rules : Array[String]
  unchecked_features : Array[String]
  parse_complete : Bool
  parse_error : String?
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Coverage::equal

source

fn Coverage::equal(Coverage, Coverage) -> Bool

Coverage::not_equal

source

fn Coverage::not_equal(x : Coverage, y : Coverage) -> Bool

Coverage::to_json

source

fn Coverage::to_json(Coverage) -> Json

Coverage::to_repr

source

fn Coverage::to_repr(Coverage) -> @moonbitlang/core/debug.Repr
Repr

Decision

source

pub(all) struct Decision {
  result : ResultStatus
  rebuild_allowed : Bool
  profile : String
  reason : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Decision::equal

source

fn Decision::equal(Decision, Decision) -> Bool

Decision::not_equal

source

fn Decision::not_equal(x : Decision, y : Decision) -> Bool

Decision::to_json

source

fn Decision::to_json(Decision) -> Json

Decision::to_repr

source

fn Decision::to_repr(Decision) -> @moonbitlang/core/debug.Repr
Repr

Disposition

source

pub(all) struct Disposition {
  part : String
  classification : String
  before_hash : String
  after_hash : String?
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Disposition::equal

source

fn Disposition::equal(Disposition, Disposition) -> Bool

Disposition::not_equal

source

fn Disposition::not_equal(x : Disposition, y : Disposition) -> Bool

Disposition::to_json

source

fn Disposition::to_json(Disposition) -> Json

Disposition::to_repr

source

fn Disposition::to_repr(Disposition) -> @moonbitlang/core/debug.Repr
Repr

Finding

source

pub(all) struct Finding {
  rule : String
  capability : String
  part : String
  evidence : Array[String]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Finding::equal

source

fn Finding::equal(Finding, Finding) -> Bool

Finding::not_equal

source

fn Finding::not_equal(x : Finding, y : Finding) -> Bool

Finding::to_json

source

fn Finding::to_json(Finding) -> Json

Finding::to_repr

source

fn Finding::to_repr(Finding) -> @moonbitlang/core/debug.Repr
Repr

GraphNode

source

pub(all) struct GraphNode {
  part : String
  inbound : Array[Int]
  outbound : Array[Int]
  xml_references : Array[Int]
  reachable : Bool
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

GraphNode::equal

source

fn GraphNode::equal(GraphNode, GraphNode) -> Bool

GraphNode::not_equal

source

fn GraphNode::not_equal(x : GraphNode, y : GraphNode) -> Bool

GraphNode::to_json

source

fn GraphNode::to_json(GraphNode) -> Json

GraphNode::to_repr

source

fn GraphNode::to_repr(GraphNode) -> @moonbitlang/core/debug.Repr
Repr

ImplicitReference

source

pub(all) struct ImplicitReference {
  source : String
  relationship_index : Int
  semantics : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

ImplicitReference::equal

source

fn ImplicitReference::equal(ImplicitReference, ImplicitReference) -> Bool

ImplicitReference::not_equal

source

fn ImplicitReference::not_equal(x : ImplicitReference, y : ImplicitReference) -> Bool

ImplicitReference::to_json

source

fn ImplicitReference::to_json(ImplicitReference) -> Json

ImplicitReference::to_repr

source

fn ImplicitReference::to_repr(ImplicitReference) -> @moonbitlang/core/debug.Repr
Repr

Limits

source

pub(all) struct Limits {
  input_bytes : Int
  entry_bytes : Int
  total_bytes : Int
  entries : Int
  xml_bytes : Int
  xml_depth : Int
  xml_nodes : Int
  xml_attributes : Int
  output_bytes : Int
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Limits::default

source

fn Limits::default() -> Limits

Limits::equal

source

fn Limits::equal(Limits, Limits) -> Bool

Limits::not_equal

source

fn Limits::not_equal(x : Limits, y : Limits) -> Bool

Limits::to_json

source

fn Limits::to_json(Limits) -> Json

Limits::to_repr

source

fn Limits::to_repr(Limits) -> @moonbitlang/core/debug.Repr
Repr

Operation

source

pub(all) struct Operation {
  kind : String
  part : String
  relationship_id : String
  rule : String
  reason : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Operation::equal

source

fn Operation::equal(Operation, Operation) -> Bool

Operation::not_equal

source

fn Operation::not_equal(x : Operation, y : Operation) -> Bool

Operation::to_json

source

fn Operation::to_json(Operation) -> Json

Operation::to_repr

source

fn Operation::to_repr(Operation) -> @moonbitlang/core/debug.Repr
Repr

PackageGraph

source

pub(all) struct PackageGraph {
  schema : String
  root : String
  parts : Array[PartRecord]
  relationships : Array[Relationship]
  xml_references : Array[XmlReference]
  implicit_references : Array[ImplicitReference]
  nodes : Array[GraphNode]
  content_types : Array[ContentTypeIndex]
  reachable : Array[String]
  orphan_candidates : Array[String]
  coverage_gaps : Array[String]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

PackageGraph::equal

source

fn PackageGraph::equal(PackageGraph, PackageGraph) -> Bool

PackageGraph::not_equal

source

fn PackageGraph::not_equal(x : PackageGraph, y : PackageGraph) -> Bool

PackageGraph::to_json

source

fn PackageGraph::to_json(PackageGraph) -> Json

PackageGraph::to_repr

source

fn PackageGraph::to_repr(PackageGraph) -> @moonbitlang/core/debug.Repr
Repr

PartRecord

source

pub(all) struct PartRecord {
  name : String
  content_type : String
  sha256 : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

PartRecord::equal

source

fn PartRecord::equal(PartRecord, PartRecord) -> Bool

PartRecord::not_equal

source

fn PartRecord::not_equal(x : PartRecord, y : PartRecord) -> Bool

PartRecord::to_json

source

fn PartRecord::to_json(PartRecord) -> Json

PartRecord::to_repr

source

fn PartRecord::to_repr(PartRecord) -> @moonbitlang/core/debug.Repr
Repr

PlanOperationKind

source

pub(all) enum PlanOperationKind {
  RemovePart
  RemoveRelationship
  RewriteSourceXml
  RewriteRelationshipPart
  RewriteContentTypes
  ChangeMainContentType
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

PlanOperationKind::equal

source

fn PlanOperationKind::equal(PlanOperationKind, PlanOperationKind) -> Bool

PlanOperationKind::not_equal

source

fn PlanOperationKind::not_equal(x : PlanOperationKind, y : PlanOperationKind) -> Bool

PlanOperationKind::to_json

source

fn PlanOperationKind::to_json(self : PlanOperationKind) -> Json

PlanOperationKind::to_repr

source

fn PlanOperationKind::to_repr(PlanOperationKind) -> @moonbitlang/core/debug.Repr
Repr

PolicyAction

source

pub(all) enum PolicyAction {
  AllowAction
  RemoveAction
  RefuseAction
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

PolicyAction::equal

source

fn PolicyAction::equal(PolicyAction, PolicyAction) -> Bool

PolicyAction::not_equal

source

fn PolicyAction::not_equal(x : PolicyAction, y : PolicyAction) -> Bool

PolicyAction::to_json

source

fn PolicyAction::to_json(self : PolicyAction) -> Json

PolicyAction::to_repr

source

fn PolicyAction::to_repr(PolicyAction) -> @moonbitlang/core/debug.Repr
Repr

PolicyDecision

source

pub(all) struct PolicyDecision {
  decision_id : String
  finding_index : Int?
  action : PolicyAction
  rule_id : String
  part : String
  reason : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

PolicyDecision::equal

source

fn PolicyDecision::equal(PolicyDecision, PolicyDecision) -> Bool

PolicyDecision::not_equal

source

fn PolicyDecision::not_equal(x : PolicyDecision, y : PolicyDecision) -> Bool

PolicyDecision::to_json

source

fn PolicyDecision::to_json(PolicyDecision) -> Json

PolicyDecision::to_repr

source

fn PolicyDecision::to_repr(PolicyDecision) -> @moonbitlang/core/debug.Repr
Repr

PreparedPlan

source

pub(all) struct PreparedPlan {
  schema : String
  tool : String
  rules : String
  input_hash : String
  input_format : String
  output_format : String
  policy : String
  profile : String
  limits : Limits
  preconditions : Array[PartRecord]
  findings : Array[CapabilityFinding]
  decisions : Array[PolicyDecision]
  operations : Array[CheckedOperation]
  controlled_removals : Array[String]
  orphan_candidates : Array[String]
  coverage : Coverage
  gate : Decision
  unavailable_handlers : Array[String]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

PreparedPlan::equal

source

fn PreparedPlan::equal(PreparedPlan, PreparedPlan) -> Bool

PreparedPlan::not_equal

source

fn PreparedPlan::not_equal(x : PreparedPlan, y : PreparedPlan) -> Bool

PreparedPlan::to_json

source

fn PreparedPlan::to_json(PreparedPlan) -> Json

PreparedPlan::to_repr

source

fn PreparedPlan::to_repr(PreparedPlan) -> @moonbitlang/core/debug.Repr
Repr

Presence

source

pub(all) enum Presence {
  Present
  Absent
  Unknown
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Presence::equal

source

fn Presence::equal(Presence, Presence) -> Bool

Presence::not_equal

source

fn Presence::not_equal(x : Presence, y : Presence) -> Bool

Presence::to_json

source

fn Presence::to_json(self : Presence) -> Json

Presence::to_repr

source

fn Presence::to_repr(Presence) -> @moonbitlang/core/debug.Repr
Repr

PreservationKind

source

pub(all) enum PreservationKind {
  BytePreservedKind
  SemanticallyRewrittenKind
  RemovedByPolicyKind
  RegeneratedMetadataKind
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

PreservationKind::equal

source

fn PreservationKind::equal(PreservationKind, PreservationKind) -> Bool

PreservationKind::not_equal

source

fn PreservationKind::not_equal(x : PreservationKind, y : PreservationKind) -> Bool

PreservationKind::to_json

source

fn PreservationKind::to_json(self : PreservationKind) -> Json

PreservationKind::to_repr

source

fn PreservationKind::to_repr(PreservationKind) -> @moonbitlang/core/debug.Repr
Repr

RebuildSupport

source

pub(all) enum RebuildSupport {
  Supported
  NotSupported
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

RebuildSupport::equal

source

fn RebuildSupport::equal(RebuildSupport, RebuildSupport) -> Bool

RebuildSupport::not_equal

source

fn RebuildSupport::not_equal(x : RebuildSupport, y : RebuildSupport) -> Bool

RebuildSupport::to_json

source

fn RebuildSupport::to_json(self : RebuildSupport) -> Json

RebuildSupport::to_repr

source

fn RebuildSupport::to_repr(RebuildSupport) -> @moonbitlang/core/debug.Repr
Repr

Rebuilt

source

pub(all) struct Rebuilt {
  bytes : Bytes
  receipt : Receipt
}

Receipt

source

pub(all) struct Receipt {
  schema : String
  tool : String
  rules : String
  policy : String
  profile : String
  input_hash : String
  output_hash : String
  input_size : Int
  output_size : Int
  input_format : String
  output_format : String
  limits : Limits
  audit : Audit
  plan : RewritePlan
  dispositions : Array[Disposition]
  structure : String
  preservation : String
  independent_validation : String
  limitations : Array[String]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Receipt::equal

source

fn Receipt::equal(Receipt, Receipt) -> Bool

Receipt::not_equal

source

fn Receipt::not_equal(x : Receipt, y : Receipt) -> Bool

Receipt::to_json

source

fn Receipt::to_json(Receipt) -> Json

Receipt::to_repr

source

fn Receipt::to_repr(Receipt) -> @moonbitlang/core/debug.Repr
Repr

Relationship

source

pub(all) struct Relationship {
  source : String
  id : String
  kind : String
  target : String
  resolved : String
  external : Bool
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

Relationship::equal

source

fn Relationship::equal(Relationship, Relationship) -> Bool

Relationship::not_equal

source

fn Relationship::not_equal(x : Relationship, y : Relationship) -> Bool

Relationship::to_json

source

fn Relationship::to_json(Relationship) -> Json

Relationship::to_repr

source

fn Relationship::to_repr(Relationship) -> @moonbitlang/core/debug.Repr
Repr

ResultStatus

source

pub(all) enum ResultStatus {
  Pass
  Fail
  IncompleteResult
  Unsupported
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ResultStatus::equal

source

fn ResultStatus::equal(ResultStatus, ResultStatus) -> Bool

ResultStatus::not_equal

source

fn ResultStatus::not_equal(x : ResultStatus, y : ResultStatus) -> Bool

ResultStatus::to_json

source

fn ResultStatus::to_json(self : ResultStatus) -> Json

ResultStatus::to_repr

source

fn ResultStatus::to_repr(ResultStatus) -> @moonbitlang/core/debug.Repr
Repr

RewritePlan

source

pub(all) struct RewritePlan {
  schema : String
  input_hash : String
  policy : String
  profile : String
  operations : Array[Operation]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RewritePlan::equal

source

fn RewritePlan::equal(RewritePlan, RewritePlan) -> Bool

RewritePlan::not_equal

source

fn RewritePlan::not_equal(x : RewritePlan, y : RewritePlan) -> Bool

RewritePlan::to_json

source

fn RewritePlan::to_json(RewritePlan) -> Json

RewritePlan::to_repr

source

fn RewritePlan::to_repr(RewritePlan) -> @moonbitlang/core/debug.Repr
Repr

RuleCoverage

source

pub(all) struct RuleCoverage {
  rule_id : String
  capability : Capability
  state : CheckState
  presence : Presence
  rebuild_support : RebuildSupport
  reason : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

RuleCoverage::equal

source

fn RuleCoverage::equal(RuleCoverage, RuleCoverage) -> Bool

RuleCoverage::not_equal

source

fn RuleCoverage::not_equal(x : RuleCoverage, y : RuleCoverage) -> Bool

RuleCoverage::to_json

source

fn RuleCoverage::to_json(RuleCoverage) -> Json

RuleCoverage::to_repr

source

fn RuleCoverage::to_repr(RuleCoverage) -> @moonbitlang/core/debug.Repr
Repr

VerificationCheck

source

pub(all) struct VerificationCheck {
  check_id : String
  state : CheckState
  result : ResultStatus?
  detail : String
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

VerificationCheck::equal

source

fn VerificationCheck::equal(VerificationCheck, VerificationCheck) -> Bool

VerificationCheck::not_equal

source

fn VerificationCheck::not_equal(x : VerificationCheck, y : VerificationCheck) -> Bool

VerificationCheck::to_json

source

fn VerificationCheck::to_json(VerificationCheck) -> Json

VerificationCheck::to_repr

source

fn VerificationCheck::to_repr(VerificationCheck) -> @moonbitlang/core/debug.Repr
Repr

VerifiedRebuilt

source

pub(all) struct VerifiedRebuilt {
  bytes : Bytes
  receipt : VerifiedReceipt
}

VerifiedReceipt

source

pub(all) struct VerifiedReceipt {
  schema : String
  tool : String
  rules : String
  policy : String
  profile : String
  input_hash : String
  output_hash : String
  input_size : Int
  output_size : Int
  input_format : String
  output_format : String
  limits : Limits
  input_coverage : Coverage
  output_coverage : Coverage
  findings : Array[CapabilityFinding]
  output_findings : Array[CapabilityFinding]
  decisions : Array[PolicyDecision]
  allowed_capabilities : Array[CapabilityFinding]
  plan : PreparedPlan
  dispositions : Array[ContractDisposition]
  checks : Array[VerificationCheck]
  result : ResultStatus
  independent_validation : CheckState
  independent_tools : Array[String]
  limitations : Array[String]
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

VerifiedReceipt::equal

source

fn VerifiedReceipt::equal(VerifiedReceipt, VerifiedReceipt) -> Bool

VerifiedReceipt::not_equal

source

fn VerifiedReceipt::not_equal(x : VerifiedReceipt, y : VerifiedReceipt) -> Bool

VerifiedReceipt::to_json

source

fn VerifiedReceipt::to_json(VerifiedReceipt) -> Json

VerifiedReceipt::to_repr

source

fn VerifiedReceipt::to_repr(VerifiedReceipt) -> @moonbitlang/core/debug.Repr
Repr

XmlReference

source

pub(all) struct XmlReference {
  source : String
  element_index : Int
  depth : Int
  element_namespace : String
  element_name : String
  attribute_name : String
  relationship_id : String
  relationship_index : Int
} derive(Eq, ToJson, @moonbitlang/core/debug.Debug
Debug)

XmlReference::equal

source

fn XmlReference::equal(XmlReference, XmlReference) -> Bool

XmlReference::not_equal

source

fn XmlReference::not_equal(x : XmlReference, y : XmlReference) -> Bool

XmlReference::to_json

source

fn XmlReference::to_json(XmlReference) -> Json

XmlReference::to_repr

source

fn XmlReference::to_repr(XmlReference) -> @moonbitlang/core/debug.Repr
Repr

assess

source

fn assess(input : Bytes, limits? : Limits) -> Assessment

audit

source

fn audit(input : Bytes, limits? : Limits) -> Audit raise

digest

source

fn digest(bytes : BytesView) -> String

inspect_graph

source

fn inspect_graph(input : Bytes, limits? : Limits) -> PackageGraph raise

plan

source

fn plan(input : Bytes, limits? : Limits) -> RewritePlan raise

prepare

source

fn prepare(input : Bytes, limits? : Limits) -> PreparedPlan raise

rebuild

source

fn rebuild(input : Bytes, limits? : Limits) -> Rebuilt raise

rebuild_verified

source

fn rebuild_verified(input : Bytes, limits? : Limits) -> VerifiedRebuilt raise

rebuild_verified_with_plan

source

fn rebuild_verified_with_plan(input : Bytes, supplied : Json, limits? : Limits) -> VerifiedRebuilt raise

rebuild_with_plan

source

fn rebuild_with_plan(input : Bytes, supplied : Json, limits? : Limits) -> Rebuilt raise

resolve_target

source

fn resolve_target(source : String, target : String) -> String raise

verify

source

fn verify(output : Bytes, original : Bytes, limits? : Limits) -> Receipt raise

verify_contract

source

fn verify_contract(output : Bytes, original : Bytes, limits? : Limits) -> VerifiedReceipt raise

Source Files

Site source Report issue Packages Build queue Skills Statistics

partsieve

#zlhahaha/partsieve

#SieveError

#SieveError::to_repr

#Assessment

#Assessment::equal

#Assessment::not_equal

#Assessment::to_json

#Assessment::to_repr

#Audit

#Audit::equal

#Audit::not_equal

#Audit::to_json

#Audit::to_repr

#Capability

#Capability::equal

#Capability::not_equal

#Capability::to_json

#Capability::to_repr

#CapabilityFinding

#CapabilityFinding::equal

#CapabilityFinding::not_equal

#CapabilityFinding::to_json

#CapabilityFinding::to_repr

#Certainty

#Certainty::equal

#Certainty::not_equal

#Certainty::to_json

#Certainty::to_repr

#CheckState

#CheckState::equal

#CheckState::not_equal

#CheckState::to_json

#CheckState::to_repr

#CheckedOperation

#CheckedOperation::equal

#CheckedOperation::not_equal

#CheckedOperation::to_json

#CheckedOperation::to_repr

#ContentTypeIndex

#ContentTypeIndex::equal

#ContentTypeIndex::not_equal

#ContentTypeIndex::to_json

#ContentTypeIndex::to_repr

#ContractDisposition

#ContractDisposition::equal

#ContractDisposition::not_equal

#ContractDisposition::to_json

#ContractDisposition::to_repr

#Coverage

#Coverage::equal

#Coverage::not_equal

#Coverage::to_json

#Coverage::to_repr

#Decision

#Decision::equal

#Decision::not_equal

#Decision::to_json

#Decision::to_repr

#Disposition

#Disposition::equal

#Disposition::not_equal

#Disposition::to_json

#Disposition::to_repr

#Finding

#Finding::equal

#Finding::not_equal

#Finding::to_json

#Finding::to_repr

#GraphNode

#GraphNode::equal

#GraphNode::not_equal

#GraphNode::to_json

#GraphNode::to_repr

#ImplicitReference

#ImplicitReference::equal

#ImplicitReference::not_equal

#ImplicitReference::to_json

#ImplicitReference::to_repr

#Limits

SieveError

SieveError::to_repr

Assessment

Assessment::equal

Assessment::not_equal

Assessment::to_json

Assessment::to_repr

Audit

Audit::equal

Audit::not_equal

Audit::to_json

Audit::to_repr

Capability

Capability::equal

Capability::not_equal

Capability::to_json

Capability::to_repr

CapabilityFinding

CapabilityFinding::equal

CapabilityFinding::not_equal

CapabilityFinding::to_json

CapabilityFinding::to_repr

Certainty

Certainty::equal

Certainty::not_equal

Certainty::to_json

Certainty::to_repr

CheckState

CheckState::equal

CheckState::not_equal

CheckState::to_json

CheckState::to_repr

CheckedOperation

CheckedOperation::equal

CheckedOperation::not_equal

CheckedOperation::to_json

CheckedOperation::to_repr

ContentTypeIndex

ContentTypeIndex::equal

ContentTypeIndex::not_equal

ContentTypeIndex::to_json

ContentTypeIndex::to_repr

ContractDisposition

ContractDisposition::equal

ContractDisposition::not_equal

ContractDisposition::to_json

ContractDisposition::to_repr

Coverage

Coverage::equal

Coverage::not_equal

Coverage::to_json

Coverage::to_repr

Decision

Decision::equal

Decision::not_equal

Decision::to_json

Decision::to_repr

Disposition

Disposition::equal

Disposition::not_equal

Disposition::to_json

Disposition::to_repr

Finding

Finding::equal

Finding::not_equal

Finding::to_json

Finding::to_repr

GraphNode

GraphNode::equal

GraphNode::not_equal

GraphNode::to_json

GraphNode::to_repr

ImplicitReference

ImplicitReference::equal

ImplicitReference::not_equal

ImplicitReference::to_json

ImplicitReference::to_repr

Limits

Limits::default

Limits::equal