tidysimple.xqm

xquery version "3.1";

(:~
 : This modules handles the conversion of the Fontante-TEI/XML into TEI simplePrint
 : for the edited text. The resulting TEI simplePrint is the basis for the "Editerter
 : Text" (edited text) view on the website and the book. It represents the latest
 : layer of text.
 :
 : @author Michelle Weidling
 : @version 0.1
 : @since TODO
 :)

module namespace tidySimple ="http://fontane-nb.dariah.eu/tidysimple";


declare namespace tei="http://www.tei-c.org/ns/1.0";
declare namespace test="http://exist-db.org/xquery/xqsuite";

import module namespace config="http://textgrid.de/ns/SADE/config" at "../../config/config.xqm";
import module namespace console="http://exist-db.org/xquery/console";
import module namespace functx="http://www.functx.com";
import module namespace presort="http://fontane-nb.dariah.eu/presort" at "presort.xqm";
import module namespace simpleHelpers="http://fontane-nb.dariah.eu/teisimplehelpers" at "teisimplehelpers.xqm";


declare variable $tidySimple:valid-hands :=
    for $res in collection("/db/sade-projects/textgrid/data/xml/data")
(:    for $res in collection("/db/apps/SADE/resources/xml"):)
    return
        $res//tei:handNote[@script = "contemporary"]/@xml:id/string();


