---
marp: true
theme: default
paginate: true
size: 16:9
style: |
  section {
    font-size: 24px;
  }
  section h1 {
    color: #1a5276;
  }
  section h2 {
    color: #2980b9;
  }
  section table {
    font-size: 20px;
  }
  section small {
    font-size: 18px;
  }
---
# Wykład 8
## Relax NG — alternatywny język schematów

**Systemy Zarządzania Treścią**  
Politechnika Poznańska

---

# Część 1
## Wprowadzenie do Relax NG

---

## Czym jest Relax NG?

> **Relax NG** (REgular LAnguage for XML Next Generation) to język schematów dla dokumentów XML, oparty na **gramatykach regularnych** — alternatywa dla DTD i XML Schema.

### Geneza i status

| Aspekt | Informacja |
|---|---|
| **Autor** | James Clark (współtwórca XSLT) |
| **Standard ISO** | ISO/IEC 19757-2 (DSDL) |
| **Standard OASIS** | RELAX NG Specification |
| **Dwie składnie** | XML (pełna) i compact (skrótowa) |
| **Podstawa teoretyczna** | Gramatyki regularne drzew |

### Filozofia projektowa

Relax NG łączy **prostotę i moc DTD** z **formalną czystością** gramatyk regularnych. W przeciwieństwie do XML Schema, model jest **jednolity i przewidywalny** — bez rozróżnienia na typy proste/złożone jako osobnych bytów.

---

## Dwie składnie Relax NG

Relax NG występuje w dwóch równoważnych formach składniowych:

### 1. Składnia XML (pełna)

```xml
<element name="addressBook" xmlns="http://relaxng.org/ns/structure/1.0">
  <zeroOrMore>
    <element name="card">
      <element name="name"><text/></element>
      <element name="email"><text/></element>
    </element>
  </zeroOrMore>
</element>
```

### 2. Składnia compact (skrótowa)

```
element addressBook {
  element card {
    element name { text },
    element email { text }
  }*
}
```

> Obie składnie są **równoważne** — narzędzie Trang konwertuje między nimi automatycznie.

---

## Relax NG na tle DTD i XML Schema

| Cecha | DTD | XML Schema | Relax NG |
|---|---|---|---|
| **Podstawa** | gramatyki SGML | typy + struktury | gramatyki regularne |
| **Składnia** | własna (nie-XML) | XML | XML + compact |
| **Typy danych** | 10 typów | 44 wbudowane + własne | dowolne (przez biblioteki) |
| **Jednolitość modelu** | — | podział proste/złożone | jednolity model wzorców |
| **Przestrzenie nazw** | brak | pełne | pełne (klasy nazw) |
| **Mieszana zawartość** | ograniczona | możliwa | naturalna (mixed) |
| **Przeplot (interleave)** | brak | brak | tak |
| **Modularyzacja** | encje parametryczne | include/import/redefine | include/externalRef/combine |
| **Złożoność specyfikacji** | niska | bardzo wysoka | niska–średnia |

> Relax NG oferuje **najprostszy formalnie** model spośród trzech języków — jednolity mechanizm "wzorców" zamiast podziału na typy. Dla porównania: DTD omówione w **wykładzie 4**, XML Schema w **wykładach 5–7**.

---

## Zasada działania — wzorce

Relax NG opiera się na jednym, uniwersalnym pojęciu: **wzorca** (*pattern*).

> **Wzorzec** opisuje dopuszczalną strukturę fragmentu dokumentu — elementy, atrybuty, tekst i ich kombinacje.

### Cechy modelu wzorców

- Wszystko jest wzorcem — nie ma osobnych "typów",
- Wzorce **składają się** rekurencyjnie (pattern composition),
- Schemat to **gramatyka** złożona ze wzorców,
- Walidacja = dopasowanie dokumentu do wzorca.

### Przykład podstawowego wzorca

```xml
<element name="name">
  <text/>
</element>
```

Ten wzorzec oznacza: element o nazwie `name`, zawierający dowolny tekst.

---

# Część 2
## Podstawowe wzorce

---

## Wzorce element, attribute, text, empty

Cztery podstawowe wzorce opisują fundament dokumentu XML:

| Wzorzec | Znaczenie | Przykład |
|---|---|---|
| `<element>` | element o danej nazwie | `<element name="name">` |
| `<attribute>` | atrybut o danej nazwie | `<attribute name="email">` |
| `<text/>` | dowolny tekst | `<text/>` |
| `<empty/>` | brak treści i atrybutów | `<empty/>` |

