xmlutils

type CommonCPR ¶

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

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","XML"
	MetaFormat string
	// MetaProps uses dot separators if hierarchy is needed
	MetaProps SU.PropSet
}

ContentityBasics has Raw,Root,Text,Meta,MetaProps and is embedded in XU.AnalysisRecord. .

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)

<!DOCTYPE topic PUBLIC "-//OASIS//DTD LWDITA Topic//EN">
<!DOCTYPE topic PUBLIC "-//OASIS//DTD LWDITA Topic//EN" "./foo.dtd">
<!DOCTYPE topic SYSTEM "./foo.dtd">

DOCTYPE topic PUBLIC "-//OASIS//DTD LWDITA Topic//EN" (and variations)
        topic PUBLIC "-//OASIS//DTD LWDITA Topic//EN" (and variations)
              PUBLIC "-//OASIS//DTD LWDITA Topic//EN" (and variations)

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

type DitaContype ¶

type DitaContype string

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

type DitaFlavor ¶

type DitaFlavor string

DitaFlavor is a [Lw]DITA flavor. See enumeration "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
}

func GetKeyElmTriplet(localName string) *KeyElmTriplet

type MType ¶

type MType string

Possible TODO:

type XmlDoctypeFamily string

The XmlDoctypeFamilies are the broad groups of DOCTYPES.

var XmlDoctypeFamilies = []XmlDoctypeFamily {
"lwdita",
"dita13",
"dita",
"html5",
"html4",
 "svg",
 "mathml",
"other",
}

.

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 {
	CT.Raw // Raw Doctype string
	// 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 {
	// Do not include a trailing newline.
	Preamble_raw string
	// e.g. "0" means XML 1.0
	MinorVersion string
	// Valid values and forms are TBS.
	Encoding string
	// "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" ?>   <= optional, can be "yes", assume "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 {
	// ParseTree ??
	NodeSlice []CT.CToken // []xml.Token
	CommonCPR
}

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
}

type XmlCatalogFile ¶

type XmlCatalogFile struct {
	XMLName xml.Name `xml:"catalog"`
	// "public" or "system"
	Prefer                string                    `xml:"prefer,attr"`
	XmlPublicIDsubrecords []PIDSIDcatalogFileRecord `xml:"public"`
	// We do this 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 "XmlContypes".

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 called by FU.AnalyseFile(..) when preparing an FU.AnalysisRecord . 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)