meta-tech/pluie-yaml
meta-tech/pluie-yaml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: meta-tech:master
Branches Tags
meta-tech:master
meta-tech:fix-processor
meta-tech:tag-impl-2
meta-tech:tag-impl
meta-tech:latest
meta-tech:0.60
meta-tech:0.56
meta-tech:0.55
meta-tech:0.54
meta-tech:0.53
meta-tech:0.52
meta-tech:0.50
meta-tech:0.51
meta-tech:0.45
meta-tech:0.44
meta-tech:0.43
meta-tech:0.42
meta-tech:0.41
meta-tech:0.40
meta-tech:0.31
meta-tech:0.30
..
compare: meta-tech:tag-impl
Branches Tags
meta-tech:master
meta-tech:fix-processor
meta-tech:tag-impl-2
meta-tech:tag-impl
meta-tech:latest
meta-tech:0.60
meta-tech:0.56
meta-tech:0.55
meta-tech:0.54
meta-tech:0.53
meta-tech:0.52
meta-tech:0.50
meta-tech:0.51
meta-tech:0.45
meta-tech:0.44
meta-tech:0.43
meta-tech:0.42
meta-tech:0.41
meta-tech:0.40
meta-tech:0.31
meta-tech:0.30

No commits in common. "master" and "tag-impl" have entirely different histories.
master ... tag-impl

58 changed files with 1380 additions and 4029 deletions
Show Stats Expand all files Collapse all files

74
.berel.yml
View File

@ -1,74 +0,0 @@
%YAML 1.2
%TAG !v! tag:pluie.org,2018:vala/
---
!v!Pluie.Berel.Meta meta :
keys :
software : pluie-yaml; <https://git.pluie.org/pluie/lib-yaml>
version : 0.60
type : library
date : 2018
license : GPLv3.0; <http://www.gnu.org/licenses/>
author : a-Sansara; <[dev]at[pluie]dot[org]>
copyright : pluie.org; <http://www.pluie.org>
headers :
- sh :
file :
- build.sh
- valadoc.sh
startline : 2 # to embed shebang before header tpl
sepline :
motif : "# "
repeat : 40
comment :
start : "#^#"
end : "#^#"
begin : "# "
- meson :
file :
- meson.build
- src/meson.build
sepline :
motif : "# "
repeat : 40
comment :
start : "#^#"
end : "#^#"
begin : "# "
- vala :
dir :
- src
- samples
extension :
- .vala
- .c
sepline :
motif : " *"
repeat : 40
comment :
start : "/*^"
end : "^*/"
begin : " * "
tpl : |
^sepline^
^keys^
^sepline^
This file is part of ^software.name^.
^software.name^ is free software (free as in speech) : you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.
^software.name^ is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
You should have received a copy of the GNU General Public License
along with ^software.name^. If not, see ^license.address^.
^sepline^

4
.gitignore vendored
View File

@ -2,7 +2,3 @@ build/
bin/
doc/
pluie-yaml-*.tar.gz
.geany
docfix*
docsvg.tar.gz
tag-generated.yml

185
README.md
View File