### Przykład — prosty dokument

**Dokument XML:**
```xml
<addressBook>
  <card>
    <name>John Smith</name>
    <email>js@example.com</email>
  </card>
</addressBook>
```

**Schemat Relax NG:**
```xml
<element name="addressBook" xmlns="http://relaxng.org/ns/structure/1.0">
  <zeroOrMore>
    <element name="card">
      <element name="name"><text/></element>
      <element name="email"><text/></element>
    </element>
  </zeroOrMore>
</element>
```

---

## Odpowiednik DTD — porównanie

Ten sam dokument opisany w DTD:

```xml
<!DOCTYPE addressBook [
  <!ELEMENT addressBook (card*)>
  <!ELEMENT card (name, email)>
  <!ELEMENT name (#PCDATA)>
  <!ELEMENT email (#PCDATA)>
]>
```

### Porównanie zapisu

| Element struktury | DTD | Relax NG |
|---|---|---|
| Element główny | `<!ELEMENT addressBook (card*)>` | `<element name="addressBook">` |
| Powtórzenie (0+) | `card*` | `<zeroOrMore>` |
| Sekwencja | `(name, email)` | kolejne wzorce |
| Tekst | `#PCDATA` | `<text/>` |

> Relax NG jest **bardziej rozwlekły** w składni XML, ale **bardziej jednolity** — każda konstrukcja jest wzorcem.

---

## Krotność: zeroOrMore, oneOrMore, optional

Relax NG wyraża liczebność przez **wzorce-kontenery**:

| Wzorzec | Znaczenie | Odpowiednik DTD |
|---|---|---|
| `<zeroOrMore>` | zero lub więcej | `*` |
| `<oneOrMore>` | jeden lub więcej | `+` |
| `<optional>` | zero lub jeden | `?` |
| *(brak kontenera)* | dokładnie raz | *(brak)* |

### Przykład — opcjonalny element

```xml
<element name="card">
  <element name="name"><text/></element>
  <element name="email"><text/></element>
  <optional>
    <element name="note"><text/></element>
  </optional>
</element>
```

> `optional` oznacza, że element `note` **może**, ale nie musi wystąpić.

---

## Przestrzeń nazw Relax NG

Wszystkie elementy wzorca należą do przestrzeni nazw:

`http://relaxng.org/ns/structure/1.0`

### Dwa sposoby deklaracji

**Domyślna przestrzeń nazw:**
```xml
<element name="addressBook" xmlns="http://relaxng.org/ns/structure/1.0">
```

**Prefiks:**
```xml
<rng:element name="addressBook" xmlns:rng="http://relaxng.org/ns/structure/1.0">
  <rng:zeroOrMore>
    <rng:element name="card">
      <rng:element name="name"><rng:text/></rng:element>
    </rng:element>
  </rng:zeroOrMore>
</rng:element>
```

> Każdy element wzorca **musi** być kwalifikowany tą przestrzenią nazw — inaczej jest traktowany jako adnotacja (ignorowany).

---

# Część 3
## Wzorce złożone

---

## Wzorzec choice — alternatywa

`choice` dopasowuje **jeden** z podanych wzorców:

```xml
<element name="card">
  <choice>
    <element name="name"><text/></element>
    <group>
      <element name="givenName"><text/></element>
      <element name="familyName"><text/></element>
    </group>
  </choice>
  <element name="email"><text/></element>
</element>
```

### Odpowiednik DTD

```xml
<!ELEMENT card ((name | (givenName, familyName)), email)>
```

### Znaczenie

- `choice` = **albo** `name`, **albo** para `givenName` + `familyName`,
- `group` = **grupowanie** (sekwencja), potrzebne, gdy alternatywa dotyczy więcej niż jednego elementu.

---

## Wzorzec group — sekwencja

`group` grupuje wzorce w **sekwencję** (wszystkie po kolei):

```xml
<group>
  <element name="givenName"><text/></element>
  <element name="familyName"><text/></element>
</group>
```

### Kiedy group jest konieczny?

`group` jest potrzebny, gdy chcemy zgrupować kilka wzorców jako **całość** — np. jako jedną gałąź `choice`.

> Bez `group` nie dałoby się wyrazić "albo pojedynczy `name`, albo para `givenName`+`familyName`" — bo `choice` przyjmuje pojedyncze wzorce.