declare function tidySimple:main($tei as node()*) {
    let $tidy := tidySimple:sort-out-invalid-hands($tei//tei:text) 
        => tidySimple:sort-out-surplus-elements()
        => tidySimple:whitespaces()
        => tidySimple:summarize-entries()
        => tidySimple:split-headings()
(:        => tidySimple:sort():)
(:    let $text-with-sections := tidySimple:make-structure($clear-surplus-hands):)
    let $header := $tei/tei:teiHeader
    return 
        xmldb:store("/db/apps/SADE/resources/xml/", "fontane-tei.xml", <TEI xmlns="http://www.tei-c.org/ns/1.0" id="{$tei//tei:TEI/@id}">{$header}{$tidy}</TEI>)
};

declare function tidySimple:sort-out-invalid-hands($nodes as node()*) 
as node()* {
    for $node in $nodes return
        typeswitch ($node)
        case text() return
            if($node/preceding::tei:milestone[@unit = "handshift"][1] 
            and not(simpleHelpers:is-hand-valid($tidySimple:valid-hands, $node/preceding::tei:milestone[@unit = "handshift"][1]))) then
                ()
            else
                $node
        
        (: all lines have to be preserved because of the editorial commentary
        which references the lines in the notebooks. if we omitted @unit = "line"
        referencing wouldn't work any longer :)        
        case element(tei:milestone) return
            let $prev-handshift := $node/preceding::tei:milestone[@unit = "handshift"][1]
                return
                if($node/@unit = "handshift" and
                simpleHelpers:is-hand-valid($tidySimple:valid-hands, $node)) then
                    tidySimple:clear-handshift($node)  
                    
                else if($node/@unit = "handshift") then
                    ()
                    
                else if($prev-handshift
                and $node/@unit = "line" 
                and not(simpleHelpers:is-hand-valid($tidySimple:valid-hands, $prev-handshift))) then
                    tidySimple:copy-element($node, "post")
                
                else if($prev-handshift
                and not(simpleHelpers:is-hand-valid($tidySimple:valid-hands, $prev-handshift))) then
                    ()
                
                else
                    tidySimple:copy-element($node, "post")
                
        default return
            let $prev-handshift := $node/preceding::tei:milestone[@unit = "handshift"][1]
            let $first-child-handshift := $node/child::tei:milestone[@unit = "handshift"][1]
            let $first-child-element := $node/child::*[1]
            let $first-child-node := $node/child::node()[1]
            
            return
                (: in some cases the valid handshift is the first child node 
                instead of a previous node. of course we want to keep the element
                then :)
                if($first-child-element = $first-child-handshift
                (: ensure there's no text before the handshift :)
                and (normalize-space($first-child-node) = ""
                    or $first-child-element = $first-child-node)
                and simpleHelpers:is-hand-valid($tidySimple:valid-hands, $first-child-handshift)) then
                    tidySimple:copy-element($node, "post")
                
                else if($prev-handshift
                and not(simpleHelpers:is-hand-valid($tidySimple:valid-hands, $prev-handshift))) then
                    ()
                    
                else
                    tidySimple:copy-element($node, "post")
};


declare function tidySimple:sort-out-surplus-elements($nodes as node()*) 
as node()* {
    for $node in $nodes return
        typeswitch ($node)
        case text() return
            $node
        
        case element(tei:milestone) return
            if($node/@unit = "handshift") then
                if(simpleHelpers:is-prev-hand-same($node)
                or not(tidySimple:has-hand-text($node))) then
                    ()
                else
                    tidySimple:clear-handshift($node)
                    
            else if($node/@unit = "line") then
                let $next-pb := $node/following::tei:pb[1]
                let $nodes-on-page := $node/preceding::tei:pb[1]/following::node()[. << $next-pb][functx:node-kind(.) = "text"]
                let $contains-text :=
                    for $node-pb in $nodes-on-page return
                        if(normalize-space($node-pb) != "") then
                            true()
                        else 
                            false()
                return
                    if(functx:is-value-in-sequence(true(), $contains-text)) then
                        element {QName("http://www.tei-c.org/ns/1.0", $node/name())} {
                            $node/@*,
                            tidySimple:sort-out-surplus-elements($node/node())
                        }
                    else
                        ()
                
            else
                element {QName("http://www.tei-c.org/ns/1.0", $node/name())} {
                    $node/@*,
                    tidySimple:sort-out-surplus-elements($node/node())
                }                
                
        default return
            element {QName("http://www.tei-c.org/ns/1.0", $node/name())} {
                $node/@*,
                tidySimple:sort-out-surplus-elements($node/node())
            }
};

declare function tidySimple:has-hand-text($node as element(tei:milestone))
as xs:boolean {
    let $next-handshift := $node/following::tei:milestone[@unit = "handshift"][1]
    let $nodes-between := $node/following::node()[. << $next-handshift]
    let $is-text-node :=
        for $node-between in $nodes-between
        return 
            if ($node-between[self::text()]
            and not(normalize-space($node-between) = "")) then
                true()
            else
                false()
    return 
        if($next-handshift 
        and functx:is-value-in-sequence(true(), $is-text-node)) then
            true()
        else if(not($next-handshift)) then
            true()
        else
            false()
};


declare function tidySimple:copy-element($node as node(), $flag as xs:string)
 {
    element {QName("http://www.tei-c.org/ns/1.0", $node/name())}{
        $node/@*,
        if($flag = "structure") then
            tidySimple:make-structure($node/node())
        else if($flag = "post") then
            tidySimple:sort-out-invalid-hands($node/node())        
        else if($flag = "surplus") then
            tidySimple:sort-out-invalid-hands($node/node())        
        else if($flag = "summarize") then
            tidySimple:summarize-entries($node/node())
        else
            tidySimple:tidy($node/node())
    }
};

(:~
 : Purges surplus attributes from tei:milestone[@unit = "handshift"].
 : 
 : @author Michelle Weidling
 : @param $node the current tei:milestone[@unit = "handshift"]
 : @return the purged tei:milestone[@unit = "handshift"]
 :  :)
declare function tidySimple:clear-handshift($node as element(tei:milestone))
as element(tei:milestone) {
    element {QName("http://www.tei-c.org/ns/1.0", $node/name())} {
        attribute unit {"handshift"},
        $node/@ws-before,
        $node/@ws-after,
        if($node/@subtype = "") then
            ()
        else
            $node/@subtype,
        if($node/@rend = "") then
            ()
        else
            $node/@rend
    }
};


(:~ 
 : 
 :  :)
declare function tidySimple:make-structure($nodes as node()*) as node()* {
    for $node in $nodes return
        typeswitch ($node)
        case text() return
            if(tidySimple:is-in-section($node)) then
                ()
            else
                $node
                
        case element(tei:milestone) return 
            if($node/@unit = "section") then
                tidySimple:make-section($node)
                
            else if($node/@unit = "paragraph") then
                tidySimple:copy-element($node, "structure")
            
            (: lines in sections have to be ignored since they are copied into 
            the section with get-section-chunk :)    
            else if($node/@unit = "line"
            and tidySimple:is-in-section($node)) then
                ()
            else
                tidySimple:copy-element($node, "structure")
                
        case element(tei:anchor) return
            if (matches($node/preceding::tei:milestone/@spanTo, $node/@xml:id)) then
                ()
            else
                tidySimple:copy-element($node, "structure")
                
        default return 
            if(tidySimple:is-in-section($node)) then
                ()
            else
                tidySimple:copy-element($node, "structure")
};

(:~
 : Checks if a given node is between a tei:milestone[@unit = "section"] and its
 : corresponing tei:anchor.
 : 
 : @author Michelle Weidling
 : @param the current node
 : @return xs:boolean
 :  :)
declare function tidySimple:is-in-section($node as node()) as xs:boolean {
    let $prev-section-marker := $node/preceding::tei:milestone[1][@spanTo]
    let $target-id := replace($prev-section-marker, "#", "")
    let $next-anchor := $node/following::tei:anchor[matches(@xml:id, $target-id)]
    return
        if($prev-section-marker 
        and $next-anchor) then
            true()
        else
            false()
};


(:~
 : Creates a tei:div from a given tei:milestone[@unit = "section"] that contains 
 : all elements from a given tei:milestone to its corresponding tei:anchor.
 : 
 : Since the nodes between the current and the target one may also contain 
 : structural information (e.g. tei:milestone[@unit = "paragraph"]), these nodes
 : cannot simply be copied but have to be transformed as well.
 : 
 : @author Michelle Weidling
 : @param $node the current tei:milestone[@unit = "section"]
 : @return element(tei:div)
 :  :)
declare function tidySimple:make-section($node as element(tei:milestone)) 
as element(tei:div) {
    element tei:div {
        attribute type {"section"},
        tidySimple:get-section-chunk($node)
    }
};


(:~
 : Returns all nodes between a tei:milestone[@unit = "section"] and its 
 : corresponding tei:anchor.
 :
 : @author Michelle Weidling
 : @param the current tei:milestone element
 : @return all nodes between the current element and the respective tei:anchor
 :)
declare function tidySimple:get-section-chunk($node as element(tei:milestone)) 
as node()* {
    let $target-id := substring-after($node/@spanTo, "#")
    let $target := $node/following::tei:anchor[matches(@xml:id, $target-id)]
    return
        $node/following-sibling::node()[. << $target]
};


declare function tidySimple:tidy($nodes as node()*) as node()* {
    ()
};

declare function tidySimple:whitespaces($nodes as node()*) as node()* {
    for $node in $nodes return
        typeswitch($node)
        case text() return
            $node
            
        default return
            element {QName("http://www.tei-c.org/ns/1.0", $node/name())} {
                $node/@*,
                if($node/@next) then
                    let $target-id := replace($node/@next, "#", "")
                    let $target := $node/ancestor::tei:TEI//*[@xml:id = $target-id]
                    return
                        if(ends-with($node//text()[last()], "@P")
                        (: example: C6 Kapell:drf. :)
                        or $node[self::tei:abbr][ends-with(., ":")]
                        or $node[self::tei:rs]/tei:choice[not(following-sibling::*)][tei:abbr[ends-with(., ":")]]
                        or $node[ends-with(., "-")]) then
                            ()
                        else
                            attribute break {"true"}
                else
                    (),
                tidySimple:whitespaces($node/node())
            }
};


declare function tidySimple:split-headings($nodes as node()*) as node()* {
    for $node in $nodes return
        typeswitch($node)
        case text() return
            $node
        
        case element(tei:head) return
            if($node//tei:lb[@type = "edited_text"]) then
                let $lb := $node//tei:lb[@type = "edited_text"]
                let $split-top := $node/node()[. << $lb]
                let $split-bottom := $node/node()[. >> $lb]
                return
                    element {QName("http://www.tei-c.org/ns/1.0", $node/name())} {
                        $node/@*,
                        (element {QName("http://www.tei-c.org/ns/1.0", "seg")} {
                            attribute type {"upper-part"},
                            $split-top
                        },
                        element {QName("http://www.tei-c.org/ns/1.0", "lb")} {
                            attribute type {"edited_text"}
                        },
                        element {QName("http://www.tei-c.org/ns/1.0", "seg")} {
                            attribute type {"lower-part"},
                            $split-bottom
                        })
                    }
                    
            else
                element {QName("http://www.tei-c.org/ns/1.0", $node/name())} {
                    $node/@*,
                    tidySimple:split-headings($node/node())
                }
            
        default return
            element {QName("http://www.tei-c.org/ns/1.0", $node/name())} {
                $node/@*,
                if($node/tei:add[@type = "edited_text" and @subtype = "interlinear"]) then
                    let $add := $node/tei:add[@type = "edited_text" and @subtype = "interlinear"]
                    return
                        (element {QName("http://www.tei-c.org/ns/1.0", "seg")} {
                            attribute type {"upper-part"},
                            $add/node()
                        },
                        element {QName("http://www.tei-c.org/ns/1.0", "lb")} {
                            attribute type {"edited_text"}
                        },
                        element {QName("http://www.tei-c.org/ns/1.0", "seg")} {
                            attribute type {"lower-part"},
                            $add/following-sibling::node()
                        })
                else
                    tidySimple:split-headings($node/node())
            }
};

declare function tidySimple:summarize-entries($nodes as node()*) as node()* {
    for $node in $nodes return
        typeswitch ($node)
        
        case text() return
            $node
        
        case element(tei:hi) return
            if($node/@next and not($node/@prev)) then
                let $this-content := $node/child::text()

                return
                    element {QName("http://www.tei-c.org/ns/1.0", "hi")} {
                        $this-content,
                        tidySimple:get-next-content($node, ())
                    }
            else if($node[@prev]) then
                ()
            else
                 tidySimple:copy-element($node, "summarize")
                 
        default return
            tidySimple:copy-element($node, "summarize")
};

declare function tidySimple:get-next-content($node as node()*, $content as node()*) 
as node()* {
    if($node/@next) then
        let $next-hi-id := substring-after($node/@next, "#")
        let $next-node := $node/following-sibling::*[@xml:id = $next-hi-id]
        let $next-content := $next-node/text()
        let $break := if($node/@break = "true") then text{" "} else ()
        let $content := ($content, $break, $next-content)

        return 
            tidySimple:get-next-content($next-node, $content)
    else
        $content
};