@ -10,17 +10,34 @@ in the main yaml document.
The lib partially manage tag directives and tag values (basic types and Yaml.Object extended objects types).
with version 0.5, **pluie-yaml** is now able to :
* parse yaml file with vala tags => transform to Yaml.Node
* Build Yaml.Object from Yaml.Node (with some glue for struct and non Yaml.Object derived types)
* Build Yaml.Node from Yaml.Object (with some glue for struct and non Yaml.Object derived types)
**pluie-yaml** use the ![libyaml c library](https://github.com/yaml/libyaml) (License MIT, many thanks to Kirill Simonov) to parse and retriew related yaml events.
![pluie-yaml-1](https://www.meta-tech.academy/img/pluie-yaml-1.png?tmp=1)
![pluie-yaml](https://www.meta-tech.academy/img/pluie-yaml-imports2.png)
![pluie-yaml-2](https://www.meta-tech.academy/img/pluie-yaml-2.png)
_legend display_childs_ :
```
[ node.name [refCount] node.parent.name node.level node.ntype.infos () node.count () node.uuid node.tag]
```
You can easily manage display tracing of yaml nodes by setting these var according to your needs :
```vala
namespace Pluie
{
namespace Yaml
{
public static bool DEBUG = false;
public static bool DBG_SHOW_INDENT = true;
public static bool DBG_SHOW_PARENT = false;
public static bool DBG_SHOW_UUID = true;
public static bool DBG_SHOW_LEVEL = false;
public static bool DBG_SHOW_REF = false;
public static bool DBG_SHOW_COUNT = true;
public static bool DBG_SHOW_TAG = true;
public static bool DBG_SHOW_TYPE = true;
```
## License
@ -28,7 +45,7 @@ GNU GPL v3
## Prerequisites
`valac meson ninja libyaml glib gobject gmodule gio gee pluie-echo`
`valac meson ninja libyaml glib gobject gmodule gee pluie-echo`
see https://git.pluie.org/pluie/libpluie-echo in order to install pluie-echo-0.2 pkg
@ -45,32 +62,15 @@ sudo ninja install -C build
## Compilation
```
valac --pkg glib-2.0 \
--pkg gobject-2.0 \
--pkg gmodule-2.0 \
--pkg gio-2.0 \
--pkg gee-0.8 \
--pkg pluie-echo-0.2 \
--pkg pluie-yaml-0.4 \
main.vala
valac --pkg pluie-echo-0.2 --pkg pluie-yaml-0.4 main.vala
```
You can use `./build.sh` to rebuild/install the **pluie-yaml** lib and compile samples files
```
# rebuild lib + build all samples
./build.sh
# rebuild lib + build only single sample (give sample file name without extension)
./build.sh yaml-serialize
# rebuild lib in local mode
# local mode avoid to rebuild when modifying yaml files in resources dir
# must be in the root directory
./build.sh yaml-serialize 1
```
## Api / Documentation
https://pluie.org/pluie-yaml-0.6/index.htm
https://pluie.org/pluie-yaml-0.5/index.htm
## Docker
@ -135,34 +135,6 @@ see Finder below to get precisions about config.get parameter (search path defin
db : db.yml
```
![pluie-yaml](https://www.meta-tech.academy/img/pluie-yaml-imports2.png)
__legend display_childs__ :
```
[ node.name [refCount] node.parent.name node.level node.ntype.infos () node.count () node.uuid node.tag]
```
You can easily manage display tracing of yaml nodes by setting these var according to your needs :
```vala
using Pluie
...
// general debug display usefull informations
Yaml.DEBUG = false;
// drive display_childs method :
Yaml.DBG_SHOW_INDENT = true;
Yaml.DBG_SHOW_PARENT = false;
Yaml.DBG_SHOW_UUID = true;
Yaml.DBG_SHOW_LEVEL = false;
Yaml.DBG_SHOW_REF = false;
Yaml.DBG_SHOW_COUNT = true;
Yaml.DBG_SHOW_TAG = true;
Yaml.DBG_SHOW_TYPE = true;
...
```
-------------------
### loader
@ -297,7 +269,7 @@ on yaml side, proceed like that :
%YAML 1.2
%TAG !v! tag:pluie.org,2018:vala/
---
!v!Pluie.Samples.YamlObject test1 :
!v!Pluie.Yaml.Example test1 :
myname : test1object
type_int : !v!int 3306
type_bool : !v!bool false
@ -308,12 +280,12 @@ on yaml side, proceed like that :
type_float : !v!float 42.36
type_double : !v!double 95542123.4579512128
type_enum : !v!Pluie.Yaml.NODE_TYPE scalar # or int
!v!Pluie.Samples.YamlChild type_object :
!v!Pluie.Yaml.ExampleChild type_object :
toto : totovalue1
tata : tatavalue1
titi : 123
tutu : 1
!v!Pluie.Samples.YamlStruct type_struct :
!v!Pluie.Yaml.ExampleStruct type_struct :
red : !v!uint8 214
green : !v!uint8 78
blue : 153
@ -328,18 +300,16 @@ on yaml side, proceed like that :
**note :**
only the first level of yaml node matching a vala object need a tag.
**pluie-yaml** has mechanisms to retriew properties types of a Yaml.Object.
So basic vala types tag, enum tag, struct tag and derived Yaml.Object (here Samples.YamlObject & Samples.YamlChild)
or GLib.Object.
vala tags are not necessary inside a Yaml.Object.
So basic vala types tag, enum tag, struct tag and derived Yaml.Object (here ExampleChild)
or GLib.Object vala tags are not necessary inside a Yaml.Object.
on vala side :
```vala
using pluie;
...
var obj = (Samples.YamlObject) Yaml.Builder.from_node (root.first ());
var obj = (Yaml.Example) Yaml.Builder.from_node (root.first ());
of.echo("obj.type_int : %d".printf (obj.type_int));
// calling Samples.YamlChild method
// calling ExampleChild method
obj.type_object.method_a ()
```
@ -356,31 +326,26 @@ We cannot do introspection on Structure's properties, so you need to implement a
First at all, in the static construct of your class, you need to register (properties) types that need some glue for instanciation.
```vala
using Pluie;
public class Pluie.Samples.YamlObject : Yaml.Object
public class Example : Yaml.Object
{
static construct
{
Yaml.Register.add_type (
typeof (Samples.YamlObject), // owner type
typeof (Samples.YamlStruct), // property type
typeof (Gee.ArrayList) // property type
);
Yaml.Object.register.add_type (typeof (Example), typeof (ExampleStruct));
Yaml.Object.register.add_type (typeof (Example), typeof (Gee.ArrayList));
}
...
```
Secondly you must override the `public void populate_from_node (Glib.Type, Yaml.Node node)` Yaml.Object original method.
`populate_from_node` is automatically called by the Yaml.Builder if the type property is prealably registered.
Secondly you must override the `Yaml.Object populate_by_type (Glib.Type, Yaml.Node node)` original method.
`populate_by_type` is called by the Yaml.Builder only if the type property is prealably registered.
Example of implementation from `src/vala/Pluie/Samples.YamlObject.vala` :
Example of implementation from `src/vala/Pluie/Yaml.Example.vala` :
```vala
public override void populate_from_node(GLib.Type type, Yaml.Node node)
public override void populate_by_type(GLib.Type type, Yaml.Node node)
{
if (type == typeof (Samples.YamlStruct)) {
this.type_struct = Samples.YamlStruct.from_yaml_node (node);
if (type == typeof (Yaml.ExampleStruct)) {
this.type_struct = ExampleStruct.from_yaml_node (node);
}
else if (type == typeof (Gee.ArrayList)) {
this.type_gee_al = new Gee.ArrayList<string> ();
@ -396,9 +361,9 @@ Once your class has this glue, you can deal with complex object and populate the
directly from yaml files.
for more details see :
* `src/vala/Pluie/Samples.YamlObject.vala`
* `src/vala/Pluie/Samples.YamlChild.vala`
* `src/vala/Pluie/Samples.YamlStruct.vala`
* `src/vala/Pluie/Yaml.Example.vala`
* `src/vala/Pluie/Yaml.ExampleChild.vala`
* `src/vala/Pluie/Yaml.ExampleStruct.vala`
* `samples/yaml-tag.vala`
code from samples/yaml-tag.vala :
@ -409,56 +374,6 @@ output from samples/yaml-tag.vala :
![pluie-yaml-tag](https://www.meta-tech.academy/img/pluie-yaml-sample-tag-output.png?tmp=53)
### Build Yaml.Node from Yaml.Object
reverse build mechanism is also possible but have the same limitation.
```vala
var config = new Yaml.Config (path, true);
var root = config.root_node ();
root.display_childs ();
of.action ("Yaml.Builder.from_node", root.first ().name);
var obj = (Samples.YamlObject) Yaml.Builder.from_node (root.first ());
obj.type_object.method_a ();
of.action ("Yaml.Builder.to_node", obj.get_type ().name ());
var n = Yaml.Builder.to_node (obj);
if ((done = n !=null)) {
n.display_childs ();
}
```
you need to override the `public Yaml.Node? populate_to_node(GLib.Type type, string name)` Yaml.Object original method
`populate_to_node` is also automatically called by the Yaml.Builder if the type property is prealably registered.
Example of implementation from `src/vala/Pluie/Samples.YamlObject.vala` :
```vala
public override Yaml.Node? populate_to_node(GLib.Type type, string name)
{
Yaml.Node? node = base.populate_to_node (type, name);
// non Yaml.Object type & registered type
if (node == null) {
if (type == typeof (Samples.YamlStruct)) {
node = this.type_struct.to_yaml_node (name);
}
else if (type == typeof (Gee.ArrayList)) {
node = new Yaml.Sequence (null, name);
foreach (var data in this.type_gee_al) {
new Yaml.Scalar (node, data);
}
}
}
return node;
}
```
### Serialize/Deserialize
-------------------
### more samples
@ -474,10 +389,6 @@ see samples files in ./samples directory
* ~~rewrite nodes classes~~
* ~~put doc online~~
* ~~add docker image~~
* ~~transform Yaml.Node nodes to Yaml.Object objects~~
* ~~transform Yaml.Object objects to Yaml.Node nodes~~
* ~~dumper~~
* ~~serialize/deserialize~~
* manage tag directives & tag (partially done)
* improve doc
* dumper

73
build.sh
View File

@ -1,45 +1,43 @@
#!/bin/bash
#^# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
# @version : 0.60
# @type : library
# @date : 2018
# @license : GPLv3.0 <http://www.gnu.org/licenses/>
# @author : a-Sansara <[dev]at[pluie]dot[org]>
# @copyright : pluie.org <http://www.pluie.org>
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
# @version : 0.5
# @type : library
# @date : 2018
# @licence : GPLv3.0 <http://www.gnu.org/licenses/>
# @author : a-Sansara <[dev]at[pluie]dot[org]>
# @copyright : pluie.org <http://www.pluie.org/>
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# This file is part of pluie-yaml.
#
#
# pluie-yaml is free software (free as in speech) : you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation, either version 3 of the License,
# or (at your option) any later version.
#
# pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
#
# lib-yaml is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
# more details.
#
#
# You should have received a copy of the GNU General Public License
# along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
# along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #^#
# --------------------------------------------------------
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
lib="pluie-yaml-0.6"
samples=" src/vala/Pluie/Samples.YamlObject.vala \
src/vala/Pluie/Samples.YamlChild.vala \
src/vala/Pluie/Samples.YamlStruct.vala "
c1="\033[1;38;5;215m"
c2="\033[1;38;5;97m"
cok="\033[1;38;5;37m"
cko="\033[1;38;5;204m"
off="\033[m"
resume=
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
lib="pluie-yaml-0.5"
c1="\033[1;38;5;215m"
c2="\033[1;38;5;97m"
cok="\033[1;38;5;37m"
cko="\033[1;38;5;204m"
off="\033[m"
resume=
# --------------------------------------------------------
function build.title()
{
@ -65,11 +63,6 @@ function build.lib()
cd "$DIR"
build.title "$lib LIB BUILD"
meson --prefix=/usr ./ build
if [ "$1" -eq 1 ]; then
meson configure -DLOCAL=true build
else
meson configure -DLOCAL=false build
fi
if [ "$UID" != "0" ]; then
sudo ninja -v install -C build
else
@ -85,9 +78,7 @@ function build.samples()
for file in ./samples/*.vala
do
if [[ -f $file ]]; then
if [ -z "$1" ] || [ "$1" == "$file" ]; then
build.sample "$file"
fi
build.sample "$file"
fi
done
echo -e "\n RESUME : "
@ -102,9 +93,9 @@ function build.sample()
local f="$(basename $1)"
local fx="${f:0:-5}"
local state="FAILED"
local cmd="valac -v -X -Wno-discarded-qualifiers -X -Wno-deprecated-declarations --pkg gee-0.8 --pkg gio-2.0 --pkg pluie-echo-0.2 --pkg $lib $samples $1 -o ./bin/$fx"
local cmd="valac -v --pkg gee-0.8 --pkg pluie-echo-0.2 --pkg $lib $1 -o ./bin/$fx"
build.title "$f SAMPLE BUILD"
echo
echo -e "\n$cmd"
$cmd
local done=$?
resume="$resume$done$f "
@ -113,14 +104,10 @@ function build.sample()
# --------------------------------------------------------
function build.main()
{
local onefile=""
if [ ! -z "$1" ]; then
onefile="./samples/$1.vala"
fi
build.lib "$2"
build.lib
if [ $? -eq 0 ]; then
build.samples $onefile
build.samples
fi
}
build.main "$1" "${2:-0}"
build.main

38
install.vala.in Normal file
View File

@ -0,0 +1,38 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
namespace Pluie
{
namespace Yaml
{
protected const string INSTALL_PATH = "@INSTALL_PATH@";
public const string DATA_PATH = "@DATA_PATH@";
public const string VERSION = "@VERSION@";
}
}

116
meson.build
View File

@ -1,87 +1,105 @@
#^# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
# @version : 0.60
# @type : library
# @date : 2018
# @license : GPLv3.0 <http://www.gnu.org/licenses/>
# @author : a-Sansara <[dev]at[pluie]dot[org]>
# @copyright : pluie.org <http://www.pluie.org>
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
# @version : 0.5
# @type : library
# @date : 2018
# @licence : GPLv3.0 <http://www.gnu.org/licenses/>
# @author : a-Sansara <[dev]at[pluie]dot[org]>
# @copyright : pluie.org <http://www.pluie.org/>
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# This file is part of pluie-yaml.
#
# pluie-yaml is free software (free as in speech) : you can redistribute it
#
# lib-yaml is free software (free as in speech) : you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation, either version 3 of the License,
# or (at your option) any later version.
#
#
# pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
# more details.
#
#
# You should have received a copy of the GNU General Public License
# along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
# along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #^#
project('pluie-yaml', ['vala', 'c'], version:'0.6')
project('libpluie-yaml', 'vala', 'c', version:'0.5')
cc = meson.get_compiler('c')
version = meson.project_version()
dep_glib = dependency('glib-2.0')
dep_gobject = dependency('gobject-2.0')
dep_gmodule = dependency('gmodule-2.0')
dep_gio = dependency('gio-2.0')
dep_gee = dependency('gee-0.8')
dep_echo = dependency('pluie-echo-0.2')
dep_m = cc.find_library('m', required : false)
dep_yaml = cc.find_library('yaml', required : true)
#~ add_global_link_arguments('-lyaml', language : 'c')
version = '0.5'
bindir = join_paths(get_option('prefix'), get_option('bindir'))
datadir = join_paths(get_option('prefix'), get_option('datadir'), 'pluie/yaml')
libdir = join_paths(get_option('prefix'), get_option('libdir'), 'pkgconfig')
incdir = join_paths(get_option('prefix'), get_option('includedir'), 'pluie')
conf = configuration_data()
conf.set('VERSION' , version)
conf.set('INSTALL_PATH', bindir)
if get_option('LOCAL')
conf.set('DATA_PATH' , './resources')
else
conf.set('DATA_PATH' , datadir)
endif
conf.set('DATA_PATH' , datadir)
configure_file(
input: 'src/vala/install.vala.in',
input: 'install.vala.in',
output: 'install.vala',
configuration: conf
)
install_data([
'resources/main.yml',
'resources/tag.yml',
'resources/bug.yml',
'resources/test.yml',
'resources/test.json'
],
install_dir : datadir
)
sources = [
'build/install.vala',
'src/vala/Pluie/Io.Reader.vala',
'src/vala/Pluie/Io.StreamLineMark.vala',
'src/vala/Pluie/Yaml.global.vala',
'src/vala/Pluie/Yaml.AbstractChild.vala',
'src/vala/Pluie/Yaml.AbstractNode.vala',
'src/vala/Pluie/Yaml.Builder.vala',
'src/vala/Pluie/Yaml.Collection.vala',
'src/vala/Pluie/Yaml.Config.vala',
'src/vala/Pluie/Yaml.Event.vala',
'src/vala/Pluie/Yaml.Example.vala',
'src/vala/Pluie/Yaml.ExampleChild.vala',
'src/vala/Pluie/Yaml.ExampleStruct.vala',
'src/vala/Pluie/Yaml.Finder.vala',
'src/vala/Pluie/Yaml.Loader.vala',
'src/vala/Pluie/Yaml.Mapping.vala',
'src/vala/Pluie/Yaml.Node.vala',
'src/vala/Pluie/Yaml.Object.vala',
'src/vala/Pluie/Yaml.Processor.vala',
'src/vala/Pluie/Yaml.Register.vala',
'src/vala/Pluie/Yaml.Root.vala',
'src/vala/Pluie/Yaml.Scalar.vala',
'src/vala/Pluie/Yaml.Scanner.vala',
'src/vala/Pluie/Yaml.Sequence.vala',
'src/vala/Pluie/Yaml.Tag.vala',
'src/c/yaml.c'
]
install_data('resources/main.yml', install_dir : datadir)
install_data('resources/tag.yml', install_dir : datadir)
install_data('resources/test.yml', install_dir : datadir)
install_data('resources/test.json', install_dir : datadir)
install_data('resources/config/db.yml', install_dir : join_paths(datadir, 'config'))
install_data('resources/config/subdir/test.yml', install_dir : join_paths(datadir, 'config/subdir'))
subdir('src')
add_global_arguments('-D DEBUG', language : 'valac')
libpluie_yaml = library(
'pluie-yaml-' + version,
src_files,
sources,
vala_header : 'pluie_yaml.h',
vala_vapi : 'pluie-yaml-' +version+'.vapi',
dependencies : [
dependency('glib-2.0'),
dependency('gobject-2.0'),
dependency('gmodule-2.0'),
dependency('gio-2.0'),
dependency('gee-0.8'),
dependency('pluie-echo-0.2'),
cc.find_library('m', required : false),
cc.find_library('yaml', required : true)
],
dependencies : [dep_glib, dep_gobject, dep_gmodule, dep_gio, dep_gee, dep_echo, dep_m, dep_yaml],
install : true,
version : version,
install_dir : [get_option('libdir'), incdir, true]

1
meson_options.txt
View File

@ -1 +0,0 @@
option('LOCAL', type : 'boolean', value : false)

82
resources/bug.yml
View File

@ -1,82 +0,0 @@
%YAML 1.2
%TAG !v! tag:pluie.org,2018:vala/
---
!v!Pluie.Berel.Meta meta :
!v!Gee.ArrayList keys :
- software : berel; <https://git.pluie.org/pluie/berel>
- version : 0.24
- type : program
- date : 2018
- license : GPLv3.0; <http://www.gnu.org/licenses/>
- author : a-Sansara; <[dev]at[pluie]dot[org]>
- copyright : pluie.org; <http://www.pluie.org>
!v!Gee.ArrayList headers :
- !v!Pluie.Berel.HeaderDef sh :
file :
- build.sh
startline : 2 # to embed shebang before header tpl
sepline :
motif : "# "
repeat : 40
comment :
start : "#^#"
end : "#^#"
begin : "# "
- !v!Pluie.Berel.HeaderDef meson :
file :
- meson.build
- src/meson.build
sepline :
motif : "# "
repeat : 40
comment :
start : "#^#"
end : "#^#"
begin : "# "
- !v!Pluie.Berel.HeaderDef vala :
dir :
- src
extension :
- .vala
sepline :
motif : " *"
repeat : 40
comment :
start : "/*^"
end : "^*/"
begin : " * "
tpl : |
^sepline^
^keys^
^sepline^
This file is part of ^software.name^.
^software.name^ is free software (free as in speech) : you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.
^software.name^ is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
You should have received a copy of the GNU General Public License
along with ^software.name^. If not, see <http://www.gnu.org/licenses/>.
^sepline^
product:
- sku : BL394D
quantity : 5
description : Basketball
price : 450.00
- sku : BL394D
quantity : 5
description : Basketball
price : 450.00

2
resources/doc-style.css
View File

File diff suppressed because one or more lines are too long

80
resources/tag.yml
View File

@ -1,7 +1,7 @@
%YAML 1.2
%TAG !v! tag:pluie.org,2018:vala/
---
!v!Pluie.Samples.YamlObject test1 :
!v!Pluie.Yaml.Example test1 :
myname : test1object
type_int : !v!int 3306
type_bool : !v!bool false
@ -12,66 +12,34 @@
type_float : !v!float 42.36
type_double : !v!double 95542123.4579512128
type_enum : !v!Pluie.Yaml.NODE_TYPE scalar # or int
!v!Pluie.Samples.YamlChild type_object :
!v!Pluie.Yaml.ExampleChild type_object :
toto : totovalue1
tata : tatavalue1
titi : 123
tutu : 1
!v!Pluie.Samples.YamlStruct type_struct :
!v!Pluie.Yaml.ExampleStruct type_struct :
red : !v!uint8 214
green : !v!uint8 78
blue : 153
!v!Gee.ArrayList type_gee_al :
- 1.2
- 2.2
- 3.2
- 4.2
!v!Gee.ArrayList type_gee_alobject :
- toto : totovalue1
tata : tatavalue1
titi : 789
tutu : true
- toto : totovalue2
tata : tatavalue2
titi : 456
tutu : false
- toto : totovalue3
tata : tatavalue3
titi : 123
tutu : 1
- toto : totovalue4
tata : tatavalue4
titi : 44
tutu : 0
!v!Gee.HashMap type_gee_hmap :
- key : key1
!v!Pluie.Samples.YamlChild val :
toto : key1toto
tata : kay1tata
titi : 5
tutu : 0
- key : key2
val :
toto : key2toto
tata : kay2tata
titi : 46
tutu : 1
!v!Gee.HashMap type_gee_hmap2 :
- !v!Pluie.Samples.YamlStruct key :
red : !v!uint8 214
green : !v!uint8 78
blue : 153
!v!Pluie.Samples.YamlChild val :
toto : key1toto
tata : kay1tata
titi : 5
tutu : 0
- key :
red : !v!uint8 82
green : !v!uint8 109
blue : 35
val :
toto : key2toto
tata : kay2tata
titi : 46
tutu : 1
- ab_1
- ab_2
- ab_3
- ab_4
!v!Pluie.Yaml.Example test2 :
myname : test2object
type_int : 3306
type_bool : "true"
type_char : g
type_string : mystring2
type_uchar : Y
type_uint : 63005
type_float : 5.28
type_double : 9.28
type_enum : PLUIE_YAML_NODE_TYPE_SCALAR
!v!Pluie.Yaml.ExampleChild type_object :
toto : totovalue2
tata : tatavalue2
titi : !v!int 456
tutu : !v!bool TRUE

18
resources/test.json
View File

@ -1,20 +1,20 @@
{
"glossary": {
"title": "example glossary",
"GlossDiv": {
"GlossDiv": {
"title": "S",
"GlossList": {
"GlossList": {
"GlossEntry": {
"ID": "SGML",
"SortAs": "SGML",
"GlossTerm": "Standard Generalized Markup Language",
"Acronym": "SGML",
"Abbrev": "ISO 8879:1986",
"GlossDef": {
"SortAs": "SGML",
"GlossTerm": "Standard Generalized Markup Language",
"Acronym": "SGML",
"Abbrev": "ISO 8879:1986",
"GlossDef": {
"para": "A meta-markup language, used to create markup languages such as DocBook.",
"GlossSeeAlso": ["GML", "XML"]
"GlossSeeAlso": ["GML", "XML"]
},
"GlossSee": "markup"
"GlossSee": "markup"
}
}
}

31
samples/json-loader.vala
View File

@ -1,32 +1,3 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
@ -69,7 +40,7 @@ int main (string[] args)
var done = false;
of.title ("Pluie Yaml Library", Pluie.Yaml.VERSION, "a-sansara");
Pluie.Yaml.DEBUG = true;
Pluie.Yaml.DEBUG = false;
var loader = new Yaml.Loader (path, true, true);
if ((done = loader.done)) {
var root = loader.get_nodes ();

85
samples/yaml-bug.vala
View File

@ -1,85 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
using Pluie;
int main (string[] args)
{
Echo.init(false);
var path = Yaml.DATA_PATH + "/bug.yml";
var done = false;
of.title ("Pluie Yaml Library", Pluie.Yaml.VERSION, "a-sansara");
Pluie.Yaml.DEBUG = false;
Yaml.Loader.PACK_NESTED_ENTRIES = true;
var loader = new Yaml.Loader (path, true, true);
if ((done = loader.done)) {
var root = loader.get_nodes ();
done = root != null;
}
of.rs (done);
of.echo ();
return (int) done;
}

29
samples/yaml-config.vala
View File

@ -1,32 +1,3 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>

89
samples/yaml-dump.vala
View File

@ -1,89 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
using Pluie;
int main (string[] args)
{
Echo.init(false);
var path = Yaml.DATA_PATH + "/tag.yml";
var done = false;
of.title ("Pluie Yaml Library", Pluie.Yaml.VERSION, "a-sansara");
Pluie.Yaml.DEBUG = false;
var config = new Yaml.Config (path, true);
var root = config.root_node () as Yaml.Root;
if ((done = root != null)) {
root.display_childs ();
of.action("Yaml.Node", "to_yaml_string");
string genpath = "./tag-generated.yml";
var writter = new Io.Writter (genpath, true);
long written = 0;
writter.write (root.to_yaml_string ().data, out written);
of.echo ("write %ld bytes in `%s`".printf ((long) written, genpath));
Yaml.Dumper.show_yaml_string (root, true, true, true);
}
return (int) done;
}

29
samples/yaml-finder.vala
View File

@ -1,32 +1,3 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>

29
samples/yaml-imports.vala
View File

@ -1,32 +1,3 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>

29
samples/yaml-loader.vala
View File

@ -1,32 +1,3 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>

29
samples/yaml-node.vala
View File

@ -1,32 +1,3 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>

132
samples/yaml-serialize.vala
View File

@ -1,132 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
using GLib;
using Gee;
using Pluie;
public void test_object(Samples.YamlObject obj)
{
of.action ("Test Object", obj.yaml_name);
obj.type_object.method_a ();
if (obj.type_gee_al != null) {
of.keyval("yaml_name" , "%s" .printf(obj.yaml_name));
of.keyval("type_int" , "%d" .printf(obj.type_int));
of.keyval("type_bool" , "%s" .printf(obj.type_bool.to_string ()));
of.keyval("type_char" , "%c" .printf(obj.type_char));
of.keyval("type_string" , "%s" .printf(obj.type_string));
of.keyval("type_uchar" , "%u" .printf(obj.type_uchar));
of.keyval("type_uint" , "%u" .printf(obj.type_uint));
of.keyval("type_float" , "%f" .printf(obj.type_float));
of.keyval("type_double" , "%f" .printf(obj.type_double));
of.keyval("type_struct" , "%s" .printf(obj.type_struct.to_string ()));
of.keyval("type_enum" , "%d (%s)" .printf(obj.type_enum, obj.type_enum.infos()));
of.keyval("type_gee_al", "(%s<%s>)" .printf(obj.type_gee_al.get_type ().name (), obj.type_gee_al.element_type.name ()));
foreach (var v in obj.type_gee_al) {
of.echo(" - item : %g".printf (v));
}
of.keyval("type_object", "(%s)" .printf(obj.type_object.get_type ().name ()));
of.keyval(" toto" , "%s (string)" .printf(obj.type_object.toto));
of.keyval(" tapa" , "%s (string)" .printf(obj.type_object.tata));
of.keyval(" titi" , "%d (int)" .printf(obj.type_object.titi));
of.keyval(" tutu" , "%s (bool)" .printf(obj.type_object.tutu.to_string ()));
obj.type_object.method_a ();
of.keyval("type_gee_alobject", "(%s<%s>)" .printf(obj.type_gee_alobject.get_type ().name (), obj.type_gee_alobject.element_type.name ()));
foreach (var child in obj.type_gee_alobject) {
of.echo(" == entry (%s) ==".printf(child.get_type ().name ()));
of.keyval(" toto" , "%s (string)" .printf(child.toto));
of.keyval(" tapa" , "%s (string)" .printf(child.tata));
of.keyval(" titi" , "%d (int)" .printf(child.titi));
of.keyval(" tutu" , "%s (bool)" .printf(child.tutu.to_string ()));
child.method_a ();
}
if (obj.type_gee_hmap != null) {
of.keyval("type_gee_hmap", "(%s<%s, %s>)" .printf(obj.type_gee_hmap.get_type ().name (), obj.type_gee_hmap.key_type.name (), obj.type_gee_hmap.value_type.name ()));
foreach (var child in obj.type_gee_hmap.entries) {
of.echo(" == entry (%s) ==".printf(child.key));
of.keyval(" toto" , "%s (string)" .printf(child.value.toto));
of.keyval(" tapa" , "%s (string)" .printf(child.value.tata));
of.keyval(" titi" , "%d (int)" .printf(child.value.titi));
of.keyval(" tutu" , "%s (bool)" .printf(child.value.tutu.to_string ()));
}
}
if (obj.type_gee_hmap2 != null) {
of.keyval("type_gee_hmap", "(%s<%s, %s>)" .printf(obj.type_gee_hmap2.get_type ().name (), obj.type_gee_hmap2.key_type.name (), obj.type_gee_hmap2.value_type.name ()));
foreach (var child in obj.type_gee_hmap2.entries) {
of.echo(" == key ==");
of.keyval(" obj :" , "%s" .printf(child.key.to_string ()));
of.echo(" == val (%s) ==".printf(child.value.get_type ( ).name ()));
of.keyval(" toto" , "%s (string)" .printf(child.value.toto));
of.keyval(" tapa" , "%s (string)" .printf(child.value.tata));
of.keyval(" titi" , "%d (int)" .printf(child.value.titi));
of.keyval(" tutu" , "%s (bool)" .printf(child.value.tutu.to_string ()));
}
}
else {
of.echo ("hmap2 null");
}
}
}
int main (string[] args)
{
Echo.init(false);
var path = Yaml.DATA_PATH + "/tag.yml";
var done = false;
of.title ("Pluie Yaml Library", Pluie.Yaml.VERSION, "a-sansara");
Pluie.Yaml.DEBUG = false;
var config = new Yaml.Config (path, true);
var root = config.root_node ();
if ((done = root != null)) {
root.display_childs ();
of.action ("Yaml build first child", root.first ().name);
var obj = (Samples.YamlObject) Yaml.Builder.from_node (root.first ());
test_object (obj);
of.action ("Serialize", obj.yaml_name);
uint8[] zdata = Yaml.serialize (obj);
of.echo ("zdata size : %ld".printf (zdata.length));
for (var i = 0; i < zdata.length; i++) {
print ("%02x", zdata[i]);
}
of.action ("Deserialize zdata from", obj.yaml_name);
root = Yaml.deserialize (zdata);
root.display_childs ();
of.action ("Yaml build first child", obj.yaml_name);
obj = (Samples.YamlObject) Yaml.Builder.from_node (root.first ());
test_object (obj);
}
return (int) done;
}

110
samples/yaml-tag.vala
View File

@ -1,32 +1,3 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
@ -80,7 +51,7 @@ int main (string[] args)
foreach (var node in root) {
of.action ("Yaml.Object from node", node.name);
of.echo (node.to_string (false));
if ((obj = (Yaml.Object) Yaml.Builder.from_node (node)) != null) {
if ((obj = Yaml.Builder.from_node (node)) != null) {
list[node.name] = obj;
}
else {
@ -89,71 +60,32 @@ int main (string[] args)
node = node.next_sibling ();
}
}
// hard code
Samples.YamlObject? o = null;
Yaml.Example? o = null;
foreach (var entry in list.entries) {
if ((o = (Samples.YamlObject) entry.value)!=null) {
of.action ("Getting Hard coded values for Samples.YamlObject %s".printf (of.c (ECHO.MICROTIME).s (o.get_type().name ())), entry.key);
of.keyval("yaml_name" , "%s" .printf(o.yaml_name));
of.keyval("type_int" , "%d" .printf(o.type_int));
of.keyval("type_bool" , "%s" .printf(o.type_bool.to_string ()));
of.keyval("type_char" , "%c" .printf(o.type_char));
of.keyval("type_string" , "%s" .printf(o.type_string));
of.keyval("type_uchar" , "%u" .printf(o.type_uchar));
of.keyval("type_uint" , "%u" .printf(o.type_uint));
of.keyval("type_float" , "%f" .printf(o.type_float));
of.keyval("type_double" , "%f" .printf(o.type_double));
of.keyval("type_struct" , "%s" .printf(o.type_struct.to_string ()));
of.keyval("type_enum" , "%d (%s)" .printf(o.type_enum, o.type_enum.infos()));
of.keyval("type_object" , "%s" .printf(o.type_object.get_type ().name ()));
of.keyval(" toto" , "%s (string)" .printf(o.type_object.toto));
of.keyval(" tapa" , "%s (string)" .printf(o.type_object.tata));
of.keyval(" titi" , "%d (int)" .printf(o.type_object.titi));
of.keyval(" tutu" , "%s (bool)" .printf(o.type_object.tutu.to_string ()));
if ((o = (Yaml.Example) entry.value)!=null) {
of.action ("Getting Hard coded values for Yaml.Object %s".printf (of.c (ECHO.MICROTIME).s (o.type_from_self ())), entry.key);
of.keyval("type_int" , "%d" .printf(o.type_int));
of.keyval("type_bool" , "%s" .printf(o.type_bool.to_string ()));
of.keyval("type_char" , "%c" .printf(o.type_char));
of.keyval("type_string", "%s" .printf(o.type_string));
of.keyval("type_uchar" , "%u" .printf(o.type_uchar));
of.keyval("type_uint" , "%u" .printf(o.type_uint));
of.keyval("type_float" , "%f" .printf(o.type_float));
of.keyval("type_double", "%f" .printf(o.type_double));
of.keyval("type_struct", "%s" .printf(o.type_struct.to_string ()));
of.keyval("type_object", "%s" .printf(o.type_object.get_type ().name ()));
of.keyval(" toto" , "%s (string)" .printf(o.type_object.toto));
of.keyval(" tapa" , "%s (string)" .printf(o.type_object.tata));
of.keyval(" titi" , "%d (int)" .printf(o.type_object.titi));
of.keyval(" tutu" , "%s (bool)" .printf(o.type_object.tutu.to_string ()));
o.type_object.method_a ();
if (o.type_gee_al!= null) {
if (o.type_gee_al != null) {
of.keyval("type_gee_al", "(%s)" .printf(o.type_gee_al.get_type ().name ()));
foreach (var v in o.type_gee_al) {
of.echo(" - item : %g".printf (v));
foreach (string v in o.type_gee_al) {
of.echo(" - item : %s".printf (v));
}
}
if (o.type_gee_alobject != null) {
of.keyval("type_gee_alobject", "(%s<%s>)" .printf(o.type_gee_alobject.get_type ().name (), o.type_gee_alobject.element_type.name ()));
foreach (var child in o.type_gee_alobject) {
of.echo(" == entry (%s) ==".printf(child.get_type ().name ()));
of.keyval(" toto" , "%s (string)" .printf(child.toto));
of.keyval(" tapa" , "%s (string)" .printf(child.tata));
of.keyval(" titi" , "%d (int)" .printf(child.titi));
of.keyval(" tutu" , "%s (bool)" .printf(child.tutu.to_string ()));
child.method_a ();
}
}
if (o.type_gee_hmap != null) {
of.keyval("type_gee_hmap", "(%s<%s, %s>)" .printf(o.type_gee_hmap.get_type ().name (), o.type_gee_hmap.key_type.name (), o.type_gee_hmap.value_type.name ()));
foreach (var child in o.type_gee_hmap.entries) {
of.echo(" == entry (%s) ==".printf(child.key));
of.keyval(" toto" , "%s (string)" .printf(child.value.toto));
of.keyval(" tapa" , "%s (string)" .printf(child.value.tata));
of.keyval(" titi" , "%d (int)" .printf(child.value.titi));
of.keyval(" tutu" , "%s (bool)" .printf(child.value.tutu.to_string ()));
}
}
if (o.type_gee_hmap2 != null) {
of.keyval("type_gee_hmap", "(%s<%s, %s>)" .printf(o.type_gee_hmap2.get_type ().name (), o.type_gee_hmap2.key_type.name (), o.type_gee_hmap2.value_type.name ()));
foreach (var child in o.type_gee_hmap2.entries) {
of.echo(" == key ==");
of.keyval(" obj :" , "%s" .printf(child.key.to_string ()));
of.echo(" == val (%s) ==".printf(child.value.get_type ( ).name ()));
of.keyval(" toto" , "%s (string)" .printf(child.value.toto));
of.keyval(" tapa" , "%s (string)" .printf(child.value.tata));
of.keyval(" titi" , "%d (int)" .printf(child.value.titi));
of.keyval(" tutu" , "%s (bool)" .printf(child.value.tutu.to_string ()));
}
}
else {
of.echo ("hmap2 null");
}
}
}

114
samples/yaml-test.vala
View File

@ -1,114 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
using Pluie;
int main (string[] args)
{
Echo.init(false);
var path = Yaml.DATA_PATH + "/tag.yml";
var done = false;
of.title ("Pluie Yaml Library", Pluie.Yaml.VERSION, "a-sansara");
Pluie.Yaml.DEBUG = false;
var config = new Yaml.Config (path, true);
var root = config.root_node () as Yaml.Root;
root.first ().display_childs ();
of.action ("with signal Yaml.Builder.from_node", root.first ().name);
Samples.YamlObject obj = (Samples.YamlObject) Yaml.Builder.from_node (root.first ());
obj.type_object.method_a ();
if (obj.type_gee_al != null) {
of.keyval("type_gee_al", "(%s<%s>)" .printf(obj.type_gee_al.get_type ().name (), obj.type_gee_al.element_type.name ()));
foreach (var v in obj.type_gee_al) {
of.echo(" - item : %g".printf (v));
}
of.keyval("type_object", "(%s)" .printf(obj.type_object.get_type ().name ()));
of.keyval(" toto" , "%s (string)" .printf(obj.type_object.toto));
of.keyval(" tapa" , "%s (string)" .printf(obj.type_object.tata));
of.keyval(" titi" , "%d (int)" .printf(obj.type_object.titi));
of.keyval(" tutu" , "%s (bool)" .printf(obj.type_object.tutu.to_string ()));
obj.type_object.method_a ();
of.keyval("type_gee_alobject", "(%s<%s>)" .printf(obj.type_gee_alobject.get_type ().name (), obj.type_gee_alobject.element_type.name ()));
foreach (var child in obj.type_gee_alobject) {
of.echo(" == entry (%s) ==".printf(child.get_type ().name ()));
of.keyval(" toto" , "%s (string)" .printf(child.toto));
of.keyval(" tapa" , "%s (string)" .printf(child.tata));
of.keyval(" titi" , "%d (int)" .printf(child.titi));
of.keyval(" tutu" , "%s (bool)" .printf(child.tutu.to_string ()));
child.method_a ();
}
}
of.action ("with signal Yaml.Builder.to_node", obj.yaml_name);
var n = Yaml.Builder.to_node (obj);
if ((done = n !=null)) {
n.display_childs ();
}
of.rs (done);
of.echo ();
return (int) done;
}

160
samples/yaml-tonode.vala
View File

@ -1,160 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
using Pluie;
public void inspect_type (GLib.Type type, ...)
{
var l = va_list();
while (true) {
var obj = l.arg<GLib.Object> ();
if (obj == null) {
break; // end of the list
}
print ("%s\n", type.name ());
print ("%s\n", type.name ());
print (" is-obj: %s\n", type.is_object ().to_string ());
print (" is-abstr: %s\n", type.is_abstract ().to_string ());
print (" is-classed: %s\n", type.is_classed ().to_string ());
print (" is-derivable: %s\n", type.is_derivable ().to_string ());
print (" is-derived: %s\n", type.is_derived ().to_string ());
print (" is-fund: %s\n", type.is_fundamental ().to_string ());
print (" is-inst: %s\n", type.is_instantiatable ().to_string ());
print (" is-iface: %s\n", type.is_interface ().to_string ());
print (" is-enum: %s\n", type.is_enum ().to_string ());
print (" is-flags: %s\n", type.is_object ().to_string ());
// Output:
// `` Children:``
print (" Children:\n");
foreach (unowned Type ch in type.children ()) {
print (" - %s\n", ch.name ());
}
// `` Interfaces:``
// `` - Interface``
print (" Interfaces:\n");
foreach (unowned Type ch in type.interfaces ()) {
if ( ch == typeof(Gee.Traversable)) {
var t = (obj as Gee.Traversable).element_type;
print (" --- !!! element type is %s\n", (obj as Gee.Traversable).element_type.name ());
print (" is-obj: %s\n", t.is_object ().to_string ());
print (" is-abstr: %s\n", t.is_abstract ().to_string ());
print (" is-classed: %s\n", t.is_classed ().to_string ());
print (" is-derivable: %s\n", t.is_derivable ().to_string ());
print (" is-derived: %s\n", t.is_derived ().to_string ());
print (" is-fund: %s\n", t.is_fundamental ().to_string ());
print (" is-inst: %s\n", t.is_instantiatable ().to_string ());
print (" is-iface: %s\n", t.is_interface ().to_string ());
print (" is-enum: %s\n", t.is_enum ().to_string ());
print (" is-flags: %s\n", t.is_object ().to_string ());
if ((obj as Gee.Traversable).element_type == typeof (Gee.Map.Entry)) {
print (" --- !!! key type is %s\n", (obj as Gee.Map).key_type.name ());
print (" --- !!! value type is %s\n", (obj as Gee.Map).value_type.name ());
}
}
print (" - %s\n", ch.name ());
}
// Output:
// `` Parents:``
// `` - GObject``
print (" Parents:\n");
for (Type p = type.parent (); p != 0 ; p = p.parent ()) {
print (" - %s\n", p.name ());
}
}
}
int main (string[] args)
{
Echo.init(false);
var path = Yaml.DATA_PATH + "/tag.yml";
var done = false;
of.title ("Pluie Yaml Library", Pluie.Yaml.VERSION, "a-sansara");
Pluie.Yaml.DEBUG = false;
var config = new Yaml.Config (path, true);
var root = config.root_node ();
root.display_childs ();
root.first ().display_childs ();
of.action ("Yaml.Builder.from_node", root.first ().name);
Samples.YamlObject obj = (Samples.YamlObject) Yaml.Builder.from_node (root.first ());
obj.type_object.method_a ();
if (obj.type_gee_al != null) {
of.keyval("type_gee_al", "(%s)" .printf(obj.type_gee_al.get_type ().name ()));
foreach (double v in obj.type_gee_al as Gee.ArrayList<double?>) {
of.echo(" - item : %f".printf (v));
}
}
var n = Yaml.Builder.to_node (obj);
if ((done = n !=null)) {
n.display_childs ();
}
of.rs (done);
of.echo ();
return (int) done;
}

29
samples/yaml-traversing.vala
View File

@ -1,32 +1,3 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>

31
src/c/yaml.c
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
#include <stdio.h>
#include <yaml.h>

58
src/meson.build
View File

@ -1,58 +0,0 @@
#^# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
# @version : 0.60
# @type : library
# @date : 2018
# @license : GPLv3.0 <http://www.gnu.org/licenses/>
# @author : a-Sansara <[dev]at[pluie]dot[org]>
# @copyright : pluie.org <http://www.pluie.org>
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# This file is part of pluie-yaml.
#
# pluie-yaml is free software (free as in speech) : you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation, either version 3 of the License,
# or (at your option) any later version.
#
# pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
# more details.
#
# You should have received a copy of the GNU General Public License
# along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #^#
src_files = [
'src/c/yaml.c',
'build/install.vala',
'src/vala/Pluie/Io.Reader.vala',
'src/vala/Pluie/Io.InputChunkStream.vala',
'src/vala/Pluie/Io.StreamLineMark.vala',
'src/vala/Pluie/Io.Writter.vala',
'src/vala/Pluie/Yaml.global.vala',
'src/vala/Pluie/Yaml.AbstractChild.vala',
'src/vala/Pluie/Yaml.AbstractNode.vala',
'src/vala/Pluie/Yaml.Builder.vala',
'src/vala/Pluie/Yaml.Collection.vala',
'src/vala/Pluie/Yaml.Config.vala',
'src/vala/Pluie/Yaml.Dumper.vala',
'src/vala/Pluie/Yaml.Event.vala',
'src/vala/Pluie/Yaml.Finder.vala',
'src/vala/Pluie/Yaml.GeeBuilder.vala',
'src/vala/Pluie/Yaml.Loader.vala',
'src/vala/Pluie/Yaml.Mapping.vala',
'src/vala/Pluie/Yaml.Node.vala',
'src/vala/Pluie/Yaml.Object.vala',
'src/vala/Pluie/Yaml.Processor.vala',
'src/vala/Pluie/Yaml.Register.vala',
'src/vala/Pluie/Yaml.Root.vala',
'src/vala/Pluie/Yaml.Scalar.vala',
'src/vala/Pluie/Yaml.Scanner.vala',
'src/vala/Pluie/Yaml.Sequence.vala',
'src/vala/Pluie/Yaml.Tag.vala'
]

126
src/vala/Pluie/Io.InputChunkStream.vala
View File

@ -1,126 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
using GLib;
/**
* basic class to read file by chunk
*/
class Pluie.Io.InputChunkStream : Object
{
/**
*
*/
protected ulong chunk_index;
/**
*
*/
protected uint8 chunk_size;
/**
*
*/
protected uint8 buffer_size;
/**
*
*/
protected uint8[] buffer;
/**
*
*/
protected FileStream fs;
/**
* default constructor
* @param path the path to read
* @param chunk_size the chunk size
*/
public InputChunkStream (string path, uint8 chunk_size)
{
this.chunk_size = chunk_size;
this.buffer = new uint8[this.chunk_size];
this.fs = FileStream.open (path, "r");
this.chunk_index = 0;
}
/**
* indicate if end of file of readed file is reached
*/
public bool eof ()
{
bool stop = this.fs.eof ();
if (stop) {
this.buffer = null;
}
return stop;
}
/**
* read chunk_size
*/
public unowned uint8[] read ()
{
if (!this.eof ()) {
this.buffer_size = (uint8) this.fs.read (this.buffer);
this.chunk_index++;
}
return this.buffer;
}
/**
* retriew the buffer size (chunk_size)
*/
public unowned uint8 get_buffer_size ()
{
return this.buffer_size;
}
/**
* retriew content of buffer
*/
public unowned uint8[] get_buffer ()
{
return this.buffer;
}
/**
* retriew chunk index
*/
public ulong get_chunk_index ()
{
return this.chunk_index-1;
}
/**
* retriew chunk size
*/
public uint8 get_chunk_size ()
{
return this.chunk_size;
}
}

45
src/vala/Pluie/Io.Reader.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
@ -141,18 +142,4 @@ public class Pluie.Io.Reader
return this.readable;
}
/**
* get content of loaded file
*/
public string? get_contents ()
{
string? read = null;
try {
FileUtils.get_contents (this.path, out read);
}
catch(GLib.Error e) {
of.error (e.message);
}
return read;
}
}

31
src/vala/Pluie/Io.StreamLineMark.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
/**
* a class representing a stream mark recording a line and it's position in the stream

115
src/vala/Pluie/Io.Writter.vala
View File

@ -1,115 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
using GLib;
using Gee;
using Pluie;
/**
* basic writter class
*/
public class Pluie.Io.Writter
{
/**
* current file path
*/
public string path { get; internal set; }
/**
* current file
*/
public File file { get; internal set; }
/**
* stream used to read the file
*/
DataOutputStream stream;
/**
* construct a writter
* @param path the path to write
* @param delete_if_exists flag indicating if existing file must be removed first
*/
public Writter (string path, bool delete_if_exists = false)
{
this.path = path;
this.file = File.new_for_path (path);
try {
if (delete_if_exists) {
this.delete_file(this.file);
}
this.file = File.new_for_path (path);
this.stream = new DataOutputStream(file.create (FileCreateFlags.NONE));
if (!file.query_exists ()) {
of.error ("cannot create file '%s'".printf (path));
}
}
catch (GLib.Error e) {
of.error (e.message);
}
}
/**
* write specified data to current file
* @param data the data to write
* @param written the written data size
*/
public bool write (uint8[] data, out long? written = null)
{
bool done = false;
long w = 0;
try {
while (w < data.length) {
// sum of the bytes that already have been written to the stream
w += stream.write (data[w:data.length]);
}
done = w == data.length;
}
catch (GLib.Error e) {
of.error (e.message);
}
written = w;
return done;
}
/**
* delete current or specified file
* @param file the file to delete (current file if null)
*/
public bool delete_file(File? file = null)
{
bool done = false;
try {
((file == null) ? this.file : file).delete ();
done = true;
}
catch (GLib.Error e) {
of.error (e.message);
}
return done;
}
}

204
src/vala/Pluie/Samples.YamlObject.vala
View File

@ -1,204 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
using GLib;
using Gee;
using Pluie;
/**
* a YamlObject test class
*/
public class Pluie.Samples.YamlObject : Yaml.Object
{
public string myname { get; set; }
public string type_string { get; set; }
public int type_int { get; set; }
public uint type_uint { get; set; }
public float type_float { get; set; }
public double type_double { get; set; }
public char type_char { get; set; }
public uchar type_uchar { get; set; }
public unichar type_unichar { get; set; }
public short type_short { get; set; }
public ushort type_ushort { get; set; }
public long type_long { get; set; }
public ulong type_ulong { get; set; }
public size_t type_size_t { get; set; }
public ssize_t type_ssize_t { get; set; }
public int8 type_int8 { get; set; }
public uint8 type_uint8 { get; set; }
public int16 type_int16 { get; set; }
public uint16 type_uint16 { get; set; }
public int32 type_int32 { get; set; }
public uint32 type_uint32 { get; set; }
public int64 type_int64 { get; set; }
public uint64 type_uint64 { get; set; }
public bool type_bool { get; set; }
public Samples.YamlChild type_object { get; set; }
public Yaml.NODE_TYPE type_enum { get; set; }
public Samples.YamlStruct type_struct { get; set; }
public Gee.ArrayList<double?> type_gee_al { get; set; }
public Gee.ArrayList<Samples.YamlChild> type_gee_alobject { get; set; }
public Gee.HashMap<string, Samples.YamlChild> type_gee_hmap { get; set; }
public Gee.HashMap<YamlStruct?, Samples.YamlChild> type_gee_hmap2 { get; set; }
/**
*
*/
static construct
{
Yaml.Register.add_type (
typeof (Samples.YamlObject),
typeof (Samples.YamlChild),
typeof (Samples.YamlStruct),
typeof (Gee.ArrayList),
typeof (Gee.HashMap)
);
}
/**
*
*/
protected override void yaml_construct ()
{
this.type_gee_al = new Gee.ArrayList<double?> ();
this.type_gee_alobject = new Gee.ArrayList<Samples.YamlChild> ();
this.type_gee_hmap = new Gee.HashMap<string, Samples.YamlChild> ();
this.type_gee_hmap2 = new Gee.HashMap<Samples.YamlStruct?, Samples.YamlChild> ();
Yaml.Register.add_namespace("Gee", "Pluie.Samples");
Dbg.msg ("%s (%s) instantiated".printf (this.yaml_name, this.get_type().name ()), Log.LINE, Log.FILE);
}
/**
*
*/
protected override void yaml_init ()
{
Dbg.msg ("%s (%s) initialized".printf (this.yaml_name, this.get_type().name ()), Log.LINE, Log.FILE);
}
/**
*
*/
public override void populate_from_node (string name, GLib.Type type, Yaml.Node node) {
if (type == typeof (Samples.YamlStruct)) {
this.type_struct = Samples.YamlStruct.from_yaml_node (node);
}
else if (type == typeof (Gee.ArrayList)) {
foreach (var child in node) {
switch (name) {
case "type_gee_al":
this.type_gee_al.add(double.parse(child.data));
break;
case "type_gee_alobject":
this.type_gee_alobject.add((Samples.YamlChild) Yaml.Builder.from_node (child, typeof (Samples.YamlChild)));
break;
}
}
}
else if (type == typeof (Gee.HashMap)) {
Yaml.Mapping? c;
foreach (var child in node) {
c = child as Yaml.Mapping;
switch (name) {
case "type_gee_hmap":
Value key = c.item ("key").val (typeof (string));
var entry = (Samples.YamlChild) Yaml.Builder.from_node (c.item ("val"), typeof (Samples.YamlChild));
this.type_gee_hmap.set((string) key, entry);
break;
case "type_gee_hmap2":
var key = Samples.YamlStruct.from_yaml_node (c.item ("key"));
var entry = (Samples.YamlChild) Yaml.Builder.from_node (c.item ("val"), typeof (Samples.YamlChild));
this.type_gee_hmap2.set(key, entry);
break;
}
}
}
else {
var obj = Yaml.Builder.from_node(node, type);
if (name == "type_object") {
this.set (node.name, (Samples.YamlChild) obj);
}
else {
this.set (node.name, obj);
}
}
}
/**
*
*/
public override Yaml.Node? populate_to_node (string name, GLib.Type type, Yaml.Node parent) {
Yaml.Node? node = null;
if (type == typeof (Samples.YamlStruct)) {
node = this.type_struct.to_yaml_node (name);
}
else if (type == typeof (Gee.ArrayList)) {
switch (name) {
case "type_gee_al" :
Yaml.GeeBuilder.fundamental_arraylist_to_node (this.type_gee_al, name, parent);
break;
case "type_gee_alobject" :
Yaml.Object.objects_collection_to_node (this.type_gee_alobject, name, parent);
break;
}
}
else if (type == typeof (Gee.HashMap)) {
switch (name) {
case "type_gee_hmap" :
Yaml.Object.objects_mapkstr_to_node (this.type_gee_hmap, name, parent);
break;
case "type_gee_hmap2" :
this.hmap2_to_node (name, parent);
break;
}
}
else {
base.populate_to_node (name, type, parent);
}
return node;
}
/**
*
*/
public void hmap2_to_node (string name, Yaml.Node? parent = null)
{
of.echo (Log.METHOD);
var node = new Yaml.Sequence (parent, name);
node.tag = new Yaml.Tag (Yaml.Register.resolve_namespace_type(this.type_gee_hmap2.get_type ()), "v");
var i = 0;
foreach (var child in this.type_gee_hmap2.entries) {
var entryNode = new Yaml.Mapping (node, "_%d".printf (i));
entryNode.add (child.key.to_yaml_node ("key"));
Yaml.Builder.to_node ((GLib.Object) child.value, entryNode, false, null, "val");
}
}
}

85
src/vala/Pluie/Samples.YamlStruct.vala
View File

@ -1,85 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/**
* YamlStruct test structure
*/
public struct Pluie.Samples.YamlStruct
{
/**
*
*/
public uint red;
/**
*
*/
public uint green;
/**
*
*/
public uint blue;
/**
* get a new YamlStruct populated by specified node
* @param node the source Yaml.Node
*/
public static YamlStruct from_yaml_node (Yaml.Node node)
{
YamlStruct s = {};
foreach (var child in node) {
var v = child.val (typeof (uint));
switch (child.name) {
case "red" : s.red = v.get_uint (); break;
case "green" : s.green = v.get_uint (); break;
case "blue" : s.blue = v.get_uint (); break;
}
}
return s;
}
/**
*
*/
public Yaml.Node to_yaml_node (string name)
{
var node = new Yaml.Mapping (null, name);
new Yaml.Mapping.with_scalar (node, "red" , this.red.to_string ());
new Yaml.Mapping.with_scalar (node, "green", this.green.to_string ());
new Yaml.Mapping.with_scalar (node, "blue" , this.blue.to_string ());
return node;
}
/**
*
*/
public string to_string ()
{
return "%s(red:%u,green:%u,blue:%u)".printf ((typeof (YamlStruct)).name (), this.red, this.green, this.blue);
}
}

42
src/vala/Pluie/Yaml.AbstractChild.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Pluie;
@ -87,7 +88,7 @@ public abstract class Pluie.Yaml.AbstractChild : Yaml.AbstractNode
}
/**
* check if last chikd
* check if first chikd
*/
public bool is_last ()
{
@ -95,7 +96,7 @@ public abstract class Pluie.Yaml.AbstractChild : Yaml.AbstractNode
}
/**
* get nextt sibling node
* check if first chikd
*/
public Yaml.Node? next_sibling ()
{
@ -103,7 +104,7 @@ public abstract class Pluie.Yaml.AbstractChild : Yaml.AbstractNode
}
/**
* get previous sibling node
* check if first chikd
*/
public Yaml.Node? previous_sibling ()
{
@ -123,9 +124,6 @@ public abstract class Pluie.Yaml.AbstractChild : Yaml.AbstractNode
return done;
}
/**
* coutn childs. return 0
*/
public virtual int count ()
{
return 0;
@ -138,4 +136,6 @@ public abstract class Pluie.Yaml.AbstractChild : Yaml.AbstractNode
{
this.anchor = id;
}
}

64
src/vala/Pluie/Yaml.AbstractNode.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
@ -88,16 +89,6 @@ public abstract class Pluie.Yaml.AbstractNode : GLib.Object
return node != null && node.uuid == this.uuid;
}
/**
* get a presentation string of current Yaml.Node
* @param withIndent display indentation formating
* @param withParent display parent node name
* @param withUuid display node uuid
* @param withCount display number of childs
* @param withRefCount display number of reference
* @param withTag display tag information
* @param withType display node type
*/
public virtual string to_string (
bool withIndent = Yaml.DBG_SHOW_INDENT,
bool withParent = Yaml.DBG_SHOW_PARENT,
@ -112,27 +103,4 @@ public abstract class Pluie.Yaml.AbstractNode : GLib.Object
return "";
}
/**
* get a gracefull yaml presentation of current Yaml.Node
* @param indent number of space for indentation
* @param show_doc flag indicating if the document start must be print
* @param show_tags flag indicating if tags must be print
* @param show_fullkeys flag indicating if full key definition must be print
*
*/
public string to_yaml_string (
int indent = Yaml.Dumper.DEFAULT_INDENT,
bool show_doc = Yaml.Dumper.SHOW_DOC,
bool show_tags = Yaml.Dumper.SHOW_TAGS,
bool show_fullkeys = Yaml.Dumper.SHOW_FULL_KEYS
)
{
return Yaml.Dumper.dump (
(Yaml.Node) this,
indent,
show_doc,
show_tags,
show_fullkeys
);
}
}

266
src/vala/Pluie/Yaml.Builder.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
@ -47,24 +48,22 @@ public class Pluie.Yaml.Builder
private static unowned GLib.Module p_open_module ()
{
if (p_module == null) {
p_module = Module.open (null, 0);
p_module = GLib.Module.open (null, 0);
}
return p_module;
}
/**
* retriew GLib.Type related to specified vala name
* type must be registered
*
*/
public static GLib.Type? type_from_string (string name)
{
Type? type = Type.from_name (name.replace(".", ""));
GLib.Type? type = Type.from_name (name.replace(".", ""));
return type;
}
/**
* retriew GLib.Type related to specified vala name
* type may be not registered
* @param name a valid vala identifier name
*/
public static Type type_from_vala (string name)
@ -78,7 +77,7 @@ public class Pluie.Yaml.Builder
}
/**
* retriew GLib.Type related to specified tag value.
* retiew GLib.Type related to specified tag value.
* Type may not be registered yet
*/
public static Type? type_from_tag (string tagValue)
@ -90,40 +89,20 @@ public class Pluie.Yaml.Builder
return type;
}
/**
*
*/
private static string resolve_c_subname (string name) throws GLib.RegexError
{
MatchInfo? mi = null;
bool update = false;
var reg = new Regex ("([A-Z]{1}[a-z]+)");
string? str = null;
var sb = new StringBuilder();
for (reg.match (name, 0, out mi) ; mi.matches () ; mi.next ()) {
if ((str = mi.fetch (1)) != null && str.length > 0) {
sb.append ("%s%s%s".printf (update ? "_" : "", str[0].tolower ().to_string (), str.substring(1)));
if (!update) update = true;
}
}
return update ? sb.str : name;
}
/**
* retriew corresponding c name related to specified vala name
* @param name a valid vala identifier name
*/
public static string resolve_c_name (string name)
{
string? str = null;
MatchInfo? mi = null;
string? str = null;
MatchInfo? mi = null;
StringBuilder sb = new StringBuilder ();
bool begin = true;
try {
var reg = new Regex ("([^.]*).?");
for (reg.match (name, 0, out mi) ; mi.matches () ; mi.next ()) {
str = Yaml.Builder.resolve_c_subname(mi.fetch (1));
if (str != null && str.length > 0) {
if ((str = mi.fetch (1)) != null && str.length > 0) {
if (!begin) sb.append_unichar ('_');
else begin = false;
sb.append_unichar (str[0].tolower ());
@ -131,7 +110,7 @@ public class Pluie.Yaml.Builder
}
}
}
catch (RegexError e) {
catch (GLib.RegexError e) {
of.error (e.message, true);
}
return !begin ? sb.str : name;
@ -141,49 +120,46 @@ public class Pluie.Yaml.Builder
private delegate Type dlgType();
/**
* Build an Object from a YYaml.Node
* @param node the source Yaml.Node
* @param otype used for recursion only
*
*/
public static GLib.Object? from_node (Yaml.Node node, Type otype = GLib.Type.INVALID)
public static Yaml.Object? from_node (Yaml.Node node, Type otype = GLib.Type.INVALID)
{
GLib.Object? obj = null;
Type type = node.tag != null ? type_from_tag (node.tag.value) : otype;
if (type != Type.INVALID) {
Yaml.dbg_action ("vala type founded", "%s (%s)".printf (type.name (), type.to_string ()));
if (type.is_object ()) {
obj = GLib.Object.new (type);
if (type.is_a (typeof (Yaml.Object))) {
(obj as Yaml.Object).set ("yaml_name", node.name);
(obj as Yaml.Object).yaml_construct ();
}
if (node!= null && !node.empty ()) {
GLib.ParamSpec? def = null;
Yaml.Node? scalar = null;
foreach (var child in node) {
if ((def = obj.get_class ().find_property (child.name)) != null) {
Yaml.dbg ("== prop [%s] type is : %s".printf (child.name, def.value_type.name ()));
if (child.ntype.is_single_pair () && (scalar = child.first ()) != null) {
set_from_scalar (ref obj, def.name, def.value_type, scalar.data);
Yaml.Object? obj = null;
try {
Type type = node.tag != null ? type_from_tag (node.tag.value) : otype;
if (type != Type.INVALID) {
Yaml.dbg_action ("vala type founded", "%s (%s)".printf (type.name (), type.to_string ()));
if (type.is_object ()) {
obj = (Yaml.Object) GLib.Object.new (type);
if (node!= null && !node.empty ()) {
GLib.ParamSpec? def = null;
Yaml.Node? scalar = null;
foreach (var child in node) {
if ((def = obj.get_class ().find_property (child.name)) != null) {
Yaml.dbg ("== prop [%s] type is : %s".printf (child.name, def.value_type.name ()));
if (child.ntype.is_single_pair () && (scalar = child.first ()) != null) {
set_from_scalar (ref obj, def.name, def.value_type, scalar.data);
}
else if (child.ntype.is_collection ()) {
set_from_collection (ref obj, type, child, def.value_type);
}
}
else if (child.ntype.is_collection ()) {
set_from_collection (ref obj, type, child, def.value_type);
else {
of.warn ("property %s not found".printf (child.name));
}
}
else {
of.warn ("property %s not found".printf (child.name));
}
}
}
}
}
if (obj == null) {
of.warn ("searched type not found : %s".printf (type.name ()));
}
else {
if (type.is_a (typeof (Yaml.Object))) {
(obj as Yaml.Object).yaml_init ();
if (obj == null) {
of.warn ("searched type not found : %s".printf (type.name ()));
}
else {
obj.yaml_init ();
}
}
catch (GLib.Error e) {
of.warn (e.message);
}
return obj;
}
@ -191,21 +167,24 @@ public class Pluie.Yaml.Builder
/**
*
*/
private static void set_from_collection (ref GLib.Object obj, Type parentType, Yaml.Node node, Type type)
public static void set_from_collection (ref Yaml.Object obj, GLib.Type parentType, Yaml.Node node, GLib.Type type)
{
Yaml.dbg (" > set_from_collection %s (%s)".printf (node.name, type.name ()));
if (type.is_a (typeof (Yaml.Object)) || Yaml.Register.is_registered_type (parentType, type)) {
(obj as Yaml.Object).populate_from_node (node.name, type, node);
if (type.is_a (typeof (Yaml.Object))) {
obj.set (node.name, Yaml.Builder.from_node(node, type));
}
else if (Yaml.Object.register.is_registered_type(parentType, type)) {
Yaml.dbg ("%s is a registered type".printf (type.name ()));
obj.populate_by_type (type, node);
}
else {
of.error ("%s is not registered and cannot be populated".printf (type.name ()));
Dbg.error ("%s is not registered and cannot be populated".printf (type.name ()), Log.METHOD, Log.LINE);
}
}
/**
*
*/
private static void set_from_scalar (ref GLib.Object obj, string name, GLib.Type type, string data)
public static void set_from_scalar (ref Yaml.Object obj, string name, GLib.Type type, string data)
{
GLib.Value v = GLib.Value(type);
Yaml.dbg_action ("Auto setting property value %s".printf (of.c (ECHO.MICROTIME).s (type.name ())), name);
@ -262,59 +241,7 @@ public class Pluie.Yaml.Builder
/**
*
*/
public static string? get_basic_type_value (GLib.Object obj, GLib.Type type, string name)
{
GLib.Value v = GLib.Value(Type.STRING);
switch (type)
{
case Type.STRING :
string s;
obj.get (name, out s);
v = s;
break;
case Type.CHAR :
char c;
obj.get (name, out c);
v = c.to_string ();
break;
case Type.UCHAR :
uchar c;
obj.get (name, out c);
break;
case Type.UINT64 :
case Type.UINT :
uint64 i;
obj.get (name, out i);
break;
case Type.INT64 :
case Type.INT :
int64 i;
obj.get (name, out i);
v = i.to_string ();
break;
case Type.BOOLEAN :
bool b;
obj.get (name, out b);
v = b.to_string ();
break;
case Type.DOUBLE :
double d;
obj.get (name, out d);
v = "%g".printf (d);
break;
case Type.FLOAT :
float f;
obj.get (name, out f);
v = "%f".printf (f);
break;
}
return (string) v;
}
/**
*
*/
private static void set_enum_value (ref Value v, GLib.Type type, string data)
public static void set_enum_value (ref Value v, GLib.Type type, string data)
{
EnumClass kenum = (EnumClass) type.class_ref();
unowned EnumValue? enumval = kenum.get_value_by_name(data);
@ -332,67 +259,4 @@ public class Pluie.Yaml.Builder
//~ of.echo ("enumValue : %d".printf (enumval.value));
}
private static string transform_param_name (string name)
{
return name.replace("-", "_");
}
/**
*
*/
private static Yaml.Tag add_tag (GLib.Type type)
{
return new Yaml.Tag (Yaml.Register.resolve_namespace_type(type), Yaml.YAML_VALA_PREFIX);
}
/**
* transform an Yaml.Object to his corresponding Yaml.Node
* @param obj the obj to transform
* @param parent the parent node
* @param root indicates if node must be add to a root node, if true a Yaml.Root node is return
* @param index for sequence entry anonymous mapping block
* @param property_name name of property name related to obj
*/
public static Yaml.Node to_node (GLib.Object obj, Yaml.Node? parent = null, bool root = true, int? index = null, string? property_name = null)
{
string node_name = "";
if (obj.get_type ().is_a (typeof (Yaml.Object))) {
node_name = (obj as Yaml.Object).yaml_name;
}
else {
node_name = parent.ntype.is_sequence () && index != null ? "_%d".printf (index+1) : (property_name != null ? property_name : obj.get_type ().name ());
}
var node = new Yaml.Mapping (parent, node_name);
string? name = null;
foreach (var def in obj.get_class ().list_properties ()){
name = Yaml.Builder.transform_param_name(def.name);
if (name != null && name != "yaml_name") {
if (def.value_type.is_a (typeof (Yaml.Object)) || Yaml.Register.is_registered_type(obj.get_type (), def.value_type)) {
var child = (obj as Yaml.Object).populate_to_node(name, def.value_type, node);
if (child != null) {
child.tag = Yaml.Builder.add_tag (def.value_type);
node.add (child);
}
}
else if (def.value_type.is_enum ()) {
EnumValue enumval;
obj.get (name, out enumval);
string data = enumval.value.to_string ();
var n = new Yaml.Mapping.with_scalar (node, name, (string) data);
n.tag = Yaml.Builder.add_tag (def.value_type);
}
else if (def.value_type.is_fundamental ()) {
string data = Yaml.Builder.get_basic_type_value(obj, def.value_type, name);
if (data != null) {
new Yaml.Mapping.with_scalar (node, name, (string) data);
}
}
else {
of.error ("type %s for property %s is not registered".printf (def.value_type.name (), name));
}
}
}
node.tag = Yaml.Builder.add_tag (obj.get_type ());
return root ? new Yaml.Root(null, true, node) : node;
}
}

46
src/vala/Pluie/Yaml.Collection.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
@ -37,15 +38,14 @@ using Pluie;
public interface Pluie.Yaml.Collection
{
/**
* retriew a child node throught specifiyed index
* @param index index of searched child
* @return the matching child node
* retriew the child at index
* @param index index of seached child
*/
public abstract Yaml.Node? item (int index);
/**
* check if current node contains the specifiyed child node
* @param child the child to check
* check if contains specifyed child node
* @param child the child to check
*/
public abstract bool contains (Yaml.Node child);
@ -67,25 +67,23 @@ public interface Pluie.Yaml.Collection
/**
* retriew the first child
* @return the first child node
*/
public abstract Yaml.Node? first ();
/**
* retriew the last child
* @return the last child node
*/
public abstract Yaml.Node? last ();
/**
* retriew the next sibling of specifiyed child node
* @param child the the reference child node
* @param child the the reference child node
*/
public abstract Yaml.Node? child_next_sibling (Yaml.Node child);
/**
* retriew the previous sibling of specifiyed child node
* @param child the the reference child node
* @param child the the reference child node
*/
public abstract Yaml.Node? child_previous_sibling (Yaml.Node child);

104
src/vala/Pluie/Yaml.Config.vala
View File

@ -1,76 +1,40 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
/**
* Yaml.Config class to manage Yaml configuration files and provide a Yaml.Root node.
*
* Yaml.Config use a Yaml.Finder to easily retriew a particular node. <<BR>>
* The Yaml.Config.get method is bind to the Yaml.Finder.find method with <<BR>>
* the root node as context. (more details on {@link Yaml.Finder})
*
* {{{
* var config = new Yaml.Config (path);
* var node = config.get ("ship-to.address.city{0}");
* if (node != null) {
* of.echo (node.data)
* }
* }}}
*
* You can use a special import clause to embed a set of yaml files into your current document.
*
* {{{
* # | use special key word '^imports' to import other yaml config files in
* # | current yaml document
* # | '^imports' must be uniq and a direct child of root node
* # | imported files are injected as mapping nodes at top document level
* # | so you cannot use keys that already exists in the document
* ^imports :
* # you can redefine default import path with the special key '^path'
* # if you do not use it, the default path value will be the current directory
* # redefined path values are relative to the current directory (if a relative path
* # is provided)
* ^path : ./config
* # you can also define any other var by prefixing key with ^
* ^dir : subdir
* # and use it enclosed by ^
* # here final test path will be "./config/subdir/test.yml"
* test : ^dir^/test.yml
* # here final db path will be "./config/db.yml"
* db : db.yml
* }}}
*
* {{doc/img/pluie-yaml-imports2.png}}
* a class to manage Yaml configuration files
*/
public class Pluie.Yaml.Config
{
/**
* special char use in imports clause & imports var
*
*/
const char IMPORTS_SPE = '^';
@ -82,7 +46,7 @@ public class Pluie.Yaml.Config
/**
*
*/
public bool display_file { get; internal set; }
public bool displayFile { get; internal set; }
/**
* Yaml Loader
@ -106,30 +70,24 @@ public class Pluie.Yaml.Config
/**
* construct a Yaml Config for specifiyed path
* @param path the yaml path file to load
* @param display_file flag to display file
* @param mode Yaml.FIND_MODE to apply to finder
*/
public Config (string? path = null, bool display_file = false, Yaml.FIND_MODE mode = Yaml.FIND_MODE.DOT)
public Config (string? path = null, bool displayFile = false, Yaml.FIND_MODE mode = Yaml.FIND_MODE.DOT)
{
Yaml.MODE = mode;
this.path = path;
this.display_file = display_file;
this.displayFile = displayFile;
if (this.path != null) {
this.loader = new Yaml.Loader (this.path, display_file, false);
if (this.loader.done) {
Yaml.Node? root = this.loader.get_nodes ();
if (root != null) {
this.finder = new Yaml.Finder(root);
this.get_imports ();
}
this.loader = new Yaml.Loader (this.path, displayFile, false);
Yaml.Node? root = this.loader.get_nodes ();
if (root != null) {
this.finder = new Yaml.Finder(root);
this.get_imports ();
}
}
}
/**
* find node matching specifiyed keyPath
* see {@link Yaml.Finder} for precisions
*/
public new Yaml.Node? get (string keyPath)
{
@ -141,15 +99,15 @@ public class Pluie.Yaml.Config
}
/**
* retriew the corresponding Yaml.Root node for loaded yaml file
*
*/
public Yaml.Root? root_node ()
public Yaml.Node root_node ()
{
return this.finder!=null ? this.finder.context as Yaml.Root : null;
return this.finder.context;
}
/**
*
* find node matching specifiyed keyPath
*/
protected void get_imports ()
{
@ -180,7 +138,7 @@ public class Pluie.Yaml.Config
Yaml.Node? n = null;
Yaml.Config? conf = null;
foreach(var entry in this.paths.entries) {
conf = new Yaml.Config(entry.value, this.display_file);
conf = new Yaml.Config(entry.value, this.displayFile);
sub = conf.loader.get_nodes ();
n = new Yaml.Mapping (root, entry.key);
foreach(var subnode in sub.list) {

232
src/vala/Pluie/Yaml.Dumper.vala
View File

@ -1,232 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
using GLib;
using Gee;
using Pluie;
/**
* a Yaml.Dumper to dump a Yaml.Node to his file representation
*/
public class Pluie.Yaml.Dumper
{
/**
* default number space indentation to apply for all nodes. default : 4
*/
public static int DEFAULT_INDENT { get; internal set; default = 4; }
/**
* flag indicating if the document start must be print
*/
public static bool SHOW_DOC { get; internal set; default = true; }
/**
* flag indicating if tags must be print
*/
public static bool SHOW_TAGS { get; internal set; default = true; }
/**
* flag indicating if full key definition must be print
*/
public static bool SHOW_FULL_KEYS { get; internal set; default = false; }
/**
* flag indicating if enable printing colors
*/
static bool SHOW_COLOR { get; internal set; default = false; }
/**
* flag indicating if line number must be print
*/
static bool SHOW_LINE { get; internal set; default = false; }
/**
* a line counter
*/
static int line { get; internal set; default = 0; }
/**
*
*/
internal Dumper ()
{
}
/**
* get a gracefull yaml presentation of current Yaml.Node
* @param node the node to dump
* @param show_line flag indicating if line number must be print
* @param show_color flag indicating if enable printing colors
* @param show_tags flag indicating if tags must be print
* @param show_doc flag indicating if the document start must be print
* @param indent number of space for indentation
* @param show_fullkeys flag indicating if full key definition must be print
*/
public static void show_yaml_string (
Yaml.Node? node,
bool show_line = true,
bool show_color = true,
bool show_tags = Yaml.Dumper.SHOW_TAGS,
bool show_doc = Yaml.Dumper.SHOW_DOC,
int indent = Yaml.Dumper.DEFAULT_INDENT,
bool show_fullkeys = Yaml.Dumper.SHOW_FULL_KEYS
)
{
SHOW_LINE = show_line;
SHOW_COLOR = show_color;
string yaml = dump (node, indent, show_doc, show_tags, show_fullkeys);
SHOW_LINE = false;
SHOW_COLOR = false;
of.action ("Yaml string representation for", node!= null ? node.name : "null");
print ("%s%s%s", "\n", yaml, "\n");
}
/**
* get a yaml presentation of specified Yaml.Node
* @param node the node to dump
* @param indent number of space for indentation
* @param show_doc flag indicating if the document start must be print
* @param show_tags flag indicating if tags must be print
* @param show_fullkeys flag indicating if full key definition must be print
*/
public static string dump (
Yaml.Node? node,
int indent = Yaml.Dumper.DEFAULT_INDENT,
bool show_doc = Yaml.Dumper.SHOW_DOC,
bool show_tags = Yaml.Dumper.SHOW_TAGS,
bool show_fullkeys = Yaml.Dumper.SHOW_FULL_KEYS
)
{
var yaml = new StringBuilder("");
if (node != null) {
if (node.ntype.is_root ()) {
line = 0;
yaml_root (ref yaml, node as Yaml.Root, show_doc);
foreach (var child in node) {
yaml.append (Yaml.Dumper.dump (child, indent, show_doc, show_tags, show_fullkeys));
}
}
else if (node.ntype.is_single_pair ()) {
yaml_key (ref yaml, node, indent, show_tags);
yaml_scalar (ref yaml, node.first (), indent, show_tags);
}
else if (node.ntype.is_collection ()) {
yaml_key (ref yaml, node, indent, show_tags);
foreach (var child in node) {
yaml.append (Yaml.Dumper.dump (child, indent, show_doc, show_tags, show_fullkeys));
}
}
else if (node.ntype.is_scalar ()) {
yaml_scalar (ref yaml, node, indent, show_tags);
}
}
line++;
return yaml.str;
}
/**
*
*/
private static void yaml_indent (ref StringBuilder yaml, Yaml.Node node, int indent, bool wrapchild = false)
{
yaml.append("%s%s".printf (
! SHOW_LINE ? "" : of.c (ECHO.NUM).s ("%03d %s".printf (line, of.c (ECHO.FILE).s ("|"))),
string.nfill ((node.level-1) * indent - (wrapchild ? 2 : 0), ' ')
));
}
/**
*
*/
private static void yaml_tag (ref StringBuilder yaml, Yaml.Node node, bool show_tags)
{
if (node.tag != null && show_tags) {
if (SHOW_COLOR) yaml.append (of.c (ECHO.COMMAND).to_string ());
yaml.append ("!%s!%s".printf (
node.tag.handle,
node.tag.value
));
yaml.append ("%s ".printf (SHOW_COLOR ? Color.off () : ""));
}
}
/**
*
*/
private static void yaml_root (ref StringBuilder yaml, Yaml.Root node, bool show_doc)
{
yaml.append(! SHOW_LINE ? "" : of.c (ECHO.NUM).s ("%03d %s".printf (line++, of.c (ECHO.FILE).s ("|"))));
yaml.append("%YAML %s\n".printf (Yaml.YAML_VERSION));
foreach (var entry in node.tag_directives.entries) {
yaml.append(! SHOW_LINE ? "" : of.c (ECHO.NUM).s ("%03d %s".printf (line++, of.c (ECHO.FILE).s ("|"))));
yaml.append ("%TAG %s %s\n".printf (entry.key, entry.value));
}
if (show_doc) {
yaml.append(! SHOW_LINE ? "" : of.c (ECHO.NUM).s ("%03d %s".printf (line++, of.c (ECHO.FILE).s ("|"))));
yaml.append ("---\n");
}
}
/**
*
*/
private static void yaml_key (ref StringBuilder yaml, Yaml.Node node, int indent, bool show_tags)
{
bool wrapseq = node.parent.ntype.is_sequence () && node.ntype.is_mapping () && node.name[0]=='_';
bool childwrap = node.parent != null && node.parent.parent != null && node.parent.parent.ntype.is_sequence () && node.parent.ntype.is_mapping () && node.parent.name[0]=='_';
if (!childwrap) yaml_indent (ref yaml, node, indent);
else if (!node.is_first ()) {
yaml_indent (ref yaml, node, indent, true);
}
if (node.parent != null && node.parent.ntype.is_sequence ()) yaml.append (!SHOW_COLOR ? "- " : of.c (ECHO.DATE).s ("- "));
if (wrapseq) {
if (Yaml.DEBUG) of.warn ("node %s wrapseq ? %s".printf (node.name, wrapseq.to_string ()));
}
yaml_tag (ref yaml, node, show_tags);
if (!wrapseq) {
int len = 0;
foreach (var child in node.parent) {
if (child.name.length > len) len = child.name.length;
}
len = (!show_tags || (node.tag == null && !node.ntype.is_collection ()) && len > 0) ? len +1 - node.name.length : 0;
yaml.append("%s%s%s".printf(
!SHOW_COLOR ? @"%s%$(len)s ".printf (node.name, " ") : of.c (node.ntype.is_collection() ? ECHO.TIME : ECHO.OPTION).s(@"%s%$(len)s".printf (node.name, " ")),
!SHOW_COLOR ? ":" : of.c (ECHO.DATE).s(":"),
node.ntype.is_collection () ? "\n" : " "
));
}
}
/**
*
*/
private static void yaml_scalar (ref StringBuilder yaml, Yaml.Node node, int indent, bool show_tags)
{
if (!(node.parent !=null && node.parent.ntype.is_single_pair ())) yaml_indent (ref yaml, node, indent);
if (node.parent != null && node.parent.ntype.is_sequence ()) yaml.append (!SHOW_COLOR ? "- " : of.c (ECHO.DATE).s ("- "));
yaml_tag (ref yaml, node, show_tags);
yaml.append ("%s\n".printf (
!SHOW_COLOR ? node.data : of.c (ECHO.OPTION_SEP).s (node.data)
));
}
}

34
src/vala/Pluie/Yaml.Event.vala
View File

@ -1,39 +1,39 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
using Pluie;
/**
* Yaml Event class populated by {@link Yaml.Scanner} and treat by the {@link Yaml.Processor} to
* build a {@link Yaml.Node} from a yaml.file
* Yaml Event class
*/
public class Pluie.Yaml.Event
{

107
src/vala/Pluie/Yaml.Example.vala Normal file
View File

@ -0,0 +1,107 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
using Pluie;
/**
* a test class to implements yamlize
*/
public class Pluie.Yaml.Example : Yaml.Object
{
public string myname { get; set; }
public string type_string { get; set; }
public int type_int { get; set; }
public uint type_uint { get; set; }
public float type_float { get; set; }
public double type_double { get; set; }
public char type_char { get; set; }
public uchar type_uchar { get; set; }
public unichar type_unichar { get; set; }
public short type_short { get; set; }
public ushort type_ushort { get; set; }
public long type_long { get; set; }
public ulong type_ulong { get; set; }
public size_t type_size_t { get; set; }
public ssize_t type_ssize_t { get; set; }
public int8 type_int8 { get; set; }
public uint8 type_uint8 { get; set; }
public int16 type_int16 { get; set; }
public uint16 type_uint16 { get; set; }
public int32 type_int32 { get; set; }
public uint32 type_uint32 { get; set; }
public int64 type_int64 { get; set; }
public uint64 type_uint64 { get; set; }
public bool type_bool { get; set; }
public Yaml.ExampleChild type_object { get; set; }
public Yaml.NODE_TYPE type_enum { get; set; }
public Yaml.ExampleStruct type_struct { get; set; }
public Gee.ArrayList<string> type_gee_al { get; set; }
static construct
{
Yaml.Object.register.add_type (typeof (Yaml.Example), typeof (Yaml.ExampleStruct));
Yaml.Object.register.add_type (typeof (Yaml.Example), typeof (Gee.ArrayList));
}
/**
*
*/
protected override void yaml_init ()
{
// base.yaml_init ();
Dbg.msg ("Yaml.Object %s (%s) instantiated".printf (this.myname, this.type_from_self ()), Log.LINE, Log.FILE);
}
/**
*
*/
public override void populate_by_type(GLib.Type type, Yaml.Node node)
{
try {
if (type == typeof (Yaml.ExampleStruct)) {
this.type_struct = ExampleStruct.from_yaml_node (node);
}
else if (type == typeof (Gee.ArrayList)) {
this.type_gee_al = new Gee.ArrayList<string> ();
if (!node.empty ()) {
foreach (var child in node) {
this.type_gee_al.add(child.data);
}
}
}
}
catch (GLib.Error e) {
Dbg.error(e.message, Log.METHOD, Log.LINE);
}
}
}

45
src/vala/Pluie/Samples.YamlChild.vala → src/vala/Pluie/Yaml.ExampleChild.vala
View File

@ -1,44 +1,45 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
/**
* a YamlCHild test class
* a test class to implements yamlize
*/
public class Pluie.Samples.YamlChild : Yaml.Object
public class Pluie.Yaml.ExampleChild : Yaml.Object
{
public string toto { get; set; }
public string tata { get; set; }
public int titi { get; set; }
public bool tutu { get; set; }
public string toto { get; set; }
public string tata { get; set; }
public int titi { get; set; }
public bool tutu { get; set; }
public void method_a ()
{
of.echo (" called method from object %s builded via yaml".printf (this.get_type().name ()));
of.echo (" called method from object %s builded via yaml".printf (this.type_from_self ()));
}
}

59
src/vala/Pluie/Yaml.ExampleStruct.vala Normal file
View File

@ -0,0 +1,59 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
public struct Pluie.Yaml.ExampleStruct
{
public uint red;
public uint green;
public uint blue;
public static ExampleStruct from_yaml_node (Yaml.Node node)
{
var s = ExampleStruct ();
foreach (var child in node) {
var v = child.val (typeof (uint));
switch (child.name) {
case "red" :
s.red = v.get_uint ();
break;
case "green" :
s.green = v.get_uint ();
break;
case "blue" :
s.blue = v.get_uint ();
break;
}
}
return s;
}
public string to_string ()
{
return "%s(red:%u,green:%u,blue:%u)".printf ((typeof (ExampleStruct)).name (), this.red, this.green, this.blue);
}
}

56
src/vala/Pluie/Yaml.Finder.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
@ -33,19 +34,6 @@ using Pluie;
/**
* Finder class used to easily retriew Yaml.Node
*
* Path definition has two mode :
* default mode is ''Yaml.FIND_MODE.DOT''
*
* * child mapping node are separated by dot :
* * sequence entry must be enclosed in curly brace
* ex : ``grandfather.father.son{2}.age``
*
* other mode is ''Yaml.FIND_MODE.SQUARE_BRACKETS''.
*
* * node's key name must be enclosed in square brackets
* * sequence entry must be enclosed in curly brace
* ex : ``[grandfather][father][son]{2}[age]``
*/
public class Pluie.Yaml.Finder : GLib.Object
{
@ -65,7 +53,17 @@ public class Pluie.Yaml.Finder : GLib.Object
}
/**
* Find a specific child Yaml.Node corresponding to path definition.
* find a specific child Yaml.Node corresponding to path definition
* path definition has two mode.
* default mode is Yaml.FIND_MODE.DOT
* - child mapping node are separated by dot :
* - sequence entry must be enclosed in curly brace
* ex : grandfather.father.son{2}.age
*
* other mode is Yaml.FIND_MODE.DOTSQUARE_BRACKETS
* - node's key name must be enclosed in square brackets
* - sequence entry must be enclosed in curly brace
* ex : [grandfather][father][son]{2}[age]
*
* @param path the definition to retriew the child node
* @param context the Yaml.Node context to operate

107
src/vala/Pluie/Yaml.GeeBuilder.vala
View File

@ -1,107 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
using GLib;
using Gee;
using Pluie;
/**
* a Yaml.GeeBuilder class helping to build vala Gee.Collection with fundamental type to Yaml.Node
*/
public class Pluie.Yaml.GeeBuilder
{
/**
* transform a Gee.Collection with fundamental type to a Yaml.Node
* @param property_name name of related property
* @param parent parent Yaml.Node of the list
* @param is_char flag indicating data with char representation
*/
public static Yaml.Node? fundamental_arraylist_to_node (Gee.ArrayList* o, string property_name, Yaml.Node parent, bool is_char = false)
{
Yaml.dbg_action ("prop %s (type %s) has element type :".printf (property_name, o->get_type ().name ()), o->element_type.name ());
Yaml.Node? node = null;
var type = o->element_type;
if (!type.is_object () && type.is_fundamental ()) {
node = new Yaml.Sequence (parent, property_name);
var it = o->iterator();
while (it.next ()) {
string data = "";
if (is_char && (type == typeof (unichar) || type == typeof (uchar))) {
void* d = (void*) it.get ();
data = ((unichar) d).to_string();
}
else {
switch (type) {
case Type.LONG :
case Type.INT64 :
int64* d = (int64*) it.get ();
data = d.to_string ();
break;
case Type.INT :
data = ((int64) it.get ()).to_string ();
break;
case Type.CHAR :
data = ((char) it.get ()).to_string ();
break;
case Type.UCHAR :
data = "%u".printf (((uint) it.get ()));
break;
case Type.ULONG :
case Type.UINT64 :
uint64* d = (uint64*) it.get ();
data = d.to_string ();
break;
case Type.UINT :
data = "%u".printf ((uint) it.get ());
break;
case Type.BOOLEAN :
data = ((bool) it.get ()).to_string ();
break;
case Type.FLOAT :
float* f = (float*) it.get ();
data = f.to_string ();
break;
case Type.DOUBLE :
var d = (double*) it.get ();
data = "%g".printf (double.parse(d.to_string ()));
break;
default :
data = (string) it.get ();
break;
}
}
new Yaml.Scalar (node, data);
}
}
else {
of.error ("in %s : Gee.ArrayList.element_type (%s) is not a fundamental type".printf (Log.METHOD, type.name ()));
}
return node;
}
}

106
src/vala/Pluie/Yaml.Loader.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
@ -37,49 +38,43 @@ using Pluie;
public class Pluie.Yaml.Loader
{
/**
* Flag PACK_NESTED_ENTRIES
* Scanner
*/
public static bool PACK_NESTED_ENTRIES { public get; public set; default = false; }
/**
* Yaml.Scanner used to retriew yaml events
*/
Yaml.Scanner scanner { public get; internal set; }
Yaml.Scanner scanner { public get; internal set; }
/**
* indicate if file has been sucessfully loaded
*/
public bool done { get; internal set; }
public bool done { get; internal set; }
/**
* Reader used to load content yaml file
*/
Io.Reader reader;
Io.Reader reader;
/**
* default constructor of Yaml.Loader
* @param path the path of file to parse
* @param display_file display original file
* @param displayFile display original file
* @param displayNode display corresponding Yaml Node Graph
*/
public Loader (string path, bool display_file = false, bool displayNode = false )
public Loader (string path, bool displayFile = false, bool displayNode = false )
{
this.reader = new Io.Reader (path);
if (this.reader.readable) {
this.scanner = new Yaml.Scanner (path);
if (display_file) this.display_file ();
this.scanner = new Yaml.Scanner (path);
if (displayFile) this.displayFile ();
if ((this.done = this.scanner.run())) {
if (displayNode) {
var n = this.get_nodes ();
if (n != null) n.display_childs ();
of.state(n != null);
}
}
else {
var evt = this.scanner.get_error_event ();
of.error ("line %d (%s)".printf (evt.line, evt.data["error"]));
this.display_file (evt.line);
if ((this.done = this.scanner.run())) {
if (displayNode) {
var n = this.get_nodes ();
if (n != null) n.display_childs ();
of.state(n != null);
}
}
else {
var evt = this.scanner.get_error_event ();
of.error ("line %d (%s)".printf (evt.line, evt.data["error"]));
this.displayFile (evt.line);
}
}
/**
@ -87,40 +82,13 @@ public class Pluie.Yaml.Loader
*/
public Yaml.Node? get_nodes ()
{
Yaml.Node? n = this.scanner.get_nodes ();
if (PACK_NESTED_ENTRIES) {
this.pack_entries (n);
}
return n;
}
/**
*
*/
private void pack_entries (Yaml.Node? node = null)
{
bool restart = false;
if (node != null) {
if (node.ntype.is_sequence ()) {
foreach (var child in node) {
if (child.ntype.is_mapping () && child.name[0] == '_' && child.count () == 1) {
var sub = child.first ().clone_node ();
node.replace_node (child, sub);
restart = true;
break;
}
}
if (restart) pack_entries (node);
}
else foreach (var child in node) this.pack_entries (child);
}
return this.scanner.get_nodes ();
}
/**
* display original file
* @param errorLine highlight error line
*/
public void display_file (int errorLine = 0)
public void displayFile (int errorLine = 0)
{
of.action (errorLine == 0 ? "Reading file" : "Invalid Yaml File", this.reader.path);
of.echo ();

59
src/vala/Pluie/Yaml.Mapping.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Pluie;
@ -42,9 +43,7 @@ public class Pluie.Yaml.Mapping : Yaml.Node
Gee.ArrayList<string>? keys { internal get; internal set; default = null; }
/**
* default Yaml.Mapping constructor
* @param parent the parent node
* @param name the node name
*
*/
public Mapping (Yaml.Node? parent = null, string? name = null)
{
@ -53,10 +52,7 @@ public class Pluie.Yaml.Mapping : Yaml.Node
}
/**
* Yaml.Mapping constructor as single pair node with scalar data
* @param parent the parent node
* @param name the node name
* @param data scalar data
*
*/
public Mapping.with_scalar (Yaml.Node? parent = null, string? name = null, string? data = null)
{
@ -66,7 +62,8 @@ public class Pluie.Yaml.Mapping : Yaml.Node
}
/**
* {@inheritDoc}
* add a child node to current collection (mapping or sequence) node
* @param child the Yaml.Node child to add
*/
protected override void before_add (Yaml.Node child) throws Yaml.AddNodeError
{
@ -87,7 +84,8 @@ public class Pluie.Yaml.Mapping : Yaml.Node
}
/**
* {@inheritDoc}
* add a child node to current collection (mapping or sequence) node
* @param child the Yaml.Node child to add
*/
protected override void on_added (Yaml.Node child)
{
@ -101,7 +99,9 @@ public class Pluie.Yaml.Mapping : Yaml.Node
}
/**
* {@inheritDoc}
* add a child node to current collection (mapping or sequence) node
* @param child the Yaml.Node child to add
* @param levelUpdate flag indicating if update level is needed
*/
protected override void on_removed (Yaml.Node child, bool levelUpdate = true)
{
@ -112,9 +112,9 @@ public class Pluie.Yaml.Mapping : Yaml.Node
}
/**
* retriew a child node throught specifiyed name
* retriew a child node throught specifiyed index
* @param name name of searched child
* @return the matching child node
* @return the child node
*/
public new Yaml.Node? item (string name)
{
@ -129,7 +129,8 @@ public class Pluie.Yaml.Mapping : Yaml.Node
}
/**
* {@inheritDoc}
* clone current node
* @param name the overrinding name
*/
public override Yaml.Node clone_node (string? name = null)
{
@ -144,7 +145,7 @@ public class Pluie.Yaml.Mapping : Yaml.Node
}
/**
* get a collection of chils name
*
*/
public Gee.ArrayList<string>? child_names ()
{

113
src/vala/Pluie/Yaml.Node.vala
View File

@ -1,37 +1,37 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
/**
* a class representing a yaml node no matter was his type
* a class representing a node
*/
public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
{
@ -76,14 +76,12 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
catch (Yaml.AddNodeError e) {
of.warn (e.message);
Yaml.dbg (this.to_string ());
this.display_childs ();
}
return done;
}
/**
* actions to execute before adding the specified child bode
* add a child node to current collection (mapping or sequence) node
* @param child the Yaml.Node child to add
*/
protected virtual void before_add (Yaml.Node child) throws Yaml.AddNodeError
@ -92,7 +90,7 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
* actions to execute after adding the specified child bode
* add a child node to current collection (mapping or sequence) node
* @param child the Yaml.Node child to add
*/
protected virtual void on_added (Yaml.Node child)
@ -102,8 +100,7 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
/**
* remove a child
* @param child the child to remove
* @param levelUpdate flag indacting if level must be updated
* @param child the child to remove
*/
public bool remove_child (Yaml.Node child, bool levelUpdate = true)
{
@ -117,9 +114,8 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
* action to exectuing after removing the specified child node
* @param child the Yaml.Node child to remove
* @param levelUpdate flag indacting if level must be updated for removed child
* add a child node to current collection (mapping or sequence) node
* @param child the Yaml.Node child to add
*/
protected virtual void on_removed (Yaml.Node child, bool levelUpdate = true)
{
@ -130,7 +126,9 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
* {@inheritDoc}
* retriew a child node throught specifiyed index
* @param index index of searched child
* @return the child node
*/
public virtual Yaml.Node? item (int index)
{
@ -138,35 +136,37 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
* {@inheritDoc}
* check if current node contains the specifiyed child node
* @param child the child to check
*/
public bool contains (Yaml.Node child) {
return !this.empty () && this.list.contains (child);
}
/**
* {@inheritDoc}
* count childnodes
*/
public override int count () {
return !this.empty () ? this.list.size : 0;
}
/**
* {@inheritDoc}
* check if empty
*/
public bool empty () {
return this.list == null || this.list.size == 0;
}
/**
* {@inheritDoc}
* get an iterator
*/
public Gee.Iterator<Yaml.Node> iterator () {
return this.list.iterator ();
}
/**
* {@inheritDoc}
* retriew the first child node
* @return the first child node
*/
public virtual Yaml.Node? first ()
{
@ -174,7 +174,8 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
* {@inheritDoc}
* retriew the last child node
* @return the last child node
*/
public Yaml.Node? last ()
{
@ -197,7 +198,7 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
* {@inheritDoc}
*
*/
public Yaml.Node? child_next_sibling (Yaml.Node child)
{
@ -205,15 +206,15 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
* {@inheritDoc}
*
*/
public Yaml.Node? child_previous_sibling (Yaml.Node child)
{
return this.child_sibling (child, false);
}
/**
* update nested indention node level and propagate approprietly level to all childs
/*
*
*/
public virtual void update_level()
{
@ -226,9 +227,8 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
* clone current node (with all his children)
* @param name the name of the clone
* @return the cloned node with cloned childs
* clone current node
* @param name the name of clone
*/
public virtual Yaml.Node clone_node (string? name = null)
{
@ -243,16 +243,16 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
}
/**
*
* clone current node
* @param name the name of clone
*/
internal virtual Yaml.Node get_cloned_instance (string? name = null)
public virtual Yaml.Node get_cloned_instance (string? name = null)
{
return new Yaml.Node (null, this.ntype, name);
}
/**
* retriew the GLib.Value initialized with specified type (only) for single pair node
* return the pair value
*
*/
public GLib.Value val (GLib.Type type)
{
@ -263,24 +263,8 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
return v;
}
/**
*
*/
public void replace_node (Yaml.Node child, Yaml.Node new_child)
{
int index = this.list.index_of (child);
if (index > -1) {
new_child.level = this.level + 1;
new_child.parent = this;
new_child.update_level ();
this.list.remove_at (index);
this.list.insert (index, new_child);
}
}
/**
* display childs
* @param withTitle display a title before the childs node presentation
*/
public void display_childs (bool withTitle = true)
{
@ -298,13 +282,6 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
/**
* get a presentation string of current Yaml.Node
* @param withIndent display indentation formating
* @param withParent display parent node name
* @param withUuid display node uuid
* @param withCount display number of childs
* @param withRefCount display number of reference
* @param withTag display tag information
* @param withType display node type
*/
public override string to_string (
bool withIndent = Yaml.DBG_SHOW_INDENT,
@ -343,7 +320,7 @@ public class Pluie.Yaml.Node : Yaml.AbstractChild, Pluie.Yaml.Collection
)
: "",
of.c (ECHO.OPTION).s ("]"),
withTag && this.ntype.is_root () && (this as Yaml.Root) !=null ? (this as Yaml.Root).get_display_tag_directives () : ""
withTag && this.ntype.is_root () ? (this as Yaml.Root).get_display_tag_directives () : ""
);
}
}

168
src/vala/Pluie/Yaml.Object.vala
View File

@ -1,54 +1,44 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
/**
* Yaml.Object base class which can be transform to a Yaml.Node structure
* a test class to implements yamlize
*/
public abstract class Pluie.Yaml.Object : GLib.Object
{
/**
* Yaml node name
*
*/
public string yaml_name { get; internal set; }
/**
* associated Yaml.Register for tag resolution (full namespace names)
*/
public static Yaml.Register register { get; private set; }
/**
* Yaml.Tag definition
*/
public static Yaml.Tag yaml_tag { get; internal set; }
public static Yaml.Register register { get; private set; }
/**
*
@ -56,125 +46,31 @@ public abstract class Pluie.Yaml.Object : GLib.Object
static construct
{
register = new Yaml.Register();
yaml_tag = new Tag (typeof (Pluie.Yaml.Object).name (), "v");
Yaml.Register.add_namespace("Pluie", "Pluie.Yaml");
}
/**
*
*/
public Object ()
{
this.yaml_construct ();
}
/**
* default constructor
*/
public virtual void yaml_construct ()
{
Dbg.msg ("%s (%s) instantiated".printf (this.yaml_name, this.get_type().name ()), Log.LINE, Log.FILE);
}
/**
* initialization method called by Yaml.Builder after instantiation
* and after properties has been populated
*/
public virtual void yaml_init ()
{
Dbg.msg ("%s (%s) initialized".printf (this.yaml_name, this.get_type().name ()), Log.LINE, Log.FILE);
Dbg.msg ("Yaml.Object (%s) instantiated".printf (this.type_from_self ()), Log.LINE, Log.FILE);
}
/**
* build property name from a Yaml.Node
* @param name name the property to build
* @param type type the property type
* @param node the Yaml.Node source
* retiew GLib.Type related to instance
*/
public virtual signal void populate_from_node (string name, GLib.Type type, Yaml.Node node) {
if (type.is_a(typeof (Yaml.Object))) {
public string type_from_self ()
{
return Type.from_instance (this).name ();
}
/**
*
*/
public virtual void populate_by_type(GLib.Type type, Yaml.Node node)
{
if (type.is_a (typeof (Yaml.Object))) {
this.set (node.name, Yaml.Builder.from_node(node, type));
}
else {
message ("base Yaml.Object : %s".printf (Log.METHOD));
this.set (node.name, (GLib.Object) Yaml.Builder.from_node(node, type));
}
}
/**
* convert property name to a Yaml.node
* @param name name of the property to build
* @param type type of the property to build
* @param parent parent node of the property
* @return the resulting Yaml.Node
*/
public virtual signal Yaml.Node? populate_to_node (string name, GLib.Type type, Yaml.Node parent) {
Yaml.Node? node = null;
if (type.is_object ()) {
var o = (GLib.Object) GLib.Object.new (type);
this.get (name, out o);
node = Yaml.Builder.to_node (o, parent, false, null, name);
}
return node;
}
/**
* build an object collection (Gee.Collection) to a Yaml.Node
* @param list the gee collection to transform
* @param name name of collection sequence node
* @param parent parent node of the collection
* @return the resulting Yaml.Node
*/
public static Yaml.Node? objects_collection_to_node (Gee.Collection list, string name, Yaml.Node? parent = null)
{
var node = new Yaml.Sequence (parent, name);
node.tag = new Yaml.Tag (Yaml.Register.resolve_namespace_type(list.get_type ()), "v");
var it = list.iterator ();
var i = 0;
while (it.next ()) {
Yaml.Builder.to_node ((GLib.Object) it.get (), node, false, i++);
}
return node;
}
/**
* build an object Gee.HashMap<string, Yaml.Object> to a Yaml.Node
* @param map the gee hashmap to transform
* @param name name of map sequence node
* @param parent parent node of the map
* @return the resulting Yaml.Node
*/
public static Yaml.Node? objects_mapkstr_to_node (Gee.HashMap map, string name, Yaml.Node? parent = null)
{
var node = new Yaml.Sequence (parent, name);
node.tag = new Yaml.Tag (Yaml.Register.resolve_namespace_type(map.get_type ()), "v");
var i = 0;
foreach (var child in map.entries) {
var entryNode = new Yaml.Mapping (node, "_%d".printf (i++));
new Yaml.Mapping.with_scalar (entryNode, "key", (string) child.key);
Yaml.Builder.to_node ((GLib.Object) child.value, entryNode, false, null, "val");
}
return node;
}
/**
* build an object Gee.HashMap<string, Yaml.Object> to a Yaml.Node
* @param map the gee hashmap to transform
* @param name name of map sequence node
* @param parent parent node of the map
* @return the resulting Yaml.Node
*/
public static Yaml.Node? objects_mapobjects_to_node (Gee.HashMap map, string name, Yaml.Node? parent = null)
{
var node = new Yaml.Sequence (parent, name);
node.tag = new Yaml.Tag (Yaml.Register.resolve_namespace_type(map.get_type ()), "v");
var i = 0;
foreach (var child in map.entries) {
var entryNode = new Yaml.Mapping (node, "_%d".printf (i++));
Yaml.Builder.to_node ((GLib.Object) child.key, entryNode, false, null, "key");
Yaml.Builder.to_node ((GLib.Object) child.value, entryNode, false, null, "val");
}
return node;
}
}

302
src/vala/Pluie/Yaml.Processor.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
@ -46,31 +47,11 @@ public class Pluie.Yaml.Processor
*/
bool change;
/**
* indicates if document start begin
*/
bool begin;
/**
* indicates if new node is a sequence entry
*/
bool isEntry;
/**
* indicates if new node is a sequence entry mapping
*/
bool isEntryMapping;
/**
* indicates if begon a flow sequence
*/
bool beginFlowSeq;
/**
*
*/
int indexEvt;
/**
* current anchor id
*/
@ -96,11 +77,6 @@ public class Pluie.Yaml.Processor
*/
string? tagHandle;
/**
* current tag handle
*/
Yaml.Event? nextValueEvt;
/**
* Events list
*/
@ -161,10 +137,9 @@ public class Pluie.Yaml.Processor
public void read ()
{
of.action ("Reading events");
var i = 0;
foreach (Yaml.Event event in this.events) {
int len = 24 - event.evtype.infos ().length;
stdout.printf (" %03d [ %s"+@" %$(len)s "+", %d, %s", i++, event.evtype.infos (), " ", event.line, event.style != null ? event.style.to_string () : "0");
stdout.printf (" [ %s"+@" %$(len)s "+", %d, %s", event.evtype.infos (), " ", event.line, event.style != null ? event.style.to_string () : "0");
if (event.data != null && event.data.size > 0) {
stdout.printf (", {");
var it = event.data.map_iterator ();
@ -189,7 +164,6 @@ public class Pluie.Yaml.Processor
this.reset ();
for (var has_next = this.iterator.next (); has_next; has_next = this.iterator.next ()) {
this.event = this.iterator.get ();
Yaml.dbg (" [[[ EVENT %d %s ]]]".printf (this.indexEvt++, this.event.evtype.infos ()));
if (this.event.evtype.is_tag_directive ()) {
this.on_tag_directive ();
}
@ -197,54 +171,34 @@ public class Pluie.Yaml.Processor
this.on_error ();
break;
}
if (!this.begin) {
if (this.event.evtype.is_sequence_start () || this.event.evtype.is_mapping_start ()) {
this.begin = true;
continue;
}
else if (this.event.evtype.is_document_start ()) {
this.begin = true;
// to do
this.event = this.next_event ();
if (this.event.evtype.is_tag ()) {
this.root.tag = new Yaml.Tag (this.event.data["suffix"], this.event.data["handle"].replace("!", ""));
this.event = this.next_event ();
}
continue;
}
if (this.event.evtype.is_mapping_end () || this.event.evtype.is_sequence_end ()) {
this.on_block_end ();
continue;
}
else {
if (this.event.evtype.is_anchor ()) {
this.on_anchor ();
if (this.event.evtype.is_entry ()) {
this.on_entry ();
}
if (this.beginFlowSeq && this.event.evtype.is_scalar ()) {
if (!this.change) {
this.on_scalar (true);
}
else if (this.event.evtype.is_alias ()) {
this.on_alias ();
}
else if (this.event.evtype.is_mapping_end () || this.event.evtype.is_sequence_end ()) {
this.on_block_end ();
continue;
}
else if (this.event.evtype.is_key () && (this.event = this.get_value_key_event ()) != null) {
this.on_key ();
}
else if (this.event.evtype.is_entry ()) {
this.on_entry ();
}
else if (this.event.evtype.is_mapping_start ()) {
this.create_mapping (this.isEntry);
this.beginFlowSeq = false;
}
if (this.event.evtype.is_key () && (this.event = this.get_value_key_event ()) != null) {
this.on_key ();
}
if (this.event.evtype.is_value () && (this.event = this.get_value_event ()) != null) {
this.on_value ();
if (this.event.evtype.is_mapping_start ()) {
this.on_mapping_start ();
}
else if (this.event.evtype.is_sequence_start ()) {
this.on_sequence_start ();
}
else if (this.event.evtype.is_value ()) {
continue;
}
else if (this.event.evtype.is_scalar ()) {
this.on_scalar ();
}
this.add_anchor_if_needed ();
this.on_update ();
this.ckey = null;
}
this.on_update ();
}
this.done = error_event == null && this.root != null;
return done;
@ -255,22 +209,17 @@ public class Pluie.Yaml.Processor
*/
private void reset ()
{
this.root = new Yaml.Root ();
this.prev_node = this.root;
this.parent_node = this.root;
this.iterator = this.events.iterator ();
this.change = false;
this.ckey = null;
this.idAnchor = null;
this.tagHandle = null;
this.keyTag = null;
this.valueTag = null;
this.beginFlowSeq = false;
this.nextValueEvt = null;
this.indexEvt = 0;
this.isEntry = false;
this.begin = false;
this.isEntryMapping = false;
this.root = new Yaml.Root ();
this.prev_node = this.root;
this.parent_node = this.root;
this.iterator = this.events.iterator ();
this.change = false;
this.ckey = null;
this.idAnchor = null;
this.tagHandle = null;
this.keyTag = null;
this.valueTag = null;
this.beginFlowSeq = false;
}
/**
@ -281,20 +230,6 @@ public class Pluie.Yaml.Processor
Yaml.Event? evt = null;
if (this.iterator.has_next () && this.iterator.next ()) {
evt = this.iterator.get ();
Yaml.dbg (" >>>>> [EVENT event [%d] %s <<<<< %s".printf (this.indexEvt++, evt.evtype.infos (), Log.METHOD));
}
return evt;
}
/**
* retriew the next Yaml Event without use of iterator
*/
private Yaml.Event? get_next_event ()
{
Yaml.Event? evt = null;
var i = this.indexEvt;
if (i < this.events.size) {
evt = this.events.get (i);
}
return evt;
}
@ -321,35 +256,10 @@ public class Pluie.Yaml.Processor
var e = this.iterator.get ();
if (e != null && e.evtype.is_value ()) {
evt = this.next_event ();
this.nextValueEvt = evt;
}
return evt;
}
/**
* retriew the next Yaml Value Event without use of iterator
*/
private Yaml.Event? get_next_value_event ()
{
Yaml.Event? evt = null;
var i = this.indexEvt;
Yaml.dbg (" >>> %s from %d".printf (Log.METHOD, i));
var search = true;
while (search) {
if (i < this.events.size) {
var e = this.events.get (i++);
if (e != null && e.evtype.is_value ()) {
evt = this.events.get (i);
Yaml.dbg (" >>> %s > %d : %s".printf (Log.METHOD, i, evt.evtype.infos ()));
break;
}
}
else search = false;
}
return evt;
}
/**
*
*/
@ -367,26 +277,15 @@ public class Pluie.Yaml.Processor
this.error_event = this.event;
}
/**
*
*/
private bool is_entry_nested_block (Yaml.Node node)
{
return node.ntype.is_sequence () && !node.empty() && node.first ().ntype.is_collection ();
}
/**
*
*/
private void on_block_end ()
{
if (this.prev_node.ntype.is_scalar () || (this.prev_node.ntype.is_single_pair () && this.prev_node.parent != null && this.prev_node.parent.ntype.is_mapping ())) {
this.prev_node = this.prev_node.parent;
}
this.parent_node = this.prev_node.parent != null && this.prev_node.parent != this.root
? this.prev_node.parent
? this.prev_node.parent.parent
: this.root;
this.prev_node = this.parent_node;
this.prev_node = this.parent_node;
}
/**
@ -394,13 +293,12 @@ public class Pluie.Yaml.Processor
*/
private void on_entry ()
{
this.isEntry = true;
this.ckey = null;
var e = this.get_next_event ();
if (e!= null && e.evtype.is_mapping_start ()) {
this.isEntryMapping = true;
this.create_mapping (true);
this.next_event ();
this.event = this.next_event();
if (this.event.evtype.is_mapping_start ()) {
this.on_mapping_start (true);
}
else if (this.event.evtype.is_scalar ()) {
this.on_scalar (true);
}
}
@ -432,9 +330,23 @@ public class Pluie.Yaml.Processor
private void on_key ()
{
this.on_tag (true);
this.ckey = this.event.data["data"];
}
/**
*
*/
private void on_value ()
{
this.on_tag (false);
if (this.event.evtype.is_scalar ()) {
this.ckey = this.event.data["data"];
Yaml.dbg (" >> node name : %s".printf (this.ckey));
this.on_scalar ();
}
else if (this.event.evtype.is_anchor ()) {
this.on_anchor ();
}
else if (this.event.evtype.is_alias ()) {
this.on_alias ();
}
}
@ -443,13 +355,16 @@ public class Pluie.Yaml.Processor
*/
private void on_scalar (bool entry = false)
{
if (this.ckey != null && this.parent_node.ntype.is_collection ()) {
this.node = new Yaml.Mapping.with_scalar (this.parent_node, this.ckey, this.event.data["data"]);
if (!entry) {
if (this.ckey != null) {
this.node = new Yaml.Mapping.with_scalar (this.parent_node, this.ckey, this.event.data["data"]);
this.change = true;
}
}
else {
this.node = new Yaml.Scalar (this.parent_node, this.event.data["data"]);
this.node = new Yaml.Scalar (this.parent_node, this.event.data["data"]);
this.change = true;
}
this.change = true;
}
/**
@ -457,9 +372,8 @@ public class Pluie.Yaml.Processor
*/
private void on_anchor ()
{
if (this.event.data != null) {
this.idAnchor = this.event.data["id"];
}
this.idAnchor = this.event.data["id"];
this.event = this.next_event ();
}
/**
@ -467,14 +381,12 @@ public class Pluie.Yaml.Processor
*/
private void on_alias ()
{
if (this.event.data != null) {
this.idAnchor = this.event.data["id"];
Yaml.Node? refnode = this.anchors.get(this.idAnchor);
if (refnode != null) {
this.node = refnode.clone_node (this.ckey);
this.parent_node.add (this.node);
this.prev_node = this.node;
}
this.idAnchor = this.event.data["id"];
Yaml.Node? refnode = this.anchors.get(this.idAnchor);
if (refnode != null) {
this.node = refnode.clone_node (this.ckey);
this.parent_node.add (this.node);
this.prev_node = this.node;
}
}
@ -485,6 +397,7 @@ public class Pluie.Yaml.Processor
{
this.node = new Yaml.Sequence (this.parent_node, this.ckey);
this.change = true;
this.beginFlowSeq = true;
}
/**
@ -492,24 +405,11 @@ public class Pluie.Yaml.Processor
*/
private void on_mapping_start (bool entry = false)
{
this.ckey = null;
this.event = this.next_event ();
if (this.event.evtype.is_key ()) {
this.event = this.next_event ();
this.on_tag (true);
if (this.event.evtype.is_scalar ()) {
this.ckey = this.event.data["data"];
}
var e = this.get_next_value_event();
if (e!=null) {
if ( e.evtype.is_sequence_start ()) {
this.on_sequence_start ();
}
else {
this.create_mapping (this.isEntry);
}
}
if (entry) {
this.create_mapping (entry);
this.ckey = null;
}
else this.create_mapping ();
}
/**
@ -517,7 +417,7 @@ public class Pluie.Yaml.Processor
*/
private void create_mapping (bool entry = false)
{
if (entry && this.ckey == null) {
if (entry) {
this.ckey = "_%d".printf(this.parent_node.count());
}
this.node = new Yaml.Mapping (this.parent_node, this.ckey);
@ -529,8 +429,10 @@ public class Pluie.Yaml.Processor
*/
private void add_anchor_if_needed ()
{
if (this.idAnchor != null && this.node != null) {
this.anchors.set(this.idAnchor, this.node);
if (this.idAnchor != null) {
if (this.node != null) {
this.anchors.set(this.idAnchor, this.node);
}
this.idAnchor = null;
}
}
@ -541,16 +443,9 @@ public class Pluie.Yaml.Processor
private void on_update ()
{
if (this.node != null) {
Yaml.dbg (Log.METHOD);
Yaml.dbg (this.node.name);
Yaml.dbg (this.node.ntype.infos ());
Yaml.dbg ("anchor ? %s".printf (this.idAnchor));
}
if (this.change) {
if (this.node.parent.ntype.is_sequence ()) {
var seq = this.node.parent as Yaml.Sequence;
if (seq != null) seq.close_block = false;
}
Yaml.dbg_action ("on change", this.node.name != null ? this.node.name : this.node.data);
if (this.keyTag != null) {
Yaml.dbg_action ("setting tag", this.keyTag.@value);
@ -575,10 +470,7 @@ public class Pluie.Yaml.Processor
this.keyTag = null;
this.valueTag = null;
this.node = null;
this.isEntryMapping = false;
this.change = false;
this.isEntry = false;
this.ckey = null;
}
}

198
src/vala/Pluie/Yaml.Register.vala
View File

@ -1,210 +1,94 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Pluie;
using Gee;
/**
* A Register class responsible to register owner types and related types lists
*
* The register also manage full namespace resolving for the yaml tags generation <<BR>>
* (from Yaml.Object to Yaml.Node)
*
* The registered types means that they can (must) be populated from Yaml.Node
* to Yaml.Object or the opposite.<<BR>>
* See classes Yaml.Builder & Yaml.Object for more details about that.
* a class registering type which could be populated
*/
public class Pluie.Yaml.Register
public class Pluie.Yaml.Register : GLib.Object
{
/**
*
*/
static Gee.HashMap<Type, Gee.ArrayList<GLib.Type>> rtype;
/**
*
*/
static Gee.ArrayList<string> namespaces;
/**
*
*/
static Gee.HashMap<Quark, string> ns_resolved;
public static Gee.HashMap<Type, Gee.ArrayList<GLib.Type>> reg { get; internal set; }
/**
*
*/
static construct {
Yaml.Register.rtype = new Gee.HashMap<Type, Gee.ArrayList<GLib.Type>> ();
Yaml.Register.namespaces = new Gee.ArrayList<string> ();
Yaml.Register.ns_resolved = new Gee.HashMap<Quark, string> ();
Yaml.Register.reg = new Gee.HashMap<Type, Gee.ArrayList<GLib.Type>> ();
}
/**
*
*/
internal Register ()
{
}
/**
* add multiple type to specified owner type
* @param owner_type the owner type to registering types
*/
public static bool add_type (GLib.Type owner_type, ...)
{
bool done = true;
if (!is_registered (owner_type)) {
rtype.set (owner_type, init_type_list ());
}
var l = va_list();
while (done) {
GLib.Type? t = l.arg<GLib.Type> ();
if (t == null || t == Type.INVALID) {
break;
}
Yaml.dbg ("adding to %s type %s".printf (owner_type.name (), t.name ()));
done = done && rtype.get (owner_type).add (t);
}
return done;
}
/**
* check if specified owner_type is registered
* @param owner_type the owner type to check
*/
public static bool is_registered (GLib.Type owner_type)
{
return rtype.has_key (owner_type);
}
/**
* check if specified type is registered for specified owner_type
* @param owner_type the owner type to check
* @param type the type presumably belonging to owner type
*/
public static bool is_registered_type (GLib.Type owner_type, GLib.Type type)
{
return is_registered (owner_type) && rtype.get (owner_type).contains (type);
}
/**
* add one or multiple namespace for tag resolution
* namespace value ar same as in vala source code (so with dot separator)
* @param name a namespace to register
*/
public static bool add_namespace (string name, ...)
{
var l = va_list();
Yaml.dbg ("adding namespace %s".printf (name));
var done = Yaml.Register.namespaces.contains (name) || Yaml.Register.namespaces.add (name);
while (done) {
string? ns = l.arg();
if (ns == null) {
break; // end of the list
}
Yaml.dbg ("adding namespace %s".printf (ns));
if (!Yaml.Register.namespaces.contains (ns)) {
done = done && Yaml.Register.namespaces.add (ns);
}
}
return done;
}
/**
* resolve full namespace for specified type
* @param type the type to retriew his full namespace
* @return the full namespace
*/
public static string resolve_namespace_type (GLib.Type type)
{
if (!is_resolved_ns (type)) {
var name = type.name ();
try {
Regex reg = new Regex ("([A-Z]{1}[a-z]+)");
var d = reg.split (type.name (), 0);
var rn = "";
var gb = "";
for (var i = 1; i < d.length; i+=2) {
rn += d[i];
if (namespaces.contains (rn)) {
rn += ".";
gb += d[i];
}
}
// case ENUM which ends with dot
if (rn.substring(-1) == ".") {
rn = name.splice (0, gb.length, rn);
}
name = rn;
}
catch (GLib.RegexError e) {
of.error (e.message);
}
var serial = get_serial (type);
Yaml.dbg ("resolve_namespace_type %u (%s) => %s".printf (serial, type.name (), name));
ns_resolved.set (serial, name);
}
return get_resolved_ns (type);
}
/**
*
*/
private static Gee.ArrayList<GLib.Type> init_type_list ()
private Gee.ArrayList<GLib.Type> init_type_list ()
{
return new Gee.ArrayList<GLib.Type> ();
}
/**
* check if full namespace is already resolved for specified type
* @param type the type to check
*
*/
private static bool is_resolved_ns (GLib.Type type)
public Gee.ArrayList<GLib.Type>? get_type_list (GLib.Type type)
{
return ns_resolved.has_key (get_serial (type));
return reg.get (type);
}
/**
* get Quark related to specified type
*
*/
private static Quark get_serial (Type type)
public bool add_type (GLib.Type type, GLib.Type addedType)
{
return Quark.from_string (type.name ());
if (!this.is_registered (type)) {
reg.set (type, this.init_type_list ());
}
return reg.get (type).add (addedType);
}
/**
* retriew full namespace value for specified type
* @param type the type to retriew his full namespace
* @return the full namespace for specified type
*
*/
private static string get_resolved_ns (GLib.Type type)
public bool is_registered (GLib.Type type)
{
return is_resolved_ns (type) ? ns_resolved.get (get_serial (type)) : type.name ();
return reg.has_key (type);
}
/**
*
*/
public bool is_registered_type (GLib.Type type, GLib.Type checktype)
{
return this.is_registered (type) && reg.get (type).contains (checktype);
}
}

47
src/vala/Pluie/Yaml.Root.vala
View File

@ -1,64 +1,59 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Pluie;
using Gee;
/**
* a class representing a Yaml Root Node
* a class representing a mapping node
*/
public class Pluie.Yaml.Root : Yaml.Mapping
{
/**
* Tags directives
* Tags map definition
*/
public Gee.HashMap<string, string> tag_directives { get; internal set; }
/**
* @param name the name of the root node
*
*/
public Root (string? name = "PluieYamlRoot", bool add_directive = false, Yaml.Node? child = null)
public Root (string? name = "PluieYamlRoot")
{
base (null, name);
this.ntype = Yaml.NODE_TYPE.ROOT;
this.tag_directives = new Gee.HashMap<string, string> ();
if (add_directive) {
this.tag_directives["!%s!".printf (Yaml.YAML_VALA_PREFIX)] = Yaml.YAML_VALA_DIRECTIVE;
}
if (child != null) {
this.add (child);
}
}
/**
* get tag directives formatted for colorized output
*
*/
public string get_display_tag_directives ()
{

34
src/vala/Pluie/Yaml.Scalar.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Pluie;
@ -47,8 +48,7 @@ public class Pluie.Yaml.Scalar : Yaml.Node
public Scalar (Yaml.Node ? parent = null, string? data = null)
{
base (parent, NODE_TYPE.SCALAR);
this.container = false;
this.data = data;
this.data = data;
}
/**

53
src/vala/Pluie/Yaml.Scanner.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;
@ -37,7 +38,6 @@ extern void yaml_parse_file(string srcPath, string destPath);
*/
public class Pluie.Yaml.Scanner
{
string path;
/**
* Regex pattern use to find EVENT
*/
@ -112,24 +112,9 @@ public class Pluie.Yaml.Scanner
*/
public Scanner (string path)
{
var date = new GLib.DateTime.now_local ().format ("%s");
this.path = Path.build_filename (Environment.get_tmp_dir (), "pluie-yaml-%s-%s.events".printf (date, Path.get_basename(path)));
yaml_parse_file(path, this.path);
this.reader = new Io.Reader (this.path);
}
/**
*
*/
~Scanner()
{
var f = GLib.File.new_for_path (this.path);
try {
f.delete ();
}
catch (GLib.Error e) {
of.error (e.message);
}
var destPath = Path.build_filename (Environment.get_tmp_dir (), Path.get_basename(path));
yaml_parse_file(path, destPath);
this.reader = new Io.Reader (destPath);
}
/**

32
src/vala/Pluie/Yaml.Sequence.vala
View File

@ -1,31 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Pluie;
@ -36,7 +37,6 @@ using Gee;
*/
public class Pluie.Yaml.Sequence : Yaml.Node
{
internal bool close_block { internal get; internal set; default = false; }
/**
* default Yaml.Node constructor

32
src/vala/Pluie/Yaml.Tag.vala
View File

@ -1,32 +1,32 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
using GLib;
using Gee;

718
src/vala/Pluie/Yaml.global.vala
View File

@ -1,461 +1,365 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.60
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.5
* @type : library
* @date : 2018
* @licence : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org/>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
namespace Pluie.Yaml
namespace Pluie
{
const string YAML_VERSION = "1.2";
const string YAML_VALA_PREFIX = "v";
const string YAML_VALA_DIRECTIVE = "tag:pluie.org,2018:vala/";
public static bool DEBUG = false;
public static bool DBG_SHOW_INDENT = true;
public static bool DBG_SHOW_PARENT = false;
public static bool DBG_SHOW_UUID = true;
public static bool DBG_SHOW_LEVEL = false;
public static bool DBG_SHOW_REF = false;
public static bool DBG_SHOW_COUNT = true;
public static bool DBG_SHOW_TAG = true;
public static bool DBG_SHOW_TYPE = true;
/**
*
*/
internal static void dbg_action (string msg, string? val = null)
namespace Yaml
{
if (Pluie.Yaml.DEBUG) of.action (msg, val);
}
public static bool DEBUG = false;
/**
*
*/
internal static void dbg_keyval (string key, string val)
{
if (Pluie.Yaml.DEBUG) of.keyval (key, val);
}
/**
*
*/
internal static void dbg_state (bool done)
{
if (Pluie.Yaml.DEBUG) of.state (done);
}
/**
*
*/
internal static void dbg (string? msg = null)
{
if (Pluie.Yaml.DEBUG && msg != null) of.echo (msg);
}
/**
* ParseError
*/
public errordomain AddNodeError
{
MAPPING_CONTAINS_CHILD,
MAPPING_IS_SINGLE_PAIR,
MAPPING_NOT_SINGLE_PAIR
}
private const ZlibCompressorFormat ZFORMAT = ZlibCompressorFormat.GZIP;
/**
*
*/
private void convert (File source, File dest, Converter converter) throws Error {
var src_stream = source.read ();
var dst_stream = dest.replace (null, false, 0);
var conv_stream = new ConverterOutputStream (dst_stream, converter);
// 'splice' pumps all data from an InputStream to an OutputStream
conv_stream.splice (src_stream, 0);
}
/**
* serialize an object as a yaml compressed document data
* @param obj the object to serialize
* @param dest path destination if you want to write to a file
*/
public static uint8[] serialize (GLib.Object? obj, string? dest = null)
{
Array<uint8> a = new Array<uint8> ();
if (obj != null) {
var node = obj.get_type ().is_a (typeof (Yaml.Node)) ? obj as Yaml.Node : Yaml.Builder.to_node (obj);
if (node != null) {
var content = node.to_yaml_string ();
var date = new GLib.DateTime.now_local ().format ("%s");
var path = Path.build_filename (Environment.get_tmp_dir (), "pluie-yaml-%s-%s.source".printf (date, node.uuid));
var dpath = dest == null ? path + ".gz" : dest;
var writter = new Io.Writter (path);
if (writter.write (content.data)) {
try {
var gzfile = File.new_for_path (dpath);
convert (writter.file, gzfile, new ZlibCompressor (ZFORMAT));
var reader = new Io.InputChunkStream(dpath, 80);
while (!reader.eof ()) {
var b = reader.read ();
a.append_vals (b, reader.get_buffer_size ());
}
writter.delete_file ();
if (dest == null) {
writter.delete_file (gzfile);
}
}
catch (GLib.Error e) {
of.error (e.message);
}
}
}
}
return a.data;
}
/**
* deserialize yaml compressed document data to a Yaml.Object
* @param zdata the data to deserialized
*/
public static Yaml.Root deserialize (uint8[] zdata)
{
Yaml.Root? obj = null;
if (zdata.length > 0) {
var date = new GLib.DateTime.now_local ().format ("%s");
var path = Path.build_filename (Environment.get_tmp_dir (), "pluie-yaml-%s.gz".printf (date));
var dpath = Path.build_filename (Environment.get_tmp_dir (), "pluie-yaml-%s.source".printf (date));
var writter = new Io.Writter (path);
if (writter.write (zdata)) {
var file = File.new_for_path (dpath);
try {
convert (writter.file, file, new ZlibDecompressor (ZFORMAT));
var config = new Yaml.Config (dpath);
obj = config.root_node ();
writter.delete_file ();
}
catch(GLib.Error e) {
of.error (e.message);
}
}
}
return obj;
}
/**
* haxadecimal sequence
*/
const string hexa_sequence = "0123456789abcdef";
/**
* convert %02x string to uint8
* @param hex2byte string representation of hexadecimal value on 1 byte
*/
uint8 hex_to_dec (string hexbyte)
{
return (uint8) (
Yaml.hexa_sequence.index_of(hexbyte.data[0].to_string ())*16 +
Yaml.hexa_sequence.index_of(hexbyte.data[1].to_string ())
);
}
/**
* enum MatchInfo keys of Yaml.Mode.find method related to mode FIND_MODE.SQUARE_BRACKETS of Yaml.Node
*/
public enum EVT {
NONE,
STREAM_START,
STREAM_END,
VERSION_DIRECTIVE,
TAG_DIRECTIVE,
DOCUMENT_START,
DOCUMENT_END,
BLOCK_SEQUENCE_START,
BLOCK_MAPPING_START,
BLOCK_END,
FLOW_SEQUENCE_START,
FLOW_SEQUENCE_END,
FLOW_MAPPING_START,
FLOW_MAPPING_END,
BLOCK_ENTRY,
FLOW_ENTRY,
KEY,
VALUE,
ALIAS,
ANCHOR,
TAG,
SCALAR;
/**
* @return infos related to EVT
*/
public string infos ()
{
return this.to_string().substring("PLUIE_YAML_".length);
}
/**
* @return event is key
*/
public bool is_key ()
{
return this == EVT.KEY;
}
/**
* @return event is anchor
*/
public bool is_anchor ()
{
return this == EVT.ANCHOR;
}
/**
* @return event is alias
*/
public bool is_alias ()
{
return this == EVT.ALIAS;
}
/**
* @return event is tag
*/
public bool is_tag ()
{
return this == EVT.TAG;
}
/**
* @return event is tag
*/
public bool is_tag_directive ()
{
return this == EVT.TAG_DIRECTIVE;
}
/**
* @return event is key
*/
public bool is_value ()
{
return this == EVT.VALUE;
}
/**
* @return event is scalar
*/
public bool is_scalar ()
{
return this == EVT.SCALAR;
}
/**
* @return event is mapping start event
*/
public bool is_mapping_start ()
{
return this == EVT.BLOCK_MAPPING_START || this == EVT.FLOW_MAPPING_START;
}
/**
* @return event is sequence start event
*/
public bool is_sequence_start ()
{
return this == EVT.BLOCK_SEQUENCE_START || this == EVT.FLOW_SEQUENCE_START;
}
/**
* @return event is sequence end event
*/
public bool is_sequence_end ()
{
return this == EVT.BLOCK_END || this == EVT.FLOW_SEQUENCE_END;
}
/**
* @return event is sequence entry event
*/
public bool is_entry ()
{
return this == EVT.BLOCK_ENTRY || this == EVT.FLOW_ENTRY;
}
/**
* @return event is mapping end event
*/
public bool is_mapping_end ()
{
return this == EVT.BLOCK_END;
}
/**
* @return event is error event
*/
public bool is_error ()
{
return this == EVT.NONE;
}
/**
* @return event is document start event
*/
public bool is_document_start ()
{
return this == EVT.DOCUMENT_START;
}
/**
* @return event is stream start event
*/
public bool is_stream_start ()
{
return this == EVT.STREAM_START;
}
}
/**
* enum possible find mode of Yaml.Node.mode
*/
public enum FIND_MODE
{
DOT,
SQUARE_BRACKETS;
public static bool DBG_SHOW_INDENT = true;
public static bool DBG_SHOW_PARENT = false;
public static bool DBG_SHOW_UUID = true;
public static bool DBG_SHOW_LEVEL = false;
public static bool DBG_SHOW_REF = false;
public static bool DBG_SHOW_COUNT = true;
public static bool DBG_SHOW_TAG = true;
public static bool DBG_SHOW_TYPE = true;
/**
*
*/
public bool is_dot ()
public static void dbg_action (string msg, string? val = null)
{
return this == DOT;
}
}
public static FIND_MODE MODE = FIND_MODE.DOT;
/**
* enum MatchInfo keys of Yaml.Mode.find method related to mode FIND_MODE.SQUARE_BRACKETS of Yaml.Node
*/
internal enum FIND_COLLECTION { PATH, OPEN, KEY, CLOSE; }
/**
* enum MatchInfo keys of Yaml.Node.find method related to mode FIND_MODE.DOT of Yaml.Node
*/
internal enum FIND_DOT { PATH, KEY, SEQUENCE; }
/**
* enum possible type of Yaml.Node
*/
public enum NODE_TYPE
{
UNDEFINED,
ROOT,
SCALAR,
SINGLE_PAIR,
MAPPING,
SEQUENCE;
/**
* @return if current NODE_TYPE match a collection node (root|mapping|sequence)
*/
public bool is_collection ()
{
return this == MAPPING || this == SEQUENCE || this == ROOT;
if (Pluie.Yaml.DEBUG) of.action (msg, val);
}
/**
* @return if current NODE_TYPE match a scalar node
*
*/
public bool is_scalar ()
public static void dbg_keyval (string key, string val)
{
return this == SCALAR;
if (Pluie.Yaml.DEBUG) of.keyval (key, val);
}
/**
* @return if current NODE_TYPE match a single/pair mapping node
*
*/
public bool is_single_pair ()
public static void dbg_state (bool done)
{
return this == SINGLE_PAIR;
if (Pluie.Yaml.DEBUG) of.state (done);
}
/**
* @return if current NODE_TYPE match a mapping node
*
*/
public bool is_mapping ()
public static void dbg (string? msg = null)
{
return this == MAPPING;
if (Pluie.Yaml.DEBUG && msg != null) of.echo (msg);
}
/**
* @return if current NODE_TYPE match a sequence node
* ParseError
*/
public bool is_sequence ()
public errordomain AddNodeError
{
return this == SEQUENCE;
MAPPING_CONTAINS_CHILD,
MAPPING_IS_SINGLE_PAIR,
MAPPING_NOT_SINGLE_PAIR
}
/**
* @return if current NODE_TYPE match a root node
* haxadecimal sequence
*/
public bool is_root ()
const string hexa_sequence = "0123456789abcdef";
/**
* convert %02x string to uint8
* @param hex2byte string representation of hexadecimal value on 1 byte
*/
uint8 hex_to_dec (string hexbyte)
{
return this == ROOT;
return (uint8) (
Yaml.hexa_sequence.index_of(hexbyte.data[0].to_string ())*16 +
Yaml.hexa_sequence.index_of(hexbyte.data[1].to_string ())
);
}
/**
*@return infos related to NODE_TYPE
* enum MatchInfo keys of Yaml.Mode.find method related to mode FIND_MODE.SQUARE_BRACKETS of Yaml.Node
*/
public string infos ()
{
return this.to_string().substring("PLUIE_YAML_NODE_TYPE_".length);
}
}
public enum EVT {
NONE,
STREAM_START,
STREAM_END,
VERSION_DIRECTIVE,
TAG_DIRECTIVE,
DOCUMENT_START,
DOCUMENT_END,
BLOCK_SEQUENCE_START,
BLOCK_MAPPING_START,
BLOCK_END,
FLOW_SEQUENCE_START,
FLOW_SEQUENCE_END,
FLOW_MAPPING_START,
FLOW_MAPPING_END,
BLOCK_ENTRY,
FLOW_ENTRY,
KEY,
VALUE,
ALIAS,
ANCHOR,
TAG,
SCALAR;
/**
*@return a universal unique identifier (type 4)
*/
public string uuid ()
{
var sb = new StringBuilder();
for (var i = 0; i < 4; i++) sb.append (Random.next_int ().to_string ("%08x"));
var h = sb.str;
var d = Yaml.hex_to_dec (h.substring (16, 2));
d &= 0x3f;
d |= 0x80;
return "%s-%s-4%s-%02x%s-%s".printf (
h.substring (0, 8),
h.substring (8, 4),
h.substring (13, 3),
d,
h.substring (18, 2),
h.substring (20)
);
/**
* @return infos related to EVT
*/
public string infos ()
{
return this.to_string().substring("PLUIE_YAML_".length);
}
/**
* @return event is key
*/
public bool is_key ()
{
return this == EVT.KEY;
}
/**
* @return event is anchor
*/
public bool is_anchor ()
{
return this == EVT.ANCHOR;
}
/**
* @return event is alias
*/
public bool is_alias ()
{
return this == EVT.ALIAS;
}
/**
* @return event is tag
*/
public bool is_tag ()
{
return this == EVT.TAG;
}
/**
* @return event is tag
*/
public bool is_tag_directive ()
{
return this == EVT.TAG_DIRECTIVE;
}
/**
* @return event is key
*/
public bool is_value ()
{
return this == EVT.VALUE;
}
/**
* @return event is scalar
*/
public bool is_scalar ()
{
return this == EVT.SCALAR;
}
/**
* @return event is mapping start event
*/
public bool is_mapping_start ()
{
return this == EVT.BLOCK_MAPPING_START || this == EVT.FLOW_MAPPING_START;
}
/**
* @return event is sequence start event
*/
public bool is_sequence_start ()
{
return this == EVT.BLOCK_SEQUENCE_START || this == EVT.FLOW_SEQUENCE_START;
}
/**
* @return event is sequence end event
*/
public bool is_sequence_end ()
{
return this == EVT.BLOCK_END || this == EVT.FLOW_SEQUENCE_END;
}
/**
* @return event is sequence entry event
*/
public bool is_entry ()
{
return this == EVT.BLOCK_ENTRY || this == EVT.FLOW_ENTRY;
}
/**
* @return event is mapping end event
*/
public bool is_mapping_end ()
{
return this == EVT.BLOCK_END;
}
/**
* @return event is error event
*/
public bool is_error ()
{
return this == EVT.NONE;
}
}
/**
* enum possible find mode of Yaml.Node.mode
*/
public enum FIND_MODE
{
DOT,
SQUARE_BRACKETS;
/**
*
*/
public bool is_dot ()
{
return this == DOT;
}
}
public static FIND_MODE MODE = FIND_MODE.DOT;
/**
* enum MatchInfo keys of Yaml.Mode.find method related to mode FIND_MODE.SQUARE_BRACKETS of Yaml.Node
*/
internal enum FIND_COLLECTION { PATH, OPEN, KEY, CLOSE; }
/**
* enum MatchInfo keys of Yaml.Node.find method related to mode FIND_MODE.DOT of Yaml.Node
*/
internal enum FIND_DOT { PATH, KEY, SEQUENCE; }
/**
* enum possible type of Yaml.Node
*/
public enum NODE_TYPE
{
UNDEFINED,
ROOT,
SCALAR,
SINGLE_PAIR,
MAPPING,
SEQUENCE;
/**
* @return if current NODE_TYPE match a collection node (root|mapping|sequence)
*/
public bool is_collection ()
{
return this == MAPPING || this == SEQUENCE || this == ROOT;
}
/**
* @return if current NODE_TYPE match a scalar node
*/
public bool is_scalar ()
{
return this == SCALAR;
}
/**
* @return if current NODE_TYPE match a single/pair mapping node
*/
public bool is_single_pair ()
{
return this == SINGLE_PAIR;
}
/**
* @return if current NODE_TYPE match a mapping node
*/
public bool is_mapping ()
{
return this == MAPPING;
}
/**
* @return if current NODE_TYPE match a sequence node
*/
public bool is_sequence ()
{
return this == SEQUENCE;
}
/**
* @return if current NODE_TYPE match a root node
*/
public bool is_root ()
{
return this == ROOT;
}
/**
*@return infos related to NODE_TYPE
*/
public string infos ()
{
return this.to_string().substring("PLUIE_YAML_NODE_TYPE_".length);
}
}
/**
*@return universal infos related to NODE_TYPE
*/
public string uuid ()
{
var sb = new StringBuilder();
for (var i = 0; i < 4; i++) sb.append (Random.next_int ().to_string ("%08x"));
var h = sb.str;
var d = Yaml.hex_to_dec (h.substring (16, 2));
d &= 0x3f;
d |= 0x80;
return "%s-%s-4%s-%02x%s-%s".printf (
h.substring (0, 8),
h.substring (8, 4),
h.substring (13, 3),
d,
h.substring (18, 2),
h.substring (20)
);
}
}
}

68
src/vala/install.vala.in
View File

@ -1,68 +0,0 @@
/*^* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
* @version : 0.56
* @type : library
* @date : 2018
* @license : GPLv3.0 <http://www.gnu.org/licenses/>
* @author : a-Sansara <[dev]at[pluie]dot[org]>
* @copyright : pluie.org <http://www.pluie.org>
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* This file is part of pluie-yaml.
*
* pluie-yaml is free software (free as in speech) : you can redistribute it
* and/or modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *^*/
/**
* root namespace of various Pluie lib
*/
namespace Pluie
{
/**
* Pluie.Io is dedicated to various input/ouput operations
*/
namespace Io
{
}
/**
* Samples namespace to illustrate or test functionnalities
*/
namespace Samples
{
}
/**
* Pluie.Yaml provides various tools to deal with yaml files and yaml nodes :
*
* Use {@link Yaml.Config} to load a .yml file and build a {@link Yaml.Root} node<<BR>>
* Use {@link Yaml.Config.get} to retriew a particular {@link Yaml.Node}<<BR>>
* Use {@link Yaml.Builder} to convert a {@link Yaml.Node} into a {@link Yaml.Object}<<BR>>
* Use {@link Yaml.Dumper} to dump a {@link Yaml.Object} or {@link Yaml.Node} into a yaml string<<BR>>
* Use {@link Yaml.serialize} to serialize a {@link Yaml.Object} or {@link Yaml.Node} into a string<<BR>>
* Use {@link Yaml.deserialize} to deserialize a serialized string into a {@link Yaml.Node}<<BR>>
* Use {@link Yaml.Collection} and {@link Yaml.AbstractChild} methods for Node traversing
*/
namespace Yaml
{
protected const string INSTALL_PATH = "@INSTALL_PATH@";
public const string DATA_PATH = "@DATA_PATH@";
public const string VERSION = "@VERSION@";
}
}

54
valadoc.sh
View File

@ -1,48 +1,40 @@
#!/bin/bash
#^# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
# @version : 0.60
# @type : library
# @date : 2018
# @license : GPLv3.0 <http://www.gnu.org/licenses/>
# @author : a-Sansara <[dev]at[pluie]dot[org]>
# @copyright : pluie.org <http://www.pluie.org>
#!/bin/bash
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# @software : pluie-yaml <https://git.pluie.org/pluie/lib-yaml>
# @version : 0.5
# @type : library
# @date : 2018
# @licence : GPLv3.0 <http://www.gnu.org/licenses/>
# @author : a-Sansara <[dev]at[pluie]dot[org]>
# @copyright : pluie.org <http://www.pluie.org/>
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# This file is part of pluie-yaml.
#
#
# pluie-yaml is free software (free as in speech) : you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation, either version 3 of the License,
# or (at your option) any later version.
#
# pluie-yaml is distributed in the hope that it will be useful, but WITHOUT
#
# lib-yaml is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
# more details.
#
#
# You should have received a copy of the GNU General Public License
# along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
# along with pluie-yaml. If not, see <http://www.gnu.org/licenses/>.
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #^#
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
lib="pluie-yaml-0.6"
lib="pluie-yaml-0.5"
cd $DIR
valadoc --package-name=$lib --verbose --force --deps -o ./doc --pkg gee-0.8 --pkg gio-2.0 --pkg gobject-2.0 --pkg gmodule-2.0 --pkg glib-2.0 --pkg pluie-echo-0.2 ./src/vala/Pluie/*.vala ./build/install.vala
if [ $? -eq 0 ]; then
rm doc/*.png
cp resources/doc-scripts.js ./doc/scripts.js
cp resources/doc-style.css ./doc/style.css
if [ -f "./docfix" ]; then
./docfix
if [ $? -eq 0 ]; then
rm $lib.tar.gz
tar -czvf $lib.tar.gz doc/
scp $lib.tar.gz pluie@pluie.org:/home/pluie/
ssh pluie@pluie.org "./updatedoc.sh $lib"
fi
fi
fi
rm doc/*.png
cp resources/doc-scripts.js ./doc/scripts.js
cp resources/doc-style.css ./doc/style.css
rm $lib.tar.gz
tar -czvf $lib.tar.gz doc/