---

## Wzorzec interleave — przeplot

`interleave` pozwala elementom potomnym występować w **dowolnej kolejności**:

```xml
<element name="card">
  <interleave>
    <element name="name"><text/></element>
    <element name="email"><text/></element>
  </interleave>
</element>
```

### Semantyka interleave

Sekwencja elementów pasuje do `interleave`, jeśli jest **przeplotem** (interleavingiem) sekwencji pasujących do wzorców-dzieci.

### Przykład z HTML `<head>`

```xml
<element name="head">
  <interleave>
    <ref name="title"/>
    <optional><ref name="base"/></optional>
    <zeroOrMore><ref name="style"/></zeroOrMore>
    <zeroOrMore><ref name="script"/></zeroOrMore>
    <zeroOrMore><ref name="link"/></zeroOrMore>
    <zeroOrMore><ref name="meta"/></zeroOrMore>
  </interleave>
</element>
```

> `interleave` to cecha **unikatowa** Relax NG — ani DTD, ani XML Schema nie oferują tak elastycznego mechanizmu.

---

## interleave vs łącznik `&` z SGML

`interleave` jest **silniejszy** niż łącznik `&` znany z SGML:

| Wyrażenie | Dopasuje `A A B`? | Dopasuje `A B A`? |
|---|---|---|
| `A* & B` (SGML) | ✅ tak | ❌ nie |
| `interleave(A*, B)` (Relax NG) | ✅ tak | ✅ tak |

> `interleave` pozwala na **pełne przeplatanie** sekwencji, podczas gdy `&` wymaga blokowego ułożenia.

---

## Wzorzec mixed — zawartość mieszana

`mixed` to **skrót** dla przeplatania tekstu z innymi wzorcami:

```
<mixed> p </mixed>  ⟺  <interleave> <text/> p </interleave>
```

### Przykład — treść mieszana

```xml
<define name="paragraph">
  <mixed>
    <zeroOrMore>
      <choice>
        <element name="bold"><ref name="inline"/></element>
        <element name="italic"><ref name="inline"/></element>
      </choice>
    </zeroOrMore>
  </mixed>
</define>
```

> `mixed` naturalnie wyraża treść typu "tekst przeplatany elementami formatującymi" — bez ograniczeń znanych z DTD.

---

## Elementy a atrybuty — kolejność

Relax NG zachowuje **rozróżnienie** między elementami a atrybutami:

### Kolejność elementów — istotna

```xml
<element name="card">
  <element name="name"><text/></element>
  <element name="email"><text/></element>
</element>
```

Powyższy wzorzec **nie** dopasuje `<card><email>...</email><name>...</name></card>` — elementy muszą być w zadeklarowanej kolejności.

### Kolejność atrybutów — nieistotna

Wzorzec `<attribute name="name"/><attribute name="email"/>` dopasuje **oba** układy atrybutów (kolejność atrybutów w XML nie ma znaczenia).

> Zasada: kolejność **elementów** ma znaczenie, kolejność **atrybutów** nie — zgodnie z modelem XML.

---

## Domyślna zawartość: text vs empty

Ważna asymetria między wzorcami `element` i `attribute`:

| Wzorzec | Domyślna zawartość | Zapis skrócony |
|---|---|---|
| `<attribute name="x"/>` | `<text/>` | `attribute` bez treści = tekst |
| `<element name="x"/>` | **niedozwolone** | element wymaga jawnego wzorca |

### Przykład

```xml
<attribute name="email"/>        <!-- = <attribute name="email"><text/></attribute> -->
<element name="x"><empty/></element>  <!-- element bez treści wymaga <empty/> -->
```

> Element bez treści i atrybutów opisuje się jawnie przez `<empty/>`. Wyjątek: element z samymi atrybutami nie wymaga `<empty/>` — atrybuty już "wypełniają" wzorzec.

---

# Część 4
## Gramatyki i nazwane wzorce

---

## Wzorce nazwane: grammar, start, define, ref

Dla nietrywialnych schematów wygodnie jest **nazywać** części wzorca:

```xml
<grammar>
  <start>
    <element name="addressBook">
      <zeroOrMore>
        <element name="card"><ref name="cardContent"/></element>
      </zeroOrMore>
    </element>
  </start>
  <define name="cardContent">
    <element name="name"><text/></element>
    <element name="email"><text/></element>
  </define>
</grammar>
```

### Struktura gramatyki

