Metafacture is a toolkit for processing semi-structured data with a focus on library metadata. It provides a versatile set of tools for reading, writing and transforming data. Metafacture can be used as a stand-alone application or as a Java library in other applications. The name Metafacture is a portmanteau of the words metadata and manufacture.

Metafacture includes a large number of modules for operating on semi-structured data. These modules can be combined to build pipelines to perform complex metadata processing tasks. The pipelines can be constructed either in Java code or with the domain-specific language Flux. One of the core features of Metafacture is the Metamorph module. Metamorph is an XML-based language for specifying transformations of semi-structured data. It can be seamlessly integrated into Java code.

At its heart Metafacture is a framework for implementing modules for metadata processing. This makes Metafacture easily extendable with additional modules. The plugins and tools page on the wiki shows supplementary packages and projects which extend Metafacture.

Originally, Metafacture was developed as part of the Culturegraph platform but it is developed independently now and used by others, too: see who uses Metafacture.

Getting started

You can either use Metafacture as a stand-alone application or include it as a Java library in your own projects.

Metafacture as a stand-alone application

If you are only interested in running Flux scripts without doing any Java programming this is the way to go. The instructions assume that you are using a *nix-like shell. See more information in the wiki page about Flux. You can build the stand-alone application yourself or download it.

a) Build

Proceed as described in Building metafacture-core from source.

b) Download

Download the latest distribution package from the release page. Make sure that you do download a distribution package and not a source code package (the file name should include *-dist*).

Regardless if you've built or downloaded, go on with:

1. Extract the archive:

    $ tar xzf metafacture-core-$VERSION-dist.tar.gz

   This will create a new directory containing a ready-to-use Metafacture distribution.

2. Change into the newly created directory:

    $ cd metafacture-core-$VERSION

3. Run one of the example scripts:

    $ ./flux.sh examples/read/marc21/read-marc21.flux

   This example will print a number of MARC 21 records on standard output.

The examples folder contains many more examples which provide a good starting point for learning Metafacture. If you have any questions please take a look at the German Metafacture forum and create a topic there or open an issue over at metafacture-documentation metafacture-documentation.

Using Metafacture as a Java library

If you want to use Metafacture in your own Java projects all you need is to add some dependencies to your project. As of Metafacture 5, the single metafacture-core package has been replaced with a number of domain-specific packages. You can find the list of packages on Maven Central.

Alternatively, you can simply guess the package names from the top-level folders in the source code repository -- they are the same. For instance, if you want to use Metamorph in your project, simply add the following dependency to your pom.xml:

<dependency>
    <groupId>org.metafacture</groupId>
    <artifactId>metamorph</artifactId>
    <version>$VERSION</version>
</dependency>

or if Gradle is your build tool of choice use:

dependencies {
    implementation 'org.metafacture:metamorph:$VERSION'
}

Occasionally, we publish snapshot builds on Sonatype OSS Repository. The version number is derived from the branch name. Snapshot builds from the master branch always have the version master-SNAPSHOT. We also provide sometimes pre releases as github packages.

Building metafacture-core from source

Building metafacture-core from source is easy. All you need is git and JDK 17:

1. Clone the metafacture-core repository and change into the directory:

    $ git clone https://github.com/metafacture/metafacture-core.git
    $ cd metafacture-core

2. Invoke the Gradle wrapper to download Gradle and build metafacture-core (on Windows call gradlew.bat publishToMavenLocal instead) and publish these to your local Maven repository:

    $ ./gradlew publishToMavenLocal

3. Create a distribution if you need one. The resulting distribution can be found in metafacture-core/metafacture-runner/build/distributions/:

    $ ./gradlew assembleDist

(To import the projects in Eclipse, choose File > Import > Existing Gradle Project and select the metafacture-core directory.)

See Code Quality and Style on the wiki for further information on the sources.

Metafacture Fix

Metafacture Fix (Metafix) is work in progress towards tools and an implementation of the Fix language for Metafacture as an alternative to configuring data transformations with Metamorph. Inspired by Catmandu Fix, Metafix processes metadata not as a continuous data stream but as discrete records. The basic idea is to rebuild constructs from the (Catmandu) Fix language like functions, selectors and binds in Java and combine with additional functionalities from the Metamorph toolbox.

