xmlutils

type CommonCPR ¶

type CommonCPR struct {
	NodeDepths []int
	FilePosns  []*CT.FilePosition
	CPR_raw    string
	// Writer is usually the GTokens Writer
	io.Writer
}

CommonCPR is Concrete Parse Results common to all formats processed.

func NewCommonCPR() *CommonCPR

func (p *CommonCPR) AsString(i int) string

type ContentityBasics ¶

type ContentityBasics struct {
	// XmlRoot is not meaningful for non-XML
	XmlRoot CT.Span
	Text    CT.Span
	Meta    CT.Span
	// MetaFormat is "YAML" or "XML"
	MetaFormat string
	// MetaProps uses dot separators if hierarchy is needed
	MetaProps SU.PropSet
}

ContentityBasics describes the top-level structure of a Contentity (content entity). It has XmlRoot, Text, Meta, MetaProps, and is embedded in struct XmlPeek. .

func (p *ContentityBasics) CheckTopTags() (bool, string)

func (p *ContentityBasics) HasNone() bool

func (p *ContentityBasics) SetToNonXml(L int)

type ContypingInfo ¶

type ContypingInfo struct {
	FileExt         string
	MimeType        string
	MimeTypeAsSnift string
	MType           string
}

ContypingInfo has simple fields related to typing content (i.e. determining its type). .

func (p ContypingInfo) MultilineString() (s string)

func (pC *ContypingInfo) ParseDoctype(sRaw CT.Raw) (*ParsedDoctype, error)

func (p ContypingInfo) String() (s string)

type DitaContype ¶

type DitaContype string

DitaContype is a [Lw]DITA Topic, Map, etc. See DitaContypes.

type DitaFlavor ¶

type DitaFlavor string

DitaFlavor is a [Lw]DITA flavor. See DitaFlavors.

type DoctypeMType ¶

type DoctypeMType struct {
	ToMatch       string
	DoctypesMType string
	RootElm       string
	IsLwDITA      bool
	// LwDITA, HTML5, and not much more (if any)
	IsInScope bool
}

DoctypeMType maps a DOCTYPE string to an MType string and a bool, ? Is it LwDITA ?

type KeyElmTriplet ¶

type KeyElmTriplet struct {
	Name string
	Meta string
	Text string
}

KeyElmTriplet is a set of tags that appear together in a well-known content format.

func GetKeyElmTriplet(localName string) *KeyElmTriplet

type MType ¶

type MType string

An MType is specific to this app and/but is modeled after the prior concept of Mime-type. An MType has three fields.

Its value is generally based on two to four inputs:

• The Mime-type guess returned by Go stdlib func net/http.DetectContentType(data []byte) string (which is based on https://mimesniff.spec.whatwg.org/ ) (The no-op default return value is "application/octet-stream")
• Our own shallow analysis of file contents
• The file extension (it is normally present)
• The DOCTYPE (iff XML, incl. HTML)

Note that

• a plain text file MAY be presumed to be Markdown, altho it is not clear (yet) which (TXT or MKDN) should take precedence.
• a Markdown file CAN and WILL be presumed to be LwDITA MDITA; this may cause conflicts/problems for other dialects.
• mappings can appear bogus, for example HTTP stdlib "text/html" might become MType "xml/html".

String possibilities (but in LOWER CASE!) in each field:

• [0] XML, HTML, BIN, TXT, MKDN, (new!) DIRLIKE (i.e. non-contentful)
• We might (or not) keep XML and HTML distinct for a number of reasons, but partly because in the Go stdlib, they are processed quite differently, and we take advantage of it to keep HTML pro- cessing free of nasty surprises and unhelpful strictness
• We might (or might not) keep MKDN distinct from TXT
• [1] CNT (Content), MAP (ToC), IMG, SCH(ema) [and maybe others TBD?]
• [2] Depends on [0]: XML: per-DTD [and/or Pub-ID/filext]; HTML: per-DTD [and/or Pub-ID/filext]; BIN: format/filext; SCH: format/filext [DTD,MOD,XSD,wotevs]; TXT: TBD MKDN: flavor of Markdown (?) (note also AsciiDoc, RST, ...) DIRLIKE: dir, symlink, pipe, socket, ...?

Possible FIXME: Let [2] (3rd) be version info (html5, lwdiat, dita13) and then keep root tag info separately.

Possible FIXME: Append version info, probably after a semicolon. .

type NS ¶

type NS struct {
	// Prefix is the shorthand version.
	Prefix string
	// URI is the full version.
	URI string
}

NS is e.g. { "xml", "http://www.w3.org/XML/1998/namespace" }

type NSsnapshot ¶

type NSsnapshot struct {
	Default NS
	Others  []NS
}

One of these has to be filled in for the NS declarations at the top of a content file. Also this can describe the NS state at any point in parsing or traversing a content tree.

type PIDFPIfields ¶

type PIDFPIfields struct {
	// Registration is "+" or "-"
	Registration string
	// IsOasis but if not, then could be any of many others
	IsOasis bool
	// Organization is "OASIS" or maybe something else
	Organization string
	// PublicTextClass is typically "DTD" (filename.dtd)
	// or "ELEMENTS" (filename.mod)
	PublicTextClass string
	// PublicTextDesc is the distinguishing string,
	// e.g. PUBLIC "-//OASIS//DTD (_PublicTextDesc_)//EN".
	// It can end with the root tag of the document
	// (e.g. "Topic"). It can have an optional
	// embedded version number, such as "DITA 1.3".
	PublicTextDesc string
}

PIDFPIfields holds the parsed results of a PID (PublicID) a.k.a. Formal Public Identifier, for example "-//OASIS//DTD LIGHTWEIGHT DITA Topic//EN"

func (p PIDFPIfields) String() string

type PIDSIDcatalogFileRecord ¶

type PIDSIDcatalogFileRecord struct {
	// XMLName probably does not ever need to be printed.
	XMLName xml.Name `xml:"public"`
	// XmlPublicID (PID) (FPI) is the DOCTYPE string
	XmlPublicID  `xml:"publicId,attr"`
	PIDFPIfields // PublicID
	// XmlSystemID is the path to the file. Tipicly a relative filepath.
	XmlSystemID `xml:"uri,attr"`
	// The filepath long form, as resolved.
	// Note that we must use a string in order to avoid an import cycle.
	AbsFilePath string // FU.AbsFilePath
	HttpPath    string
	Err         error // in case an entry barfs

}

PIDSIDcatalogFileRecord representa a line item from a parsed XML catalog file. One with a simple structure, such as the catalog file for LwDITA. This same struct is also used to record the PID and/or SID of a DOCTYPE declaration.

func NewPIDSIDcatalogFileRecord(pid string, sid string) (*PIDSIDcatalogFileRecord, error)

func NewSIDPIDcatalogRecordfromStartTag(ct CT.CToken) (pID *PIDSIDcatalogFileRecord, err error)

func (p PIDSIDcatalogFileRecord) DString() string

func (p PIDSIDcatalogFileRecord) Echo() string

func (p *PIDSIDcatalogFileRecord) HasPID() bool

func (p *PIDSIDcatalogFileRecord) HasSID() bool

func (p PIDSIDcatalogFileRecord) String() string

type ParsedDoctype ¶

type ParsedDoctype struct {
	// Raw is the raw Doctype string
	CT.Raw
	// PIDSIDcatalogFileRecord is the PID + SID.
	PIDSIDcatalogFileRecord
	// DTrootElm is the tag declared in the DOCTYPE, which
	// should match the root tag in the text of the file.
	DTrootElm string
	// contains filtered or unexported fields
}

ParsedDoctype is a parse of a complete DOCTYPE declaration. For [Lw]DITA, what interests us is something like

PUBLIC "-//OASIS//DTD (PublicTextDesc)//EN" or sometimes
PUBLIC "-//OASIS//ELEMENTS (PublicTextDesc)//EN" and
maybe followed by SYSTEM...

The structure of a DOCTYPE is like so:

• PUBLIC | SYSTEM = Availability
• - = Registration = Organization & DTD are not registeredd with ISO.
• OASIS = Organization
• DTD = Public Text Class (CAPACITY | CHARSET | DOCUMENT | DTD | ELEMENTS | ENTITIES | LPD | NONSGML | NOTATION | SHORTREF | SUBDOC | SYNTAX | TEXT )
• (*) = Public Text Description, incl. any version number
• EN = Public Text Language
• URL = optional, explicit

We don't include the raw DOCTYPE here because this structure can be optional but we still need to have the Doctype string in the DB as a separate column, even if it is empty (i.e. "").

type ParsedPreamble ¶

type ParsedPreamble struct {
	// Preamble_raw does not include a trailing newline
	Preamble_raw string
	// MinorVersion "0" means XML 1.0
	MinorVersion string
	// Encoding has Valid values and forms TBS
	Encoding string
	// IsStandalone has value "yes" or "no"
	IsStandalone bool
}

ParsedPreamble is a parse of an optional PI (processing instruction) at the start of an XML file. The most typical form is defined in the stdlib:

"<?xml version="1.0" encoding="UTF-8"?>" + "\n"

Here the major version MUST be 1. XML has a version 1.1 but nobody uses it, so also the minor version MUST be 0, because that's what the Go stdlib XML parser understands, and anything else is gonna cause crazy breakage. Fields:

<?xml version="version_number"         <= required, "1.0"
     encoding="encoding_declaration"   <= optional, assume "UTF-8"
   standalone="standalone_status" ?>   <= opt'l, can be "yes", dflt "no"

Probably any errors returned by this function should be panicked on, because any such error is pretty fundamental and also ridiculous. Note also that strictly speaking, an XML preamble is NOT a PI.

var STD_PreambleParsed ParsedPreamble

func ParsePreamble(sRaw CT.Raw) (*ParsedPreamble, error)

type ParserResults_xml ¶

type ParserResults_xml struct {
	// NodeSlice is driven by the stdlib XML parser in [encoding/xml].
	NodeSlice []CT.CToken // []xml.Token
	CommonCPR
}

ParserResults_xml is TBS.

func GenerateParserResults_xml(s string) (*ParserResults_xml, error)

func (p *ParserResults_xml) NodeCount() int

func (p *ParserResults_xml) NodeDebug(i int) string

func (p *ParserResults_xml) NodeEcho(i int) string

func (p *ParserResults_xml) NodeInfo(i int) string

type SliceBounds ¶

type SliceBounds struct {
	BegIdx, EndIdx int
}

SliceBounds specifies a subslice.

type XmlCatalogFile ¶

type XmlCatalogFile struct {
	XMLName xml.Name `xml:"catalog"`
	// Prefer is "public" or "system"
	Prefer                string                    `xml:"prefer,attr"`
	XmlPublicIDsubrecords []PIDSIDcatalogFileRecord `xml:"public"`
	// AbsFilePath is so we can peel off the directory path
	AbsFilePath string
}

XmlCatalogFile represents a parsed XML catalog file, at the top level.

func NewXmlCatalogFile(fpath string) (pXC *XmlCatalogFile, err error)

func (p *XmlCatalogFile) GetByPublicID(s string) *PIDSIDcatalogFileRecord

func (p *XmlCatalogFile) Validate() (retval bool)

type XmlContype ¶

type XmlContype string

XmlContype categorizes the XML file. See variable 8XmlContypes9.

type XmlDoctype ¶

type XmlDoctype string

XmlDoctype is just a DOCTYPE string, for example: <!DOCTYPE html>

type XmlPeek ¶

type XmlPeek struct {
	PreambleRaw CT.Raw // string
	DoctypeRaw  CT.Raw // string
	HasDTDstuff bool
	ContentityBasics
}

XmlPeek is used by [fileutils.AnalyseFile] when preparing a [fileutils.AnalysisRecord]. Note that ContentityBasics has chunks of Raw but not the full "Raw" string. .

func Peek_xml(content string) (*XmlPeek, error)

type XmlPublicID ¶

type XmlPublicID string

XmlPublicID = PID = Public ID = FPI = Formal Public Identifier

type XmlSystemID ¶

type XmlSystemID string

XmlSystemID = SID = System ID = URI (Universal Resource Identifier) (can be a filepath or an HTTP address)