| Element | Rola |
|---|---|
| `<grammar>` | Kontener gramatyki — jeden `<start>` i zero lub więcej `<define>` |
| `<start>` | Wzorzec początkowy (dopasowywany do całego dokumentu) |
| `<define>` | Nazwana definicja wzorca |
| `<ref>` | Odwołanie do nazwanej definicji |

> Gramatyka jest dopasowywana przez dopasowanie wzorca w elemencie `<start>`.

---

## Styl zbliżony do DTD

Relax NG pozwala pisać gramatyki w stylu przypominającym DTD — każdy element jako osobna definicja:

```xml
<grammar>
  <start><ref name="AddressBook"/></start>
  <define name="AddressBook">
    <element name="addressBook">
      <zeroOrMore><ref name="Card"/></zeroOrMore>
    </element>
  </define>
  <define name="Card">
    <element name="card">
      <ref name="Name"/>
      <ref name="Email"/>
    </element>
  </define>
  <define name="Name">
    <element name="name"><text/></element>
  </define>
  <define name="Email">
    <element name="email"><text/></element>
  </define>
</grammar>
```

> Ten styl jest czytelny dla osób przyzwyczajonych do DTD — każda definicja odpowiada jednemu typowi dokumentu.

---

## Odwołania rekurencyjne

Relax NG pozwala na **rekurencyjne odwołania** — pod warunkiem, że rekursja jest "przez element":

```xml
<define name="inline">
  <zeroOrMore>
    <choice>
      <text/>
      <element name="bold"><ref name="inline"/></element>
      <element name="italic"><ref name="inline"/></element>
    </choice>
  </zeroOrMore>
</define>
```

### Ograniczenie rekursji

Rekurencyjne odwołanie musi **przechodzić przez element**. Poniższa definicja jest **niedozwolona** (rekursja bezpośrednia bez elementu):

```xml
<!-- NIEDOZWOLONE -->
<define name="inline">
  <choice>
    <text/>
    <ref name="inline"/>   <!-- rekursja nie przez element -->
  </choice>
</define>
```

> To ograniczenie gwarantuje **rozstrzygalność** gramatyki — zapobiega nieskończonym pętlom.

---

# Część 5
## Typy danych

---

## Wzorzec data — typy danych

Relax NG odwołuje się do **zewnętrznych bibliotek typów** (np. W3C XML Schema Datatypes):

```xml
<element name="number">
  <data type="integer"
        datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"/>
</element>
```

### Atrybuty wzorca data

| Atrybut | Rola |
|---|---|
| `type` | Nazwa typu w bibliotece |
| `datatypeLibrary` | URI identyfikujące bibliotekę typów |

### Domyślna biblioteka

Atrybut `datatypeLibrary` może być **dziedziczony** — zwykle deklaruje się go na elemencie głównym:

```xml
<element name="point" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
  <element name="x"><data type="double"/></element>
  <element name="y"><data type="double"/></element>
</element>
```

---

## Ograniczenie: data musi dopasować całość

Wzorzec `data` musi dopasować **całą zawartość** elementu lub atrybutu — nie można mieszać `data` z innymi wzorcami treści:

### Niedozwolone

```xml
<element name="bad">
  <data type="int"/>
  <element name="note"><text/></element>  <!-- mieszanie data + element -->
</element>
```

### Dozwolone

```xml
<element name="ok">
  <data type="int"/>
  <attribute name="note"><text/></attribute>  <!-- atrybut obok data -->
</element>
```

> Ograniczenie to nie dotyczy wzorca `<text/>` — tylko `data` i `value` muszą dopasować całość.

---

## Parametry typów danych

Typy danych mogą mieć **parametry** przekazywane elementem `<param>`:

```xml
<element name="email">
  <data type="string">
    <param name="maxLength">127</param>
  </data>
</element>
```

### Zasada

- Parametry definiowane są przez **słownik typów** (datatyping vocabulary),
- `<param name="...">wartość</param>` jako dziecko elementu `data`.

> Dzięki parametrom Relax NG może wyrazić np. "napis o maksymalnej długości 127 znaków" — podobnie jak aspekty w XML Schema.

---

## Wzorzec value — wyliczenia

`value` dopasowuje **konkretną wartość** (wyliczenie):

```xml
<element name="card">
  <attribute name="preferredFormat">
    <choice>
      <value>html</value>
      <value>text</value>
    </choice>
  </attribute>
</element>
```

