Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/zaid-ajaj/fable.simplexml
A library for easily parsing and working with XML in Fable projects
https://github.com/zaid-ajaj/fable.simplexml
fable parser xml xml-parser
Last synced: about 2 months ago
JSON representation
A library for easily parsing and working with XML in Fable projects
- Host: GitHub
- URL: https://github.com/zaid-ajaj/fable.simplexml
- Owner: Zaid-Ajaj
- License: mit
- Created: 2018-01-08T07:16:26.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2023-01-07T13:40:35.000Z (almost 2 years ago)
- Last Synced: 2024-10-12T13:25:37.285Z (2 months ago)
- Topics: fable, parser, xml, xml-parser
- Language: F#
- Homepage: https://zaid-ajaj.github.io/Fable.SimpleXml/
- Size: 1.36 MB
- Stars: 16
- Watchers: 3
- Forks: 4
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Fable.SimpleXml [](https://travis-ci.org/Zaid-Ajaj/Fable.SimpleXml) [](https://ci.appveyor.com/project/Zaid-Ajaj/fable-simplexml) [](https://www.nuget.org/packages/Fable.SimpleXml)
A simple library for parsing Xml strings into structured Xml data. Works in browser and node without installing any extra javascript dependencies. It is written using parser combinators from [Fable.Parsimmon](https://github.com/Zaid-Ajaj/Fable.Parsimmon)
### See the library in action in the [Test page](https://zaid-ajaj.github.io/Fable.SimpleXml/)
### Installation
Install from nuget using paket
```sh
paket add nuget Fable.SimpleXml --project path/to/YourProject.fsproj
```
Make sure the references are added to your paket files
```sh
# paket.dependencies (solution-wide dependencies)
nuget Fable.SimpleXml
# paket.refernces (project-specific dependencies)
Fable.SimpleXml
```
### Example usage
```fs
type Person = { Id : int; Name: string }
let createPerson id name =
{ Id = id; Name = name }
"""
"""
|> SimpleXml.parseElement
|> SimpleXml.findElementsByName "Person"
|> List.map (fun elem ->
let id = int (Map.find "Id" elem.Attributes)
let name = Map.find "Name" elem.Attributes
createPerson id name)
```
Or you can inspect the content of the elements:
```fs
testCase "SimpleXml use case" <| fun test ->
"
John
Jane
"
|> SimpleXml.parseElementNonStrict
|> SimpleXml.children
|> List.map SimpleXml.content
|> test.areEqual [ "John"; "Jane" ]
```
### API
```fs
// Parsing functions
SimpleXml.tryParseElement : string -> Option
SimpleXml.parseElement : string -> XmlElement
SimpleXml.tryParseDocument : string -> Option
SimpleXml.parseDocument : string -> XmlDocument
// Non strict parsing functions, exludes text nodes between elements (leaving Content intact)
SimpleXml.parseElementNonStrict : string -> XmlElement
SimpleXml.tryParseElementNonStrict : string -> Option
SimpleXml.tryParseDocumentNonStrict : string -> Option
SimpleXml.parseDocumentNonStrict : string -> XmlDocument
// Search functions
SimpleXml.findElementsBy : (XmlElement -> bool) -> XmlElement -> XmlElement list
SimpleXml.findElementsByName : string -> XmlElement -> XmlElement list
SimpleXml.findElementByName : string -> XmlElement -> XmlElement
SimpleXml.findElementsByExactAttributes : Map -> XmlElement -> XmlElement list
SimpleXml.findElementByAttribute : string -> string -> XmlElement -> XmlElement list
SimpleXml.tryFindElementByAttributes : Map -> XmlElement -> Option
SimpleXml.tryFindElementByName : string -> XmlElement -> Option
/// ... AND MORE ...
```
Where `XmlElement` and `XmlDocument` are defined as follows:
```fs
type XmlElement = {
Namespace : string option
Name : string
Attributes : Map
Content : string
Children : XmlElement list
SelfClosing : bool
IsTextNode : bool
IsComment : bool
}
type XmlDocument = {
Declaration : Map option
Root : XmlElement
}
```
### Generate Xml:
Create Xml from a tree structure. Opening the `Fable.SimpleXml.Generator` module, gives you access to these:
- `node`: creates a nested element
- `leaf`: creates a self-closing element
- `text`: creates a terminal node with text
- `comment`: creates a comment
- `namespace`: adds a namespace prefix to a `node` or a `leaf`
- `attr.value`: create an attribute
- `ofXmlElement`/`ofXmlElements`: Can be used to convert a `XmlElemnt` to a Xml tree
- `serializeXml`: converts a Xml tree to a xml string
> Indentation is not supported yet. PR's are welcome ;)
```fs
open Fable.SimpleXml.Generator
let people =
node "people" [ ] [
leaf "person" [
attr.value("name", "John Doe")
attr.value("age", 26)
attr.value("married", false)
]
leaf "person" [
attr.value("name", "Jane Doe")
attr.value("age", 25)
attr.value("married", true)
]
]
serializeXml people
```
will generate:
```xml
```
Use nested property
```fs
let person =
node "person" [ ] [
node "id" [ ] [ text "1" ]
node "name" [ ] [ text "John" ]
node "married" [ ] [ text "false" ]
]
serializeXml person
```
will generate
```xml
1
John
false
```
Access any xml to update/change it
```fs
let xml =
"""people>
"""
let parsedXml = SimpleXml.parseElement xml
// .. Work with the xml by removing, changing, adding any xml element or attribute including comments and namespaces. ..
// Revert XmlElement back to xml string
let xmlTree = Generator.ofXmlElement parsedXml
serializeXml xmlTree
```
### Running sample app locally
```sh
./build.sh RunSample
#or
build RunSample
```
### Running the tests live
```sh
./build.sh RunLiveTests
```
### Building the tests and running QUnit cli runner
```sh
./build.sh RunTests
```
or just `Ctrl + Shift + B` to run the cli tests as a VS Code task