See also Fix Interest Group for an initiative towards an implementation-independent specification for the Fix Language.

The project metafix contains the actual implementation of the Fix language as a Metafacture module and related components. It started as an Xtext web project with a Fix grammar, from which a parser, a web editor, and a language server are generated. This project also contains an extension for VS code/codium based on that language server. (The web editor has been replaced by the Metafacture Playground.)

# Fix is a macro-language for data transformations

# Simple fixes

add_field("hello", "world")
remove_field("my.deep.nested.junk")
copy_field("stats", "output.$append")

# Conditionals

if exists("error")
  set_field("is_valid", "no")
  log("error")
elsif exists("warning")
  set_field("is_valid", "yes")
  log("warning")
else
  set_field("is_valid", "yes")
end

# Loops

do list(path: "foo", "var": "$i")
  add_field("$i.bar", "baz")
end

Usage

The project metafix contains and uses a new Metafix stream module for Metafacture which plays the role of the Metamorph module in Fix-based Metafacture workflows. For the current implementation of the Metafix stream module see the tests in metafix/src/test/java. To play around with some examples, check out the Metafacture Playground. For real-world usage samples see openRub.fix and duepublico.fix. For reference documentation, see Functions and cookbook.

Functions and cookbook

Best practices and guidelines for working with Metafacture Fix

• We recommend to use double quotation marks for arguments and values in functions, binds and conditionals.
• If using a list bind with a variable, the var option requires quotation marks (do list(path: "<sourceField>", "var": "<variableName>")).
• Fix turns repeated fields into arrays internally but only marked arrays (with [] at the end of the field name) are also emitted as "arrays" (entities with indexed literals), all other arrays are emitted as repeated fields.
• Every Fix file should end with a final newline.
• We recommend to wrap functions that create maps (e.g. put_filemap, put_map, put_rdfmap) as well as those that create macros (do put_macro) into a once bind since maps and macros are saved into memory. You can use one once bind for all maps and macros.

Glossary

Array wildcards

Array wildcards resemble Catmandu's concept of wildcards.

When working with arrays and repeated fields you can use wildcards instead of an index number to select elements of an array.

Path wildcards

Path wildcards resemble Metamorph's concept of wildcards. They are not supported in Catmandu (it has specialized Fix functions instead).

You can use path wildcards to select fields matching a pattern. They only match path segments (field names), though, not whole paths of nested fields. These wildcards cannot be used to add new elements.

Functions

Script-level functions

include

Includes a Fix file and executes it as if its statements were written in place of the function call.

Parameters:

• path (required): Path to Fix file (if the path starts with a ., it is resolved relative to the including file's directory; otherwise, it is resolved relative to the current working directory).

Options:

• All options are made available as "dynamic" local variables in the included Fix file.

include("<path>"[, <dynamicLocalVariables>...])

Example for Metafacture Runner

Java Code

log

Sends a message to the logs.

Parameters:

• logMessage (required): Message to log.

Options:

• level: Log level to log at (one of DEBUG, INFO, WARN or ERROR). (Default: INFO)

log("<logMessage>"[, level: "<logLevel>"])

Example for Metafacture Runner

Java Code

nothing

Does nothing. It is used for benchmarking in Catmandu.

nothing()

Example in Playground

Java Code

put_filemap

Defines an external map for lookup from a file or a URL. Maps with more than 2 columns are supported but are reduced to a defined key and a value column.

put_filemap("<sourceFile>", "<mapName>", sep_char: "\t")

The separator (sep_char) will vary depending on the source file, e.g.:

Options:

• allow_empty_values: Sets whether to allow empty values in the filemap or to ignore these entries. (Default: false)
• compression: Sets the compression of the file.
• decompress_concatenated: Flags whether to use decompress concatenated file compression.
• encoding: Sets the encoding used to open the resource.
• expected_columns: Sets number of expected columns; lines with different number of columns are ignored. Set to -1 to disable the check and allow arbitrary number of columns. (Default: 2)
• key_column: Defines the column to be used for keys. Uses zero index. (Default: 0)
• value_column: Defines the column to be used for values. Uses zero index. (Default: 1)

Example in Playground

Example for Metafacture Runner

Java Code

put_map

Defines an internal map for lookup from key/value pairs.

put_map("<mapName>",
  "dog": "mammal",
  "parrot": "bird",
  "shark": "fish"
)

Example in Playground

Java Code

put_rdfmap

Defines an external RDF map for lookup from a file or an HTTP(S) resource. As the RDF map is reducing RDF triples to a key/value map it is mandatory to set the target. The targeted RDF property can optionally be bound by an RDF language tag.

put_rdfmap("<rdfResource>", "<rdfMapName>", target: "<rdfProperty>")
put_rdfmap("<rdfResource>", "<rdfMapName>", target: "<rdfProperty>", select_language: "<rdfLanguageTag>")

Example in Playground

Java Code

put_var

Defines a single global variable that can be referenced with $[<variableName>].

put_var("<variableName>", "<variableValue>")

Example in Playground

Java Code

put_vars

Defines multiple global variables that can be referenced with $[<variableName>].

put_vars(
  "<variableName_1>": "<variableValue_1>",
  "<variableName_2>": "<variableValue_2>"
)

Example in Playground

Java Code

to_var

Defines a single global variable that can be referenced with $[<variableName>] and assigns the value of the <sourceField>.

to_var("<sourceField>", "<variableName>")

Options:

• default: Default value if source field does not exist. The option needs to be written in quotation marks because it is a reserved word in Java. (Default: Empty string)

Example in Playground

Java Code

Record-level functions

add_array

Creates a new array (with optional values).

add_array("<targetFieldName>")
add_array("<targetFieldName>", "<value_1>"[, ...])

Example in Playground

Java Code

add_field

Creates a field with a defined value.

add_field("<targetFieldName>", "<fieldValue>")

Example in Playground

Java Code

add_hash

Creates a new hash (with optional values).

add_hash("<targetFieldName>")
add_hash("<targetFieldName>", "subfieldName": "<subfieldValue>"[, ...])

Example in Playground

Java Code

array

Converts a hash/object into an array.

array("<sourceField>")

E.g.:

array("foo")
# {"name":"value"} => ["name", "value"]

Example in Playground

Java Code

call_macro

Calls a named macro, i.e. a list of statements that have been previously defined with the do put_macro bind.

Parameters:

• name (required): Unique name of the macro.

Options:

• All options are made available as "dynamic" local variables in the macro.

do put_macro("<macroName>"[, <staticLocalVariables>...])
  ...
end
call_macro("<macroName>"[, <dynamicLocalVariables>...])

Example in Playground

Java Code

copy_field

Copies a field from an existing field.

copy_field("<sourceField>", "<targetField>")

Example in Playground

Java Code

format

Replaces the value with a formatted (sprintf-like) version as in java.util.Formatter.

format("<sourceField>", "<formatString>")

Example in Playground

Java Code

hash

Converts an array into a hash/object.

hash("<sourceField>")

E.g.:

hash("foo")
# ["name", "value"] => {"name":"value"}

Example in Playground

Java Code

move_field

Moves a field from an existing field. Can be used to rename a field.

move_field("<sourceField>", "<targetField>")

Example in Playground

Java Code

parse_text

Parses a text into an array or hash of values using regular expressions and grouping.

parse_text("<sourceField>", "<parsePattern>")

E.g.:

# date1: "2015-03-07"
parse_text("date1", "(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)")
# "date1": "2015",
# "date1": "03".
# "date1": "07"
# This repeated field is internally an array, if you rename the field by adding a `[]` suffix the json/yaml encoder would also interpret this repeated element as array.

# "date2": "2015-03-07"
parse_text("date2", "(?<year>\\d\\d\\d\\d)-(?<month>\\d\\d)-(?<day>\\d\\d)")
# "date2":
#   "year": "2015"
#   "month": "03"
#   "day": "07"

# date: "abcd"
parse_text(date, '(\d\d\d\d)-(\d\d)-(\d\d)')
# date: "abcd"

Example in Playground

Java Code

paste

Joins multiple field values into a new field. Can be combined with additional literal strings.

The default join_char is a single space. Literal strings have to start with ~.

paste("<targetField>", "<sourceField_1>"[, ...][, "join_char": ", "])

E.g.:

# a: eeny
# b: meeny
# c: miny
# d: moe
paste("my.string", "~Hi", "a", "~how are you?")
# "my.string": "Hi eeny how are you?"

Example in Playground

Java Code

print_record

Prints the current record as JSON either to standard output or to a file.

Parameters:

• prefix (optional): Prefix to print before the record; may include format directives for counter and record ID (in that order). (Default: Empty string)

Options:

• append: Whether to open files in append mode if they exist. (Default: false)
• compression (file output only): Compression mode. (Default: auto)
• destination: Destination to write the record to; may include format directives for counter and record ID (in that order). (Default: stdout)
• encoding (file output only): Encoding used by the underlying writer. (Default: UTF-8)
• footer: Footer which is written at the end of the output. (Default: \n)
• header: Header which is written at the beginning of the output. (Default: Empty string)
• id: Field name which contains the record ID; if found, will be available for inclusion in prefix and destination. (Default: _id)
• internal: Whether to print the record's internal representation instead of JSON. (Default: false)
• pretty: Whether to use pretty printing. (Default: false)
• separator: Separator which is written after the record. (Default: \n)

print_record(["<prefix>"][, <options>...])

E.g.:

print_record("%d) Before transformation: ")
print_record(destination: "record-%2$s.json", id: "001", pretty: "true")
print_record(destination: "record-%03d.json.gz", header: "After transformation: ")

Example for Metafacture Runner

Java Code

random

Creates (or replaces) a field with a random number (less than the specified maximum).

random("<targetField>", "<maximum>")

Example in Playground

Java Code

remove_field

Removes a field.

remove_field("<sourceField>")

Example in Playground

Java Code

rename

Replaces a regular expression pattern in subfield names of a field. Does not change the name of the source field itself.

rename("<sourceField>", "<regexp>", "<replacement>")

Example in Playground

Java Code

retain

Deletes all fields except the ones listed (incl. subfields).

retain("<sourceField_1>"[, ...])

Example in Playground

Java Code

set_array

Creates a new array (with optional values), provided that the intermediate structures (i.e. parent fields) exist. To create any missing intermediate structures, use add_array instead.

set_array("<targetFieldName>")
set_array("<targetFieldName>", "<value_1>"[, ...])

Example in Playground

Java Code

set_field

Creates a field with a defined value, provided that the intermediate structures (i.e. parent fields) exist. To create any missing intermediate structures, use add_field instead.

set_field("<targetFieldName>", "<fieldValue>")

Example in Playground

Java Code

set_hash

Creates a new hash (with optional values), provided that the intermediate structures (i.e. parent fields) exist. To create any missing intermediate structures, use add_hash instead.

set_hash("<targetFieldName>")
set_hash("<targetFieldName>", "subfieldName": "<subfieldValue>"[, ...])

Example in Playground

Java Code

timestamp

Creates (or replaces) a field with the current timestamp.

Options:

• format: Date and time pattern as in java.text.SimpleDateFormat. (Default: timestamp)
• timezone: Time zone as in java.util.TimeZone. (Default: UTC)
• language: Language tag as in java.util.Locale. (Default: The locale of the host system)

timestamp("<targetField>"[, format: "<formatPattern>"][, timezone: "<timezoneCode>"][, language: "<languageCode>"])

Example in Playground

Java Code

vacuum

Deletes empty fields, arrays and objects.

vacuum()

Example in Playground

Java Code

Field-level functions

append

Adds a string at the end of a field value.

append("<sourceField>", "<appendString>")

Example in Playground

Java Code

capitalize

Upcases the first character in a field value.

capitalize("<sourceField>")

Example in Playground

Java Code

count

Counts the number of elements in an array or a hash and replaces the field value with this number.

count("<sourceField>")

Example in Playground

Java Code

downcase

Downcases all characters in a field value.

downcase("<sourceField>")

Example in Playground

Java Code

filter

Only keeps field values that match the regular expression pattern. Works only with array of strings/repeated fields.

filter("<sourceField>", "<regexp>")

Example in Playground

Java Code

flatten

Flattens a nested array field.

flatten("<sourceField>")

Example in Playground

Java Code

from_json

Replaces the string with its JSON deserialization.

Options:

• error_string: Error message as a placeholder if the JSON couldn't be parsed. (Default: null)

from_json("<sourceField>"[, error_string: "<errorValue>"])

Example in Playground

Java Code

html_to_text

Turns HTML text to plain text.

html_to_text("<sourceField>")

Example in Playground

Java Code

index

Returns the index position of a substring in a field and replaces the field value with this number.

index("<sourceField>", "<substring>")

Example in Playground

Java Code

isbn

Extracts an ISBN and replaces the field value with the normalized ISBN; optionally converts and/or validates the ISBN.

Options:

• to: ISBN format to convert to (either ISBN10 or ISBN13). (Default: Only normalize ISBN)
• verify_check_digit: Whether the check digit should be verified. (Default: false)
• error_string: Error message as a placeholder if the ISBN couldn't be validated. (Default: null)

isbn("<sourceField>"[, to: "<isbnFormat>"][, verify_check_digit: "<boolean>"][, error_string: "<errorValue>"])

Example in Playground

Java Code

join_field

Joins an array of strings into a single string.

join_field("<sourceField>", "<separator>")

Example in Playground

Java Code

lookup

Looks up matching values in a map and replaces the field value with this match. External files, internal maps as well as RDF resources can be used.

Parameters:

• path (required): Field path to look up.
• map (optional): Name or path of the map in which to look up values.

Options:

• default: Default value to use for unknown values. The option needs to be written in quotation marks because it is a reserved word in Java. (Default: Old value)
• delete: Whether to delete unknown values. (Default: false)
• print_unknown: Whether to print unknown values. (Default: false)

Additional options when printing unknown values:

• append: Whether to open files in append mode if they exist. (Default: true)
• compression (file output only): Compression mode. (Default: auto)
• destination: Destination to write unknown values to; may include format directives for counter and record ID (in that order). (Default: stdout)
• encoding (file output only): Encoding used by the underlying writer. (Default: UTF-8)
• footer: Footer which is written at the end of the output. (Default: \n)
• header: Header which is written at the beginning of the output. (Default: Empty string)
• id: Field name which contains the record ID; if found, will be available for inclusion in prefix and destination. (Default: _id)
• prefix: Prefix to print before the unknown value; may include format directives for counter and record ID (in that order). (Default: Empty string)
• separator: Separator which is written after the unknown value. (Default: \n)

lookup("<sourceField>"[, <mapName>][, <options>...])

E.g.:

# local (unnamed) map
lookup("path.to.field", key_1: "value_1", ...)

# internal (named) map
put_map("internal-map", key_1: "value_1", ...)
lookup("path.to.field", "internal-map")

# external file map (implicit)
lookup("path.to.field", "path/to/file", sep_char: ";")

# external file map (explicit)
put_filemap("path/to/file", "file-map", sep_char: ";")
lookup("path.to.field", "file-map")

# RDF map (explicit)
put_rdfmap("path/to/file", "rdf-map", target: "<rdfProperty>")
lookup("path.to.field", "rdf-map")

# with default value
lookup("path.to.field", "map-name", "default": "NA")

# with printing unknown values to a file
lookup("path.to.field", "map-name", print_unknown: "true", destination: "unknown.txt")

Example in Playground

Java Code

normalize_utf8

Performs normalization of diacritics in UTF-8 encoded strings.

normalize_utf8("<sourceField>")

Example in Playground

Java Code

prepend

Adds a string at the beginning of a field value.

prepend("<sourceField>", "<prependString>")

Example in Playground

Java Code

replace_all

Replaces a regular expression pattern in field values with a replacement string. Regexp capturing is possible; refer to capturing groups by number ($<number>) or name (${<name>}).

replace_all("<sourceField>", "<regexp>", "<replacement>")

Example in Playground

Java Code

reverse

Reverses the character order of a string or the element order of an array.

reverse("<sourceField>")

Example in Playground

Java Code

sort_field

Sorts strings in an array. Alphabetically and A-Z by default. Optional numerical and reverse sorting.

sort_field("<sourceField>")
sort_field("<sourceField>", reverse: "true")
sort_field("<sourceField>", numeric: "true")

Example in Playground

Java Code

split_field

Splits a string into an array and replaces the field value with this array.

split_field("<sourceField>", "<separator>")

Example in Playground

Java Code

substring

Replaces a string with its substring as defined by the start position (offset) and length.

substring("<sourceField>", "<startPosition>", "<length>")

Example in Playground

Java Code

sum

Sums numbers in an array and replaces the field value with this number.

sum("<sourceField>")

Example in Playground

Java Code

to_base64

Replaces the value with its Base64 encoding.

Options:

-url_safe: Perform URL-safe encoding (uses Base64URL format). (Default: false)

to_base64("<sourceField>"[, url_safe: "<boolean>"])

Example in Playground

Java Code

to_json

Replaces the value with its JSON serialization.

Options:

• error_string: Error message as a placeholder if the JSON couldn't be generated. (Default: null)
• pretty: Whether to use pretty printing. (Default: false)

to_json("<sourceField>"[, pretty: "<boolean>"][, error_string: "<errorValue>"])

Example in Playground

Java Code

trim

Deletes whitespace at the beginning and the end of a field value.

trim("<sourceField>")

Example in Playground

Java Code

uniq

Deletes duplicate values in an array.

uniq("<sourceField>")

Example in Playground

Java Code

upcase

Upcases all characters in a field value.

upcase("<sourceField>")

Example in Playground

Java Code

uri_encode

Encodes a field value as URI. Aka percent-encoding.

Options:

• plus_for_space: Sets whether "space" (`) will be substituted by a "plus" (+) or be percent escaped (%20). (Default:true`)
• safe_chars: Sets characters that won't be escaped. Safe characters are the ranges 0..9, a..z and A..Z. These are always safe and should not be specified. (Default: .-*_)

uri_encode("<sourceField>"[, <options>...])

E.g.:

uri_encode("path.to.field", plus_for_space:"false", safe_chars:"")

Example in Playground

Java Code

Selectors

reject

Ignores records that match a condition.

if <condition>
  reject()
end

Example in Playground

Java Code

Binds

do list

Iterates over each element of an array. In contrast to Catmandu, it can also iterate over a single object or string.

Java Code

do list(path: "<sourceField>")
  ...
end

Example in Playground

Only the current element is accessible in this case (as the root element).

When specifying a variable name for the current element, the record remains accessible as the root element and the current element is accessible through the variable name:

do list(path: "<sourceField>", "var": "<variableName>")
  ...
end

Example in Playground

do list_as

Iterates over each named element of an array (like do list with a variable name). If multiple arrays are given, iterates over the corresponding elements from each array (i.e., all elements with the same array index, skipping elements whose arrays have already been exhausted).

Example in Playground

Java Code

do list_as(element_1: "<sourceField_1>"[, ...])
  ...
end

E.g.:

# "ccm:university":["https://ror.org/0304hq317"]
# "ccm:university_DISPLAYNAME":["Gottfried Wilhelm Leibniz Universität Hannover"]
set_array("sourceOrga[]")
do list_as(orgId: "ccm:university[]", orgName: "ccm:university_DISPLAYNAME[]")
  copy_field(orgId, "sourceOrga[].$append.id")
  copy_field(orgName, "sourceOrga[].$last.name")
end
# {"sourceOrga":[{"id":"https://ror.org/0304hq317","name":"Gottfried Wilhelm Leibniz Universität Hannover"}]}

do once

Executes the statements only once (when the bind is first encountered), not repeatedly for each record.

do once()
  ...
end

Example in Playground

Java Code

In order to execute multiple blocks only once, tag them with unique identifiers:

do once("maps setup")
  ...
end
do once("vars setup")
  ...
end

do put_macro

Defines a named macro, i.e. a list of statements that can be executed later with the call_macro function.

Variables can be referenced with $[<variableName>], in the following order of precedence:

1. "dynamic" local variables, passed as options to the call_macro function;
2. "static" local variables, passed as options to the do put_macro bind;
3. global variables, defined via put_var/put_vars.

Parameters:

• name (required): Unique name of the macro.

Options:

• All options are made available as "static" local variables in the macro.

do put_macro("<macroName>"[, <staticLocalVariables>...])
  ...
end
call_macro("<macroName>"[, <dynamicLocalVariables>...])

Example in Playground

Java Code

Conditionals

Conditionals start with if in case of affirming the condition or unless rejecting the condition.

Conditionals require a final end.

Additional conditionals can be set with elsif and else.

if <condition(params, ...)>
  ...
end

Example in Playground

unless <condition(params, ...)>
  ...
end

Example in Playground

if <condition(params, ...)>
  ...
elsif
  ...
else
  ...
end

Example in Playground

contain

all_contain

Executes the functions if/unless the field contains the value. If it is an array or a hash all field values must contain the string.

Example in Playground

Java Code

any_contain

Executes the functions if/unless the field contains the value. If it is an array or a hash one or more field values must contain the string.

Example in Playground

Java Code

none_contain

Executes the functions if/unless the field does not contain the value. If it is an array or a hash none of the field values may contain the string.

Example in Playground

Java Code

str_contain

Executes the functions if/unless the first string contains the second string.

Example in Playground

Java Code

equal

all_equal

Executes the functions if/unless the field value equals the string. If it is an array or a hash all field values must equal the string.

Example in Playground

Java Code

any_equal

Executes the functions if/unless the field value equals the string. If it is an array or a hash one or more field values must equal the string.

Example in Playground

Java Code

none_equal

Executes the functions if/unless the field value does not equal the string. If it is an array or a hash none of the field values may equal the string.

Example in Playground

Java Code

str_equal

Executes the functions if/unless the first string equals the second string.

Example in Playground

Java Code

exists

Executes the functions if/unless the field exists.

if exists("<sourceField>")

Example in Playground

Java Code

greater_than

Executes the functions if/unless the field value is greater than the given value.

Example in Playground

Java Code

in

Executes the functions if/unless the field value is contained in the value of the other field.

_Also aliased as is_contained_in._

Example in Playground

Java Code

is_contained_in

Alias for in.

Java Code

is_array

Executes the functions if/unless the field value is an array.

Example in Playground

Java Code

is_empty

Executes the functions if/unless the field value is empty.

Example in Playground

Java Code

is_false

Executes the functions if/unless the field value equals false or 0.

Example in Playground

Java Code

is_hash

_Alias for is_object._

Example in Playground

Java Code

is_number

Executes the functions if/unless the field value is a number.

Example in Playground

Java Code

is_object

Executes the functions if/unless the field value is a hash (object).

_Also aliased as is_hash._

Java Code

is_string

Executes the functions if/unless the field value is a string (and not a number).

Example in Playground

Java Code

is_true

Executes the functions if/unless the field value equals true or 1.

Example in Playground

Java Code

less_than

Executes the functions if/unless the field value is less than the given value.

Example in Playground

Java Code

match

all_match

Executes the functions if/unless the field value matches the regular expression pattern. If it is an array or a hash all field values must match the regular expression pattern.

Example in Playground

Java Code

any_match

Executes the functions if/unless the field value matches the regular expression pattern. If it is an array or a hash one or more field values must match the regular expression pattern.

Example in Playground

Java Code

none_match

Executes the functions if/unless the field value does not match the regular expression pattern. If it is an array or a hash none of the field values may match the regular expression pattern.

Example in Playground

Java Code

str_match

Executes the functions if/unless the string matches the regular expression pattern.

Example in Playground

Java Code

Xtext

The Metafix projects have been originally set up with Xtext 2.17.0 and Eclipse for Java 2019-03, following https://www.eclipse.org/Xtext/documentation/104_jvmdomainmodel.html.

Stay updated

For support and discussion join the mailing list.