### value vs data

| Wzorzec | Znaczenie |
|---|---|
| `<data>` | **dowolna** wartość danego typu |
| `<value>` | **konkretna** wartość danego typu |

### Normalizacja białych znaków

Domyślnie `value` porównuje po **normalizacji białych znaków** (usunięcie skrajnych, scalenie środkowych). Aby porównywać dokładnie, użyj `type="string"`:

```xml
<value type="string">html</value>
```

> `value type="string"` porównuje **bez** normalizacji — "  html  " nie dopasuje "html".

---

## Wzorzec list — listy wartości

`list` dopasowuje **ciąg tokenów rozdzielonych spacjami**:

```xml
<element name="vector">
  <list>
    <data type="float"/>
    <data type="float"/>
  </list>
</element>
```

### Warianty

**Jeden lub więcej elementów:**
```xml
<element name="vector">
  <list>
    <oneOrMore><data type="double"/></oneOrMore>
  </list>
</element>
```

**Parzysta liczba elementów (pary):**
```xml
<element name="path">
  <list>
    <oneOrMore>
      <data type="double"/>
      <data type="double"/>
    </oneOrMore>
  </list>
</element>
```

> `list` dzieli napis na tokeny i dopasowuje je do wzorca wewnętrznego — odpowiednik `xsd:list`.

---

# Część 6
## Przestrzenie nazw i klasy nazw

---

## Przestrzenie nazw — atrybut ns

Relax NG jest **świadomy przestrzeni nazw** — nazwa elementu/atrybutu składa się z nazwy lokalnej i URI przestrzeni nazw.

```xml
<element name="foo" ns="http://www.example.com">
  <empty/>
</element>
```

### Dopasuje

```xml
<foo xmlns="http://www.example.com"/>
<e:foo xmlns:e="http://www.example.com"/>
<example:foo xmlns:example="http://www.example.com"/>
```

### Nie dopasuje

```xml
<foo/>
<e:foo xmlns:e="http://WWW.EXAMPLE.COM"/>   <!-- wielkość liter! -->
<example:foo xmlns:example="http://www.example.net"/>
```

---

## Dziedziczenie atrybutu ns

Atrybut `ns` jest **dziedziczony** przez elementy potomne:

```xml
<element name="addressBook" ns="http://www.example.com">
  <zeroOrMore>
    <element name="card">   <!-- dziedziczy ns -->
      <element name="name"><text/></element>
    </element>
  </zeroOrMore>
</element>
```

### Różnica dla atrybutów

Atrybut `ns` **nie jest dziedziczony** przez wzorce `attribute` — domyślnie mają pustą przestrzeń nazw:

```xml
<attribute name="name" ns=""/>   <!-- domyślnie pusta -->
```

> To odzwierciedla fakt, że w XML atrybuty **nie dziedziczą** domyślnej przestrzeni nazw.

---

## Nazwy kwalifikowane

Zamiast atrybutu `ns` można używać **prefiksów** w wartości `name`:

```xml
<element name="ab:addressBook"
         xmlns:ab="http://www.example.com/addressBook"
         xmlns:a="http://www.example.com/address">
  <zeroOrMore>
    <element name="ab:card">
      <element name="a:name"><text/></element>
      <element name="a:email"><text/></element>
    </element>
  </zeroOrMore>
</element>
```

### Zasada

Prefiks w `name` **określa przestrzeń nazw** niezależnie od atrybutu `ns`. Domyślna przestrzeń nazw (xmlns) **nie** wpływa na dopasowywanie nazw we wzorcach.

---

## Klasy nazw (name classes)

Klasa nazw pozwala dopasować **wiele nazw** naraz. Podstawowe klasy:

| Klasa | Znaczenie |
|---|---|
| `<anyName/>` | dowolna nazwa (lokalna + przestrzeń) |
| `<nsName/>` | dowolna nazwa w danej przestrzeni nazw |
| `<name>` | konkretna nazwa |
| `<choice>` | suma klas |
| `<except>` | wykluczenie z klasy |

### Przykład — dowolny dokument XML

```xml
<define name="anyElement">
  <element>
    <anyName/>
    <zeroOrMore>
      <choice>
        <attribute><anyName/></attribute>
        <text/>
        <ref name="anyElement"/>
      </choice>
    </zeroOrMore>
  </element>
</define>
```

---

## Klasy nazw — except i nsName

```xml
<element name="card" ns="http://www.example.com">
  <zeroOrMore>
    <attribute>
      <anyName>
        <except>
          <nsName/>
          <nsName ns=""/>
        </except>
      </anyName>
    </attribute>
  </zeroOrMore>
  <text/>
</element>
```

### Znaczenie

Powyższy wzorzec pozwala elementowi `card` na **dowolną liczbę atrybutów** kwalifikowanych przestrzenią nazw **inną** niż przestrzeń `card` — ale nie z przestrzeni `card` ani bez przestrzeni.

### Zastosowanie klas nazw

Klasy nazw umożliwiają **otwartą walidację** (*lax validation*) — pozwalają na "dowolne atrybuty z wyjątkiem tych, które definiujemy ściśle".

---

## Lax validation — przykład z xml:space

Problem: chcemy pozwolić na **dowolne atrybuty**, ale jeśli wystąpi `xml:space`, to musi mieć wartość `default` lub `preserve`.

### Rozwiązanie z except

```xml
<element name="example">
  <zeroOrMore>
    <attribute>
      <anyName>
        <except>
          <name>xml:space</name>
        </except>
      </anyName>
    </attribute>
  </zeroOrMore>
  <optional>
    <attribute name="xml:space">
      <choice>
        <value>default</value>
        <value>preserve</value>
      </choice>
    </attribute>
  </optional>
</element>
```

> Klasa `anyName` z `except` pozwala wykluczyć `xml:space` z "dowolności", a następnie zdefiniować go **ściśle** osobno.

---

# Część 7
## Modularyzacja

---

## Odwołania zewnętrzne — externalRef

`externalRef` odwołuje się do wzorca zdefiniowanego w **osobnym pliku**:

```xml
<element name="note">
  <externalRef href="inline.rng"/>
</element>
```

### Łączenie wzorców z plików

```xml
<choice>
  <externalRef href="pattern1.rng"/>
  <externalRef href="pattern2.rng"/>
</choice>
```

> `externalRef` to prosty mechanizm **wielokrotnego użycia** schematów z osobnych plików.

---

## Łączenie definicji — combine

Wiele definicji o tej samej nazwie łączy się atrybutem `combine`:

```xml
<define name="inline.class" combine="choice">
  <element name="bold"><ref name="inline"/></element>
</define>
<define name="inline.class" combine="choice">
  <element name="italic"><ref name="inline"/></element>
</define>
```

Jest to równoważne:

```xml
<define name="inline.class">
  <choice>
    <element name="bold"><ref name="inline"/></element>
    <element name="italic"><ref name="inline"/></element>
  </choice>
</define>
```

### Wartości combine

| Wartość | Znaczenie |
|---|---|
| `choice` | suma alternatyw (elementy) |
| `interleave` | przeplot (zwykle dla atrybutów) |

---

## combine="interleave" dla atrybutów

Przy łączeniu atrybutów typowo używa się `interleave`:

```xml
<define name="card.attlist" combine="interleave">
  <attribute name="name"><text/></attribute>
</define>
<define name="card.attlist" combine="interleave">
  <attribute name="email"><text/></attribute>
</define>
```

Jest to równoważne (dla atrybutów kolejność nie ma znaczenia):

```xml
<define name="card.attlist">
  <group>
    <attribute name="name"><text/></attribute>
    <attribute name="email"><text/></attribute>
  </group>
</define>
```

> Zasada: `combine="choice"` dla elementów, `combine="interleave"` dla atrybutów.

---

## Scalanie gramatyk — include

`include` scala gramatyki z osobnych plików:

```xml
<grammar>
  <include href="inline.rng"/>
  <start>
    <element name="doc">
      <zeroOrMore>
        <element name="p"><ref name="inline"/></element>
      </zeroOrMore>
    </element>
  </start>
  <define name="inline.class" combine="choice">
    <choice>
      <element name="code"><ref name="inline"/></element>
      <element name="em"><ref name="inline"/></element>
    </choice>
  </define>
</grammar>
```

### Działanie

- Definicje z `inline.rng` są **dołączane** do gramatyki,
- `combine="choice"` **rozszerza** definicję `inline.class` o nowe elementy.

---

## notAllowed — wzorzec "nic"

`notAllowed` **nigdy nic nie dopasowuje** — używany do budowy punktów rozszerzeń:

```xml
<grammar>
  <define name="inline">
    <zeroOrMore>
      <choice>
        <text/>
        <element name="bold"><ref name="inline"/></element>
        <element name="italic"><ref name="inline"/></element>
        <ref name="inline.extra"/>
      </choice>
    </zeroOrMore>
  </define>
  <define name="inline.extra">
    <notAllowed/>
  </define>
</grammar>
```

### Zastosowanie

`inline.extra` jest domyślnie "pusty" (nic nie dopasowuje), ale gramatyka dołączająca może go **rozszerzyć** przez `combine="choice"`:

```xml
<define name="inline.extra" combine="choice">
  <choice>
    <element name="code"><ref name="inline"/></element>
    <element name="em"><ref name="inline"/></element>
  </choice>
</define>
```

> `notAllowed` pełni rolę **wtyczki rozszerzeń** — jak punkt zaczepienia dla przyszłych modyfikacji.

---

## Zastępowanie definicji — include z define

Element `include` może zawierać `define`, które **zastępują** definicje z dołączanej gramatyki:

```xml
<grammar>
  <include href="addressBook.rng">
    <define name="cardContent">
      <element name="name"><text/></element>
      <element name="emailAddress"><text/></element>
    </define>
  </include>
</grammar>
```

### Zasada

- Definicja `cardContent` w `include` **zastępuje** oryginalną,
- Analogicznie `start` wewnątrz `include` zastępuje `start` dołączanej gramatyki.

---

## Gramatyki zagnieżdżone — parentRef

Relax NG pozwala **zagnieżdżać gramatyki**. `parentRef` ucieka z bieżącej gramatyki do definicji gramatyki **nadrzędnej**:

```xml
<grammar>
  <start>
    <element name="doc">
      <zeroOrMore>
        <choice>
          <element name="p"><ref name="inline"/></element>
          <grammar>
            <include href="table.rng">
              <define name="cell.content">
                <parentRef name="inline"/>
              </define>
            </include>
          </grammar>
        </choice>
      </zeroOrMore>
    </element>
  </start>
  <define name="inline">
    <zeroOrMore>
      <choice>
        <text/>
        <element name="em"><ref name="inline"/></element>
      </choice>
    </zeroOrMore>
  </define>
</grammar>
```

### Znaczenie

Wzorzec `table.rng` (zagnieżdżona gramatyka) redefiniuje `cell.content`, odwołując się do `inline` z gramatyki **zewnętrznej** — to umożliwia **parametryzację** dołączanych modułów.

---

## Adnotacje

Elementy i atrybuty z **innej przestrzeni nazw** niż Relax NG są **ignorowane** — można ich używać jako adnotacji:

```xml
<element name="card"
         xmlns:a="http://www.example.com/annotation">
  <a:documentation>Informacja o karcie.</a:documentation>
  <element name="name"><text/></element>
  <element name="email"><text/></element>
</element>
```

### Element div

`div` grupuje definicje (np. w moduły) i przenosi adnotacje:

```xml
<grammar xmlns:m="http://www.example.com/module">
  <div m:name="inline">
    <define name="code">...</define>
    <define name="em">...</define>
  </div>
  <div m:name="block">
    <define name="p">...</define>
  </div>
</grammar>
```

---

## Podsumowanie

| Temat | Kluczowe wnioski |
|---|---|
| **Relax NG** | Język schematów oparty na gramatykach regularnych (ISO 19757-2) |
| **Dwie składnie** | XML (pełna) i compact (skrótowa) |
| **Wzorce** | element, attribute, text, empty, group, choice, optional, zeroOrMore, oneOrMore |
| **interleave/mixed** | Unikatowy mechanizm przeplotu — brak odpowiednika w DTD/XSD |
| **Gramatyki** | grammar, start, define, ref — nazwane wzorce i rekursja |
| **Typy danych** | data (typy zewnętrzne), value (wyliczenia), list (listy) |
| **Przestrzenie nazw** | ns, klasy nazw: anyName, nsName, except |
| **Modularyzacja** | externalRef, combine, include, notAllowed, parentRef |

### Porównanie trzech języków

| | DTD | XML Schema | Relax NG |
|---|---|---|---|
| **Prostota** | wysoka | niska | średnia |
| **Siła wyrazu** | niska | wysoka | wysoka |
| **Jednolitość** | — | podział typów | jednolite wzorce |
| **Przeplot** | brak | brak | tak |

---

# Dziękuję za uwagę

**Systemy Zarządzania Treścią**  
Politechnika Poznańska