From 02801d4672322b26d45c276847860da7e784fcbf Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Tue, 17 Jun 2025 15:22:11 +0200 Subject: [PATCH 01/27] ajouter formtConfig sur Turtle / triG /ntriples --- .../serialization/BlankNodeStyleEnum.java | 15 + .../common/serialization/FormatConfig.java | 597 +++++++++++++++++- .../LiteralDatatypePolicyEnum.java | 19 + .../common/serialization/NQuadsFormat.java | 191 ++++-- .../common/serialization/NTriplesFormat.java | 118 +++- .../serialization/PrefixOrderingEnum.java | 19 + .../common/serialization/TurtleFormat.java | 4 + .../common/util/SerializationConstants.java | 20 + .../serialization/FormatConfigTest.java | 149 ++++- .../serialization/NQuadsFormatTest.java | 94 +-- .../serialization/NTriplesFormatTest.java | 175 ++--- .../serialization/TurtleFormatTest.java | 4 + 12 files changed, 1090 insertions(+), 315 deletions(-) create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/BlankNodeStyleEnum.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/LiteralDatatypePolicyEnum.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/PrefixOrderingEnum.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/BlankNodeStyleEnum.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/BlankNodeStyleEnum.java new file mode 100644 index 000000000..eab5e23e0 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/BlankNodeStyleEnum.java @@ -0,0 +1,15 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +/** + * Defines the style for serializing blank nodes. + */ +public enum BlankNodeStyleEnum { + /** + * Use the compact '[]' or '[ predicate object ; ... ]' shorthand syntax where possible. + */ + ANONYMOUS, + /** + * Use named blank nodes with generated IDs (e.g., '_:b1', '_:b2'). + */ + NAMED +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java index 0e85acff7..80d80541e 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java @@ -1,15 +1,145 @@ package fr.inria.corese.core.next.impl.common.serialization; +import fr.inria.corese.core.next.impl.common.util.SerializationConstants; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; import java.util.Objects; /** - * Configuration options for the {@link NTriplesFormat} serializer. - * Use {@link FormatConfig # Builder} to create instances. + * Configuration for RDF serialization formats (Turtle, TriG, N-Triples, N-Quads). + * This class provides a comprehensive set of options to control the output + * syntax, pretty-printing, and technical aspects of RDF serialization. + * + *

Use the {@link Builder} class to create instances of {@code FormatConfig}. + * Predefined configurations for common RDF formats are available via static methods + * like {@link #ntriplesConfig()}, {@link #nquadsConfig()}, {@link #turtleConfig()}, etc.

*/ public class FormatConfig { - private final String blankNodePrefix; + /** + * Whether prefix declarations (e.g., `@prefix`, `PREFIX`) should be used for compact IRIs. + * This is crucial for human-readable formats like Turtle but not for N-Triples. + */ + private final boolean usePrefixes; + /** + * Whether the serializer should automatically discover and declare prefixes used in the graph. + * This avoids manual prefix configuration but can lead to more prefixes than strictly needed. + */ + private final boolean autoDeclarePrefixes; + /** + * The policy for ordering prefix declarations (e.g., alphabetically, by usage, or custom). + * This impacts the determinism and readability of the prefix block. + */ + private final PrefixOrderingEnum prefixOrdering; + /** + * A map of custom URI prefixes to be used for serialization, in addition to or instead of + * auto-declared prefixes. Useful for enforcing specific prefix names or when {@code autoDeclarePrefixes} is false. + */ + private final Map customPrefixes; // Used for CUSTOM ordering or if autoDeclarePrefixes=false + + /** + * Whether compact triple syntax (e.g., using ';' for subject/predicate reuse and ',' for object lists) + * should be used. This significantly reduces file size and improves readability for formats like Turtle. + */ + private final boolean useCompactTriples; // Includes comma-separated objects and subject/predicate reuse via ';' + /** + * Whether the `a` shortcut should be used for `rdf:type` predicates. + * This is a common Turtle shorthand that improves conciseness and readability. + */ + private final boolean useRdfTypeShortcut; // 'a' instead of 'rdf:type' + /** + * Whether Turtle collection syntax `( item1 item2 )` should be used for `rdf:List` structures. + * This provides a more idiomatic and readable representation of lists in Turtle. + */ + private final boolean useCollections; // Turtle collection syntax ( ) + /** + * The preferred style for serializing blank nodes (e.g., `[]` vs `_:id`). + * This affects both the conciseness and the identifiability of blank nodes in the output. + */ + private final BlankNodeStyleEnum blankNodeStyle; // [] vs _:id + + // --- Pretty-Printing Options --- + /** + * Whether human-readable formatting with indentation and newlines (pretty-printing) is enabled. + * This makes the output easier for humans to read and debug, but increases file size slightly. + */ + private final boolean prettyPrint; + /** + * The string used for indentation (e.g., " ", "\t"). + * This defines the visual spacing for nested structures when pretty-printing. + */ + private final String indent; + /** + * The maximum desired line length before the serializer attempts to break lines. + * This helps ensure readability by preventing very long lines in the output. + */ + private final int maxLineLength; + /** + * Whether triples should be grouped by subject in the output (e.g., using ';' and '.'). + * This organizes the output logically around subjects, improving readability. + */ + private final boolean groupBySubject; // Group triples by subject using ; and . + /** + * Whether subjects should be sorted alphabetically in the output. + * This ensures a consistent and reproducible order of subjects, useful for diffing or testing. + */ + private final boolean sortSubjects; // Sort subjects alphabetically + /** + * Whether predicates should be sorted alphabetically within a subject group. + * This ensures a consistent and reproducible order of properties for a given subject. + */ + private final boolean sortPredicates; // Sort predicates alphabetically within a subject group + + // --- Technical Output Options --- + /** + * The policy for how literal datatypes are printed. + * This determines whether datatypes are always explicit, minimal, or follow specific rules. + */ + private final LiteralDatatypePolicyEnum literalDatatypePolicy; + /** + * Whether non-ASCII characters should be escaped using Unicode escape sequences (e.g., `\u00E9`). + * This ensures compatibility with systems that might not handle UTF-8 correctly, but makes output less human-readable. + */ + private final boolean escapeUnicode; // XXXX for non-ASCII + /** + * Whether a dot `.` should be added at the end of each triple block or statement. + * This is a syntax requirement for some RDF serialization formats (e.g., Turtle, N-Triples). + */ + private final boolean trailingDot; // Add a dot '.' at the end of each triple block + /** + * The base IRI to be used for the serialization. + * This allows relative IRIs to be resolved and can shorten the output by avoiding full IRIs. + */ + private final String baseIRI; // @base directive + /** + * Whether deterministic blank node IDs (e.g., `_:b0`, `_:b1`) should be generated. + * This is crucial for reproducible outputs, especially in testing environments, as blank node IDs are typically random. + */ + private final boolean stableBlankNodeIds; // Generate deterministic _:bids + // --- Validation & Context Options --- + /** + * General strictness setting for validation during serialization. + * Enabling this can catch errors or non-standard RDF constructs but might reject valid, less common patterns. + */ + private final boolean strictMode; // General strictness for validation + /** + * Whether URIs should be validated for compliance with RDF/Turtle/N-Triples rules. + * This ensures that generated URIs are valid and will be correctly parsed by other tools. + */ + private final boolean validateURIs; // Specific URI validation + /** + * Whether context information (named graphs) should be included in the serialization output. + * This is essential for formats like N-Quads or TriG which support named graphs. + */ + private final boolean includeContext; // For N-Quads (control writing the 4th element) + /** + * The string used for line endings (e.g., `"\n"` for Unix, `"\r\n"` for Windows). + * This ensures that the generated file has correct line endings for the target operating system. + */ + private final String lineEnding; /** * Private constructor to enforce usage of the Builder. @@ -17,53 +147,468 @@ public class FormatConfig { * @param builder The builder instance. */ private FormatConfig(Builder builder) { - this.blankNodePrefix = builder.blankNodePrefix; - } + this.usePrefixes = builder.usePrefixes; + this.autoDeclarePrefixes = builder.autoDeclarePrefixes; + this.prefixOrdering = Objects.requireNonNull(builder.prefixOrdering, "Prefix ordering cannot be null"); + this.customPrefixes = Collections.unmodifiableMap(new HashMap<>(Objects.requireNonNull(builder.customPrefixes, "Custom prefixes map cannot be null"))); - /** - * Returns the prefix to use for blank nodes. - * - * @return The blank node prefix. - */ - public String getBlankNodePrefix() { - return blankNodePrefix; + this.useCompactTriples = builder.useCompactTriples; + this.useRdfTypeShortcut = builder.useRdfTypeShortcut; + this.useCollections = builder.useCollections; + this.blankNodeStyle = Objects.requireNonNull(builder.blankNodeStyle, "Blank node style cannot be null"); + + // Pretty-Printing + this.prettyPrint = builder.prettyPrint; + this.indent = Objects.requireNonNull(builder.indent, "Indentation string cannot be null"); + this.maxLineLength = builder.maxLineLength; + this.groupBySubject = builder.groupBySubject; + this.sortSubjects = builder.sortSubjects; + this.sortPredicates = builder.sortPredicates; + + // Technical Output + this.literalDatatypePolicy = Objects.requireNonNull(builder.literalDatatypePolicy, "Literal datatype policy cannot be null"); + this.escapeUnicode = builder.escapeUnicode; + this.trailingDot = builder.trailingDot; + this.baseIRI = builder.baseIRI; // Can be null + this.stableBlankNodeIds = builder.stableBlankNodeIds; + + // Validation & Context + this.strictMode = builder.strictMode; + this.validateURIs = builder.validateURIs; + this.includeContext = builder.includeContext; + this.lineEnding = Objects.requireNonNull(builder.lineEnding, "Line ending cannot be null"); } + // --- Builder Class --- + /** * Builder class for {@link FormatConfig}. + * Provides a fluent API for constructing FormatConfig instances with default values. */ public static class Builder { + // Syntax Sugar Defaults + private boolean usePrefixes = true; + private boolean autoDeclarePrefixes = true; + private PrefixOrderingEnum prefixOrdering = PrefixOrderingEnum.ALPHABETICAL; + private Map customPrefixes = new HashMap<>(); + + private boolean useCompactTriples = true; + private boolean useRdfTypeShortcut = true; + // Default to false for complexity + private boolean useCollections = false; + // Default to NAMED (safer for initial impl) + private BlankNodeStyleEnum blankNodeStyle = BlankNodeStyleEnum.NAMED; - private String blankNodePrefix = "_:"; + // Pretty-Printing Defaults + private boolean prettyPrint = true; + private String indent = SerializationConstants.DEFAULT_INDENTATION; + private int maxLineLength = 80; + private boolean groupBySubject = true; + private boolean sortSubjects = false; + private boolean sortPredicates = false; + + // Technical Output Defaults + private LiteralDatatypePolicyEnum literalDatatypePolicy = LiteralDatatypePolicyEnum.MINIMAL; + private boolean escapeUnicode = false; + private boolean trailingDot = true; + private String baseIRI = null; + private boolean stableBlankNodeIds = false; + + // Validation & Context Defaults + private boolean strictMode = true; + private boolean validateURIs = true; + private boolean includeContext = false; + private String lineEnding = SerializationConstants.DEFAULT_LINE_ENDING; /** - * Default constructor for the Builder. - * Initializes fields with default values. + * Default constructor initializes all options with their default values. + * The values are directly assigned during field declaration above. */ - Builder() { + public Builder() { + // No initialized + } + // --- Builder Methods for Syntax Sugar Options --- + + public Builder usePrefixes(boolean usePrefixes) { + this.usePrefixes = usePrefixes; + return this; } - /** - * Sets the prefix to use for blank nodes. Default is "_:". - * - * @param blankNodePrefix The desired blank node prefix. - * @return The builder instance. - */ - public Builder blankNodePrefix(String blankNodePrefix) { - this.blankNodePrefix = Objects.requireNonNull(blankNodePrefix, "Blank node prefix cannot be null"); + public Builder autoDeclarePrefixes(boolean autoDeclarePrefixes) { + this.autoDeclarePrefixes = autoDeclarePrefixes; return this; } + public Builder prefixOrdering(PrefixOrderingEnum prefixOrdering) { + this.prefixOrdering = Objects.requireNonNull(prefixOrdering, "Prefix ordering cannot be null"); + return this; + } + + public Builder addCustomPrefix(String prefix, String namespace) { + Objects.requireNonNull(prefix, "Prefix name cannot be null"); + Objects.requireNonNull(namespace, "Namespace URI cannot be null"); + this.customPrefixes.put(prefix, namespace); + return this; + } + + public Builder addCustomPrefixes(Map prefixes) { + Objects.requireNonNull(prefixes, "Prefixes map cannot be null"); + this.customPrefixes.putAll(prefixes); + return this; + } + + public Builder useCompactTriples(boolean useCompactTriples) { + this.useCompactTriples = useCompactTriples; + return this; + } + + public Builder useRdfTypeShortcut(boolean useRdfTypeShortcut) { + this.useRdfTypeShortcut = useRdfTypeShortcut; + return this; + } + + public Builder useCollections(boolean useCollections) { + this.useCollections = useCollections; + return this; + } + + public Builder blankNodeStyle(BlankNodeStyleEnum blankNodeStyle) { + this.blankNodeStyle = Objects.requireNonNull(blankNodeStyle, "Blank node style cannot be null"); + return this; + } + + // --- Builder Methods for Pretty-Printing Options --- + + public Builder prettyPrint(boolean prettyPrint) { + this.prettyPrint = prettyPrint; + return this; + } + + public Builder indent(String indent) { + this.indent = Objects.requireNonNull(indent, "Indentation string cannot be null"); + return this; + } + + public Builder maxLineLength(int maxLineLength) { + this.maxLineLength = maxLineLength; + return this; + } + + public Builder groupBySubject(boolean groupBySubject) { + this.groupBySubject = groupBySubject; + return this; + } + + public Builder sortSubjects(boolean sortSubjects) { + this.sortSubjects = sortSubjects; + return this; + } + + public Builder sortPredicates(boolean sortPredicates) { + this.sortPredicates = sortPredicates; + return this; + } + + // --- Builder Methods for Technical Output Options --- + + public Builder literalDatatypePolicy(LiteralDatatypePolicyEnum literalDatatypePolicy) { + this.literalDatatypePolicy = Objects.requireNonNull(literalDatatypePolicy, "Literal datatype policy cannot be null"); + return this; + } + + public Builder escapeUnicode(boolean escapeUnicode) { + this.escapeUnicode = escapeUnicode; + return this; + } + + public Builder trailingDot(boolean trailingDot) { + this.trailingDot = trailingDot; + return this; + } + + public Builder baseIRI(String baseIRI) { + this.baseIRI = baseIRI; + return this; + } // Can be null + + public Builder stableBlankNodeIds(boolean stableBlankNodeIds) { + this.stableBlankNodeIds = stableBlankNodeIds; + return this; + } + + // --- Builder Methods for Validation & Context Options --- + + public Builder strictMode(boolean strictMode) { + this.strictMode = strictMode; + return this; + } + + public Builder validateURIs(boolean validateURIs) { + this.validateURIs = validateURIs; + return this; + } + + public Builder includeContext(boolean includeContext) { + this.includeContext = includeContext; + return this; + } + + public Builder lineEnding(String lineEnding) { + this.lineEnding = Objects.requireNonNull(lineEnding, "Line ending cannot be null"); + return this; + } /** - * Builds a new {@link FormatConfig} instance. + * Builds and returns a new {@link FormatConfig} instance with the current builder settings. * - * @return A new NFormatConfig instance. + * @return A new {@code FormatConfig} instance. + * @throws NullPointerException if any required field has not been set (should not happen with default values). */ public FormatConfig build() { return new FormatConfig(this); } } + + // --- Predefined Configurations --- + + /** + * Returns a default configuration suitable for N-Triples serialization. + * N-Triples is a simple, line-oriented format without prefixes, contexts, or complex syntax sugar. + * + * @return A {@code FormatConfig} instance for N-Triples. + */ + public static FormatConfig ntriplesConfig() { + return new Builder() + .usePrefixes(false) // N-Triples doesn't use prefixes + .autoDeclarePrefixes(false) + .useCompactTriples(false) // N-Triples is one triple per line + .useRdfTypeShortcut(false) + .useCollections(false) + .blankNodeStyle(BlankNodeStyleEnum.NAMED) // N-Triples uses _:bnodeId + .prettyPrint(false) // N-Triples is usually not "pretty-printed" beyond newlines + .indent("") // No indentation + .maxLineLength(0) // No line length limit for simplicity (or can be set very high) + .groupBySubject(false) // Each triple on its own line + .sortSubjects(false) // Order not strictly defined + .sortPredicates(false) // Order not strictly defined + .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) // N-Triples typically shows all datatypes explicitly + .escapeUnicode(true) // N-Triples often requires unicode escaping + .trailingDot(true) + .baseIRI(null) // No @base in N-Triples + .stableBlankNodeIds(true) // Good for reproducible N-Triples tests + .strictMode(true) // Be strict for N-Triples validation + .validateURIs(true) + .includeContext(false) // N-Triples does not support contexts + .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) + .build(); + } + + /** + * Returns a default configuration suitable for N-Quads serialization. + * N-Quads extends N-Triples with named graphs. + * + * @return A {@code FormatConfig} instance for N-Quads. + */ + public static FormatConfig nquadsConfig() { + return new Builder() + .usePrefixes(false) // N-Quads doesn't use prefixes + .autoDeclarePrefixes(false) + .useCompactTriples(false) + .useRdfTypeShortcut(false) + .useCollections(false) + .blankNodeStyle(BlankNodeStyleEnum.NAMED) + .prettyPrint(false) + .indent("") + .maxLineLength(0) + .groupBySubject(false) + .sortSubjects(false) + .sortPredicates(false) + .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) + .escapeUnicode(true) + .trailingDot(true) + .baseIRI(null) + .stableBlankNodeIds(true) + .strictMode(true) + .validateURIs(true) + .includeContext(true) // N-Quads includes contexts by definition + .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) + .build(); + } + + /** + * Returns a default configuration suitable for Turtle serialization. + * Turtle is a concise, human-readable format with extensive syntax sugar and pretty-printing. + * + * @return A {@code FormatConfig} instance for Turtle. + */ + public static FormatConfig turtleConfig() { + Map commonTurtlePrefixes = new HashMap<>(); + commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); + commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + + return new Builder() + .usePrefixes(true) + .autoDeclarePrefixes(true) // Auto-declare new prefixes found in the graph + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .addCustomPrefixes(commonTurtlePrefixes) // Start with common prefixes + .useCompactTriples(true) // Enable ; and , + .useRdfTypeShortcut(true) // Use 'a' + .useCollections(false) // Keep false for now due to complexity + .blankNodeStyle(BlankNodeStyleEnum.NAMED) // Default to NAMED, for now (shorthand is complex) + .prettyPrint(true) + .indent(SerializationConstants.DEFAULT_INDENTATION) + .maxLineLength(80) // Standard line length + .groupBySubject(true) + .sortSubjects(false) // Optional, for reproducible output + .sortPredicates(false) // Optional, for reproducible output + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) // Turtle's typical literal style + .escapeUnicode(false) // Usually direct UTF-8 for Turtle + .trailingDot(true) + .baseIRI(null) // No default base IRI + .stableBlankNodeIds(false) // Random by default + .strictMode(true) + .validateURIs(true) + .includeContext(false) // Turtle does not support contexts + .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) + .build(); + } + + /** + * Returns a default configuration suitable for TriG serialization. + * TriG extends Turtle with named graphs, supporting all Turtle features plus context inclusion. + * + * @return A {@code FormatConfig} instance for TriG. + */ + public static FormatConfig trigConfig() { + Map commonTriGPrefixes = new HashMap<>(); + commonTriGPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + commonTriGPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + commonTriGPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); + commonTriGPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + + return new Builder() + .usePrefixes(true) + .autoDeclarePrefixes(true) + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .addCustomPrefixes(commonTriGPrefixes) + .useCompactTriples(true) + .useRdfTypeShortcut(true) + .useCollections(false) + .blankNodeStyle(BlankNodeStyleEnum.NAMED) + .prettyPrint(true) + .indent(SerializationConstants.DEFAULT_INDENTATION) + .maxLineLength(80) + .groupBySubject(true) + .sortSubjects(false) + .sortPredicates(false) + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) + .escapeUnicode(false) + .trailingDot(true) + .baseIRI(null) + .stableBlankNodeIds(false) + .strictMode(true) + .validateURIs(true) + .includeContext(true) // TriG includes contexts by definition + .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) + .build(); + } + + + // --- Getters for all options --- + + public boolean usePrefixes() { + return usePrefixes; + } + + public boolean autoDeclarePrefixes() { + return autoDeclarePrefixes; + } + + public PrefixOrderingEnum getPrefixOrdering() { + return prefixOrdering; + } + + public Map getCustomPrefixes() { + return customPrefixes; + } + + public boolean useCompactTriples() { + return useCompactTriples; + } + + public boolean useRdfTypeShortcut() { + return useRdfTypeShortcut; + } + + public boolean useCollections() { + return useCollections; + } + + public BlankNodeStyleEnum getBlankNodeStyle() { + return blankNodeStyle; + } + + public boolean prettyPrint() { + return prettyPrint; + } + + public String getIndent() { + return indent; + } + + public int getMaxLineLength() { + return maxLineLength; + } + + public boolean groupBySubject() { + return groupBySubject; + } + + public boolean sortSubjects() { + return sortSubjects; + } + + public boolean sortPredicates() { + return sortPredicates; + } + + public LiteralDatatypePolicyEnum getLiteralDatatypePolicy() { + return literalDatatypePolicy; + } + + public boolean escapeUnicode() { + return escapeUnicode; + } + + public boolean trailingDot() { + return trailingDot; + } + + public String getBaseIRI() { + return baseIRI; + } + + public boolean stableBlankNodeIds() { + return stableBlankNodeIds; + } + + public boolean isStrictMode() { + return strictMode; + } + + public boolean validateURIs() { + return validateURIs; + } + + public boolean includeContext() { + return includeContext; + } + + public String getLineEnding() { + return lineEnding; + } } \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/LiteralDatatypePolicyEnum.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/LiteralDatatypePolicyEnum.java new file mode 100644 index 000000000..3ad06e788 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/LiteralDatatypePolicyEnum.java @@ -0,0 +1,19 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +/** + * Defines the policy for serializing literal datatypes. + */ +public enum LiteralDatatypePolicyEnum { + /** + * Only show datatype if it's not xsd:string and not rdf:langString. + */ + MINIMAL, + /** + * Always show the full datatype, even for xsd:string. + */ + ALWAYS_TYPED, + /** + * Only show explicit datatype for XSD types (non-XSD datatypes might be omitted or full URI). + */ + XSD_TYPED +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java index daa921cf0..9895e2e36 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java @@ -11,11 +11,6 @@ import java.io.Writer; import java.util.Objects; -/** - * Serializes a Corese {@link Model} into N-Quads format. - * This class provides a method to write the statements (quads) of a model to a given {@link Writer} - * according to the N-Quads specification, including support for named graphs (contexts). - */ public class NQuadsFormat implements FormatSerializer { /** @@ -27,13 +22,14 @@ public class NQuadsFormat implements FormatSerializer { private final FormatConfig config; /** - * Constructs a new {@code NQuadsFormat} instance with the specified model and default configuration. + * Constructs a new {@code NQuadsFormat} instance with the specified model and default N-Quads configuration. + * The default configuration is obtained from {@link FormatConfig#nquadsConfig()}. * * @param model the {@link Model} to be serialized. Must not be null. * @throws NullPointerException if the provided model is null. */ public NQuadsFormat(Model model) { - this(model, new FormatConfig.Builder().build()); + this(model, FormatConfig.nquadsConfig()); } /** @@ -71,8 +67,9 @@ public void write(Writer writer) throws SerializationException { /** * Writes a single {@link Statement} (quad) to the writer in N-Quads format. - * The statement is written as "$subject $predicate $object $context ." if a context is present, - * or "$subject $predicate $object ." if no context is present (default graph). + * The statement is written as "$subject $predicate $object $context ." if a context is present + * and {@code config.includeContext()} is true. + * If no context is present or {@code config.includeContext()} is false, it's written as "$subject $predicate $object .". * * @param writer the {@link Writer} to which the statement will be written. * @param stmt the {@link Statement} to write. @@ -86,25 +83,39 @@ private void writeStatement(Writer writer, Statement stmt) throws IOException { writeValue(writer, stmt.getObject()); Resource context = stmt.getContext(); - if (context != null) { + if (context != null && config.includeContext()) { writer.write(SerializationConstants.SPACE); writeValue(writer, context); + } else if (context != null && logger.isWarnEnabled()) { + logger.warn("Context '{}' will be ignored for statement: {} because includeContext is false in configuration.", + context.stringValue(), stmt); } - writer.write(SerializationConstants.SPACE_POINT); + if (config.trailingDot()) { + writer.write(SerializationConstants.SPACE); + writer.write(SerializationConstants.POINT); + } + + writer.write(config.getLineEnding()); } /** * Writes a single {@link Value} to the writer. - * Handles literals, blank nodes, and IRIs. + * Handles literals, blank nodes, and IRIs, applying validation based on configuration. * * @param writer the {@link Writer} to which the value will be written. * @param value the {@link Value} to write. * @throws IOException if an I/O error occurs. - * @throws IllegalArgumentException if the provided value is null or an unsupported type. + * @throws IllegalArgumentException if the provided value is null or an unsupported type, especially in strict mode. */ private void writeValue(Writer writer, Value value) throws IOException { - validateValue(value); + if (config.isStrictMode()) { + validateValue(value); + } else if (value == null) { + logger.warn("Encountered a null value during N-Quads serialization. This might lead to invalid output."); + throw new IllegalArgumentException("Value cannot be null for N-Quads serialization."); + } + if (value.isLiteral()) { writeLiteral(writer, (Literal) value); @@ -123,7 +134,8 @@ private void writeValue(Writer writer, Value value) throws IOException { /** * Writes a {@link Literal} to the writer in N-Quads format. - * Handles plain literals, language-tagged literals, and typed literals. + * Handles plain literals, language-tagged literals, and typed literals, + * applying escaping and datatype/language tag rules based on configuration. * * @param writer the {@link Writer} to which the literal will be written. * @param literal the {@link Literal} to write. @@ -134,35 +146,40 @@ private void writeLiteral(Writer writer, Literal literal) throws IOException { writer.write(escapeLiteral(literal.stringValue())); writer.write(SerializationConstants.QUOTE); - // Gestion du langage literal.getLanguage().ifPresent(lang -> { try { writer.write(SerializationConstants.AT_SIGN + lang); } catch (IOException e) { - throw new UncheckedIOException("Error writing language tag", e); + throw new UncheckedIOException("Error writing language tag to stream", e); } }); - if (!literal.getLanguage().isPresent()) { - IRI datatype = literal.getDatatype(); - if (datatype != null && !datatype.stringValue().equals(SerializationConstants.XSD_STRING)) { - writer.write(SerializationConstants.DATATYPE_SEPARATOR); - writeIRI(writer, datatype); - } + IRI datatype = literal.getDatatype(); + if (!literal.getLanguage().isPresent() && datatype != null && + (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || + (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL && !datatype.stringValue().equals(SerializationConstants.XSD_STRING)))) { + writer.write(SerializationConstants.DATATYPE_SEPARATOR); + writeIRI(writer, datatype); } } /** * Writes an {@link IRI} to the writer. * The IRI's string representation must be enclosed in angle brackets for N-Quads. + * Applies URI validation and Unicode escaping based on configuration. * * @param writer the {@link Writer} to which the IRI will be written. * @param iri the {@link IRI} to write. - * @throws IOException if an I/O error occurs. + * @throws IOException if an I/O error occurs. + * @throws IllegalArgumentException if the IRI is invalid (e.g., contains spaces) and strict mode/URI validation is enabled. */ private void writeIRI(Writer writer, IRI iri) throws IOException { + if (config.isStrictMode() && config.validateURIs()) { + validateIRI(iri); + } + writer.write(SerializationConstants.LT); - writer.write(escapeIRI(iri.stringValue())); + writer.write(escapeNQuadsIRI(iri.stringValue())); writer.write(SerializationConstants.GT); } @@ -175,39 +192,48 @@ private void writeIRI(Writer writer, IRI iri) throws IOException { * @throws IOException if an I/O error occurs. */ private void writeBlankNode(Writer writer, Resource blankNode) throws IOException { - writer.write(config.getBlankNodePrefix()); + writer.write(SerializationConstants.BNODE_PREFIX); writer.write(blankNode.stringValue()); } /** - * Validates and potentially escapes an IRI string. + * Validates and potentially escapes an IRI string for N-Quads. * Throws an {@link IllegalArgumentException} if the IRI contains characters - * that are not allowed in N-Quads unescaped form (like spaces, quotes, angle brackets). + * that are not allowed in N-Quads unescaped form (like spaces, quotes, angle brackets) + * when strict mode and URI validation are enabled. + * Applies Unicode escaping if {@code config.escapeUnicode()} is true. * * @param iri The string value of the IRI to validate and escape. * @return The validated and potentially escaped IRI string. - * @throws IllegalArgumentException if the IRI string is invalid. + * @throws IllegalArgumentException if the IRI string is invalid according to rules. */ - private String escapeIRI(String iri) { + private String escapeNQuadsIRI(String iri) { + Objects.requireNonNull(iri, "IRI string cannot be null"); - if (iri.contains(SerializationConstants.SPACE) || iri.contains(SerializationConstants.QUOTE) || - iri.contains(SerializationConstants.LT) || iri.contains(SerializationConstants.GT)) { - throw new IllegalArgumentException("Invalid IRI: contains illegal characters for N-Quads unescaped form: " + iri); + if (config.isStrictMode() && config.validateURIs() && + (iri.contains(SerializationConstants.SPACE) || + iri.contains(SerializationConstants.QUOTE) || + iri.contains(SerializationConstants.LT) || + iri.contains(SerializationConstants.GT))) { + throw new IllegalArgumentException( + "Invalid IRI for N-Quads (contains illegal characters inside '<>'): " + iri); } - return iri; + + return config.escapeUnicode() ? escapeUnicodeString(iri) : iri; } /** * Escape special characters in N-Quads string literals. * Handles backslash, double quote, and common control characters. - * Unicode escape sequences are used for unprintable characters. + * Unicode escape sequences are used for unprintable characters if `config.escapeUnicode()` is true. * * @param value The string value of the literal to escape. * @return The escaped string suitable for N-Quads literal. */ private String escapeLiteral(String value) { StringBuilder sb = new StringBuilder(); - for (int i = 0; i < value.length(); i++) { + int len = value.length(); // Cache length for invariant stop condition + for (int i = 0; i < len; i++) { char c = value.charAt(i); switch (c) { case '\n': @@ -232,26 +258,86 @@ private String escapeLiteral(String value) { sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.BACK_SLASH); break; default: - if (c <= 0x1F || c == 0x7F) { - sb.append(String.format("\\u%04X", (int) c)); - } else { - sb.append(c); - } + i += appendDefaultCharOrUnicodeEscape(sb, c, value, i, config); + break; } } return sb.toString(); } + /** + * Helper method to append a character to StringBuilder, applying unicode escaping based on config + * and handling supplementary characters. Returns the additional increment for the loop index. + * + * @param sb The StringBuilder to append to. + * @param c The current character to process. + * @param value The original string (needed for codePointAt for supplementary characters). + * @param currentIndex The current index in the original string. + * @param config The FormatConfig to check for unicode escaping preference. + * @return The additional increment to the loop index (0 or 1 for supplementary characters). + */ + private int appendDefaultCharOrUnicodeEscape(StringBuilder sb, char c, String value, int currentIndex, FormatConfig config) { + if (config.escapeUnicode()) { + if (c <= 0x1F || c == 0x7F) { + sb.append(String.format("\\u%04X", (int) c)); + } else if (Character.isHighSurrogate(c)) { + if (currentIndex + 1 < value.length() && Character.isLowSurrogate(value.charAt(currentIndex + 1))) { + int codePoint = value.codePointAt(currentIndex); + sb.append(String.format("\\U%08X", codePoint)); + return 1; + } else { + sb.append(c); + } + } else { + sb.append(c); + } + } else { + sb.append(c); + } + return 0; + } + + /** + * Escapes non-ASCII and control characters into Unicode escape sequences. + * This is a helper for `escapeNQuadsIRI` and `escapeLiteral` + * if `escapeUnicode` is true in config. + * + * @param value The string to escape. + * @return The string with Unicode characters escaped. + */ + private String escapeUnicodeString(String value) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < value.length(); i++) { + char c = value.charAt(i); + if (c <= 0x1F || c == 0x7F || (c >= 0x80 && c <= 0xFFFF)) { + sb.append(String.format("\\u%04X", (int) c)); + } else if (Character.isHighSurrogate(c)) { + int codePoint = value.codePointAt(i); + if (Character.isValidCodePoint(codePoint)) { + sb.append(String.format("\\U%08X", codePoint)); + i++; + } else { + sb.append(c); + } + } else { + sb.append(c); + } + } + return sb.toString(); + } + + /** * Validates RDF values before serialization to ensure they conform to N-Quads rules. + * Only called if {@code config.isStrictMode()} is enabled. * * @param value The {@link Value} to validate. - * @throws IllegalArgumentException if the value is null or invalid. + * @throws IllegalArgumentException if the value is null or invalid based on N-Quads rules. */ private void validateValue(Value value) { if (value == null) { - logger.warn("Encountered a null value where a non-null value was expected for N-Quads serialization."); - throw new IllegalArgumentException("Value cannot be null in N-Quads format"); + logger.warn("Encountered a null value where a non-null value was expected for N-Quads serialization. This will result in an IllegalArgumentException if strict mode is enabled."); + throw new IllegalArgumentException("Value cannot be null in N-Quads format when strictMode is enabled."); } if (value.isLiteral()) { @@ -264,6 +350,7 @@ private void validateValue(Value value) { /** * Validates a {@link Literal} to ensure it conforms to RDF/N-Quads rules. * Specifically checks for consistency between language tags and the rdf:langString datatype. + * Only called if {@code config.isStrictMode()} is enabled. * * @param literal The {@link Literal} to validate. * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, @@ -272,15 +359,12 @@ private void validateValue(Value value) { private void validateLiteral(Literal literal) { IRI datatype = literal.getDatatype(); - if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { throw new IllegalArgumentException( "Literal with language tag must use rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); } } else { - if (datatype != null && datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { throw new IllegalArgumentException( "rdf:langString literal must have a language tag."); @@ -291,14 +375,19 @@ private void validateLiteral(Literal literal) { /** * Validates an {@link IRI} to ensure it conforms to N-Quads rules. * Checks if the IRI string contains characters that are not allowed in N-Quads - * unescaped form, such as spaces. + * unescaped form, such as spaces, quotes, or angle brackets. + * Only called if {@code config.isStrictMode()} and {@code config.validateURIs()} are enabled. * * @param iri The {@link IRI} to validate. - * @throws IllegalArgumentException if the IRI contains spaces or is otherwise invalid. + * @throws IllegalArgumentException if the IRI contains invalid characters. */ private void validateIRI(IRI iri) { - if (iri.stringValue().contains(SerializationConstants.SPACE)) { - throw new IllegalArgumentException("IRI contains spaces, which is not allowed in N-Quads unescaped form: " + iri.stringValue()); + String iriString = iri.stringValue(); + if (iriString.contains(SerializationConstants.SPACE) || + iriString.contains(SerializationConstants.QUOTE) || + iriString.contains(SerializationConstants.LT) || + iriString.contains(SerializationConstants.GT)) { + throw new IllegalArgumentException("IRI contains illegal characters (space, quote, angle brackets) for N-Quads unescaped form: " + iriString); } } } \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java index fc20c0e92..b94c8a38e 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java @@ -33,7 +33,7 @@ public class NTriplesFormat implements FormatSerializer { * @throws NullPointerException if the provided model is null. */ public NTriplesFormat(Model model) { - this(model, new FormatConfig.Builder().build()); + this(model, FormatConfig.ntriplesConfig()); } /** @@ -92,7 +92,12 @@ private void writeStatement(Writer writer, Statement stmt) throws IOException { } - writer.write(SerializationConstants.SPACE_POINT); + if (config.trailingDot()) { + writer.write(SerializationConstants.SPACE); + writer.write(SerializationConstants.POINT); + } + + writer.write(config.getLineEnding()); } /** @@ -124,7 +129,7 @@ private void writeValue(Writer writer, Value value) throws IOException { /** * Writes a {@link Literal} to the writer in N-Triples format. - * Handles plain literals, language-tagged literals, and typed literals. + * Applies escaping and datatype/language tag rules based on configuration. * * @param writer the {@link Writer} to which the literal will be written. * @param literal the {@link Literal} to write. @@ -139,68 +144,80 @@ private void writeLiteral(Writer writer, Literal literal) throws IOException { try { writer.write(SerializationConstants.AT_SIGN + lang); } catch (IOException e) { - throw new UncheckedIOException("Error writing language tag to stream", e); } }); - if (!literal.getLanguage().isPresent()) { - IRI datatype = literal.getDatatype(); - if (datatype != null && !datatype.stringValue().equals(SerializationConstants.XSD_STRING)) { - writer.write(SerializationConstants.DATATYPE_SEPARATOR); - writeIRI(writer, datatype); - } + IRI datatype = literal.getDatatype(); + if (!literal.getLanguage().isPresent() && datatype != null && + (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || + (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL && !datatype.stringValue().equals(SerializationConstants.XSD_STRING)))) { + writer.write(SerializationConstants.DATATYPE_SEPARATOR); + writeIRI(writer, datatype); } } /** * Writes an {@link IRI} to the writer. * The IRI's string representation must be enclosed in angle brackets for N-Triples. + * Applies URI validation based on configuration. * * @param writer the {@link Writer} to which the IRI will be written. * @param iri the {@link IRI} to write. - * @throws IOException if an I/O error occurs. + * @throws IOException if an I/O error occurs. + * @throws IllegalArgumentException if the IRI is invalid (e.g., contains spaces) and strict mode/URI validation is enabled. */ private void writeIRI(Writer writer, IRI iri) throws IOException { + if (config.isStrictMode() && config.validateURIs()) { + validateIRI(iri); + } writer.write(SerializationConstants.LT); - writer.write(escapeIRI(iri.stringValue())); + writer.write(escapeNtriplesIRI(iri.stringValue())); writer.write(SerializationConstants.GT); } /** * Writes a blank node to the writer. * Blank nodes are prefixed with "_:", and the identifier is appended. + * Uses the blank node prefix from configuration. * * @param writer the {@link Writer} to which the blank node will be written. * @param blankNode the {@link Resource} representing the blank node. * @throws IOException if an I/O error occurs. */ private void writeBlankNode(Writer writer, Resource blankNode) throws IOException { - writer.write(config.getBlankNodePrefix()); + writer.write(SerializationConstants.BNODE_PREFIX); writer.write(blankNode.stringValue()); } /** - * Validates and potentially escapes an IRI string. + * Validates and potentially escapes an IRI string for N-Triples. * Throws an {@link IllegalArgumentException} if the IRI contains characters * that are not allowed in N-Triples unescaped form (like spaces, quotes, angle brackets). + * This method is called if strictMode and validateURIs are enabled. * * @param iri The string value of the IRI to validate and escape. * @return The validated and potentially escaped IRI string. * @throws IllegalArgumentException if the IRI string is invalid. */ - private String escapeIRI(String iri) { + private String escapeNtriplesIRI(String iri) { + + if (iri.contains(SerializationConstants.SPACE) || + iri.contains(SerializationConstants.QUOTE) || + iri.contains(SerializationConstants.LT) || + iri.contains(SerializationConstants.GT)) { - if (iri.contains(SerializationConstants.SPACE) || iri.contains(SerializationConstants.QUOTE) || iri.contains(SerializationConstants.LT) || iri.contains(SerializationConstants.GT)) { - throw new IllegalArgumentException("Invalid IRI: contains illegal characters for N-Triples unescaped form: " + iri); + throw new IllegalArgumentException("Invalid IRI for N-Triples (contains illegal characters inside '<>'): " + iri); } - return iri; + + return config.escapeUnicode() ? escapeUnicodeString(iri) : iri; } + /** * Escape special characters in N-Triples string literals. * Handles backslash, double quote, and common control characters. - * Unicode escape sequences are used for unprintable characters. + * Unicode escape sequences are used for unprintable characters if `escapeUnicode` is true. * * @param value The string value of the literal to escape. * @return The escaped string suitable for N-Triples literal. @@ -232,8 +249,12 @@ private String escapeLiteral(String value) { sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.BACK_SLASH); break; default: - if (c <= 0x1F || c == 0x7F) { - sb.append(String.format("\\u%04X", (int) c)); + if (config.escapeUnicode()) { + if (c <= 0x1F || c == 0x7F) { + sb.append(String.format("\\u%04X", (int) c)); + } else { + sb.append(c); + } } else { sb.append(c); } @@ -242,16 +263,47 @@ private String escapeLiteral(String value) { return sb.toString(); } + /** + * Escapes non-ASCII and control characters into Unicode escape sequences. + * This is a helper for `escapeNtriplesIRI` and potentially `escapeLiteral` + * if `escapeUnicode` is true in config. + * + * @param value The string to escape. + * @return The string with Unicode characters escaped. + */ + private String escapeUnicodeString(String value) { + StringBuilder sb = new StringBuilder(); + int len = value.length(); // Cache length for invariant stop condition + for (int i = 0; i < len; i++) { + char c = value.charAt(i); + if (c <= 0x1F || c == 0x7F || (c >= 0x80 && c <= 0xFFFF)) { // Basic Multilingual Plane characters and control characters + sb.append(String.format("\\u%04X", (int) c)); + } else if (Character.isHighSurrogate(c)) { // Supplementary characters + int codePoint = value.codePointAt(i); + if (Character.isValidCodePoint(codePoint)) { + sb.append(String.format("\\U%08X", codePoint)); + i++; // Skip the low surrogate char + } else { + sb.append(c); // Append invalid surrogate char directly + } + } else { + sb.append(c); + } + } + return sb.toString(); + } + /** * Validates RDF values before serialization to ensure they conform to N-Triples rules. + * Only called if strictMode is enabled. * * @param value The {@link Value} to validate. - * @throws IllegalArgumentException if the value is null or invalid. + * @throws IllegalArgumentException if the value is null or invalid based on N-Triples rules. */ private void validateValue(Value value) { if (value == null) { - logger.warn("Encountered a null value where a non-null value was expected for N-Triples serialization."); - throw new IllegalArgumentException("Value cannot be null in N-Triples format"); + logger.warn("Encountered a null value where a non-null value was expected for N-Triples serialization. This will result in an IllegalArgumentException if strict mode is enabled."); + throw new IllegalArgumentException("Value cannot be null in N-Triples format when strictMode is enabled."); } if (value.isLiteral()) { @@ -259,12 +311,12 @@ private void validateValue(Value value) { } else if (value.isIRI()) { validateIRI((IRI) value); } - } /** * Validates a {@link Literal} to ensure it conforms to RDF/N-Triples rules. * Specifically checks for consistency between language tags and the rdf:langString datatype. + * Only called if strictMode is enabled. * * @param literal The {@link Literal} to validate. * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, @@ -273,15 +325,12 @@ private void validateValue(Value value) { private void validateLiteral(Literal literal) { IRI datatype = literal.getDatatype(); - if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { throw new IllegalArgumentException( "Literal with language tag must use rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); } } else { - if (datatype != null && datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { throw new IllegalArgumentException( "rdf:langString literal must have a language tag."); @@ -292,14 +341,19 @@ private void validateLiteral(Literal literal) { /** * Validates an {@link IRI} to ensure it conforms to N-Triples rules. * Checks if the IRI string contains characters that are not allowed in N-Triples - * unescaped form, such as spaces. + * unescaped form, such as spaces, quotes, or angle brackets. + * Only called if strictMode and validateURIs are enabled. * * @param iri The {@link IRI} to validate. - * @throws IllegalArgumentException if the IRI contains spaces or is otherwise invalid. + * @throws IllegalArgumentException if the IRI contains invalid characters. */ private void validateIRI(IRI iri) { - if (iri.stringValue().contains(SerializationConstants.SPACE)) { - throw new IllegalArgumentException("IRI contains spaces, which is not allowed in N-Triples unescaped form: " + iri.stringValue()); + String iriString = iri.stringValue(); + if (iriString.contains(SerializationConstants.SPACE) || + iriString.contains(SerializationConstants.QUOTE) || + iriString.contains(SerializationConstants.LT) || + iriString.contains(SerializationConstants.GT)) { + throw new IllegalArgumentException("IRI contains illegal characters (space, quote, angle brackets) for N-Triples unescaped form: " + iriString); } } } \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/PrefixOrderingEnum.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/PrefixOrderingEnum.java new file mode 100644 index 000000000..e69d0f075 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/PrefixOrderingEnum.java @@ -0,0 +1,19 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +/** + * Defines the ordering policy for prefix declarations. + */ +public enum PrefixOrderingEnum { + /** + * Prefixes are sorted alphabetically by their namespace URI. + */ + ALPHABETICAL, + /** + * Prefixes are declared in the order they are first encountered/used in the graph. + */ + USAGE_ORDER, + /** + * A custom order defined by the user through the customPrefixes map. + */ + CUSTOM +} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java new file mode 100644 index 000000000..0a42b6b41 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +public class TurtleFormat { +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java b/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java index 54dfdca54..e7605a6cd 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java @@ -72,8 +72,28 @@ public class SerializationConstants { // Nouvelle constante pour le séparateur de datatype public static final String DATATYPE_SEPARATOR = "^^"; + // Used by NAMED BlankNodeStyle + public static final String DEFAULT_BLANK_NODE_PREFIX = "_:"; + // Separator for predicate-object lists in Turtle/TriG + public static final String SEMICOLON = ";"; + // Separator for object lists in Turtle/TriG + public static final String COMMA = ","; + // 2 spaces + public static final String DEFAULT_INDENTATION = " "; + public static final String DEFAULT_LINE_ENDING = "\n"; + + // --- Keywords and Shortcuts --- + public static final String PREFIX_KEYWORD = "@prefix"; // Turtle/TriG prefix keyword + + public static final String RDF_TYPE_SHORTCUT = "a"; // Shortcut for rdf:type in Turtle/TriG + + public static final String COLON = ":"; + + public static final String RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"; + + public static final String RDF_TYPE = RDF_NS + "type"; /** * Private constructor to prevent instantiation of this utility class. * All members are static. diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java index c1ee05f95..cb2b94616 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java @@ -1,56 +1,147 @@ package fr.inria.corese.core.next.impl.common.serialization; +import fr.inria.corese.core.next.impl.common.util.SerializationConstants; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.*; class FormatConfigTest { - @Test - @DisplayName("Builder should create FormatConfig with default blank node prefix") - void builderShouldCreateWithDefaultBlankNodePrefix() { - - FormatConfig config = new FormatConfig.Builder().build(); + @DisplayName("ntriplesConfig() should return correct default config for N-Triples") + void ntriplesConfigReturnsCorrectConfig() { + FormatConfig config = FormatConfig.ntriplesConfig(); - - assertNotNull(config, "FormatConfig should not be null"); - assertEquals("_:", config.getBlankNodePrefix(), "Default blank node prefix should be '_:'"); + assertFalse(config.usePrefixes()); + assertFalse(config.autoDeclarePrefixes()); + assertFalse(config.useCompactTriples()); + assertFalse(config.useRdfTypeShortcut()); + assertFalse(config.useCollections()); + assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle()); + assertFalse(config.prettyPrint()); + assertEquals("", config.getIndent()); + assertEquals(0, config.getMaxLineLength()); + assertFalse(config.groupBySubject()); + assertFalse(config.sortSubjects()); + assertFalse(config.sortPredicates()); + assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy()); + assertTrue(config.escapeUnicode()); + assertTrue(config.trailingDot()); + assertNull(config.getBaseIRI()); + assertTrue(config.stableBlankNodeIds()); + assertTrue(config.isStrictMode()); + assertTrue(config.validateURIs()); + assertFalse(config.includeContext()); + assertEquals(SerializationConstants.DEFAULT_LINE_ENDING, config.getLineEnding()); + assertTrue(config.getCustomPrefixes().isEmpty()); } @Test - @DisplayName("Builder should create FormatConfig with custom blank node prefix") - void builderShouldCreateWithCustomBlankNodePrefix() { - String customPrefix = "genid-"; - - - FormatConfig config = new FormatConfig.Builder() - .blankNodePrefix(customPrefix) - .build(); + @DisplayName("nquadsConfig() should return correct default config for N-Quads") + void nquadsConfigReturnsCorrectConfig() { + FormatConfig config = FormatConfig.nquadsConfig(); - - assertNotNull(config, "FormatConfig should not be null"); - assertEquals(customPrefix, config.getBlankNodePrefix(), "Blank node prefix should match the custom value"); + assertFalse(config.usePrefixes()); + assertFalse(config.autoDeclarePrefixes()); + assertFalse(config.useCompactTriples()); + assertFalse(config.useRdfTypeShortcut()); + assertFalse(config.useCollections()); + assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle()); + assertFalse(config.prettyPrint()); + assertEquals("", config.getIndent()); + assertEquals(0, config.getMaxLineLength()); + assertFalse(config.groupBySubject()); + assertFalse(config.sortSubjects()); + assertFalse(config.sortPredicates()); + assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy()); + assertTrue(config.escapeUnicode()); + assertTrue(config.trailingDot()); + assertNull(config.getBaseIRI()); + assertTrue(config.stableBlankNodeIds()); + assertTrue(config.isStrictMode()); + assertTrue(config.validateURIs()); + assertTrue(config.includeContext()); + assertEquals(SerializationConstants.DEFAULT_LINE_ENDING, config.getLineEnding()); + assertTrue(config.getCustomPrefixes().isEmpty()); } + @Test - @DisplayName("blankNodePrefix method in Builder should throw NullPointerException for null prefix") - void blankNodePrefixShouldThrowForNull() { + @DisplayName("FormatConfig constructor should be private and only accessible via builder") + void constructorIsPrivateAndAccessibleViaBuilder() { + FormatConfig config = new FormatConfig.Builder().build(); + assertNotNull(config); + } + + @Test + @DisplayName("blankNodeStyle method in Builder should throw NullPointerException for null style") + void blankNodeStyleShouldThrowForNull() { FormatConfig.Builder builder = new FormatConfig.Builder(); + assertThrows(NullPointerException.class, () -> builder.blankNodeStyle(null), + "Setting a null blankNodeStyle should throw NullPointerException"); + } + @Test + @DisplayName("indent method in Builder should throw NullPointerException for null indent") + void indentShouldThrowForNull() { + FormatConfig.Builder builder = new FormatConfig.Builder(); + assertThrows(NullPointerException.class, () -> builder.indent(null), + "Setting a null indent should throw NullPointerException"); + } - assertThrows(NullPointerException.class, () -> builder.blankNodePrefix(null), - "Setting a null blank node prefix should throw NullPointerException"); + @Test + @DisplayName("lineEnding method in Builder should throw NullPointerException for null lineEnding") + void lineEndingShouldThrowForNull() { + FormatConfig.Builder builder = new FormatConfig.Builder(); + assertThrows(NullPointerException.class, () -> builder.lineEnding(null), + "Setting a null lineEnding should throw NullPointerException"); } @Test - @DisplayName("FormatConfig constructor should be private and only accessible via builder") - void constructorIsPrivateAndAccessibleViaBuilder() { + @DisplayName("prefixOrdering method in Builder should throw NullPointerException for null prefixOrdering") + void prefixOrderingShouldThrowForNull() { + FormatConfig.Builder builder = new FormatConfig.Builder(); + assertThrows(NullPointerException.class, () -> builder.prefixOrdering(null), + "Setting a null prefixOrdering should throw NullPointerException"); + } + @Test + @DisplayName("Builder should create FormatConfig with all default values") + void builderShouldCreateWithAllDefaults() { FormatConfig config = new FormatConfig.Builder().build(); - assertNotNull(config); + + assertNotNull(config, "FormatConfig should not be null"); + + // --- Syntax Sugar Defaults --- + assertTrue(config.usePrefixes(), "Default usePrefixes should be true"); + assertTrue(config.autoDeclarePrefixes(), "Default autoDeclarePrefixes should be true"); + assertEquals(PrefixOrderingEnum.ALPHABETICAL, config.getPrefixOrdering(), "Default prefixOrdering should be ALPHABETICAL"); + assertTrue(config.getCustomPrefixes().isEmpty(), "Default customPrefixes map should be empty"); + assertTrue(config.useCompactTriples(), "Default useCompactTriples should be true"); + assertTrue(config.useRdfTypeShortcut(), "Default useRdfTypeShortcut should be true"); + assertFalse(config.useCollections(), "Default useCollections should be false"); + assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle(), "Default blankNodeStyle should be NAMED"); + + // --- Pretty-Printing Defaults --- + assertTrue(config.prettyPrint(), "Default prettyPrint should be true"); + assertEquals(SerializationConstants.DEFAULT_INDENTATION, config.getIndent(), "Default indent should be " + SerializationConstants.DEFAULT_INDENTATION); + assertEquals(80, config.getMaxLineLength(), "Default maxLineLength should be 80"); + assertTrue(config.groupBySubject(), "Default groupBySubject should be true"); + assertFalse(config.sortSubjects(), "Default sortSubjects should be false"); + assertFalse(config.sortPredicates(), "Default sortPredicates should be false"); + + // --- Technical Output Defaults --- + assertEquals(LiteralDatatypePolicyEnum.MINIMAL, config.getLiteralDatatypePolicy(), "Default literalDatatypePolicy should be MINIMAL"); + assertFalse(config.escapeUnicode(), "Default escapeUnicode should be false"); + assertTrue(config.trailingDot(), "Default trailingDot should be true"); + assertNull(config.getBaseIRI(), "Default baseIRI should be null"); + assertFalse(config.stableBlankNodeIds(), "Default stableBlankNodeIds should be false"); + + // --- Validation & Context Defaults --- + assertTrue(config.isStrictMode(), "Default strictMode should be true"); + assertTrue(config.validateURIs(), "Default validateURIs should be true"); + assertFalse(config.includeContext(), "Default includeContext should be false"); + assertEquals(SerializationConstants.DEFAULT_LINE_ENDING, config.getLineEnding(), "Default lineEnding should be " + SerializationConstants.DEFAULT_LINE_ENDING); } } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java index 5d1a3636d..b6c2f2d67 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java @@ -29,8 +29,6 @@ class NQuadsFormatTest { private IRI mockExName; private IRI mockExKnows; - private IRI mockExContext; - private final String lexJohn = "John Doe"; @@ -44,7 +42,7 @@ class NQuadsFormatTest { @BeforeEach void setUp() { model = mock(Model.class); - config = new FormatConfig.Builder().build(); + config = FormatConfig.nquadsConfig(); nQuadsFormat = new NQuadsFormat(model, config); mockExPerson = createIRI("http://example.org/Person"); @@ -58,7 +56,6 @@ void setUp() { mockBNode1 = createBlankNode("b1"); mockBNode2 = createBlankNode("b2"); - mockExContext = createIRI("http://example.org/myGraph"); } @Test @@ -96,30 +93,6 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { assertEquals(expected, writer.toString()); } - @Test - @DisplayName("Write should serialize statement with context (named graph)") - void writeShouldSerializeStatementWithContext() throws SerializationException { - Statement stmt = createStatement( - mockExPerson, - mockExName, - mockLiteralJohn, - mockExContext - ); - when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); - - StringWriter writer = new StringWriter(); - nQuadsFormat.write(writer); - - - String expected = String.format("<%s> <%s> \"%s\" <%s>", - mockExPerson.stringValue(), - mockExName.stringValue(), - escapeNQuadsString(lexJohn), - mockExContext.stringValue()) + " .\n"; - - assertEquals(expected, writer.toString()); - } - @Test @DisplayName("Write should handle blank nodes with default prefix") void writeShouldHandleBlankNodes() throws SerializationException { @@ -165,31 +138,6 @@ void writeShouldHandleBlankNodesInContext() throws SerializationException { assertEquals(expected, writer.toString()); } - @Test - @DisplayName("Write should handle blank nodes with custom prefix") - void writeShouldHandleBlankNodesWithCustomPrefix() throws SerializationException { - FormatConfig customConfig = new FormatConfig.Builder().blankNodePrefix("genid-").build(); - NQuadsFormat customSerializer = new NQuadsFormat(model, customConfig); - - Statement stmt = createStatement( - mockBNode1, - mockExKnows, - mockBNode2, - createBlankNode("b3") - ); - when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); - - StringWriter writer = new StringWriter(); - customSerializer.write(writer); - - String expected = String.format("genid-%s <%s> genid-%s genid-%s", - mockBNode1.stringValue(), - mockExKnows.stringValue(), - mockBNode2.stringValue(), - createBlankNode("b3").stringValue()) + " .\n"; - - assertEquals(expected, writer.toString()); - } @Test @DisplayName("Write should throw SerializationException on IO error") @@ -208,7 +156,7 @@ void writeShouldThrowOnIOException() throws IOException { } @Test - @DisplayName("Write should throw SerializationException on null subject value from Statement") + @DisplayName("Write should throw SerializationException on null subject value from Statement in strict mode") void writeShouldThrowOnNullSubjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(null); @@ -218,11 +166,12 @@ void writeShouldThrowOnNullSubjectValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); + assertEquals("Invalid data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: NQuads]", thrown.getMessage()); } @Test - @DisplayName("Write should throw SerializationException on null predicate value from Statement") + @DisplayName("Write should throw SerializationException on null predicate value from Statement in strict mode") void writeShouldThrowOnNullPredicateValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -232,11 +181,12 @@ void writeShouldThrowOnNullPredicateValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); + assertEquals("Invalid data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: NQuads]", thrown.getMessage()); } @Test - @DisplayName("Write should throw SerializationException on null object value from Statement") + @DisplayName("Write should throw SerializationException on null object value from Statement in strict mode") void writeShouldThrowOnNullObjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -246,17 +196,19 @@ void writeShouldThrowOnNullObjectValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); + assertEquals("Invalid data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: NQuads]", thrown.getMessage()); } @Test @DisplayName("Write should correctly handle null context (default graph)") void writeShouldHandleNullContext() throws SerializationException { + // Default config (nquadsConfig) has includeContext = true, but this statement has null context. Statement stmt = createStatement( mockExPerson, mockExName, mockLiteralJohn, - null + null // Explicitly null context ); when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); @@ -283,9 +235,8 @@ void writeShouldHandleNullContext() throws SerializationException { "literal with \u0001 (SOH)", "literal with \u007F (DEL)" }) - @DisplayName("Write should handle various literal values with proper escaping") + @DisplayName("Write should handle various literal values with proper escaping (including Unicode)") void writeShouldHandleVariousLiterals(String literalValue) throws SerializationException { - Literal literalMock = createLiteral(literalValue, null, null); Statement stmt = createStatement( @@ -318,7 +269,8 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); Writer writer = new StringWriter(); - NQuadsFormat serializer = new NQuadsFormat(currentTestModel); + + NQuadsFormat serializer = new NQuadsFormat(currentTestModel, FormatConfig.nquadsConfig()); serializer.write(writer); String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", @@ -350,7 +302,6 @@ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTa if (langTag != null && !langTag.isEmpty()) { when(literal.getLanguage()).thenReturn(Optional.of(langTag)); - when(literal.getDatatype()).thenReturn(RDF.langString.getIRI()); } else { when(literal.getLanguage()).thenReturn(Optional.empty()); @@ -362,7 +313,8 @@ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTa /** * Escapes a string according to N-Quads literal escaping rules. * This helper is used in tests to construct the *expected* output strings. - * It mimics the behavior of NQuadsFormat's internal escapeLiteral method. + * It mimics the behavior of NQuadsFormat's internal escapeLiteral method, + * considering that `nquadsConfig().escapeUnicode()` is `true`. * * @param s The string to escape. * @return The escaped string. @@ -394,8 +346,18 @@ private String escapeNQuadsString(String s) { sb.append("\\\\"); break; default: - if (c >= '\u0000' && c <= '\u001F' || c == '\u007F') { + if (c <= 0x1F || c == 0x7F) { // Control characters + sb.append(String.format("\\u%04X", (int) c)); + } else if (c >= 0x80 && c <= 0xFFFF) { // Non-ASCII Basic Multilingual Plane characters sb.append(String.format("\\u%04X", (int) c)); + } else if (Character.isHighSurrogate(c)) { // Supplementary characters + int codePoint = s.codePointAt(i); + if (Character.isValidCodePoint(codePoint)) { + sb.append(String.format("\\U%08X", codePoint)); + i++; // Skip the low surrogate char + } else { + sb.append(c); // Append invalid surrogate char directly + } } else { sb.append(c); } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java index e00d89d41..860e61ac3 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java @@ -2,13 +2,10 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; - import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; import java.io.IOException; import java.io.StringWriter; @@ -31,33 +28,28 @@ class NTriplesFormatTest { private IRI mockExKnows; private final String lexJohn = "John Doe"; - private final String hello = "Hello"; private Literal mockLiteralJohn; - - private Literal mockLiteralHelloEn; private Resource mockBNode1; private Resource mockBNode2; @BeforeEach void setUp() { model = mock(Model.class); - config = new FormatConfig.Builder().build(); + + config = FormatConfig.ntriplesConfig(); nTriplesFormat = new NTriplesFormat(model, config); mockExPerson = createIRI("http://example.org/Person"); mockExName = createIRI("http://example.org/name"); - mockExKnows = createIRI("http://example.org/knows"); - mockLiteralJohn = createLiteral(lexJohn, null, null); - - mockLiteralHelloEn = createLiteral(hello, null, "en"); - mockBNode1 = createBlankNode("b1"); mockBNode2 = createBlankNode("b2"); + + mockLiteralJohn = createLiteral(lexJohn, null, null); } @Test @@ -119,7 +111,7 @@ void writeShouldSerializeStatementWithContext() throws SerializationException { } @Test - @DisplayName("Write should handle blank nodes with default prefix") + @DisplayName("Write should handle blank nodes with default N-Triples prefix (_:)") void writeShouldHandleBlankNodes() throws SerializationException { Statement stmt = createStatement( mockBNode1, @@ -139,30 +131,6 @@ void writeShouldHandleBlankNodes() throws SerializationException { assertEquals(expected, writer.toString()); } - @Test - @DisplayName("Write should handle blank nodes with custom prefix") - void writeShouldHandleBlankNodesWithCustomPrefix() throws SerializationException { - FormatConfig customConfig = new FormatConfig.Builder().blankNodePrefix("genid-").build(); - NTriplesFormat customSerializer = new NTriplesFormat(model, customConfig); - - Statement stmt = createStatement( - mockBNode1, - mockExKnows, - mockBNode2 - ); - when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); - - StringWriter writer = new StringWriter(); - customSerializer.write(writer); - - String expected = String.format("genid-%s <%s> genid-%s", - mockBNode1.stringValue(), - mockExKnows.stringValue(), - mockBNode2.stringValue()) + " .\n"; - - assertEquals(expected, writer.toString()); - } - @Test @DisplayName("Write should throw SerializationException on IO error") void writeShouldThrowOnIOException() throws IOException { @@ -181,7 +149,7 @@ void writeShouldThrowOnIOException() throws IOException { } @Test - @DisplayName("Write should throw SerializationException on null subject value from Statement") + @DisplayName("Write should throw SerializationException on null subject value from Statement in strict mode") void writeShouldThrowOnNullSubjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(null); @@ -190,11 +158,13 @@ void writeShouldThrowOnNullSubjectValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); + + assertEquals("Invalid data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); } @Test - @DisplayName("Write should throw SerializationException on null predicate value from Statement") + @DisplayName("Write should throw SerializationException on null predicate value from Statement in strict mode") void writeShouldThrowOnNullPredicateValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -203,104 +173,77 @@ void writeShouldThrowOnNullPredicateValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); + assertEquals("Invalid data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); } @Test - @DisplayName("Write should throw SerializationException on null object value from Statement") + @DisplayName("Write should throw SerializationException on null object value from Statement in strict mode") void writeShouldThrowOnNullObjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); when(stmt.getPredicate()).thenReturn(mockExName); - when(stmt.getObject()).thenReturn(null); + when(stmt.getObject()).thenReturn(null); // L'objet est null when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); + assertEquals("Invalid data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); } - @ParameterizedTest - @ValueSource(strings = { - "simple literal", - "literal with \"quotes\"", - "literal with \\ backslash", - "literal with \n newline", - "literal with \t tab", - "literal with \r carriage return", - "literal with \u0001 (SOH)", - "literal with \u007F (DEL)" - }) - @DisplayName("Write should handle various literal values with proper escaping") - void writeShouldHandleVariousLiterals(String literalValue) throws SerializationException { - Literal literalMock = createLiteral(literalValue, null, null); - Statement stmt = createStatement( - mockExPerson, - mockExName, - literalMock - ); - when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); + @Test + @DisplayName("Should handle literals with language tags correctly") + void shouldHandleLiteralsWithLanguageTags() throws SerializationException { + IRI subject = createIRI("http://example.org/person"); + IRI predicate = createIRI("http://example.org/greeting"); + Literal object = createLiteral("Hello", "en"); // Use the helper that sets rdf:langString - StringWriter writer = new StringWriter(); - nTriplesFormat.write(writer); + Statement stmt = createStatement(subject, predicate, object); - String expectedEscapedLiteral = escapeNTriplesString(literalValue); - String expectedOutput = String.format("<%s> <%s> \"%s\"", - mockExPerson.stringValue(), - mockExName.stringValue(), - expectedEscapedLiteral) + " .\n"; + Model modelMock = mock(Model.class); + when(modelMock.iterator()).thenReturn(new MockStatementIterator(stmt)); - assertEquals(expectedOutput, writer.toString()); - } + FormatConfig testConfig = new FormatConfig.Builder() + .strictMode(true) // Keep strict mode enabled to test validation + .build(); - @Test - @DisplayName("Write should handle multiple statements") - void writeShouldHandleMultipleStatements() throws SerializationException { - Statement stmt1 = createStatement( - mockExPerson, - mockExName, - createLiteral("o1", null, null) - ); - Statement stmt2 = createStatement( - mockBNode1, - mockExKnows, - mockExPerson, - createIRI("http://example.org/ctx") - ); - when(model.iterator()).thenReturn(new MockStatementIterator(stmt1, stmt2)); + NTriplesFormat serializer = new NTriplesFormat(modelMock, testConfig); StringWriter writer = new StringWriter(); - nTriplesFormat.write(writer); + serializer.write(writer); - String expectedOutput = String.format("<%s> <%s> \"%s\"", - mockExPerson.stringValue(), - mockExName.stringValue(), - escapeNTriplesString("o1")) + " .\n" + - String.format("_:%s <%s> <%s>", - mockBNode1.stringValue(), - mockExKnows.stringValue(), - mockExPerson.stringValue()) + " .\n"; + String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", + subject.stringValue(), + predicate.stringValue(), + escapeNTriplesString("Hello"), + "en") + " .\n"; assertEquals(expectedOutput, writer.toString()); } + @Test - @DisplayName("Should handle literals with language tags") - void shouldHandleLiteralsWithLanguageTags() throws SerializationException { - Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/greeting"), mockLiteralHelloEn); + @DisplayName("Should handle literals with custom datatypes") + void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { + IRI customDatatype = createIRI("http://example.org/myDataType"); + Literal customLiteral = createLiteral("123", customDatatype, null); + + Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/value"), customLiteral); Model currentTestModel = mock(Model.class); when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); - Writer writer = new StringWriter(); - NTriplesFormat serializer = new NTriplesFormat(currentTestModel); + NTriplesFormat serializer = new NTriplesFormat(currentTestModel, FormatConfig.ntriplesConfig()); + + StringWriter writer = new StringWriter(); serializer.write(writer); - String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", + String expectedOutput = String.format("<%s> <%s> \"%s\"^^<%s>", mockExPerson.stringValue(), - createIRI("http://example.org/greeting").stringValue(), - escapeNTriplesString(hello), - mockLiteralHelloEn.getLanguage().get()) + " .\n"; + createIRI("http://example.org/value").stringValue(), + escapeNTriplesString("123"), + customDatatype.stringValue()) + " .\n"; assertEquals(expectedOutput, writer.toString()); } @@ -309,7 +252,8 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { /** * Escapes a string according to N-Triples literal escaping rules. * This helper is used in tests to construct the *expected* output strings. - * It mimics the behavior of NTriplesFormat's internal escapeLiteral method. + * It mimics the behavior of NTriplesFormat's internal escapeLiteral method, + * specifically when `escapeUnicode` is true (as per ntriplesConfig() default). * * @param s The string to escape. * @return The escaped string. @@ -341,7 +285,7 @@ private String escapeNTriplesString(String s) { sb.append("\\\\"); break; default: - if (c >= '\u0000' && c <= '\u001F' || c == '\u007F') { + if (c <= 0x1F || c == 0x7F) { sb.append(String.format("\\u%04X", (int) c)); } else { sb.append(c); @@ -391,12 +335,11 @@ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTa if (langTag != null && !langTag.isEmpty()) { when(literal.getLanguage()).thenReturn(Optional.of(langTag)); - - + // When a language tag is present, the datatype should be rdf:langString implicitly or explicitly when(literal.getDatatype()).thenReturn(RDF.langString.getIRI()); } else { when(literal.getLanguage()).thenReturn(Optional.empty()); - when(literal.getDatatype()).thenReturn(dataTypeIRI); + when(literal.getDatatype()).thenReturn(dataTypeIRI); // Can be XSD.STRING.getIRI() or any custom IRI } return literal; } @@ -431,4 +374,14 @@ private IRI createIRI(String uri) { when(iri.stringValue()).thenReturn(uri); return iri; } + + public static Literal createLiteral(String value, String lang) { + Literal mockLiteral = mock(Literal.class); + when(mockLiteral.stringValue()).thenReturn(value); // Removed quotes here + when(mockLiteral.getLanguage()).thenReturn(Optional.of(lang)); + when(mockLiteral.isLiteral()).thenReturn(true); + when(mockLiteral.isResource()).thenReturn(false); + when(mockLiteral.getDatatype()).thenReturn(RDF.langString.getIRI()); + return mockLiteral; + } } \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java new file mode 100644 index 000000000..e87078991 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +public class TurtleFormatTest { +} From f7265177a0851c0a4957e9dbf1f2f83f159f78b9 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Wed, 18 Jun 2025 14:45:11 +0200 Subject: [PATCH 02/27] Create turtles Serializer --- .../common/serialization/FormatConfig.java | 60 +- .../common/serialization/TurtleFormat.java | 994 +++++++++++++++++- .../common/util/SerializationConstants.java | 138 +-- 3 files changed, 1096 insertions(+), 96 deletions(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java index 80d80541e..c5e9bd650 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java @@ -141,6 +141,9 @@ public class FormatConfig { */ private final String lineEnding; + + private final boolean useMultilineLiterals; + /** * Private constructor to enforce usage of the Builder. * @@ -178,8 +181,14 @@ private FormatConfig(Builder builder) { this.validateURIs = builder.validateURIs; this.includeContext = builder.includeContext; this.lineEnding = Objects.requireNonNull(builder.lineEnding, "Line ending cannot be null"); + + if (builder.escapeUnicode && builder.useMultilineLiterals) { + throw new IllegalArgumentException("Cannot enable both escapeUnicode and useMultilineLiterals"); + } + this.useMultilineLiterals = builder.useMultilineLiterals; } + // --- Builder Class --- /** @@ -220,6 +229,7 @@ public static class Builder { private boolean validateURIs = true; private boolean includeContext = false; private String lineEnding = SerializationConstants.DEFAULT_LINE_ENDING; + private boolean useMultilineLiterals = true; /** * Default constructor initializes all options with their default values. @@ -311,6 +321,11 @@ public Builder sortPredicates(boolean sortPredicates) { return this; } + public Builder useMultilineLiterals(boolean useMultilineLiterals) { + this.useMultilineLiterals = useMultilineLiterals; + return this; + } + // --- Builder Methods for Technical Output Options --- public Builder literalDatatypePolicy(LiteralDatatypePolicyEnum literalDatatypePolicy) { @@ -388,7 +403,7 @@ public static FormatConfig ntriplesConfig() { .useCollections(false) .blankNodeStyle(BlankNodeStyleEnum.NAMED) // N-Triples uses _:bnodeId .prettyPrint(false) // N-Triples is usually not "pretty-printed" beyond newlines - .indent("") // No indentation + .indent(SerializationConstants.EMPTY_STRING) // No indentation .maxLineLength(0) // No line length limit for simplicity (or can be set very high) .groupBySubject(false) // Each triple on its own line .sortSubjects(false) // Order not strictly defined @@ -400,6 +415,7 @@ public static FormatConfig ntriplesConfig() { .stableBlankNodeIds(true) // Good for reproducible N-Triples tests .strictMode(true) // Be strict for N-Triples validation .validateURIs(true) + .useMultilineLiterals(false) .includeContext(false) // N-Triples does not support contexts .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) .build(); @@ -420,7 +436,7 @@ public static FormatConfig nquadsConfig() { .useCollections(false) .blankNodeStyle(BlankNodeStyleEnum.NAMED) .prettyPrint(false) - .indent("") + .indent(SerializationConstants.EMPTY_STRING) .maxLineLength(0) .groupBySubject(false) .sortSubjects(false) @@ -432,6 +448,7 @@ public static FormatConfig nquadsConfig() { .stableBlankNodeIds(true) .strictMode(true) .validateURIs(true) + .useMultilineLiterals(false) .includeContext(true) // N-Quads includes contexts by definition .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) .build(); @@ -445,10 +462,10 @@ public static FormatConfig nquadsConfig() { */ public static FormatConfig turtleConfig() { Map commonTurtlePrefixes = new HashMap<>(); - commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); - commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + commonTurtlePrefixes.put("rdf", SerializationConstants.RDF_NS); + commonTurtlePrefixes.put("rdfs", SerializationConstants.RDFS_NS); + commonTurtlePrefixes.put("xsd", SerializationConstants.XSD_NS); + commonTurtlePrefixes.put("owl", SerializationConstants.OWL_NS); return new Builder() .usePrefixes(true) @@ -457,8 +474,8 @@ public static FormatConfig turtleConfig() { .addCustomPrefixes(commonTurtlePrefixes) // Start with common prefixes .useCompactTriples(true) // Enable ; and , .useRdfTypeShortcut(true) // Use 'a' - .useCollections(false) // Keep false for now due to complexity - .blankNodeStyle(BlankNodeStyleEnum.NAMED) // Default to NAMED, for now (shorthand is complex) + .useCollections(true) // Changed to true for comprehensive Turtle output + .blankNodeStyle(BlankNodeStyleEnum.ANONYMOUS) .prettyPrint(true) .indent(SerializationConstants.DEFAULT_INDENTATION) .maxLineLength(80) // Standard line length @@ -473,6 +490,7 @@ public static FormatConfig turtleConfig() { .strictMode(true) .validateURIs(true) .includeContext(false) // Turtle does not support contexts + .useMultilineLiterals(true) .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) .build(); } @@ -485,10 +503,10 @@ public static FormatConfig turtleConfig() { */ public static FormatConfig trigConfig() { Map commonTriGPrefixes = new HashMap<>(); - commonTriGPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - commonTriGPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - commonTriGPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); - commonTriGPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + commonTriGPrefixes.put("rdf", SerializationConstants.RDF_NS); + commonTriGPrefixes.put("rdfs", SerializationConstants.RDFS_NS); + commonTriGPrefixes.put("xsd", SerializationConstants.XSD_NS); + commonTriGPrefixes.put("owl", SerializationConstants.OWL_NS); return new Builder() .usePrefixes(true) @@ -513,11 +531,23 @@ public static FormatConfig trigConfig() { .strictMode(true) .validateURIs(true) .includeContext(true) // TriG includes contexts by definition + .useMultilineLiterals(true) .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) .build(); } + public boolean shouldUseTripleQuotes(String literalValue) { + return useMultilineLiterals && + (literalValue.contains(SerializationConstants.LINE_FEED) || literalValue.contains(SerializationConstants.CARRIAGE_RETURN)); + } + + public boolean shouldOptimizeOutput() { + return useCompactTriples || groupBySubject || prettyPrint; + } + public boolean shouldUseInlineBlankNodes() { + return blankNodeStyle == BlankNodeStyleEnum.ANONYMOUS && useCompactTriples; + } // --- Getters for all options --- public boolean usePrefixes() { @@ -611,4 +641,8 @@ public boolean includeContext() { public String getLineEnding() { return lineEnding; } -} \ No newline at end of file + + public boolean useMultilineLiterals() { + return useMultilineLiterals; + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java index 0a42b6b41..3f5bcad16 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java @@ -1,4 +1,996 @@ package fr.inria.corese.core.next.impl.common.serialization; -public class TurtleFormat { +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.io.Writer; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.*; +import java.util.stream.Collectors; + +/** + * Serializes a {@link Model} to Turtle format with comprehensive syntax support. + * This class provides a method to write the declarations of a model to a {@link Writer} + * in accordance with the Turtle specification, taking into account configuration options. + * + *

This implementation handles:

+ *
    + *
  • Declaration and usage of prefixes for IRIs, including auto-declaration and sorting.
    • + *
  • The 'a' shortcut for 'rdf:type'.
    • + *
  • Escaping of special characters in literals (single-line and multi-line) and IRIs.
    • + *
  • Basic pretty-printing (indentation, end-of-line dots).
    • + *
  • Management of literal datatype policies (minimal or always typed).
    • + *
  • Serialization of compact triples (semicolons, commas) to group subjects and predicates.
    • + *
  • Serialization of nested blank nodes using the '[]' syntax.
    • + *
  • Serialization of RDF collections (lists) using the '()' syntax.
    • + *
  • Detection and prevention of infinite loops during serialization of nested blank nodes and lists.
    • + *
  • Sorting of subjects and predicates if configured.
    • + *
+ *

Advanced features such as strict adherence to maximum line length + * and generation of stable blank node identifiers are not fully implemented in this version.

+ */ +public class TurtleFormat implements FormatSerializer { + + /** + * Logger for this class, used to log potential issues or information during serialization. + */ + private static final Logger logger = LoggerFactory.getLogger(TurtleFormat.class); + + private final Model model; + private final FormatConfig config; + private final Map iriToPrefixMapping; + private final Map prefixToIriMapping; + // Set to track blank nodes already serialized inline or as part of a list + private final Set consumedBlankNodes; + // Set to track blank nodes currently being serialized to detect cycles + private final Set currentlyWritingBlankNodes; + + /** + * Constructs a new {@code TurtleFormat} instance with the specified model and default configuration. + * The default configuration is returned by {@link FormatConfig#turtleConfig()}. + * + * @param model the {@link Model} to serialize. Must not be null. + * @throws NullPointerException if the provided model is null. + */ + public TurtleFormat(Model model) { + this(model, FormatConfig.turtleConfig()); + } + + /** + * Constructs a new {@code TurtleFormat} instance with the specified model and custom configuration. + * + * @param model the {@link Model} to serialize. Must not be null. + * @param config the {@link FormatConfig} to use for serialization. Must not be null. + * @throws NullPointerException if the provided model or configuration is null. + */ + public TurtleFormat(Model model, FormatConfig config) { + this.model = Objects.requireNonNull(model, "Model cannot be null"); + this.config = Objects.requireNonNull(config, "Configuration cannot be null"); + this.iriToPrefixMapping = new HashMap<>(); + this.prefixToIriMapping = new HashMap<>(); + this.consumedBlankNodes = new HashSet<>(); + this.currentlyWritingBlankNodes = new HashSet<>(); + initializePrefixes(); + } + + /** + * Initializes prefix mappings by adding custom prefixes from the configuration. + */ + private void initializePrefixes() { + if (config.usePrefixes()) { + for (Map.Entry entry : config.getCustomPrefixes().entrySet()) { + addPrefixMapping(entry.getValue(), entry.getKey()); + } + } + } + + /** + * Writes the model to the given writer in Turtle format. + * + * @param writer the {@link Writer} to which the Turtle output will be written. + * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + */ + @Override + public void write(Writer writer) throws SerializationException { + try { + writeHeader(writer); + + Set precomputedInlineBlankNodes = precomputeInlineBlankNodesAndLists(); + consumedBlankNodes.addAll(precomputedInlineBlankNodes); + + if (config.useCompactTriples() && config.groupBySubject()) { + writeOptimizedStatements(writer); + } else { + writeSimpleStatements(writer); + } + + writer.flush(); + } catch (IOException e) { + throw new SerializationException("Failed to write to stream for Turtle format", "Turtle", e); + } catch (IllegalArgumentException e) { + throw new SerializationException("Invalid data for Turtle format: " + e.getMessage(), "Turtle", e); + } + } + + /** + * Writes the Turtle document header, including base IRI declaration and prefixes. + * + * @param writer the {@link Writer} to which the header will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeHeader(Writer writer) throws IOException { + if (config.getBaseIRI() != null) { + writer.write(String.format("@base <%s> .%s", + config.getBaseIRI(), + config.getLineEnding())); + } + + if (config.usePrefixes() && config.autoDeclarePrefixes()) { + collectUsedNamespaces(); + } + + writePrefixDeclarations(writer); + } + + /** + * Collects all namespaces used in the model and attempts to assign prefixes to them + * if auto-declaration is enabled and they are not already mapped. + */ + private void collectUsedNamespaces() { + Set namespaces = model.stream() + .flatMap(stmt -> Arrays.asList( + stmt.getSubject(), + stmt.getPredicate(), + stmt.getObject() + ).stream()) + .filter(Value::isIRI) + .map(v -> getNamespace(v.stringValue())) + .collect(Collectors.toSet()); + + namespaces.forEach(namespace -> { + if (!iriToPrefixMapping.containsKey(namespace)) { + String prefix = getSuggestedPrefix(namespace); + if (prefix != null) { + addPrefixMapping(namespace, prefix); + } + } + }); + } + + /** + * Writes prefix declarations to the writer, sorted if configured. + * + * @param writer the {@link Writer} to which prefixes will be written. + * @throws IOException if an I/O error occurs. + */ + private void writePrefixDeclarations(Writer writer) throws IOException { + List prefixes = new ArrayList<>(prefixToIriMapping.keySet()); + + if (config.getPrefixOrdering() == PrefixOrderingEnum.ALPHABETICAL) { + Collections.sort(prefixes); + } + + for (String prefix : prefixes) { + writer.write(String.format("@prefix %s: <%s> .%s", + prefix, + prefixToIriMapping.get(prefix), + config.getLineEnding())); + } + + if (!prefixes.isEmpty() || config.getBaseIRI() != null) { + writer.write(config.getLineEnding()); + } + } + + /** + * Serializes the model's statements in a simple manner, one per line, without grouping. + * Triples already "consumed" by inline serialization are ignored. + * + * @param writer the {@link Writer} to which the statements will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeSimpleStatements(Writer writer) throws IOException { + for (Statement stmt : model) { + if (!isConsumed(stmt.getSubject())) { + writeStatement(writer, stmt); + writer.write(config.getLineEnding()); + } + } + } + + /** + * Writes a single {@link Statement} to the writer in Turtle format. + * + * @param writer the {@link Writer} to which the statement will be written. + * @param stmt the {@link Statement} to write. + * @throws IOException if an I/O error occurs. + */ + private void writeStatement(Writer writer, Statement stmt) throws IOException { + String indent = config.prettyPrint() ? config.getIndent() : ""; + writer.write(indent); + + // Subject + writeValue(writer, stmt.getSubject()); + writer.write(SerializationConstants.SPACE); + + // Predicate + writePredicate(writer, stmt.getPredicate()); + writer.write(SerializationConstants.SPACE); + + // Object + writeValue(writer, stmt.getObject()); + + // Trailing dot + if (config.trailingDot()) { + writer.write(SerializationConstants.SPACE); + writer.write(SerializationConstants.POINT); + } + + logContextWarning(stmt); + } + + /** + * Writes the predicate to the writer, using the 'a' shortcut if configured and applicable. + * + * @param writer the {@link Writer} to which the predicate will be written. + * @param predicate the {@link Value} representing the predicate. + * @throws IOException if an I/O error occurs. + */ + private void writePredicate(Writer writer, Value predicate) throws IOException { + if (config.useRdfTypeShortcut() && predicate.stringValue().equals(SerializationConstants.RDF_TYPE)) { + writer.write(SerializationConstants.RDF_TYPE_SHORTCUT); + } else { + writeValue(writer, predicate); + } + } + + /** + * Writes a single {@link Value} to the writer. + * Handles literals, blank nodes, and IRIs. + * This is the entry point for serializing nested blank nodes and lists. + * + * @param writer the {@link Writer} to which the value will be written. + * @param value the {@link Value} to write. + * @throws IOException if an I/O error occurs. + * @throws IllegalArgumentException if the provided value is null or of an unsupported type. + */ + private void writeValue(Writer writer, Value value) throws IOException { + validateValue(value); + + if (value.isIRI()) { + writeIRI(writer, (IRI) value); + } else if (value.isLiteral()) { + writeLiteral(writer, (Literal) value); + } else if (value.isBNode()) { + Resource bNode = (Resource) value; + + if (currentlyWritingBlankNodes.contains(bNode)) { + writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); + return; + } + + currentlyWritingBlankNodes.add(bNode); + + boolean handled = false; + if (config.useCollections() && bNode.isBNode()) { + handled = writeRDFList(writer, bNode); + } + + if (!handled && config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS && bNode.isBNode()) { + List properties = model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .collect(Collectors.toList()); + + if (!properties.isEmpty()) { + writeInlineBlankNode(writer, properties); + handled = true; + } + } + + if (!handled) { + writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); + } + + currentlyWritingBlankNodes.remove(bNode); + } else { + throw new IllegalArgumentException("Unsupported value type for Turtle serialization: " + value.getClass().getName()); + } + } + + + /** + * Writes an {@link IRI} to the writer. + * Attempts to use a prefixed name if possible, otherwise writes the full IRI in angle brackets. + * + * @param writer the {@link Writer} to which the IRI will be written. + * @param iri the {@link IRI} to write. + * @throws IOException if an I/O error occurs. + */ + private void writeIRI(Writer writer, IRI iri) throws IOException { + if (config.isStrictMode() && config.validateURIs()) { + validateIRI(iri); + } + + String prefixed = config.usePrefixes() ? getPrefixedName(iri.stringValue()) : null; + + if (prefixed != null) { + writer.write(prefixed); + } else { + writer.write(String.format("<%s>", escapeTurtleIRI(iri.stringValue()))); + } + } + + /** + * Writes a {@link Literal} to the writer in Turtle format. + * Applies escaping and datatype/language tag rules based on configuration. + * + * @param writer the {@link Writer} to which the literal will be written. + * @param literal the {@link Literal} to write. + * @throws IOException if an I/O error occurs. + */ + private void writeLiteral(Writer writer, Literal literal) throws IOException { + String value = literal.stringValue(); + + if (config.shouldUseTripleQuotes(value)) { + writer.write(String.format("\"\"\"%s\"\"\"", escapeMultilineLiteral(value))); + } else { + writer.write(String.format("\"%s\"", escapeTurtleLiteral(value))); + } + + literal.getLanguage().ifPresent(lang -> { + try { + writer.write(SerializationConstants.AT_SIGN + lang); + } catch (IOException e) { + throw new UncheckedIOException("Error writing language tag to stream", e); + } + }); + + writeDatatype(writer, literal); + } + + /** + * Writes the datatype of a literal if the configured datatype policy allows it. + * + * @param writer the {@link Writer} to which the datatype will be written. + * @param literal the {@link Literal} whose datatype is to be written. + * @throws IOException if an I/O error occurs. + */ + private void writeDatatype(Writer writer, Literal literal) throws IOException { + IRI datatype = literal.getDatatype(); + if (shouldWriteDatatype(literal)) { + writer.write(SerializationConstants.DATATYPE_SEPARATOR); + writeIRI(writer, datatype); + } + } + + /** + * Determines if a literal's datatype should be written based on the configuration. + * + * @param literal the {@link Literal} to check. + * @return {@code true} if the datatype should be written, {@code false} otherwise. + */ + private boolean shouldWriteDatatype(Literal literal) { + if (literal.getLanguage().isPresent()) { + return false; + } + + IRI datatype = literal.getDatatype(); + if (datatype == null) { + return false; + } + + return config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || + (!datatype.stringValue().equals(SerializationConstants.XSD_STRING) && + config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL); + } + + /** + * Writes an inline blank node using the `[]` syntax. + * The blank node's properties are serialized inside the brackets. + * + * @param writer the {@link Writer} to which the blank node will be written. + * @param properties the list of statements where the blank node is the subject. + * @throws IOException if an I/O error occurs. + */ + private void writeInlineBlankNode(Writer writer, List properties) throws IOException { + String currentIndent = config.prettyPrint() ? config.getIndent() : ""; + String propIndent = config.prettyPrint() ? currentIndent + config.getIndent() : ""; + + writer.write(SerializationConstants.BLANK_NODE_START); + + boolean firstProperty = true; + for (Statement stmt : properties) { + if (stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || + stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) { + continue; + } + + if (!firstProperty) { + writer.write(SerializationConstants.SEMICOLON); + } + firstProperty = false; + + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + propIndent); + } else { + writer.write(SerializationConstants.SPACE); + } + + writePredicate(writer, stmt.getPredicate()); + writer.write(SerializationConstants.SPACE); + writeValue(writer, stmt.getObject()); + } + + if (config.prettyPrint() && !properties.isEmpty() && !firstProperty) { + writer.write(config.getLineEnding() + currentIndent); + } + + writer.write(SerializationConstants.BLANK_NODE_END); + } + + /** + * Serializes the model's statements by grouping triples by subject, then by predicate, + * using compact syntax (semicolons and commas) if configured. + * Triples already "consumed" by inline serialization are ignored. + * + * @param writer the {@link Writer} to which the optimized statements will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeOptimizedStatements(Writer writer) throws IOException { + // Collect and group statements by subject + Map> bySubject = config.sortSubjects() ? + new TreeMap<>(Comparator.comparing(Resource::stringValue)) : + new LinkedHashMap<>(); + + + model.stream() + .filter(stmt -> !isConsumed(stmt.getSubject())) + .forEach(stmt -> bySubject.computeIfAbsent(stmt.getSubject(), k -> new ArrayList<>()).add(stmt)); + + for (Map.Entry> subjectEntry : bySubject.entrySet()) { + String indent = config.prettyPrint() ? config.getIndent() : ""; + writer.write(indent); + writeValue(writer, subjectEntry.getKey()); + writer.write(SerializationConstants.SPACE); + + // Group statements of the current subject by predicate + Map> byPredicate = config.sortPredicates() ? + new TreeMap<>(Comparator.comparing(IRI::stringValue)) : + new LinkedHashMap<>(); + + subjectEntry.getValue().forEach(stmt -> byPredicate.computeIfAbsent(stmt.getPredicate(), k -> new ArrayList<>()).add(stmt)); + + boolean firstPredicate = true; + for (Map.Entry> predicateEntry : byPredicate.entrySet()) { + if (!firstPredicate) { + writer.write(SerializationConstants.SEMICOLON); + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + indent + config.getIndent()); + } else { + writer.write(SerializationConstants.SPACE); + } + } + firstPredicate = false; + + writePredicate(writer, predicateEntry.getKey()); + writer.write(SerializationConstants.SPACE); + + boolean firstObject = true; + for (Statement stmt : predicateEntry.getValue()) { + if (!firstObject) { + writer.write(SerializationConstants.COMMA); // Object separator + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + indent + config.getIndent() + config.getIndent()); // Indentation for new object + } else { + writer.write(SerializationConstants.SPACE); + } + } + firstObject = false; + + writeValue(writer, stmt.getObject()); + } + } + + writer.write(SerializationConstants.SPACE + SerializationConstants.POINT); + writer.write(config.getLineEnding()); + } + } + + /** + * Attempts to serialize an RDF list if the given blank node is its head. + * Marks all blank nodes in the list as consumed. + * + * @param writer the {@link Writer} to which the list will be written. + * @param listHead the blank node that might be the head of an RDF list. + * @return {@code true} if an RDF list was serialized, {@code false} otherwise. + * @throws IOException if an I/O error occurs. + */ + private boolean writeRDFList(Writer writer, Resource listHead) throws IOException { + List items = new ArrayList<>(); + Resource current = listHead; + Set listBlankNodes = new HashSet<>(); + + if (currentlyWritingBlankNodes.contains(listHead)) { + return false; + } + currentlyWritingBlankNodes.add(listHead); + + while (current != null && current.isBNode() && !currentlyWritingBlankNodes.contains(current)) { + listBlankNodes.add(current); + currentlyWritingBlankNodes.add(current); + + final Resource finalCurrentForLambda = current; + List statements = model.stream() + .filter(stmt -> stmt.getSubject().equals(finalCurrentForLambda)) + .collect(Collectors.toList()); + + if (statements.size() != 2) { + current = null; + break; + } + + Optional first = statements.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + .map(Statement::getObject) + .findFirst(); + + Optional rest = statements.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .map(Statement::getObject) + .findFirst(); + + if (!first.isPresent() || !rest.isPresent()) { + current = null; + break; + } + + items.add(first.get()); + + if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { + current = null; // End of the list + } else if (rest.get().isBNode()) { + current = (Resource) rest.get(); + } else { + current = null; + break; + } + } + currentlyWritingBlankNodes.remove(listHead); + + if (items.isEmpty() || current != null) { + listBlankNodes.forEach(currentlyWritingBlankNodes::remove); + return false; + } + + // Mark all blank nodes composing this list as consumed + consumedBlankNodes.addAll(listBlankNodes); + + writer.write(SerializationConstants.OPEN_PARENTHESIS); + boolean firstItem = true; + for (Value item : items) { + if (!firstItem) writer.write(SerializationConstants.SPACE); + firstItem = false; + writeValue(writer, item); + } + writer.write(SerializationConstants.CLOSE_PARENTHESIS); + return true; + } + + /** + * Determines if a value (subject, predicate, object) is a blank node that has already been + * serialized inline (within a '[]' or '()') and should be ignored during top-level serialization. + * + * @param value the {@link Value} to check. + * @return {@code true} if the value is a consumed blank node, {@code false} otherwise. + */ + private boolean isConsumed(Value value) { + return value.isBNode() && consumedBlankNodes.contains((Resource) value); + } + + /** + * Identifies and returns a set of blank nodes that can be serialized inline (either as `[]` or as `()` for lists). + * These nodes will then be "consumed" to prevent their serialization as top-level triples. + * + * @return A {@link Set} of {@link Resource} representing the blank nodes that will be serialized inline. + */ + private Set precomputeInlineBlankNodesAndLists() { + Set precomputed = new HashSet<>(); + for (Statement stmt : model) { + if (stmt.getSubject().isBNode()) { + Resource bNodeSubject = (Resource) stmt.getSubject(); + // Check if it's a list + if (config.useCollections() && isRDFListHead(bNodeSubject)) { + Resource current = bNodeSubject; + Set listNodes = new HashSet<>(); + Set visitedInPrecomp = new HashSet<>(); + boolean isList = true; + while (current != null && current.isBNode() && !visitedInPrecomp.contains(current)) { + visitedInPrecomp.add(current); + listNodes.add(current); + final Resource finalCurrentForLambda = current; + List listProps = model.stream() + .filter(s -> s.getSubject().equals(finalCurrentForLambda)) + .collect(Collectors.toList()); + if (listProps.size() != 2) { + isList = false; + break; + } + + Optional rest = listProps.stream() + .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .map(Statement::getObject) + .findFirst(); + + if (!rest.isPresent()) { + isList = false; + break; + } + + if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { + current = null; + } else if (rest.get().isBNode()) { + current = (Resource) rest.get(); + } else { + isList = false; + break; + } + } + if (isList && current == null) { + precomputed.addAll(listNodes); + } + } + // Check if it's a blank node with properties to include inline (style [] ) + if (config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS) { + List properties = model.stream() + .filter(s -> s.getSubject().equals(bNodeSubject)) + .collect(Collectors.toList()); + // Do not consider as inlineable if it's part of a list (already handled) + boolean isPartOfList = properties.stream().anyMatch(s -> + s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || + s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST) + ); + + if (!properties.isEmpty() && !isPartOfList) { + precomputed.add(bNodeSubject); + } + } + } + } + return precomputed; + } + + /** + * Checks if a given blank node is the head of an RDF list. + * + * @param bNode the blank node to check. + * @return true if it's the head of an RDF list, false otherwise. + */ + private boolean isRDFListHead(Resource bNode) { + + boolean hasFirstAndRest = model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + && + model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)); + + if (!hasFirstAndRest) return false; + + // Check if this blank node is the object of another rdf:rest triple + boolean isObjectOfRest = model.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .anyMatch(stmt -> stmt.getObject().equals(bNode)); + + return hasFirstAndRest && !isObjectOfRest; + } + + + // --- Helpers for prefix resolution --- + + /** + * Adds a prefix-namespace URI mapping to the internal mappings. + * Handles potential conflicts to ensure uniqueness. + * + * @param namespaceURI The namespace URI. + * @param prefix The associated prefix. + */ + private void addPrefixMapping(String namespaceURI, String prefix) { + if (iriToPrefixMapping.containsKey(namespaceURI)) { + if (!iriToPrefixMapping.get(namespaceURI).equals(prefix)) { + logger.warn("Namespace URI '{}' is already mapped to prefix '{}'. Cannot map to new prefix '{}'.", + namespaceURI, iriToPrefixMapping.get(namespaceURI), prefix); + } + return; + } + + if (prefixToIriMapping.containsKey(prefix)) { + if (!prefixToIriMapping.get(prefix).equals(namespaceURI)) { + String originalNamespace = prefixToIriMapping.get(prefix); + logger.warn("Prefix '{}' is already mapped to namespace '{}'. Cannot map to new namespace '{}'. " + + "A new unique prefix will be generated for '{}'.", + prefix, originalNamespace, namespaceURI, namespaceURI); + return; + } + } + iriToPrefixMapping.put(namespaceURI, prefix); + prefixToIriMapping.put(prefix, namespaceURI); + } + + /** + * Extracts the namespace URI part from an IRI string. + * This is a common heuristic for RDF IRIs. + * + * @param iriString The full IRI. + * @return The namespace URI part. + */ + private String getNamespace(String iriString) { + int hashIdx = iriString.lastIndexOf(SerializationConstants.HASH); + int slashIdx = iriString.lastIndexOf(SerializationConstants.SLASH); + + if (hashIdx > -1) { + return iriString.substring(0, hashIdx + 1); + } else if (slashIdx > -1 && slashIdx < iriString.length() - 1) { + int dotIdx = iriString.lastIndexOf(SerializationConstants.POINT); + if (dotIdx > slashIdx) { + + return iriString.substring(0, slashIdx + 1); + } + return iriString.substring(0, slashIdx + 1); + } + return iriString; + } + + + /** + * Attempts to find a prefixed name for an IRI from existing mappings. + * + * @param iriString The full IRI. + * @return The prefixed name (e.g., "ex:someResource") or null if no suitable prefix is found. + */ + private String getPrefixedName(String iriString) { + for (Map.Entry entry : iriToPrefixMapping.entrySet()) { + String namespace = entry.getKey(); + String prefix = entry.getValue(); + + if (iriString.startsWith(namespace)) { + String localName = iriString.substring(namespace.length()); + if (localName.isEmpty()) { + if (!prefix.isEmpty()) { + return prefix + SerializationConstants.COLON; + } else { + continue; + } + } + return prefix + SerializationConstants.COLON + localName; + } + } + return null; + } + + /** + * Suggests a prefix for a given namespace URI. + * Attempts to derive a meaningful prefix or generates a unique one. + * + * @param namespace The namespace URI. + * @return A suggested prefix, or null if suggestion is not possible. + */ + private String getSuggestedPrefix(String namespace) { + // Try common predefined prefixes + if (namespace.equals(SerializationConstants.RDF_NS)) return "rdf"; + if (namespace.equals(SerializationConstants.RDFS_NS)) return "rdfs"; + if (namespace.equals(SerializationConstants.XSD_NS)) return "xsd"; + if (namespace.equals(SerializationConstants.OWL_NS)) return "owl"; + if (namespace.equals(SerializationConstants.FOAF_NS)) return "foaf"; + + + String base = namespace; + if (base.endsWith(SerializationConstants.HASH) || base.endsWith(SerializationConstants.SLASH)) { + base = base.substring(0, base.length() - 1); + } + int lastSlash = base.lastIndexOf(SerializationConstants.SLASH); + int lastHash = base.lastIndexOf(SerializationConstants.HASH); + int lastSegmentStart = Math.max(lastSlash, lastHash); + if (lastSegmentStart != -1) { + base = base.substring(lastSegmentStart + 1); + } + + if (base.isEmpty()) { // If it's something like http://example.com/ + try { + URL url = new URL(namespace); + base = url.getHost().replace(SerializationConstants.POINT, ""); + } catch (MalformedURLException e) { + // Fallback + base = "p"; + } + } + + // Convert to lowercase and remove non-alphanumeric characters + base = base.replaceAll("[^a-zA-Z0-9]", "").toLowerCase(); + if (base.isEmpty()) base = "p"; // General fallback + + // Ensure uniqueness + String candidate = base; + int i = 0; + // Check if the prefix already exists and is mapped to *another* namespace + while (prefixToIriMapping.containsKey(candidate) && !prefixToIriMapping.get(candidate).equals(namespace)) { + candidate = base + (++i); + } + return candidate; + } + + + // --- Helpers for escaping and validation --- + + /** + * Escapes special characters in Turtle string literals. + * Handles backslashes, double quotes, and common control characters. + * Unicode escape sequences are used for unprintable characters if `escapeUnicode` is true. + * + * @param value The string value of the literal to escape. + * @return The escaped string suitable for a Turtle literal. + */ + private String escapeTurtleLiteral(String value) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < value.length(); i++) { + char c = value.charAt(i); + switch (c) { + case '\n': + sb.append(SerializationConstants.BACK_SLASH).append("n"); + break; + case '\r': + sb.append(SerializationConstants.BACK_SLASH).append("r"); + break; + case '\t': + sb.append(SerializationConstants.BACK_SLASH).append("t"); + break; + case '\b': + sb.append(SerializationConstants.BACK_SLASH).append("b"); + break; + case '\f': + sb.append(SerializationConstants.BACK_SLASH).append("f"); + break; + case '"': + sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.QUOTE); + break; + case '\\': + sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.BACK_SLASH); + break; + default: + if (config.escapeUnicode() && (c <= 0x1F || c == 0x7F || (c >= 0x80 && c <= 0xFFFF))) { + sb.append(String.format("\\u%04X", (int) c)); + } else if (Character.isHighSurrogate(c)) { + int codePoint = value.codePointAt(i); + if (Character.isValidCodePoint(codePoint)) { + sb.append(String.format("\\U%08X", codePoint)); + i++; + } else { + sb.append(c); + } + } else { + sb.append(c); + } + } + } + return sb.toString(); + } + + /** + * Escapes special characters in multi-line literals (triple-quotes). + * Primarily used to escape occurrences of `"""` within the literal. + * + * @param value The string value of the literal to escape. + * @return The escaped string suitable for a multi-line Turtle literal. + */ + private String escapeMultilineLiteral(String value) { + // In multi-line literals, only triple quotes need to be escaped + return value.replace(SerializationConstants.QUOTE + SerializationConstants.QUOTE + SerializationConstants.QUOTE, + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE); + } + + /** + * Escapes characters in an IRI string for Turtle output. + * This method primarily focuses on control characters and problematic characters within angle brackets. + * + * @param iri The IRI to escape. + * @return The escaped IRI. + */ + private String escapeTurtleIRI(String iri) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < iri.length(); i++) { + char c = iri.charAt(i); + if (c < 0x20 || c == 0x7F || c == SerializationConstants.LT.charAt(0) || c == SerializationConstants.GT.charAt(0) || c == SerializationConstants.QUOTE.charAt(0) || c == '{' || c == '}' || c == '|' || c == '^' || c == '`' || c == SerializationConstants.BACK_SLASH.charAt(0)) { + sb.append(String.format("\\u%04X", (int) c)); + } else { + sb.append(c); + } + } + return sb.toString(); + } + + /** + * Validates RDF values before serialization. + * Called only if strictMode is enabled. + * + * @param value The {@link Value} to validate. + * @throws IllegalArgumentException if the value is null or invalid according to strict rules. + */ + private void validateValue(Value value) { + if (value == null) { + logger.warn("Null value encountered where a non-null value was expected for Turtle serialization. This will lead to an IllegalArgumentException if strict mode is enabled."); + throw new IllegalArgumentException("Value cannot be null in Turtle format when strictMode is enabled."); + } + + if (config.isStrictMode()) { + if (value.isLiteral()) { + validateLiteral((Literal) value); + } + } + } + + /** + * Validates a {@link Literal} to ensure it conforms to RDF/Turtle rules. + * Specifically checks for consistency between language tags and the rdf:langString datatype. + * Called only if strictMode is enabled. + * + * @param literal The {@link Literal} to validate. + * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, + * or rdf:langString literal without language tag). + */ + private void validateLiteral(Literal literal) { + IRI datatype = literal.getDatatype(); + + if (literal.getLanguage().isPresent()) { + if (datatype == null || !datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + throw new IllegalArgumentException( + "A literal with a language tag must use the rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); + } + } else { + if (datatype != null && datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + throw new IllegalArgumentException( + "An rdf:langString literal must have a language tag."); + } + } + } + + /** + * Validates an {@link IRI} to ensure it conforms to Turtle rules. + * Checks if the IRI string contains characters not allowed in unescaped Turtle + * form within angle brackets (e.g., control characters, space). + * Called only if strictMode and validateURIs are enabled. + * + * @param iri The {@link IRI} to validate. + * @throws IllegalArgumentException if the IRI contains invalid characters. + */ + private void validateIRI(IRI iri) { + String iriString = iri.stringValue(); + + if (iriString.contains(SerializationConstants.SPACE) || + iriString.contains(SerializationConstants.QUOTE) || + iriString.contains(SerializationConstants.LT) || + iriString.contains(SerializationConstants.GT)) { + throw new IllegalArgumentException("IRI contains illegal characters (space, quotes, angle brackets) for unescaped Turtle form: " + iriString); + } + } + + /** + * Logs a warning if a context (named graph) is present in a statement, + * as the Turtle format does not support named graphs. + * + * @param stmt The statement to check. + */ + private void logContextWarning(Statement stmt) { + if (stmt.getContext() != null && logger.isWarnEnabled()) { + logger.warn("Turtle format does not support named graphs. Context '{}' will be ignored for statement: {}", + stmt.getContext().stringValue(), stmt); + } + } } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java b/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java index e7605a6cd..a34177a7a 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java @@ -1,103 +1,77 @@ package fr.inria.corese.core.next.impl.common.util; /** - * Provides a collection of constant strings used during the serialization process - * for various RDF formats. These constants aim to - * centralize common literal values to ensure consistency and maintainability - * across different serialization utilities. + * Provides common constants used throughout the RDF serialization process. + * This includes URIs for common RDF, RDFS, XSD, and OWL vocabularies, + * as well as various special characters and strings used in serialization formats + * like Turtle, N-Triples, and N-Quads. */ -public class SerializationConstants { +public final class SerializationConstants { - /** - * Represents a single space character (" "). - * Used for separating elements within an RDF triple or quad. - */ - public static final String SPACE = " "; - - /** - * Represents the termination sequence for an RDF statement format: - * a space, a dot, and a newline character (" .\n"). - */ - public static final String SPACE_POINT = " .\n"; + private SerializationConstants() { + // Private constructor to prevent instantiation + } - /** - * Represents a single dot character ("."). - * Used as a terminator for RDF statements. - */ - public static final String POINT = "."; + // --- Standard RDF/RDFS/XSD/OWL URIs --- + public static final String RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"; + public static final String RDFS_NS = "http://www.w3.org/2000/01/rdf-schema#"; + public static final String XSD_NS = "http://www.w3.org/2001/XMLSchema#"; + public static final String OWL_NS = "http://www.w3.org/2002/07/owl#"; - /** - * Represents the less-than sign ("<"). - * Used to enclose URIs in N-Triples and N-Quads. - */ - public static final String LT = "<"; - - /** - * Represents the greater-than sign (">"). - * Used to enclose URIs. - */ - public static final String GT = ">"; - - /** - * Represents the standard prefix for blank nodes ("_:"). - * Used to identify blank nodes. - */ - public static final String BNODE_PREFIX = "_:"; + public static final String RDF_TYPE = RDF_NS + "type"; + public static final String RDF_FIRST = RDF_NS + "first"; + public static final String RDF_REST = RDF_NS + "rest"; + public static final String RDF_NIL = RDF_NS + "nil"; + public static final String RDF_LANGSTRING = RDF_NS + "langString"; - /** - * Represents a double-quote character ("\""). - * Used to enclose literal values. - */ - public static final String QUOTE = "\""; - /** - * Represents a backslash character ("\\"). - * Used for escaping special characters within string literals. - */ - public static final String BACK_SLASH = "\\"; + public static final String XSD_STRING = XSD_NS + "string"; + public static final String XSD_INTEGER = XSD_NS + "integer"; + public static final String XSD_DECIMAL = XSD_NS + "decimal"; + public static final String XSD_DOUBLE = XSD_NS + "double"; + public static final String XSD_BOOLEAN = XSD_NS + "boolean"; + public static final String XSD_DATETIME = XSD_NS + "dateTime"; - /** - * The URI string for the XML Schema `xsd:string` datatype: - * {@code http://www.w3.org/2001/XMLSchema#string}. - */ - public static final String XSD_STRING = "http://www.w3.org/2001/XMLSchema#string"; + // Nouveau namespace FOAF + public static final String FOAF_NS = "http://xmlns.com/foaf/0.1/"; - /** - * The URI string for the RDF `rdf:langString` datatype: - * {@code http://www.w3.org/1999/02/22-rdf-syntax-ns#langString}. - */ - public static final String RDF_LANGSTRING = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"; - // Nouvelle constante pour le préfixe de la balise de langue - public static final String AT_SIGN = "@"; + // --- Common Delimiters and Special Characters in Serialization --- + public static final String SPACE = " "; + public static final String TAB = "\t"; + public static final String LINE_FEED = "\n"; + public static final String CARRIAGE_RETURN = "\r"; + public static final String NEWLINE = LINE_FEED; // Unix-style newline for general use - // Nouvelle constante pour le séparateur de datatype - public static final String DATATYPE_SEPARATOR = "^^"; - // Used by NAMED BlankNodeStyle - public static final String DEFAULT_BLANK_NODE_PREFIX = "_:"; - // Separator for predicate-object lists in Turtle/TriG + public static final String POINT = "."; public static final String SEMICOLON = ";"; - // Separator for object lists in Turtle/TriG public static final String COMMA = ","; - // 2 spaces - public static final String DEFAULT_INDENTATION = " "; + public static final String AT_SIGN = "@"; + public static final String CARET = "^"; + public static final String LT = "<"; // Less than + public static final String GT = ">"; // Greater than + public static final String QUOTE = "\""; + public static final String COLON = ":"; + public static final String BACK_SLASH = "\\"; - public static final String DEFAULT_LINE_ENDING = "\n"; + // Nouveaux délimiteurs + public static final String HASH = "#"; + public static final String SLASH = "/"; - // --- Keywords and Shortcuts --- - public static final String PREFIX_KEYWORD = "@prefix"; // Turtle/TriG prefix keyword + // Turtle-specific + public static final String RDF_TYPE_SHORTCUT = "a"; + public static final String BNODE_PREFIX = "_:"; + public static final String DATATYPE_SEPARATOR = "^^"; + public static final String BLANK_NODE_START = "["; + public static final String BLANK_NODE_END = "]"; - public static final String RDF_TYPE_SHORTCUT = "a"; // Shortcut for rdf:type in Turtle/TriG + public static final String OPEN_PARENTHESIS = "("; + public static final String CLOSE_PARENTHESIS = ")"; - public static final String COLON = ":"; + // --- Default Values for Configuration --- + public static final String DEFAULT_INDENTATION = " "; // Two spaces + public static final String DEFAULT_LINE_ENDING = "\n"; // Unix-style - public static final String RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"; + public static final String EMPTY_STRING = ""; - public static final String RDF_TYPE = RDF_NS + "type"; - /** - * Private constructor to prevent instantiation of this utility class. - * All members are static. - */ - private SerializationConstants() { - } -} \ No newline at end of file +} From 796e45ba6e2fe51d69be07d850c5f5ed375753ce Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Wed, 18 Jun 2025 16:14:07 +0200 Subject: [PATCH 03/27] Create turtles Serializer --- .../common/serialization/TurtleFormat.java | 60 +++++++++++-------- 1 file changed, 34 insertions(+), 26 deletions(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java index 3f5bcad16..3526a388f 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java @@ -9,8 +9,8 @@ import java.io.IOException; import java.io.UncheckedIOException; import java.io.Writer; -import java.net.MalformedURLException; -import java.net.URL; +import java.net.URI; +import java.net.URISyntaxException; import java.util.*; import java.util.stream.Collectors; @@ -285,7 +285,7 @@ private void writeValue(Writer writer, Value value) throws IOException { if (!handled && config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS && bNode.isBNode()) { List properties = model.stream() .filter(stmt -> stmt.getSubject().equals(bNode)) - .collect(Collectors.toList()); + .toList(); if (!properties.isEmpty()) { writeInlineBlankNode(writer, properties); @@ -528,7 +528,7 @@ private boolean writeRDFList(Writer writer, Resource listHead) throws IOExceptio final Resource finalCurrentForLambda = current; List statements = model.stream() .filter(stmt -> stmt.getSubject().equals(finalCurrentForLambda)) - .collect(Collectors.toList()); + .toList(); if (statements.size() != 2) { current = null; @@ -568,7 +568,6 @@ private boolean writeRDFList(Writer writer, Resource listHead) throws IOExceptio return false; } - // Mark all blank nodes composing this list as consumed consumedBlankNodes.addAll(listBlankNodes); writer.write(SerializationConstants.OPEN_PARENTHESIS); @@ -590,7 +589,7 @@ private boolean writeRDFList(Writer writer, Resource listHead) throws IOExceptio * @return {@code true} if the value is a consumed blank node, {@code false} otherwise. */ private boolean isConsumed(Value value) { - return value.isBNode() && consumedBlankNodes.contains((Resource) value); + return value.isBNode() && consumedBlankNodes.contains(value); } /** @@ -603,8 +602,8 @@ private Set precomputeInlineBlankNodesAndLists() { Set precomputed = new HashSet<>(); for (Statement stmt : model) { if (stmt.getSubject().isBNode()) { - Resource bNodeSubject = (Resource) stmt.getSubject(); - // Check if it's a list + Resource bNodeSubject = stmt.getSubject(); + if (config.useCollections() && isRDFListHead(bNodeSubject)) { Resource current = bNodeSubject; Set listNodes = new HashSet<>(); @@ -616,18 +615,24 @@ private Set precomputeInlineBlankNodesAndLists() { final Resource finalCurrentForLambda = current; List listProps = model.stream() .filter(s -> s.getSubject().equals(finalCurrentForLambda)) - .collect(Collectors.toList()); + .toList(); + if (listProps.size() != 2) { isList = false; break; } + Optional first = listProps.stream() + .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + .map(Statement::getObject) + .findFirst(); + Optional rest = listProps.stream() .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) .map(Statement::getObject) .findFirst(); - if (!rest.isPresent()) { + if (!first.isPresent() || !rest.isPresent()) { isList = false; break; } @@ -645,12 +650,11 @@ private Set precomputeInlineBlankNodesAndLists() { precomputed.addAll(listNodes); } } - // Check if it's a blank node with properties to include inline (style [] ) if (config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS) { List properties = model.stream() .filter(s -> s.getSubject().equals(bNodeSubject)) - .collect(Collectors.toList()); - // Do not consider as inlineable if it's part of a list (already handled) + .toList(); + boolean isPartOfList = properties.stream().anyMatch(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST) @@ -665,6 +669,7 @@ private Set precomputeInlineBlankNodesAndLists() { return precomputed; } + /** * Checks if a given blank node is the head of an RDF list. * @@ -702,23 +707,28 @@ private boolean isRDFListHead(Resource bNode) { * @param prefix The associated prefix. */ private void addPrefixMapping(String namespaceURI, String prefix) { + if (iriToPrefixMapping.containsKey(namespaceURI)) { - if (!iriToPrefixMapping.get(namespaceURI).equals(prefix)) { + if (!iriToPrefixMapping.get(namespaceURI).equals(prefix) && logger.isWarnEnabled()) { logger.warn("Namespace URI '{}' is already mapped to prefix '{}'. Cannot map to new prefix '{}'.", namespaceURI, iriToPrefixMapping.get(namespaceURI), prefix); + } return; } + if (prefixToIriMapping.containsKey(prefix)) { - if (!prefixToIriMapping.get(prefix).equals(namespaceURI)) { + if (!prefixToIriMapping.get(prefix).equals(namespaceURI) && logger.isWarnEnabled()) { String originalNamespace = prefixToIriMapping.get(prefix); logger.warn("Prefix '{}' is already mapped to namespace '{}'. Cannot map to new namespace '{}'. " + "A new unique prefix will be generated for '{}'.", prefix, originalNamespace, namespaceURI, namespaceURI); - return; + } + return; } + iriToPrefixMapping.put(namespaceURI, prefix); prefixToIriMapping.put(prefix, namespaceURI); } @@ -801,13 +811,13 @@ private String getSuggestedPrefix(String namespace) { base = base.substring(lastSegmentStart + 1); } - if (base.isEmpty()) { // If it's something like http://example.com/ + if (base.isEmpty()) { try { - URL url = new URL(namespace); - base = url.getHost().replace(SerializationConstants.POINT, ""); - } catch (MalformedURLException e) { - // Fallback - base = "p"; + URI uri = new URI(namespace); // Utilisation de URI + base = uri.getHost().replace(SerializationConstants.POINT, SerializationConstants.EMPTY_STRING); + } catch (URISyntaxException e) { // Capture URISyntaxException + logger.warn("Malformed URI encountered while suggesting prefix: {}", namespace, e); + base = "p"; // Fallback } } @@ -929,10 +939,8 @@ private void validateValue(Value value) { throw new IllegalArgumentException("Value cannot be null in Turtle format when strictMode is enabled."); } - if (config.isStrictMode()) { - if (value.isLiteral()) { - validateLiteral((Literal) value); - } + if (config.isStrictMode() && value.isLiteral()) { + validateLiteral((Literal) value); } } From 84919a21700ed85142f0c1edd6b3cee9b4b7aad4 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Thu, 19 Jun 2025 10:15:40 +0200 Subject: [PATCH 04/27] Create turtles Serializer et correction sonar --- .../impl/common/serialization/Serializer.java | 11 +++++------ .../common/serialization/TurtleFormat.java | 18 ++++++++---------- 2 files changed, 13 insertions(+), 16 deletions(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java index 37427b832..d2138edb0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java @@ -37,14 +37,13 @@ public void serialize(Writer writer, RdfFormat format) throws SerializationExcep if (format.equals(RdfFormat.NTRIPLES)) { formatSerializer = new NTriplesFormat(model, config); - } else if (format.equals( RdfFormat.NQUADS)) { + } else if (format.equals(RdfFormat.NQUADS)) { formatSerializer = new NQuadsFormat(model, config); - } else if (format.equals( RdfFormat.TURTLE)) { - - throw new UnsupportedOperationException("Serialization to " + format.getName() + " format is not yet implemented."); - } else if (format.equals( RdfFormat.JSONLD)) { + } else if (format.equals(RdfFormat.TURTLE)) { + formatSerializer = new TurtleFormat(model, config); + } else if (format.equals(RdfFormat.JSONLD)) { throw new UnsupportedOperationException("Serialization to " + format.getName() + " format is not yet implemented."); - } else if (format.equals( RdfFormat.RDFXML)) { + } else if (format.equals(RdfFormat.RDFXML)) { throw new UnsupportedOperationException("Serialization to " + format.getName() + " format is not yet implemented."); } else { throw new IllegalArgumentException("Unknown or unsupported RdfFormat: " + format.getName()); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java index 3526a388f..0c8fe0d36 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java @@ -399,8 +399,8 @@ private boolean shouldWriteDatatype(Literal literal) { * @throws IOException if an I/O error occurs. */ private void writeInlineBlankNode(Writer writer, List properties) throws IOException { - String currentIndent = config.prettyPrint() ? config.getIndent() : ""; - String propIndent = config.prettyPrint() ? currentIndent + config.getIndent() : ""; + String currentIndent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; + String propIndent = config.prettyPrint() ? currentIndent + config.getIndent() : SerializationConstants.EMPTY_STRING; writer.write(SerializationConstants.BLANK_NODE_START); @@ -454,7 +454,7 @@ private void writeOptimizedStatements(Writer writer) throws IOException { .forEach(stmt -> bySubject.computeIfAbsent(stmt.getSubject(), k -> new ArrayList<>()).add(stmt)); for (Map.Entry> subjectEntry : bySubject.entrySet()) { - String indent = config.prettyPrint() ? config.getIndent() : ""; + String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; writer.write(indent); writeValue(writer, subjectEntry.getKey()); writer.write(SerializationConstants.SPACE); @@ -484,9 +484,9 @@ private void writeOptimizedStatements(Writer writer) throws IOException { boolean firstObject = true; for (Statement stmt : predicateEntry.getValue()) { if (!firstObject) { - writer.write(SerializationConstants.COMMA); // Object separator + writer.write(SerializationConstants.COMMA); if (config.prettyPrint()) { - writer.write(config.getLineEnding() + indent + config.getIndent() + config.getIndent()); // Indentation for new object + writer.write(config.getLineEnding() + indent + config.getIndent() + config.getIndent()); } else { writer.write(SerializationConstants.SPACE); } @@ -817,18 +817,16 @@ private String getSuggestedPrefix(String namespace) { base = uri.getHost().replace(SerializationConstants.POINT, SerializationConstants.EMPTY_STRING); } catch (URISyntaxException e) { // Capture URISyntaxException logger.warn("Malformed URI encountered while suggesting prefix: {}", namespace, e); - base = "p"; // Fallback + base = "p"; } } - // Convert to lowercase and remove non-alphanumeric characters base = base.replaceAll("[^a-zA-Z0-9]", "").toLowerCase(); - if (base.isEmpty()) base = "p"; // General fallback + if (base.isEmpty()) base = "p"; // Ensure uniqueness String candidate = base; int i = 0; - // Check if the prefix already exists and is mapped to *another* namespace while (prefixToIriMapping.containsKey(candidate) && !prefixToIriMapping.get(candidate).equals(namespace)) { candidate = base + (++i); } @@ -899,7 +897,7 @@ private String escapeTurtleLiteral(String value) { * @return The escaped string suitable for a multi-line Turtle literal. */ private String escapeMultilineLiteral(String value) { - // In multi-line literals, only triple quotes need to be escaped + return value.replace(SerializationConstants.QUOTE + SerializationConstants.QUOTE + SerializationConstants.QUOTE, SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + From ef539be49281ffb7f0e2e1b28eb1ac0900fb8319 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Thu, 19 Jun 2025 10:29:30 +0200 Subject: [PATCH 05/27] Create Trig Serializer --- .../core/next/impl/common/serialization/RdfFormat.java | 9 ++++++++- .../core/next/impl/common/serialization/Serializer.java | 2 ++ .../core/next/impl/common/serialization/TriGFormat.java | 4 ++++ 3 files changed, 14 insertions(+), 1 deletion(-) create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/RdfFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/RdfFormat.java index fbea74d93..98dc9171d 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/RdfFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/RdfFormat.java @@ -52,6 +52,13 @@ public class RdfFormat extends FileFormat { true, false); + public static final RdfFormat TRIG = new RdfFormat( + "TriG", + List.of("trig"), + List.of("application/trig"), + true, + true); + /** * Constructs a new RDF format. * @@ -138,7 +145,7 @@ public static Optional byMimeType(String mimeType) { * @return An unmodifiable List of all RdfFormat constants. */ public static List all() { - return List.of(TURTLE, NTRIPLES, NQUADS, JSONLD, RDFXML); + return List.of(TURTLE, NTRIPLES, NQUADS, JSONLD, RDFXML, TRIG); } @Override diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java index d2138edb0..1871d8302 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java @@ -41,6 +41,8 @@ public void serialize(Writer writer, RdfFormat format) throws SerializationExcep formatSerializer = new NQuadsFormat(model, config); } else if (format.equals(RdfFormat.TURTLE)) { formatSerializer = new TurtleFormat(model, config); + } else if (format.equals(RdfFormat.TRIG)) { + formatSerializer = new TriGFormat(model, config); } else if (format.equals(RdfFormat.JSONLD)) { throw new UnsupportedOperationException("Serialization to " + format.getName() + " format is not yet implemented."); } else if (format.equals(RdfFormat.RDFXML)) { diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java new file mode 100644 index 000000000..4b4ce683d --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +public class TriGFormat { +} From 516aa3b9f3122fe4f85e257da4fcb6a999db2892 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Thu, 19 Jun 2025 13:40:34 +0200 Subject: [PATCH 06/27] =?UTF-8?q?ajout=C3=A9=20les=20tests=20unitaires=20p?= =?UTF-8?q?our=20Turtle=20et=20r=C3=A9organis=C3=A9=20le=20fichier=20de=20?= =?UTF-8?q?configuration?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../common/serialization/NQuadsFormat.java | 2 + .../common/serialization/NTriplesFormat.java | 2 + .../impl/common/serialization/Serializer.java | 1 + .../common/serialization/TurtleFormat.java | 4 + .../{ => config}/BlankNodeStyleEnum.java | 2 +- .../{ => config}/FormatConfig.java | 2 +- .../LiteralDatatypePolicyEnum.java | 2 +- .../{ => config}/PrefixOrderingEnum.java | 2 +- .../common/util/SerializationConstants.java | 6 +- .../serialization/FormatConfigTest.java | 4 + .../serialization/NQuadsFormatTest.java | 1 + .../serialization/NTriplesFormatTest.java | 1 + .../common/serialization/RdfFormatTest.java | 15 +- .../common/serialization/SerializerTest.java | 30 +- .../common/serialization/TriGFormatTest.java | 786 ++++++++++++++++++ 15 files changed, 852 insertions(+), 8 deletions(-) rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/{ => config}/BlankNodeStyleEnum.java (82%) rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/{ => config}/FormatConfig.java (99%) rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/{ => config}/LiteralDatatypePolicyEnum.java (86%) rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/{ => config}/PrefixOrderingEnum.java (86%) create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java index 9895e2e36..9b1dd9878 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java @@ -1,6 +1,8 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java index b94c8a38e..d165e391f 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java @@ -1,6 +1,8 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java index 1871d8302..9783a0c59 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java @@ -2,6 +2,7 @@ import fr.inria.corese.core.next.api.FormatSerializer; import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.exception.SerializationException; import java.io.Writer; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java index 0c8fe0d36..15f38c241 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java @@ -1,6 +1,10 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/BlankNodeStyleEnum.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/BlankNodeStyleEnum.java similarity index 82% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/BlankNodeStyleEnum.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/BlankNodeStyleEnum.java index eab5e23e0..ef04f0744 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/BlankNodeStyleEnum.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/BlankNodeStyleEnum.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.serialization; +package fr.inria.corese.core.next.impl.common.serialization.config; /** * Defines the style for serializing blank nodes. diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java similarity index 99% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java index c5e9bd650..daca8e4f0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.serialization; +package fr.inria.corese.core.next.impl.common.serialization.config; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/LiteralDatatypePolicyEnum.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/LiteralDatatypePolicyEnum.java similarity index 86% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/LiteralDatatypePolicyEnum.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/LiteralDatatypePolicyEnum.java index 3ad06e788..b79a60eb0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/LiteralDatatypePolicyEnum.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/LiteralDatatypePolicyEnum.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.serialization; +package fr.inria.corese.core.next.impl.common.serialization.config; /** * Defines the policy for serializing literal datatypes. diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/PrefixOrderingEnum.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/PrefixOrderingEnum.java similarity index 86% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/PrefixOrderingEnum.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/PrefixOrderingEnum.java index e69d0f075..76f0aa6c1 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/PrefixOrderingEnum.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/PrefixOrderingEnum.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.serialization; +package fr.inria.corese.core.next.impl.common.serialization.config; /** * Defines the ordering policy for prefix declarations. diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java b/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java index a34177a7a..beac9b144 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java @@ -40,7 +40,7 @@ private SerializationConstants() { public static final String TAB = "\t"; public static final String LINE_FEED = "\n"; public static final String CARRIAGE_RETURN = "\r"; - public static final String NEWLINE = LINE_FEED; // Unix-style newline for general use + public static final String NEWLINE = LINE_FEED; public static final String POINT = "."; public static final String SEMICOLON = ";"; @@ -74,4 +74,8 @@ private SerializationConstants() { public static final String EMPTY_STRING = ""; + // TriG-specific + public static final String OPEN_BRACE = "{"; + public static final String CLOSE_BRACE = "}"; + } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java index cb2b94616..3d0a0e8c3 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java @@ -1,5 +1,9 @@ package fr.inria.corese.core.next.impl.common.serialization; +import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java index b6c2f2d67..7756f92d6 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java index 860e61ac3..e127f5a7f 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/RdfFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/RdfFormatTest.java index 8f0df66d0..28f5da4b1 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/RdfFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/RdfFormatTest.java @@ -219,6 +219,18 @@ void rdfXmlConstant() { assertFalse(rdfxml.supportsNamedGraphs()); } + @Test + @DisplayName("TRIG constant should be correctly defined") + void trigConstant() { + RdfFormat trig = RdfFormat.TRIG; + + assertNotNull(trig, "TRIG constant should not be null"); + assertEquals("TriG", trig.getName()); + assertTrue(trig.getExtensions().contains("trig")); + assertTrue(trig.getMimeTypes().contains("application/trig")); + assertTrue(trig.supportsNamespaces()); + assertTrue(trig.supportsNamedGraphs()); + } @Test @DisplayName("byName() should find existing format by name (case-insensitive)") @@ -286,13 +298,14 @@ void allFormats() { List allFormats = RdfFormat.all(); assertNotNull(allFormats, "List of all formats should not be null"); - assertEquals(5, allFormats.size(), "List should contain 5 predefined formats"); // TURTLE, NTRIPLES, NQUADS, JSONLD, RDFXML + assertEquals(6, allFormats.size(), "List should contain 5 predefined formats"); // TURTLE, NTRIPLES, NQUADS, JSONLD, RDFXML, TRIG assertTrue(allFormats.contains(RdfFormat.TURTLE)); assertTrue(allFormats.contains(RdfFormat.NTRIPLES)); assertTrue(allFormats.contains(RdfFormat.NQUADS)); assertTrue(allFormats.contains(RdfFormat.JSONLD)); assertTrue(allFormats.contains(RdfFormat.RDFXML)); + assertTrue(allFormats.contains(RdfFormat.TRIG)); assertThrows(UnsupportedOperationException.class, () -> allFormats.add(RdfFormat.TURTLE), "The list returned by all() should be unmodifiable"); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerTest.java index 0e8700810..1fefad379 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerTest.java @@ -7,6 +7,9 @@ import java.io.Writer; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -14,8 +17,6 @@ import org.mockito.MockedConstruction; import org.mockito.MockitoAnnotations; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.impl.exception.SerializationException; class SerializerTest { @@ -95,4 +96,29 @@ void serializeShouldDelegateToNQuadsFormat() throws SerializationException { } } + @Test + @DisplayName("serialize should delegate to TurtleFormat for TURTLE format") + void serializeShouldDelegateToTurtleFormat() throws SerializationException { + try (MockedConstruction mockedTurtleConstructor = mockConstruction(TurtleFormat.class)) { + serializer.serialize(mockWriter, RdfFormat.TURTLE); + + assertEquals(1, mockedTurtleConstructor.constructed().size(), "TurtleFormat constructor should be called once"); + TurtleFormat createdTurtleSerializer = mockedTurtleConstructor.constructed().get(0); + + verify(createdTurtleSerializer).write(mockWriter); + } + } + + @Test + @DisplayName("serialize should delegate to TriGFormat for TRIG format") + void serializeShouldDelegateToTriGFormat() throws SerializationException { + try (MockedConstruction mockedTriGConstructor = mockConstruction(TriGFormat.class)) { + serializer.serialize(mockWriter, RdfFormat.TRIG); + + assertEquals(1, mockedTriGConstructor.constructed().size(), "TriGFormat constructor should be called once"); + TriGFormat createdTriGSerializer = mockedTriGConstructor.constructed().get(0); + + verify(createdTriGSerializer).write(mockWriter); + } + } } \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java new file mode 100644 index 000000000..922a4f97b --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java @@ -0,0 +1,786 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.io.StringWriter; +import java.util.*; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.*; + +/** + * Test class for {@link TriGFormat} using Mockito to verify serialization behavior + * under various configurations and RDF graph structures. + */ +class TriGFormatTest { + + /** + * Tests basic TriG serialization of a simple triple. + * Verifies that the subject, predicate, and object are correctly formatted + * and that standard prefixes are declared and used. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testBasicTriGSerialization() throws SerializationException, IOException { + // Given + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + + when(mockSubject.stringValue()).thenReturn("http://example.org/ns/person1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/ns/hasName"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + + when(mockObject.stringValue()).thenReturn("John Doe"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(null); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + StringWriter writer = new StringWriter(); + + TriGFormat trigFormat = new TriGFormat(mockModel, FormatConfig.trigConfig()); + + + trigFormat.write(writer); + + + verify(mockModel, times(2)).stream(); + verify(mockSubject, atLeastOnce()).stringValue(); + verify(mockSubject, atLeastOnce()).isIRI(); + verify(mockPredicate, atLeastOnce()).stringValue(); + verify(mockPredicate, atLeastOnce()).isIRI(); + verify(mockObject, atLeastOnce()).stringValue(); + verify(mockObject, atLeastOnce()).isLiteral(); + + + String expected = """ + @prefix ns: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + ns:person1 ns:hasName "John Doe" . + + """; + + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests the `rdf:type` shortcut (using `a`). + * Verifies that `rdf:type` is serialized as `a` when the option is enabled. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testRdfTypeShortcut() throws SerializationException, IOException { + + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + IRI mockObject = mock(IRI.class); + + when(mockSubject.stringValue()).thenReturn("http://example.org/ns/person1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + when(mockPredicate.stringValue()).thenReturn(SerializationConstants.RDF_TYPE); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + when(mockObject.stringValue()).thenReturn("http://xmlns.com/foaf/0.1/Person"); + when(mockObject.isIRI()).thenReturn(true); + when(mockObject.isResource()).thenReturn(true); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.isLiteral()).thenReturn(false); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + StringWriter writer = new StringWriter(); + TriGFormat trigFormat = new TriGFormat(mockModel); + + + trigFormat.write(writer); + + + verify(mockModel, times(2)).stream(); + + String expected = """ + @prefix foaf: . + @prefix ns: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + ns:person1 a foaf:Person . + + """; + + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests serialization of a literal with a language tag. + * Verifies that the language tag is appended correctly. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testLiteralWithLanguageTag() throws SerializationException, IOException { + + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + + when(mockSubject.stringValue()).thenReturn("http://example.org/data/book1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://purl.org/dc/elements/1.1/title"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + when(mockObject.stringValue()).thenReturn("The Odyssey"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.of("en")); + + IRI mockRdfLangString = mock(IRI.class); + when(mockRdfLangString.stringValue()).thenReturn(SerializationConstants.RDF_LANGSTRING); + when(mockRdfLangString.isIRI()).thenReturn(true); + when(mockRdfLangString.isResource()).thenReturn(true); + when(mockObject.getDatatype()).thenReturn(mockRdfLangString); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + + // Explicitly create FormatConfig to ensure strictMode is false + Map commonTriGPrefixes = new HashMap<>(); + commonTriGPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + commonTriGPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + commonTriGPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); + commonTriGPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + + FormatConfig config = new FormatConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) + .useRdfTypeShortcut(true) + .useCollections(true) + .groupBySubject(true) + .prettyPrint(true) + .indent(" ") + .lineEnding("\n") + .addCustomPrefixes(commonTriGPrefixes) + .autoDeclarePrefixes(true) + .trailingDot(true) + .strictMode(false) + .build(); + TriGFormat trigFormat = new TriGFormat(mockModel, config); + + + trigFormat.write(writer); + + + verify(mockModel, times(2)).stream(); + String expected = """ + @prefix 11: . + @prefix data: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + data:book1 11:title \"The Odyssey\"@en . + """; + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests serialization of a literal with an explicit `xsd:string` datatype. + * Verifies that the datatype is printed when `ALWAYS_TYPED` policy is used. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testLiteralWithExplicitXsdStringType() throws SerializationException, IOException { + // Given + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + IRI mockDatatype = mock(IRI.class); + + // Configure mocks + when(mockSubject.stringValue()).thenReturn("http://example.org/data/book2"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://purl.org/dc/elements/1.1/creator"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + when(mockDatatype.stringValue()).thenReturn(SerializationConstants.XSD_STRING); + when(mockDatatype.isIRI()).thenReturn(true); + when(mockDatatype.isResource()).thenReturn(true); + + when(mockObject.stringValue()).thenReturn("Homer"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(mockDatatype); + + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + + Map commonTrigPrefixes = new HashMap<>(); + commonTrigPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + commonTrigPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + commonTrigPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); + commonTrigPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + commonTrigPrefixes.put("dc", "http://purl.org/dc/elements/1.1/"); + + FormatConfig config = new FormatConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) + .addCustomPrefixes(commonTrigPrefixes) + .usePrefixes(true) + .autoDeclarePrefixes(true) + .build(); + TriGFormat triGFormat = new TriGFormat(mockModel, config); + + + triGFormat.write(writer); + + + verify(mockModel, times(2)).stream(); + String expected = """ + @prefix data: . + @prefix dc: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + data:book2 dc:creator \"Homer\"^^xsd:string . + """; + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + + /** + * Tests serialization with a base IRI defined. + * Verifies that the `@base` directive is included in the output. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testBaseIRI() throws SerializationException, IOException { + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + when(mockSubject.stringValue()).thenReturn("http://example.org/base/resource1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/base/prop"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + + when(mockObject.stringValue()).thenReturn("Test"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(null); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + + Map commonTrigPrefixes = new HashMap<>(); + commonTrigPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + commonTrigPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + commonTrigPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); + commonTrigPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + commonTrigPrefixes.put("base", "http://example.org/base/"); + + FormatConfig configWithBase = new FormatConfig.Builder() + .baseIRI("http://example.org/base/") + .addCustomPrefixes(commonTrigPrefixes) + .usePrefixes(true) + .autoDeclarePrefixes(true) + .build(); + TriGFormat trigFormat = new TriGFormat(mockModel, configWithBase); + + trigFormat.write(writer); + + verify(mockModel, times(2)).stream(); + String expected = """ + @base . + @prefix base: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + base:resource1 base:prop "Test" . + """; + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests serialization of an empty model. + * Verifies that only prefix declarations (if auto-declared) are written, with no statements. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testEmptyModel() throws SerializationException, IOException { + + Model emptyModel = mock(Model.class); + when(emptyModel.iterator()).thenAnswer(invocation -> Collections.emptyList().iterator()); + when(emptyModel.stream()) + .thenReturn(Stream.empty()) + .thenReturn(Stream.empty()); + + + StringWriter writer = new StringWriter(); + TriGFormat triGFormat = new TriGFormat(emptyModel); + + + triGFormat.write(writer); + + + verify(emptyModel, times(2)).stream(); + + String expected = """ + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + """; + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests strict mode validation for an invalid literal (rdf:langString without language tag). + * Verifies that a {@link SerializationException} is thrown. + * + * @throws SerializationException (expected) if a serialization error occurs due to strict mode. + */ + @Test + void testStrictModeInvalidLiteral() throws SerializationException { + + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + when(mockSubject.stringValue()).thenReturn("http://example.org/s"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/p"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + when(mockObject.stringValue()).thenReturn("invalid"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + IRI mockRdfLangStringDatatype = mock(IRI.class); + when(mockRdfLangStringDatatype.stringValue()).thenReturn(SerializationConstants.RDF_LANGSTRING); + when(mockRdfLangStringDatatype.isIRI()).thenReturn(true); + when(mockRdfLangStringDatatype.isResource()).thenReturn(true); + when(mockObject.getDatatype()).thenReturn(mockRdfLangStringDatatype); + + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).build(); + TriGFormat triGFormat = new TriGFormat(mockModel, strictConfig); + + + SerializationException thrown = assertThrows(SerializationException.class, () -> { + triGFormat.write(writer); + }); + + assertEquals("TriG", thrown.getFormatName()); + + assertEquals("Invalid data for TriG format: An rdf:langString literal must have a language tag. [Format: TriG]", thrown.getMessage()); + } + + /** + * Tests strict mode validation for an IRI containing invalid characters (e.g., space). + * Verifies that a {@link SerializationException} is thrown. + * + * @throws SerializationException (expected) if a serialization error occurs due to strict mode. + */ + @Test + void testStrictModeInvalidIRICharacters() throws SerializationException { + + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + IRI mockObject = mock(IRI.class); + + + when(mockSubject.stringValue()).thenReturn("http://example.org/s"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/p"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + + when(mockObject.stringValue()).thenReturn("http://example.org/invalid iri"); + when(mockObject.isIRI()).thenReturn(true); + when(mockObject.isResource()).thenReturn(true); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.isLiteral()).thenReturn(false); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).validateURIs(true).build(); + TriGFormat triGFormat = new TriGFormat(mockModel, strictConfig); + + + SerializationException thrown = assertThrows(SerializationException.class, () -> { + triGFormat.write(writer); + }); + + assertEquals("TriG", thrown.getFormatName()); + + assertEquals("Invalid data for TriG format: IRI contains illegal characters (space, quotes, angle brackets) for unescaped TriG form: http://example.org/invalid iri [Format: TriG]", thrown.getMessage()); + } + + /** + * Tests serialization of a literal containing multiple lines. + * Verifies that the literal is wrapped in triple quotes `"""` when `useMultilineLiterals` is true. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testMultilineLiteralSerialization() throws SerializationException, IOException { + // Given + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + + when(mockSubject.stringValue()).thenReturn("http://example.org/book/1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/properties/description"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + String multilineText = "This is the first line.\nThis is the second line."; + when(mockObject.stringValue()).thenReturn(multilineText); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(null); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + StringWriter writer = new StringWriter(); + FormatConfig config = new FormatConfig.Builder() + .useMultilineLiterals(true) + .prettyPrint(true) + .autoDeclarePrefixes(true) + .build(); + TriGFormat triGFormat = new TriGFormat(mockModel, config); + + + triGFormat.write(writer); + + + verify(mockModel, times(2)).stream(); + verify(mockSubject, atLeastOnce()).stringValue(); + verify(mockSubject, atLeastOnce()).isIRI(); + verify(mockPredicate, atLeastOnce()).stringValue(); + verify(mockPredicate, atLeastOnce()).isIRI(); + verify(mockObject, atLeastOnce()).stringValue(); + verify(mockObject, atLeastOnce()).isLiteral(); + + String expected = """ + @prefix book: . + @prefix properties: . + + book:1 properties:description \"\"\"This is the first line. + This is the second line.\"\"\" . + """; + + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests basic TriG serialization with a named graph. + * Verifies that the graph name and graph block are correctly formatted. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testBasicTrigSerializationWithNamedGraph() throws SerializationException, IOException { + // Given + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + IRI mockContext = mock(IRI.class); + + + when(mockSubject.stringValue()).thenReturn("http://example.org/data/person1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/data/name"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + + when(mockObject.stringValue()).thenReturn("Alice"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(null); + + + when(mockContext.stringValue()).thenReturn("http://example.org/graph/g1"); + when(mockContext.isIRI()).thenReturn(true); + when(mockContext.isResource()).thenReturn(true); + when(mockContext.isBNode()).thenReturn(false); + when(mockContext.isLiteral()).thenReturn(false); + + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(mockContext); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + StringWriter writer = new StringWriter(); + + TriGFormat trigFormat = new TriGFormat(mockModel, FormatConfig.trigConfig()); + + + trigFormat.write(writer); + + + verify(mockModel, times(2)).stream(); + verify(mockSubject, atLeastOnce()).stringValue(); + verify(mockSubject, atLeastOnce()).isIRI(); + verify(mockPredicate, atLeastOnce()).stringValue(); + verify(mockPredicate, atLeastOnce()).isIRI(); + verify(mockObject, atLeastOnce()).stringValue(); + verify(mockObject, atLeastOnce()).isLiteral(); + verify(mockContext, atLeastOnce()).stringValue(); + verify(mockContext, atLeastOnce()).isIRI(); + + String expected = """ + @prefix data: . + @prefix graph: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + graph:g1 { + data:person1 data:name "Alice" . + } . + + """; + + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } +} From 0287b2bb2fcbfe86a2215d6336a01f5c57405522 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Thu, 19 Jun 2025 13:41:24 +0200 Subject: [PATCH 07/27] =?UTF-8?q?ajout=C3=A9=20les=20tests=20unitaires=20p?= =?UTF-8?q?our=20Turtle?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../serialization/TurtleFormatTest.java | 790 +++++++++++++++++- 1 file changed, 789 insertions(+), 1 deletion(-) diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java index e87078991..f3a83a29a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java @@ -1,4 +1,792 @@ package fr.inria.corese.core.next.impl.common.serialization; -public class TurtleFormatTest { +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.io.StringWriter; +import java.util.*; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.*; + +/** + * Test class for {@link TurtleFormat} using Mockito to verify serialization behavior + * under various configurations and RDF graph structures. + */ +class TurtleFormatTest { + + /** + * Tests basic Turtle serialization of a simple triple. + * Verifies that the subject, predicate, and object are correctly formatted + * and that standard prefixes are declared and used. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testBasicTurtleSerialization() throws SerializationException, IOException { + // Given + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + // Configure mocks for the subject + when(mockSubject.stringValue()).thenReturn("http://example.org/ns/person1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + // Configure mocks for the predicate + when(mockPredicate.stringValue()).thenReturn("http://example.org/ns/hasName"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + // Configure mocks for the object (literal) + when(mockObject.stringValue()).thenReturn("John Doe"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(null); + + // Configure the statement + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + StringWriter writer = new StringWriter(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel, FormatConfig.turtleConfig()); + + // When + turtleFormat.write(writer); + + // Then + verify(mockModel, times(2)).stream(); + verify(mockSubject, atLeastOnce()).stringValue(); + verify(mockSubject, atLeastOnce()).isIRI(); + verify(mockPredicate, atLeastOnce()).stringValue(); + verify(mockPredicate, atLeastOnce()).isIRI(); + verify(mockObject, atLeastOnce()).stringValue(); + verify(mockObject, atLeastOnce()).isLiteral(); + + + String expected = """ + @prefix ns: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + ns:person1 ns:hasName "John Doe" . + """; + + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests the `rdf:type` shortcut (using `a`). + * Verifies that `rdf:type` is serialized as `a` when the option is enabled. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testRdfTypeShortcut() throws SerializationException, IOException { + // Given + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + IRI mockObject = mock(IRI.class); + + // Configure mocks + when(mockSubject.stringValue()).thenReturn("http://example.org/ns/person1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + when(mockPredicate.stringValue()).thenReturn(SerializationConstants.RDF_TYPE); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + when(mockObject.stringValue()).thenReturn("http://xmlns.com/foaf/0.1/Person"); + when(mockObject.isIRI()).thenReturn(true); + when(mockObject.isResource()).thenReturn(true); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.isLiteral()).thenReturn(false); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + StringWriter writer = new StringWriter(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel); + + // When + turtleFormat.write(writer); + + // Then + verify(mockModel, times(2)).stream(); + + String expected = """ + @prefix foaf: . + @prefix ns: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + ns:person1 a foaf:Person . + """; + + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests serialization of a literal with a language tag. + * Verifies that the language tag is appended correctly. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testLiteralWithLanguageTag() throws SerializationException, IOException { + + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + + when(mockSubject.stringValue()).thenReturn("http://example.org/data/book1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://purl.org/dc/elements/1.1/title"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + when(mockObject.stringValue()).thenReturn("The Odyssey"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.of("en")); + + IRI mockRdfLangString = mock(IRI.class); + when(mockRdfLangString.stringValue()).thenReturn(SerializationConstants.RDF_LANGSTRING); + when(mockRdfLangString.isIRI()).thenReturn(true); + when(mockRdfLangString.isResource()).thenReturn(true); + when(mockObject.getDatatype()).thenReturn(mockRdfLangString); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + + // Explicitly create FormatConfig to ensure strictMode is false + Map commonTurtlePrefixes = new HashMap<>(); + commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); + commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + + FormatConfig config = new FormatConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) + .useRdfTypeShortcut(true) + .useCollections(true) + .groupBySubject(true) + .prettyPrint(true) + .indent(" ") + .lineEnding("\n") + .addCustomPrefixes(commonTurtlePrefixes) + .autoDeclarePrefixes(true) + .trailingDot(true) + .strictMode(false) + .build(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel, config); + + // When + turtleFormat.write(writer); + + // Then + verify(mockModel, times(2)).stream(); + String expected = """ + @prefix 11: . + @prefix data: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + data:book1 11:title \"The Odyssey\"@en . + """; + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests serialization of a literal with an explicit `xsd:string` datatype. + * Verifies that the datatype is printed when `ALWAYS_TYPED` policy is used. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testLiteralWithExplicitXsdStringType() throws SerializationException, IOException { + // Given + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + IRI mockDatatype = mock(IRI.class); + + // Configure mocks + when(mockSubject.stringValue()).thenReturn("http://example.org/data/book2"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://purl.org/dc/elements/1.1/creator"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + when(mockDatatype.stringValue()).thenReturn(SerializationConstants.XSD_STRING); + when(mockDatatype.isIRI()).thenReturn(true); + when(mockDatatype.isResource()).thenReturn(true); + + when(mockObject.stringValue()).thenReturn("Homer"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(mockDatatype); + + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + + Map commonTurtlePrefixes = new HashMap<>(); + commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); + commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + commonTurtlePrefixes.put("dc", "http://purl.org/dc/elements/1.1/"); + + FormatConfig config = new FormatConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) + .addCustomPrefixes(commonTurtlePrefixes) + .usePrefixes(true) + .autoDeclarePrefixes(true) + .build(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel, config); + + // When + turtleFormat.write(writer); + + // Then + verify(mockModel, times(2)).stream(); + String expected = """ + @prefix data: . + @prefix dc: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + data:book2 dc:creator \"Homer\"^^xsd:string . + """; + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests serialization of a blank node subject using the default anonymous style (`[]`). + * Verifies that the blank node is serialized inline with its properties. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testBlankNodeSerialization() throws SerializationException, IOException { + Model mockModel = mock(Model.class); + + Resource mockBNode = mock(Resource.class); + IRI mockBNodeProperty = mock(IRI.class); + Literal mockBNodeObject = mock(Literal.class); + + + IRI mockMainSubject = mock(IRI.class); + IRI mockMainPredicate = mock(IRI.class); + Statement mainStatement = mock(Statement.class); + + + Statement bNodePropertyStatement = mock(Statement.class); + + + when(mockBNode.stringValue()).thenReturn("b1"); + when(mockBNode.isBNode()).thenReturn(true); + when(mockBNode.isResource()).thenReturn(true); + when(mockBNode.isIRI()).thenReturn(false); + when(mockBNode.isLiteral()).thenReturn(false); + + when(mockBNodeProperty.stringValue()).thenReturn("http://example.org/ns/hasValue"); + when(mockBNodeProperty.isIRI()).thenReturn(true); + when(mockBNodeProperty.isResource()).thenReturn(true); + when(mockBNodeProperty.isBNode()).thenReturn(false); + when(mockBNodeProperty.isLiteral()).thenReturn(false); + + when(mockBNodeObject.stringValue()).thenReturn("Value of BNode"); + when(mockBNodeObject.isLiteral()).thenReturn(true); + when(mockBNodeObject.isIRI()).thenReturn(false); + when(mockBNodeObject.isResource()).thenReturn(false); + when(mockBNodeObject.isBNode()).thenReturn(false); + when(mockBNodeObject.getLanguage()).thenReturn(Optional.empty()); + when(mockBNodeObject.getDatatype()).thenReturn(null); + + + when(bNodePropertyStatement.getSubject()).thenReturn(mockBNode); + when(bNodePropertyStatement.getPredicate()).thenReturn(mockBNodeProperty); + when(bNodePropertyStatement.getObject()).thenReturn(mockBNodeObject); + when(bNodePropertyStatement.getContext()).thenReturn(null); + + + when(mockMainSubject.stringValue()).thenReturn("http://example.org/ns/mainSubject"); + when(mockMainSubject.isIRI()).thenReturn(true); + when(mockMainSubject.isResource()).thenReturn(true); + when(mockMainSubject.isBNode()).thenReturn(false); + when(mockMainSubject.isLiteral()).thenReturn(false); + + when(mockMainPredicate.stringValue()).thenReturn("http://example.org/ns/refersTo"); + when(mockMainPredicate.isIRI()).thenReturn(true); + when(mockMainPredicate.isResource()).thenReturn(true); + when(mockMainPredicate.isBNode()).thenReturn(false); + when(mockMainPredicate.isLiteral()).thenReturn(false); + + when(mainStatement.getSubject()).thenReturn(mockMainSubject); + when(mainStatement.getPredicate()).thenReturn(mockMainPredicate); + when(mainStatement.getObject()).thenReturn(mockBNode); + when(mainStatement.getContext()).thenReturn(null); + + + when(mockModel.iterator()).thenAnswer(invocation -> Arrays.asList(mainStatement, bNodePropertyStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)) + .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)) + .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)) + .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)) + .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)); + + + StringWriter writer = new StringWriter(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel, FormatConfig.turtleConfig()); + + turtleFormat.write(writer); + + + verify(mockModel, times(5)).stream(); + + String expected = """ + @prefix ns: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + ns:mainSubject ns:refersTo [ + ns:hasValue "Value of BNode" + ] . + """; + + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests serialization with a base IRI defined. + * Verifies that the `@base` directive is included in the output. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testBaseIRI() throws SerializationException, IOException { + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + when(mockSubject.stringValue()).thenReturn("http://example.org/base/resource1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/base/prop"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + + when(mockObject.stringValue()).thenReturn("Test"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(null); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + + Map commonTurtlePrefixes = new HashMap<>(); + commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); + commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); + commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); + commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); + commonTurtlePrefixes.put("base", "http://example.org/base/"); + + FormatConfig configWithBase = new FormatConfig.Builder() + .baseIRI("http://example.org/base/") + .addCustomPrefixes(commonTurtlePrefixes) + .usePrefixes(true) + .autoDeclarePrefixes(true) + .build(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel, configWithBase); + + turtleFormat.write(writer); + + verify(mockModel, times(2)).stream(); + String expected = """ + @base . + @prefix base: . + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + base:resource1 base:prop "Test" . + """; + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests serialization of an empty model. + * Verifies that only prefix declarations (if auto-declared) are written, with no statements. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testEmptyModel() throws SerializationException, IOException { + + Model emptyModel = mock(Model.class); + when(emptyModel.iterator()).thenAnswer(invocation -> Collections.emptyList().iterator()); + when(emptyModel.stream()) + .thenReturn(Stream.empty()) + .thenReturn(Stream.empty()); + + + StringWriter writer = new StringWriter(); + TurtleFormat turtleFormat = new TurtleFormat(emptyModel); + + + turtleFormat.write(writer); + + + verify(emptyModel, times(2)).stream(); + + String expected = """ + @prefix owl: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . + + """; + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } + + /** + * Tests strict mode validation for an invalid literal (rdf:langString without language tag). + * Verifies that a {@link SerializationException} is thrown. + * + * @throws SerializationException (expected) if a serialization error occurs due to strict mode. + */ + @Test + void testStrictModeInvalidLiteral() throws SerializationException { + + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + when(mockSubject.stringValue()).thenReturn("http://example.org/s"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/p"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + when(mockObject.stringValue()).thenReturn("invalid"); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + IRI mockRdfLangStringDatatype = mock(IRI.class); + when(mockRdfLangStringDatatype.stringValue()).thenReturn(SerializationConstants.RDF_LANGSTRING); + when(mockRdfLangStringDatatype.isIRI()).thenReturn(true); + when(mockRdfLangStringDatatype.isResource()).thenReturn(true); + when(mockObject.getDatatype()).thenReturn(mockRdfLangStringDatatype); + + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).build(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel, strictConfig); + + + SerializationException thrown = assertThrows(SerializationException.class, () -> { + turtleFormat.write(writer); + }); + + assertEquals("Turtle", thrown.getFormatName()); + + assertEquals("Invalid data for Turtle format: An rdf:langString literal must have a language tag. [Format: Turtle]", thrown.getMessage()); + } + + /** + * Tests strict mode validation for an IRI containing invalid characters (e.g., space). + * Verifies that a {@link SerializationException} is thrown. + * + * @throws SerializationException (expected) if a serialization error occurs due to strict mode. + */ + @Test + void testStrictModeInvalidIRICharacters() throws SerializationException { + + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + IRI mockObject = mock(IRI.class); // Invalid IRI + + + when(mockSubject.stringValue()).thenReturn("http://example.org/s"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + + when(mockPredicate.stringValue()).thenReturn("http://example.org/p"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + + when(mockObject.stringValue()).thenReturn("http://example.org/invalid iri"); // Contains a space + when(mockObject.isIRI()).thenReturn(true); + when(mockObject.isResource()).thenReturn(true); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.isLiteral()).thenReturn(false); + + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + + StringWriter writer = new StringWriter(); + FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).validateURIs(true).build(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel, strictConfig); + + + SerializationException thrown = assertThrows(SerializationException.class, () -> { + turtleFormat.write(writer); + }); + + assertEquals("Turtle", thrown.getFormatName()); + + assertEquals("Invalid data for Turtle format: IRI contains illegal characters (space, quotes, angle brackets) for unescaped Turtle form: http://example.org/invalid iri [Format: Turtle]", thrown.getMessage()); + } + + /** + * Tests serialization of a literal containing multiple lines. + * Verifies that the literal is wrapped in triple quotes `"""` when `useMultilineLiterals` is true. + * + * @throws SerializationException if a serialization error occurs. + * @throws IOException if an I/O error occurs during writing. + */ + @Test + void testMultilineLiteralSerialization() throws SerializationException, IOException { + // Given + Model mockModel = mock(Model.class); + Statement mockStatement = mock(Statement.class); + IRI mockSubject = mock(IRI.class); + IRI mockPredicate = mock(IRI.class); + Literal mockObject = mock(Literal.class); + + when(mockSubject.stringValue()).thenReturn("http://example.org/book/1"); + when(mockSubject.isIRI()).thenReturn(true); + when(mockSubject.isResource()).thenReturn(true); + when(mockSubject.isBNode()).thenReturn(false); + when(mockSubject.isLiteral()).thenReturn(false); + + when(mockPredicate.stringValue()).thenReturn("http://example.org/properties/description"); + when(mockPredicate.isIRI()).thenReturn(true); + when(mockPredicate.isResource()).thenReturn(true); + when(mockPredicate.isBNode()).thenReturn(false); + when(mockPredicate.isLiteral()).thenReturn(false); + + String multilineText = "This is the first line.\nThis is the second line."; + when(mockObject.stringValue()).thenReturn(multilineText); + when(mockObject.isLiteral()).thenReturn(true); + when(mockObject.isIRI()).thenReturn(false); + when(mockObject.isResource()).thenReturn(false); + when(mockObject.isBNode()).thenReturn(false); + when(mockObject.getLanguage()).thenReturn(Optional.empty()); + when(mockObject.getDatatype()).thenReturn(null); // Assuming no specific datatype for simplicity + + // Configure the statement + when(mockStatement.getSubject()).thenReturn(mockSubject); + when(mockStatement.getPredicate()).thenReturn(mockPredicate); + when(mockStatement.getObject()).thenReturn(mockObject); + when(mockStatement.getContext()).thenReturn(null); + + when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); + when(mockModel.stream()) + .thenReturn(Stream.of(mockStatement)) + .thenReturn(Stream.of(mockStatement)); + + StringWriter writer = new StringWriter(); + // Configure FormatConfig to enable multiline literals + FormatConfig config = new FormatConfig.Builder() + .useMultilineLiterals(true) + .prettyPrint(true) + .autoDeclarePrefixes(true) + .build(); + TurtleFormat turtleFormat = new TurtleFormat(mockModel, config); + + // When + turtleFormat.write(writer); + + // Then + verify(mockModel, times(2)).stream(); + verify(mockSubject, atLeastOnce()).stringValue(); + verify(mockSubject, atLeastOnce()).isIRI(); + verify(mockPredicate, atLeastOnce()).stringValue(); + verify(mockPredicate, atLeastOnce()).isIRI(); + verify(mockObject, atLeastOnce()).stringValue(); + verify(mockObject, atLeastOnce()).isLiteral(); + + // Corrected expected string + String expected = """ + @prefix book: . + @prefix properties: . + + book:1 properties:description \"\"\"This is the first line. + This is the second line.\"\"\" . + """; + + String actual = writer.toString().replace("\r\n", "\n"); + assertEquals(expected, actual); + } } From 09509b9d0529363bb2bd4ae0f876439c5cd0377b Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Thu, 19 Jun 2025 13:42:23 +0200 Subject: [PATCH 08/27] =?UTF-8?q?ajout=C3=A9=20les=20tests=20unitaires=20p?= =?UTF-8?q?our=20trig?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../impl/common/serialization/TriGFormat.java | 1082 ++++++++++++++++- 1 file changed, 1081 insertions(+), 1 deletion(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java index 4b4ce683d..8805d3b9e 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java @@ -1,4 +1,1084 @@ package fr.inria.corese.core.next.impl.common.serialization; -public class TriGFormat { +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; +import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.io.Writer; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.*; +import java.util.stream.Collectors; + +/** + * Serializes a {@link Model} to TriG format with comprehensive syntax support. + * This class provides a method to write the declarations of a model to a {@link Writer} + * in accordance with the TriG specification, taking into account configuration options. + * + *

This implementation handles:

+ *
    + *
  • Declaration and usage of prefixes for IRIs, including auto-declaration and sorting.
    • + *
  • The 'a' shortcut for 'rdf:type'.
    • + *
  • Escaping of special characters in literals (single-line and multi-line) and IRIs.
    • + *
  • Basic pretty-printing (indentation, end-of-line dots).
    • + *
  • Management of literal datatype policies (minimal or always typed).
    • + *
  • Serialization of compact triples (semicolons, commas) to group subjects and predicates.
    • + *
  • Serialization of nested blank nodes using the '[]' syntax.
    • + *
  • Serialization of RDF collections (lists) using the '()' syntax.
    • + *
  • Detection and prevention of infinite loops during serialization of nested blank nodes and lists.
    • + *
  • Sorting of subjects and predicates if configured.
    • + *
  • Serialization of named graphs using the `{}` syntax for TriG.
    • + *
+ *

Advanced features such as strict adherence to maximum line length + * and generation of stable blank node identifiers are not fully implemented in this version.

+ */ +public class TriGFormat implements FormatSerializer { + + /** + * Logger for this class, used to log potential issues or information during serialization. + */ + private static final Logger logger = LoggerFactory.getLogger(TriGFormat.class); + + private final Model model; + private final FormatConfig config; + private final Map iriToPrefixMapping; + private final Map prefixToIriMapping; + // Set to track blank nodes already serialized inline or as part of a list + private final Set consumedBlankNodes; + // Set to track blank nodes currently being serialized to detect cycles + private final Set currentlyWritingBlankNodes; + + /** + * Constructs a new {@code TriGFormat} instance with the specified model and default configuration. + * The default configuration is returned by {@link FormatConfig#trigConfig()}. + * + * @param model the {@link Model} to serialize. Must not be null. + * @throws NullPointerException if the provided model is null. + */ + public TriGFormat(Model model) { + this(model, FormatConfig.trigConfig()); + } + + /** + * Constructs a new {@code TriGFormat} instance with the specified model and custom configuration. + * + * @param model the {@link Model} to serialize. Must not be null. + * @param config the {@link FormatConfig} to use for serialization. Must not be null. + * @throws NullPointerException if the provided model or configuration is null. + */ + public TriGFormat(Model model, FormatConfig config) { + this.model = Objects.requireNonNull(model, "Model cannot be null"); + this.config = Objects.requireNonNull(config, "Configuration cannot be null"); + this.iriToPrefixMapping = new HashMap<>(); + this.prefixToIriMapping = new HashMap<>(); + this.consumedBlankNodes = new HashSet<>(); + this.currentlyWritingBlankNodes = new HashSet<>(); + initializePrefixes(); + } + + /** + * Initializes prefix mappings by adding custom prefixes from the configuration. + */ + private void initializePrefixes() { + if (config.usePrefixes()) { + for (Map.Entry entry : config.getCustomPrefixes().entrySet()) { + addPrefixMapping(entry.getValue(), entry.getKey()); + } + } + } + + /** + * Writes the model to the given writer in TriG format. + * + * @param writer the {@link Writer} to which the TriG output will be written. + * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + */ + @Override + public void write(Writer writer) throws SerializationException { + try { + writeHeader(writer); + + Set precomputedInlineBlankNodes = precomputeInlineBlankNodesAndLists(); + consumedBlankNodes.addAll(precomputedInlineBlankNodes); + + if (config.includeContext()) { + writeStatementsWithContext(writer); + } else if (config.useCompactTriples() && config.groupBySubject()) { + writeOptimizedStatements(writer); + } else { + writeSimpleStatements(writer); + } + + writer.flush(); + } catch (IOException e) { + throw new SerializationException("Failed to write to stream for TriG format", "TriG", e); + } catch (IllegalArgumentException e) { + throw new SerializationException("Invalid data for TriG format: " + e.getMessage(), "TriG", e); + } + } + + /** + * Writes the TriG document header, including base IRI declaration and prefixes. + * + * @param writer the {@link Writer} to which the header will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeHeader(Writer writer) throws IOException { + if (config.getBaseIRI() != null) { + writer.write(String.format("@base <%s> .%s", + config.getBaseIRI(), + config.getLineEnding())); + } + + if (config.usePrefixes() && config.autoDeclarePrefixes()) { + collectUsedNamespaces(); + } + + writePrefixDeclarations(writer); + } + + /** + * Collects all namespaces used in the model and attempts to assign prefixes to them + * if auto-declaration is enabled and they are not already mapped. + */ + private void collectUsedNamespaces() { + Set namespaces = model.stream() + .flatMap(stmt -> Arrays.asList( + stmt.getSubject(), + stmt.getPredicate(), + stmt.getObject(), + stmt.getContext() + ).stream()) + .filter(Objects::nonNull) + .filter(Value::isIRI) + .map(v -> getNamespace(v.stringValue())) + .collect(Collectors.toSet()); + + namespaces.forEach(namespace -> { + if (!iriToPrefixMapping.containsKey(namespace)) { + String prefix = getSuggestedPrefix(namespace); + if (prefix != null) { + addPrefixMapping(namespace, prefix); + } + } + }); + } + + /** + * Writes prefix declarations to the writer, sorted if configured. + * + * @param writer the {@link Writer} to which prefixes will be written. + * @throws IOException if an I/O error occurs. + */ + private void writePrefixDeclarations(Writer writer) throws IOException { + List prefixes = new ArrayList<>(prefixToIriMapping.keySet()); + + if (config.getPrefixOrdering() == PrefixOrderingEnum.ALPHABETICAL) { + Collections.sort(prefixes); + } + + for (String prefix : prefixes) { + writer.write(String.format("@prefix %s: <%s> .%s", + prefix, + prefixToIriMapping.get(prefix), + config.getLineEnding())); + } + + if (!prefixes.isEmpty() || config.getBaseIRI() != null) { + writer.write(config.getLineEnding()); + } + } + + /** + * Serializes the model's statements in a simple manner, one per line, without grouping. + * Triples already "consumed" by inline serialization are ignored. + * This method is used when `includeContext` is false and `useCompactTriples` is false. + * + * @param writer the {@link Writer} to which the statements will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeSimpleStatements(Writer writer) throws IOException { + for (Statement stmt : model) { + if (!isConsumed(stmt.getSubject())) { + writeStatement(writer, stmt); + writer.write(config.getLineEnding()); + } + } + } + + /** + * Writes a single {@link Statement} to the writer in TriG format. + * If the statement has a context and `includeContext` is enabled, this method will be + * called within a named graph block, so it will only write the triple parts. + * + * @param writer the {@link Writer} to which the statement will be written. + * @param stmt the {@link Statement} to write. + * @throws IOException if an I/O error occurs. + */ + private void writeStatement(Writer writer, Statement stmt) throws IOException { + String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; + writer.write(indent); + + // Subject + writeValue(writer, stmt.getSubject()); + writer.write(SerializationConstants.SPACE); + + // Predicate + writePredicate(writer, stmt.getPredicate()); + writer.write(SerializationConstants.SPACE); + + // Object + writeValue(writer, stmt.getObject()); + + + writer.write(SerializationConstants.SPACE); + writer.write(SerializationConstants.POINT); + + } + + /** + * Writes the predicate to the writer, using the 'a' shortcut if configured and applicable. + * + * @param writer the {@link Writer} to which the predicate will be written. + * @param predicate the {@link Value} representing the predicate. + * @throws IOException if an I/O error occurs. + */ + private void writePredicate(Writer writer, Value predicate) throws IOException { + if (config.useRdfTypeShortcut() && predicate.stringValue().equals(SerializationConstants.RDF_TYPE)) { + writer.write(SerializationConstants.RDF_TYPE_SHORTCUT); + } else { + writeValue(writer, predicate); + } + } + + /** + * Writes a single {@link Value} to the writer. + * Handles literals, blank nodes, and IRIs. + * This is the entry point for serializing nested blank nodes and lists. + * + * @param writer the {@link Writer} to which the value will be written. + * @param value the {@link Value} to write. + * @throws IOException if an I/O error occurs. + * @throws IllegalArgumentException if the provided value is null or of an unsupported type. + */ + private void writeValue(Writer writer, Value value) throws IOException { + validateValue(value); + + if (value.isIRI()) { + writeIRI(writer, (IRI) value); + } else if (value.isLiteral()) { + writeLiteral(writer, (Literal) value); + } else if (value.isBNode()) { + Resource bNode = (Resource) value; + + if (currentlyWritingBlankNodes.contains(bNode)) { + writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); + return; + } + + currentlyWritingBlankNodes.add(bNode); + + boolean handled = false; + if (config.useCollections() && bNode.isBNode()) { + handled = writeRDFList(writer, bNode); + } + + if (!handled && config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS && bNode.isBNode()) { + List properties = model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .toList(); + + if (!properties.isEmpty()) { + writeInlineBlankNode(writer, properties); + handled = true; + } + } + + if (!handled) { + writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); + } + + currentlyWritingBlankNodes.remove(bNode); + } else { + throw new IllegalArgumentException("Unsupported value type for TriG serialization: " + value.getClass().getName()); + } + } + + + /** + * Writes an {@link IRI} to the writer. + * Attempts to use a prefixed name if possible, otherwise writes the full IRI in angle brackets. + * + * @param writer the {@link Writer} to which the IRI will be written. + * @param iri the {@link IRI} to write. + * @throws IOException if an I/O error occurs. + */ + private void writeIRI(Writer writer, IRI iri) throws IOException { + if (config.isStrictMode() && config.validateURIs()) { + validateIRI(iri); + } + + String prefixed = config.usePrefixes() ? getPrefixedName(iri.stringValue()) : null; + + if (prefixed != null) { + writer.write(prefixed); + } else { + writer.write(String.format("<%s>", escapeTriGIRI(iri.stringValue()))); + } + } + + /** + * Writes a {@link Literal} to the writer in TriG format. + * Applies escaping and datatype/language tag rules based on configuration. + * + * @param writer the {@link Writer} to which the literal will be written. + * @param literal the {@link Literal} to write. + * @throws IOException if an I/O error occurs. + */ + private void writeLiteral(Writer writer, Literal literal) throws IOException { + String value = literal.stringValue(); + + if (config.shouldUseTripleQuotes(value)) { + writer.write(String.format("\"\"\"%s\"\"\"", escapeMultilineLiteral(value))); + } else { + writer.write(String.format("\"%s\"", escapeTriGLiteral(value))); + } + + literal.getLanguage().ifPresent(lang -> { + try { + writer.write(SerializationConstants.AT_SIGN + lang); + } catch (IOException e) { + throw new UncheckedIOException("Error writing language tag to stream", e); + } + }); + + writeDatatype(writer, literal); + } + + /** + * Writes the datatype of a literal if the configured datatype policy allows it. + * + * @param writer the {@link Writer} to which the datatype will be written. + * @param literal the {@link Literal} whose datatype is to be written. + * @throws IOException if an I/O error occurs. + */ + private void writeDatatype(Writer writer, Literal literal) throws IOException { + IRI datatype = literal.getDatatype(); + if (shouldWriteDatatype(literal)) { + writer.write(SerializationConstants.DATATYPE_SEPARATOR); + writeIRI(writer, datatype); + } + } + + /** + * Determines if a literal's datatype should be written based on the configuration. + * + * @param literal the {@link Literal} to check. + * @return {@code true} if the datatype should be written, {@code false} otherwise. + */ + private boolean shouldWriteDatatype(Literal literal) { + if (literal.getLanguage().isPresent()) { + return false; + } + + IRI datatype = literal.getDatatype(); + if (datatype == null) { + return false; + } + + return config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || + (!datatype.stringValue().equals(SerializationConstants.XSD_STRING) && + config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL); + } + + /** + * Writes an inline blank node using the `[]` syntax. + * The blank node's properties are serialized inside the brackets. + * + * @param writer the {@link Writer} to which the blank node will be written. + * @param properties the list of statements where the blank node is the subject. + * @throws IOException if an I/O error occurs. + */ + private void writeInlineBlankNode(Writer writer, List properties) throws IOException { + String currentIndent = config.prettyPrint() ? config.getIndent() : ""; + String propIndent = config.prettyPrint() ? currentIndent + config.getIndent() : ""; + + writer.write(SerializationConstants.BLANK_NODE_START); + + boolean firstProperty = true; + for (Statement stmt : properties) { + if (stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || + stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) { + continue; + } + + if (!firstProperty) { + writer.write(SerializationConstants.SEMICOLON); + } + firstProperty = false; + + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + propIndent); + } else { + writer.write(SerializationConstants.SPACE); + } + + writePredicate(writer, stmt.getPredicate()); + writer.write(SerializationConstants.SPACE); + writeValue(writer, stmt.getObject()); + } + + if (config.prettyPrint() && !properties.isEmpty() && !firstProperty) { + writer.write(config.getLineEnding() + currentIndent); + } + + writer.write(SerializationConstants.BLANK_NODE_END); + } + + /** + * Serializes the model's statements by grouping triples by subject, then by predicate, + * using compact syntax (semicolons and commas) if configured. + * Triples already "consumed" by inline serialization are ignored. + * This method is used when `includeContext` is false and `useCompactTriples` is true. + * + * @param writer the {@link Writer} to which the optimized statements will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeOptimizedStatements(Writer writer) throws IOException { + Map> bySubject = config.sortSubjects() ? + new TreeMap<>(Comparator.comparing(Resource::stringValue)) : + new LinkedHashMap<>(); + + + model.stream() + .filter(stmt -> !isConsumed(stmt.getSubject())) + .forEach(stmt -> bySubject.computeIfAbsent(stmt.getSubject(), k -> new ArrayList<>()).add(stmt)); + + for (Map.Entry> subjectEntry : bySubject.entrySet()) { + String indent = config.prettyPrint() ? config.getIndent() : ""; + writer.write(indent); + writeValue(writer, subjectEntry.getKey()); + writer.write(SerializationConstants.SPACE); + + Map> byPredicate = config.sortPredicates() ? + new TreeMap<>(Comparator.comparing(IRI::stringValue)) : + new LinkedHashMap<>(); + + subjectEntry.getValue().forEach(stmt -> byPredicate.computeIfAbsent(stmt.getPredicate(), k -> new ArrayList<>()).add(stmt)); + + boolean firstPredicate = true; + for (Map.Entry> predicateEntry : byPredicate.entrySet()) { + if (!firstPredicate) { + writer.write(SerializationConstants.SEMICOLON); + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + indent + config.getIndent()); + } else { + writer.write(SerializationConstants.SPACE); + } + } + firstPredicate = false; + + writePredicate(writer, predicateEntry.getKey()); + writer.write(SerializationConstants.SPACE); + + boolean firstObject = true; + for (Statement stmt : predicateEntry.getValue()) { + if (!firstObject) { + writer.write(SerializationConstants.COMMA); + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + indent + config.getIndent() + config.getIndent()); + } else { + writer.write(SerializationConstants.SPACE); + } + } + firstObject = false; + + writeValue(writer, stmt.getObject()); + } + } + + writer.write(SerializationConstants.SPACE + SerializationConstants.POINT); + writer.write(config.getLineEnding()); + } + } + + /** + * Serializes statements, grouping them by named graph context. + * Statements without a context are considered part of the default graph. + * This method is used when {@code includeContext} is true. + * + * @param writer the {@link Writer} to which the statements will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeStatementsWithContext(Writer writer) throws IOException { + Map> byContext = new LinkedHashMap<>(); + model.stream() + .filter(stmt -> !isConsumed(stmt.getSubject())) + .forEach(stmt -> byContext.computeIfAbsent(stmt.getContext(), k -> new ArrayList<>()).add(stmt)); + + for (Map.Entry> contextEntry : byContext.entrySet()) { + Resource context = contextEntry.getKey(); + List statementsInContext = contextEntry.getValue(); + + String initialIndent = ""; + String graphIndent = config.prettyPrint() ? config.getIndent() : ""; + + if (context != null) { + if (context.isIRI()) { + writeIRI(writer, (IRI) context); + } else if (context.isBNode()) { + writeValue(writer, context); + } + writer.write(SerializationConstants.SPACE); + writer.write(SerializationConstants.OPEN_BRACE); + writer.write(config.getLineEnding()); + initialIndent = graphIndent; + } + + + Map> bySubject = config.sortSubjects() ? + new TreeMap<>(Comparator.comparing(Resource::stringValue)) : + new LinkedHashMap<>(); + + statementsInContext.forEach(stmt -> bySubject.computeIfAbsent(stmt.getSubject(), k -> new ArrayList<>()).add(stmt)); + + for (Map.Entry> subjectEntry : bySubject.entrySet()) { + writer.write(initialIndent); + writeValue(writer, subjectEntry.getKey()); + writer.write(SerializationConstants.SPACE); + + Map> byPredicate = config.sortPredicates() ? + new TreeMap<>(Comparator.comparing(IRI::stringValue)) : + new LinkedHashMap<>(); + + subjectEntry.getValue().forEach(stmt -> byPredicate.computeIfAbsent(stmt.getPredicate(), k -> new ArrayList<>()).add(stmt)); + + boolean firstPredicate = true; + for (Map.Entry> predicateEntry : byPredicate.entrySet()) { + if (!firstPredicate) { + writer.write(SerializationConstants.SEMICOLON); + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + initialIndent + config.getIndent()); + } else { + writer.write(SerializationConstants.SPACE); + } + } + firstPredicate = false; + + writePredicate(writer, predicateEntry.getKey()); + writer.write(SerializationConstants.SPACE); + + boolean firstObject = true; + for (Statement stmt : predicateEntry.getValue()) { + if (!firstObject) { + writer.write(SerializationConstants.COMMA); + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + initialIndent + config.getIndent() + config.getIndent()); + } else { + writer.write(SerializationConstants.SPACE); + } + } + firstObject = false; + writeValue(writer, stmt.getObject()); + } + } + writer.write(SerializationConstants.SPACE + SerializationConstants.POINT); + writer.write(config.getLineEnding()); + } + + if (context != null) { + writer.write(SerializationConstants.CLOSE_BRACE); + writer.write(SerializationConstants.SPACE); + writer.write(SerializationConstants.POINT); + writer.write(config.getLineEnding()); + } + writer.write(config.getLineEnding()); + } + } + + + /** + * Attempts to serialize an RDF list if the given blank node is its head. + * Marks all blank nodes in the list as consumed. + * + * @param writer the {@link Writer} to which the list will be written. + * @param listHead the blank node that might be the head of an RDF list. + * @return {@code true} if an RDF list was serialized, {@code false} otherwise. + * @throws IOException if an I/O error occurs. + */ + private boolean writeRDFList(Writer writer, Resource listHead) throws IOException { + List items = new ArrayList<>(); + Resource current = listHead; + Set listBlankNodes = new HashSet<>(); + + if (currentlyWritingBlankNodes.contains(listHead)) { + return false; + } + currentlyWritingBlankNodes.add(listHead); + + while (current != null && current.isBNode() && !currentlyWritingBlankNodes.contains(current)) { + listBlankNodes.add(current); + currentlyWritingBlankNodes.add(current); + + final Resource finalCurrentForLambda = current; + List statements = model.stream() + .filter(stmt -> stmt.getSubject().equals(finalCurrentForLambda)) + .toList(); + + if (statements.size() != 2) { + current = null; + break; + } + + Optional first = statements.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + .map(Statement::getObject) + .findFirst(); + + Optional rest = statements.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .map(Statement::getObject) + .findFirst(); + + if (!first.isPresent() || !rest.isPresent()) { + current = null; + break; + } + + items.add(first.get()); + + if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { + current = null; + } else if (rest.get().isBNode()) { + current = (Resource) rest.get(); + } else { + current = null; + break; + } + } + currentlyWritingBlankNodes.remove(listHead); + + if (items.isEmpty() || current != null) { + listBlankNodes.forEach(currentlyWritingBlankNodes::remove); + return false; + } + + consumedBlankNodes.addAll(listBlankNodes); + + writer.write(SerializationConstants.OPEN_PARENTHESIS); + boolean firstItem = true; + for (Value item : items) { + if (!firstItem) writer.write(SerializationConstants.SPACE); + firstItem = false; + writeValue(writer, item); + } + writer.write(SerializationConstants.CLOSE_PARENTHESIS); + return true; + } + + /** + * Determines if a value (subject, predicate, object) is a blank node that has already been + * serialized inline (within a '[]' or '()') and should be ignored during top-level serialization. + * + * @param value the {@link Value} to check. + * @return {@code true} if the value is a consumed blank node, {@code false} otherwise. + */ + private boolean isConsumed(Value value) { + return value.isBNode() && consumedBlankNodes.contains(value); + } + + /** + * Identifies and returns a set of blank nodes that can be serialized inline (either as `[]` or as `()` for lists). + * These nodes will then be "consumed" to prevent their serialization as top-level triples. + * + * @return A {@link Set} of {@link Resource} representing the blank nodes that will be serialized inline. + */ + private Set precomputeInlineBlankNodesAndLists() { + Set precomputed = new HashSet<>(); + for (Statement stmt : model) { + if (stmt.getSubject().isBNode()) { + Resource bNodeSubject = stmt.getSubject(); + if (config.useCollections() && isRDFListHead(bNodeSubject)) { + Resource current = bNodeSubject; + Set listNodes = new HashSet<>(); + Set visitedInPrecomp = new HashSet<>(); + boolean isList = true; + while (current != null && current.isBNode() && !visitedInPrecomp.contains(current)) { + visitedInPrecomp.add(current); + listNodes.add(current); + final Resource finalCurrentForLambda = current; + List listProps = model.stream() + .filter(s -> s.getSubject().equals(finalCurrentForLambda)) + .toList(); + + if (listProps.size() != 2) { + isList = false; + break; + } + + Optional first = listProps.stream() + .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + .map(Statement::getObject) + .findFirst(); + + Optional rest = listProps.stream() + .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .map(Statement::getObject) + .findFirst(); + + if (!first.isPresent() || !rest.isPresent()) { + isList = false; + break; + } + + if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { + current = null; + } else if (rest.get().isBNode()) { + current = (Resource) rest.get(); + } else { + isList = false; + break; + } + } + if (isList && current == null) { + precomputed.addAll(listNodes); + } + } + if (config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS) { + List properties = model.stream() + .filter(s -> s.getSubject().equals(bNodeSubject)) + .toList(); + + boolean isPartOfList = properties.stream().anyMatch(s -> + s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || + s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST) + ); + + if (!properties.isEmpty() && !isPartOfList) { + precomputed.add(bNodeSubject); + } + } + } + } + return precomputed; + } + + /** + * Checks if a given blank node is the head of an RDF list. + * + * @param bNode the blank node to check. + * @return true if it's the head of an RDF list, false otherwise. + */ + private boolean isRDFListHead(Resource bNode) { + boolean hasFirstAndRest = model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + && + model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)); + + boolean isObjectOfRest = model.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .anyMatch(stmt -> stmt.getObject().equals(bNode)); + + return hasFirstAndRest && !isObjectOfRest; + } + + + // --- Helpers for prefix resolution --- + + /** + * Adds a prefix-namespace URI mapping to the internal mappings. + * Handles potential conflicts to ensure uniqueness. + * + * @param namespaceURI The namespace URI. + * @param prefix The associated prefix. + */ + private void addPrefixMapping(String namespaceURI, String prefix) { + if (iriToPrefixMapping.containsKey(namespaceURI)) { + if (logger.isWarnEnabled() && !iriToPrefixMapping.get(namespaceURI).equals(prefix)) { + logger.warn("Namespace URI '{}' is already mapped to prefix '{}'. Cannot map to new prefix '{}'.", + namespaceURI, iriToPrefixMapping.get(namespaceURI), prefix); + } + return; + } + + if (prefixToIriMapping.containsKey(prefix)) { + if (logger.isWarnEnabled() && !prefixToIriMapping.get(prefix).equals(namespaceURI)) { + String originalNamespace = prefixToIriMapping.get(prefix); + logger.warn("Prefix '{}' is already mapped to namespace '{}'. Cannot map to new namespace '{}'. " + + "A new unique prefix will be generated for '{}'.", + prefix, originalNamespace, namespaceURI, namespaceURI); + } + return; + } + + iriToPrefixMapping.put(namespaceURI, prefix); + prefixToIriMapping.put(prefix, namespaceURI); + } + + /** + * Extracts the namespace URI part from an IRI string. + * This is a common heuristic for RDF IRIs. + * + * @param iriString The full IRI. + * @return The namespace URI part. + */ + private String getNamespace(String iriString) { + int hashIdx = iriString.lastIndexOf(SerializationConstants.HASH); + int slashIdx = iriString.lastIndexOf(SerializationConstants.SLASH); + + if (hashIdx > -1) { + return iriString.substring(0, hashIdx + 1); + } else if (slashIdx > -1 && slashIdx < iriString.length() - 1) { + int dotIdx = iriString.lastIndexOf(SerializationConstants.POINT); + if (dotIdx > slashIdx) { + + return iriString.substring(0, slashIdx + 1); + } + return iriString.substring(0, slashIdx + 1); + } + return iriString; + } + + + /** + * Attempts to find a prefixed name for an IRI from existing mappings. + * + * @param iriString The full IRI. + * @return The prefixed name (e.g., "ex:someResource") or null if no suitable prefix is found. + */ + private String getPrefixedName(String iriString) { + for (Map.Entry entry : iriToPrefixMapping.entrySet()) { + String namespace = entry.getKey(); + String prefix = entry.getValue(); + + if (iriString.startsWith(namespace)) { + String localName = iriString.substring(namespace.length()); + if (localName.isEmpty()) { + if (!prefix.isEmpty()) { + return prefix + SerializationConstants.COLON; + } else { + continue; + } + } + return prefix + SerializationConstants.COLON + localName; + } + } + return null; + } + + /** + * Suggests a prefix for a given namespace URI. + * Attempts to derive a meaningful prefix or generates a unique one. + * + * @param namespace The namespace URI. + * @return A suggested prefix, or null if suggestion is not possible. + */ + private String getSuggestedPrefix(String namespace) { + // Try common predefined prefixes + if (namespace.equals(SerializationConstants.RDF_NS)) return "rdf"; + if (namespace.equals(SerializationConstants.RDFS_NS)) return "rdfs"; + if (namespace.equals(SerializationConstants.XSD_NS)) return "xsd"; + if (namespace.equals(SerializationConstants.OWL_NS)) return "owl"; + if (namespace.equals(SerializationConstants.FOAF_NS)) return "foaf"; + + + String base = namespace; + if (base.endsWith(SerializationConstants.HASH) || base.endsWith(SerializationConstants.SLASH)) { + base = base.substring(0, base.length() - 1); + } + int lastSlash = base.lastIndexOf(SerializationConstants.SLASH); + int lastHash = base.lastIndexOf(SerializationConstants.HASH); + int lastSegmentStart = Math.max(lastSlash, lastHash); + if (lastSegmentStart != -1) { + base = base.substring(lastSegmentStart + 1); + } + + if (base.isEmpty()) { + try { + URI uri = new URI(namespace); + base = uri.getHost().replace(SerializationConstants.POINT, SerializationConstants.EMPTY_STRING); + } catch (URISyntaxException e) { + logger.warn("Malformed URI encountered while suggesting prefix: {}", namespace, e); + base = "p"; + } + } + + base = base.replaceAll("[^a-zA-Z0-9]", SerializationConstants.EMPTY_STRING).toLowerCase(); + if (base.isEmpty()) base = "p"; + + + String candidate = base; + int i = 0; + + while (prefixToIriMapping.containsKey(candidate) && !prefixToIriMapping.get(candidate).equals(namespace)) { + candidate = base + (++i); + } + return candidate; + } + + + // --- Helpers for escaping and validation --- + + /** + * Escapes special characters in TriG string literals. + * Handles backslashes, double quotes, and common control characters. + * Unicode escape sequences are used for unprintable characters if `escapeUnicode` is true. + * + * @param value The string value of the literal to escape. + * @return The escaped string suitable for a TriG literal. + */ + private String escapeTriGLiteral(String value) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < value.length(); i++) { + char c = value.charAt(i); + switch (c) { + case '\n': + sb.append(SerializationConstants.BACK_SLASH).append("n"); + break; + case '\r': + sb.append(SerializationConstants.BACK_SLASH).append("r"); + break; + case '\t': + sb.append(SerializationConstants.BACK_SLASH).append("t"); + break; + case '\b': + sb.append(SerializationConstants.BACK_SLASH).append("b"); + break; + case '\f': + sb.append(SerializationConstants.BACK_SLASH).append("f"); + break; + case '"': + sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.QUOTE); + break; + case '\\': + sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.BACK_SLASH); + break; + default: + if (config.escapeUnicode() && (c <= 0x1F || c == 0x7F || (c >= 0x80 && c <= 0xFFFF))) { + sb.append(String.format("\\u%04X", (int) c)); + } else if (Character.isHighSurrogate(c)) { + int codePoint = value.codePointAt(i); + if (Character.isValidCodePoint(codePoint)) { + sb.append(String.format("\\U%08X", codePoint)); + i++; + } else { + sb.append(c); + } + } else { + sb.append(c); + } + } + } + return sb.toString(); + } + + /** + * Escapes special characters in multi-line literals (triple-quotes). + * Primarily used to escape occurrences of `"""` within the literal. + * + * @param value The string value of the literal to escape. + * @return The escaped string suitable for a multi-line TriG literal. + */ + private String escapeMultilineLiteral(String value) { + return value.replace(SerializationConstants.QUOTE + SerializationConstants.QUOTE + SerializationConstants.QUOTE, + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE); + } + + /** + * Escapes characters in an IRI string for TriG output. + * This method primarily focuses on control characters and problematic characters within angle brackets. + * + * @param iri The IRI to escape. + * @return The escaped IRI. + */ + private String escapeTriGIRI(String iri) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < iri.length(); i++) { + char c = iri.charAt(i); + if (c < 0x20 || c == 0x7F || c == SerializationConstants.LT.charAt(0) || c == SerializationConstants.GT.charAt(0) || c == SerializationConstants.QUOTE.charAt(0) || c == '{' || c == '}' || c == '|' || c == '^' || c == '`' || c == SerializationConstants.BACK_SLASH.charAt(0)) { + sb.append(String.format("\\u%04X", (int) c)); + } else { + sb.append(c); + } + } + return sb.toString(); + } + + /** + * Validates RDF values before serialization. + * Called only if strictMode is enabled. + * + * @param value The {@link Value} to validate. + * @throws IllegalArgumentException if the value is null or invalid according to strict rules. + */ + private void validateValue(Value value) { + if (value == null) { + logger.warn("Null value encountered where a non-null value was expected for TriG serialization. This will lead to an IllegalArgumentException if strict mode is enabled."); + throw new IllegalArgumentException("Value cannot be null in TriG format when strictMode is enabled."); + } + + if (config.isStrictMode() && value.isLiteral()) { + validateLiteral((Literal) value); + } + } + + /** + * Validates a {@link Literal} to ensure it conforms to RDF/TriG rules. + * Specifically checks for consistency between language tags and the rdf:langString datatype. + * Called only if strictMode is enabled. + * + * @param literal The {@link Literal} to validate. + * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, + * or rdf:langString literal without language tag). + */ + private void validateLiteral(Literal literal) { + IRI datatype = literal.getDatatype(); + + if (literal.getLanguage().isPresent()) { + if (datatype == null || !datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + throw new IllegalArgumentException( + "A literal with a language tag must use the rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); + } + } else { + if (datatype != null && datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + throw new IllegalArgumentException( + "An rdf:langString literal must have a language tag."); + } + } + } + + /** + * Validates an {@link IRI} to ensure it conforms to TriG rules. + * Checks if the IRI string contains characters not allowed in unescaped TriG + * form within angle brackets (e.g., control characters, space). + * Called only if strictMode and validateURIs are enabled. + * + * @param iri The {@link IRI} to validate. + * @throws IllegalArgumentException if the IRI contains invalid characters. + */ + private void validateIRI(IRI iri) { + String iriString = iri.stringValue(); + + if (iriString.contains(SerializationConstants.SPACE) || + iriString.contains(SerializationConstants.QUOTE) || + iriString.contains(SerializationConstants.LT) || + iriString.contains(SerializationConstants.GT)) { + throw new IllegalArgumentException("IRI contains illegal characters (space, quotes, angle brackets) for unescaped TriG form: " + iriString); + } + } + + } From 5ba963cc3e2c070372462d495348b2e00ffd9ed9 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Thu, 19 Jun 2025 14:17:53 +0200 Subject: [PATCH 09/27] ajouter RDF.LANGSTRING.getIRI().stringValue() --- .../next/impl/common/serialization/NQuadsFormat.java | 5 +++-- .../impl/common/serialization/NTriplesFormat.java | 5 +++-- .../next/impl/common/serialization/TriGFormat.java | 5 +++-- .../next/impl/common/serialization/TurtleFormat.java | 11 ++++++----- .../next/impl/common/util/SerializationConstants.java | 1 - .../impl/common/serialization/NQuadsFormatTest.java | 1 + .../impl/common/serialization/TriGFormatTest.java | 5 +++-- .../impl/common/serialization/TurtleFormatTest.java | 5 +++-- 8 files changed, 22 insertions(+), 16 deletions(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java index 9b1dd9878..7b138ee1c 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; @@ -362,12 +363,12 @@ private void validateLiteral(Literal literal) { IRI datatype = literal.getDatatype(); if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { throw new IllegalArgumentException( "Literal with language tag must use rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); } } else { - if (datatype != null && datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { throw new IllegalArgumentException( "rdf:langString literal must have a language tag."); } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java index d165e391f..07e4dfdc9 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; @@ -328,12 +329,12 @@ private void validateLiteral(Literal literal) { IRI datatype = literal.getDatatype(); if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { throw new IllegalArgumentException( "Literal with language tag must use rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); } } else { - if (datatype != null && datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { throw new IllegalArgumentException( "rdf:langString literal must have a language tag."); } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java index 8805d3b9e..7bff1b292 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; @@ -1048,12 +1049,12 @@ private void validateLiteral(Literal literal) { IRI datatype = literal.getDatatype(); if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { throw new IllegalArgumentException( "A literal with a language tag must use the rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); } } else { - if (datatype != null && datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { throw new IllegalArgumentException( "An rdf:langString literal must have a language tag."); } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java index 15f38c241..442520e6b 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; @@ -216,7 +217,7 @@ private void writeSimpleStatements(Writer writer) throws IOException { * @throws IOException if an I/O error occurs. */ private void writeStatement(Writer writer, Statement stmt) throws IOException { - String indent = config.prettyPrint() ? config.getIndent() : ""; + String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; writer.write(indent); // Subject @@ -817,9 +818,9 @@ private String getSuggestedPrefix(String namespace) { if (base.isEmpty()) { try { - URI uri = new URI(namespace); // Utilisation de URI + URI uri = new URI(namespace); base = uri.getHost().replace(SerializationConstants.POINT, SerializationConstants.EMPTY_STRING); - } catch (URISyntaxException e) { // Capture URISyntaxException + } catch (URISyntaxException e) { logger.warn("Malformed URI encountered while suggesting prefix: {}", namespace, e); base = "p"; } @@ -959,12 +960,12 @@ private void validateLiteral(Literal literal) { IRI datatype = literal.getDatatype(); if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { throw new IllegalArgumentException( "A literal with a language tag must use the rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); } } else { - if (datatype != null && datatype.stringValue().equals(SerializationConstants.RDF_LANGSTRING)) { + if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { throw new IllegalArgumentException( "An rdf:langString literal must have a language tag."); } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java b/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java index beac9b144..26c1fdbe7 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java @@ -22,7 +22,6 @@ private SerializationConstants() { public static final String RDF_FIRST = RDF_NS + "first"; public static final String RDF_REST = RDF_NS + "rest"; public static final String RDF_NIL = RDF_NS + "nil"; - public static final String RDF_LANGSTRING = RDF_NS + "langString"; public static final String XSD_STRING = XSD_NS + "string"; public static final String XSD_INTEGER = XSD_NS + "integer"; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java index 7756f92d6..cd660647b 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java @@ -4,6 +4,7 @@ import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.apache.jena.datatypes.xsd.impl.RDFLangString; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java index 922a4f97b..e3684b5ef 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; @@ -211,7 +212,7 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { when(mockObject.getLanguage()).thenReturn(Optional.of("en")); IRI mockRdfLangString = mock(IRI.class); - when(mockRdfLangString.stringValue()).thenReturn(SerializationConstants.RDF_LANGSTRING); + when(mockRdfLangString.stringValue()).thenReturn(RDF.LANGSTRING.getIRI().stringValue()); when(mockRdfLangString.isIRI()).thenReturn(true); when(mockRdfLangString.isResource()).thenReturn(true); when(mockObject.getDatatype()).thenReturn(mockRdfLangString); @@ -516,7 +517,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { when(mockObject.isBNode()).thenReturn(false); when(mockObject.getLanguage()).thenReturn(Optional.empty()); IRI mockRdfLangStringDatatype = mock(IRI.class); - when(mockRdfLangStringDatatype.stringValue()).thenReturn(SerializationConstants.RDF_LANGSTRING); + when(mockRdfLangStringDatatype.stringValue()).thenReturn(RDF.LANGSTRING.getIRI().stringValue()); when(mockRdfLangStringDatatype.isIRI()).thenReturn(true); when(mockRdfLangStringDatatype.isResource()).thenReturn(true); when(mockObject.getDatatype()).thenReturn(mockRdfLangStringDatatype); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java index f3a83a29a..e550580a1 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; @@ -210,7 +211,7 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { when(mockObject.getLanguage()).thenReturn(Optional.of("en")); IRI mockRdfLangString = mock(IRI.class); - when(mockRdfLangString.stringValue()).thenReturn(SerializationConstants.RDF_LANGSTRING); + when(mockRdfLangString.stringValue()).thenReturn(RDF.LANGSTRING.getIRI().stringValue()); when(mockRdfLangString.isIRI()).thenReturn(true); when(mockRdfLangString.isResource()).thenReturn(true); when(mockObject.getDatatype()).thenReturn(mockRdfLangString); @@ -616,7 +617,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { when(mockObject.isBNode()).thenReturn(false); when(mockObject.getLanguage()).thenReturn(Optional.empty()); IRI mockRdfLangStringDatatype = mock(IRI.class); - when(mockRdfLangStringDatatype.stringValue()).thenReturn(SerializationConstants.RDF_LANGSTRING); + when(mockRdfLangStringDatatype.stringValue()).thenReturn(RDF.LANGSTRING.getIRI().stringValue()); when(mockRdfLangStringDatatype.isIRI()).thenReturn(true); when(mockRdfLangStringDatatype.isResource()).thenReturn(true); when(mockObject.getDatatype()).thenReturn(mockRdfLangStringDatatype); From 57fe4d872582869085eae3947073ee3dcceb93c6 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 20 Jun 2025 23:12:31 +0200 Subject: [PATCH 10/27] Serializer to be separated into a factory class for serializers. Add a (possibly empty) Config interface for config objects --- ...matSerializer.java => IRdfSerializer.java} | 9 +- .../core/next/api/ISerializationConfig.java | 14 ++ .../core/next/api/ISerializerFactory.java | 9 ++ .../DefaultSerializerFactory.java | 65 +++++++++ ...QuadsFormat.java => NQuadsSerializer.java} | 16 +-- ...lesFormat.java => NTriplesSerializer.java} | 16 +-- .../impl/common/serialization/Serializer.java | 57 -------- .../{TriGFormat.java => TriGSerializer.java} | 16 +-- ...urtleFormat.java => TurtleSerializer.java} | 16 +-- .../serialization/config/FormatConfig.java | 3 +- .../DefaultSerializerFactoryTest.java | 102 ++++++++++++++ ...matTest.java => NQuadsSerializerTest.java} | 17 ++- ...tTest.java => NTriplesSerializerTest.java} | 16 +-- .../common/serialization/SerializerTest.java | 124 ------------------ ...ormatTest.java => TriGSerializerTest.java} | 24 ++-- ...matTest.java => TurtleSerializerTest.java} | 24 ++-- 16 files changed, 268 insertions(+), 260 deletions(-) rename src/main/java/fr/inria/corese/core/next/api/{FormatSerializer.java => IRdfSerializer.java} (84%) create mode 100644 src/main/java/fr/inria/corese/core/next/api/ISerializationConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/api/ISerializerFactory.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/{NQuadsFormat.java => NQuadsSerializer.java} (96%) rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/{NTriplesFormat.java => NTriplesSerializer.java} (96%) delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/{TriGFormat.java => TriGSerializer.java} (98%) rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/{TurtleFormat.java => TurtleSerializer.java} (98%) create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java rename src/test/java/fr/inria/corese/core/next/impl/common/serialization/{NQuadsFormatTest.java => NQuadsSerializerTest.java} (97%) rename src/test/java/fr/inria/corese/core/next/impl/common/serialization/{NTriplesFormatTest.java => NTriplesSerializerTest.java} (96%) delete mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerTest.java rename src/test/java/fr/inria/corese/core/next/impl/common/serialization/{TriGFormatTest.java => TriGSerializerTest.java} (97%) rename src/test/java/fr/inria/corese/core/next/impl/common/serialization/{TurtleFormatTest.java => TurtleSerializerTest.java} (97%) diff --git a/src/main/java/fr/inria/corese/core/next/api/FormatSerializer.java b/src/main/java/fr/inria/corese/core/next/api/IRdfSerializer.java similarity index 84% rename from src/main/java/fr/inria/corese/core/next/api/FormatSerializer.java rename to src/main/java/fr/inria/corese/core/next/api/IRdfSerializer.java index 4741a9712..d84c7d5f6 100644 --- a/src/main/java/fr/inria/corese/core/next/api/FormatSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/api/IRdfSerializer.java @@ -1,17 +1,16 @@ package fr.inria.corese.core.next.api; -import java.io.Writer; - import fr.inria.corese.core.next.impl.exception.SerializationException; -public interface FormatSerializer { +import java.io.Writer; + +public interface IRdfSerializer { /** * A serializer that converts a {@link Model} instance * into a specific output format and writes it to a character stream. - * * Implementations may follow standard RDF serialization formats - * (e.g., Turtle, N-Triples, JSON-LD), or define custom formats. + * (e.g., Turtle, N-Triples, JSON-LD, TriG , XML ), or define custom formats. * * @param writer the destination {@link Writer} for the serialized * output diff --git a/src/main/java/fr/inria/corese/core/next/api/ISerializationConfig.java b/src/main/java/fr/inria/corese/core/next/api/ISerializationConfig.java new file mode 100644 index 000000000..982f07164 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/api/ISerializationConfig.java @@ -0,0 +1,14 @@ +package fr.inria.corese.core.next.api; + + +/** + * Marker interface for configuration objects used in RDF serialization. + * This interface provides a common type for all serialization configuration + * implementations, promoting abstraction and flexibility in how serialization + * options are defined and provided. + * Implementations of this interface (e.g., FormatConfig) will define the + * specific parameters and settings relevant to a particular serialization process. + */ +public interface ISerializationConfig { + +} diff --git a/src/main/java/fr/inria/corese/core/next/api/ISerializerFactory.java b/src/main/java/fr/inria/corese/core/next/api/ISerializerFactory.java new file mode 100644 index 000000000..796a7803a --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/api/ISerializerFactory.java @@ -0,0 +1,9 @@ +package fr.inria.corese.core.next.api; + +import fr.inria.corese.core.next.impl.common.serialization.RdfFormat; + +public interface ISerializerFactory { + + + IRdfSerializer createSerializer(RdfFormat format, Model model, ISerializationConfig config); +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java new file mode 100644 index 000000000..05db36894 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java @@ -0,0 +1,65 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +import fr.inria.corese.core.next.api.IRdfSerializer; +import fr.inria.corese.core.next.api.ISerializerFactory; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.ISerializationConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; +import java.util.function.BiFunction; + +/** + * Default implementation of {@link ISerializerFactory}. + * This factory is responsible for creating instances of {@link IRdfSerializer} + * based on the requested {@link RdfFormat}. It uses a registry pattern + * to map each format to its corresponding serializer constructor, + * providing a flexible and extensible way to manage serializer instances. + */ +public class DefaultSerializerFactory implements ISerializerFactory { + + private final Map> registry; + + /** + * Constructs a {@code DefaultSerializerFactory} and populates its registry + * with constructors for all known {@link RdfFormat} implementations. + */ + public DefaultSerializerFactory() { + Map> tempRegistry = new HashMap<>(); // Changed to IFormatConfig + // Cast the lambda to BiFunction + tempRegistry.put(RdfFormat.TURTLE, (model, config) -> new TurtleSerializer(model, (FormatConfig) config)); + tempRegistry.put(RdfFormat.NTRIPLES, (model, config) -> new NTriplesSerializer(model, (FormatConfig) config)); + tempRegistry.put(RdfFormat.NQUADS, (model, config) -> new NQuadsSerializer(model, (FormatConfig) config)); + tempRegistry.put(RdfFormat.TRIG, (model, config) -> new TriGSerializer(model, (FormatConfig) config)); + this.registry = Collections.unmodifiableMap(tempRegistry); + } + + /** + * Creates an {@link IRdfSerializer} instance for the specified format, model, and configuration. + * + * @param format the {@link RdfFormat} for which to create the serializer. Must not be null. + * @param model the {@link Model} to be serialized. Must not be null. + * @param config the {@link ISerializationConfig} to apply during serialization. Must not be null. // Changed to IFormatConfig + * @return a new instance of {@link IRdfSerializer} configured for the specified format. + * @throws NullPointerException if any of the arguments (format, model, config) are null. + * @throws IllegalArgumentException if the provided format is not supported by this factory. + */ + @Override + public IRdfSerializer createSerializer(RdfFormat format, Model model, ISerializationConfig config) { + + Objects.requireNonNull(format, "RdfFormat cannot be null"); + Objects.requireNonNull(model, "Model cannot be null"); + Objects.requireNonNull(config, "IFormatConfig cannot be null"); + + BiFunction constructor = registry.get(format); + + if (constructor == null) { + throw new IllegalArgumentException("Unsupported RdfFormat: " + format.getName()); + } + + + return constructor.apply(model, config); + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java index 7b138ee1c..271bac707 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java @@ -14,37 +14,37 @@ import java.io.Writer; import java.util.Objects; -public class NQuadsFormat implements FormatSerializer { +public class NQuadsSerializer implements IRdfSerializer { /** * Logger for this class, used for logging potential issues or information during serialization. */ - private static final Logger logger = LoggerFactory.getLogger(NQuadsFormat.class); + private static final Logger logger = LoggerFactory.getLogger(NQuadsSerializer.class); private final Model model; private final FormatConfig config; /** - * Constructs a new {@code NQuadsFormat} instance with the specified model and default N-Quads configuration. + * Constructs a new {@code NQuadsSerializer} instance with the specified model and default N-Quads configuration. * The default configuration is obtained from {@link FormatConfig#nquadsConfig()}. * * @param model the {@link Model} to be serialized. Must not be null. * @throws NullPointerException if the provided model is null. */ - public NQuadsFormat(Model model) { + public NQuadsSerializer(Model model) { this(model, FormatConfig.nquadsConfig()); } /** - * Constructs a new {@code NQuadsFormat} instance with the specified model and custom configuration. + * Constructs a new {@code NQuadsSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link FormatConfig} to use for serialization. Must not be null. + * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or config is null. */ - public NQuadsFormat(Model model, FormatConfig config) { + public NQuadsSerializer(Model model, ISerializationConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); } /** diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java similarity index 96% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java index 07e4dfdc9..9b14e2a6c 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java @@ -19,36 +19,36 @@ * This class provides a method to write the statements of a model to a given {@link Writer} * according to the N-Triples specification. */ -public class NTriplesFormat implements FormatSerializer { +public class NTriplesSerializer implements IRdfSerializer { /** * Logger for this class, used for logging potential issues or information during serialization. */ - private static final Logger logger = LoggerFactory.getLogger(NTriplesFormat.class); + private static final Logger logger = LoggerFactory.getLogger(NTriplesSerializer.class); private final Model model; private final FormatConfig config; /** - * Constructs a new {@code NTriplesFormat} instance with the specified model and default configuration. + * Constructs a new {@code NTriplesSerializer} instance with the specified model and default configuration. * * @param model the {@link Model} to be serialized. Must not be null. * @throws NullPointerException if the provided model is null. */ - public NTriplesFormat(Model model) { + public NTriplesSerializer(Model model) { this(model, FormatConfig.ntriplesConfig()); } /** - * Constructs a new {@code NTriplesFormat} instance with the specified model and custom configuration. + * Constructs a new {@code NTriplesSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link FormatConfig} to use for serialization. Must not be null. + * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or config is null. */ - public NTriplesFormat(Model model, FormatConfig config) { + public NTriplesSerializer(Model model, ISerializationConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); } /** diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java deleted file mode 100644 index 9783a0c59..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/Serializer.java +++ /dev/null @@ -1,57 +0,0 @@ -package fr.inria.corese.core.next.impl.common.serialization; - -import fr.inria.corese.core.next.api.FormatSerializer; -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; -import fr.inria.corese.core.next.impl.exception.SerializationException; - -import java.io.Writer; -import java.util.Objects; - -public class Serializer { - - private final Model model; - private final FormatConfig config; - - public Serializer(Model model) { - this(model, new FormatConfig.Builder().build()); - } - - public Serializer(Model model, FormatConfig config) { - this.model = Objects.requireNonNull(model, "Model cannot be null for serialization"); - this.config = Objects.requireNonNull(config, "FormatConfig cannot be null for serialization"); - } - - /** - * Serializes the RDF model to the given writer in the specified {@link RdfFormat}. - * - * @param writer the Writer to write the serialized data to. - * @param format the {@link RdfFormat} describing the desired serialization format. - * @throws SerializationException if an error occurs during serialization or if the format is not currently supported by an implementation. - */ - public void serialize(Writer writer, RdfFormat format) throws SerializationException { - Objects.requireNonNull(writer, "Writer cannot be null"); - Objects.requireNonNull(format, "RdfFormat cannot be null"); - - FormatSerializer formatSerializer; - - - if (format.equals(RdfFormat.NTRIPLES)) { - formatSerializer = new NTriplesFormat(model, config); - } else if (format.equals(RdfFormat.NQUADS)) { - formatSerializer = new NQuadsFormat(model, config); - } else if (format.equals(RdfFormat.TURTLE)) { - formatSerializer = new TurtleFormat(model, config); - } else if (format.equals(RdfFormat.TRIG)) { - formatSerializer = new TriGFormat(model, config); - } else if (format.equals(RdfFormat.JSONLD)) { - throw new UnsupportedOperationException("Serialization to " + format.getName() + " format is not yet implemented."); - } else if (format.equals(RdfFormat.RDFXML)) { - throw new UnsupportedOperationException("Serialization to " + format.getName() + " format is not yet implemented."); - } else { - throw new IllegalArgumentException("Unknown or unsupported RdfFormat: " + format.getName()); - } - - formatSerializer.write(writer); - } -} \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java index 7bff1b292..388ecc6db 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java @@ -41,12 +41,12 @@ *

Advanced features such as strict adherence to maximum line length * and generation of stable blank node identifiers are not fully implemented in this version.

*/ -public class TriGFormat implements FormatSerializer { +public class TriGSerializer implements IRdfSerializer { /** * Logger for this class, used to log potential issues or information during serialization. */ - private static final Logger logger = LoggerFactory.getLogger(TriGFormat.class); + private static final Logger logger = LoggerFactory.getLogger(TriGSerializer.class); private final Model model; private final FormatConfig config; @@ -58,26 +58,26 @@ public class TriGFormat implements FormatSerializer { private final Set currentlyWritingBlankNodes; /** - * Constructs a new {@code TriGFormat} instance with the specified model and default configuration. + * Constructs a new {@code TriGSerializer} instance with the specified model and default configuration. * The default configuration is returned by {@link FormatConfig#trigConfig()}. * * @param model the {@link Model} to serialize. Must not be null. * @throws NullPointerException if the provided model is null. */ - public TriGFormat(Model model) { + public TriGSerializer(Model model) { this(model, FormatConfig.trigConfig()); } /** - * Constructs a new {@code TriGFormat} instance with the specified model and custom configuration. + * Constructs a new {@code TriGSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link FormatConfig} to use for serialization. Must not be null. + * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or configuration is null. */ - public TriGFormat(Model model, FormatConfig config) { + public TriGSerializer(Model model, ISerializationConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); this.iriToPrefixMapping = new HashMap<>(); this.prefixToIriMapping = new HashMap<>(); this.consumedBlankNodes = new HashSet<>(); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java similarity index 98% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java index 442520e6b..728e13d6f 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormat.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java @@ -40,12 +40,12 @@ *

Advanced features such as strict adherence to maximum line length * and generation of stable blank node identifiers are not fully implemented in this version.

*/ -public class TurtleFormat implements FormatSerializer { +public class TurtleSerializer implements IRdfSerializer { /** * Logger for this class, used to log potential issues or information during serialization. */ - private static final Logger logger = LoggerFactory.getLogger(TurtleFormat.class); + private static final Logger logger = LoggerFactory.getLogger(TurtleSerializer.class); private final Model model; private final FormatConfig config; @@ -57,26 +57,26 @@ public class TurtleFormat implements FormatSerializer { private final Set currentlyWritingBlankNodes; /** - * Constructs a new {@code TurtleFormat} instance with the specified model and default configuration. + * Constructs a new {@code TurtleSerializer} instance with the specified model and default configuration. * The default configuration is returned by {@link FormatConfig#turtleConfig()}. * * @param model the {@link Model} to serialize. Must not be null. * @throws NullPointerException if the provided model is null. */ - public TurtleFormat(Model model) { + public TurtleSerializer(Model model) { this(model, FormatConfig.turtleConfig()); } /** - * Constructs a new {@code TurtleFormat} instance with the specified model and custom configuration. + * Constructs a new {@code TurtleSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link FormatConfig} to use for serialization. Must not be null. + * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or configuration is null. */ - public TurtleFormat(Model model, FormatConfig config) { + public TurtleSerializer(Model model, ISerializationConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); this.iriToPrefixMapping = new HashMap<>(); this.prefixToIriMapping = new HashMap<>(); this.consumedBlankNodes = new HashSet<>(); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java index daca8e4f0..3e9651ec1 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java @@ -1,5 +1,6 @@ package fr.inria.corese.core.next.impl.common.serialization.config; +import fr.inria.corese.core.next.api.ISerializationConfig; import fr.inria.corese.core.next.impl.common.util.SerializationConstants; import java.util.Collections; @@ -16,7 +17,7 @@ * Predefined configurations for common RDF formats are available via static methods * like {@link #ntriplesConfig()}, {@link #nquadsConfig()}, {@link #turtleConfig()}, etc.

*/ -public class FormatConfig { +public class FormatConfig implements ISerializationConfig { /** * Whether prefix declarations (e.g., `@prefix`, `PREFIX`) should be used for compact IRIs. diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java new file mode 100644 index 000000000..c7e4845d6 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java @@ -0,0 +1,102 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +import fr.inria.corese.core.next.api.IRdfSerializer; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.MockedConstruction; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.mockConstruction; + +class DefaultSerializerFactoryTest { + + private DefaultSerializerFactory factory; + private Model mockModel; + private FormatConfig mockConfig; + + @BeforeEach + void setUp() { + factory = new DefaultSerializerFactory(); + + mockModel = org.mockito.Mockito.mock(Model.class); + mockConfig = org.mockito.Mockito.mock(FormatConfig.class); + } + + @Test + @DisplayName("createSerializer should return TurtleFormat for TURTLE format") + void createSerializer_shouldReturnTurtleFormat_forTurtleFormat() { + try (MockedConstruction mockedConstruction = mockConstruction(TurtleSerializer.class)) { + IRdfSerializer serializer = factory.createSerializer(RdfFormat.TURTLE, mockModel, mockConfig); + + assertNotNull(serializer); + assertTrue(serializer instanceof TurtleSerializer); + assertEquals(1, mockedConstruction.constructed().size(), "TurtleFormat constructor should be called once"); + } + } + + @Test + @DisplayName("createSerializer should return NTriplesFormat for NTRIPLES format") + void createSerializer_shouldReturnNTriplesFormat_forNTriplesFormat() { + try (MockedConstruction mockedConstruction = mockConstruction(NTriplesSerializer.class)) { + IRdfSerializer serializer = factory.createSerializer(RdfFormat.NTRIPLES, mockModel, mockConfig); + + assertNotNull(serializer); + assertTrue(serializer instanceof NTriplesSerializer); + assertEquals(1, mockedConstruction.constructed().size(), "NTriplesFormat constructor should be called once"); + } + } + + @Test + @DisplayName("createSerializer should return NQuadsFormat for NQUADS format") + void createSerializer_shouldReturnNQuadsFormat_forNQuadsFormat() { + try (MockedConstruction mockedConstruction = mockConstruction(NQuadsSerializer.class)) { + IRdfSerializer serializer = factory.createSerializer(RdfFormat.NQUADS, mockModel, mockConfig); + + assertNotNull(serializer); + assertTrue(serializer instanceof NQuadsSerializer); + assertEquals(1, mockedConstruction.constructed().size(), "NQuadsFormat constructor should be called once"); + } + } + + @Test + @DisplayName("createSerializer should return TriGFormat for TRIG format") + void createSerializer_shouldReturnTriGFormat_forTriGFormat() { + try (MockedConstruction mockedConstruction = mockConstruction(TriGSerializer.class)) { + IRdfSerializer serializer = factory.createSerializer(RdfFormat.TRIG, mockModel, mockConfig); + + assertNotNull(serializer); + assertTrue(serializer instanceof TriGSerializer); + assertEquals(1, mockedConstruction.constructed().size(), "TriGFormat constructor should be called once"); + } + } + + + @Test + @DisplayName("createSerializer should throw NullPointerException for null format") + void createSerializer_shouldThrowNPE_forNullFormat() { + assertThrows(NullPointerException.class, + () -> factory.createSerializer(null, mockModel, mockConfig), + "Should throw NullPointerException for null RdfFormat"); + } + + @Test + @DisplayName("createSerializer should throw NullPointerException for null model") + void createSerializer_shouldThrowNPE_forNullModel() { + assertThrows(NullPointerException.class, + () -> factory.createSerializer(RdfFormat.TURTLE, null, mockConfig), + "Should throw NullPointerException for null Model"); + } + + @Test + @DisplayName("createSerializer should throw NullPointerException for null config") + void createSerializer_shouldThrowNPE_forNullConfig() { + assertThrows(NullPointerException.class, + () -> factory.createSerializer(RdfFormat.TURTLE, mockModel, null), + "Should throw NullPointerException for null FormatConfig"); + } + + +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java rename to src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java index cd660647b..2d5dc47f9 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java @@ -4,7 +4,6 @@ import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; -import org.apache.jena.datatypes.xsd.impl.RDFLangString; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -21,11 +20,11 @@ import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.*; -class NQuadsFormatTest { +class NQuadsSerializerTest { private Model model; private FormatConfig config; - private NQuadsFormat nQuadsFormat; + private NQuadsSerializer nQuadsFormat; private Resource mockExPerson; private IRI mockExName; @@ -45,7 +44,7 @@ class NQuadsFormatTest { void setUp() { model = mock(Model.class); config = FormatConfig.nquadsConfig(); - nQuadsFormat = new NQuadsFormat(model, config); + nQuadsFormat = new NQuadsSerializer(model, config); mockExPerson = createIRI("http://example.org/Person"); mockExName = createIRI("http://example.org/name"); @@ -63,14 +62,14 @@ void setUp() { @Test @DisplayName("Constructor should throw NullPointerException for null model") void constructorShouldThrowForNullModel() { - assertThrows(NullPointerException.class, () -> new NQuadsFormat(null), "Model cannot be null"); - assertThrows(NullPointerException.class, () -> new NQuadsFormat(null, config), "Model cannot be null"); + assertThrows(NullPointerException.class, () -> new NQuadsSerializer(null), "Model cannot be null"); + assertThrows(NullPointerException.class, () -> new NQuadsSerializer(null, config), "Model cannot be null"); } @Test @DisplayName("Constructor should throw NullPointerException for null config") void constructorShouldThrowForNullConfig() { - assertThrows(NullPointerException.class, () -> new NQuadsFormat(model, null), "Configuration cannot be null"); + assertThrows(NullPointerException.class, () -> new NQuadsSerializer(model, null), "Configuration cannot be null"); } @Test @@ -210,7 +209,7 @@ void writeShouldHandleNullContext() throws SerializationException { mockExPerson, mockExName, mockLiteralJohn, - null // Explicitly null context + null ); when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); @@ -272,7 +271,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { Writer writer = new StringWriter(); - NQuadsFormat serializer = new NQuadsFormat(currentTestModel, FormatConfig.nquadsConfig()); + NQuadsSerializer serializer = new NQuadsSerializer(currentTestModel, FormatConfig.nquadsConfig()); serializer.write(writer); String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java similarity index 96% rename from src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java rename to src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java index e127f5a7f..f7ed0cb03 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java @@ -18,11 +18,11 @@ import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.*; -class NTriplesFormatTest { +class NTriplesSerializerTest { private Model model; private FormatConfig config; - private NTriplesFormat nTriplesFormat; + private NTriplesSerializer nTriplesFormat; private Resource mockExPerson; private IRI mockExName; @@ -39,7 +39,7 @@ void setUp() { model = mock(Model.class); config = FormatConfig.ntriplesConfig(); - nTriplesFormat = new NTriplesFormat(model, config); + nTriplesFormat = new NTriplesSerializer(model, config); mockExPerson = createIRI("http://example.org/Person"); @@ -56,14 +56,14 @@ void setUp() { @Test @DisplayName("Constructor should throw NullPointerException for null model") void constructorShouldThrowForNullModel() { - assertThrows(NullPointerException.class, () -> new NTriplesFormat(null), "Model cannot be null"); - assertThrows(NullPointerException.class, () -> new NTriplesFormat(null, config), "Model cannot be null"); + assertThrows(NullPointerException.class, () -> new NTriplesSerializer(null), "Model cannot be null"); + assertThrows(NullPointerException.class, () -> new NTriplesSerializer(null, config), "Model cannot be null"); } @Test @DisplayName("Constructor should throw NullPointerException for null config") void constructorShouldThrowForNullConfig() { - assertThrows(NullPointerException.class, () -> new NTriplesFormat(model, null), "Configuration cannot be null"); + assertThrows(NullPointerException.class, () -> new NTriplesSerializer(model, null), "Configuration cannot be null"); } @Test @@ -209,7 +209,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { .strictMode(true) // Keep strict mode enabled to test validation .build(); - NTriplesFormat serializer = new NTriplesFormat(modelMock, testConfig); + NTriplesSerializer serializer = new NTriplesSerializer(modelMock, testConfig); StringWriter writer = new StringWriter(); serializer.write(writer); @@ -235,7 +235,7 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { Model currentTestModel = mock(Model.class); when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); - NTriplesFormat serializer = new NTriplesFormat(currentTestModel, FormatConfig.ntriplesConfig()); + NTriplesSerializer serializer = new NTriplesSerializer(currentTestModel, FormatConfig.ntriplesConfig()); StringWriter writer = new StringWriter(); serializer.write(writer); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerTest.java deleted file mode 100644 index 1fefad379..000000000 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerTest.java +++ /dev/null @@ -1,124 +0,0 @@ -package fr.inria.corese.core.next.impl.common.serialization; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.Mockito.mockConstruction; -import static org.mockito.Mockito.verify; - -import java.io.Writer; - -import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; -import org.mockito.Mock; -import org.mockito.MockedConstruction; -import org.mockito.MockitoAnnotations; - - -class SerializerTest { - - private Serializer serializer; - - @Mock - private Model mockModel; - @Mock - private FormatConfig mockConfig; - @Mock - private Writer mockWriter; - - @BeforeEach - void setUp() { - MockitoAnnotations.openMocks(this); - serializer = new Serializer(mockModel, mockConfig); - } - - // --- Constructor tests --- - - @Test - @DisplayName("Constructor should throw NullPointerException for null model") - void constructorShouldThrowForNullModel() { - assertThrows(NullPointerException.class, () -> new Serializer(null), "Model cannot be null"); - assertThrows(NullPointerException.class, () -> new Serializer(null, mockConfig), "Model cannot be null"); - } - - @Test - @DisplayName("Constructor should throw NullPointerException for null config") - void constructorShouldThrowForNullConfig() { - assertThrows(NullPointerException.class, () -> new Serializer(mockModel, null), "FormatConfig cannot be null"); - } - - // --- Tests for the arguments of the serialize method --- - - @Test - @DisplayName("serialize should throw NullPointerException for null writer") - void serializeShouldThrowForNullWriter() { - assertThrows(NullPointerException.class, () -> serializer.serialize(null, RdfFormat.NTRIPLES), - "Writer cannot be null"); - } - - @Test - @DisplayName("serialize should throw NullPointerException for null format") - void serializeShouldThrowForNullFormat() { - assertThrows(NullPointerException.class, () -> serializer.serialize(mockWriter, null), - "RdfFormat cannot be null"); - } - - // --- Serialization delegation tests --- - - @Test - @DisplayName("serialize should delegate to NTriplesFormat for NTRIPLES format") - void serializeShouldDelegateToNTriplesFormat() throws SerializationException { - try (MockedConstruction mockedNtConstructor = mockConstruction(NTriplesFormat.class)) { - serializer.serialize(mockWriter, RdfFormat.NTRIPLES); - - assertEquals(1, mockedNtConstructor.constructed().size(), - "NTriplesFormat constructor should be called once"); - - NTriplesFormat createdNtSerializer = mockedNtConstructor.constructed().get(0); - - verify(createdNtSerializer).write(mockWriter); - } - } - - @Test - @DisplayName("serialize should delegate to NQuadsFormat for NQUADS format") - void serializeShouldDelegateToNQuadsFormat() throws SerializationException { - try (MockedConstruction mockedNqConstructor = mockConstruction(NQuadsFormat.class)) { - serializer.serialize(mockWriter, RdfFormat.NQUADS); - - assertEquals(1, mockedNqConstructor.constructed().size(), "NQuadsFormat constructor should be called once"); - NQuadsFormat createdNqSerializer = mockedNqConstructor.constructed().get(0); - - verify(createdNqSerializer).write(mockWriter); - } - } - - @Test - @DisplayName("serialize should delegate to TurtleFormat for TURTLE format") - void serializeShouldDelegateToTurtleFormat() throws SerializationException { - try (MockedConstruction mockedTurtleConstructor = mockConstruction(TurtleFormat.class)) { - serializer.serialize(mockWriter, RdfFormat.TURTLE); - - assertEquals(1, mockedTurtleConstructor.constructed().size(), "TurtleFormat constructor should be called once"); - TurtleFormat createdTurtleSerializer = mockedTurtleConstructor.constructed().get(0); - - verify(createdTurtleSerializer).write(mockWriter); - } - } - - @Test - @DisplayName("serialize should delegate to TriGFormat for TRIG format") - void serializeShouldDelegateToTriGFormat() throws SerializationException { - try (MockedConstruction mockedTriGConstructor = mockConstruction(TriGFormat.class)) { - serializer.serialize(mockWriter, RdfFormat.TRIG); - - assertEquals(1, mockedTriGConstructor.constructed().size(), "TriGFormat constructor should be called once"); - TriGFormat createdTriGSerializer = mockedTriGConstructor.constructed().get(0); - - verify(createdTriGSerializer).write(mockWriter); - } - } -} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java rename to src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java index e3684b5ef..bd918cd39 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java @@ -18,10 +18,10 @@ import static org.mockito.Mockito.*; /** - * Test class for {@link TriGFormat} using Mockito to verify serialization behavior + * Test class for {@link TriGSerializerTest} using Mockito to verify serialization behavior * under various configurations and RDF graph structures. */ -class TriGFormatTest { +class TriGSerializerTest { /** * Tests basic TriG serialization of a simple triple. @@ -75,7 +75,7 @@ void testBasicTriGSerialization() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TriGFormat trigFormat = new TriGFormat(mockModel, FormatConfig.trigConfig()); + TriGSerializer trigFormat = new TriGSerializer(mockModel, FormatConfig.trigConfig()); trigFormat.write(writer); @@ -150,7 +150,7 @@ void testRdfTypeShortcut() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TriGFormat trigFormat = new TriGFormat(mockModel); + TriGSerializer trigFormat = new TriGSerializer(mockModel); trigFormat.write(writer); @@ -250,7 +250,7 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { .trailingDot(true) .strictMode(false) .build(); - TriGFormat trigFormat = new TriGFormat(mockModel, config); + TriGSerializer trigFormat = new TriGSerializer(mockModel, config); trigFormat.write(writer); @@ -341,7 +341,7 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc .usePrefixes(true) .autoDeclarePrefixes(true) .build(); - TriGFormat triGFormat = new TriGFormat(mockModel, config); + TriGSerializer triGFormat = new TriGSerializer(mockModel, config); triGFormat.write(writer); @@ -426,7 +426,7 @@ void testBaseIRI() throws SerializationException, IOException { .usePrefixes(true) .autoDeclarePrefixes(true) .build(); - TriGFormat trigFormat = new TriGFormat(mockModel, configWithBase); + TriGSerializer trigFormat = new TriGSerializer(mockModel, configWithBase); trigFormat.write(writer); @@ -463,7 +463,7 @@ void testEmptyModel() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TriGFormat triGFormat = new TriGFormat(emptyModel); + TriGSerializer triGFormat = new TriGSerializer(emptyModel); triGFormat.write(writer); @@ -536,7 +536,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { StringWriter writer = new StringWriter(); FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).build(); - TriGFormat triGFormat = new TriGFormat(mockModel, strictConfig); + TriGSerializer triGFormat = new TriGSerializer(mockModel, strictConfig); SerializationException thrown = assertThrows(SerializationException.class, () -> { @@ -597,7 +597,7 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { StringWriter writer = new StringWriter(); FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).validateURIs(true).build(); - TriGFormat triGFormat = new TriGFormat(mockModel, strictConfig); + TriGSerializer triGFormat = new TriGSerializer(mockModel, strictConfig); SerializationException thrown = assertThrows(SerializationException.class, () -> { @@ -664,7 +664,7 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .prettyPrint(true) .autoDeclarePrefixes(true) .build(); - TriGFormat triGFormat = new TriGFormat(mockModel, config); + TriGSerializer triGFormat = new TriGSerializer(mockModel, config); triGFormat.write(writer); @@ -751,7 +751,7 @@ void testBasicTrigSerializationWithNamedGraph() throws SerializationException, I StringWriter writer = new StringWriter(); - TriGFormat trigFormat = new TriGFormat(mockModel, FormatConfig.trigConfig()); + TriGSerializer trigFormat = new TriGSerializer(mockModel, FormatConfig.trigConfig()); trigFormat.write(writer); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java similarity index 97% rename from src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java rename to src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java index e550580a1..832a471ce 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleFormatTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java @@ -18,10 +18,10 @@ import static org.mockito.Mockito.*; /** - * Test class for {@link TurtleFormat} using Mockito to verify serialization behavior + * Test class for {@link TurtleSerializerTest} using Mockito to verify serialization behavior * under various configurations and RDF graph structures. */ -class TurtleFormatTest { +class TurtleSerializerTest { /** * Tests basic Turtle serialization of a simple triple. @@ -75,7 +75,7 @@ void testBasicTurtleSerialization() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel, FormatConfig.turtleConfig()); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, FormatConfig.turtleConfig()); // When turtleFormat.write(writer); @@ -150,7 +150,7 @@ void testRdfTypeShortcut() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel); // When turtleFormat.write(writer); @@ -249,7 +249,7 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { .trailingDot(true) .strictMode(false) .build(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel, config); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, config); // When turtleFormat.write(writer); @@ -340,7 +340,7 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc .usePrefixes(true) .autoDeclarePrefixes(true) .build(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel, config); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, config); // When turtleFormat.write(writer); @@ -440,7 +440,7 @@ void testBlankNodeSerialization() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel, FormatConfig.turtleConfig()); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, FormatConfig.turtleConfig()); turtleFormat.write(writer); @@ -526,7 +526,7 @@ void testBaseIRI() throws SerializationException, IOException { .usePrefixes(true) .autoDeclarePrefixes(true) .build(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel, configWithBase); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, configWithBase); turtleFormat.write(writer); @@ -563,7 +563,7 @@ void testEmptyModel() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TurtleFormat turtleFormat = new TurtleFormat(emptyModel); + TurtleSerializer turtleFormat = new TurtleSerializer(emptyModel); turtleFormat.write(writer); @@ -636,7 +636,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { StringWriter writer = new StringWriter(); FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).build(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel, strictConfig); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, strictConfig); SerializationException thrown = assertThrows(SerializationException.class, () -> { @@ -697,7 +697,7 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { StringWriter writer = new StringWriter(); FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).validateURIs(true).build(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel, strictConfig); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, strictConfig); SerializationException thrown = assertThrows(SerializationException.class, () -> { @@ -764,7 +764,7 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .prettyPrint(true) .autoDeclarePrefixes(true) .build(); - TurtleFormat turtleFormat = new TurtleFormat(mockModel, config); + TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, config); // When turtleFormat.write(writer); From 6267288e5dc0e6612bcb1ec2365fae8d86859aa5 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Sat, 21 Jun 2025 00:38:35 +0200 Subject: [PATCH 11/27] =?UTF-8?q?ajouter=20le=20BufferedWriter=20directeme?= =?UTF-8?q?nt=20dans=20votre=20m=C3=A9thode=20write()=20et=20impl=C3=A9men?= =?UTF-8?q?tation=20compl=C3=A8te=20de=20RdfSerializationUtils?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../serialization/NQuadsSerializer.java | 30 +++++++++---- .../serialization/NTriplesSerializer.java | 28 ++++++++++--- .../common/serialization/TriGSerializer.java | 13 +++--- .../serialization/TurtleSerializer.java | 14 +++---- .../serialization/config/FormatConfig.java | 2 +- .../util/RdfSerializationUtils.java | 18 ++++++++ .../util/SerializationConstants.java | 2 +- .../serialization/FormatConfigTest.java | 2 +- .../serialization/NQuadsSerializerTest.java | 37 ++++++++-------- .../serialization/NTriplesSerializerTest.java | 35 +++++++++------- .../serialization/TriGSerializerTest.java | 42 +++++++++---------- .../serialization/TurtleSerializerTest.java | 42 +++++++++---------- 12 files changed, 162 insertions(+), 103 deletions(-) create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/RdfSerializationUtils.java rename src/main/java/fr/inria/corese/core/next/impl/common/{ => serialization}/util/SerializationConstants.java (97%) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java index 271bac707..ca7e9a729 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java @@ -4,15 +4,18 @@ import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.BufferedWriter; import java.io.IOException; import java.io.UncheckedIOException; import java.io.Writer; +import java.util.Collections; import java.util.Objects; +import java.util.Set; public class NQuadsSerializer implements IRdfSerializer { @@ -44,7 +47,7 @@ public NQuadsSerializer(Model model) { */ public NQuadsSerializer(Model model, ISerializationConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); } /** @@ -56,18 +59,31 @@ public NQuadsSerializer(Model model, ISerializationConfig config) { */ @Override public void write(Writer writer) throws SerializationException { - try { + try (BufferedWriter bufferedWriter = new BufferedWriter(writer)) { + Set processedNodes = preprocessModel(); + for (Statement stmt : model) { - writeStatement(writer, stmt); + if (shouldProcess(stmt, processedNodes)) { + writeStatement(bufferedWriter, stmt); + } } - writer.flush(); + } catch (IOException e) { - throw new SerializationException("Failed to write", "NQuads", e); + throw new SerializationException("N-Quads serialization failed", "N-Quads", e); } catch (IllegalArgumentException e) { - throw new SerializationException("Invalid data: " + e.getMessage(), "NQuads", e); + throw new SerializationException("Invalid N-Quads data: " + e.getMessage(), "N-Quads", e); } } + private Set preprocessModel() { + return Collections.emptySet(); + } + + private boolean shouldProcess(Statement stmt, Set processedNodes) { + + return !processedNodes.contains(stmt.getSubject()); + } + /** * Writes a single {@link Statement} (quad) to the writer in N-Quads format. * The statement is written as "$subject $predicate $object $context ." if a context is present diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java index 9b14e2a6c..f38ceeb5e 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java @@ -4,15 +4,18 @@ import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.BufferedWriter; import java.io.IOException; import java.io.UncheckedIOException; import java.io.Writer; +import java.util.Collections; import java.util.Objects; +import java.util.Set; /** * Serializes a Corese {@link Model} into N-Triples format. @@ -60,18 +63,31 @@ public NTriplesSerializer(Model model, ISerializationConfig config) { */ @Override public void write(Writer writer) throws SerializationException { - try { + try (BufferedWriter bufferedWriter = new BufferedWriter(writer)) { + Set processedNodes = preprocessModel(); + for (Statement stmt : model) { - writeStatement(writer, stmt); + if (shouldProcess(stmt, processedNodes)) { + writeStatement(bufferedWriter, stmt); + } } - writer.flush(); + } catch (IOException e) { - throw new SerializationException("Failed to write", "NTriples", e); + throw new SerializationException("NTriples serialization failed", "NTriples", e); } catch (IllegalArgumentException e) { - throw new SerializationException("Invalid data: " + e.getMessage(), "NTriples", e); + throw new SerializationException("Invalid NTriples data: " + e.getMessage(), "NTriples", e); } } + private Set preprocessModel() { + return Collections.emptySet(); + } + + private boolean shouldProcess(Statement stmt, Set processedNodes) { + + return !processedNodes.contains(stmt.getSubject()); + } + /** * Writes a single {@link Statement} to the writer in N-Triples format. * The statement is written as "$subject $predicate $object ." diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java index 388ecc6db..7ab5bd4b0 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java @@ -6,11 +6,12 @@ import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.BufferedWriter; import java.io.IOException; import java.io.UncheckedIOException; import java.io.Writer; @@ -104,18 +105,18 @@ private void initializePrefixes() { */ @Override public void write(Writer writer) throws SerializationException { - try { - writeHeader(writer); + try (Writer bufferedWriter = new BufferedWriter(writer)) { + writeHeader(bufferedWriter); Set precomputedInlineBlankNodes = precomputeInlineBlankNodesAndLists(); consumedBlankNodes.addAll(precomputedInlineBlankNodes); if (config.includeContext()) { - writeStatementsWithContext(writer); + writeStatementsWithContext(bufferedWriter); } else if (config.useCompactTriples() && config.groupBySubject()) { - writeOptimizedStatements(writer); + writeOptimizedStatements(bufferedWriter); } else { - writeSimpleStatements(writer); + writeSimpleStatements(bufferedWriter); } writer.flush(); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java index 728e13d6f..084c6333d 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java @@ -6,11 +6,12 @@ import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.BufferedWriter; import java.io.IOException; import java.io.UncheckedIOException; import java.io.Writer; @@ -103,21 +104,20 @@ private void initializePrefixes() { */ @Override public void write(Writer writer) throws SerializationException { - try { - writeHeader(writer); + try (Writer bufferedWriter = new BufferedWriter(writer)) { + writeHeader(bufferedWriter); Set precomputedInlineBlankNodes = precomputeInlineBlankNodesAndLists(); consumedBlankNodes.addAll(precomputedInlineBlankNodes); if (config.useCompactTriples() && config.groupBySubject()) { - writeOptimizedStatements(writer); + writeOptimizedStatements(bufferedWriter); } else { - writeSimpleStatements(writer); + writeSimpleStatements(bufferedWriter); } - writer.flush(); } catch (IOException e) { - throw new SerializationException("Failed to write to stream for Turtle format", "Turtle", e); + throw new SerializationException("Failed to write Turtle output", "Turtle", e); } catch (IllegalArgumentException e) { throw new SerializationException("Invalid data for Turtle format: " + e.getMessage(), "Turtle", e); } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java index 3e9651ec1..ff2c07919 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization.config; import fr.inria.corese.core.next.api.ISerializationConfig; -import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import java.util.Collections; import java.util.HashMap; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/RdfSerializationUtils.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/RdfSerializationUtils.java new file mode 100644 index 000000000..f72d594e0 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/RdfSerializationUtils.java @@ -0,0 +1,18 @@ +package fr.inria.corese.core.next.impl.common.serialization.util; + + +/** + * Utilities for RDF serialization, providing common constants and basic writing operations + * that are independent of the specific RDF serialization format's syntax intricacies. + * Format-specific escaping and advanced structural serialization (e.g., inline blank nodes, collections) + * are handled by the individual serializer classes. + */ +public final class RdfSerializationUtils { + + private RdfSerializationUtils() {} + + + + + +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java similarity index 97% rename from src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java index 26c1fdbe7..2067ebadf 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/util/SerializationConstants.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java @@ -1,4 +1,4 @@ -package fr.inria.corese.core.next.impl.common.util; +package fr.inria.corese.core.next.impl.common.serialization.util; /** * Provides common constants used throughout the RDF serialization process. diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java index 3d0a0e8c3..000829cf7 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java @@ -4,7 +4,7 @@ import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java index 2d5dc47f9..4c31a9143 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java @@ -24,7 +24,7 @@ class NQuadsSerializerTest { private Model model; private FormatConfig config; - private NQuadsSerializer nQuadsFormat; + private NQuadsSerializer nQuadsSerializer; private Resource mockExPerson; private IRI mockExName; @@ -44,7 +44,7 @@ class NQuadsSerializerTest { void setUp() { model = mock(Model.class); config = FormatConfig.nquadsConfig(); - nQuadsFormat = new NQuadsSerializer(model, config); + nQuadsSerializer = new NQuadsSerializer(model, config); mockExPerson = createIRI("http://example.org/Person"); mockExName = createIRI("http://example.org/name"); @@ -83,7 +83,7 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - nQuadsFormat.write(writer); + nQuadsSerializer.write(writer); String expected = String.format("<%s> <%s> \"%s\"", @@ -105,7 +105,7 @@ void writeShouldHandleBlankNodes() throws SerializationException { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - nQuadsFormat.write(writer); + nQuadsSerializer.write(writer); String expected = String.format("_:%s <%s> _:%s", mockBNode1.stringValue(), @@ -128,7 +128,7 @@ void writeShouldHandleBlankNodesInContext() throws SerializationException { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - nQuadsFormat.write(writer); + nQuadsSerializer.write(writer); String expected = String.format("_:%s <%s> <%s> _:%s", mockBNode1.stringValue(), @@ -151,9 +151,12 @@ void writeShouldThrowOnIOException() throws IOException { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); Writer faultyWriter = mock(Writer.class); - doThrow(new IOException("Simulated IO error")).when(faultyWriter).write(anyString()); + doThrow(new IOException("Simulated IO error during write")).when(faultyWriter).write(anyString()); + doThrow(new IOException("Simulated IO error (char array)")).when(faultyWriter).write(any(char[].class), anyInt(), anyInt()); + doThrow(new IOException("Simulated IO error (close)")).when(faultyWriter).close(); - assertThrows(SerializationException.class, () -> nQuadsFormat.write(faultyWriter)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsSerializer.write(faultyWriter)); + assertEquals("N-Quads serialization failed [Format: N-Quads]", thrown.getMessage()); } @Test @@ -167,8 +170,8 @@ void writeShouldThrowOnNullSubjectValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); - assertEquals("Invalid data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: NQuads]", thrown.getMessage()); + SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsSerializer.write(writer)); + assertEquals("Invalid N-Quads data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: N-Quads]", thrown.getMessage()); } @Test @@ -182,8 +185,8 @@ void writeShouldThrowOnNullPredicateValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); - assertEquals("Invalid data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: NQuads]", thrown.getMessage()); + SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsSerializer.write(writer)); + assertEquals("Invalid N-Quads data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: N-Quads]", thrown.getMessage()); } @Test @@ -197,8 +200,8 @@ void writeShouldThrowOnNullObjectValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsFormat.write(writer)); - assertEquals("Invalid data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: NQuads]", thrown.getMessage()); + SerializationException thrown = assertThrows(SerializationException.class, () -> nQuadsSerializer.write(writer)); + assertEquals("Invalid N-Quads data: Value cannot be null in N-Quads format when strictMode is enabled. [Format: N-Quads]", thrown.getMessage()); } @Test @@ -214,7 +217,7 @@ void writeShouldHandleNullContext() throws SerializationException { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - nQuadsFormat.write(writer); + nQuadsSerializer.write(writer); String expected = String.format("<%s> <%s> \"%s\"", @@ -248,7 +251,7 @@ void writeShouldHandleVariousLiterals(String literalValue) throws SerializationE when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - nQuadsFormat.write(writer); + nQuadsSerializer.write(writer); String expectedEscapedLiteral = escapeNQuadsString(literalValue); @@ -288,7 +291,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { * Creates a mocked Literal object. * Important: The `lexicalForm` is the *raw string value* of the literal, * without N-Quads specific quotes, lang tags, or datatype URIs. - * The `NQuadsFormat` class is responsible for adding those. + * The `nQuadsSerializer` class is responsible for adding those. * * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. @@ -314,7 +317,7 @@ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTa /** * Escapes a string according to N-Quads literal escaping rules. * This helper is used in tests to construct the *expected* output strings. - * It mimics the behavior of NQuadsFormat's internal escapeLiteral method, + * It mimics the behavior of nQuadsSerializer's internal escapeLiteral method, * considering that `nquadsConfig().escapeUnicode()` is `true`. * * @param s The string to escape. diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java index f7ed0cb03..ead78391a 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java @@ -22,7 +22,7 @@ class NTriplesSerializerTest { private Model model; private FormatConfig config; - private NTriplesSerializer nTriplesFormat; + private NTriplesSerializer nTriplesSerializer; private Resource mockExPerson; private IRI mockExName; @@ -39,7 +39,7 @@ void setUp() { model = mock(Model.class); config = FormatConfig.ntriplesConfig(); - nTriplesFormat = new NTriplesSerializer(model, config); + nTriplesSerializer = new NTriplesSerializer(model, config); mockExPerson = createIRI("http://example.org/Person"); @@ -77,7 +77,7 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - nTriplesFormat.write(writer); + nTriplesSerializer.write(writer); String expected = String.format("<%s> <%s> \"%s\"", @@ -101,7 +101,7 @@ void writeShouldSerializeStatementWithContext() throws SerializationException { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - nTriplesFormat.write(writer); + nTriplesSerializer.write(writer); String expected = String.format("<%s> <%s> \"%s\"", mockExPerson.stringValue(), @@ -122,7 +122,7 @@ void writeShouldHandleBlankNodes() throws SerializationException { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - nTriplesFormat.write(writer); + nTriplesSerializer.write(writer); String expected = String.format("_:%s <%s> _:%s", mockBNode1.stringValue(), @@ -144,11 +144,16 @@ void writeShouldThrowOnIOException() throws IOException { Writer faultyWriter = mock(Writer.class); - doThrow(new IOException("Simulated IO error")).when(faultyWriter).write(anyString()); + doThrow(new IOException("Simulated IO error during write")).when(faultyWriter).write(anyString()); + doThrow(new IOException("Simulated IO error (char array)")).when(faultyWriter).write(any(char[].class), anyInt(), anyInt()); + doThrow(new IOException("Simulated IO error (close)")).when(faultyWriter).close(); - assertThrows(SerializationException.class, () -> nTriplesFormat.write(faultyWriter)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesSerializer.write(faultyWriter)); + + assertEquals("NTriples serialization failed [Format: NTriples]", thrown.getMessage()); } + @Test @DisplayName("Write should throw SerializationException on null subject value from Statement in strict mode") void writeShouldThrowOnNullSubjectValue() { @@ -159,9 +164,9 @@ void writeShouldThrowOnNullSubjectValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); + SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesSerializer.write(writer)); - assertEquals("Invalid data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); + assertEquals("Invalid NTriples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); } @Test @@ -174,8 +179,8 @@ void writeShouldThrowOnNullPredicateValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); - assertEquals("Invalid data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); + SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesSerializer.write(writer)); + assertEquals("Invalid NTriples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); } @Test @@ -188,8 +193,8 @@ void writeShouldThrowOnNullObjectValue() { when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); - SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesFormat.write(writer)); - assertEquals("Invalid data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); + SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesSerializer.write(writer)); + assertEquals("Invalid NTriples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); } @@ -253,7 +258,7 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { /** * Escapes a string according to N-Triples literal escaping rules. * This helper is used in tests to construct the *expected* output strings. - * It mimics the behavior of NTriplesFormat's internal escapeLiteral method, + * It mimics the behavior of nTriplesSerializer's internal escapeLiteral method, * specifically when `escapeUnicode` is true (as per ntriplesConfig() default). * * @param s The string to escape. @@ -321,7 +326,7 @@ public Statement next() { * Creates a mocked Literal object. * Important: The `lexicalForm` is the *raw string value* of the literal, * without N-Triples specific quotes, lang tags, or datatype URIs. - * The `NTriplesFormat` class is responsible for adding those. + * The `nTriplesSerializer` class is responsible for adding those. * * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java index bd918cd39..39217d346 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java @@ -4,7 +4,7 @@ import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.Test; @@ -75,10 +75,10 @@ void testBasicTriGSerialization() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TriGSerializer trigFormat = new TriGSerializer(mockModel, FormatConfig.trigConfig()); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, FormatConfig.trigConfig()); - trigFormat.write(writer); + triGSerializer.write(writer); verify(mockModel, times(2)).stream(); @@ -150,10 +150,10 @@ void testRdfTypeShortcut() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TriGSerializer trigFormat = new TriGSerializer(mockModel); + TriGSerializer triGSerializer = new TriGSerializer(mockModel); - trigFormat.write(writer); + triGSerializer.write(writer); verify(mockModel, times(2)).stream(); @@ -250,10 +250,10 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { .trailingDot(true) .strictMode(false) .build(); - TriGSerializer trigFormat = new TriGSerializer(mockModel, config); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, config); - trigFormat.write(writer); + triGSerializer.write(writer); verify(mockModel, times(2)).stream(); @@ -341,10 +341,10 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc .usePrefixes(true) .autoDeclarePrefixes(true) .build(); - TriGSerializer triGFormat = new TriGSerializer(mockModel, config); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, config); - triGFormat.write(writer); + triGSerializer.write(writer); verify(mockModel, times(2)).stream(); @@ -426,9 +426,9 @@ void testBaseIRI() throws SerializationException, IOException { .usePrefixes(true) .autoDeclarePrefixes(true) .build(); - TriGSerializer trigFormat = new TriGSerializer(mockModel, configWithBase); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, configWithBase); - trigFormat.write(writer); + triGSerializer.write(writer); verify(mockModel, times(2)).stream(); String expected = """ @@ -463,10 +463,10 @@ void testEmptyModel() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TriGSerializer triGFormat = new TriGSerializer(emptyModel); + TriGSerializer triGSerializer = new TriGSerializer(emptyModel); - triGFormat.write(writer); + triGSerializer.write(writer); verify(emptyModel, times(2)).stream(); @@ -536,11 +536,11 @@ void testStrictModeInvalidLiteral() throws SerializationException { StringWriter writer = new StringWriter(); FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).build(); - TriGSerializer triGFormat = new TriGSerializer(mockModel, strictConfig); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, strictConfig); SerializationException thrown = assertThrows(SerializationException.class, () -> { - triGFormat.write(writer); + triGSerializer.write(writer); }); assertEquals("TriG", thrown.getFormatName()); @@ -597,11 +597,11 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { StringWriter writer = new StringWriter(); FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).validateURIs(true).build(); - TriGSerializer triGFormat = new TriGSerializer(mockModel, strictConfig); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, strictConfig); SerializationException thrown = assertThrows(SerializationException.class, () -> { - triGFormat.write(writer); + triGSerializer.write(writer); }); assertEquals("TriG", thrown.getFormatName()); @@ -664,10 +664,10 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .prettyPrint(true) .autoDeclarePrefixes(true) .build(); - TriGSerializer triGFormat = new TriGSerializer(mockModel, config); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, config); - triGFormat.write(writer); + triGSerializer.write(writer); verify(mockModel, times(2)).stream(); @@ -751,10 +751,10 @@ void testBasicTrigSerializationWithNamedGraph() throws SerializationException, I StringWriter writer = new StringWriter(); - TriGSerializer trigFormat = new TriGSerializer(mockModel, FormatConfig.trigConfig()); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, FormatConfig.trigConfig()); - trigFormat.write(writer); + triGSerializer.write(writer); verify(mockModel, times(2)).stream(); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java index 832a471ce..df4cdc2a6 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java @@ -4,7 +4,7 @@ import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.util.SerializationConstants; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.Test; @@ -75,10 +75,10 @@ void testBasicTurtleSerialization() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, FormatConfig.turtleConfig()); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, FormatConfig.turtleConfig()); // When - turtleFormat.write(writer); + turtleSerializer.write(writer); // Then verify(mockModel, times(2)).stream(); @@ -150,10 +150,10 @@ void testRdfTypeShortcut() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel); // When - turtleFormat.write(writer); + turtleSerializer.write(writer); // Then verify(mockModel, times(2)).stream(); @@ -249,10 +249,10 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { .trailingDot(true) .strictMode(false) .build(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, config); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, config); // When - turtleFormat.write(writer); + turtleSerializer.write(writer); // Then verify(mockModel, times(2)).stream(); @@ -340,10 +340,10 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc .usePrefixes(true) .autoDeclarePrefixes(true) .build(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, config); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, config); // When - turtleFormat.write(writer); + turtleSerializer.write(writer); // Then verify(mockModel, times(2)).stream(); @@ -440,9 +440,9 @@ void testBlankNodeSerialization() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, FormatConfig.turtleConfig()); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, FormatConfig.turtleConfig()); - turtleFormat.write(writer); + turtleSerializer.write(writer); verify(mockModel, times(5)).stream(); @@ -526,9 +526,9 @@ void testBaseIRI() throws SerializationException, IOException { .usePrefixes(true) .autoDeclarePrefixes(true) .build(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, configWithBase); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, configWithBase); - turtleFormat.write(writer); + turtleSerializer.write(writer); verify(mockModel, times(2)).stream(); String expected = """ @@ -563,10 +563,10 @@ void testEmptyModel() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TurtleSerializer turtleFormat = new TurtleSerializer(emptyModel); + TurtleSerializer turtleSerializer = new TurtleSerializer(emptyModel); - turtleFormat.write(writer); + turtleSerializer.write(writer); verify(emptyModel, times(2)).stream(); @@ -636,11 +636,11 @@ void testStrictModeInvalidLiteral() throws SerializationException { StringWriter writer = new StringWriter(); FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).build(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, strictConfig); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, strictConfig); SerializationException thrown = assertThrows(SerializationException.class, () -> { - turtleFormat.write(writer); + turtleSerializer.write(writer); }); assertEquals("Turtle", thrown.getFormatName()); @@ -697,11 +697,11 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { StringWriter writer = new StringWriter(); FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).validateURIs(true).build(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, strictConfig); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, strictConfig); SerializationException thrown = assertThrows(SerializationException.class, () -> { - turtleFormat.write(writer); + turtleSerializer.write(writer); }); assertEquals("Turtle", thrown.getFormatName()); @@ -764,10 +764,10 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .prettyPrint(true) .autoDeclarePrefixes(true) .build(); - TurtleSerializer turtleFormat = new TurtleSerializer(mockModel, config); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, config); // When - turtleFormat.write(writer); + turtleSerializer.write(writer); // Then verify(mockModel, times(2)).stream(); From 675a0ac526842bd563128af2b1f3230819f411af Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Tue, 24 Jun 2025 08:49:41 +0200 Subject: [PATCH 12/27] Serializer to be separated into a factory class for serializers. Add a (possibly empty) Config interface for config objects --- .../DefaultSerializerFactory.java | 6 ++- .../common/serialization/XmlSerializer.java | 4 ++ .../serialization/config/FormatConfig.java | 37 +++++++++++++++++- .../util/RdfSerializationUtils.java | 18 --------- .../util/SerializationConstants.java | 19 ++++++++++ .../serialization/FormatConfigTest.java | 38 +++++++++++++++++++ .../serialization/XmlSerializerTest.java | 4 ++ 7 files changed, 104 insertions(+), 22 deletions(-) create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/RdfSerializationUtils.java create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java index 05db36894..9ffe333b2 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java @@ -27,12 +27,14 @@ public class DefaultSerializerFactory implements ISerializerFactory { * with constructors for all known {@link RdfFormat} implementations. */ public DefaultSerializerFactory() { - Map> tempRegistry = new HashMap<>(); // Changed to IFormatConfig + Map> tempRegistry = new HashMap<>(); // Cast the lambda to BiFunction tempRegistry.put(RdfFormat.TURTLE, (model, config) -> new TurtleSerializer(model, (FormatConfig) config)); tempRegistry.put(RdfFormat.NTRIPLES, (model, config) -> new NTriplesSerializer(model, (FormatConfig) config)); tempRegistry.put(RdfFormat.NQUADS, (model, config) -> new NQuadsSerializer(model, (FormatConfig) config)); tempRegistry.put(RdfFormat.TRIG, (model, config) -> new TriGSerializer(model, (FormatConfig) config)); + tempRegistry.put(RdfFormat.RDFXML, (model, config) -> new XmlSerializer(model, (FormatConfig) config)); + this.registry = Collections.unmodifiableMap(tempRegistry); } @@ -41,7 +43,7 @@ public DefaultSerializerFactory() { * * @param format the {@link RdfFormat} for which to create the serializer. Must not be null. * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link ISerializationConfig} to apply during serialization. Must not be null. // Changed to IFormatConfig + * @param config the {@link ISerializationConfig} to apply during serialization. Must not be null. * @return a new instance of {@link IRdfSerializer} configured for the specified format. * @throws NullPointerException if any of the arguments (format, model, config) are null. * @throws IllegalArgumentException if the provided format is not supported by this factory. diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java new file mode 100644 index 000000000..efbb46eae --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +public class XmlSerializer { +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java index ff2c07919..2c1404794 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java @@ -537,9 +537,42 @@ public static FormatConfig trigConfig() { .build(); } + /** + * Returns a default configuration suitable for RDF/XML serialization. + * RDF/XML is an XML-based syntax for RDF graphs. + * + * @return A {@code FormatConfig} instance for RDF/XML. + */ + public static FormatConfig rdfXmlConfig() { + Map commonRdfXmlPrefixes = new HashMap<>(); + commonRdfXmlPrefixes.put("rdf", SerializationConstants.RDF_NS); + commonRdfXmlPrefixes.put("rdfs", SerializationConstants.RDFS_NS); + commonRdfXmlPrefixes.put("xsd", SerializationConstants.XSD_NS); + commonRdfXmlPrefixes.put("owl", SerializationConstants.OWL_NS); + + return new Builder().usePrefixes(true) + .autoDeclarePrefixes(true) + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL).addCustomPrefixes(commonRdfXmlPrefixes).useCompactTriples(false) + .useRdfTypeShortcut(false) + .useCollections(false) + .blankNodeStyle(BlankNodeStyleEnum.NAMED) + .prettyPrint(true) + .indent(SerializationConstants.DEFAULT_INDENTATION).maxLineLength(0) + .groupBySubject(false) + .sortSubjects(false) + .sortPredicates(false) + .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) + .escapeUnicode(false) + .trailingDot(false) + .baseIRI(null) + .stableBlankNodeIds(true) + .strictMode(true).validateURIs(true).useMultilineLiterals(true) + .includeContext(false) + .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING).build(); + } + public boolean shouldUseTripleQuotes(String literalValue) { - return useMultilineLiterals && - (literalValue.contains(SerializationConstants.LINE_FEED) || literalValue.contains(SerializationConstants.CARRIAGE_RETURN)); + return useMultilineLiterals && (literalValue.contains(SerializationConstants.LINE_FEED) || literalValue.contains(SerializationConstants.CARRIAGE_RETURN)); } public boolean shouldOptimizeOutput() { diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/RdfSerializationUtils.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/RdfSerializationUtils.java deleted file mode 100644 index f72d594e0..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/RdfSerializationUtils.java +++ /dev/null @@ -1,18 +0,0 @@ -package fr.inria.corese.core.next.impl.common.serialization.util; - - -/** - * Utilities for RDF serialization, providing common constants and basic writing operations - * that are independent of the specific RDF serialization format's syntax intricacies. - * Format-specific escaping and advanced structural serialization (e.g., inline blank nodes, collections) - * are handled by the individual serializer classes. - */ -public final class RdfSerializationUtils { - - private RdfSerializationUtils() {} - - - - - -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java index 2067ebadf..c63dcda05 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java @@ -77,4 +77,23 @@ private SerializationConstants() { public static final String OPEN_BRACE = "{"; public static final String CLOSE_BRACE = "}"; + // XML-specific constants + public static final String XML_DECLARATION_START = ""; + public static final String RDF_ROOT_START = " customPrefixes = config.getCustomPrefixes(); + assertFalse(customPrefixes.isEmpty()); + assertEquals(SerializationConstants.RDF_NS, customPrefixes.get("rdf")); + assertEquals(SerializationConstants.RDFS_NS, customPrefixes.get("rdfs")); + assertEquals(SerializationConstants.XSD_NS, customPrefixes.get("xsd")); + assertEquals(SerializationConstants.OWL_NS, customPrefixes.get("owl")); + } + + @Test @DisplayName("FormatConfig constructor should be private and only accessible via builder") diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java new file mode 100644 index 000000000..1489245e6 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +public class XmlSerializerTest { +} From beff6d8b3c0bcf596bdbec85212e0819a17b0430 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Tue, 24 Jun 2025 16:53:10 +0200 Subject: [PATCH 13/27] ajouter xml serializer --- .../common/serialization/XmlSerializer.java | 562 +++++++++++++++++- 1 file changed, 561 insertions(+), 1 deletion(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java index efbb46eae..5b4ffc8d9 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java @@ -1,4 +1,564 @@ package fr.inria.corese.core.next.impl.common.serialization; -public class XmlSerializer { +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.UncheckedIOException; +import java.io.Writer; +import java.util.*; +import java.util.stream.Collectors; + +/** + * Serializes a {@link Model} to RDF/XML format. + * This class provides a method to write the statements of a model to a {@link Writer} + * in accordance with the RDF/XML specification, considering configuration options. + * + *

This implementation handles:

+ *
    + *
  • Declaration and usage of XML namespaces for IRIs.
    • + *
  • Basic pretty-printing (indentation).
    • + *
  • Serialization of triples as rdf:Description elements with properties.
    • + *
  • Serialization of blank nodes using rdf:nodeID or nested elements.
    • + *
  • Serialization of literals with language tags or datatypes.
    • + *
+ *

Advanced features such as handling XML schemata, specific RDF/XML graph structures (e.g., rdf:Bag, rdf:Seq, rdf:Alt), + * and full blank node syntax optimization are simplified in this version.

+ */ +public class XmlSerializer implements IRdfSerializer { + + private static final Logger logger = LoggerFactory.getLogger(XmlSerializer.class); + + private final Model model; + private final FormatConfig config; + private final Map iriToPrefixMapping; + private final Map prefixToIriMapping; + private final Map blankNodeIds; + private int blankNodeCounter = 0; + private List cachedStatements; + + /** + * Constructs a new {@code XmlSerializer} instance with the specified model and default configuration. + * The default configuration is returned by {@link FormatConfig#rdfXmlConfig()}. + * + * @param model the {@link Model} to serialize. Must not be null. + * @throws NullPointerException if the provided model is null. + */ + public XmlSerializer(Model model) { + this(model, FormatConfig.rdfXmlConfig()); + } + + /** + * Constructs a new {@code XmlSerializer} instance with the specified model and custom configuration. + * + * @param model the {@link Model} to serialize. Must not be null. + * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. + * @throws NullPointerException if the provided model or configuration is null. + */ + public XmlSerializer(Model model, ISerializationConfig config) { + this.model = Objects.requireNonNull(model, "Model cannot be null"); + this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); + this.iriToPrefixMapping = new HashMap<>(); + this.prefixToIriMapping = new HashMap<>(); + this.blankNodeIds = new HashMap<>(); + initializePrefixes(); + } + + /** + * Initializes prefix mappings by adding custom prefixes from the configuration. + * The custom prefixes map in FormatConfig is expected to be {namespaceURI: prefix}. + */ + private void initializePrefixes() { + if (config.usePrefixes()) { + for (Map.Entry entry : config.getCustomPrefixes().entrySet()) { + addPrefixMapping(entry.getKey(), entry.getValue()); + } + } + } + + /** + * Writes the model to the given writer in RDF/XML format. + * + * @param writer the {@link Writer} to which the RDF/XML output will be written. + * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + */ + @Override + public void write(Writer writer) throws SerializationException { + try (Writer bufferedWriter = new BufferedWriter(writer)) { + this.cachedStatements = model.stream().toList(); + + writeXmlDeclaration(bufferedWriter); + writeRdfRootElement(bufferedWriter); + } catch (IOException e) { + throw new SerializationException("Failed to write RDF/XML output", "RDF/XML", e); + } catch (IllegalArgumentException e) { + throw new SerializationException("Invalid data for RDF/XML format: " + e.getMessage(), "RDF/XML", e); + } + } + + /** + * Writes the XML declaration at the beginning of the document. + * + * @param writer the {@link Writer} to which the declaration will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeXmlDeclaration(Writer writer) throws IOException { + writer.write(SerializationConstants.XML_DECLARATION_START); + writer.write(config.getLineEnding()); + } + + /** + * Writes the root `` element and its contents. + * This includes namespace declarations and all statements. + * + * @param writer the {@link Writer} to which the root element will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeRdfRootElement(Writer writer) throws IOException { + if (config.usePrefixes() && config.autoDeclarePrefixes()) { + collectUsedNamespaces(); + } + + writer.write(SerializationConstants.RDF_ROOT_START); + writeNamespaceAttributes(writer); + writer.write(">"); + writer.write(config.getLineEnding()); + + Map> statementsBySubject = cachedStatements.stream() + .collect(Collectors.groupingBy(Statement::getSubject)); + + + List sortedSubjects = new ArrayList<>(statementsBySubject.keySet()); + if (config.sortSubjects()) { + Collections.sort(sortedSubjects, Comparator.comparing(Value::stringValue)); + } + + for (Resource subject : sortedSubjects) { + writeDescriptionElement(writer, subject, statementsBySubject.get(subject), config.getIndent()); + } + + writer.write(SerializationConstants.RDF_ROOT_END); + writer.write(config.getLineEnding()); + } + + /** + * Writes the namespace attributes (`xmlns:prefix="uri"`) for the `` element. + * + * @param writer the {@link Writer} to which attributes will be written. + * @throws IOException if an I/O error occurs. + */ + private void writeNamespaceAttributes(Writer writer) throws IOException { + if (!iriToPrefixMapping.containsKey(SerializationConstants.RDF_NS)) { + addPrefixMapping(SerializationConstants.RDF_NS, "rdf"); + } + + List prefixes = new ArrayList<>(prefixToIriMapping.keySet()); + if (config.getPrefixOrdering() == PrefixOrderingEnum.ALPHABETICAL) { + Collections.sort(prefixes); + } + + for (String prefix : prefixes) { + String namespaceURI = prefixToIriMapping.get(prefix); + writer.write(String.format(" %s%s=\"%s\"", SerializationConstants.XMLNS_PREFIX, prefix, escapeXmlAttribute(namespaceURI))); + } + } + + /** + * Collects all namespaces used in the model (subjects, predicates, objects, contexts) + * and attempts to assign prefixes if auto-declaration is enabled and they are not already mapped. + */ + private void collectUsedNamespaces() { + Set namespaces = this.cachedStatements.stream() + .flatMap(stmt -> Arrays.asList( + stmt.getSubject(), + stmt.getPredicate(), + stmt.getObject() + ).stream()) + .filter(Value::isIRI) + .map(v -> getNamespace(v.stringValue())) + .collect(Collectors.toSet()); + + + namespaces.forEach(namespace -> { + if (!iriToPrefixMapping.containsKey(namespace)) { + String prefix = getSuggestedPrefix(namespace); + if (prefix != null) { + addPrefixMapping(namespace, prefix); + } + } + }); + } + + + /** + * Retrieves the prefixed name for a given IRI string. + * This method now prioritizes the longest matching namespace to ensure correct prefix application. + * + * @param iriString The full IRI. + * @return The prefixed name (e.g., "foaf:name") or null if no suitable prefix is found. + */ + private String getPrefixedNameInternal(String iriString) { + String longestMatchingNamespace = null; + String correspondingPrefix = null; + int longestMatchLength = -1; + + for (Map.Entry entry : iriToPrefixMapping.entrySet()) { + String namespace = entry.getKey(); + String prefix = entry.getValue(); + + if (iriString.startsWith(namespace)) { + if (namespace.length() > longestMatchLength) { + longestMatchLength = namespace.length(); + longestMatchingNamespace = namespace; + correspondingPrefix = prefix; + } + } + } + + if (longestMatchingNamespace != null) { + String localName = iriString.substring(longestMatchingNamespace.length()); + + if (localName.isEmpty()) { + return correspondingPrefix + SerializationConstants.COLON; + } + return correspondingPrefix + SerializationConstants.COLON + localName; + } + return null; + } + + /** + * Adds a prefix-namespace URI mapping to the internal mappings. + * Handles potential conflicts to ensure uniqueness. + * + * @param namespaceURI The namespace URI. + * @param prefix The associated prefix. + */ + private void addPrefixMapping(String namespaceURI, String prefix) { + if (iriToPrefixMapping.containsKey(namespaceURI)) { + if (iriToPrefixMapping.get(namespaceURI).equals(prefix)) { + return; + } else { + + if (logger.isWarnEnabled()) { + logger.warn("Namespace URI '{}' is already mapped to prefix '{}'. Cannot map to new prefix '{}'. " + + "Existing mapping for this namespace will be retained.", + namespaceURI, iriToPrefixMapping.get(namespaceURI), prefix); + } + return; + } + } + + String effectivePrefix = prefix; + if (prefixToIriMapping.containsKey(prefix)) { + if (!prefixToIriMapping.get(prefix).equals(namespaceURI)) { + if (logger.isWarnEnabled()) { + logger.warn("Prefix '{}' is already mapped to namespace '{}'. Cannot map to new namespace '{}'. " + + "A new unique prefix will be generated for '{}'.", + prefix, prefixToIriMapping.get(prefix), namespaceURI, namespaceURI); + } + effectivePrefix = generateUniquePrefix(prefix); + } + } + + iriToPrefixMapping.put(namespaceURI, effectivePrefix); + prefixToIriMapping.put(effectivePrefix, namespaceURI); + } + + /** + * Generates a unique prefix based on a given base string, ensuring it's not already in use. + * This method appends numbers to the base prefix until a unique one is found. + * + * @param basePrefix The desired base prefix (e.g., "foaf"). + * @return A unique prefix (e.g., "foaf", "foaf1", "foaf2"). + */ + private String generateUniquePrefix(String basePrefix) { + String candidate = basePrefix; + int i = 0; + while (prefixToIriMapping.containsKey(candidate)) { + candidate = basePrefix + (++i); + } + return candidate; + } + + /** + * Writes an `` element for a given subject. + * This element contains all properties (predicates and objects) for that subject. + * + * @param writer the {@link Writer} to which the element will be written. + * @param subject the {@link Resource} representing the subject. + * @param statements the list of statements with this subject. + * @param currentIndent the current indentation string. + * @throws IOException if an I/O error occurs. + */ + private void writeDescriptionElement(Writer writer, Resource subject, List statements, String currentIndent) throws IOException { + String nextIndent = currentIndent + config.getIndent(); + + writer.write(currentIndent); + if (subject.isIRI()) { + writer.write(String.format("%s %s=\"%s\">", SerializationConstants.RDF_DESCRIPTION_START, SerializationConstants.RDF_ABOUT_ATTRIBUTE, escapeXmlAttribute(subject.stringValue()))); + } else if (subject.isBNode()) { + writer.write(String.format("%s %s=\"%s\">", SerializationConstants.RDF_DESCRIPTION_START, SerializationConstants.RDF_NODEID_ATTRIBUTE, getBlankNodeId(subject))); + } + writer.write(config.getLineEnding()); + + Map> statementsByPredicate = statements.stream() + .collect(Collectors.groupingBy(Statement::getPredicate)); + + List sortedPredicates = new ArrayList<>(statementsByPredicate.keySet()); + if (config.sortPredicates()) { + Collections.sort(sortedPredicates, Comparator.comparing(Value::stringValue)); + } + + for (IRI predicate : sortedPredicates) { + for (Statement stmt : statementsByPredicate.get(predicate)) { + writePropertyElement(writer, stmt.getPredicate(), stmt.getObject(), nextIndent); + } + } + + writer.write(currentIndent); + writer.write(SerializationConstants.RDF_DESCRIPTION_END); + writer.write(config.getLineEnding()); + } + + /** + * Writes a property element (e.g., `objectValue`) for a triple. + * + * @param writer the {@link Writer} to which the element will be written. + * @param predicate the {@link IRI} representing the predicate. + * @param object the {@link Value} representing the object. + * @param currentIndent the current indentation string. + * @throws IOException if an I/O error occurs. + */ + private void writePropertyElement(Writer writer, IRI predicate, Value object, String currentIndent) throws IOException { + String predicateString = predicate.stringValue(); + String prefixedPredicateName = getPrefixedNameInternal(predicateString); + String elementName; + + if (prefixedPredicateName != null && !prefixedPredicateName.endsWith(SerializationConstants.COLON)) { + elementName = prefixedPredicateName; + } else { + elementName = predicateString; + logger.warn("Predicate IRI '{}' cannot be expressed as a valid prefixed element name. Using full IRI as element name in RDF/XML.", predicateString); + } + + writer.write(currentIndent); + writer.write(String.format("<%s", elementName)); + + if (object.isIRI()) { + writer.write(String.format(" %s=\"%s\"/>", SerializationConstants.RDF_RESOURCE_ATTRIBUTE, escapeXmlAttribute(object.stringValue()))); + writer.write(config.getLineEnding()); + } else if (object.isBNode()) { + writer.write(String.format(" %s=\"%s\"/>", SerializationConstants.RDF_NODEID_ATTRIBUTE, getBlankNodeId((Resource) object))); + writer.write(config.getLineEnding()); + } else if (object.isLiteral()) { + Literal literal = (Literal) object; + + literal.getLanguage().ifPresent(lang -> { + try { + writer.write(String.format(" %s=\"%s\">", SerializationConstants.XML_LANG_ATTRIBUTE, escapeXmlAttribute(lang))); + } catch (IOException e) { + throw new UncheckedIOException("Failed to write xml:lang attribute", e); + } + }); + + if (!literal.getLanguage().isPresent() && shouldWriteDatatype(literal)) { + String datatypeUri = literal.getDatatype().stringValue(); + String prefixedDatatype = getPrefixedNameInternal(datatypeUri); + writer.write(String.format(" %s=\"%s\">", SerializationConstants.RDF_DATATYPE_ATTRIBUTE, escapeXmlAttribute(prefixedDatatype != null ? prefixedDatatype : datatypeUri))); + } else if (!literal.getLanguage().isPresent()) { + writer.write(">"); + } + + writer.write(escapeXmlContent(literal.stringValue())); + writer.write(String.format("", elementName)); + writer.write(config.getLineEnding()); + } else { + throw new IllegalArgumentException("Unsupported value type for RDF/XML serialization: " + object.getClass().getName()); + } + } + + /** + * Retrieves or generates a stable blank node ID. + * + * @param bNode the blank node. + * @return a stable ID for the blank node. + */ + private String getBlankNodeId(Resource bNode) { + return blankNodeIds.computeIfAbsent(bNode, k -> { + if (config.stableBlankNodeIds()) { + return "b" + (blankNodeCounter++); + } else { + return bNode.stringValue().substring(2); + } + }); + } + + /** + * Determines if a literal's datatype should be written based on the configuration. + * + * @param literal the {@link Literal} to check. + * @return {@code true} if the datatype should be written, {@code false} otherwise. + */ + private boolean shouldWriteDatatype(Literal literal) { + if (literal.getLanguage().isPresent()) { + return false; + } + + IRI datatype = literal.getDatatype(); + if (datatype == null) { + return false; + } + + return config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || + (!datatype.stringValue().equals(SerializationConstants.XSD_STRING) && + config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL); + } + + + /** + * Extracts the namespace URI part from an IRI string. + * This is a common heuristic for RDF IRIs. + * + * @param iriString The full IRI. + * @return The namespace URI part. + */ + private String getNamespace(String iriString) { + int hashIdx = iriString.lastIndexOf(SerializationConstants.HASH); + int slashIdx = iriString.lastIndexOf(SerializationConstants.SLASH); + + if (hashIdx > -1) { + return iriString.substring(0, hashIdx + 1); + } else if (slashIdx > -1 && slashIdx < iriString.length() - 1) { + int dotIdx = iriString.lastIndexOf(SerializationConstants.POINT); + if (dotIdx > slashIdx) { + return iriString.substring(0, slashIdx + 1); + } + return iriString.substring(0, slashIdx + 1); + } + return iriString; + } + + /** + * Suggests a prefix for a given namespace URI. + * Attempts to derive a meaningful prefix or generates a unique one. + * + * @param namespace The namespace URI. + * @return A suggested prefix, or null if suggestion is not possible. + */ + private String getSuggestedPrefix(String namespace) { + + if (namespace.equals(SerializationConstants.RDF_NS)) return "rdf"; + if (namespace.equals(SerializationConstants.RDFS_NS)) return "rdfs"; + if (namespace.equals(SerializationConstants.XSD_NS)) return "xsd"; + if (namespace.equals(SerializationConstants.OWL_NS)) return "owl"; + if (namespace.equals(SerializationConstants.FOAF_NS)) return "foaf"; + + + String base = namespace; + if (base.endsWith(SerializationConstants.HASH) || base.endsWith(SerializationConstants.SLASH)) { + base = base.substring(0, base.length() - 1); + } + int lastSlash = base.lastIndexOf(SerializationConstants.SLASH); + int lastHash = base.lastIndexOf(SerializationConstants.HASH); + int lastSegmentStart = Math.max(lastSlash, lastHash); + if (lastSegmentStart != -1) { + base = base.substring(lastSegmentStart + 1); + } + + if (base.isEmpty()) { + try { + java.net.URI uri = new java.net.URI(namespace); + base = uri.getHost(); + if (base != null) { + base = base.replace(SerializationConstants.POINT, SerializationConstants.EMPTY_STRING); + } else { + base = "p"; + } + } catch (java.net.URISyntaxException e) { + logger.warn("Malformed URI encountered while suggesting prefix: {}", namespace, e); + base = "p"; + } + } + + base = base.replaceAll("[^a-zA-Z0-9]", SerializationConstants.EMPTY_STRING).toLowerCase(); + if (base.isEmpty()) base = "p"; + + String candidate = base; + int i = 0; + while (prefixToIriMapping.containsKey(candidate) && !prefixToIriMapping.get(candidate).equals(namespace)) { + candidate = base + (++i); + } + return candidate; + } + + /** + * Escapes a string for use as an XML attribute value. + * Replaces characters like '&', '<', '>', '"', "'" with their XML entity equivalents. + * + * @param value The string to escape. + * @return The escaped string. + */ + private String escapeXmlAttribute(String value) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < value.length(); i++) { + char c = value.charAt(i); + switch (c) { + case '&': + sb.append(SerializationConstants.AMP_ENTITY); + break; + case '<': + sb.append(SerializationConstants.LT_ENTITY); + break; + case '>': + sb.append(SerializationConstants.GT_ENTITY); + break; + case '"': + sb.append(SerializationConstants.QUOT_ENTITY); + break; + case '\'': + sb.append(SerializationConstants.APOS_ENTITY); + break; + default: + sb.append(c); + } + } + return sb.toString(); + } + + /** + * Escapes a string for use as XML element content. + * Replaces characters like '&', '<', '>' with their XML entity equivalents. + * + * @param value The string to escape. + * @return The escaped string. + */ + private String escapeXmlContent(String value) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < value.length(); i++) { + char c = value.charAt(i); + switch (c) { + case '&': + sb.append(SerializationConstants.AMP_ENTITY); + break; + case '<': + sb.append(SerializationConstants.LT_ENTITY); + break; + case '>': + sb.append(SerializationConstants.GT_ENTITY); + break; + default: + sb.append(c); + } + } + return sb.toString(); + } + + } From 58dc11d699b7547f9b6636f32cfced4446be2e91 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Wed, 25 Jun 2025 11:26:01 +0200 Subject: [PATCH 14/27] ajouter xml DefaultSerializerFactoryTest --- .../common/serialization/config/FormatConfig.java | 2 +- .../serialization/DefaultSerializerFactoryTest.java | 12 ++++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java index 2c1404794..ea3fda28a 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java @@ -100,7 +100,7 @@ public class FormatConfig implements ISerializationConfig { */ private final LiteralDatatypePolicyEnum literalDatatypePolicy; /** - * Whether non-ASCII characters should be escaped using Unicode escape sequences (e.g., `\u00E9`). + * Whether non-ASCII characters should be escaped using Unicode escape sequences (e.g., `\ u00E9`). * This ensures compatibility with systems that might not handle UTF-8 correctly, but makes output less human-readable. */ private final boolean escapeUnicode; // XXXX for non-ASCII diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java index c7e4845d6..5e4085d01 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java @@ -73,6 +73,18 @@ void createSerializer_shouldReturnTriGFormat_forTriGFormat() { } } + @Test + @DisplayName("createSerializer should return XmlSerializer for RDFXML format") + void createSerializer_shouldReturnXmlSerializer_forRdfXmlFormat() { + try (MockedConstruction mockedConstruction = mockConstruction(XmlSerializer.class)) { + IRdfSerializer serializer = factory.createSerializer(RdfFormat.RDFXML, mockModel, mockConfig); + + assertNotNull(serializer); + assertTrue(serializer instanceof XmlSerializer); + assertEquals(1, mockedConstruction.constructed().size(), "XmlSerializer constructor should be called once"); + } + } + @Test @DisplayName("createSerializer should throw NullPointerException for null format") From 0d567ba474fdbe9d282b1fcd48d3d0b9b4d4d83b Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Thu, 26 Jun 2025 13:56:28 +0200 Subject: [PATCH 15/27] ajouter test unitaire xml serializer --- .../serialization/config/FormatConfig.java | 4 +- .../exception/SerializationException.java | 2 +- .../serialization/XmlSerializerTest.java | 424 +++++++++++++++++- 3 files changed, 426 insertions(+), 4 deletions(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java index ea3fda28a..b41452d24 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java @@ -9,7 +9,7 @@ import java.util.Objects; /** - * Configuration for RDF serialization formats (Turtle, TriG, N-Triples, N-Quads). + * Configuration for RDF serialization formats (Turtle, TriG, N-Triples, N-Quads, XML). * This class provides a comprehensive set of options to control the output * syntax, pretty-printing, and technical aspects of RDF serialization. * @@ -201,7 +201,7 @@ public static class Builder { private boolean usePrefixes = true; private boolean autoDeclarePrefixes = true; private PrefixOrderingEnum prefixOrdering = PrefixOrderingEnum.ALPHABETICAL; - private Map customPrefixes = new HashMap<>(); + private final Map customPrefixes = new HashMap<>(); private boolean useCompactTriples = true; private boolean useRdfTypeShortcut = true; diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java b/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java index 710ba0c93..86d53bdb6 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java +++ b/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java @@ -2,7 +2,7 @@ /** * Exception levée lors d'échecs de sérialisation/désérialisation RDF. - * Peut contenir des détails spécifiques au format (NTriples, JSON-LD, etc.). + * Peut contenir des détails spécifiques au format (NTriples, JSON-LD, XML , etc.). */ public class SerializationException extends Exception { private final String formatName; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java index 1489245e6..61d061169 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java @@ -1,4 +1,426 @@ package fr.inria.corese.core.next.impl.common.serialization; -public class XmlSerializerTest { +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.io.StringWriter; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.*; + +/** + * Unit tests for the XmlSerializer class. + */ +class XmlSerializerTest { + + @Mock + private Model mockModel; + @Mock + private FormatConfig mockConfig; + @Mock + private Resource mockResource; + @Mock + private IRI mockIRI; + @Mock + private Literal mockLiteral; + @Mock + private Statement mockStatement; + + private StringWriter writer; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + writer = new StringWriter(); + + + when(mockConfig.getIndent()).thenReturn(" "); + when(mockConfig.getLineEnding()).thenReturn("\n"); + when(mockConfig.usePrefixes()).thenReturn(true); + when(mockConfig.autoDeclarePrefixes()).thenReturn(true); + when(mockConfig.getCustomPrefixes()).thenReturn(new HashMap<>()); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.CUSTOM); + when(mockConfig.sortSubjects()).thenReturn(false); + when(mockConfig.sortPredicates()).thenReturn(false); + when(mockConfig.getLiteralDatatypePolicy()).thenReturn(LiteralDatatypePolicyEnum.MINIMAL); + when(mockConfig.stableBlankNodeIds()).thenReturn(true); + } + + + @Test + @DisplayName("Should serialize a simple IRI triple with auto-declared namespaces") + void shouldSerializeSimpleIriTriple() throws SerializationException { + Statement stmt = createMockStatement("http://example.org/subject", "http://xmlns.com/foaf/0.1/name", "http://example.org/object"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + + + Map customPrefixes = new HashMap<>(); + + customPrefixes.put("http://xmlns.com/foaf/0.1/", "foaf"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + + String expected = """ + + + + + + + """; + + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should handle blank node subject") + void shouldHandleBlankNodeSubject() throws SerializationException { + Statement stmt = createMockBlankNodeSubjectStatement("b1", "http://xmlns.com/foaf/0.1/name", "http://example.org/Alice"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://xmlns.com/foaf/0.1/", "foaf"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + + + when(mockConfig.stableBlankNodeIds()).thenReturn(true); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + + + + """; + + + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should handle blank node object with correct namespace ordering") + void shouldHandleBlankNodeObject() throws SerializationException { + Statement stmt = createMockBlankNodeObjectStatement("http://example.org/book", "http://purl.org/dc/elements/1.1/creator", "b2"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://purl.org/dc/elements/1.1/", "dc"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + + when(mockConfig.stableBlankNodeIds()).thenReturn(true); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + + String expected = """ + + + + + + + """; + + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should serialize literal with xsd:string datatype (minimal policy)") + void shouldSerializeLiteralWithStringDatatypeMinimalPolicy() throws SerializationException { + Statement stmt = createMockLiteralStatement("http://example.org/person", "http://xmlns.com/foaf/0.1/name", "John Doe", SerializationConstants.XSD_STRING, + null); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + when(mockConfig.getLiteralDatatypePolicy()).thenReturn(LiteralDatatypePolicyEnum.MINIMAL); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://xmlns.com/foaf/0.1/", "foaf"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + John Doe + + + """; + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should serialize literal with custom datatype using minimal policy") + void shouldSerializeLiteralWithCustomDatatypeMinimalPolicy() throws SerializationException { + Statement stmt = createMockLiteralStatement("http://example.org/data", "http://example.org/vocabulary/value", "123", SerializationConstants.XSD_INTEGER, null); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + when(mockConfig.getLiteralDatatypePolicy()).thenReturn(LiteralDatatypePolicyEnum.MINIMAL); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://example.org/vocabulary/", "ex"); + customPrefixes.put("http://www.w3.org/2001/XMLSchema#", "xsd"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + 123 + + + """; + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should serialize literal with language tag") + void shouldSerializeLiteralWithLanguage() throws SerializationException { + Statement stmt = createMockLiteralStatement("http://example.org/book", "http://purl.org/dc/elements/1.1/title", "The Book", null, "en"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://purl.org/dc/elements/1.1/", "dc"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + The Book + + + """; + + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should respect alphabetical prefix ordering") + void shouldRespectPrefixOrderingAlphabetical() throws SerializationException { + Statement stmt1 = createMockStatement("http://ex.org/s1", "http://ex.org/p1", "http://ex.org/o1"); + Statement stmt2 = createMockStatement("http://ex.com/s2", "http://ex.com/p2", "http://ex.com/o2"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://ex.org/", "exorg"); + customPrefixes.put("http://ex.com/", "excom"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + + String expected = """ + + + + + + + + + + """; + + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should respect default prefix ordering (non-deterministic for subjects)") + void shouldRespectPrefixOrderingDefault() throws SerializationException { + Statement stmt1 = createMockStatement("http://ex.org/s1", "http://ex.org/p1", "http://ex.org/o1"); + Statement stmt2 = createMockStatement("http://ex.com/s2", "http://ex.com/p2", "http://ex.com/o2"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://ex.org/", "exorg"); + customPrefixes.put("http://ex.com/", "excom"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.USAGE_ORDER); + when(mockConfig.sortSubjects()).thenReturn(false); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String actual = writer.toString(); + + assertTrue(actual.startsWith("\n\n")); + + assertTrue(actual.contains("xmlns:exorg=\"http://ex.org/\"")); + assertTrue(actual.contains("xmlns:excom=\"http://ex.com/\"")); + assertTrue(actual.contains("xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"")); + + String desc1 = " \n \n "; + String desc2 = " \n \n "; + + assertTrue(actual.contains(desc1)); + assertTrue(actual.contains(desc2)); + } + + + + + + + + + + /** + * Helper method to create a mock Statement with IRI subject, predicate, and object. + * Completes all necessary stubbing for these mocks. + */ + private Statement createMockStatement(String subjectUri, String predicateUri, String objectUri) { + Resource subject = mock(Resource.class); + when(subject.isIRI()).thenReturn(true); + when(subject.isBNode()).thenReturn(false); + when(subject.stringValue()).thenReturn(subjectUri); + + IRI predicate = mock(IRI.class); + when(predicate.isIRI()).thenReturn(true); + when(predicate.isBNode()).thenReturn(false); + when(predicate.stringValue()).thenReturn(predicateUri); + + IRI object = mock(IRI.class); + when(object.isIRI()).thenReturn(true); + when(object.isBNode()).thenReturn(false); + when(object.stringValue()).thenReturn(objectUri); + + Statement statement = mock(Statement.class); + when(statement.getSubject()).thenReturn(subject); + when(statement.getPredicate()).thenReturn(predicate); + when(statement.getObject()).thenReturn(object); + + return statement; + } + + /** + * Helper method to create a mock Statement with a blank node subject. + */ + private Statement createMockBlankNodeSubjectStatement(String blankNodeId, String predicateUri, String objectUri) { + Resource subject = mock(Resource.class); + when(subject.isIRI()).thenReturn(false); + when(subject.isBNode()).thenReturn(true); + when(subject.stringValue()).thenReturn("_:" + blankNodeId); + + IRI predicate = mock(IRI.class); + when(predicate.isIRI()).thenReturn(true); + when(predicate.stringValue()).thenReturn(predicateUri); + + IRI object = mock(IRI.class); + when(object.isIRI()).thenReturn(true); + when(object.stringValue()).thenReturn(objectUri); + + Statement statement = mock(Statement.class); + when(statement.getSubject()).thenReturn(subject); + when(statement.getPredicate()).thenReturn(predicate); + when(statement.getObject()).thenReturn(object); + + return statement; + } + + /** + * Helper method to create a mock Statement with a blank node object. + */ + private Statement createMockBlankNodeObjectStatement(String subjectUri, String predicateUri, String blankNodeId) { + Resource subject = mock(Resource.class); + when(subject.isIRI()).thenReturn(true); + when(subject.stringValue()).thenReturn(subjectUri); + + IRI predicate = mock(IRI.class); + when(predicate.isIRI()).thenReturn(true); + when(predicate.stringValue()).thenReturn(predicateUri); + + Resource object = mock(Resource.class); + when(object.isIRI()).thenReturn(false); + when(object.isBNode()).thenReturn(true); + when(object.stringValue()).thenReturn("_:" + blankNodeId); + + Statement statement = mock(Statement.class); + when(statement.getSubject()).thenReturn(subject); + when(statement.getPredicate()).thenReturn(predicate); + when(statement.getObject()).thenReturn(object); + + return statement; + } + + /** + * Helper method to create a mock Statement with a literal object. + */ + private Statement createMockLiteralStatement(String subjectUri, String predicateUri, String literalValue, String datatypeUri, String langTag) { + Resource subject = mock(Resource.class); + when(subject.isIRI()).thenReturn(true); + when(subject.stringValue()).thenReturn(subjectUri); + + IRI predicate = mock(IRI.class); + when(predicate.isIRI()).thenReturn(true); + when(predicate.stringValue()).thenReturn(predicateUri); + + Literal literal = mock(Literal.class); + when(literal.isIRI()).thenReturn(false); + when(literal.isBNode()).thenReturn(false); + when(literal.isLiteral()).thenReturn(true); + when(literal.stringValue()).thenReturn(literalValue); + when(literal.getLanguage()).thenReturn(Optional.ofNullable(langTag)); + if (datatypeUri != null) { + IRI datatype = mock(IRI.class); + when(datatype.stringValue()).thenReturn(datatypeUri); + when(literal.getDatatype()).thenReturn(datatype); + } else { + when(literal.getDatatype()).thenReturn(null); + } + + Statement statement = mock(Statement.class); + when(statement.getSubject()).thenReturn(subject); + when(statement.getPredicate()).thenReturn(predicate); + when(statement.getObject()).thenReturn(literal); + + return statement; + } + } From bff224c6aff46477cf62e135a5a7c66206b868a0 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 27 Jun 2025 08:35:23 +0200 Subject: [PATCH 16/27] ajouter plus de test unitaire xml serializer --- .../serialization/XmlSerializerTest.java | 194 +++++++++++++++++- 1 file changed, 193 insertions(+), 1 deletion(-) diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java index 61d061169..9a07a0112 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java @@ -303,12 +303,204 @@ void shouldRespectPrefixOrderingDefault() throws SerializationException { assertTrue(actual.contains(desc2)); } - + @Test + @DisplayName("Should sort subjects alphabetically") + void shouldSortSubjectsAlphabetically() throws SerializationException { + Statement stmt1 = createMockStatement("http://ex.org/B", "http://ex.org/p", "http://ex.org/o"); + Statement stmt2 = createMockStatement("http://ex.org/A", "http://ex.org/p", "http://ex.org/o"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); + when(mockConfig.sortSubjects()).thenReturn(true); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://ex.org/", "ex"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + + + + + + + """; + + assertEquals(expected, writer.toString()); + } + + + @Test + @DisplayName("Should escape XML attribute values") + void shouldEscapeXmlAttributeValues() throws SerializationException { + Statement stmt = createMockStatement("http://example.org/sub&ject<", "http://example.org/pred", "http://example.org/obj\"ect'"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + + + + """; + + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should escape XML content values") + void shouldEscapeXmlContentValues() throws SerializationException { + Statement stmt = createMockLiteralStatement("http://example.org/item", "http://example.org/prop", "Value with & entities", null, + null + ); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + when(mockConfig.getLiteralDatatypePolicy()).thenReturn(LiteralDatatypePolicyEnum.ALWAYS_TYPED); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://example.org/", "ex"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + Value with <tags> & entities + + + """; + + assertEquals(expected, writer.toString()); + } + + + @Test + @DisplayName("Should not auto-declare prefixes if disabled in configuration") + void shouldNotAutoDeclarePrefixesIfDisabled() throws SerializationException { + Statement stmt = createMockStatement("http://example.org/subject", "http://xmlns.com/foaf/0.1/name", "http://example.org/object"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + when(mockConfig.autoDeclarePrefixes()).thenReturn(false); + when(mockConfig.usePrefixes()).thenReturn(true); + + when(mockConfig.getCustomPrefixes()).thenReturn(new HashMap<>()); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + + + + """; + assertEquals(expected, writer.toString()); + verify(mockConfig, times(1)).autoDeclarePrefixes(); + } + @Test + @DisplayName("Should not use prefixes if disabled in configuration") + void shouldNotUsePrefixesIfDisabled() throws SerializationException { + Statement stmt = createMockStatement("http://example.org/subject", "http://xmlns.com/foaf/0.1/name", "http://example.org/object"); + when(mockModel.stream()).thenReturn(Stream.of(stmt)); + when(mockConfig.usePrefixes()).thenReturn(false); + when(mockConfig.autoDeclarePrefixes()).thenReturn(true); + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://xmlns.com/foaf/0.1/", "foaf"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + + + + """; + + assertEquals(expected, writer.toString()); + verify(mockConfig, times(2)).usePrefixes(); + } + + + @Test + @DisplayName("Should not generate stable blank node IDs and sort subjects alphabetically") + void shouldNotGenerateStableBlankNodeIds() throws SerializationException { + Statement stmt1 = createMockBlankNodeSubjectStatement("bnode-abc", "http://example.org/p", "http://example.org/o"); + Statement stmt2 = createMockBlankNodeObjectStatement("http://example.org/s", "http://example.org/p", "bnode-xyz"); + + when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); + when(mockConfig.stableBlankNodeIds()).thenReturn(false); + when(mockConfig.sortSubjects()).thenReturn(true); + + Map customPrefixes = new HashMap<>(); + customPrefixes.put("http://example.org/", "ex"); + when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + + String expected = """ + + + + + + + + + + """; + + assertEquals(expected, writer.toString()); + } + + @Test + @DisplayName("Should handle an empty model") + void shouldHandleEmptyModel() throws SerializationException { + when(mockModel.stream()).thenReturn(Stream.empty()); + when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + + XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + serializer.write(writer); + + String expected = """ + + + + """; + + assertEquals(expected, writer.toString()); + } /** From 0c39531f550a72f1e357a199841b74780f139b47 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 27 Jun 2025 12:48:37 +0200 Subject: [PATCH 17/27] =?UTF-8?q?Ajout=20du=20vocabulaire=20OWL=20et=20ref?= =?UTF-8?q?actorisation=20des=20constantes=20de=20s=C3=A9rialisation?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../util/SerializationConstants.java | 27 ++++--- .../core/next/impl/common/vocabulary/OWL.java | 74 +++++++++++++++++++ .../serialization/XmlSerializerTest.java | 1 + 3 files changed, 93 insertions(+), 9 deletions(-) create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/OWL.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java index c63dcda05..ef560f804 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/util/SerializationConstants.java @@ -1,5 +1,11 @@ package fr.inria.corese.core.next.impl.common.serialization.util; +import fr.inria.corese.core.next.impl.common.vocabulary.OWL; +import fr.inria.corese.core.next.impl.common.vocabulary.RDF; +import fr.inria.corese.core.next.impl.common.vocabulary.RDFS; +import fr.inria.corese.core.next.impl.common.vocabulary.XSD; + + /** * Provides common constants used throughout the RDF serialization process. * This includes URIs for common RDF, RDFS, XSD, and OWL vocabularies, @@ -13,15 +19,18 @@ private SerializationConstants() { } // --- Standard RDF/RDFS/XSD/OWL URIs --- - public static final String RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"; - public static final String RDFS_NS = "http://www.w3.org/2000/01/rdf-schema#"; - public static final String XSD_NS = "http://www.w3.org/2001/XMLSchema#"; - public static final String OWL_NS = "http://www.w3.org/2002/07/owl#"; - - public static final String RDF_TYPE = RDF_NS + "type"; - public static final String RDF_FIRST = RDF_NS + "first"; - public static final String RDF_REST = RDF_NS + "rest"; - public static final String RDF_NIL = RDF_NS + "nil"; + public static final String RDF_NS = RDF.HTML.getNamespace(); + public static final String RDF_TYPE = RDF.type.getIRI().stringValue(); + public static final String RDF_FIRST = RDF.first.getIRI().stringValue(); + public static final String RDF_REST = RDF.rest.getIRI().stringValue(); + public static final String RDF_NIL = RDF.nil.getIRI().stringValue(); + + + public static final String RDFS_NS = RDFS.Resource.getNamespace(); + + public static final String XSD_NS = XSD.xsdString.getNamespace(); + + public static final String OWL_NS = OWL.NS; public static final String XSD_STRING = XSD_NS + "string"; public static final String XSD_INTEGER = XSD_NS + "integer"; diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/OWL.java b/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/OWL.java new file mode 100644 index 000000000..7ea0283ca --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/vocabulary/OWL.java @@ -0,0 +1,74 @@ +package fr.inria.corese.core.next.impl.common.vocabulary; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.impl.common.BasicIRI; + +/** + * Defines the OWL (Web Ontology Language) vocabulary. + */ +public enum OWL implements Vocabulary { + /** + * @see OWL Class + */ + Class("Class"), + /** + * @see OWL Ontology + */ + Ontology("Ontology"), + /** + * @see OWL ObjectProperty + */ + ObjectProperty("ObjectProperty"), + /** + * @see OWL DatatypeProperty + */ + DatatypeProperty("DatatypeProperty"), + /** + * @see OWL AnnotationProperty + */ + AnnotationProperty("AnnotationProperty"), + /** + * @see OWL NamedIndividual + */ + NamedIndividual("NamedIndividual"), + /** + * @see OWL Restriction + */ + Restriction("Restriction"), + /** + * @see OWL equivalentClass + */ + equivalentClass("equivalentClass"), + /** + * @see OWL sameAs + */ + sameAs("sameAs"), + /** + * @see OWL differentFrom + */ + differentFrom("differentFrom") + ; + + private final IRI iri; + + public static final String NS = "http://www.w3.org/2002/07/owl#"; + + OWL(String localName) { + this.iri = new BasicIRI(getNamespace(), localName); + } + + @Override + public IRI getIRI() { + return this.iri; + } + + @Override + public String getNamespace() { + return NS; // Referencing the directly defined static NS + } + + @Override + public String getPreferredPrefix() { + return "owl"; + } +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java index 9a07a0112..364794f22 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java @@ -249,6 +249,7 @@ void shouldRespectPrefixOrderingAlphabetical() throws SerializationException { customPrefixes.put("http://ex.com/", "excom"); when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + when(mockConfig.sortSubjects()).thenReturn(false); XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); serializer.write(writer); From 97a494f427818a3daedf591e7f7b322c7d107638 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9mi=20C=C3=A9r=C3=A8s?= Date: Tue, 1 Jul 2025 09:32:08 +0200 Subject: [PATCH 18/27] refactor(serialization): Extract common base for line-based serializers Extracts a common abstract base class, AbstractLineBasedSerializer, from NQuadsSerializer and NTriplesSerializer. This refactoring removes duplicated code for writing statements, values, literals, IRIs, and blank nodes. The new base class centralizes the logic for line-by-line serialization, while subclasses (NQuadsSerializer and NTriplesSerializer) now only need to implement the specific logic for handling contexts (named graphs). - NQuadsSerializer handles the optional context. - NTriplesSerializer ignores the context and logs a warning. This change improves maintainability and reduces code duplication. --- .../serialization/NQuadsSerializer.java | 371 +---------------- .../serialization/NTriplesSerializer.java | 339 +--------------- .../base/AbstractLineBasedSerializer.java | 374 ++++++++++++++++++ .../serialization/NTriplesSerializerTest.java | 8 +- 4 files changed, 413 insertions(+), 679 deletions(-) create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java index ca7e9a729..94b78053a 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java @@ -1,32 +1,27 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.RDF; +import fr.inria.corese.core.next.impl.common.serialization.base.AbstractLineBasedSerializer; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; -import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; -import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.BufferedWriter; import java.io.IOException; -import java.io.UncheckedIOException; import java.io.Writer; -import java.util.Collections; -import java.util.Objects; -import java.util.Set; -public class NQuadsSerializer implements IRdfSerializer { +/** + * Serializes a Corese {@link Model} into N-Quads format. + * This class extends {@link AbstractLineBasedSerializer} to provide + * N-Quads specific serialization behavior. + */ +public class NQuadsSerializer extends AbstractLineBasedSerializer { /** * Logger for this class, used for logging potential issues or information during serialization. */ private static final Logger logger = LoggerFactory.getLogger(NQuadsSerializer.class); - private final Model model; - private final FormatConfig config; - /** * Constructs a new {@code NQuadsSerializer} instance with the specified model and default N-Quads configuration. * The default configuration is obtained from {@link FormatConfig#nquadsConfig()}. @@ -46,61 +41,30 @@ public NQuadsSerializer(Model model) { * @throws NullPointerException if the provided model or config is null. */ public NQuadsSerializer(Model model, ISerializationConfig config) { - this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); + super(model, (FormatConfig) config); } /** - * Writes the model to the given writer in N-Quads format. - * Each statement (quad) in the model is written on a new line, terminated by a dot and a newline character. + * Returns the format name for error messages and logging. * - * @param writer the {@link Writer} to which the N-Quads output will be written. - * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + * @return "N-Quads" */ @Override - public void write(Writer writer) throws SerializationException { - try (BufferedWriter bufferedWriter = new BufferedWriter(writer)) { - Set processedNodes = preprocessModel(); - - for (Statement stmt : model) { - if (shouldProcess(stmt, processedNodes)) { - writeStatement(bufferedWriter, stmt); - } - } - - } catch (IOException e) { - throw new SerializationException("N-Quads serialization failed", "N-Quads", e); - } catch (IllegalArgumentException e) { - throw new SerializationException("Invalid N-Quads data: " + e.getMessage(), "N-Quads", e); - } - } - - private Set preprocessModel() { - return Collections.emptySet(); - } - - private boolean shouldProcess(Statement stmt, Set processedNodes) { - - return !processedNodes.contains(stmt.getSubject()); + protected String getFormatName() { + return "N-Quads"; } /** - * Writes a single {@link Statement} (quad) to the writer in N-Quads format. - * The statement is written as "$subject $predicate $object $context ." if a context is present + * Writes the context (named graph) part of a statement. + * For N-Quads, the context is written as the fourth component if present * and {@code config.includeContext()} is true. - * If no context is present or {@code config.includeContext()} is false, it's written as "$subject $predicate $object .". * - * @param writer the {@link Writer} to which the statement will be written. - * @param stmt the {@link Statement} to write. + * @param writer the {@link Writer} to which the context will be written. + * @param stmt the {@link Statement} whose context should be written. * @throws IOException if an I/O error occurs. */ - private void writeStatement(Writer writer, Statement stmt) throws IOException { - writeValue(writer, stmt.getSubject()); - writer.write(SerializationConstants.SPACE); - writeValue(writer, stmt.getPredicate()); - writer.write(SerializationConstants.SPACE); - writeValue(writer, stmt.getObject()); - + @Override + protected void writeContext(Writer writer, Statement stmt) throws IOException { Resource context = stmt.getContext(); if (context != null && config.includeContext()) { writer.write(SerializationConstants.SPACE); @@ -109,304 +73,5 @@ private void writeStatement(Writer writer, Statement stmt) throws IOException { logger.warn("Context '{}' will be ignored for statement: {} because includeContext is false in configuration.", context.stringValue(), stmt); } - - if (config.trailingDot()) { - writer.write(SerializationConstants.SPACE); - writer.write(SerializationConstants.POINT); - } - - writer.write(config.getLineEnding()); - } - - /** - * Writes a single {@link Value} to the writer. - * Handles literals, blank nodes, and IRIs, applying validation based on configuration. - * - * @param writer the {@link Writer} to which the value will be written. - * @param value the {@link Value} to write. - * @throws IOException if an I/O error occurs. - * @throws IllegalArgumentException if the provided value is null or an unsupported type, especially in strict mode. - */ - private void writeValue(Writer writer, Value value) throws IOException { - if (config.isStrictMode()) { - validateValue(value); - } else if (value == null) { - logger.warn("Encountered a null value during N-Quads serialization. This might lead to invalid output."); - throw new IllegalArgumentException("Value cannot be null for N-Quads serialization."); - } - - - if (value.isLiteral()) { - writeLiteral(writer, (Literal) value); - } else if (value.isResource()) { - if (value.isIRI()) { - writeIRI(writer, (IRI) value); - } else if (value.isBNode()) { - writeBlankNode(writer, (Resource) value); - } else { - throw new IllegalArgumentException("Unsupported resource type for N-Quads serialization: " + value.getClass().getName()); - } - } else { - throw new IllegalArgumentException("Unsupported value type for N-Quads serialization: " + value.getClass().getName()); - } - } - - /** - * Writes a {@link Literal} to the writer in N-Quads format. - * Handles plain literals, language-tagged literals, and typed literals, - * applying escaping and datatype/language tag rules based on configuration. - * - * @param writer the {@link Writer} to which the literal will be written. - * @param literal the {@link Literal} to write. - * @throws IOException if an I/O error occurs. - */ - private void writeLiteral(Writer writer, Literal literal) throws IOException { - writer.write(SerializationConstants.QUOTE); - writer.write(escapeLiteral(literal.stringValue())); - writer.write(SerializationConstants.QUOTE); - - literal.getLanguage().ifPresent(lang -> { - try { - writer.write(SerializationConstants.AT_SIGN + lang); - } catch (IOException e) { - throw new UncheckedIOException("Error writing language tag to stream", e); - } - }); - - IRI datatype = literal.getDatatype(); - if (!literal.getLanguage().isPresent() && datatype != null && - (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || - (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL && !datatype.stringValue().equals(SerializationConstants.XSD_STRING)))) { - writer.write(SerializationConstants.DATATYPE_SEPARATOR); - writeIRI(writer, datatype); - } - } - - /** - * Writes an {@link IRI} to the writer. - * The IRI's string representation must be enclosed in angle brackets for N-Quads. - * Applies URI validation and Unicode escaping based on configuration. - * - * @param writer the {@link Writer} to which the IRI will be written. - * @param iri the {@link IRI} to write. - * @throws IOException if an I/O error occurs. - * @throws IllegalArgumentException if the IRI is invalid (e.g., contains spaces) and strict mode/URI validation is enabled. - */ - private void writeIRI(Writer writer, IRI iri) throws IOException { - if (config.isStrictMode() && config.validateURIs()) { - validateIRI(iri); - } - - writer.write(SerializationConstants.LT); - writer.write(escapeNQuadsIRI(iri.stringValue())); - writer.write(SerializationConstants.GT); - } - - /** - * Writes a blank node to the writer. - * Blank nodes are prefixed with "_:", and the identifier is appended. - * - * @param writer the {@link Writer} to which the blank node will be written. - * @param blankNode the {@link Resource} representing the blank node. - * @throws IOException if an I/O error occurs. - */ - private void writeBlankNode(Writer writer, Resource blankNode) throws IOException { - writer.write(SerializationConstants.BNODE_PREFIX); - writer.write(blankNode.stringValue()); - } - - /** - * Validates and potentially escapes an IRI string for N-Quads. - * Throws an {@link IllegalArgumentException} if the IRI contains characters - * that are not allowed in N-Quads unescaped form (like spaces, quotes, angle brackets) - * when strict mode and URI validation are enabled. - * Applies Unicode escaping if {@code config.escapeUnicode()} is true. - * - * @param iri The string value of the IRI to validate and escape. - * @return The validated and potentially escaped IRI string. - * @throws IllegalArgumentException if the IRI string is invalid according to rules. - */ - private String escapeNQuadsIRI(String iri) { - Objects.requireNonNull(iri, "IRI string cannot be null"); - - if (config.isStrictMode() && config.validateURIs() && - (iri.contains(SerializationConstants.SPACE) || - iri.contains(SerializationConstants.QUOTE) || - iri.contains(SerializationConstants.LT) || - iri.contains(SerializationConstants.GT))) { - throw new IllegalArgumentException( - "Invalid IRI for N-Quads (contains illegal characters inside '<>'): " + iri); - } - - return config.escapeUnicode() ? escapeUnicodeString(iri) : iri; - } - - /** - * Escape special characters in N-Quads string literals. - * Handles backslash, double quote, and common control characters. - * Unicode escape sequences are used for unprintable characters if `config.escapeUnicode()` is true. - * - * @param value The string value of the literal to escape. - * @return The escaped string suitable for N-Quads literal. - */ - private String escapeLiteral(String value) { - StringBuilder sb = new StringBuilder(); - int len = value.length(); // Cache length for invariant stop condition - for (int i = 0; i < len; i++) { - char c = value.charAt(i); - switch (c) { - case '\n': - sb.append(SerializationConstants.BACK_SLASH).append('n'); - break; - case '\r': - sb.append(SerializationConstants.BACK_SLASH).append('r'); - break; - case '\t': - sb.append(SerializationConstants.BACK_SLASH).append('t'); - break; - case '\b': - sb.append(SerializationConstants.BACK_SLASH).append('b'); - break; - case '\f': - sb.append(SerializationConstants.BACK_SLASH).append('f'); - break; - case '"': - sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.QUOTE); - break; - case '\\': - sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.BACK_SLASH); - break; - default: - i += appendDefaultCharOrUnicodeEscape(sb, c, value, i, config); - break; - } - } - return sb.toString(); - } - - /** - * Helper method to append a character to StringBuilder, applying unicode escaping based on config - * and handling supplementary characters. Returns the additional increment for the loop index. - * - * @param sb The StringBuilder to append to. - * @param c The current character to process. - * @param value The original string (needed for codePointAt for supplementary characters). - * @param currentIndex The current index in the original string. - * @param config The FormatConfig to check for unicode escaping preference. - * @return The additional increment to the loop index (0 or 1 for supplementary characters). - */ - private int appendDefaultCharOrUnicodeEscape(StringBuilder sb, char c, String value, int currentIndex, FormatConfig config) { - if (config.escapeUnicode()) { - if (c <= 0x1F || c == 0x7F) { - sb.append(String.format("\\u%04X", (int) c)); - } else if (Character.isHighSurrogate(c)) { - if (currentIndex + 1 < value.length() && Character.isLowSurrogate(value.charAt(currentIndex + 1))) { - int codePoint = value.codePointAt(currentIndex); - sb.append(String.format("\\U%08X", codePoint)); - return 1; - } else { - sb.append(c); - } - } else { - sb.append(c); - } - } else { - sb.append(c); - } - return 0; - } - - /** - * Escapes non-ASCII and control characters into Unicode escape sequences. - * This is a helper for `escapeNQuadsIRI` and `escapeLiteral` - * if `escapeUnicode` is true in config. - * - * @param value The string to escape. - * @return The string with Unicode characters escaped. - */ - private String escapeUnicodeString(String value) { - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < value.length(); i++) { - char c = value.charAt(i); - if (c <= 0x1F || c == 0x7F || (c >= 0x80 && c <= 0xFFFF)) { - sb.append(String.format("\\u%04X", (int) c)); - } else if (Character.isHighSurrogate(c)) { - int codePoint = value.codePointAt(i); - if (Character.isValidCodePoint(codePoint)) { - sb.append(String.format("\\U%08X", codePoint)); - i++; - } else { - sb.append(c); - } - } else { - sb.append(c); - } - } - return sb.toString(); - } - - - /** - * Validates RDF values before serialization to ensure they conform to N-Quads rules. - * Only called if {@code config.isStrictMode()} is enabled. - * - * @param value The {@link Value} to validate. - * @throws IllegalArgumentException if the value is null or invalid based on N-Quads rules. - */ - private void validateValue(Value value) { - if (value == null) { - logger.warn("Encountered a null value where a non-null value was expected for N-Quads serialization. This will result in an IllegalArgumentException if strict mode is enabled."); - throw new IllegalArgumentException("Value cannot be null in N-Quads format when strictMode is enabled."); - } - - if (value.isLiteral()) { - validateLiteral((Literal) value); - } else if (value.isIRI()) { - validateIRI((IRI) value); - } - } - - /** - * Validates a {@link Literal} to ensure it conforms to RDF/N-Quads rules. - * Specifically checks for consistency between language tags and the rdf:langString datatype. - * Only called if {@code config.isStrictMode()} is enabled. - * - * @param literal The {@link Literal} to validate. - * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, - * or rdf:langString literal missing a language tag). - */ - private void validateLiteral(Literal literal) { - IRI datatype = literal.getDatatype(); - - if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { - throw new IllegalArgumentException( - "Literal with language tag must use rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); - } - } else { - if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { - throw new IllegalArgumentException( - "rdf:langString literal must have a language tag."); - } - } - } - - /** - * Validates an {@link IRI} to ensure it conforms to N-Quads rules. - * Checks if the IRI string contains characters that are not allowed in N-Quads - * unescaped form, such as spaces, quotes, or angle brackets. - * Only called if {@code config.isStrictMode()} and {@code config.validateURIs()} are enabled. - * - * @param iri The {@link IRI} to validate. - * @throws IllegalArgumentException if the IRI contains invalid characters. - */ - private void validateIRI(IRI iri) { - String iriString = iri.stringValue(); - if (iriString.contains(SerializationConstants.SPACE) || - iriString.contains(SerializationConstants.QUOTE) || - iriString.contains(SerializationConstants.LT) || - iriString.contains(SerializationConstants.GT)) { - throw new IllegalArgumentException("IRI contains illegal characters (space, quote, angle brackets) for N-Quads unescaped form: " + iriString); - } } } \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java index f38ceeb5e..399255bd1 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java @@ -1,37 +1,26 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.RDF; +import fr.inria.corese.core.next.impl.common.serialization.base.AbstractLineBasedSerializer; import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; -import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; -import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.BufferedWriter; import java.io.IOException; -import java.io.UncheckedIOException; import java.io.Writer; -import java.util.Collections; -import java.util.Objects; -import java.util.Set; /** * Serializes a Corese {@link Model} into N-Triples format. - * This class provides a method to write the statements of a model to a given {@link Writer} - * according to the N-Triples specification. + * This class extends {@link AbstractLineBasedSerializer} to provide + * N-Triples specific serialization behavior. */ -public class NTriplesSerializer implements IRdfSerializer { +public class NTriplesSerializer extends AbstractLineBasedSerializer { /** * Logger for this class, used for logging potential issues or information during serialization. */ private static final Logger logger = LoggerFactory.getLogger(NTriplesSerializer.class); - private final Model model; - private final FormatConfig config; - /** * Constructs a new {@code NTriplesSerializer} instance with the specified model and default configuration. * @@ -50,329 +39,35 @@ public NTriplesSerializer(Model model) { * @throws NullPointerException if the provided model or config is null. */ public NTriplesSerializer(Model model, ISerializationConfig config) { - this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); + super(model, (FormatConfig) config); } /** - * Writes the model to the given writer in N-Triples format. - * Each statement in the model is written on a new line, terminated by a dot and a newline character. + * Returns the format name for error messages and logging. * - * @param writer the {@link Writer} to which the N-Triples output will be written. - * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + * @return "N-Triples" */ @Override - public void write(Writer writer) throws SerializationException { - try (BufferedWriter bufferedWriter = new BufferedWriter(writer)) { - Set processedNodes = preprocessModel(); - - for (Statement stmt : model) { - if (shouldProcess(stmt, processedNodes)) { - writeStatement(bufferedWriter, stmt); - } - } - - } catch (IOException e) { - throw new SerializationException("NTriples serialization failed", "NTriples", e); - } catch (IllegalArgumentException e) { - throw new SerializationException("Invalid NTriples data: " + e.getMessage(), "NTriples", e); - } - } - - private Set preprocessModel() { - return Collections.emptySet(); - } - - private boolean shouldProcess(Statement stmt, Set processedNodes) { - - return !processedNodes.contains(stmt.getSubject()); + protected String getFormatName() { + return "N-Triples"; } /** - * Writes a single {@link Statement} to the writer in N-Triples format. - * The statement is written as "$subject $predicate $object ." - * N-Triples does not support contexts (named graphs). If a context is present, it's ignored and a warning is logged. + * Writes the context (named graph) part of a statement. + * For N-Triples, contexts are not supported, so this method logs a warning + * if a context is present and does nothing. * - * @param writer the {@link Writer} to which the statement will be written. - * @param stmt the {@link Statement} to write. + * @param writer the {@link Writer} to which the context will be written. + * @param stmt the {@link Statement} whose context should be written. * @throws IOException if an I/O error occurs. */ - private void writeStatement(Writer writer, Statement stmt) throws IOException { - writeValue(writer, stmt.getSubject()); - writer.write(SerializationConstants.SPACE); - writeValue(writer, stmt.getPredicate()); - writer.write(SerializationConstants.SPACE); - writeValue(writer, stmt.getObject()); - + @Override + protected void writeContext(Writer writer, Statement stmt) throws IOException { Resource context = stmt.getContext(); if (context != null && logger.isWarnEnabled()) { logger.warn("N-Triples format does not support named graphs. Context '{}' will be ignored for statement: {}", context.stringValue(), stmt); - - } - - if (config.trailingDot()) { - writer.write(SerializationConstants.SPACE); - writer.write(SerializationConstants.POINT); - } - - writer.write(config.getLineEnding()); - } - - /** - * Writes a single {@link Value} to the writer. - * Handles literals, blank nodes, and IRIs. - * - * @param writer the {@link Writer} to which the value will be written. - * @param value the {@link Value} to write. - * @throws IOException if an I/O error occurs. - * @throws IllegalArgumentException if the provided value is null or an unsupported type. - */ - private void writeValue(Writer writer, Value value) throws IOException { - validateValue(value); - - if (value.isLiteral()) { - writeLiteral(writer, (Literal) value); - } else if (value.isResource()) { - if (value.isIRI()) { - writeIRI(writer, (IRI) value); - } else if (value.isBNode()) { - writeBlankNode(writer, (Resource) value); - } else { - throw new IllegalArgumentException("Unsupported resource type for N-Triples serialization: " + value.getClass().getName()); - } - } else { - throw new IllegalArgumentException("Unsupported value type for N-Triples serialization: " + value.getClass().getName()); - } - } - - /** - * Writes a {@link Literal} to the writer in N-Triples format. - * Applies escaping and datatype/language tag rules based on configuration. - * - * @param writer the {@link Writer} to which the literal will be written. - * @param literal the {@link Literal} to write. - * @throws IOException if an I/O error occurs. - */ - private void writeLiteral(Writer writer, Literal literal) throws IOException { - writer.write(SerializationConstants.QUOTE); - writer.write(escapeLiteral(literal.stringValue())); - writer.write(SerializationConstants.QUOTE); - - literal.getLanguage().ifPresent(lang -> { - try { - writer.write(SerializationConstants.AT_SIGN + lang); - } catch (IOException e) { - throw new UncheckedIOException("Error writing language tag to stream", e); - } - }); - - IRI datatype = literal.getDatatype(); - if (!literal.getLanguage().isPresent() && datatype != null && - (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || - (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL && !datatype.stringValue().equals(SerializationConstants.XSD_STRING)))) { - writer.write(SerializationConstants.DATATYPE_SEPARATOR); - writeIRI(writer, datatype); - } - } - - /** - * Writes an {@link IRI} to the writer. - * The IRI's string representation must be enclosed in angle brackets for N-Triples. - * Applies URI validation based on configuration. - * - * @param writer the {@link Writer} to which the IRI will be written. - * @param iri the {@link IRI} to write. - * @throws IOException if an I/O error occurs. - * @throws IllegalArgumentException if the IRI is invalid (e.g., contains spaces) and strict mode/URI validation is enabled. - */ - private void writeIRI(Writer writer, IRI iri) throws IOException { - if (config.isStrictMode() && config.validateURIs()) { - validateIRI(iri); - } - writer.write(SerializationConstants.LT); - writer.write(escapeNtriplesIRI(iri.stringValue())); - writer.write(SerializationConstants.GT); - } - - /** - * Writes a blank node to the writer. - * Blank nodes are prefixed with "_:", and the identifier is appended. - * Uses the blank node prefix from configuration. - * - * @param writer the {@link Writer} to which the blank node will be written. - * @param blankNode the {@link Resource} representing the blank node. - * @throws IOException if an I/O error occurs. - */ - private void writeBlankNode(Writer writer, Resource blankNode) throws IOException { - writer.write(SerializationConstants.BNODE_PREFIX); - writer.write(blankNode.stringValue()); - } - - /** - * Validates and potentially escapes an IRI string for N-Triples. - * Throws an {@link IllegalArgumentException} if the IRI contains characters - * that are not allowed in N-Triples unescaped form (like spaces, quotes, angle brackets). - * This method is called if strictMode and validateURIs are enabled. - * - * @param iri The string value of the IRI to validate and escape. - * @return The validated and potentially escaped IRI string. - * @throws IllegalArgumentException if the IRI string is invalid. - */ - private String escapeNtriplesIRI(String iri) { - - if (iri.contains(SerializationConstants.SPACE) || - iri.contains(SerializationConstants.QUOTE) || - iri.contains(SerializationConstants.LT) || - iri.contains(SerializationConstants.GT)) { - - throw new IllegalArgumentException("Invalid IRI for N-Triples (contains illegal characters inside '<>'): " + iri); - } - - return config.escapeUnicode() ? escapeUnicodeString(iri) : iri; - } - - - /** - * Escape special characters in N-Triples string literals. - * Handles backslash, double quote, and common control characters. - * Unicode escape sequences are used for unprintable characters if `escapeUnicode` is true. - * - * @param value The string value of the literal to escape. - * @return The escaped string suitable for N-Triples literal. - */ - private String escapeLiteral(String value) { - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < value.length(); i++) { - char c = value.charAt(i); - switch (c) { - case '\n': - sb.append(SerializationConstants.BACK_SLASH).append('n'); - break; - case '\r': - sb.append(SerializationConstants.BACK_SLASH).append('r'); - break; - case '\t': - sb.append(SerializationConstants.BACK_SLASH).append('t'); - break; - case '\b': // backspace - sb.append(SerializationConstants.BACK_SLASH).append('b'); - break; - case '\f': // form feed - sb.append(SerializationConstants.BACK_SLASH).append('f'); - break; - case '"': - sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.QUOTE); - break; - case '\\': - sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.BACK_SLASH); - break; - default: - if (config.escapeUnicode()) { - if (c <= 0x1F || c == 0x7F) { - sb.append(String.format("\\u%04X", (int) c)); - } else { - sb.append(c); - } - } else { - sb.append(c); - } - } - } - return sb.toString(); - } - - /** - * Escapes non-ASCII and control characters into Unicode escape sequences. - * This is a helper for `escapeNtriplesIRI` and potentially `escapeLiteral` - * if `escapeUnicode` is true in config. - * - * @param value The string to escape. - * @return The string with Unicode characters escaped. - */ - private String escapeUnicodeString(String value) { - StringBuilder sb = new StringBuilder(); - int len = value.length(); // Cache length for invariant stop condition - for (int i = 0; i < len; i++) { - char c = value.charAt(i); - if (c <= 0x1F || c == 0x7F || (c >= 0x80 && c <= 0xFFFF)) { // Basic Multilingual Plane characters and control characters - sb.append(String.format("\\u%04X", (int) c)); - } else if (Character.isHighSurrogate(c)) { // Supplementary characters - int codePoint = value.codePointAt(i); - if (Character.isValidCodePoint(codePoint)) { - sb.append(String.format("\\U%08X", codePoint)); - i++; // Skip the low surrogate char - } else { - sb.append(c); // Append invalid surrogate char directly - } - } else { - sb.append(c); - } - } - return sb.toString(); - } - - /** - * Validates RDF values before serialization to ensure they conform to N-Triples rules. - * Only called if strictMode is enabled. - * - * @param value The {@link Value} to validate. - * @throws IllegalArgumentException if the value is null or invalid based on N-Triples rules. - */ - private void validateValue(Value value) { - if (value == null) { - logger.warn("Encountered a null value where a non-null value was expected for N-Triples serialization. This will result in an IllegalArgumentException if strict mode is enabled."); - throw new IllegalArgumentException("Value cannot be null in N-Triples format when strictMode is enabled."); - } - - if (value.isLiteral()) { - validateLiteral((Literal) value); - } else if (value.isIRI()) { - validateIRI((IRI) value); - } - } - - /** - * Validates a {@link Literal} to ensure it conforms to RDF/N-Triples rules. - * Specifically checks for consistency between language tags and the rdf:langString datatype. - * Only called if strictMode is enabled. - * - * @param literal The {@link Literal} to validate. - * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, - * or rdf:langString literal missing a language tag). - */ - private void validateLiteral(Literal literal) { - IRI datatype = literal.getDatatype(); - - if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { - throw new IllegalArgumentException( - "Literal with language tag must use rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); - } - } else { - if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { - throw new IllegalArgumentException( - "rdf:langString literal must have a language tag."); - } - } - } - - /** - * Validates an {@link IRI} to ensure it conforms to N-Triples rules. - * Checks if the IRI string contains characters that are not allowed in N-Triples - * unescaped form, such as spaces, quotes, or angle brackets. - * Only called if strictMode and validateURIs are enabled. - * - * @param iri The {@link IRI} to validate. - * @throws IllegalArgumentException if the IRI contains invalid characters. - */ - private void validateIRI(IRI iri) { - String iriString = iri.stringValue(); - if (iriString.contains(SerializationConstants.SPACE) || - iriString.contains(SerializationConstants.QUOTE) || - iriString.contains(SerializationConstants.LT) || - iriString.contains(SerializationConstants.GT)) { - throw new IllegalArgumentException("IRI contains illegal characters (space, quote, angle brackets) for N-Triples unescaped form: " + iriString); } + // N-Triples does not support contexts, so we don't write anything } } \ No newline at end of file diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java new file mode 100644 index 000000000..d472bc766 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java @@ -0,0 +1,374 @@ +package fr.inria.corese.core.next.impl.common.serialization.base; + +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; +import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.UncheckedIOException; +import java.io.Writer; +import java.util.Collections; +import java.util.Objects; +import java.util.Set; + +/** + * Base class for line-based RDF serializers (N-Triples, N-Quads). + * Contains all the common logic for writing statements line by line. + * Subclasses only need to implement how to handle the context part. + */ +public abstract class AbstractLineBasedSerializer implements IRdfSerializer { + + /** + * Logger for this class, used for logging potential issues or information during serialization. + */ + private static final Logger logger = LoggerFactory.getLogger(AbstractLineBasedSerializer.class); + + protected final Model model; + protected final FormatConfig config; + + /** + * Constructs a new line-based serializer. + * + * @param model the {@link Model} to be serialized. Must not be null. + * @param config the {@link FormatConfig} to use for serialization. Must not be null. + * @throws NullPointerException if the provided model or config is null. + */ + protected AbstractLineBasedSerializer(Model model, FormatConfig config) { + this.model = Objects.requireNonNull(model, "Model cannot be null"); + this.config = Objects.requireNonNull(config, "Configuration cannot be null"); + } + + /** + * Writes the model to the given writer. + * Each statement in the model is written on a new line, terminated by a dot and a newline character. + * + * @param writer the {@link Writer} to which the output will be written. + * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + */ + @Override + public void write(Writer writer) throws SerializationException { + try (BufferedWriter bufferedWriter = new BufferedWriter(writer)) { + Set processedNodes = preprocessModel(); + + for (Statement stmt : model) { + if (shouldProcess(stmt, processedNodes)) { + writeStatement(bufferedWriter, stmt); + } + } + + } catch (IOException e) { + throw new SerializationException(getFormatName() + " serialization failed", getFormatName(), e); + } catch (IllegalArgumentException e) { + throw new SerializationException("Invalid " + getFormatName() + " data: " + e.getMessage(), getFormatName(), e); + } + } + + /** + * Returns the name of the format for error messages. + */ + protected abstract String getFormatName(); + + /** + * Handles writing the context part of a statement. + * This is where N-Triples and N-Quads differ. + * + * @param writer the writer to write to + * @param stmt the statement containing the context + * @throws IOException if an I/O error occurs + */ + protected abstract void writeContext(Writer writer, Statement stmt) throws IOException; + + private Set preprocessModel() { + return Collections.emptySet(); + } + + private boolean shouldProcess(Statement stmt, Set processedNodes) { + return !processedNodes.contains(stmt.getSubject()); + } + + /** + * Writes a single {@link Statement} to the writer. + * The statement is written as "$subject $predicate $object" followed by context handling. + * + * @param writer the {@link Writer} to which the statement will be written. + * @param stmt the {@link Statement} to write. + * @throws IOException if an I/O error occurs. + */ + private void writeStatement(Writer writer, Statement stmt) throws IOException { + writeValue(writer, stmt.getSubject()); + writer.write(SerializationConstants.SPACE); + writeValue(writer, stmt.getPredicate()); + writer.write(SerializationConstants.SPACE); + writeValue(writer, stmt.getObject()); + + // Let subclass handle the context + writeContext(writer, stmt); + + if (config.trailingDot()) { + writer.write(SerializationConstants.SPACE); + writer.write(SerializationConstants.POINT); + } + + writer.write(config.getLineEnding()); + } + + /** + * Writes a single {@link Value} to the writer. + * Handles literals, blank nodes, and IRIs. + * + * @param writer the {@link Writer} to which the value will be written. + * @param value the {@link Value} to write. + * @throws IOException if an I/O error occurs. + * @throws IllegalArgumentException if the provided value is null or an unsupported type. + */ + protected void writeValue(Writer writer, Value value) throws IOException { + validateValue(value); + + if (value.isLiteral()) { + writeLiteral(writer, (Literal) value); + } else if (value.isResource()) { + if (value.isIRI()) { + writeIRI(writer, (IRI) value); + } else if (value.isBNode()) { + writeBlankNode(writer, (Resource) value); + } else { + throw new IllegalArgumentException("Unsupported resource type for " + getFormatName() + " serialization: " + value.getClass().getName()); + } + } else { + throw new IllegalArgumentException("Unsupported value type for " + getFormatName() + " serialization: " + value.getClass().getName()); + } + } + + /** + * Writes a {@link Literal} to the writer. + * Applies escaping and datatype/language tag rules based on configuration. + * + * @param writer the {@link Writer} to which the literal will be written. + * @param literal the {@link Literal} to write. + * @throws IOException if an I/O error occurs. + */ + protected void writeLiteral(Writer writer, Literal literal) throws IOException { + writer.write(SerializationConstants.QUOTE); + writer.write(escapeLiteral(literal.stringValue())); + writer.write(SerializationConstants.QUOTE); + + literal.getLanguage().ifPresent(lang -> { + try { + writer.write(SerializationConstants.AT_SIGN + lang); + } catch (IOException e) { + throw new UncheckedIOException("Error writing language tag to stream", e); + } + }); + + IRI datatype = literal.getDatatype(); + if (!literal.getLanguage().isPresent() && datatype != null && + (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || + (config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL && !datatype.stringValue().equals(SerializationConstants.XSD_STRING)))) { + writer.write(SerializationConstants.DATATYPE_SEPARATOR); + writeIRI(writer, datatype); + } + } + + /** + * Writes an {@link IRI} to the writer. + * The IRI's string representation must be enclosed in angle brackets. + * Applies URI validation based on configuration. + * + * @param writer the {@link Writer} to which the IRI will be written. + * @param iri the {@link IRI} to write. + * @throws IOException if an I/O error occurs. + * @throws IllegalArgumentException if the IRI is invalid (e.g., contains spaces) and strict mode/URI validation is enabled. + */ + protected void writeIRI(Writer writer, IRI iri) throws IOException { + if (config.isStrictMode() && config.validateURIs()) { + validateIRI(iri); + } + writer.write(SerializationConstants.LT); + writer.write(escapeIRI(iri.stringValue())); + writer.write(SerializationConstants.GT); + } + + /** + * Writes a blank node to the writer. + * Blank nodes are prefixed with "_:", and the identifier is appended. + * + * @param writer the {@link Writer} to which the blank node will be written. + * @param blankNode the {@link Resource} representing the blank node. + * @throws IOException if an I/O error occurs. + */ + protected void writeBlankNode(Writer writer, Resource blankNode) throws IOException { + writer.write(SerializationConstants.BNODE_PREFIX); + writer.write(blankNode.stringValue()); + } + + /** + * Validates and potentially escapes an IRI string. + * Throws an {@link IllegalArgumentException} if the IRI contains characters + * that are not allowed in unescaped form (like spaces, quotes, angle brackets). + * This method is called if strictMode and validateURIs are enabled. + * + * @param iri The string value of the IRI to validate and escape. + * @return The validated and potentially escaped IRI string. + * @throws IllegalArgumentException if the IRI string is invalid. + */ + protected String escapeIRI(String iri) { + if (iri.contains(SerializationConstants.SPACE) || + iri.contains(SerializationConstants.QUOTE) || + iri.contains(SerializationConstants.LT) || + iri.contains(SerializationConstants.GT)) { + + throw new IllegalArgumentException("Invalid IRI for " + getFormatName() + " (contains illegal characters inside '<>'): " + iri); + } + + return config.escapeUnicode() ? escapeUnicodeString(iri) : iri; + } + + /** + * Escape special characters in string literals. + * Handles backslash, double quote, and common control characters. + * Unicode escape sequences are used for unprintable characters if `escapeUnicode` is true. + * + * @param value The string value of the literal to escape. + * @return The escaped string suitable for literal. + */ + protected String escapeLiteral(String value) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < value.length(); i++) { + char c = value.charAt(i); + switch (c) { + case '\n': + sb.append(SerializationConstants.BACK_SLASH).append('n'); + break; + case '\r': + sb.append(SerializationConstants.BACK_SLASH).append('r'); + break; + case '\t': + sb.append(SerializationConstants.BACK_SLASH).append('t'); + break; + case '\b': // backspace + sb.append(SerializationConstants.BACK_SLASH).append('b'); + break; + case '\f': // form feed + sb.append(SerializationConstants.BACK_SLASH).append('f'); + break; + case '"': + sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.QUOTE); + break; + case '\\': + sb.append(SerializationConstants.BACK_SLASH).append(SerializationConstants.BACK_SLASH); + break; + default: + if (config.escapeUnicode()) { + if (c <= 0x1F || c == 0x7F) { + sb.append(String.format("\\u%04X", (int) c)); + } else { + sb.append(c); + } + } else { + sb.append(c); + } + } + } + return sb.toString(); + } + + /** + * Escapes non-ASCII and control characters into Unicode escape sequences. + * This is a helper for `escapeIRI` and potentially `escapeLiteral` + * if `escapeUnicode` is true in config. + * + * @param value The string to escape. + * @return The string with Unicode characters escaped. + */ + protected String escapeUnicodeString(String value) { + StringBuilder sb = new StringBuilder(); + int len = value.length(); // Cache length for invariant stop condition + for (int i = 0; i < len; i++) { + char c = value.charAt(i); + if (c <= 0x1F || c == 0x7F || (c >= 0x80 && c <= 0xFFFF)) { // Basic Multilingual Plane characters and control characters + sb.append(String.format("\\u%04X", (int) c)); + } else if (Character.isHighSurrogate(c)) { // Supplementary characters + int codePoint = value.codePointAt(i); + if (Character.isValidCodePoint(codePoint)) { + sb.append(String.format("\\U%08X", codePoint)); + i++; // Skip the low surrogate char + } else { + sb.append(c); // Append invalid surrogate char directly + } + } else { + sb.append(c); + } + } + return sb.toString(); + } + + /** + * Validates RDF values before serialization to ensure they conform to rules. + * Only called if strictMode is enabled. + * + * @param value The {@link Value} to validate. + * @throws IllegalArgumentException if the value is null or invalid based on rules. + */ + protected void validateValue(Value value) { + if (value == null) { + logger.warn("Encountered a null value where a non-null value was expected for " + getFormatName() + " serialization. This will result in an IllegalArgumentException if strict mode is enabled."); + throw new IllegalArgumentException("Value cannot be null in " + getFormatName() + " format when strictMode is enabled."); + } + + if (value.isLiteral()) { + validateLiteral((Literal) value); + } else if (value.isIRI()) { + validateIRI((IRI) value); + } + } + + /** + * Validates a {@link Literal} to ensure it conforms to RDF rules. + * Specifically checks for consistency between language tags and the rdf:langString datatype. + * Only called if strictMode is enabled. + * + * @param literal The {@link Literal} to validate. + * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, + * or rdf:langString literal missing a language tag). + */ + protected void validateLiteral(Literal literal) { + IRI datatype = literal.getDatatype(); + + if (literal.getLanguage().isPresent()) { + if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { + throw new IllegalArgumentException( + "Literal with language tag must use rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); + } + } else { + if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { + throw new IllegalArgumentException( + "rdf:langString literal must have a language tag."); + } + } + } + + /** + * Validates an {@link IRI} to ensure it conforms to rules. + * Checks if the IRI string contains characters that are not allowed + * unescaped form, such as spaces, quotes, or angle brackets. + * Only called if strictMode and validateURIs are enabled. + * + * @param iri The {@link IRI} to validate. + * @throws IllegalArgumentException if the IRI contains invalid characters. + */ + protected void validateIRI(IRI iri) { + String iriString = iri.stringValue(); + if (iriString.contains(SerializationConstants.SPACE) || + iriString.contains(SerializationConstants.QUOTE) || + iriString.contains(SerializationConstants.LT) || + iriString.contains(SerializationConstants.GT)) { + throw new IllegalArgumentException("IRI contains illegal characters (space, quote, angle brackets) for " + getFormatName() + " unescaped form: " + iriString); + } + } +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java index ead78391a..de18a756d 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java @@ -150,7 +150,7 @@ void writeShouldThrowOnIOException() throws IOException { SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesSerializer.write(faultyWriter)); - assertEquals("NTriples serialization failed [Format: NTriples]", thrown.getMessage()); + assertEquals("N-Triples serialization failed [Format: N-Triples]", thrown.getMessage()); } @@ -166,7 +166,7 @@ void writeShouldThrowOnNullSubjectValue() { StringWriter writer = new StringWriter(); SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesSerializer.write(writer)); - assertEquals("Invalid NTriples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); + assertEquals("Invalid N-Triples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: N-Triples]", thrown.getMessage()); } @Test @@ -180,7 +180,7 @@ void writeShouldThrowOnNullPredicateValue() { StringWriter writer = new StringWriter(); SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesSerializer.write(writer)); - assertEquals("Invalid NTriples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); + assertEquals("Invalid N-Triples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: N-Triples]", thrown.getMessage()); } @Test @@ -194,7 +194,7 @@ void writeShouldThrowOnNullObjectValue() { StringWriter writer = new StringWriter(); SerializationException thrown = assertThrows(SerializationException.class, () -> nTriplesSerializer.write(writer)); - assertEquals("Invalid NTriples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: NTriples]", thrown.getMessage()); + assertEquals("Invalid N-Triples data: Value cannot be null in N-Triples format when strictMode is enabled. [Format: N-Triples]", thrown.getMessage()); } From 7f9c408a3b55e0769b05d34937cca5a32a0d3993 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Tue, 1 Jul 2025 09:55:10 +0200 Subject: [PATCH 19/27] =?UTF-8?q?Correction=20des=20noms=20d'interfaces=20?= =?UTF-8?q?(suppression=20du=20pr=C3=A9fixe=20"I")=20et=20ajout=20de=20la?= =?UTF-8?q?=20documentation=20manquante?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../core/next/api/ISerializerFactory.java | 9 ---- ...IRdfSerializer.java => RdfSerializer.java} | 12 ++++- ...onConfig.java => SerializationConfig.java} | 4 +- .../core/next/api/SerializerFactory.java | 19 +++++++ .../DefaultSerializerFactory.java | 42 +++++++-------- .../serialization/NQuadsSerializer.java | 12 ++--- .../serialization/NTriplesSerializer.java | 10 ++-- .../common/serialization/TriGSerializer.java | 16 +++--- .../serialization/TurtleSerializer.java | 16 +++--- .../common/serialization/XmlSerializer.java | 18 +++---- .../base/AbstractLineBasedSerializer.java | 10 ++-- ...ormatConfig.java => SerializerConfig.java} | 40 +++++++------- .../exception/SerializationException.java | 52 +++++++++++++++++-- .../datatype/function/StringHelper.java | 2 +- .../DefaultSerializerFactoryTest.java | 20 +++---- .../serialization/NQuadsSerializerTest.java | 8 +-- .../serialization/NTriplesSerializerTest.java | 10 ++-- ...figTest.java => SerializerConfigTest.java} | 28 +++++----- .../serialization/TriGSerializerTest.java | 20 +++---- .../serialization/TurtleSerializerTest.java | 22 ++++---- .../serialization/XmlSerializerTest.java | 4 +- 21 files changed, 219 insertions(+), 155 deletions(-) delete mode 100644 src/main/java/fr/inria/corese/core/next/api/ISerializerFactory.java rename src/main/java/fr/inria/corese/core/next/api/{IRdfSerializer.java => RdfSerializer.java} (55%) rename src/main/java/fr/inria/corese/core/next/api/{ISerializationConfig.java => SerializationConfig.java} (77%) create mode 100644 src/main/java/fr/inria/corese/core/next/api/SerializerFactory.java rename src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/{FormatConfig.java => SerializerConfig.java} (95%) rename src/test/java/fr/inria/corese/core/next/impl/common/serialization/{FormatConfigTest.java => SerializerConfigTest.java} (90%) diff --git a/src/main/java/fr/inria/corese/core/next/api/ISerializerFactory.java b/src/main/java/fr/inria/corese/core/next/api/ISerializerFactory.java deleted file mode 100644 index 796a7803a..000000000 --- a/src/main/java/fr/inria/corese/core/next/api/ISerializerFactory.java +++ /dev/null @@ -1,9 +0,0 @@ -package fr.inria.corese.core.next.api; - -import fr.inria.corese.core.next.impl.common.serialization.RdfFormat; - -public interface ISerializerFactory { - - - IRdfSerializer createSerializer(RdfFormat format, Model model, ISerializationConfig config); -} diff --git a/src/main/java/fr/inria/corese/core/next/api/IRdfSerializer.java b/src/main/java/fr/inria/corese/core/next/api/RdfSerializer.java similarity index 55% rename from src/main/java/fr/inria/corese/core/next/api/IRdfSerializer.java rename to src/main/java/fr/inria/corese/core/next/api/RdfSerializer.java index d84c7d5f6..39d1f2dbc 100644 --- a/src/main/java/fr/inria/corese/core/next/api/IRdfSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/api/RdfSerializer.java @@ -4,7 +4,17 @@ import java.io.Writer; -public interface IRdfSerializer { +/** + * Factory interface for creating {@link RdfSerializer} instances. + * This interface defines a contract for classes that are responsible + * for providing appropriate RDF serializers based on the desired + * {@link fr.inria.corese.core.next.impl.common.serialization.RdfFormat}, a {@link Model} to be serialized, and + * {@link SerializationConfig}. + * Implementations of this factory can manage the instantiation + * and configuration of various RDF serializers, promoting + * loose coupling and extensibility in the serialization process. + */ +public interface RdfSerializer { /** * A serializer that converts a {@link Model} instance diff --git a/src/main/java/fr/inria/corese/core/next/api/ISerializationConfig.java b/src/main/java/fr/inria/corese/core/next/api/SerializationConfig.java similarity index 77% rename from src/main/java/fr/inria/corese/core/next/api/ISerializationConfig.java rename to src/main/java/fr/inria/corese/core/next/api/SerializationConfig.java index 982f07164..47b9f8cbe 100644 --- a/src/main/java/fr/inria/corese/core/next/api/ISerializationConfig.java +++ b/src/main/java/fr/inria/corese/core/next/api/SerializationConfig.java @@ -6,9 +6,9 @@ * This interface provides a common type for all serialization configuration * implementations, promoting abstraction and flexibility in how serialization * options are defined and provided. - * Implementations of this interface (e.g., FormatConfig) will define the + * Implementations of this interface (e.g., SerializerConfig) will define the * specific parameters and settings relevant to a particular serialization process. */ -public interface ISerializationConfig { +public interface SerializationConfig { } diff --git a/src/main/java/fr/inria/corese/core/next/api/SerializerFactory.java b/src/main/java/fr/inria/corese/core/next/api/SerializerFactory.java new file mode 100644 index 000000000..b30177181 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/api/SerializerFactory.java @@ -0,0 +1,19 @@ +package fr.inria.corese.core.next.api; + +import fr.inria.corese.core.next.impl.common.serialization.RdfFormat; + +/** + * Factory interface for creating {@link RdfSerializer} instances. + * This interface defines a contract for classes that are responsible + * for providing appropriate RDF serializers based on the desired + * {@link RdfFormat}, a {@link Model} to be serialized, and + * {@link SerializationConfig}. + * Implementations of this factory can manage the instantiation + * and configuration of various RDF serializers, promoting + * loose coupling and extensibility in the serialization process. + */ +public interface SerializerFactory { + + + RdfSerializer createSerializer(RdfFormat format, Model model, SerializationConfig config); +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java index 9ffe333b2..fabfb60c8 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java @@ -1,10 +1,10 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.IRdfSerializer; -import fr.inria.corese.core.next.api.ISerializerFactory; +import fr.inria.corese.core.next.api.RdfSerializer; +import fr.inria.corese.core.next.api.SerializerFactory; import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.api.ISerializationConfig; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.api.SerializationConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import java.util.Collections; import java.util.HashMap; import java.util.Map; @@ -12,50 +12,50 @@ import java.util.function.BiFunction; /** - * Default implementation of {@link ISerializerFactory}. - * This factory is responsible for creating instances of {@link IRdfSerializer} + * Default implementation of {@link SerializerFactory}. + * This factory is responsible for creating instances of {@link RdfSerializer} * based on the requested {@link RdfFormat}. It uses a registry pattern * to map each format to its corresponding serializer constructor, * providing a flexible and extensible way to manage serializer instances. */ -public class DefaultSerializerFactory implements ISerializerFactory { +public class DefaultSerializerFactory implements SerializerFactory { - private final Map> registry; + private final Map> registry; /** * Constructs a {@code DefaultSerializerFactory} and populates its registry * with constructors for all known {@link RdfFormat} implementations. */ public DefaultSerializerFactory() { - Map> tempRegistry = new HashMap<>(); - // Cast the lambda to BiFunction - tempRegistry.put(RdfFormat.TURTLE, (model, config) -> new TurtleSerializer(model, (FormatConfig) config)); - tempRegistry.put(RdfFormat.NTRIPLES, (model, config) -> new NTriplesSerializer(model, (FormatConfig) config)); - tempRegistry.put(RdfFormat.NQUADS, (model, config) -> new NQuadsSerializer(model, (FormatConfig) config)); - tempRegistry.put(RdfFormat.TRIG, (model, config) -> new TriGSerializer(model, (FormatConfig) config)); - tempRegistry.put(RdfFormat.RDFXML, (model, config) -> new XmlSerializer(model, (FormatConfig) config)); + Map> tempRegistry = new HashMap<>(); + // Cast the lambda to BiFunction + tempRegistry.put(RdfFormat.TURTLE, (model, config) -> new TurtleSerializer(model, (SerializerConfig) config)); + tempRegistry.put(RdfFormat.NTRIPLES, (model, config) -> new NTriplesSerializer(model, (SerializerConfig) config)); + tempRegistry.put(RdfFormat.NQUADS, (model, config) -> new NQuadsSerializer(model, (SerializerConfig) config)); + tempRegistry.put(RdfFormat.TRIG, (model, config) -> new TriGSerializer(model, (SerializerConfig) config)); + tempRegistry.put(RdfFormat.RDFXML, (model, config) -> new XmlSerializer(model, (SerializerConfig) config)); this.registry = Collections.unmodifiableMap(tempRegistry); } /** - * Creates an {@link IRdfSerializer} instance for the specified format, model, and configuration. + * Creates an {@link RdfSerializer} instance for the specified format, model, and configuration. * * @param format the {@link RdfFormat} for which to create the serializer. Must not be null. * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link ISerializationConfig} to apply during serialization. Must not be null. - * @return a new instance of {@link IRdfSerializer} configured for the specified format. + * @param config the {@link SerializationConfig} to apply during serialization. Must not be null. + * @return a new instance of {@link RdfSerializer} configured for the specified format. * @throws NullPointerException if any of the arguments (format, model, config) are null. * @throws IllegalArgumentException if the provided format is not supported by this factory. */ @Override - public IRdfSerializer createSerializer(RdfFormat format, Model model, ISerializationConfig config) { + public RdfSerializer createSerializer(RdfFormat format, Model model, SerializationConfig config) { Objects.requireNonNull(format, "RdfFormat cannot be null"); Objects.requireNonNull(model, "Model cannot be null"); - Objects.requireNonNull(config, "IFormatConfig cannot be null"); + Objects.requireNonNull(config, "SerializationConfig cannot be null"); - BiFunction constructor = registry.get(format); + BiFunction constructor = registry.get(format); if (constructor == null) { throw new IllegalArgumentException("Unsupported RdfFormat: " + format.getName()); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java index 94b78053a..db031f5de 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java @@ -2,7 +2,7 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.serialization.base.AbstractLineBasedSerializer; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -24,24 +24,24 @@ public class NQuadsSerializer extends AbstractLineBasedSerializer { /** * Constructs a new {@code NQuadsSerializer} instance with the specified model and default N-Quads configuration. - * The default configuration is obtained from {@link FormatConfig#nquadsConfig()}. + * The default configuration is obtained from {@link SerializerConfig#nquadsConfig()}. * * @param model the {@link Model} to be serialized. Must not be null. * @throws NullPointerException if the provided model is null. */ public NQuadsSerializer(Model model) { - this(model, FormatConfig.nquadsConfig()); + this(model, SerializerConfig.nquadsConfig()); } /** * Constructs a new {@code NQuadsSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. + * @param config the {@link SerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or config is null. */ - public NQuadsSerializer(Model model, ISerializationConfig config) { - super(model, (FormatConfig) config); + public NQuadsSerializer(Model model, SerializationConfig config) { + super(model, (SerializerConfig) config); } /** diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java index 399255bd1..6110be218 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java @@ -2,7 +2,7 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.serialization.base.AbstractLineBasedSerializer; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -28,18 +28,18 @@ public class NTriplesSerializer extends AbstractLineBasedSerializer { * @throws NullPointerException if the provided model is null. */ public NTriplesSerializer(Model model) { - this(model, FormatConfig.ntriplesConfig()); + this(model, SerializerConfig.ntriplesConfig()); } /** * Constructs a new {@code NTriplesSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. + * @param config the {@link SerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or config is null. */ - public NTriplesSerializer(Model model, ISerializationConfig config) { - super(model, (FormatConfig) config); + public NTriplesSerializer(Model model, SerializationConfig config) { + super(model, (SerializerConfig) config); } /** diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java index 7ab5bd4b0..1d84b5206 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java @@ -3,7 +3,7 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; @@ -42,7 +42,7 @@ *

Advanced features such as strict adherence to maximum line length * and generation of stable blank node identifiers are not fully implemented in this version.

*/ -public class TriGSerializer implements IRdfSerializer { +public class TriGSerializer implements RdfSerializer { /** * Logger for this class, used to log potential issues or information during serialization. @@ -50,7 +50,7 @@ public class TriGSerializer implements IRdfSerializer { private static final Logger logger = LoggerFactory.getLogger(TriGSerializer.class); private final Model model; - private final FormatConfig config; + private final SerializerConfig config; private final Map iriToPrefixMapping; private final Map prefixToIriMapping; // Set to track blank nodes already serialized inline or as part of a list @@ -60,25 +60,25 @@ public class TriGSerializer implements IRdfSerializer { /** * Constructs a new {@code TriGSerializer} instance with the specified model and default configuration. - * The default configuration is returned by {@link FormatConfig#trigConfig()}. + * The default configuration is returned by {@link SerializerConfig#trigConfig()}. * * @param model the {@link Model} to serialize. Must not be null. * @throws NullPointerException if the provided model is null. */ public TriGSerializer(Model model) { - this(model, FormatConfig.trigConfig()); + this(model, SerializerConfig.trigConfig()); } /** * Constructs a new {@code TriGSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. + * @param config the {@link SerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or configuration is null. */ - public TriGSerializer(Model model, ISerializationConfig config) { + public TriGSerializer(Model model, SerializationConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = (SerializerConfig) Objects.requireNonNull(config, "Configuration cannot be null"); this.iriToPrefixMapping = new HashMap<>(); this.prefixToIriMapping = new HashMap<>(); this.consumedBlankNodes = new HashSet<>(); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java index 084c6333d..f1d81b25a 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java @@ -3,7 +3,7 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; @@ -41,7 +41,7 @@ *

Advanced features such as strict adherence to maximum line length * and generation of stable blank node identifiers are not fully implemented in this version.

*/ -public class TurtleSerializer implements IRdfSerializer { +public class TurtleSerializer implements RdfSerializer { /** * Logger for this class, used to log potential issues or information during serialization. @@ -49,7 +49,7 @@ public class TurtleSerializer implements IRdfSerializer { private static final Logger logger = LoggerFactory.getLogger(TurtleSerializer.class); private final Model model; - private final FormatConfig config; + private final SerializerConfig config; private final Map iriToPrefixMapping; private final Map prefixToIriMapping; // Set to track blank nodes already serialized inline or as part of a list @@ -59,25 +59,25 @@ public class TurtleSerializer implements IRdfSerializer { /** * Constructs a new {@code TurtleSerializer} instance with the specified model and default configuration. - * The default configuration is returned by {@link FormatConfig#turtleConfig()}. + * The default configuration is returned by {@link SerializerConfig#turtleConfig()}. * * @param model the {@link Model} to serialize. Must not be null. * @throws NullPointerException if the provided model is null. */ public TurtleSerializer(Model model) { - this(model, FormatConfig.turtleConfig()); + this(model, SerializerConfig.turtleConfig()); } /** * Constructs a new {@code TurtleSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. + * @param config the {@link SerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or configuration is null. */ - public TurtleSerializer(Model model, ISerializationConfig config) { + public TurtleSerializer(Model model, SerializationConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = (SerializerConfig) Objects.requireNonNull(config, "Configuration cannot be null"); this.iriToPrefixMapping = new HashMap<>(); this.prefixToIriMapping = new HashMap<>(); this.consumedBlankNodes = new HashSet<>(); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java index 5b4ffc8d9..a81e70921 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; @@ -32,12 +32,12 @@ *

Advanced features such as handling XML schemata, specific RDF/XML graph structures (e.g., rdf:Bag, rdf:Seq, rdf:Alt), * and full blank node syntax optimization are simplified in this version.

*/ -public class XmlSerializer implements IRdfSerializer { +public class XmlSerializer implements RdfSerializer { private static final Logger logger = LoggerFactory.getLogger(XmlSerializer.class); private final Model model; - private final FormatConfig config; + private final SerializerConfig config; private final Map iriToPrefixMapping; private final Map prefixToIriMapping; private final Map blankNodeIds; @@ -46,25 +46,25 @@ public class XmlSerializer implements IRdfSerializer { /** * Constructs a new {@code XmlSerializer} instance with the specified model and default configuration. - * The default configuration is returned by {@link FormatConfig#rdfXmlConfig()}. + * The default configuration is returned by {@link SerializerConfig#rdfXmlConfig()}. * * @param model the {@link Model} to serialize. Must not be null. * @throws NullPointerException if the provided model is null. */ public XmlSerializer(Model model) { - this(model, FormatConfig.rdfXmlConfig()); + this(model, SerializerConfig.rdfXmlConfig()); } /** * Constructs a new {@code XmlSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link ISerializationConfig} to use for serialization. Must not be null. + * @param config the {@link SerializationConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or configuration is null. */ - public XmlSerializer(Model model, ISerializationConfig config) { + public XmlSerializer(Model model, SerializationConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (FormatConfig) Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = (SerializerConfig) Objects.requireNonNull(config, "Configuration cannot be null"); this.iriToPrefixMapping = new HashMap<>(); this.prefixToIriMapping = new HashMap<>(); this.blankNodeIds = new HashMap<>(); @@ -73,7 +73,7 @@ public XmlSerializer(Model model, ISerializationConfig config) { /** * Initializes prefix mappings by adding custom prefixes from the configuration. - * The custom prefixes map in FormatConfig is expected to be {namespaceURI: prefix}. + * The custom prefixes map in SerializerConfig is expected to be {namespaceURI: prefix}. */ private void initializePrefixes() { if (config.usePrefixes()) { diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java index d472bc766..869c1d108 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java @@ -2,7 +2,7 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; @@ -22,7 +22,7 @@ * Contains all the common logic for writing statements line by line. * Subclasses only need to implement how to handle the context part. */ -public abstract class AbstractLineBasedSerializer implements IRdfSerializer { +public abstract class AbstractLineBasedSerializer implements RdfSerializer { /** * Logger for this class, used for logging potential issues or information during serialization. @@ -30,16 +30,16 @@ public abstract class AbstractLineBasedSerializer implements IRdfSerializer { private static final Logger logger = LoggerFactory.getLogger(AbstractLineBasedSerializer.class); protected final Model model; - protected final FormatConfig config; + protected final SerializerConfig config; /** * Constructs a new line-based serializer. * * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link FormatConfig} to use for serialization. Must not be null. + * @param config the {@link SerializerConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or config is null. */ - protected AbstractLineBasedSerializer(Model model, FormatConfig config) { + protected AbstractLineBasedSerializer(Model model, SerializerConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); this.config = Objects.requireNonNull(config, "Configuration cannot be null"); } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/SerializerConfig.java similarity index 95% rename from src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java rename to src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/SerializerConfig.java index b41452d24..b888abd2a 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/FormatConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/SerializerConfig.java @@ -1,6 +1,6 @@ package fr.inria.corese.core.next.impl.common.serialization.config; -import fr.inria.corese.core.next.api.ISerializationConfig; +import fr.inria.corese.core.next.api.SerializationConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import java.util.Collections; @@ -13,11 +13,11 @@ * This class provides a comprehensive set of options to control the output * syntax, pretty-printing, and technical aspects of RDF serialization. * - *

Use the {@link Builder} class to create instances of {@code FormatConfig}. + *

Use the {@link Builder} class to create instances of {@code SerializerConfig}. * Predefined configurations for common RDF formats are available via static methods * like {@link #ntriplesConfig()}, {@link #nquadsConfig()}, {@link #turtleConfig()}, etc.

*/ -public class FormatConfig implements ISerializationConfig { +public class SerializerConfig implements SerializationConfig { /** * Whether prefix declarations (e.g., `@prefix`, `PREFIX`) should be used for compact IRIs. @@ -150,7 +150,7 @@ public class FormatConfig implements ISerializationConfig { * * @param builder The builder instance. */ - private FormatConfig(Builder builder) { + private SerializerConfig(Builder builder) { this.usePrefixes = builder.usePrefixes; this.autoDeclarePrefixes = builder.autoDeclarePrefixes; @@ -193,8 +193,8 @@ private FormatConfig(Builder builder) { // --- Builder Class --- /** - * Builder class for {@link FormatConfig}. - * Provides a fluent API for constructing FormatConfig instances with default values. + * Builder class for {@link SerializerConfig}. + * Provides a fluent API for constructing SerializerConfig instances with default values. */ public static class Builder { // Syntax Sugar Defaults @@ -377,13 +377,13 @@ public Builder lineEnding(String lineEnding) { } /** - * Builds and returns a new {@link FormatConfig} instance with the current builder settings. + * Builds and returns a new {@link SerializerConfig} instance with the current builder settings. * - * @return A new {@code FormatConfig} instance. + * @return A new {@code SerializerConfig} instance. * @throws NullPointerException if any required field has not been set (should not happen with default values). */ - public FormatConfig build() { - return new FormatConfig(this); + public SerializerConfig build() { + return new SerializerConfig(this); } } @@ -393,9 +393,9 @@ public FormatConfig build() { * Returns a default configuration suitable for N-Triples serialization. * N-Triples is a simple, line-oriented format without prefixes, contexts, or complex syntax sugar. * - * @return A {@code FormatConfig} instance for N-Triples. + * @return A {@code SerializerConfig} instance for N-Triples. */ - public static FormatConfig ntriplesConfig() { + public static SerializerConfig ntriplesConfig() { return new Builder() .usePrefixes(false) // N-Triples doesn't use prefixes .autoDeclarePrefixes(false) @@ -426,9 +426,9 @@ public static FormatConfig ntriplesConfig() { * Returns a default configuration suitable for N-Quads serialization. * N-Quads extends N-Triples with named graphs. * - * @return A {@code FormatConfig} instance for N-Quads. + * @return A {@code SerializerConfig} instance for N-Quads. */ - public static FormatConfig nquadsConfig() { + public static SerializerConfig nquadsConfig() { return new Builder() .usePrefixes(false) // N-Quads doesn't use prefixes .autoDeclarePrefixes(false) @@ -459,9 +459,9 @@ public static FormatConfig nquadsConfig() { * Returns a default configuration suitable for Turtle serialization. * Turtle is a concise, human-readable format with extensive syntax sugar and pretty-printing. * - * @return A {@code FormatConfig} instance for Turtle. + * @return A {@code SerializerConfig} instance for Turtle. */ - public static FormatConfig turtleConfig() { + public static SerializerConfig turtleConfig() { Map commonTurtlePrefixes = new HashMap<>(); commonTurtlePrefixes.put("rdf", SerializationConstants.RDF_NS); commonTurtlePrefixes.put("rdfs", SerializationConstants.RDFS_NS); @@ -500,9 +500,9 @@ public static FormatConfig turtleConfig() { * Returns a default configuration suitable for TriG serialization. * TriG extends Turtle with named graphs, supporting all Turtle features plus context inclusion. * - * @return A {@code FormatConfig} instance for TriG. + * @return A {@code SerializerConfig} instance for TriG. */ - public static FormatConfig trigConfig() { + public static SerializerConfig trigConfig() { Map commonTriGPrefixes = new HashMap<>(); commonTriGPrefixes.put("rdf", SerializationConstants.RDF_NS); commonTriGPrefixes.put("rdfs", SerializationConstants.RDFS_NS); @@ -541,9 +541,9 @@ public static FormatConfig trigConfig() { * Returns a default configuration suitable for RDF/XML serialization. * RDF/XML is an XML-based syntax for RDF graphs. * - * @return A {@code FormatConfig} instance for RDF/XML. + * @return A {@code SerializerConfig} instance for RDF/XML. */ - public static FormatConfig rdfXmlConfig() { + public static SerializerConfig rdfXmlConfig() { Map commonRdfXmlPrefixes = new HashMap<>(); commonRdfXmlPrefixes.put("rdf", SerializationConstants.RDF_NS); commonRdfXmlPrefixes.put("rdfs", SerializationConstants.RDFS_NS); diff --git a/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java b/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java index 86d53bdb6..ee622a195 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java +++ b/src/main/java/fr/inria/corese/core/next/impl/exception/SerializationException.java @@ -1,19 +1,39 @@ package fr.inria.corese.core.next.impl.exception; /** - * Exception levée lors d'échecs de sérialisation/désérialisation RDF. - * Peut contenir des détails spécifiques au format (NTriples, JSON-LD, XML , etc.). + * Exception thrown during RDF serialization or deserialization failures. + * This exception can carry format-specific details (e.g., NTriples, JSON-LD, XML, etc.), + * as well as information about the location of the error within the data stream. */ public class SerializationException extends Exception { private final String formatName; private final int lineNumber; private final int columnNumber; + /** + * Constructs a new {@code SerializationException} with the specified detail message, + * format name, and cause. Line and column numbers are set to -1 (unknown). + * + * @param message the detail message (which is saved for later retrieval by the {@link #getMessage()} method). + * @param formatName the name of the RDF format being processed when the error occurred. + * Use "unknown" if the format is not applicable or cannot be determined. + * @param cause the cause (which is saved for later retrieval by the {@link #getCause()} method). + * (A {@code null} value is permitted, and indicates that the cause is nonexistent or unknown.) + */ public SerializationException(String message, String formatName, Throwable cause) { this(message, formatName, -1, -1, cause); } - + /** + * Constructs a new {@code SerializationException} with the specified detail message, + * format name, line number, column number, and cause. + * + * @param message the detail message. + * @param formatName the name of the RDF format being processed. + * @param lineNumber the line number where the error occurred, or -1 if unknown. + * @param columnNumber the column number where the error occurred, or -1 if unknown. + * @param cause the cause of the exception. + */ public SerializationException(String message, String formatName, int lineNumber, int columnNumber, Throwable cause) { super(buildMessage(message, formatName, lineNumber, columnNumber), cause); this.formatName = formatName; @@ -21,6 +41,16 @@ public SerializationException(String message, String formatName, int lineNumber, this.columnNumber = columnNumber; } + /** + * Builds the complete exception message by incorporating the base message, + * format name, and line/column numbers if available. + * + * @param base the base detail message. + * @param format the name of the RDF format. + * @param line the line number. + * @param col the column number. + * @return the formatted exception message string. + */ private static String buildMessage(String base, String format, int line, int col) { StringBuilder sb = new StringBuilder(base); if (!"unknown".equals(format)) { @@ -35,15 +65,29 @@ private static String buildMessage(String base, String format, int line, int col return sb.toString(); } - + /** + * Returns the name of the RDF format that was being processed when the error occurred. + * + * @return the format name, or "unknown" if not specified. + */ public String getFormatName() { return formatName; } + /** + * Returns the line number where the error occurred. + * + * @return the line number, or -1 if unknown. + */ public int getLineNumber() { return lineNumber; } + /** + * Returns the column number where the error occurred. + * + * @return the column number, or -1 if unknown. + */ public int getColumnNumber() { return columnNumber; } diff --git a/src/main/java/fr/inria/corese/core/sparql/datatype/function/StringHelper.java b/src/main/java/fr/inria/corese/core/sparql/datatype/function/StringHelper.java index ad8d95821..87581a0bc 100644 --- a/src/main/java/fr/inria/corese/core/sparql/datatype/function/StringHelper.java +++ b/src/main/java/fr/inria/corese/core/sparql/datatype/function/StringHelper.java @@ -358,7 +358,7 @@ public static int indexOfWordIgnoreCaseAccentAndPlurial(String string1, String s * qualifier, scientific notation and numbers marked with a type * qualifier (e.g. 123L). * - * @see org.apache.commons.lang.math.NumberUtils + * @see org.apache.commons.lang3.math.NumberUtils * @param str the string to check * @return true if the string denotes a correctly formatted number, false otherwise. */ diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java index 5e4085d01..3ab7e6f7e 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java @@ -1,8 +1,8 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.IRdfSerializer; +import fr.inria.corese.core.next.api.RdfSerializer; import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -15,21 +15,21 @@ class DefaultSerializerFactoryTest { private DefaultSerializerFactory factory; private Model mockModel; - private FormatConfig mockConfig; + private SerializerConfig mockConfig; @BeforeEach void setUp() { factory = new DefaultSerializerFactory(); mockModel = org.mockito.Mockito.mock(Model.class); - mockConfig = org.mockito.Mockito.mock(FormatConfig.class); + mockConfig = org.mockito.Mockito.mock(SerializerConfig.class); } @Test @DisplayName("createSerializer should return TurtleFormat for TURTLE format") void createSerializer_shouldReturnTurtleFormat_forTurtleFormat() { try (MockedConstruction mockedConstruction = mockConstruction(TurtleSerializer.class)) { - IRdfSerializer serializer = factory.createSerializer(RdfFormat.TURTLE, mockModel, mockConfig); + RdfSerializer serializer = factory.createSerializer(RdfFormat.TURTLE, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof TurtleSerializer); @@ -41,7 +41,7 @@ void createSerializer_shouldReturnTurtleFormat_forTurtleFormat() { @DisplayName("createSerializer should return NTriplesFormat for NTRIPLES format") void createSerializer_shouldReturnNTriplesFormat_forNTriplesFormat() { try (MockedConstruction mockedConstruction = mockConstruction(NTriplesSerializer.class)) { - IRdfSerializer serializer = factory.createSerializer(RdfFormat.NTRIPLES, mockModel, mockConfig); + RdfSerializer serializer = factory.createSerializer(RdfFormat.NTRIPLES, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof NTriplesSerializer); @@ -53,7 +53,7 @@ void createSerializer_shouldReturnNTriplesFormat_forNTriplesFormat() { @DisplayName("createSerializer should return NQuadsFormat for NQUADS format") void createSerializer_shouldReturnNQuadsFormat_forNQuadsFormat() { try (MockedConstruction mockedConstruction = mockConstruction(NQuadsSerializer.class)) { - IRdfSerializer serializer = factory.createSerializer(RdfFormat.NQUADS, mockModel, mockConfig); + RdfSerializer serializer = factory.createSerializer(RdfFormat.NQUADS, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof NQuadsSerializer); @@ -65,7 +65,7 @@ void createSerializer_shouldReturnNQuadsFormat_forNQuadsFormat() { @DisplayName("createSerializer should return TriGFormat for TRIG format") void createSerializer_shouldReturnTriGFormat_forTriGFormat() { try (MockedConstruction mockedConstruction = mockConstruction(TriGSerializer.class)) { - IRdfSerializer serializer = factory.createSerializer(RdfFormat.TRIG, mockModel, mockConfig); + RdfSerializer serializer = factory.createSerializer(RdfFormat.TRIG, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof TriGSerializer); @@ -77,7 +77,7 @@ void createSerializer_shouldReturnTriGFormat_forTriGFormat() { @DisplayName("createSerializer should return XmlSerializer for RDFXML format") void createSerializer_shouldReturnXmlSerializer_forRdfXmlFormat() { try (MockedConstruction mockedConstruction = mockConstruction(XmlSerializer.class)) { - IRdfSerializer serializer = factory.createSerializer(RdfFormat.RDFXML, mockModel, mockConfig); + RdfSerializer serializer = factory.createSerializer(RdfFormat.RDFXML, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof XmlSerializer); @@ -107,7 +107,7 @@ void createSerializer_shouldThrowNPE_forNullModel() { void createSerializer_shouldThrowNPE_forNullConfig() { assertThrows(NullPointerException.class, () -> factory.createSerializer(RdfFormat.TURTLE, mockModel, null), - "Should throw NullPointerException for null FormatConfig"); + "Should throw NullPointerException for null SerializerConfig"); } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java index 4c31a9143..99426fdfb 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; @@ -23,7 +23,7 @@ class NQuadsSerializerTest { private Model model; - private FormatConfig config; + private SerializerConfig config; private NQuadsSerializer nQuadsSerializer; private Resource mockExPerson; @@ -43,7 +43,7 @@ class NQuadsSerializerTest { @BeforeEach void setUp() { model = mock(Model.class); - config = FormatConfig.nquadsConfig(); + config = SerializerConfig.nquadsConfig(); nQuadsSerializer = new NQuadsSerializer(model, config); mockExPerson = createIRI("http://example.org/Person"); @@ -274,7 +274,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { Writer writer = new StringWriter(); - NQuadsSerializer serializer = new NQuadsSerializer(currentTestModel, FormatConfig.nquadsConfig()); + NQuadsSerializer serializer = new NQuadsSerializer(currentTestModel, SerializerConfig.nquadsConfig()); serializer.write(writer); String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java index de18a756d..ef57064f6 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; @@ -21,7 +21,7 @@ class NTriplesSerializerTest { private Model model; - private FormatConfig config; + private SerializerConfig config; private NTriplesSerializer nTriplesSerializer; private Resource mockExPerson; @@ -38,7 +38,7 @@ class NTriplesSerializerTest { void setUp() { model = mock(Model.class); - config = FormatConfig.ntriplesConfig(); + config = SerializerConfig.ntriplesConfig(); nTriplesSerializer = new NTriplesSerializer(model, config); @@ -210,7 +210,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { Model modelMock = mock(Model.class); when(modelMock.iterator()).thenReturn(new MockStatementIterator(stmt)); - FormatConfig testConfig = new FormatConfig.Builder() + SerializerConfig testConfig = new SerializerConfig.Builder() .strictMode(true) // Keep strict mode enabled to test validation .build(); @@ -240,7 +240,7 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { Model currentTestModel = mock(Model.class); when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); - NTriplesSerializer serializer = new NTriplesSerializer(currentTestModel, FormatConfig.ntriplesConfig()); + NTriplesSerializer serializer = new NTriplesSerializer(currentTestModel, SerializerConfig.ntriplesConfig()); StringWriter writer = new StringWriter(); serializer.write(writer); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerConfigTest.java similarity index 90% rename from src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java rename to src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerConfigTest.java index 054e9dd7a..65d915f9e 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/FormatConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerConfigTest.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; @@ -12,11 +12,11 @@ import static org.junit.jupiter.api.Assertions.*; -class FormatConfigTest { +class SerializerConfigTest { @Test @DisplayName("ntriplesConfig() should return correct default config for N-Triples") void ntriplesConfigReturnsCorrectConfig() { - FormatConfig config = FormatConfig.ntriplesConfig(); + SerializerConfig config = SerializerConfig.ntriplesConfig(); assertFalse(config.usePrefixes()); assertFalse(config.autoDeclarePrefixes()); @@ -45,7 +45,7 @@ void ntriplesConfigReturnsCorrectConfig() { @Test @DisplayName("nquadsConfig() should return correct default config for N-Quads") void nquadsConfigReturnsCorrectConfig() { - FormatConfig config = FormatConfig.nquadsConfig(); + SerializerConfig config = SerializerConfig.nquadsConfig(); assertFalse(config.usePrefixes()); assertFalse(config.autoDeclarePrefixes()); @@ -74,7 +74,7 @@ void nquadsConfigReturnsCorrectConfig() { @Test @DisplayName("rdfXmlConfig() devrait retourner la configuration par défaut correcte pour RDF/XML") void rdfXmlConfigReturnsCorrectConfig() { - FormatConfig config = FormatConfig.rdfXmlConfig(); + SerializerConfig config = SerializerConfig.rdfXmlConfig(); assertTrue(config.usePrefixes()); assertTrue(config.autoDeclarePrefixes()); @@ -109,17 +109,17 @@ void rdfXmlConfigReturnsCorrectConfig() { @Test - @DisplayName("FormatConfig constructor should be private and only accessible via builder") + @DisplayName("SerializerConfig constructor should be private and only accessible via builder") void constructorIsPrivateAndAccessibleViaBuilder() { - FormatConfig config = new FormatConfig.Builder().build(); + SerializerConfig config = new SerializerConfig.Builder().build(); assertNotNull(config); } @Test @DisplayName("blankNodeStyle method in Builder should throw NullPointerException for null style") void blankNodeStyleShouldThrowForNull() { - FormatConfig.Builder builder = new FormatConfig.Builder(); + SerializerConfig.Builder builder = new SerializerConfig.Builder(); assertThrows(NullPointerException.class, () -> builder.blankNodeStyle(null), "Setting a null blankNodeStyle should throw NullPointerException"); } @@ -127,7 +127,7 @@ void blankNodeStyleShouldThrowForNull() { @Test @DisplayName("indent method in Builder should throw NullPointerException for null indent") void indentShouldThrowForNull() { - FormatConfig.Builder builder = new FormatConfig.Builder(); + SerializerConfig.Builder builder = new SerializerConfig.Builder(); assertThrows(NullPointerException.class, () -> builder.indent(null), "Setting a null indent should throw NullPointerException"); } @@ -135,7 +135,7 @@ void indentShouldThrowForNull() { @Test @DisplayName("lineEnding method in Builder should throw NullPointerException for null lineEnding") void lineEndingShouldThrowForNull() { - FormatConfig.Builder builder = new FormatConfig.Builder(); + SerializerConfig.Builder builder = new SerializerConfig.Builder(); assertThrows(NullPointerException.class, () -> builder.lineEnding(null), "Setting a null lineEnding should throw NullPointerException"); } @@ -143,17 +143,17 @@ void lineEndingShouldThrowForNull() { @Test @DisplayName("prefixOrdering method in Builder should throw NullPointerException for null prefixOrdering") void prefixOrderingShouldThrowForNull() { - FormatConfig.Builder builder = new FormatConfig.Builder(); + SerializerConfig.Builder builder = new SerializerConfig.Builder(); assertThrows(NullPointerException.class, () -> builder.prefixOrdering(null), "Setting a null prefixOrdering should throw NullPointerException"); } @Test - @DisplayName("Builder should create FormatConfig with all default values") + @DisplayName("Builder should create SerializerConfig with all default values") void builderShouldCreateWithAllDefaults() { - FormatConfig config = new FormatConfig.Builder().build(); + SerializerConfig config = new SerializerConfig.Builder().build(); - assertNotNull(config, "FormatConfig should not be null"); + assertNotNull(config, "SerializerConfig should not be null"); // --- Syntax Sugar Defaults --- assertTrue(config.usePrefixes(), "Default usePrefixes should be true"); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java index 39217d346..8d4c404fe 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java @@ -2,7 +2,7 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; @@ -75,7 +75,7 @@ void testBasicTriGSerialization() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TriGSerializer triGSerializer = new TriGSerializer(mockModel, FormatConfig.trigConfig()); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, SerializerConfig.trigConfig()); triGSerializer.write(writer); @@ -230,14 +230,14 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - // Explicitly create FormatConfig to ensure strictMode is false + // Explicitly create SerializerConfig to ensure strictMode is false Map commonTriGPrefixes = new HashMap<>(); commonTriGPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); commonTriGPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); commonTriGPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); commonTriGPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); - FormatConfig config = new FormatConfig.Builder() + SerializerConfig config = new SerializerConfig.Builder() .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) .useRdfTypeShortcut(true) .useCollections(true) @@ -335,7 +335,7 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc commonTrigPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); commonTrigPrefixes.put("dc", "http://purl.org/dc/elements/1.1/"); - FormatConfig config = new FormatConfig.Builder() + SerializerConfig config = new SerializerConfig.Builder() .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) .addCustomPrefixes(commonTrigPrefixes) .usePrefixes(true) @@ -420,7 +420,7 @@ void testBaseIRI() throws SerializationException, IOException { commonTrigPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); commonTrigPrefixes.put("base", "http://example.org/base/"); - FormatConfig configWithBase = new FormatConfig.Builder() + SerializerConfig configWithBase = new SerializerConfig.Builder() .baseIRI("http://example.org/base/") .addCustomPrefixes(commonTrigPrefixes) .usePrefixes(true) @@ -535,7 +535,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { StringWriter writer = new StringWriter(); - FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).build(); + SerializerConfig strictConfig = new SerializerConfig.Builder().strictMode(true).build(); TriGSerializer triGSerializer = new TriGSerializer(mockModel, strictConfig); @@ -596,7 +596,7 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { StringWriter writer = new StringWriter(); - FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).validateURIs(true).build(); + SerializerConfig strictConfig = new SerializerConfig.Builder().strictMode(true).validateURIs(true).build(); TriGSerializer triGSerializer = new TriGSerializer(mockModel, strictConfig); @@ -659,7 +659,7 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - FormatConfig config = new FormatConfig.Builder() + SerializerConfig config = new SerializerConfig.Builder() .useMultilineLiterals(true) .prettyPrint(true) .autoDeclarePrefixes(true) @@ -751,7 +751,7 @@ void testBasicTrigSerializationWithNamedGraph() throws SerializationException, I StringWriter writer = new StringWriter(); - TriGSerializer triGSerializer = new TriGSerializer(mockModel, FormatConfig.trigConfig()); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, SerializerConfig.trigConfig()); triGSerializer.write(writer); diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java index df4cdc2a6..d5b9f146c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java @@ -2,7 +2,7 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; @@ -75,7 +75,7 @@ void testBasicTurtleSerialization() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, FormatConfig.turtleConfig()); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, SerializerConfig.turtleConfig()); // When turtleSerializer.write(writer); @@ -229,14 +229,14 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - // Explicitly create FormatConfig to ensure strictMode is false + // Explicitly create SerializerConfig to ensure strictMode is false Map commonTurtlePrefixes = new HashMap<>(); commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); - FormatConfig config = new FormatConfig.Builder() + SerializerConfig config = new SerializerConfig.Builder() .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) .useRdfTypeShortcut(true) .useCollections(true) @@ -334,7 +334,7 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); commonTurtlePrefixes.put("dc", "http://purl.org/dc/elements/1.1/"); - FormatConfig config = new FormatConfig.Builder() + SerializerConfig config = new SerializerConfig.Builder() .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) .addCustomPrefixes(commonTurtlePrefixes) .usePrefixes(true) @@ -440,7 +440,7 @@ void testBlankNodeSerialization() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, FormatConfig.turtleConfig()); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, SerializerConfig.turtleConfig()); turtleSerializer.write(writer); @@ -520,7 +520,7 @@ void testBaseIRI() throws SerializationException, IOException { commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); commonTurtlePrefixes.put("base", "http://example.org/base/"); - FormatConfig configWithBase = new FormatConfig.Builder() + SerializerConfig configWithBase = new SerializerConfig.Builder() .baseIRI("http://example.org/base/") .addCustomPrefixes(commonTurtlePrefixes) .usePrefixes(true) @@ -635,7 +635,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { StringWriter writer = new StringWriter(); - FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).build(); + SerializerConfig strictConfig = new SerializerConfig.Builder().strictMode(true).build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, strictConfig); @@ -696,7 +696,7 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { StringWriter writer = new StringWriter(); - FormatConfig strictConfig = new FormatConfig.Builder().strictMode(true).validateURIs(true).build(); + SerializerConfig strictConfig = new SerializerConfig.Builder().strictMode(true).validateURIs(true).build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, strictConfig); @@ -758,8 +758,8 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - // Configure FormatConfig to enable multiline literals - FormatConfig config = new FormatConfig.Builder() + // Configure SerializerConfig to enable multiline literals + SerializerConfig config = new SerializerConfig.Builder() .useMultilineLiterals(true) .prettyPrint(true) .autoDeclarePrefixes(true) diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java index 364794f22..a64d47cfc 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.serialization.config.FormatConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; @@ -30,7 +30,7 @@ class XmlSerializerTest { @Mock private Model mockModel; @Mock - private FormatConfig mockConfig; + private SerializerConfig mockConfig; @Mock private Resource mockResource; @Mock From ba063ca24162705ed4c7bc19bcc296315aba73e6 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Tue, 1 Jul 2025 11:08:17 +0200 Subject: [PATCH 20/27] ajouter une classe commun trig et turtles --- .../common/serialization/TriGSerializer.java | 888 +---------------- .../serialization/TurtleSerializer.java | 890 +---------------- .../base/AbstractGraphSerializer.java | 899 ++++++++++++++++++ .../serialization/TriGSerializerTest.java | 4 +- .../serialization/TurtleSerializerTest.java | 15 +- 5 files changed, 980 insertions(+), 1716 deletions(-) create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractGraphSerializer.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java index 1d84b5206..59cb8b796 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java @@ -1,24 +1,13 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; +import fr.inria.corese.core.next.impl.common.serialization.base.AbstractGraphSerializer; import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; -import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; -import fr.inria.corese.core.next.impl.exception.SerializationException; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import java.io.BufferedWriter; import java.io.IOException; -import java.io.UncheckedIOException; import java.io.Writer; -import java.net.URI; -import java.net.URISyntaxException; import java.util.*; -import java.util.stream.Collectors; /** * Serializes a {@link Model} to TriG format with comprehensive syntax support. @@ -29,7 +18,7 @@ *
    *
  • Declaration and usage of prefixes for IRIs, including auto-declaration and sorting.
    • *
  • The 'a' shortcut for 'rdf:type'.
    • - *
  • Escaping of special characters in literals (single-line and multi-line) and IRIs.
    • + *
  • Escaping of special characters in literals (single-line and multi-lines) and IRIs.
    • *
  • Basic pretty-printing (indentation, end-of-line dots).
    • *
  • Management of literal datatype policies (minimal or always typed).
    • *
  • Serialization of compact triples (semicolons, commas) to group subjects and predicates.
    • @@ -42,21 +31,7 @@ *

    Advanced features such as strict adherence to maximum line length * and generation of stable blank node identifiers are not fully implemented in this version.

    */ -public class TriGSerializer implements RdfSerializer { - - /** - * Logger for this class, used to log potential issues or information during serialization. - */ - private static final Logger logger = LoggerFactory.getLogger(TriGSerializer.class); - - private final Model model; - private final SerializerConfig config; - private final Map iriToPrefixMapping; - private final Map prefixToIriMapping; - // Set to track blank nodes already serialized inline or as part of a list - private final Set consumedBlankNodes; - // Set to track blank nodes currently being serialized to detect cycles - private final Set currentlyWritingBlankNodes; +public class TriGSerializer extends AbstractGraphSerializer { /** * Constructs a new {@code TriGSerializer} instance with the specified model and default configuration. @@ -77,438 +52,34 @@ public TriGSerializer(Model model) { * @throws NullPointerException if the provided model or configuration is null. */ public TriGSerializer(Model model, SerializationConfig config) { - this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (SerializerConfig) Objects.requireNonNull(config, "Configuration cannot be null"); - this.iriToPrefixMapping = new HashMap<>(); - this.prefixToIriMapping = new HashMap<>(); - this.consumedBlankNodes = new HashSet<>(); - this.currentlyWritingBlankNodes = new HashSet<>(); - initializePrefixes(); + super(model, config); } /** - * Initializes prefix mappings by adding custom prefixes from the configuration. - */ - private void initializePrefixes() { - if (config.usePrefixes()) { - for (Map.Entry entry : config.getCustomPrefixes().entrySet()) { - addPrefixMapping(entry.getValue(), entry.getKey()); - } - } - } - - /** - * Writes the model to the given writer in TriG format. + * Returns the format name for error messages and logging. * - * @param writer the {@link Writer} to which the TriG output will be written. - * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + * @return "TriG" */ @Override - public void write(Writer writer) throws SerializationException { - try (Writer bufferedWriter = new BufferedWriter(writer)) { - writeHeader(bufferedWriter); - - Set precomputedInlineBlankNodes = precomputeInlineBlankNodesAndLists(); - consumedBlankNodes.addAll(precomputedInlineBlankNodes); - - if (config.includeContext()) { - writeStatementsWithContext(bufferedWriter); - } else if (config.useCompactTriples() && config.groupBySubject()) { - writeOptimizedStatements(bufferedWriter); - } else { - writeSimpleStatements(bufferedWriter); - } - - writer.flush(); - } catch (IOException e) { - throw new SerializationException("Failed to write to stream for TriG format", "TriG", e); - } catch (IllegalArgumentException e) { - throw new SerializationException("Invalid data for TriG format: " + e.getMessage(), "TriG", e); - } - } - - /** - * Writes the TriG document header, including base IRI declaration and prefixes. - * - * @param writer the {@link Writer} to which the header will be written. - * @throws IOException if an I/O error occurs. - */ - private void writeHeader(Writer writer) throws IOException { - if (config.getBaseIRI() != null) { - writer.write(String.format("@base <%s> .%s", - config.getBaseIRI(), - config.getLineEnding())); - } - - if (config.usePrefixes() && config.autoDeclarePrefixes()) { - collectUsedNamespaces(); - } - - writePrefixDeclarations(writer); - } - - /** - * Collects all namespaces used in the model and attempts to assign prefixes to them - * if auto-declaration is enabled and they are not already mapped. - */ - private void collectUsedNamespaces() { - Set namespaces = model.stream() - .flatMap(stmt -> Arrays.asList( - stmt.getSubject(), - stmt.getPredicate(), - stmt.getObject(), - stmt.getContext() - ).stream()) - .filter(Objects::nonNull) - .filter(Value::isIRI) - .map(v -> getNamespace(v.stringValue())) - .collect(Collectors.toSet()); - - namespaces.forEach(namespace -> { - if (!iriToPrefixMapping.containsKey(namespace)) { - String prefix = getSuggestedPrefix(namespace); - if (prefix != null) { - addPrefixMapping(namespace, prefix); - } - } - }); + protected String getFormatName() { + return "TriG"; } /** - * Writes prefix declarations to the writer, sorted if configured. - * - * @param writer the {@link Writer} to which prefixes will be written. - * @throws IOException if an I/O error occurs. - */ - private void writePrefixDeclarations(Writer writer) throws IOException { - List prefixes = new ArrayList<>(prefixToIriMapping.keySet()); - - if (config.getPrefixOrdering() == PrefixOrderingEnum.ALPHABETICAL) { - Collections.sort(prefixes); - } - - for (String prefix : prefixes) { - writer.write(String.format("@prefix %s: <%s> .%s", - prefix, - prefixToIriMapping.get(prefix), - config.getLineEnding())); - } - - if (!prefixes.isEmpty() || config.getBaseIRI() != null) { - writer.write(config.getLineEnding()); - } - } - - /** - * Serializes the model's statements in a simple manner, one per line, without grouping. - * Triples already "consumed" by inline serialization are ignored. - * This method is used when `includeContext` is false and `useCompactTriples` is false. + * Implements the main statement writing logic for the TriG format. + * Handles the serialization of named graphs. * * @param writer the {@link Writer} to which the statements will be written. * @throws IOException if an I/O error occurs. */ - private void writeSimpleStatements(Writer writer) throws IOException { - for (Statement stmt : model) { - if (!isConsumed(stmt.getSubject())) { - writeStatement(writer, stmt); - writer.write(config.getLineEnding()); - } - } - } - - /** - * Writes a single {@link Statement} to the writer in TriG format. - * If the statement has a context and `includeContext` is enabled, this method will be - * called within a named graph block, so it will only write the triple parts. - * - * @param writer the {@link Writer} to which the statement will be written. - * @param stmt the {@link Statement} to write. - * @throws IOException if an I/O error occurs. - */ - private void writeStatement(Writer writer, Statement stmt) throws IOException { - String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; - writer.write(indent); - - // Subject - writeValue(writer, stmt.getSubject()); - writer.write(SerializationConstants.SPACE); - - // Predicate - writePredicate(writer, stmt.getPredicate()); - writer.write(SerializationConstants.SPACE); - - // Object - writeValue(writer, stmt.getObject()); - - - writer.write(SerializationConstants.SPACE); - writer.write(SerializationConstants.POINT); - - } - - /** - * Writes the predicate to the writer, using the 'a' shortcut if configured and applicable. - * - * @param writer the {@link Writer} to which the predicate will be written. - * @param predicate the {@link Value} representing the predicate. - * @throws IOException if an I/O error occurs. - */ - private void writePredicate(Writer writer, Value predicate) throws IOException { - if (config.useRdfTypeShortcut() && predicate.stringValue().equals(SerializationConstants.RDF_TYPE)) { - writer.write(SerializationConstants.RDF_TYPE_SHORTCUT); - } else { - writeValue(writer, predicate); - } - } - - /** - * Writes a single {@link Value} to the writer. - * Handles literals, blank nodes, and IRIs. - * This is the entry point for serializing nested blank nodes and lists. - * - * @param writer the {@link Writer} to which the value will be written. - * @param value the {@link Value} to write. - * @throws IOException if an I/O error occurs. - * @throws IllegalArgumentException if the provided value is null or of an unsupported type. - */ - private void writeValue(Writer writer, Value value) throws IOException { - validateValue(value); - - if (value.isIRI()) { - writeIRI(writer, (IRI) value); - } else if (value.isLiteral()) { - writeLiteral(writer, (Literal) value); - } else if (value.isBNode()) { - Resource bNode = (Resource) value; - - if (currentlyWritingBlankNodes.contains(bNode)) { - writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); - return; - } - - currentlyWritingBlankNodes.add(bNode); - - boolean handled = false; - if (config.useCollections() && bNode.isBNode()) { - handled = writeRDFList(writer, bNode); - } - - if (!handled && config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS && bNode.isBNode()) { - List properties = model.stream() - .filter(stmt -> stmt.getSubject().equals(bNode)) - .toList(); - - if (!properties.isEmpty()) { - writeInlineBlankNode(writer, properties); - handled = true; - } - } - - if (!handled) { - writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); - } - - currentlyWritingBlankNodes.remove(bNode); - } else { - throw new IllegalArgumentException("Unsupported value type for TriG serialization: " + value.getClass().getName()); - } - } - - - /** - * Writes an {@link IRI} to the writer. - * Attempts to use a prefixed name if possible, otherwise writes the full IRI in angle brackets. - * - * @param writer the {@link Writer} to which the IRI will be written. - * @param iri the {@link IRI} to write. - * @throws IOException if an I/O error occurs. - */ - private void writeIRI(Writer writer, IRI iri) throws IOException { - if (config.isStrictMode() && config.validateURIs()) { - validateIRI(iri); - } - - String prefixed = config.usePrefixes() ? getPrefixedName(iri.stringValue()) : null; - - if (prefixed != null) { - writer.write(prefixed); - } else { - writer.write(String.format("<%s>", escapeTriGIRI(iri.stringValue()))); - } - } - - /** - * Writes a {@link Literal} to the writer in TriG format. - * Applies escaping and datatype/language tag rules based on configuration. - * - * @param writer the {@link Writer} to which the literal will be written. - * @param literal the {@link Literal} to write. - * @throws IOException if an I/O error occurs. - */ - private void writeLiteral(Writer writer, Literal literal) throws IOException { - String value = literal.stringValue(); - - if (config.shouldUseTripleQuotes(value)) { - writer.write(String.format("\"\"\"%s\"\"\"", escapeMultilineLiteral(value))); + @Override + protected void doWriteStatements(Writer writer) throws IOException { + if (config.includeContext()) { + writeStatementsWithContext(writer); + } else if (config.useCompactTriples() && config.groupBySubject()) { + writeOptimizedStatements(writer); } else { - writer.write(String.format("\"%s\"", escapeTriGLiteral(value))); - } - - literal.getLanguage().ifPresent(lang -> { - try { - writer.write(SerializationConstants.AT_SIGN + lang); - } catch (IOException e) { - throw new UncheckedIOException("Error writing language tag to stream", e); - } - }); - - writeDatatype(writer, literal); - } - - /** - * Writes the datatype of a literal if the configured datatype policy allows it. - * - * @param writer the {@link Writer} to which the datatype will be written. - * @param literal the {@link Literal} whose datatype is to be written. - * @throws IOException if an I/O error occurs. - */ - private void writeDatatype(Writer writer, Literal literal) throws IOException { - IRI datatype = literal.getDatatype(); - if (shouldWriteDatatype(literal)) { - writer.write(SerializationConstants.DATATYPE_SEPARATOR); - writeIRI(writer, datatype); - } - } - - /** - * Determines if a literal's datatype should be written based on the configuration. - * - * @param literal the {@link Literal} to check. - * @return {@code true} if the datatype should be written, {@code false} otherwise. - */ - private boolean shouldWriteDatatype(Literal literal) { - if (literal.getLanguage().isPresent()) { - return false; - } - - IRI datatype = literal.getDatatype(); - if (datatype == null) { - return false; - } - - return config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || - (!datatype.stringValue().equals(SerializationConstants.XSD_STRING) && - config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL); - } - - /** - * Writes an inline blank node using the `[]` syntax. - * The blank node's properties are serialized inside the brackets. - * - * @param writer the {@link Writer} to which the blank node will be written. - * @param properties the list of statements where the blank node is the subject. - * @throws IOException if an I/O error occurs. - */ - private void writeInlineBlankNode(Writer writer, List properties) throws IOException { - String currentIndent = config.prettyPrint() ? config.getIndent() : ""; - String propIndent = config.prettyPrint() ? currentIndent + config.getIndent() : ""; - - writer.write(SerializationConstants.BLANK_NODE_START); - - boolean firstProperty = true; - for (Statement stmt : properties) { - if (stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || - stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) { - continue; - } - - if (!firstProperty) { - writer.write(SerializationConstants.SEMICOLON); - } - firstProperty = false; - - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + propIndent); - } else { - writer.write(SerializationConstants.SPACE); - } - - writePredicate(writer, stmt.getPredicate()); - writer.write(SerializationConstants.SPACE); - writeValue(writer, stmt.getObject()); - } - - if (config.prettyPrint() && !properties.isEmpty() && !firstProperty) { - writer.write(config.getLineEnding() + currentIndent); - } - - writer.write(SerializationConstants.BLANK_NODE_END); - } - - /** - * Serializes the model's statements by grouping triples by subject, then by predicate, - * using compact syntax (semicolons and commas) if configured. - * Triples already "consumed" by inline serialization are ignored. - * This method is used when `includeContext` is false and `useCompactTriples` is true. - * - * @param writer the {@link Writer} to which the optimized statements will be written. - * @throws IOException if an I/O error occurs. - */ - private void writeOptimizedStatements(Writer writer) throws IOException { - Map> bySubject = config.sortSubjects() ? - new TreeMap<>(Comparator.comparing(Resource::stringValue)) : - new LinkedHashMap<>(); - - - model.stream() - .filter(stmt -> !isConsumed(stmt.getSubject())) - .forEach(stmt -> bySubject.computeIfAbsent(stmt.getSubject(), k -> new ArrayList<>()).add(stmt)); - - for (Map.Entry> subjectEntry : bySubject.entrySet()) { - String indent = config.prettyPrint() ? config.getIndent() : ""; - writer.write(indent); - writeValue(writer, subjectEntry.getKey()); - writer.write(SerializationConstants.SPACE); - - Map> byPredicate = config.sortPredicates() ? - new TreeMap<>(Comparator.comparing(IRI::stringValue)) : - new LinkedHashMap<>(); - - subjectEntry.getValue().forEach(stmt -> byPredicate.computeIfAbsent(stmt.getPredicate(), k -> new ArrayList<>()).add(stmt)); - - boolean firstPredicate = true; - for (Map.Entry> predicateEntry : byPredicate.entrySet()) { - if (!firstPredicate) { - writer.write(SerializationConstants.SEMICOLON); - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + indent + config.getIndent()); - } else { - writer.write(SerializationConstants.SPACE); - } - } - firstPredicate = false; - - writePredicate(writer, predicateEntry.getKey()); - writer.write(SerializationConstants.SPACE); - - boolean firstObject = true; - for (Statement stmt : predicateEntry.getValue()) { - if (!firstObject) { - writer.write(SerializationConstants.COMMA); - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + indent + config.getIndent() + config.getIndent()); - } else { - writer.write(SerializationConstants.SPACE); - } - } - firstObject = false; - - writeValue(writer, stmt.getObject()); - } - } - - writer.write(SerializationConstants.SPACE + SerializationConstants.POINT); - writer.write(config.getLineEnding()); + writeSimpleStatements(writer); } } @@ -545,7 +116,6 @@ private void writeStatementsWithContext(Writer writer) throws IOException { initialIndent = graphIndent; } - Map> bySubject = config.sortSubjects() ? new TreeMap<>(Comparator.comparing(Resource::stringValue)) : new LinkedHashMap<>(); @@ -606,332 +176,27 @@ private void writeStatementsWithContext(Writer writer) throws IOException { } } - /** - * Attempts to serialize an RDF list if the given blank node is its head. - * Marks all blank nodes in the list as consumed. + * Escapes characters in an IRI string for TriG output. + * This method primarily focuses on control characters and problematic characters within angle brackets. * - * @param writer the {@link Writer} to which the list will be written. - * @param listHead the blank node that might be the head of an RDF list. - * @return {@code true} if an RDF list was serialized, {@code false} otherwise. - * @throws IOException if an I/O error occurs. + * @param iri The IRI to escape. + * @return The escaped IRI. */ - private boolean writeRDFList(Writer writer, Resource listHead) throws IOException { - List items = new ArrayList<>(); - Resource current = listHead; - Set listBlankNodes = new HashSet<>(); - - if (currentlyWritingBlankNodes.contains(listHead)) { - return false; - } - currentlyWritingBlankNodes.add(listHead); - - while (current != null && current.isBNode() && !currentlyWritingBlankNodes.contains(current)) { - listBlankNodes.add(current); - currentlyWritingBlankNodes.add(current); - - final Resource finalCurrentForLambda = current; - List statements = model.stream() - .filter(stmt -> stmt.getSubject().equals(finalCurrentForLambda)) - .toList(); - - if (statements.size() != 2) { - current = null; - break; - } - - Optional first = statements.stream() - .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) - .map(Statement::getObject) - .findFirst(); - - Optional rest = statements.stream() - .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) - .map(Statement::getObject) - .findFirst(); - - if (!first.isPresent() || !rest.isPresent()) { - current = null; - break; - } - - items.add(first.get()); - - if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { - current = null; - } else if (rest.get().isBNode()) { - current = (Resource) rest.get(); + @Override + protected String escapeIRIString(String iri) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < iri.length(); i++) { + char c = iri.charAt(i); + if (c < 0x20 || c == 0x7F || c == SerializationConstants.LT.charAt(0) || c == SerializationConstants.GT.charAt(0) || c == SerializationConstants.QUOTE.charAt(0) || c == '{' || c == '}' || c == '|' || c == '^' || c == '`' || c == SerializationConstants.BACK_SLASH.charAt(0)) { + sb.append(String.format("\\u%04X", (int) c)); } else { - current = null; - break; - } - } - currentlyWritingBlankNodes.remove(listHead); - - if (items.isEmpty() || current != null) { - listBlankNodes.forEach(currentlyWritingBlankNodes::remove); - return false; - } - - consumedBlankNodes.addAll(listBlankNodes); - - writer.write(SerializationConstants.OPEN_PARENTHESIS); - boolean firstItem = true; - for (Value item : items) { - if (!firstItem) writer.write(SerializationConstants.SPACE); - firstItem = false; - writeValue(writer, item); - } - writer.write(SerializationConstants.CLOSE_PARENTHESIS); - return true; - } - - /** - * Determines if a value (subject, predicate, object) is a blank node that has already been - * serialized inline (within a '[]' or '()') and should be ignored during top-level serialization. - * - * @param value the {@link Value} to check. - * @return {@code true} if the value is a consumed blank node, {@code false} otherwise. - */ - private boolean isConsumed(Value value) { - return value.isBNode() && consumedBlankNodes.contains(value); - } - - /** - * Identifies and returns a set of blank nodes that can be serialized inline (either as `[]` or as `()` for lists). - * These nodes will then be "consumed" to prevent their serialization as top-level triples. - * - * @return A {@link Set} of {@link Resource} representing the blank nodes that will be serialized inline. - */ - private Set precomputeInlineBlankNodesAndLists() { - Set precomputed = new HashSet<>(); - for (Statement stmt : model) { - if (stmt.getSubject().isBNode()) { - Resource bNodeSubject = stmt.getSubject(); - if (config.useCollections() && isRDFListHead(bNodeSubject)) { - Resource current = bNodeSubject; - Set listNodes = new HashSet<>(); - Set visitedInPrecomp = new HashSet<>(); - boolean isList = true; - while (current != null && current.isBNode() && !visitedInPrecomp.contains(current)) { - visitedInPrecomp.add(current); - listNodes.add(current); - final Resource finalCurrentForLambda = current; - List listProps = model.stream() - .filter(s -> s.getSubject().equals(finalCurrentForLambda)) - .toList(); - - if (listProps.size() != 2) { - isList = false; - break; - } - - Optional first = listProps.stream() - .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) - .map(Statement::getObject) - .findFirst(); - - Optional rest = listProps.stream() - .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) - .map(Statement::getObject) - .findFirst(); - - if (!first.isPresent() || !rest.isPresent()) { - isList = false; - break; - } - - if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { - current = null; - } else if (rest.get().isBNode()) { - current = (Resource) rest.get(); - } else { - isList = false; - break; - } - } - if (isList && current == null) { - precomputed.addAll(listNodes); - } - } - if (config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS) { - List properties = model.stream() - .filter(s -> s.getSubject().equals(bNodeSubject)) - .toList(); - - boolean isPartOfList = properties.stream().anyMatch(s -> - s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || - s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST) - ); - - if (!properties.isEmpty() && !isPartOfList) { - precomputed.add(bNodeSubject); - } - } - } - } - return precomputed; - } - - /** - * Checks if a given blank node is the head of an RDF list. - * - * @param bNode the blank node to check. - * @return true if it's the head of an RDF list, false otherwise. - */ - private boolean isRDFListHead(Resource bNode) { - boolean hasFirstAndRest = model.stream() - .filter(stmt -> stmt.getSubject().equals(bNode)) - .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) - && - model.stream() - .filter(stmt -> stmt.getSubject().equals(bNode)) - .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)); - - boolean isObjectOfRest = model.stream() - .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) - .anyMatch(stmt -> stmt.getObject().equals(bNode)); - - return hasFirstAndRest && !isObjectOfRest; - } - - - // --- Helpers for prefix resolution --- - - /** - * Adds a prefix-namespace URI mapping to the internal mappings. - * Handles potential conflicts to ensure uniqueness. - * - * @param namespaceURI The namespace URI. - * @param prefix The associated prefix. - */ - private void addPrefixMapping(String namespaceURI, String prefix) { - if (iriToPrefixMapping.containsKey(namespaceURI)) { - if (logger.isWarnEnabled() && !iriToPrefixMapping.get(namespaceURI).equals(prefix)) { - logger.warn("Namespace URI '{}' is already mapped to prefix '{}'. Cannot map to new prefix '{}'.", - namespaceURI, iriToPrefixMapping.get(namespaceURI), prefix); - } - return; - } - - if (prefixToIriMapping.containsKey(prefix)) { - if (logger.isWarnEnabled() && !prefixToIriMapping.get(prefix).equals(namespaceURI)) { - String originalNamespace = prefixToIriMapping.get(prefix); - logger.warn("Prefix '{}' is already mapped to namespace '{}'. Cannot map to new namespace '{}'. " + - "A new unique prefix will be generated for '{}'.", - prefix, originalNamespace, namespaceURI, namespaceURI); - } - return; - } - - iriToPrefixMapping.put(namespaceURI, prefix); - prefixToIriMapping.put(prefix, namespaceURI); - } - - /** - * Extracts the namespace URI part from an IRI string. - * This is a common heuristic for RDF IRIs. - * - * @param iriString The full IRI. - * @return The namespace URI part. - */ - private String getNamespace(String iriString) { - int hashIdx = iriString.lastIndexOf(SerializationConstants.HASH); - int slashIdx = iriString.lastIndexOf(SerializationConstants.SLASH); - - if (hashIdx > -1) { - return iriString.substring(0, hashIdx + 1); - } else if (slashIdx > -1 && slashIdx < iriString.length() - 1) { - int dotIdx = iriString.lastIndexOf(SerializationConstants.POINT); - if (dotIdx > slashIdx) { - - return iriString.substring(0, slashIdx + 1); - } - return iriString.substring(0, slashIdx + 1); - } - return iriString; - } - - - /** - * Attempts to find a prefixed name for an IRI from existing mappings. - * - * @param iriString The full IRI. - * @return The prefixed name (e.g., "ex:someResource") or null if no suitable prefix is found. - */ - private String getPrefixedName(String iriString) { - for (Map.Entry entry : iriToPrefixMapping.entrySet()) { - String namespace = entry.getKey(); - String prefix = entry.getValue(); - - if (iriString.startsWith(namespace)) { - String localName = iriString.substring(namespace.length()); - if (localName.isEmpty()) { - if (!prefix.isEmpty()) { - return prefix + SerializationConstants.COLON; - } else { - continue; - } - } - return prefix + SerializationConstants.COLON + localName; - } - } - return null; - } - - /** - * Suggests a prefix for a given namespace URI. - * Attempts to derive a meaningful prefix or generates a unique one. - * - * @param namespace The namespace URI. - * @return A suggested prefix, or null if suggestion is not possible. - */ - private String getSuggestedPrefix(String namespace) { - // Try common predefined prefixes - if (namespace.equals(SerializationConstants.RDF_NS)) return "rdf"; - if (namespace.equals(SerializationConstants.RDFS_NS)) return "rdfs"; - if (namespace.equals(SerializationConstants.XSD_NS)) return "xsd"; - if (namespace.equals(SerializationConstants.OWL_NS)) return "owl"; - if (namespace.equals(SerializationConstants.FOAF_NS)) return "foaf"; - - - String base = namespace; - if (base.endsWith(SerializationConstants.HASH) || base.endsWith(SerializationConstants.SLASH)) { - base = base.substring(0, base.length() - 1); - } - int lastSlash = base.lastIndexOf(SerializationConstants.SLASH); - int lastHash = base.lastIndexOf(SerializationConstants.HASH); - int lastSegmentStart = Math.max(lastSlash, lastHash); - if (lastSegmentStart != -1) { - base = base.substring(lastSegmentStart + 1); - } - - if (base.isEmpty()) { - try { - URI uri = new URI(namespace); - base = uri.getHost().replace(SerializationConstants.POINT, SerializationConstants.EMPTY_STRING); - } catch (URISyntaxException e) { - logger.warn("Malformed URI encountered while suggesting prefix: {}", namespace, e); - base = "p"; + sb.append(c); } } - - base = base.replaceAll("[^a-zA-Z0-9]", SerializationConstants.EMPTY_STRING).toLowerCase(); - if (base.isEmpty()) base = "p"; - - - String candidate = base; - int i = 0; - - while (prefixToIriMapping.containsKey(candidate) && !prefixToIriMapping.get(candidate).equals(namespace)) { - candidate = base + (++i); - } - return candidate; + return sb.toString(); } - - // --- Helpers for escaping and validation --- - /** * Escapes special characters in TriG string literals. * Handles backslashes, double quotes, and common control characters. @@ -940,7 +205,8 @@ private String getSuggestedPrefix(String namespace) { * @param value The string value of the literal to escape. * @return The escaped string suitable for a TriG literal. */ - private String escapeTriGLiteral(String value) { + @Override + protected String escapeLiteralString(String value) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < value.length(); i++) { char c = value.charAt(i); @@ -990,97 +256,13 @@ private String escapeTriGLiteral(String value) { * Primarily used to escape occurrences of `"""` within the literal. * * @param value The string value of the literal to escape. - * @return The escaped string suitable for a multi-line TriG literal. + * @return The escaped string suitable for a TriG multi-line literal. */ - private String escapeMultilineLiteral(String value) { + @Override + protected String escapeMultilineLiteralString(String value) { return value.replace(SerializationConstants.QUOTE + SerializationConstants.QUOTE + SerializationConstants.QUOTE, SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE); } - - /** - * Escapes characters in an IRI string for TriG output. - * This method primarily focuses on control characters and problematic characters within angle brackets. - * - * @param iri The IRI to escape. - * @return The escaped IRI. - */ - private String escapeTriGIRI(String iri) { - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < iri.length(); i++) { - char c = iri.charAt(i); - if (c < 0x20 || c == 0x7F || c == SerializationConstants.LT.charAt(0) || c == SerializationConstants.GT.charAt(0) || c == SerializationConstants.QUOTE.charAt(0) || c == '{' || c == '}' || c == '|' || c == '^' || c == '`' || c == SerializationConstants.BACK_SLASH.charAt(0)) { - sb.append(String.format("\\u%04X", (int) c)); - } else { - sb.append(c); - } - } - return sb.toString(); - } - - /** - * Validates RDF values before serialization. - * Called only if strictMode is enabled. - * - * @param value The {@link Value} to validate. - * @throws IllegalArgumentException if the value is null or invalid according to strict rules. - */ - private void validateValue(Value value) { - if (value == null) { - logger.warn("Null value encountered where a non-null value was expected for TriG serialization. This will lead to an IllegalArgumentException if strict mode is enabled."); - throw new IllegalArgumentException("Value cannot be null in TriG format when strictMode is enabled."); - } - - if (config.isStrictMode() && value.isLiteral()) { - validateLiteral((Literal) value); - } - } - - /** - * Validates a {@link Literal} to ensure it conforms to RDF/TriG rules. - * Specifically checks for consistency between language tags and the rdf:langString datatype. - * Called only if strictMode is enabled. - * - * @param literal The {@link Literal} to validate. - * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, - * or rdf:langString literal without language tag). - */ - private void validateLiteral(Literal literal) { - IRI datatype = literal.getDatatype(); - - if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { - throw new IllegalArgumentException( - "A literal with a language tag must use the rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); - } - } else { - if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { - throw new IllegalArgumentException( - "An rdf:langString literal must have a language tag."); - } - } - } - - /** - * Validates an {@link IRI} to ensure it conforms to TriG rules. - * Checks if the IRI string contains characters not allowed in unescaped TriG - * form within angle brackets (e.g., control characters, space). - * Called only if strictMode and validateURIs are enabled. - * - * @param iri The {@link IRI} to validate. - * @throws IllegalArgumentException if the IRI contains invalid characters. - */ - private void validateIRI(IRI iri) { - String iriString = iri.stringValue(); - - if (iriString.contains(SerializationConstants.SPACE) || - iriString.contains(SerializationConstants.QUOTE) || - iriString.contains(SerializationConstants.LT) || - iriString.contains(SerializationConstants.GT)) { - throw new IllegalArgumentException("IRI contains illegal characters (space, quotes, angle brackets) for unescaped TriG form: " + iriString); - } - } - - } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java index f1d81b25a..e54a56546 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java @@ -1,24 +1,14 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; +import fr.inria.corese.core.next.impl.common.serialization.base.AbstractGraphSerializer; import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; -import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; -import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.BufferedWriter; import java.io.IOException; -import java.io.UncheckedIOException; import java.io.Writer; -import java.net.URI; -import java.net.URISyntaxException; -import java.util.*; -import java.util.stream.Collectors; /** * Serializes a {@link Model} to Turtle format with comprehensive syntax support. @@ -41,22 +31,10 @@ *

    Advanced features such as strict adherence to maximum line length * and generation of stable blank node identifiers are not fully implemented in this version.

    */ -public class TurtleSerializer implements RdfSerializer { +public class TurtleSerializer extends AbstractGraphSerializer { - /** - * Logger for this class, used to log potential issues or information during serialization. - */ private static final Logger logger = LoggerFactory.getLogger(TurtleSerializer.class); - private final Model model; - private final SerializerConfig config; - private final Map iriToPrefixMapping; - private final Map prefixToIriMapping; - // Set to track blank nodes already serialized inline or as part of a list - private final Set consumedBlankNodes; - // Set to track blank nodes currently being serialized to detect cycles - private final Set currentlyWritingBlankNodes; - /** * Constructs a new {@code TurtleSerializer} instance with the specified model and default configuration. * The default configuration is returned by {@link SerializerConfig#turtleConfig()}. @@ -76,771 +54,57 @@ public TurtleSerializer(Model model) { * @throws NullPointerException if the provided model or configuration is null. */ public TurtleSerializer(Model model, SerializationConfig config) { - this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (SerializerConfig) Objects.requireNonNull(config, "Configuration cannot be null"); - this.iriToPrefixMapping = new HashMap<>(); - this.prefixToIriMapping = new HashMap<>(); - this.consumedBlankNodes = new HashSet<>(); - this.currentlyWritingBlankNodes = new HashSet<>(); - initializePrefixes(); + super(model, config); } /** - * Initializes prefix mappings by adding custom prefixes from the configuration. - */ - private void initializePrefixes() { - if (config.usePrefixes()) { - for (Map.Entry entry : config.getCustomPrefixes().entrySet()) { - addPrefixMapping(entry.getValue(), entry.getKey()); - } - } - } - - /** - * Writes the model to the given writer in Turtle format. + * Returns the format name for error messages and logging. * - * @param writer the {@link Writer} to which the Turtle output will be written. - * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + * @return "Turtle" */ @Override - public void write(Writer writer) throws SerializationException { - try (Writer bufferedWriter = new BufferedWriter(writer)) { - writeHeader(bufferedWriter); - - Set precomputedInlineBlankNodes = precomputeInlineBlankNodesAndLists(); - consumedBlankNodes.addAll(precomputedInlineBlankNodes); - - if (config.useCompactTriples() && config.groupBySubject()) { - writeOptimizedStatements(bufferedWriter); - } else { - writeSimpleStatements(bufferedWriter); - } - - } catch (IOException e) { - throw new SerializationException("Failed to write Turtle output", "Turtle", e); - } catch (IllegalArgumentException e) { - throw new SerializationException("Invalid data for Turtle format: " + e.getMessage(), "Turtle", e); - } - } - - /** - * Writes the Turtle document header, including base IRI declaration and prefixes. - * - * @param writer the {@link Writer} to which the header will be written. - * @throws IOException if an I/O error occurs. - */ - private void writeHeader(Writer writer) throws IOException { - if (config.getBaseIRI() != null) { - writer.write(String.format("@base <%s> .%s", - config.getBaseIRI(), - config.getLineEnding())); - } - - if (config.usePrefixes() && config.autoDeclarePrefixes()) { - collectUsedNamespaces(); - } - - writePrefixDeclarations(writer); - } - - /** - * Collects all namespaces used in the model and attempts to assign prefixes to them - * if auto-declaration is enabled and they are not already mapped. - */ - private void collectUsedNamespaces() { - Set namespaces = model.stream() - .flatMap(stmt -> Arrays.asList( - stmt.getSubject(), - stmt.getPredicate(), - stmt.getObject() - ).stream()) - .filter(Value::isIRI) - .map(v -> getNamespace(v.stringValue())) - .collect(Collectors.toSet()); - - namespaces.forEach(namespace -> { - if (!iriToPrefixMapping.containsKey(namespace)) { - String prefix = getSuggestedPrefix(namespace); - if (prefix != null) { - addPrefixMapping(namespace, prefix); - } - } - }); - } - - /** - * Writes prefix declarations to the writer, sorted if configured. - * - * @param writer the {@link Writer} to which prefixes will be written. - * @throws IOException if an I/O error occurs. - */ - private void writePrefixDeclarations(Writer writer) throws IOException { - List prefixes = new ArrayList<>(prefixToIriMapping.keySet()); - - if (config.getPrefixOrdering() == PrefixOrderingEnum.ALPHABETICAL) { - Collections.sort(prefixes); - } - - for (String prefix : prefixes) { - writer.write(String.format("@prefix %s: <%s> .%s", - prefix, - prefixToIriMapping.get(prefix), - config.getLineEnding())); - } - - if (!prefixes.isEmpty() || config.getBaseIRI() != null) { - writer.write(config.getLineEnding()); - } + protected String getFormatName() { + return "Turtle"; } /** - * Serializes the model's statements in a simple manner, one per line, without grouping. - * Triples already "consumed" by inline serialization are ignored. + * Implements the main statement writing logic for the Turtle format. + * Turtle does not support named graphs, so this method handles the serialization + * of simple or optimized triples. * * @param writer the {@link Writer} to which the statements will be written. * @throws IOException if an I/O error occurs. */ - private void writeSimpleStatements(Writer writer) throws IOException { - for (Statement stmt : model) { - if (!isConsumed(stmt.getSubject())) { - writeStatement(writer, stmt); - writer.write(config.getLineEnding()); - } - } - } - - /** - * Writes a single {@link Statement} to the writer in Turtle format. - * - * @param writer the {@link Writer} to which the statement will be written. - * @param stmt the {@link Statement} to write. - * @throws IOException if an I/O error occurs. - */ - private void writeStatement(Writer writer, Statement stmt) throws IOException { - String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; - writer.write(indent); - - // Subject - writeValue(writer, stmt.getSubject()); - writer.write(SerializationConstants.SPACE); - - // Predicate - writePredicate(writer, stmt.getPredicate()); - writer.write(SerializationConstants.SPACE); - - // Object - writeValue(writer, stmt.getObject()); - - // Trailing dot - if (config.trailingDot()) { - writer.write(SerializationConstants.SPACE); - writer.write(SerializationConstants.POINT); - } - - logContextWarning(stmt); - } - - /** - * Writes the predicate to the writer, using the 'a' shortcut if configured and applicable. - * - * @param writer the {@link Writer} to which the predicate will be written. - * @param predicate the {@link Value} representing the predicate. - * @throws IOException if an I/O error occurs. - */ - private void writePredicate(Writer writer, Value predicate) throws IOException { - if (config.useRdfTypeShortcut() && predicate.stringValue().equals(SerializationConstants.RDF_TYPE)) { - writer.write(SerializationConstants.RDF_TYPE_SHORTCUT); - } else { - writeValue(writer, predicate); - } - } - - /** - * Writes a single {@link Value} to the writer. - * Handles literals, blank nodes, and IRIs. - * This is the entry point for serializing nested blank nodes and lists. - * - * @param writer the {@link Writer} to which the value will be written. - * @param value the {@link Value} to write. - * @throws IOException if an I/O error occurs. - * @throws IllegalArgumentException if the provided value is null or of an unsupported type. - */ - private void writeValue(Writer writer, Value value) throws IOException { - validateValue(value); - - if (value.isIRI()) { - writeIRI(writer, (IRI) value); - } else if (value.isLiteral()) { - writeLiteral(writer, (Literal) value); - } else if (value.isBNode()) { - Resource bNode = (Resource) value; - - if (currentlyWritingBlankNodes.contains(bNode)) { - writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); - return; - } - - currentlyWritingBlankNodes.add(bNode); - - boolean handled = false; - if (config.useCollections() && bNode.isBNode()) { - handled = writeRDFList(writer, bNode); - } - - if (!handled && config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS && bNode.isBNode()) { - List properties = model.stream() - .filter(stmt -> stmt.getSubject().equals(bNode)) - .toList(); - - if (!properties.isEmpty()) { - writeInlineBlankNode(writer, properties); - handled = true; - } - } - - if (!handled) { - writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); - } - - currentlyWritingBlankNodes.remove(bNode); - } else { - throw new IllegalArgumentException("Unsupported value type for Turtle serialization: " + value.getClass().getName()); - } - } - - - /** - * Writes an {@link IRI} to the writer. - * Attempts to use a prefixed name if possible, otherwise writes the full IRI in angle brackets. - * - * @param writer the {@link Writer} to which the IRI will be written. - * @param iri the {@link IRI} to write. - * @throws IOException if an I/O error occurs. - */ - private void writeIRI(Writer writer, IRI iri) throws IOException { - if (config.isStrictMode() && config.validateURIs()) { - validateIRI(iri); - } - - String prefixed = config.usePrefixes() ? getPrefixedName(iri.stringValue()) : null; - - if (prefixed != null) { - writer.write(prefixed); - } else { - writer.write(String.format("<%s>", escapeTurtleIRI(iri.stringValue()))); - } - } - - /** - * Writes a {@link Literal} to the writer in Turtle format. - * Applies escaping and datatype/language tag rules based on configuration. - * - * @param writer the {@link Writer} to which the literal will be written. - * @param literal the {@link Literal} to write. - * @throws IOException if an I/O error occurs. - */ - private void writeLiteral(Writer writer, Literal literal) throws IOException { - String value = literal.stringValue(); - - if (config.shouldUseTripleQuotes(value)) { - writer.write(String.format("\"\"\"%s\"\"\"", escapeMultilineLiteral(value))); + @Override + protected void doWriteStatements(Writer writer) throws IOException { + if (config.useCompactTriples() && config.groupBySubject()) { + writeOptimizedStatements(writer); } else { - writer.write(String.format("\"%s\"", escapeTurtleLiteral(value))); - } - - literal.getLanguage().ifPresent(lang -> { - try { - writer.write(SerializationConstants.AT_SIGN + lang); - } catch (IOException e) { - throw new UncheckedIOException("Error writing language tag to stream", e); - } - }); - - writeDatatype(writer, literal); - } - - /** - * Writes the datatype of a literal if the configured datatype policy allows it. - * - * @param writer the {@link Writer} to which the datatype will be written. - * @param literal the {@link Literal} whose datatype is to be written. - * @throws IOException if an I/O error occurs. - */ - private void writeDatatype(Writer writer, Literal literal) throws IOException { - IRI datatype = literal.getDatatype(); - if (shouldWriteDatatype(literal)) { - writer.write(SerializationConstants.DATATYPE_SEPARATOR); - writeIRI(writer, datatype); - } - } - - /** - * Determines if a literal's datatype should be written based on the configuration. - * - * @param literal the {@link Literal} to check. - * @return {@code true} if the datatype should be written, {@code false} otherwise. - */ - private boolean shouldWriteDatatype(Literal literal) { - if (literal.getLanguage().isPresent()) { - return false; - } - - IRI datatype = literal.getDatatype(); - if (datatype == null) { - return false; - } - - return config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || - (!datatype.stringValue().equals(SerializationConstants.XSD_STRING) && - config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL); - } - - /** - * Writes an inline blank node using the `[]` syntax. - * The blank node's properties are serialized inside the brackets. - * - * @param writer the {@link Writer} to which the blank node will be written. - * @param properties the list of statements where the blank node is the subject. - * @throws IOException if an I/O error occurs. - */ - private void writeInlineBlankNode(Writer writer, List properties) throws IOException { - String currentIndent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; - String propIndent = config.prettyPrint() ? currentIndent + config.getIndent() : SerializationConstants.EMPTY_STRING; - - writer.write(SerializationConstants.BLANK_NODE_START); - - boolean firstProperty = true; - for (Statement stmt : properties) { - if (stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || - stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) { - continue; - } - - if (!firstProperty) { - writer.write(SerializationConstants.SEMICOLON); - } - firstProperty = false; - - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + propIndent); - } else { - writer.write(SerializationConstants.SPACE); - } - - writePredicate(writer, stmt.getPredicate()); - writer.write(SerializationConstants.SPACE); - writeValue(writer, stmt.getObject()); - } - - if (config.prettyPrint() && !properties.isEmpty() && !firstProperty) { - writer.write(config.getLineEnding() + currentIndent); - } - - writer.write(SerializationConstants.BLANK_NODE_END); - } - - /** - * Serializes the model's statements by grouping triples by subject, then by predicate, - * using compact syntax (semicolons and commas) if configured. - * Triples already "consumed" by inline serialization are ignored. - * - * @param writer the {@link Writer} to which the optimized statements will be written. - * @throws IOException if an I/O error occurs. - */ - private void writeOptimizedStatements(Writer writer) throws IOException { - // Collect and group statements by subject - Map> bySubject = config.sortSubjects() ? - new TreeMap<>(Comparator.comparing(Resource::stringValue)) : - new LinkedHashMap<>(); - - - model.stream() - .filter(stmt -> !isConsumed(stmt.getSubject())) - .forEach(stmt -> bySubject.computeIfAbsent(stmt.getSubject(), k -> new ArrayList<>()).add(stmt)); - - for (Map.Entry> subjectEntry : bySubject.entrySet()) { - String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; - writer.write(indent); - writeValue(writer, subjectEntry.getKey()); - writer.write(SerializationConstants.SPACE); - - // Group statements of the current subject by predicate - Map> byPredicate = config.sortPredicates() ? - new TreeMap<>(Comparator.comparing(IRI::stringValue)) : - new LinkedHashMap<>(); - - subjectEntry.getValue().forEach(stmt -> byPredicate.computeIfAbsent(stmt.getPredicate(), k -> new ArrayList<>()).add(stmt)); - - boolean firstPredicate = true; - for (Map.Entry> predicateEntry : byPredicate.entrySet()) { - if (!firstPredicate) { - writer.write(SerializationConstants.SEMICOLON); - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + indent + config.getIndent()); - } else { - writer.write(SerializationConstants.SPACE); - } - } - firstPredicate = false; - - writePredicate(writer, predicateEntry.getKey()); - writer.write(SerializationConstants.SPACE); - - boolean firstObject = true; - for (Statement stmt : predicateEntry.getValue()) { - if (!firstObject) { - writer.write(SerializationConstants.COMMA); - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + indent + config.getIndent() + config.getIndent()); - } else { - writer.write(SerializationConstants.SPACE); - } - } - firstObject = false; - - writeValue(writer, stmt.getObject()); - } - } - - writer.write(SerializationConstants.SPACE + SerializationConstants.POINT); - writer.write(config.getLineEnding()); + writeSimpleStatements(writer); } } /** - * Attempts to serialize an RDF list if the given blank node is its head. - * Marks all blank nodes in the list as consumed. + * Escapes characters in an IRI string for Turtle output. + * This method primarily focuses on control characters and problematic characters within angle brackets. * - * @param writer the {@link Writer} to which the list will be written. - * @param listHead the blank node that might be the head of an RDF list. - * @return {@code true} if an RDF list was serialized, {@code false} otherwise. - * @throws IOException if an I/O error occurs. + * @param iri The IRI to escape. + * @return The escaped IRI. */ - private boolean writeRDFList(Writer writer, Resource listHead) throws IOException { - List items = new ArrayList<>(); - Resource current = listHead; - Set listBlankNodes = new HashSet<>(); - - if (currentlyWritingBlankNodes.contains(listHead)) { - return false; - } - currentlyWritingBlankNodes.add(listHead); - - while (current != null && current.isBNode() && !currentlyWritingBlankNodes.contains(current)) { - listBlankNodes.add(current); - currentlyWritingBlankNodes.add(current); - - final Resource finalCurrentForLambda = current; - List statements = model.stream() - .filter(stmt -> stmt.getSubject().equals(finalCurrentForLambda)) - .toList(); - - if (statements.size() != 2) { - current = null; - break; - } - - Optional first = statements.stream() - .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) - .map(Statement::getObject) - .findFirst(); - - Optional rest = statements.stream() - .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) - .map(Statement::getObject) - .findFirst(); - - if (!first.isPresent() || !rest.isPresent()) { - current = null; - break; - } - - items.add(first.get()); - - if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { - current = null; // End of the list - } else if (rest.get().isBNode()) { - current = (Resource) rest.get(); + @Override + protected String escapeIRIString(String iri) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < iri.length(); i++) { + char c = iri.charAt(i); + if (c < 0x20 || c == 0x7F || c == SerializationConstants.LT.charAt(0) || c == SerializationConstants.GT.charAt(0) || c == SerializationConstants.QUOTE.charAt(0) || c == '{' || c == '}' || c == '|' || c == '^' || c == '`' || c == SerializationConstants.BACK_SLASH.charAt(0)) { + sb.append(String.format("\\u%04X", (int) c)); } else { - current = null; - break; - } - } - currentlyWritingBlankNodes.remove(listHead); - - if (items.isEmpty() || current != null) { - listBlankNodes.forEach(currentlyWritingBlankNodes::remove); - return false; - } - - consumedBlankNodes.addAll(listBlankNodes); - - writer.write(SerializationConstants.OPEN_PARENTHESIS); - boolean firstItem = true; - for (Value item : items) { - if (!firstItem) writer.write(SerializationConstants.SPACE); - firstItem = false; - writeValue(writer, item); - } - writer.write(SerializationConstants.CLOSE_PARENTHESIS); - return true; - } - - /** - * Determines if a value (subject, predicate, object) is a blank node that has already been - * serialized inline (within a '[]' or '()') and should be ignored during top-level serialization. - * - * @param value the {@link Value} to check. - * @return {@code true} if the value is a consumed blank node, {@code false} otherwise. - */ - private boolean isConsumed(Value value) { - return value.isBNode() && consumedBlankNodes.contains(value); - } - - /** - * Identifies and returns a set of blank nodes that can be serialized inline (either as `[]` or as `()` for lists). - * These nodes will then be "consumed" to prevent their serialization as top-level triples. - * - * @return A {@link Set} of {@link Resource} representing the blank nodes that will be serialized inline. - */ - private Set precomputeInlineBlankNodesAndLists() { - Set precomputed = new HashSet<>(); - for (Statement stmt : model) { - if (stmt.getSubject().isBNode()) { - Resource bNodeSubject = stmt.getSubject(); - - if (config.useCollections() && isRDFListHead(bNodeSubject)) { - Resource current = bNodeSubject; - Set listNodes = new HashSet<>(); - Set visitedInPrecomp = new HashSet<>(); - boolean isList = true; - while (current != null && current.isBNode() && !visitedInPrecomp.contains(current)) { - visitedInPrecomp.add(current); - listNodes.add(current); - final Resource finalCurrentForLambda = current; - List listProps = model.stream() - .filter(s -> s.getSubject().equals(finalCurrentForLambda)) - .toList(); - - if (listProps.size() != 2) { - isList = false; - break; - } - - Optional first = listProps.stream() - .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) - .map(Statement::getObject) - .findFirst(); - - Optional rest = listProps.stream() - .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) - .map(Statement::getObject) - .findFirst(); - - if (!first.isPresent() || !rest.isPresent()) { - isList = false; - break; - } - - if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { - current = null; - } else if (rest.get().isBNode()) { - current = (Resource) rest.get(); - } else { - isList = false; - break; - } - } - if (isList && current == null) { - precomputed.addAll(listNodes); - } - } - if (config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS) { - List properties = model.stream() - .filter(s -> s.getSubject().equals(bNodeSubject)) - .toList(); - - boolean isPartOfList = properties.stream().anyMatch(s -> - s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || - s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST) - ); - - if (!properties.isEmpty() && !isPartOfList) { - precomputed.add(bNodeSubject); - } - } - } - } - return precomputed; - } - - - /** - * Checks if a given blank node is the head of an RDF list. - * - * @param bNode the blank node to check. - * @return true if it's the head of an RDF list, false otherwise. - */ - private boolean isRDFListHead(Resource bNode) { - - boolean hasFirstAndRest = model.stream() - .filter(stmt -> stmt.getSubject().equals(bNode)) - .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) - && - model.stream() - .filter(stmt -> stmt.getSubject().equals(bNode)) - .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)); - - if (!hasFirstAndRest) return false; - - // Check if this blank node is the object of another rdf:rest triple - boolean isObjectOfRest = model.stream() - .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) - .anyMatch(stmt -> stmt.getObject().equals(bNode)); - - return hasFirstAndRest && !isObjectOfRest; - } - - - // --- Helpers for prefix resolution --- - - /** - * Adds a prefix-namespace URI mapping to the internal mappings. - * Handles potential conflicts to ensure uniqueness. - * - * @param namespaceURI The namespace URI. - * @param prefix The associated prefix. - */ - private void addPrefixMapping(String namespaceURI, String prefix) { - - if (iriToPrefixMapping.containsKey(namespaceURI)) { - if (!iriToPrefixMapping.get(namespaceURI).equals(prefix) && logger.isWarnEnabled()) { - logger.warn("Namespace URI '{}' is already mapped to prefix '{}'. Cannot map to new prefix '{}'.", - namespaceURI, iriToPrefixMapping.get(namespaceURI), prefix); - - } - return; - } - - - if (prefixToIriMapping.containsKey(prefix)) { - if (!prefixToIriMapping.get(prefix).equals(namespaceURI) && logger.isWarnEnabled()) { - String originalNamespace = prefixToIriMapping.get(prefix); - logger.warn("Prefix '{}' is already mapped to namespace '{}'. Cannot map to new namespace '{}'. " + - "A new unique prefix will be generated for '{}'.", - prefix, originalNamespace, namespaceURI, namespaceURI); - - } - return; - } - - iriToPrefixMapping.put(namespaceURI, prefix); - prefixToIriMapping.put(prefix, namespaceURI); - } - - /** - * Extracts the namespace URI part from an IRI string. - * This is a common heuristic for RDF IRIs. - * - * @param iriString The full IRI. - * @return The namespace URI part. - */ - private String getNamespace(String iriString) { - int hashIdx = iriString.lastIndexOf(SerializationConstants.HASH); - int slashIdx = iriString.lastIndexOf(SerializationConstants.SLASH); - - if (hashIdx > -1) { - return iriString.substring(0, hashIdx + 1); - } else if (slashIdx > -1 && slashIdx < iriString.length() - 1) { - int dotIdx = iriString.lastIndexOf(SerializationConstants.POINT); - if (dotIdx > slashIdx) { - - return iriString.substring(0, slashIdx + 1); - } - return iriString.substring(0, slashIdx + 1); - } - return iriString; - } - - - /** - * Attempts to find a prefixed name for an IRI from existing mappings. - * - * @param iriString The full IRI. - * @return The prefixed name (e.g., "ex:someResource") or null if no suitable prefix is found. - */ - private String getPrefixedName(String iriString) { - for (Map.Entry entry : iriToPrefixMapping.entrySet()) { - String namespace = entry.getKey(); - String prefix = entry.getValue(); - - if (iriString.startsWith(namespace)) { - String localName = iriString.substring(namespace.length()); - if (localName.isEmpty()) { - if (!prefix.isEmpty()) { - return prefix + SerializationConstants.COLON; - } else { - continue; - } - } - return prefix + SerializationConstants.COLON + localName; - } - } - return null; - } - - /** - * Suggests a prefix for a given namespace URI. - * Attempts to derive a meaningful prefix or generates a unique one. - * - * @param namespace The namespace URI. - * @return A suggested prefix, or null if suggestion is not possible. - */ - private String getSuggestedPrefix(String namespace) { - // Try common predefined prefixes - if (namespace.equals(SerializationConstants.RDF_NS)) return "rdf"; - if (namespace.equals(SerializationConstants.RDFS_NS)) return "rdfs"; - if (namespace.equals(SerializationConstants.XSD_NS)) return "xsd"; - if (namespace.equals(SerializationConstants.OWL_NS)) return "owl"; - if (namespace.equals(SerializationConstants.FOAF_NS)) return "foaf"; - - - String base = namespace; - if (base.endsWith(SerializationConstants.HASH) || base.endsWith(SerializationConstants.SLASH)) { - base = base.substring(0, base.length() - 1); - } - int lastSlash = base.lastIndexOf(SerializationConstants.SLASH); - int lastHash = base.lastIndexOf(SerializationConstants.HASH); - int lastSegmentStart = Math.max(lastSlash, lastHash); - if (lastSegmentStart != -1) { - base = base.substring(lastSegmentStart + 1); - } - - if (base.isEmpty()) { - try { - URI uri = new URI(namespace); - base = uri.getHost().replace(SerializationConstants.POINT, SerializationConstants.EMPTY_STRING); - } catch (URISyntaxException e) { - logger.warn("Malformed URI encountered while suggesting prefix: {}", namespace, e); - base = "p"; + sb.append(c); } } - - base = base.replaceAll("[^a-zA-Z0-9]", "").toLowerCase(); - if (base.isEmpty()) base = "p"; - - // Ensure uniqueness - String candidate = base; - int i = 0; - while (prefixToIriMapping.containsKey(candidate) && !prefixToIriMapping.get(candidate).equals(namespace)) { - candidate = base + (++i); - } - return candidate; + return sb.toString(); } - - // --- Helpers for escaping and validation --- - /** * Escapes special characters in Turtle string literals. * Handles backslashes, double quotes, and common control characters. @@ -849,7 +113,8 @@ private String getSuggestedPrefix(String namespace) { * @param value The string value of the literal to escape. * @return The escaped string suitable for a Turtle literal. */ - private String escapeTurtleLiteral(String value) { + @Override + protected String escapeLiteralString(String value) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < value.length(); i++) { char c = value.charAt(i); @@ -899,99 +164,16 @@ private String escapeTurtleLiteral(String value) { * Primarily used to escape occurrences of `"""` within the literal. * * @param value The string value of the literal to escape. - * @return The escaped string suitable for a multi-line Turtle literal. + * @return The escaped string suitable for a Turtle multi-line literal. */ - private String escapeMultilineLiteral(String value) { - + @Override + protected String escapeMultilineLiteralString(String value) { return value.replace(SerializationConstants.QUOTE + SerializationConstants.QUOTE + SerializationConstants.QUOTE, SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE + SerializationConstants.BACK_SLASH + SerializationConstants.QUOTE); } - /** - * Escapes characters in an IRI string for Turtle output. - * This method primarily focuses on control characters and problematic characters within angle brackets. - * - * @param iri The IRI to escape. - * @return The escaped IRI. - */ - private String escapeTurtleIRI(String iri) { - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < iri.length(); i++) { - char c = iri.charAt(i); - if (c < 0x20 || c == 0x7F || c == SerializationConstants.LT.charAt(0) || c == SerializationConstants.GT.charAt(0) || c == SerializationConstants.QUOTE.charAt(0) || c == '{' || c == '}' || c == '|' || c == '^' || c == '`' || c == SerializationConstants.BACK_SLASH.charAt(0)) { - sb.append(String.format("\\u%04X", (int) c)); - } else { - sb.append(c); - } - } - return sb.toString(); - } - - /** - * Validates RDF values before serialization. - * Called only if strictMode is enabled. - * - * @param value The {@link Value} to validate. - * @throws IllegalArgumentException if the value is null or invalid according to strict rules. - */ - private void validateValue(Value value) { - if (value == null) { - logger.warn("Null value encountered where a non-null value was expected for Turtle serialization. This will lead to an IllegalArgumentException if strict mode is enabled."); - throw new IllegalArgumentException("Value cannot be null in Turtle format when strictMode is enabled."); - } - - if (config.isStrictMode() && value.isLiteral()) { - validateLiteral((Literal) value); - } - } - - /** - * Validates a {@link Literal} to ensure it conforms to RDF/Turtle rules. - * Specifically checks for consistency between language tags and the rdf:langString datatype. - * Called only if strictMode is enabled. - * - * @param literal The {@link Literal} to validate. - * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, - * or rdf:langString literal without language tag). - */ - private void validateLiteral(Literal literal) { - IRI datatype = literal.getDatatype(); - - if (literal.getLanguage().isPresent()) { - if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { - throw new IllegalArgumentException( - "A literal with a language tag must use the rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); - } - } else { - if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { - throw new IllegalArgumentException( - "An rdf:langString literal must have a language tag."); - } - } - } - - /** - * Validates an {@link IRI} to ensure it conforms to Turtle rules. - * Checks if the IRI string contains characters not allowed in unescaped Turtle - * form within angle brackets (e.g., control characters, space). - * Called only if strictMode and validateURIs are enabled. - * - * @param iri The {@link IRI} to validate. - * @throws IllegalArgumentException if the IRI contains invalid characters. - */ - private void validateIRI(IRI iri) { - String iriString = iri.stringValue(); - - if (iriString.contains(SerializationConstants.SPACE) || - iriString.contains(SerializationConstants.QUOTE) || - iriString.contains(SerializationConstants.LT) || - iriString.contains(SerializationConstants.GT)) { - throw new IllegalArgumentException("IRI contains illegal characters (space, quotes, angle brackets) for unescaped Turtle form: " + iriString); - } - } - /** * Logs a warning if a context (named graph) is present in a statement, * as the Turtle format does not support named graphs. @@ -1004,4 +186,10 @@ private void logContextWarning(Statement stmt) { stmt.getContext().stringValue(), stmt); } } + + @Override + protected void writeStatement(Writer writer, Statement stmt) throws IOException { + super.writeStatement(writer, stmt); + logContextWarning(stmt); + } } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractGraphSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractGraphSerializer.java new file mode 100644 index 000000000..cb2dc67ac --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractGraphSerializer.java @@ -0,0 +1,899 @@ +package fr.inria.corese.core.next.impl.common.serialization.base; + +import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; +import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; +import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.UncheckedIOException; +import java.io.Writer; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.*; +import java.util.stream.Collectors; + +/** + * Abstract base class for RDF serializers based on TriG and Turtle syntax. + * This class contains the common logic for serializing RDF models + * into formats that support prefixes, nested blank nodes, + * RDF collections, and compact triple serialization. + * Subclasses must implement format-specific methods + * (context handling, specific escaping rules). + */ +public abstract class AbstractGraphSerializer implements RdfSerializer { + + /** + * Logger for this class, used to log potential issues or information during serialization. + */ + protected static final Logger logger = LoggerFactory.getLogger(AbstractGraphSerializer.class); + + protected final Model model; + protected final SerializerConfig config; + protected final Map iriToPrefixMapping; + protected final Map prefixToIriMapping; + protected final Set consumedBlankNodes; + protected final Set currentlyWritingBlankNodes; + + /** + * Constructs a new abstract TriG/Turtle serializer instance. + * + * @param model the {@link Model} to serialize. Must not be null. + * @param config the {@link SerializationConfig} to use for serialization. Must not be null. + * @throws NullPointerException if the provided model or configuration is null. + */ + protected AbstractGraphSerializer(Model model, SerializationConfig config) { + this.model = Objects.requireNonNull(model, "The model cannot be null"); + this.config = (SerializerConfig) Objects.requireNonNull(config, "The configuration cannot be null"); + this.iriToPrefixMapping = new HashMap<>(); + this.prefixToIriMapping = new HashMap<>(); + this.consumedBlankNodes = new HashSet<>(); + this.currentlyWritingBlankNodes = new HashSet<>(); + initializePrefixes(); + } + + /** + * Initializes prefix mappings by adding custom prefixes from the configuration. + */ + private void initializePrefixes() { + if (config.usePrefixes()) { + for (Map.Entry entry : config.getCustomPrefixes().entrySet()) { + addPrefixMapping(entry.getValue(), entry.getKey()); + } + } + } + + /** + * Writes the model to the given writer in the specific format. + * + * @param writer the {@link Writer} to which the output will be written. + * @throws SerializationException if an I/O error occurs during writing or if invalid data is encountered. + */ + @Override + public void write(Writer writer) throws SerializationException { + try (Writer bufferedWriter = new BufferedWriter(writer)) { + writeHeader(bufferedWriter); + + Set precomputedInlineBlankNodes = precomputeInlineBlankNodesAndLists(); + consumedBlankNodes.addAll(precomputedInlineBlankNodes); + + doWriteStatements(bufferedWriter); + + bufferedWriter.flush(); + } catch (IOException e) { + throw new SerializationException("Failed to write to stream for format " + getFormatName(), getFormatName(), e); + } catch (IllegalArgumentException e) { + throw new SerializationException("Invalid data for format " + getFormatName() + ": " + e.getMessage(), getFormatName(), e); + } + } + + /** + * Returns the format name for error messages and logging. + * + * @return the format name (e.g., "TriG", "Turtle"). + */ + protected abstract String getFormatName(); + + /** + * Abstract method for the main statement writing, + * to be implemented by subclasses to handle format-specific details. + * + * @param writer the {@link Writer} to which the statements will be written. + * @throws IOException if an I/O error occurs. + * @throws SerializationException if a format-specific serialization error occurs. + */ + protected abstract void doWriteStatements(Writer writer) throws IOException, SerializationException; + + /** + * Writes the document header, including base IRI declaration and prefixes. + * + * @param writer the {@link Writer} to which the header will be written. + * @throws IOException if an I/O error occurs. + */ + protected void writeHeader(Writer writer) throws IOException { + if (config.getBaseIRI() != null) { + writer.write(String.format("@base <%s> .%s", + config.getBaseIRI(), + config.getLineEnding())); + } + + if (config.usePrefixes() && config.autoDeclarePrefixes()) { + collectUsedNamespaces(); + } + + writePrefixDeclarations(writer); + } + + /** + * Collects all namespaces used in the model and attempts to assign prefixes to them + * if auto-declaration is enabled and they are not already mapped. + */ + protected void collectUsedNamespaces() { + Set namespaces = model.stream() + .flatMap(stmt -> { + List values = new ArrayList<>(Arrays.asList( + stmt.getSubject(), + stmt.getPredicate(), + stmt.getObject() + )); + if (stmt.getContext() != null) { + values.add(stmt.getContext()); + } + return values.stream(); + }) + .filter(Objects::nonNull) + .filter(Value::isIRI) + .map(v -> getNamespace(v.stringValue())) + .collect(Collectors.toSet()); + + namespaces.forEach(namespace -> { + if (!iriToPrefixMapping.containsKey(namespace)) { + String prefix = getSuggestedPrefix(namespace); + if (prefix != null) { + addPrefixMapping(namespace, prefix); + } + } + }); + } + + /** + * Writes prefix declarations to the writer, sorted if configured. + * + * @param writer the {@link Writer} to which prefixes will be written. + * @throws IOException if an I/O error occurs. + */ + protected void writePrefixDeclarations(Writer writer) throws IOException { + List prefixes = new ArrayList<>(prefixToIriMapping.keySet()); + + if (config.getPrefixOrdering() == PrefixOrderingEnum.ALPHABETICAL) { + Collections.sort(prefixes); + } + + for (String prefix : prefixes) { + writer.write(String.format("@prefix %s: <%s> .%s", + prefix, + prefixToIriMapping.get(prefix), + config.getLineEnding())); + } + + if (!prefixes.isEmpty() || config.getBaseIRI() != null) { + writer.write(config.getLineEnding()); + } + } + + /** + * Serializes the model's statements in a simple manner, one per line, without grouping. + * Triples already "consumed" by inline serialization are ignored. + * + * @param writer the {@link Writer} to which the statements will be written. + * @throws IOException if an I/O error occurs. + */ + protected void writeSimpleStatements(Writer writer) throws IOException { + for (Statement stmt : model) { + if (!isConsumed(stmt.getSubject())) { + writeStatement(writer, stmt); + writer.write(config.getLineEnding()); + } + } + } + + /** + * Writes a single {@link Statement} to the writer. + * This method is designed to be called by statement writing methods (simple or optimized). + * + * @param writer the {@link Writer} to which the statement will be written. + * @param stmt the {@link Statement} to write. + * @throws IOException if an I/O error occurs. + */ + protected void writeStatement(Writer writer, Statement stmt) throws IOException { + String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; + writer.write(indent); + + // Subject + writeValue(writer, stmt.getSubject()); + writer.write(SerializationConstants.SPACE); + + // Predicate + writePredicate(writer, stmt.getPredicate()); + writer.write(SerializationConstants.SPACE); + + // Object + writeValue(writer, stmt.getObject()); + + writer.write(SerializationConstants.SPACE); + writer.write(SerializationConstants.POINT); + } + + /** + * Writes the predicate to the writer, using the 'a' shortcut if configured and applicable. + * + * @param writer the {@link Writer} to which the predicate will be written. + * @param predicate the {@link Value} representing the predicate. + * @throws IOException if an I/O error occurs. + */ + protected void writePredicate(Writer writer, Value predicate) throws IOException { + if (config.useRdfTypeShortcut() && predicate.stringValue().equals(SerializationConstants.RDF_TYPE)) { + writer.write(SerializationConstants.RDF_TYPE_SHORTCUT); + } else { + writeValue(writer, predicate); + } + } + + /** + * Writes a single {@link Value} to the writer. + * Handles literals, blank nodes, and IRIs. + * This is the entry point for serializing nested blank nodes and lists. + * + * @param writer the {@link Writer} to which the value will be written. + * @param value the {@link Value} to write. + * @throws IOException if an I/O error occurs. + * @throws IllegalArgumentException if the provided value is null or of an unsupported type. + */ + protected void writeValue(Writer writer, Value value) throws IOException { + validateValue(value); + + if (value.isIRI()) { + writeIRI(writer, (IRI) value); + } else if (value.isLiteral()) { + writeLiteral(writer, (Literal) value); + } else if (value.isBNode()) { + Resource bNode = (Resource) value; + + if (currentlyWritingBlankNodes.contains(bNode)) { + writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); + return; + } + + currentlyWritingBlankNodes.add(bNode); + + boolean handled = false; + if (config.useCollections() && bNode.isBNode()) { + handled = writeRDFList(writer, bNode); + } + + if (!handled && config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS && bNode.isBNode()) { + List properties = model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .toList(); + + if (!properties.isEmpty()) { + writeInlineBlankNode(writer, properties); + handled = true; + } + } + + if (!handled) { + writer.write(SerializationConstants.BNODE_PREFIX + bNode.stringValue()); + } + + currentlyWritingBlankNodes.remove(bNode); + } else { + throw new IllegalArgumentException("Unsupported value type for " + getFormatName() + " serialization: " + value.getClass().getName()); + } + } + + /** + * Writes an {@link IRI} to the writer. + * Attempts to use a prefixed name if possible, otherwise writes the full IRI in angle brackets. + * + * @param writer the {@link Writer} to which the IRI will be written. + * @param iri the {@link IRI} to write. + * @throws IOException if an I/O error occurs. + */ + protected void writeIRI(Writer writer, IRI iri) throws IOException { + if (config.isStrictMode() && config.validateURIs()) { + validateIRI(iri); + } + + String prefixed = config.usePrefixes() ? getPrefixedName(iri.stringValue()) : null; + + if (prefixed != null) { + writer.write(prefixed); + } else { + writer.write(String.format("<%s>", escapeIRIString(iri.stringValue()))); + } + } + + /** + * Writes a {@link Literal} to the writer. + * Applies escaping and datatype/language tag rules based on configuration. + * + * @param writer the {@link Writer} to which the literal will be written. + * @param literal the {@link Literal} to write. + * @throws IOException if an I/O error occurs. + */ + protected void writeLiteral(Writer writer, Literal literal) throws IOException { + String value = literal.stringValue(); + + if (config.shouldUseTripleQuotes(value)) { + writer.write(String.format("\"\"\"%s\"\"\"", escapeMultilineLiteralString(value))); + } else { + writer.write(String.format("\"%s\"", escapeLiteralString(value))); + } + + literal.getLanguage().ifPresent(lang -> { + try { + writer.write(SerializationConstants.AT_SIGN + lang); + } catch (IOException e) { + throw new UncheckedIOException("Error writing language tag to stream", e); + } + }); + + writeDatatype(writer, literal); + } + + /** + * Writes the datatype of a literal if the configured datatype policy allows it. + * + * @param writer the {@link Writer} to which the datatype will be written. + * @param literal the {@link Literal} whose datatype is to be written. + * @throws IOException if an I/O error occurs. + */ + protected void writeDatatype(Writer writer, Literal literal) throws IOException { + IRI datatype = literal.getDatatype(); + if (shouldWriteDatatype(literal)) { + writer.write(SerializationConstants.DATATYPE_SEPARATOR); + writeIRI(writer, datatype); + } + } + + /** + * Determines if a literal's datatype should be written based on the configuration. + * + * @param literal the {@link Literal} to check. + * @return {@code true} if the datatype should be written, {@code false} otherwise. + */ + protected boolean shouldWriteDatatype(Literal literal) { + if (literal.getLanguage().isPresent()) { + return false; + } + + IRI datatype = literal.getDatatype(); + if (datatype == null) { + return false; + } + + return config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.ALWAYS_TYPED || + (!datatype.stringValue().equals(SerializationConstants.XSD_STRING) && + config.getLiteralDatatypePolicy() == LiteralDatatypePolicyEnum.MINIMAL); + } + + /** + * Writes an inline blank node using the '[]' syntax. + * The blank node's properties are serialized inside the brackets. + * + * @param writer the {@link Writer} to which the blank node will be written. + * @param properties the list of statements where the blank node is the subject. + * @throws IOException if an I/O error occurs. + */ + protected void writeInlineBlankNode(Writer writer, List properties) throws IOException { + String currentIndent = config.prettyPrint() ? config.getIndent() : ""; + String propIndent = config.prettyPrint() ? currentIndent + config.getIndent() : ""; + + writer.write(SerializationConstants.BLANK_NODE_START); + + boolean firstProperty = true; + for (Statement stmt : properties) { + if (stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || + stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) { + continue; + } + + if (!firstProperty) { + writer.write(SerializationConstants.SEMICOLON); + } + firstProperty = false; + + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + propIndent); + } else { + writer.write(SerializationConstants.SPACE); + } + + writePredicate(writer, stmt.getPredicate()); + writer.write(SerializationConstants.SPACE); + writeValue(writer, stmt.getObject()); + } + + if (config.prettyPrint() && !properties.isEmpty() && !firstProperty) { + writer.write(config.getLineEnding() + currentIndent); + } + + writer.write(SerializationConstants.BLANK_NODE_END); + } + + /** + * Serializes the model's statements by grouping triples by subject, then by predicate, + * using compact syntax (semicolons and commas) if configured. + * Triples already "consumed" by inline serialization are ignored. + * + * @param writer the {@link Writer} to which the optimized statements will be written. + * @throws IOException if an I/O error occurs. + */ + protected void writeOptimizedStatements(Writer writer) throws IOException { + Map> bySubject = config.sortSubjects() ? + new TreeMap<>(Comparator.comparing(Resource::stringValue)) : + new LinkedHashMap<>(); + + model.stream() + .filter(stmt -> !isConsumed(stmt.getSubject())) + .forEach(stmt -> bySubject.computeIfAbsent(stmt.getSubject(), k -> new ArrayList<>()).add(stmt)); + + for (Map.Entry> subjectEntry : bySubject.entrySet()) { + String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; + writer.write(indent); + writeValue(writer, subjectEntry.getKey()); + writer.write(SerializationConstants.SPACE); + + Map> byPredicate = config.sortPredicates() ? + new TreeMap<>(Comparator.comparing(IRI::stringValue)) : + new LinkedHashMap<>(); + + subjectEntry.getValue().forEach(stmt -> byPredicate.computeIfAbsent(stmt.getPredicate(), k -> new ArrayList<>()).add(stmt)); + + boolean firstPredicate = true; + for (Map.Entry> predicateEntry : byPredicate.entrySet()) { + if (!firstPredicate) { + writer.write(SerializationConstants.SEMICOLON); + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + indent + config.getIndent()); + } else { + writer.write(SerializationConstants.SPACE); + } + } + firstPredicate = false; + + writePredicate(writer, predicateEntry.getKey()); + writer.write(SerializationConstants.SPACE); + + boolean firstObject = true; + for (Statement stmt : predicateEntry.getValue()) { + if (!firstObject) { + writer.write(SerializationConstants.COMMA); + if (config.prettyPrint()) { + writer.write(config.getLineEnding() + indent + config.getIndent() + config.getIndent()); + } else { + writer.write(SerializationConstants.SPACE); + } + } + firstObject = false; + + writeValue(writer, stmt.getObject()); + } + } + + writer.write(SerializationConstants.SPACE + SerializationConstants.POINT); + writer.write(config.getLineEnding()); + } + } + + /** + * Attempts to serialize an RDF list if the given blank node is its head. + * Marks all blank nodes in the list as consumed. + * + * @param writer the {@link Writer} to which the list will be written. + * @param listHead the blank node that might be the head of an RDF list. + * @return {@code true} if an RDF list was serialized, {@code false} otherwise. + * @throws IOException if an I/O error occurs. + */ + protected boolean writeRDFList(Writer writer, Resource listHead) throws IOException { + List items = new ArrayList<>(); + Resource current = listHead; + Set listBlankNodes = new HashSet<>(); + + if (currentlyWritingBlankNodes.contains(listHead)) { + return false; + } + currentlyWritingBlankNodes.add(listHead); + + while (current != null && current.isBNode() && !currentlyWritingBlankNodes.contains(current)) { + listBlankNodes.add(current); + currentlyWritingBlankNodes.add(current); + + final Resource finalCurrentForLambda = current; + List statements = model.stream() + .filter(stmt -> stmt.getSubject().equals(finalCurrentForLambda)) + .toList(); + + if (statements.size() != 2) { + current = null; + break; + } + + Optional first = statements.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + .map(Statement::getObject) + .findFirst(); + + Optional rest = statements.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .map(Statement::getObject) + .findFirst(); + + if (!first.isPresent() || !rest.isPresent()) { + current = null; + break; + } + + items.add(first.get()); + + if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { + current = null; + } else if (rest.get().isBNode()) { + current = (Resource) rest.get(); + } else { + current = null; + break; + } + } + currentlyWritingBlankNodes.remove(listHead); + + if (items.isEmpty() || current != null) { + listBlankNodes.forEach(currentlyWritingBlankNodes::remove); + return false; + } + + consumedBlankNodes.addAll(listBlankNodes); + + writer.write(SerializationConstants.OPEN_PARENTHESIS); + boolean firstItem = true; + for (Value item : items) { + if (!firstItem) writer.write(SerializationConstants.SPACE); + firstItem = false; + writeValue(writer, item); + } + writer.write(SerializationConstants.CLOSE_PARENTHESIS); + return true; + } + + /** + * Determines if a value (subject, predicate, object) is a blank node that has already been + * serialized inline (within a '[]' or '()') and should be ignored during top-level serialization. + * + * @param value the {@link Value} to check. + * @return {@code true} if the value is a consumed blank node, {@code false} otherwise. + */ + protected boolean isConsumed(Value value) { + return value.isBNode() && consumedBlankNodes.contains(value); + } + + /** + * Identifies and returns a set of blank nodes that can be serialized inline (either as '[]' or as '()' for lists). + * These nodes will then be "consumed" to prevent their serialization as top-level triples. + * + * @return A {@link Set} of {@link Resource} representing the blank nodes that will be serialized inline. + */ + protected Set precomputeInlineBlankNodesAndLists() { + Set precomputed = new HashSet<>(); + for (Statement stmt : model) { + if (stmt.getSubject().isBNode()) { + Resource bNodeSubject = stmt.getSubject(); + if (config.useCollections() && isRDFListHead(bNodeSubject)) { + Resource current = bNodeSubject; + Set listNodes = new HashSet<>(); + Set visitedInPrecomp = new HashSet<>(); + boolean isList = true; + while (current != null && current.isBNode() && !visitedInPrecomp.contains(current)) { + visitedInPrecomp.add(current); + listNodes.add(current); + final Resource finalCurrentForLambda = current; + List listProps = model.stream() + .filter(s -> s.getSubject().equals(finalCurrentForLambda)) + .toList(); + + if (listProps.size() != 2) { + isList = false; + break; + } + + Optional first = listProps.stream() + .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + .map(Statement::getObject) + .findFirst(); + + Optional rest = listProps.stream() + .filter(s -> s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .map(Statement::getObject) + .findFirst(); + + if (!first.isPresent() || !rest.isPresent()) { + isList = false; + break; + } + + if (rest.get().stringValue().equals(SerializationConstants.RDF_NIL)) { + current = null; + } else if (rest.get().isBNode()) { + current = (Resource) rest.get(); + } else { + isList = false; + break; + } + } + if (isList && current == null) { + precomputed.addAll(listNodes); + } + } + if (config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS) { + List properties = model.stream() + .filter(s -> s.getSubject().equals(bNodeSubject)) + .toList(); + + boolean isPartOfList = properties.stream().anyMatch(s -> + s.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST) || + s.getPredicate().stringValue().equals(SerializationConstants.RDF_REST) + ); + + if (!properties.isEmpty() && !isPartOfList) { + precomputed.add(bNodeSubject); + } + } + } + } + return precomputed; + } + + /** + * Checks if a given blank node is the head of an RDF list. + * + * @param bNode the blank node to check. + * @return true if it's the head of an RDF list, false otherwise. + */ + protected boolean isRDFListHead(Resource bNode) { + boolean hasFirstAndRest = model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_FIRST)) + && + model.stream() + .filter(stmt -> stmt.getSubject().equals(bNode)) + .anyMatch(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)); + + boolean isObjectOfRest = model.stream() + .filter(stmt -> stmt.getPredicate().stringValue().equals(SerializationConstants.RDF_REST)) + .anyMatch(stmt -> stmt.getObject().equals(bNode)); + + return hasFirstAndRest && !isObjectOfRest; + } + + + /** + * Adds a prefix-namespace URI mapping to the internal mappings. + * Handles potential conflicts to ensure uniqueness. + * + * @param namespaceURI The namespace URI. + * @param prefix The associated prefix. + */ + protected void addPrefixMapping(String namespaceURI, String prefix) { + if (iriToPrefixMapping.containsKey(namespaceURI)) { + if (logger.isWarnEnabled() && !iriToPrefixMapping.get(namespaceURI).equals(prefix)) { + logger.warn("Namespace URI '{}' is already mapped to prefix '{}'. Cannot map to new prefix '{}'.", + namespaceURI, iriToPrefixMapping.get(namespaceURI), prefix); + } + return; + } + + if (prefixToIriMapping.containsKey(prefix)) { + if (logger.isWarnEnabled() && !prefixToIriMapping.get(prefix).equals(namespaceURI)) { + String originalNamespace = prefixToIriMapping.get(prefix); + logger.warn("Prefix '{}' is already mapped to namespace '{}'. Cannot map to new namespace '{}'. " + + "A new unique prefix will be generated for '{}'.", + prefix, originalNamespace, namespaceURI, namespaceURI); + } + return; + } + + iriToPrefixMapping.put(namespaceURI, prefix); + prefixToIriMapping.put(prefix, namespaceURI); + } + + /** + * Extracts the namespace URI part from an IRI string. + * This is a common heuristic for RDF IRIs. + * + * @param iriString The full IRI. + * @return The namespace URI part. + */ + protected String getNamespace(String iriString) { + int hashIdx = iriString.lastIndexOf(SerializationConstants.HASH); + int slashIdx = iriString.lastIndexOf(SerializationConstants.SLASH); + + if (hashIdx > -1) { + return iriString.substring(0, hashIdx + 1); + } else if (slashIdx > -1 && slashIdx < iriString.length() - 1) { + int dotIdx = iriString.lastIndexOf(SerializationConstants.POINT); + if (dotIdx > slashIdx) { + return iriString.substring(0, slashIdx + 1); + } + return iriString.substring(0, slashIdx + 1); + } + return iriString; + } + + /** + * Attempts to find a prefixed name for an IRI from existing mappings. + * + * @param iriString The full IRI. + * @return The prefixed name (e.g., "ex:someResource") or null if no suitable prefix is found. + */ + protected String getPrefixedName(String iriString) { + for (Map.Entry entry : iriToPrefixMapping.entrySet()) { + String namespace = entry.getKey(); + String prefix = entry.getValue(); + + if (iriString.startsWith(namespace)) { + String localName = iriString.substring(namespace.length()); + if (localName.isEmpty()) { + if (!prefix.isEmpty()) { + return prefix + SerializationConstants.COLON; + } else { + continue; + } + } + return prefix + SerializationConstants.COLON + localName; + } + } + return null; + } + + /** + * Suggests a prefix for a given namespace URI. + * Attempts to derive a meaningful prefix or generates a unique one. + * + * @param namespace The namespace URI. + * @return A suggested prefix, or null if suggestion is not possible. + */ + protected String getSuggestedPrefix(String namespace) { + if (namespace.equals(SerializationConstants.RDF_NS)) return "rdf"; + if (namespace.equals(SerializationConstants.RDFS_NS)) return "rdfs"; + if (namespace.equals(SerializationConstants.XSD_NS)) return "xsd"; + if (namespace.equals(SerializationConstants.OWL_NS)) return "owl"; + if (namespace.equals(SerializationConstants.FOAF_NS)) return "foaf"; + + String base = namespace; + if (base.endsWith(SerializationConstants.HASH) || base.endsWith(SerializationConstants.SLASH)) { + base = base.substring(0, base.length() - 1); + } + int lastSlash = base.lastIndexOf(SerializationConstants.SLASH); + int lastHash = base.lastIndexOf(SerializationConstants.HASH); + int lastSegmentStart = Math.max(lastSlash, lastHash); + if (lastSegmentStart != -1) { + base = base.substring(lastSegmentStart + 1); + } + + if (base.isEmpty()) { + try { + URI uri = new URI(namespace); + base = uri.getHost().replace(SerializationConstants.POINT, SerializationConstants.EMPTY_STRING); + } catch (URISyntaxException e) { + logger.warn("Malformed URI encountered while suggesting prefix: {}", namespace, e); + base = "p"; + } + } + + base = base.replaceAll("[^a-zA-Z0-9]", SerializationConstants.EMPTY_STRING).toLowerCase(); + if (base.isEmpty()) base = "p"; + + String candidate = base; + int i = 0; + + while (prefixToIriMapping.containsKey(candidate) && !prefixToIriMapping.get(candidate).equals(namespace)) { + candidate = base + (++i); + } + return candidate; + } + + + /** + * Abstract method to escape special characters in an IRI string for the specific format. + * + * @param iri The IRI to escape. + * @return The escaped IRI. + */ + protected abstract String escapeIRIString(String iri); + + /** + * Abstract method to escape special characters in string literals. + * + * @param value The string value of the literal to escape. + * @return The escaped string. + */ + protected abstract String escapeLiteralString(String value); + + /** + * Abstract method to escape special characters in multi-line literals (triple-quotes). + * + * @param value The string value of the literal to escape. + * @return The escaped string. + */ + protected abstract String escapeMultilineLiteralString(String value); + + /** + * Validates RDF values before serialization. + * Called only if strictMode is enabled. + * + * @param value The {@link Value} to validate. + * @throws IllegalArgumentException if the value is null or invalid according to strict rules. + */ + protected void validateValue(Value value) { + if (value == null) { + logger.warn("Null value encountered where a non-null value was expected for {} serialization. This will lead to an IllegalArgumentException if strict mode is enabled.", getFormatName()); + throw new IllegalArgumentException("Value cannot be null in {} format when strictMode is enabled." + getFormatName()); + } + + if (config.isStrictMode() && value.isLiteral()) { + validateLiteral((Literal) value); + } + } + + /** + * Validates a {@link Literal} to ensure it conforms to RDF/format rules. + * Specifically checks for consistency between language tags and the rdf:langString datatype. + * Called only if strictMode is enabled. + * + * @param literal The {@link Literal} to validate. + * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, + * or rdf:langString literal without language tag). + */ + protected void validateLiteral(Literal literal) { + IRI datatype = literal.getDatatype(); + + if (literal.getLanguage().isPresent()) { + if (datatype == null || !datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { + throw new IllegalArgumentException( + "A literal with a language tag must use the rdf:langString datatype. Found: " + (datatype != null ? datatype.stringValue() : "null")); + } + } else { + if (datatype != null && datatype.stringValue().equals(RDF.LANGSTRING.getIRI().stringValue())) { + throw new IllegalArgumentException( + "An rdf:langString literal must have a language tag."); + } + } + } + + /** + * Validates an {@link IRI} to ensure it conforms to format rules. + * Checks if the IRI string contains characters not allowed in unescaped form + * within angle brackets (e.g., control characters, space). + * Called only if strictMode and validateURIs are enabled. + * + * @param iri The {@link IRI} to validate. + * @throws IllegalArgumentException if the IRI contains invalid characters. + */ + protected void validateIRI(IRI iri) { + String iriString = iri.stringValue(); + + if (iriString.contains(SerializationConstants.SPACE) || + iriString.contains(SerializationConstants.QUOTE) || + iriString.contains(SerializationConstants.LT) || + iriString.contains(SerializationConstants.GT)) { + throw new IllegalArgumentException("IRI contains illegal characters (space, quotes, angle brackets) for the unescaped form of " + getFormatName() + ": " + iriString); + } + } +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java index 8d4c404fe..39fe649cc 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java @@ -545,7 +545,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { assertEquals("TriG", thrown.getFormatName()); - assertEquals("Invalid data for TriG format: An rdf:langString literal must have a language tag. [Format: TriG]", thrown.getMessage()); + assertEquals("Invalid data for format TriG: An rdf:langString literal must have a language tag. [Format: TriG]", thrown.getMessage()); } /** @@ -606,7 +606,7 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { assertEquals("TriG", thrown.getFormatName()); - assertEquals("Invalid data for TriG format: IRI contains illegal characters (space, quotes, angle brackets) for unescaped TriG form: http://example.org/invalid iri [Format: TriG]", thrown.getMessage()); + assertEquals("Invalid data for format TriG: IRI contains illegal characters (space, quotes, angle brackets) for the unescaped form of TriG: http://example.org/invalid iri [Format: TriG]", thrown.getMessage()); } /** diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java index d5b9f146c..b867f53cc 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java @@ -2,8 +2,8 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.Test; @@ -431,12 +431,7 @@ void testBlankNodeSerialization() throws SerializationException, IOException { when(mockModel.iterator()).thenAnswer(invocation -> Arrays.asList(mainStatement, bNodePropertyStatement).iterator()); - when(mockModel.stream()) - .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)) - .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)) - .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)) - .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)) - .thenReturn(Stream.of(mainStatement, bNodePropertyStatement)); + when(mockModel.stream()).thenAnswer(invocation -> Stream.of(mainStatement, bNodePropertyStatement)); StringWriter writer = new StringWriter(); @@ -445,7 +440,7 @@ void testBlankNodeSerialization() throws SerializationException, IOException { turtleSerializer.write(writer); - verify(mockModel, times(5)).stream(); + verify(mockModel, atLeastOnce()).stream(); String expected = """ @prefix ns: . @@ -645,7 +640,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { assertEquals("Turtle", thrown.getFormatName()); - assertEquals("Invalid data for Turtle format: An rdf:langString literal must have a language tag. [Format: Turtle]", thrown.getMessage()); + assertEquals("Invalid data for format Turtle: An rdf:langString literal must have a language tag. [Format: Turtle]", thrown.getMessage()); } /** @@ -706,7 +701,7 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { assertEquals("Turtle", thrown.getFormatName()); - assertEquals("Invalid data for Turtle format: IRI contains illegal characters (space, quotes, angle brackets) for unescaped Turtle form: http://example.org/invalid iri [Format: Turtle]", thrown.getMessage()); + assertEquals("Invalid data for format Turtle: IRI contains illegal characters (space, quotes, angle brackets) for the unescaped form of Turtle: http://example.org/invalid iri [Format: Turtle]", thrown.getMessage()); } /** From ebdb7d1d443b94a7e963abe2ea6cd658629fa259 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 4 Jul 2025 11:03:29 +0200 Subject: [PATCH 21/27] =?UTF-8?q?=20la=20configuration=20de=20la=20s=C3=A9?= =?UTF-8?q?rialisation?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../DefaultSerializerFactory.java | 79 +- .../serialization/NQuadsSerializer.java | 21 +- .../serialization/NTriplesSerializer.java | 22 +- .../common/serialization/TriGSerializer.java | 62 +- .../serialization/TurtleSerializer.java | 17 +- .../common/serialization/XmlSerializer.java | 26 +- .../base/AbstractGraphSerializer.java | 117 ++- .../base/AbstractLineBasedSerializer.java | 11 +- .../config/AbstractNFamilyConfig.java | 62 ++ .../config/AbstractSerializerConfig.java | 310 ++++++++ .../config/AbstractTFamilyConfig.java | 525 ++++++++++++++ .../serialization/config/NQuadsConfig.java | 66 ++ .../serialization/config/NTriplesConfig.java | 67 ++ .../config/SerializerConfig.java | 682 ------------------ .../serialization/config/TriGConfig.java | 81 +++ .../serialization/config/TurtleConfig.java | 84 +++ .../serialization/config/XmlConfig.java | 370 ++++++++++ .../DefaultSerializerFactoryTest.java | 55 +- .../serialization/NQuadsSerializerTest.java | 108 +-- .../serialization/NTriplesSerializerTest.java | 208 +++--- .../serialization/SerializerConfigTest.java | 189 ----- .../serialization/TriGSerializerTest.java | 542 ++++---------- .../serialization/TurtleSerializerTest.java | 564 +++++---------- .../serialization/XmlSerializerTest.java | 230 +++--- .../config/NQuadsConfigTest.java | 4 + .../config/NTriplesConfigTest.java | 4 + .../serialization/config/TriGConfigTest.java | 4 + .../config/TurtleConfigTest.java | 4 + .../serialization/config/XmlConfigTest.java | 4 + 29 files changed, 2458 insertions(+), 2060 deletions(-) create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractNFamilyConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractSerializerConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractTFamilyConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfig.java delete mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/SerializerConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfig.java create mode 100644 src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfig.java delete mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerConfigTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfigTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfigTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfigTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfigTest.java create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfigTest.java diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java index fabfb60c8..166badef4 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactory.java @@ -1,10 +1,13 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.RdfSerializer; -import fr.inria.corese.core.next.api.SerializerFactory; import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.RdfSerializer; import fr.inria.corese.core.next.api.SerializationConfig; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.api.SerializerFactory; +import fr.inria.corese.core.next.impl.common.serialization.config.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + import java.util.Collections; import java.util.HashMap; import java.util.Map; @@ -17,23 +20,76 @@ * based on the requested {@link RdfFormat}. It uses a registry pattern * to map each format to its corresponding serializer constructor, * providing a flexible and extensible way to manage serializer instances. + * + *

    It adapts the generic {@link SerializationConfig} provided to the specific + * configuration type expected by each serializer in the hierarchy, with a fallback + * to default configurations if an incompatible type is provided.

    */ public class DefaultSerializerFactory implements SerializerFactory { + private static final Logger logger = LoggerFactory.getLogger(DefaultSerializerFactory.class); + private final Map> registry; /** * Constructs a {@code DefaultSerializerFactory} and populates its registry * with constructors for all known {@link RdfFormat} implementations. + * Each constructor attempts to cast the generic {@link SerializationConfig} to the + * specific configuration type required by the serializer. If the cast is not possible, + * it falls back to the format's default configuration. */ public DefaultSerializerFactory() { Map> tempRegistry = new HashMap<>(); - // Cast the lambda to BiFunction - tempRegistry.put(RdfFormat.TURTLE, (model, config) -> new TurtleSerializer(model, (SerializerConfig) config)); - tempRegistry.put(RdfFormat.NTRIPLES, (model, config) -> new NTriplesSerializer(model, (SerializerConfig) config)); - tempRegistry.put(RdfFormat.NQUADS, (model, config) -> new NQuadsSerializer(model, (SerializerConfig) config)); - tempRegistry.put(RdfFormat.TRIG, (model, config) -> new TriGSerializer(model, (SerializerConfig) config)); - tempRegistry.put(RdfFormat.RDFXML, (model, config) -> new XmlSerializer(model, (SerializerConfig) config)); + + tempRegistry.put(RdfFormat.TURTLE, (model, genericConfig) -> { + if (genericConfig instanceof TurtleConfig specificConfig) { + return new TurtleSerializer(model, specificConfig); + } else { + logger.warn("Provided config for TURTLE is not TurtleConfig (was {}). Using default TurtleConfig.", + genericConfig.getClass().getSimpleName()); + return new TurtleSerializer(model, TurtleConfig.defaultConfig()); + } + }); + + tempRegistry.put(RdfFormat.NTRIPLES, (model, genericConfig) -> { + if (genericConfig instanceof NTriplesConfig specificConfig) { + return new NTriplesSerializer(model, specificConfig); + } else { + logger.warn("Provided config for NTRIPLES is not NTriplesConfig (was {}). Using default NTriplesConfig.", + genericConfig.getClass().getSimpleName()); + return new NTriplesSerializer(model, NTriplesConfig.defaultConfig()); + } + }); + + tempRegistry.put(RdfFormat.NQUADS, (model, genericConfig) -> { + if (genericConfig instanceof NQuadsConfig specificConfig) { + return new NQuadsSerializer(model, specificConfig); + } else { + logger.warn("Provided config for NQUADS is not NQuadsConfig (was {}). Using default NQuadsConfig.", + genericConfig.getClass().getSimpleName()); + return new NQuadsSerializer(model, NQuadsConfig.defaultConfig()); + } + }); + + tempRegistry.put(RdfFormat.TRIG, (model, genericConfig) -> { + if (genericConfig instanceof TriGConfig specificConfig) { + return new TriGSerializer(model, specificConfig); + } else { + logger.warn("Provided config for TRIG is not TriGConfig (was {}). Using default TriGConfig.", + genericConfig.getClass().getSimpleName()); + return new TriGSerializer(model, TriGConfig.defaultConfig()); + } + }); + + tempRegistry.put(RdfFormat.RDFXML, (model, genericConfig) -> { + if (genericConfig instanceof XmlConfig specificConfig) { + return new XmlSerializer(model, specificConfig); + } else { + logger.warn("Provided config for RDFXML is not RdfXmlConfig (was {}). Using default RdfXmlConfig.", + genericConfig.getClass().getSimpleName()); + return new XmlSerializer(model, XmlConfig.defaultConfig()); + } + }); this.registry = Collections.unmodifiableMap(tempRegistry); } @@ -42,10 +98,10 @@ public DefaultSerializerFactory() { * Creates an {@link RdfSerializer} instance for the specified format, model, and configuration. * * @param format the {@link RdfFormat} for which to create the serializer. Must not be null. - * @param model the {@link Model} to be serialized. Must not be null. + * @param model the {@link Model} to be serialized. Must not be null. * @param config the {@link SerializationConfig} to apply during serialization. Must not be null. * @return a new instance of {@link RdfSerializer} configured for the specified format. - * @throws NullPointerException if any of the arguments (format, model, config) are null. + * @throws NullPointerException if any of the arguments (format, model, config) are null. * @throws IllegalArgumentException if the provided format is not supported by this factory. */ @Override @@ -61,7 +117,6 @@ public RdfSerializer createSerializer(RdfFormat format, Model model, Serializati throw new IllegalArgumentException("Unsupported RdfFormat: " + format.getName()); } - return constructor.apply(model, config); } } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java index db031f5de..af2a67c66 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializer.java @@ -1,14 +1,17 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; import fr.inria.corese.core.next.impl.common.serialization.base.AbstractLineBasedSerializer; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.NQuadsConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.io.Writer; +import java.util.Objects; /** * Serializes a Corese {@link Model} into N-Quads format. @@ -24,24 +27,26 @@ public class NQuadsSerializer extends AbstractLineBasedSerializer { /** * Constructs a new {@code NQuadsSerializer} instance with the specified model and default N-Quads configuration. - * The default configuration is obtained from {@link SerializerConfig#nquadsConfig()}. + * The default configuration is obtained from {@link NQuadsConfig#defaultConfig()}. * * @param model the {@link Model} to be serialized. Must not be null. * @throws NullPointerException if the provided model is null. */ public NQuadsSerializer(Model model) { - this(model, SerializerConfig.nquadsConfig()); + this(model, NQuadsConfig.defaultConfig()); } /** * Constructs a new {@code NQuadsSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link SerializationConfig} to use for serialization. Must not be null. + * @param config the {@link NQuadsConfig} to use for serialization. Must not be null. + * This config object should be an instance of {@code NQuadsConfig} or a subclass thereof. * @throws NullPointerException if the provided model or config is null. */ - public NQuadsSerializer(Model model, SerializationConfig config) { - super(model, (SerializerConfig) config); + public NQuadsSerializer(Model model, NQuadsConfig config) { + super(model, config); + Objects.requireNonNull(config, "NQuadsConfig cannot be null"); } /** @@ -74,4 +79,4 @@ protected void writeContext(Writer writer, Statement stmt) throws IOException { context.stringValue(), stmt); } } -} \ No newline at end of file +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java index 6110be218..aaefc3f4f 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializer.java @@ -1,13 +1,16 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; import fr.inria.corese.core.next.impl.common.serialization.base.AbstractLineBasedSerializer; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.NTriplesConfig; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.io.Writer; +import java.util.Objects; /** * Serializes a Corese {@link Model} into N-Triples format. @@ -23,23 +26,26 @@ public class NTriplesSerializer extends AbstractLineBasedSerializer { /** * Constructs a new {@code NTriplesSerializer} instance with the specified model and default configuration. + * The default configuration is obtained from {@link NTriplesConfig#defaultConfig()}. * * @param model the {@link Model} to be serialized. Must not be null. * @throws NullPointerException if the provided model is null. */ public NTriplesSerializer(Model model) { - this(model, SerializerConfig.ntriplesConfig()); + this(model, NTriplesConfig.defaultConfig()); } /** * Constructs a new {@code NTriplesSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link SerializationConfig} to use for serialization. Must not be null. + * @param config the {@link NTriplesConfig} to use for serialization. Must not be null. + * This config object should be an instance of {@code NTriplesConfig} or a subclass thereof. * @throws NullPointerException if the provided model or config is null. */ - public NTriplesSerializer(Model model, SerializationConfig config) { - super(model, (SerializerConfig) config); + public NTriplesSerializer(Model model, NTriplesConfig config) { + super(model, config); + Objects.requireNonNull(config, "NTriplesConfig cannot be null"); } /** @@ -64,10 +70,10 @@ protected String getFormatName() { @Override protected void writeContext(Writer writer, Statement stmt) throws IOException { Resource context = stmt.getContext(); + if (context != null && logger.isWarnEnabled()) { logger.warn("N-Triples format does not support named graphs. Context '{}' will be ignored for statement: {}", context.stringValue(), stmt); } - // N-Triples does not support contexts, so we don't write anything } -} \ No newline at end of file +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java index 59cb8b796..d68303ff2 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializer.java @@ -1,8 +1,11 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; import fr.inria.corese.core.next.impl.common.serialization.base.AbstractGraphSerializer; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.TriGConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import java.io.IOException; @@ -35,24 +38,26 @@ public class TriGSerializer extends AbstractGraphSerializer { /** * Constructs a new {@code TriGSerializer} instance with the specified model and default configuration. - * The default configuration is returned by {@link SerializerConfig#trigConfig()}. + * The default configuration is returned by {@link TriGConfig#defaultConfig()}. * * @param model the {@link Model} to serialize. Must not be null. * @throws NullPointerException if the provided model is null. */ public TriGSerializer(Model model) { - this(model, SerializerConfig.trigConfig()); + this(model, TriGConfig.defaultConfig()); } /** * Constructs a new {@code TriGSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link SerializationConfig} to use for serialization. Must not be null. + * @param config the {@link TriGConfig} to use for serialization. Must not be null. + * This config object should be an instance of {@code TriGConfig} or a subclass thereof. * @throws NullPointerException if the provided model or configuration is null. */ - public TriGSerializer(Model model, SerializationConfig config) { + public TriGSerializer(Model model, TriGConfig config) { super(model, config); + Objects.requireNonNull(config, "TriGConfig cannot be null"); } /** @@ -65,6 +70,21 @@ protected String getFormatName() { return "TriG"; } + /** + * Helper method to safely cast the generic config to TriGConfig. + * This should be called before accessing any methods specific to TriGConfig. + * + * @return The config cast to TriGConfig. + * @throws IllegalStateException if the config is not an instance of TriGConfig. + */ + private TriGConfig getTriGConfig() { + if (!(config instanceof TriGConfig)) { + throw new IllegalStateException("Current serializer configuration is not an instance of TriGConfig. " + + "TriGSerializer requires a TriGConfig instance."); + } + return (TriGConfig) config; + } + /** * Implements the main statement writing logic for the TriG format. * Handles the serialization of named graphs. @@ -74,9 +94,11 @@ protected String getFormatName() { */ @Override protected void doWriteStatements(Writer writer) throws IOException { - if (config.includeContext()) { + TriGConfig trigConfig = getTriGConfig(); + + if (trigConfig.includeContext()) { writeStatementsWithContext(writer); - } else if (config.useCompactTriples() && config.groupBySubject()) { + } else if (trigConfig.useCompactTriples() && trigConfig.groupBySubject()) { writeOptimizedStatements(writer); } else { writeSimpleStatements(writer); @@ -92,6 +114,8 @@ protected void doWriteStatements(Writer writer) throws IOException { * @throws IOException if an I/O error occurs. */ private void writeStatementsWithContext(Writer writer) throws IOException { + TriGConfig trigConfig = getTriGConfig(); + Map> byContext = new LinkedHashMap<>(); model.stream() .filter(stmt -> !isConsumed(stmt.getSubject())) @@ -102,7 +126,7 @@ private void writeStatementsWithContext(Writer writer) throws IOException { List statementsInContext = contextEntry.getValue(); String initialIndent = ""; - String graphIndent = config.prettyPrint() ? config.getIndent() : ""; + String graphIndent = trigConfig.prettyPrint() ? trigConfig.getIndent() : ""; if (context != null) { if (context.isIRI()) { @@ -112,11 +136,11 @@ private void writeStatementsWithContext(Writer writer) throws IOException { } writer.write(SerializationConstants.SPACE); writer.write(SerializationConstants.OPEN_BRACE); - writer.write(config.getLineEnding()); + writer.write(trigConfig.getLineEnding()); initialIndent = graphIndent; } - Map> bySubject = config.sortSubjects() ? + Map> bySubject = trigConfig.sortSubjects() ? new TreeMap<>(Comparator.comparing(Resource::stringValue)) : new LinkedHashMap<>(); @@ -127,7 +151,7 @@ private void writeStatementsWithContext(Writer writer) throws IOException { writeValue(writer, subjectEntry.getKey()); writer.write(SerializationConstants.SPACE); - Map> byPredicate = config.sortPredicates() ? + Map> byPredicate = trigConfig.sortPredicates() ? new TreeMap<>(Comparator.comparing(IRI::stringValue)) : new LinkedHashMap<>(); @@ -137,8 +161,8 @@ private void writeStatementsWithContext(Writer writer) throws IOException { for (Map.Entry> predicateEntry : byPredicate.entrySet()) { if (!firstPredicate) { writer.write(SerializationConstants.SEMICOLON); - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + initialIndent + config.getIndent()); + if (trigConfig.prettyPrint()) { + writer.write(trigConfig.getLineEnding() + initialIndent + trigConfig.getIndent()); } else { writer.write(SerializationConstants.SPACE); } @@ -152,8 +176,8 @@ private void writeStatementsWithContext(Writer writer) throws IOException { for (Statement stmt : predicateEntry.getValue()) { if (!firstObject) { writer.write(SerializationConstants.COMMA); - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + initialIndent + config.getIndent() + config.getIndent()); + if (trigConfig.prettyPrint()) { + writer.write(trigConfig.getLineEnding() + initialIndent + trigConfig.getIndent() + trigConfig.getIndent()); } else { writer.write(SerializationConstants.SPACE); } @@ -163,16 +187,16 @@ private void writeStatementsWithContext(Writer writer) throws IOException { } } writer.write(SerializationConstants.SPACE + SerializationConstants.POINT); - writer.write(config.getLineEnding()); + writer.write(trigConfig.getLineEnding()); } if (context != null) { writer.write(SerializationConstants.CLOSE_BRACE); writer.write(SerializationConstants.SPACE); writer.write(SerializationConstants.POINT); - writer.write(config.getLineEnding()); + writer.write(trigConfig.getLineEnding()); } - writer.write(config.getLineEnding()); + writer.write(trigConfig.getLineEnding()); } } diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java index e54a56546..d1316920f 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializer.java @@ -2,13 +2,15 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.serialization.base.AbstractGraphSerializer; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.TurtleConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.AbstractTFamilyConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.io.Writer; +import java.util.Objects; /** * Serializes a {@link Model} to Turtle format with comprehensive syntax support. @@ -37,24 +39,25 @@ public class TurtleSerializer extends AbstractGraphSerializer { /** * Constructs a new {@code TurtleSerializer} instance with the specified model and default configuration. - * The default configuration is returned by {@link SerializerConfig#turtleConfig()}. + * The default configuration is returned by {@link TurtleConfig#defaultConfig()}. * * @param model the {@link Model} to serialize. Must not be null. * @throws NullPointerException if the provided model is null. */ public TurtleSerializer(Model model) { - this(model, SerializerConfig.turtleConfig()); + this(model, TurtleConfig.defaultConfig()); } /** * Constructs a new {@code TurtleSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link SerializationConfig} to use for serialization. Must not be null. + * @param config the {@link TurtleConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or configuration is null. */ - public TurtleSerializer(Model model, SerializationConfig config) { + public TurtleSerializer(Model model, TurtleConfig config) { super(model, config); + Objects.requireNonNull(config, "TurtleConfig cannot be null"); } /** @@ -77,7 +80,9 @@ protected String getFormatName() { */ @Override protected void doWriteStatements(Writer writer) throws IOException { - if (config.useCompactTriples() && config.groupBySubject()) { + AbstractTFamilyConfig tFamilyConfig = (AbstractTFamilyConfig) config; + + if (tFamilyConfig.useCompactTriples() && tFamilyConfig.groupBySubject()) { writeOptimizedStatements(writer); } else { writeSimpleStatements(writer); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java index a81e70921..b79e9d3d1 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializer.java @@ -1,9 +1,9 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.XmlConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; @@ -37,7 +37,7 @@ public class XmlSerializer implements RdfSerializer { private static final Logger logger = LoggerFactory.getLogger(XmlSerializer.class); private final Model model; - private final SerializerConfig config; + private final XmlConfig config; private final Map iriToPrefixMapping; private final Map prefixToIriMapping; private final Map blankNodeIds; @@ -46,25 +46,25 @@ public class XmlSerializer implements RdfSerializer { /** * Constructs a new {@code XmlSerializer} instance with the specified model and default configuration. - * The default configuration is returned by {@link SerializerConfig#rdfXmlConfig()}. + * The default configuration is obtained from {@link XmlConfig#defaultConfig()}. * * @param model the {@link Model} to serialize. Must not be null. * @throws NullPointerException if the provided model is null. */ public XmlSerializer(Model model) { - this(model, SerializerConfig.rdfXmlConfig()); + this(model, XmlConfig.defaultConfig()); } /** * Constructs a new {@code XmlSerializer} instance with the specified model and custom configuration. * * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link SerializationConfig} to use for serialization. Must not be null. + * @param config the {@link XmlConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or configuration is null. */ - public XmlSerializer(Model model, SerializationConfig config) { + public XmlSerializer(Model model, XmlConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); - this.config = (SerializerConfig) Objects.requireNonNull(config, "Configuration cannot be null"); + this.config = Objects.requireNonNull(config, "Configuration cannot be null"); this.iriToPrefixMapping = new HashMap<>(); this.prefixToIriMapping = new HashMap<>(); this.blankNodeIds = new HashMap<>(); @@ -73,12 +73,12 @@ public XmlSerializer(Model model, SerializationConfig config) { /** * Initializes prefix mappings by adding custom prefixes from the configuration. - * The custom prefixes map in SerializerConfig is expected to be {namespaceURI: prefix}. + * The custom prefixes map in XmlConfig is expected to be {prefix: namespaceURI}. */ private void initializePrefixes() { if (config.usePrefixes()) { for (Map.Entry entry : config.getCustomPrefixes().entrySet()) { - addPrefixMapping(entry.getKey(), entry.getValue()); + addPrefixMapping(entry.getValue(), entry.getKey()); } } } @@ -376,7 +376,13 @@ private void writePropertyElement(Writer writer, IRI predicate, Value object, St writer.write(">"); } - writer.write(escapeXmlContent(literal.stringValue())); + if (config.useMultilineLiterals() && (literal.stringValue().contains(SerializationConstants.LINE_FEED) || literal.stringValue().contains(SerializationConstants.CARRIAGE_RETURN))) { + + writer.write(escapeXmlContent(literal.stringValue())); + } else { + writer.write(escapeXmlContent(literal.stringValue())); + } + writer.write(String.format("", elementName)); writer.write(config.getLineEnding()); } else { diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractGraphSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractGraphSerializer.java index cb2dc67ac..2c091dd79 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractGraphSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractGraphSerializer.java @@ -2,10 +2,7 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.*; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.slf4j.Logger; @@ -27,6 +24,12 @@ * RDF collections, and compact triple serialization. * Subclasses must implement format-specific methods * (context handling, specific escaping rules). + * + *

    Note: Many features related to compact syntax, pretty-printing, and advanced + * prefix management are specific to Turtle Trig formats and require the + * provided {@link AbstractSerializerConfig} to be an instance of + * {@link AbstractTFamilyConfig} at runtime. An {@link IllegalStateException} + * will be thrown if an incompatible configuration is used for such features.

    */ public abstract class AbstractGraphSerializer implements RdfSerializer { @@ -36,22 +39,22 @@ public abstract class AbstractGraphSerializer implements RdfSerializer { protected static final Logger logger = LoggerFactory.getLogger(AbstractGraphSerializer.class); protected final Model model; - protected final SerializerConfig config; + protected final AbstractSerializerConfig config; protected final Map iriToPrefixMapping; protected final Map prefixToIriMapping; - protected final Set consumedBlankNodes; - protected final Set currentlyWritingBlankNodes; + protected final Set consumedBlankNodes; + protected final Set currentlyWritingBlankNodes; /** * Constructs a new abstract TriG/Turtle serializer instance. * - * @param model the {@link Model} to serialize. Must not be null. - * @param config the {@link SerializationConfig} to use for serialization. Must not be null. + * @param model the {@link Model} to serialize. Must not be null. + * @param config the {@link AbstractSerializerConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or configuration is null. */ - protected AbstractGraphSerializer(Model model, SerializationConfig config) { + protected AbstractGraphSerializer(Model model, AbstractSerializerConfig config) { this.model = Objects.requireNonNull(model, "The model cannot be null"); - this.config = (SerializerConfig) Objects.requireNonNull(config, "The configuration cannot be null"); + this.config = Objects.requireNonNull(config, "The configuration cannot be null"); this.iriToPrefixMapping = new HashMap<>(); this.prefixToIriMapping = new HashMap<>(); this.consumedBlankNodes = new HashSet<>(); @@ -59,12 +62,27 @@ protected AbstractGraphSerializer(Model model, SerializationConfig config) { initializePrefixes(); } + /** + * Helper method to safely cast the generic config to AbstractTFamilyConfig. + * This should be called before accessing any methods specific to AbstractTFamilyConfig. + * + * @return The config cast to AbstractTFamilyConfig. + * @throws IllegalStateException if the config is not an instance of AbstractTFamilyConfig. + */ + private AbstractTFamilyConfig getTFamilyConfig() { + if (!(config instanceof AbstractTFamilyConfig)) { + throw new IllegalStateException("Current serializer configuration is not an instance of AbstractTFamilyConfig. " + + "Features like prefixes, compact syntax, and pretty-printing are only available for T-Family formats."); + } + return (AbstractTFamilyConfig) config; + } + /** * Initializes prefix mappings by adding custom prefixes from the configuration. */ private void initializePrefixes() { - if (config.usePrefixes()) { - for (Map.Entry entry : config.getCustomPrefixes().entrySet()) { + if (config instanceof AbstractTFamilyConfig && getTFamilyConfig().usePrefixes()) { + for (Map.Entry entry : getTFamilyConfig().getCustomPrefixes().entrySet()) { addPrefixMapping(entry.getValue(), entry.getKey()); } } @@ -106,7 +124,7 @@ public void write(Writer writer) throws SerializationException { * to be implemented by subclasses to handle format-specific details. * * @param writer the {@link Writer} to which the statements will be written. - * @throws IOException if an I/O error occurs. + * @throws IOException if an I/O error occurs. * @throws SerializationException if a format-specific serialization error occurs. */ protected abstract void doWriteStatements(Writer writer) throws IOException, SerializationException; @@ -124,7 +142,9 @@ protected void writeHeader(Writer writer) throws IOException { config.getLineEnding())); } - if (config.usePrefixes() && config.autoDeclarePrefixes()) { + if (config instanceof AbstractTFamilyConfig + && getTFamilyConfig().usePrefixes() + && getTFamilyConfig().autoDeclarePrefixes()) { collectUsedNamespaces(); } @@ -136,6 +156,8 @@ protected void writeHeader(Writer writer) throws IOException { * if auto-declaration is enabled and they are not already mapped. */ protected void collectUsedNamespaces() { + AbstractTFamilyConfig tFamilyConfig = getTFamilyConfig(); + Set namespaces = model.stream() .flatMap(stmt -> { List values = new ArrayList<>(Arrays.asList( @@ -170,9 +192,11 @@ protected void collectUsedNamespaces() { * @throws IOException if an I/O error occurs. */ protected void writePrefixDeclarations(Writer writer) throws IOException { + AbstractTFamilyConfig tFamilyConfig = getTFamilyConfig(); + List prefixes = new ArrayList<>(prefixToIriMapping.keySet()); - if (config.getPrefixOrdering() == PrefixOrderingEnum.ALPHABETICAL) { + if (tFamilyConfig.getPrefixOrdering() == PrefixOrderingEnum.ALPHABETICAL) { Collections.sort(prefixes); } @@ -213,7 +237,9 @@ protected void writeSimpleStatements(Writer writer) throws IOException { * @throws IOException if an I/O error occurs. */ protected void writeStatement(Writer writer, Statement stmt) throws IOException { - String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; + AbstractTFamilyConfig tFamilyConfig = getTFamilyConfig(); + + String indent = tFamilyConfig.prettyPrint() ? tFamilyConfig.getIndent() : SerializationConstants.EMPTY_STRING; writer.write(indent); // Subject @@ -239,7 +265,8 @@ protected void writeStatement(Writer writer, Statement stmt) throws IOException * @throws IOException if an I/O error occurs. */ protected void writePredicate(Writer writer, Value predicate) throws IOException { - if (config.useRdfTypeShortcut() && predicate.stringValue().equals(SerializationConstants.RDF_TYPE)) { + AbstractTFamilyConfig tFamilyConfig = getTFamilyConfig(); + if (tFamilyConfig.useRdfTypeShortcut() && predicate.stringValue().equals(SerializationConstants.RDF_TYPE)) { writer.write(SerializationConstants.RDF_TYPE_SHORTCUT); } else { writeValue(writer, predicate); @@ -274,11 +301,11 @@ protected void writeValue(Writer writer, Value value) throws IOException { currentlyWritingBlankNodes.add(bNode); boolean handled = false; - if (config.useCollections() && bNode.isBNode()) { + if (config instanceof AbstractTFamilyConfig && getTFamilyConfig().useCollections() && bNode.isBNode()) { handled = writeRDFList(writer, bNode); } - if (!handled && config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS && bNode.isBNode()) { + if (!handled && config instanceof AbstractTFamilyConfig && getTFamilyConfig().getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS && bNode.isBNode()) { // getBlankNodeStyle is on AbstractTFamilyConfig List properties = model.stream() .filter(stmt -> stmt.getSubject().equals(bNode)) .toList(); @@ -312,7 +339,11 @@ protected void writeIRI(Writer writer, IRI iri) throws IOException { validateIRI(iri); } - String prefixed = config.usePrefixes() ? getPrefixedName(iri.stringValue()) : null; + String prefixed = null; + if (config instanceof AbstractTFamilyConfig && getTFamilyConfig().usePrefixes()) { + prefixed = getPrefixedName(iri.stringValue()); + } + if (prefixed != null) { writer.write(prefixed); @@ -332,7 +363,13 @@ protected void writeIRI(Writer writer, IRI iri) throws IOException { protected void writeLiteral(Writer writer, Literal literal) throws IOException { String value = literal.stringValue(); - if (config.shouldUseTripleQuotes(value)) { + boolean useTripleQuotes = false; + if (config instanceof AbstractTFamilyConfig) { + useTripleQuotes = getTFamilyConfig().shouldUseTripleQuotes(value); + } + + + if (useTripleQuotes) { writer.write(String.format("\"\"\"%s\"\"\"", escapeMultilineLiteralString(value))); } else { writer.write(String.format("\"%s\"", escapeLiteralString(value))); @@ -394,8 +431,10 @@ protected boolean shouldWriteDatatype(Literal literal) { * @throws IOException if an I/O error occurs. */ protected void writeInlineBlankNode(Writer writer, List properties) throws IOException { - String currentIndent = config.prettyPrint() ? config.getIndent() : ""; - String propIndent = config.prettyPrint() ? currentIndent + config.getIndent() : ""; + AbstractTFamilyConfig tFamilyConfig = getTFamilyConfig(); + + String currentIndent = tFamilyConfig.prettyPrint() ? tFamilyConfig.getIndent() : SerializationConstants.EMPTY_STRING; + String propIndent = tFamilyConfig.prettyPrint() ? currentIndent + tFamilyConfig.getIndent() : ""; writer.write(SerializationConstants.BLANK_NODE_START); @@ -411,7 +450,7 @@ protected void writeInlineBlankNode(Writer writer, List properties) t } firstProperty = false; - if (config.prettyPrint()) { + if (tFamilyConfig.prettyPrint()) { writer.write(config.getLineEnding() + propIndent); } else { writer.write(SerializationConstants.SPACE); @@ -422,7 +461,7 @@ protected void writeInlineBlankNode(Writer writer, List properties) t writeValue(writer, stmt.getObject()); } - if (config.prettyPrint() && !properties.isEmpty() && !firstProperty) { + if (tFamilyConfig.prettyPrint() && !properties.isEmpty() && !firstProperty) { writer.write(config.getLineEnding() + currentIndent); } @@ -438,7 +477,9 @@ protected void writeInlineBlankNode(Writer writer, List properties) t * @throws IOException if an I/O error occurs. */ protected void writeOptimizedStatements(Writer writer) throws IOException { - Map> bySubject = config.sortSubjects() ? + AbstractTFamilyConfig tFamilyConfig = getTFamilyConfig(); + + Map> bySubject = tFamilyConfig.sortSubjects() ? new TreeMap<>(Comparator.comparing(Resource::stringValue)) : new LinkedHashMap<>(); @@ -447,12 +488,12 @@ protected void writeOptimizedStatements(Writer writer) throws IOException { .forEach(stmt -> bySubject.computeIfAbsent(stmt.getSubject(), k -> new ArrayList<>()).add(stmt)); for (Map.Entry> subjectEntry : bySubject.entrySet()) { - String indent = config.prettyPrint() ? config.getIndent() : SerializationConstants.EMPTY_STRING; + String indent = tFamilyConfig.prettyPrint() ? tFamilyConfig.getIndent() : SerializationConstants.EMPTY_STRING; writer.write(indent); writeValue(writer, subjectEntry.getKey()); writer.write(SerializationConstants.SPACE); - Map> byPredicate = config.sortPredicates() ? + Map> byPredicate = tFamilyConfig.sortPredicates() ? new TreeMap<>(Comparator.comparing(IRI::stringValue)) : new LinkedHashMap<>(); @@ -462,8 +503,8 @@ protected void writeOptimizedStatements(Writer writer) throws IOException { for (Map.Entry> predicateEntry : byPredicate.entrySet()) { if (!firstPredicate) { writer.write(SerializationConstants.SEMICOLON); - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + indent + config.getIndent()); + if (tFamilyConfig.prettyPrint()) { + writer.write(config.getLineEnding() + indent + tFamilyConfig.getIndent()); } else { writer.write(SerializationConstants.SPACE); } @@ -477,8 +518,8 @@ protected void writeOptimizedStatements(Writer writer) throws IOException { for (Statement stmt : predicateEntry.getValue()) { if (!firstObject) { writer.write(SerializationConstants.COMMA); - if (config.prettyPrint()) { - writer.write(config.getLineEnding() + indent + config.getIndent() + config.getIndent()); + if (tFamilyConfig.prettyPrint()) { + writer.write(config.getLineEnding() + indent + tFamilyConfig.getIndent() + tFamilyConfig.getIndent()); } else { writer.write(SerializationConstants.SPACE); } @@ -504,6 +545,8 @@ protected void writeOptimizedStatements(Writer writer) throws IOException { * @throws IOException if an I/O error occurs. */ protected boolean writeRDFList(Writer writer, Resource listHead) throws IOException { + AbstractTFamilyConfig tFamilyConfig = getTFamilyConfig(); + List items = new ArrayList<>(); Resource current = listHead; Set listBlankNodes = new HashSet<>(); @@ -591,11 +634,13 @@ protected boolean isConsumed(Value value) { * @return A {@link Set} of {@link Resource} representing the blank nodes that will be serialized inline. */ protected Set precomputeInlineBlankNodesAndLists() { + AbstractTFamilyConfig tFamilyConfig = getTFamilyConfig(); + Set precomputed = new HashSet<>(); for (Statement stmt : model) { if (stmt.getSubject().isBNode()) { Resource bNodeSubject = stmt.getSubject(); - if (config.useCollections() && isRDFListHead(bNodeSubject)) { + if (tFamilyConfig.useCollections() && isRDFListHead(bNodeSubject)) { Resource current = bNodeSubject; Set listNodes = new HashSet<>(); Set visitedInPrecomp = new HashSet<>(); @@ -641,7 +686,7 @@ protected Set precomputeInlineBlankNodesAndLists() { precomputed.addAll(listNodes); } } - if (config.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS) { + if (tFamilyConfig.getBlankNodeStyle() == BlankNodeStyleEnum.ANONYMOUS) { List properties = model.stream() .filter(s -> s.getSubject().equals(bNodeSubject)) .toList(); @@ -859,7 +904,7 @@ protected void validateValue(Value value) { * * @param literal The {@link Literal} to validate. * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, - * or rdf:langString literal without language tag). + * or rdf:langString literal without language tag). */ protected void validateLiteral(Literal literal) { IRI datatype = literal.getDatatype(); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java index 869c1d108..264501d26 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/base/AbstractLineBasedSerializer.java @@ -2,7 +2,8 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +// Changed import from SerializerConfig to AbstractSerializerConfig +import fr.inria.corese.core.next.impl.common.serialization.config.AbstractSerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; @@ -30,16 +31,16 @@ public abstract class AbstractLineBasedSerializer implements RdfSerializer { private static final Logger logger = LoggerFactory.getLogger(AbstractLineBasedSerializer.class); protected final Model model; - protected final SerializerConfig config; + protected final AbstractSerializerConfig config; /** * Constructs a new line-based serializer. * * @param model the {@link Model} to be serialized. Must not be null. - * @param config the {@link SerializerConfig} to use for serialization. Must not be null. + * @param config the {@link AbstractSerializerConfig} to use for serialization. Must not be null. * @throws NullPointerException if the provided model or config is null. */ - protected AbstractLineBasedSerializer(Model model, SerializerConfig config) { + protected AbstractLineBasedSerializer(Model model, AbstractSerializerConfig config) { this.model = Objects.requireNonNull(model, "Model cannot be null"); this.config = Objects.requireNonNull(config, "Configuration cannot be null"); } @@ -335,7 +336,7 @@ protected void validateValue(Value value) { * * @param literal The {@link Literal} to validate. * @throws IllegalArgumentException if the literal is invalid (e.g., language tag with wrong datatype, - * or rdf:langString literal missing a language tag). + * or rdf:langString literal missing a language tag). */ protected void validateLiteral(Literal literal) { IRI datatype = literal.getDatatype(); diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractNFamilyConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractNFamilyConfig.java new file mode 100644 index 000000000..34f6f3d61 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractNFamilyConfig.java @@ -0,0 +1,62 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +/** + * An abstract base class for serialization configurations of N-Family RDF formats (e.g., N-Triples, N-Quads). + * This class extends {@link AbstractSerializerConfig} and provides a common foundation + * for formats that typically have simpler, line-based structures and specific default behaviors + * regarding literal datatypes and character escaping. + * + *

    It enforces the use of the Builder pattern for construction through its + * nested {@link AbstractNFamilyBuilder}. Subclasses are expected to extend this + * configuration and its builder to add format-specific options.

    + */ +public abstract class AbstractNFamilyConfig extends AbstractSerializerConfig { + + /** + * Protected constructor to be used by concrete builder implementations. + * Initializes the N-Family serialization configuration options, calling the superclass + * constructor for common options. + * + * @param builder The builder instance containing the desired configuration values. + */ + protected AbstractNFamilyConfig(AbstractNFamilyBuilder builder) { + super(builder); + } + + /** + * An abstract base builder for {@link AbstractNFamilyConfig}. + * This builder provides methods for setting N-Family serialization configuration options. + * It extends {@link AbstractSerializerConfig.AbstractBuilder} and uses a recursive type + * parameter (`S`) to allow concrete subclass builders to return their own specific type, + * enabling fluent API chaining. + * + *

    By default, it sets {@code literalDatatypePolicy} to {@link LiteralDatatypePolicyEnum#ALWAYS_TYPED} + * and {@code escapeUnicode} to {@code true}, which are common characteristics of N-Family formats.

    + * + * @param The type of the concrete builder extending this abstract builder. + */ + public abstract static class AbstractNFamilyBuilder> + extends AbstractSerializerConfig.AbstractBuilder { + + /** + * Default constructor for the builder. + * Initializes common N-Family specific defaults: + *
      + *
    • {@code literalDatatypePolicy} is set to {@link LiteralDatatypePolicyEnum#ALWAYS_TYPED}.
      • + *
    • {@code escapeUnicode} is set to {@code true}.
      • + *
    + */ + protected AbstractNFamilyBuilder() { + super.literalDatatypePolicy = LiteralDatatypePolicyEnum.ALWAYS_TYPED; + super.escapeUnicode = true; + } + + /** + * Builds and returns a new {@link AbstractNFamilyConfig} instance with the current builder settings. + * This method must be implemented by concrete builder subclasses to return their specific configuration type. + * + * @return A new {@code AbstractNFamilyConfig} instance or a subclass instance. + */ + public abstract AbstractNFamilyConfig build(); + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractSerializerConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractSerializerConfig.java new file mode 100644 index 000000000..6ed99d68e --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractSerializerConfig.java @@ -0,0 +1,310 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +import fr.inria.corese.core.next.api.SerializationConfig; +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; + +import java.util.Objects; + +/** + * An abstract base class for all RDF serialization configurations. + * This class defines common configuration parameters that are applicable across various + * RDF serialization formats (e.g., N-Triples, Turtle, RDF/XML). + * + *

    It enforces the use of the Builder pattern for construction through its + * nested {@link AbstractBuilder}. Subclasses are expected to extend this + * configuration and its builder to add format-specific options.

    + */ +public abstract class AbstractSerializerConfig implements SerializationConfig { + + /** + * The policy for how literal datatypes are printed. + * This determines whether datatypes are always explicit, minimal, or follow specific rules. + */ + protected final LiteralDatatypePolicyEnum literalDatatypePolicy; + /** + * Whether non-ASCII characters should be escaped using Unicode escape sequences (e.g., `\ u00E9`). + * This ensures compatibility with systems that might not handle UTF-8 correctly, but makes output less human-readable. + */ + protected final boolean escapeUnicode; + /** + * Whether a dot `.` should be added at the end of each triple block or statement. + * This is a syntax requirement for some RDF serialization formats (e.g., Turtle, N-Triples). + */ + protected final boolean trailingDot; + /** + * The base IRI to be used for the serialization. + * This allows relative IRIs to be resolved and can shorten the output by avoiding full IRIs. + * Can be {@code null} if no base IRI is specified. + */ + protected final String baseIRI; + /** + * Whether deterministic blank node IDs (e.g., `_:b0`, `_:b1`) should be generated. + * This is crucial for reproducible outputs, especially in testing environments, as blank node IDs are typically random. + */ + protected final boolean stableBlankNodeIds; + /** + * The string used for line endings (e.g., `"\n"` for Unix, `"\r\n"` for Windows). + * This ensures that the generated file has correct line endings for the target operating system. + */ + protected final String lineEnding; + + /** + * General strictness setting for validation during serialization. + * Enabling this can catch errors or non-standard RDF constructs but might reject valid, less common patterns. + */ + protected final boolean strictMode; + /** + * Whether URIs should be validated for compliance with RDF/Turtle/N-Triples rules. + * This ensures that generated URIs are valid and will be correctly parsed by other tools. + */ + protected final boolean validateURIs; + /** + * Whether context information (named graphs) should be included in the serialization output. + * This is essential for formats like N-Quads or TriG which support named graphs. + */ + protected final boolean includeContext; + + /** + * Protected constructor to be used by concrete builder implementations. + * Initializes the common serialization configuration options. + * + * @param builder The builder instance containing the desired configuration values. + * @throws NullPointerException if any required field from the builder is null. + */ + protected AbstractSerializerConfig(AbstractBuilder builder) { + this.literalDatatypePolicy = Objects.requireNonNull(builder.literalDatatypePolicy, "Literal datatype policy cannot be null"); + this.escapeUnicode = builder.escapeUnicode; + this.trailingDot = builder.trailingDot; + this.baseIRI = builder.baseIRI; + this.stableBlankNodeIds = builder.stableBlankNodeIds; + this.lineEnding = Objects.requireNonNull(builder.lineEnding, "Line ending cannot be null"); + + this.strictMode = builder.strictMode; + this.validateURIs = builder.validateURIs; + this.includeContext = builder.includeContext; + } + + // --- Getters for common properties --- + + /** + * Returns the policy for how literal datatypes are printed. + * + * @return The {@link LiteralDatatypePolicyEnum} indicating the literal datatype serialization policy. + */ + public LiteralDatatypePolicyEnum getLiteralDatatypePolicy() { + return literalDatatypePolicy; + } + + /** + * Checks if non-ASCII characters should be escaped using Unicode escape sequences. + * + * @return {@code true} if Unicode escaping is enabled, {@code false} otherwise. + */ + public boolean escapeUnicode() { + return escapeUnicode; + } + + /** + * Checks if a dot `.` should be added at the end of each triple block or statement. + * + * @return {@code true} if a trailing dot is required, {@code false} otherwise. + */ + public boolean trailingDot() { + return trailingDot; + } + + /** + * Returns the base IRI to be used for the serialization. + * + * @return The base IRI string, or {@code null} if no base IRI is specified. + */ + public String getBaseIRI() { + return baseIRI; + } + + /** + * Checks if deterministic blank node IDs should be generated. + * + * @return {@code true} if stable blank node IDs are enabled, {@code false} otherwise. + */ + public boolean stableBlankNodeIds() { + return stableBlankNodeIds; + } + + /** + * Returns the string used for line endings. + * + * @return The line ending string (e.g., `"\n"` for Unix, `"\r\n"` for Windows). + */ + public String getLineEnding() { + return lineEnding; + } + + /** + * Checks if strict mode for validation is enabled. + * + * @return {@code true} if strict mode is enabled, {@code false} otherwise. + */ + public boolean isStrictMode() { + return strictMode; + } + + /** + * Checks if URIs should be validated for compliance with RDF/serialization rules. + * + * @return {@code true} if URI validation is enabled, {@code false} otherwise. + */ + public boolean validateURIs() { + return validateURIs; + } + + /** + * Checks if context information (named graphs) should be included in the serialization output. + * + * @return {@code true} if context inclusion is enabled, {@code false} otherwise. + */ + public boolean includeContext() { + return includeContext; + } + + /** + * An abstract base builder for {@link AbstractSerializerConfig}. + * This builder provides methods for setting common serialization configuration options. + * It uses a recursive type parameter (`S`) to allow concrete subclass builders + * to return their own specific type, enabling fluent API chaining. + * + * @param The type of the concrete builder extending this abstract builder. + */ + public abstract static class AbstractBuilder> { + protected LiteralDatatypePolicyEnum literalDatatypePolicy = LiteralDatatypePolicyEnum.MINIMAL; + protected boolean escapeUnicode = false; + protected boolean trailingDot = true; + protected String baseIRI = null; + protected boolean stableBlankNodeIds = false; + protected String lineEnding = SerializationConstants.DEFAULT_LINE_ENDING; + + protected boolean strictMode = true; + protected boolean validateURIs = true; + protected boolean includeContext = false; + + /** + * Sets the policy for how literal datatypes are printed. + * + * @param policy The {@link LiteralDatatypePolicyEnum} to set. Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided policy is null. + */ + public S literalDatatypePolicy(LiteralDatatypePolicyEnum policy) { + this.literalDatatypePolicy = Objects.requireNonNull(policy); + return self(); + } + + /** + * Sets whether non-ASCII characters should be escaped using Unicode escape sequences. + * + * @param escape {@code true} to enable Unicode escaping, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S escapeUnicode(boolean escape) { + this.escapeUnicode = escape; + return self(); + } + + /** + * Sets whether a dot `.` should be added at the end of each triple block or statement. + * + * @param trailing {@code true} to require a trailing dot, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S trailingDot(boolean trailing) { + this.trailingDot = trailing; + return self(); + } + + /** + * Sets the base IRI to be used for the serialization. + * + * @param base The base IRI string. Can be {@code null}. + * @return The builder instance for fluent chaining. + */ + public S baseIRI(String base) { + this.baseIRI = base; + return self(); + } + + /** + * Sets whether deterministic blank node IDs should be generated. + * + * @param stable {@code true} to enable stable blank node IDs, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S stableBlankNodeIds(boolean stable) { + this.stableBlankNodeIds = stable; + return self(); + } + + /** + * Sets the string used for line endings. + * + * @param lineEnding The line ending string (e.g., `"\n"` for Unix, `"\r\n"` for Windows). Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided line ending is null. + */ + public S lineEnding(String lineEnding) { + this.lineEnding = Objects.requireNonNull(lineEnding); + return self(); + } + + /** + * Sets the general strictness setting for validation during serialization. + * + * @param strict {@code true} to enable strict mode, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S strictMode(boolean strict) { + this.strictMode = strict; + return self(); + } + + /** + * Sets whether URIs should be validated for compliance with RDF/serialization rules. + * + * @param validate {@code true} to enable URI validation, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S validateURIs(boolean validate) { + this.validateURIs = validate; + return self(); + } + + /** + * Sets whether context information (named graphs) should be included in the serialization output. + * + * @param include {@code true} to include context information, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S includeContext(boolean include) { + this.includeContext = include; + return self(); + } + + /** + * Builds and returns a new {@link AbstractSerializerConfig} instance with the current builder settings. + * This method must be implemented by concrete builder subclasses to return their specific configuration type. + * + * @return A new {@code AbstractSerializerConfig} instance or a subclass instance. + */ + public abstract AbstractSerializerConfig build(); + + /** + * Helper method to return the concrete builder instance for fluent API chaining. + * This method is used internally by the builder methods to ensure that method calls + * return the correct subclass type, allowing for method chaining. + * + * @return The concrete builder instance. + */ + protected final S self() { + return (S) this; + } + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractTFamilyConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractTFamilyConfig.java new file mode 100644 index 000000000..4c22d8805 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/AbstractTFamilyConfig.java @@ -0,0 +1,525 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +/** + * An abstract base class for serialization configurations of Turtle Trig RDF formats (e.g., Turtle, TriG). + * This class extends {@link AbstractSerializerConfig} and introduces parameters specific to + * formats that utilize syntax sugar, pretty-printing, and collection syntax. + * + *

    It enforces the use of the Builder pattern for construction through its + * nested {@link AbstractTFamilyBuilder}. Subclasses are expected to extend this + * configuration and its builder to add format-specific options.

    + */ +public abstract class AbstractTFamilyConfig extends AbstractSerializerConfig { + + /** + * Whether prefix declarations (e.g., `@prefix`, `PREFIX`) should be used for compact IRIs. + * This is crucial for human-readable formats like Turtle but not for N-Triples. + */ + protected final boolean usePrefixes; + /** + * Whether the serializer should automatically discover and declare prefixes used in the graph. + * This avoids manual prefix configuration but can lead to more prefixes than strictly needed. + */ + protected final boolean autoDeclarePrefixes; + /** + * The policy for ordering prefix declarations (e.g., alphabetically, by usage, or custom). + * This impacts the determinism and readability of the prefix block. + */ + protected final PrefixOrderingEnum prefixOrdering; + /** + * A map of custom URI prefixes to be used for serialization, in addition to or instead of + * auto-declared prefixes. Useful for enforcing specific prefix names or when {@code autoDeclarePrefixes} is false. + */ + protected final Map customPrefixes; // Used for CUSTOM ordering or if autoDeclarePrefixes=false + /** + * Whether compact triple syntax (e.g., using ';' for subject/predicate reuse and ',' for object lists) + * should be used. This significantly reduces file size and improves readability for formats like Turtle. + */ + protected final boolean useCompactTriples; // Includes comma-separated objects and subject/predicate reuse via ';' + /** + * Whether the `a` shortcut should be used for `rdf:type` predicates. + * This is a common Turtle shorthand that improves conciseness and readability. + */ + protected final boolean useRdfTypeShortcut; // 'a' instead of 'rdf:type' + /** + * Whether Turtle collection syntax `( item1 item2 )` should be used for `rdf:List` structures. + * This provides a more idiomatic and readable representation of lists in Turtle. + */ + protected final boolean useCollections; // Turtle collection syntax ( ) + /** + * The preferred style for serializing blank nodes (e.g., `[]` vs `_:id`). + * This affects both the conciseness and the identifiability of blank nodes in the output. + */ + protected final BlankNodeStyleEnum blankNodeStyle; // [] vs _:id + /** + * Whether multi-line literal syntax (triple quotes `"""..."""`) should be used for literals + * containing newline characters. + */ + protected final boolean useMultilineLiterals; + + // --- Pretty-Printing Options --- + /** + * Whether human-readable formatting with indentation and newlines (pretty-printing) is enabled. + * This makes the output easier for humans to read and debug, but increases file size slightly. + */ + protected final boolean prettyPrint; + /** + * The string used for indentation (e.g., " ", "\t"). + * This defines the visual spacing for nested structures when pretty-printing. + */ + protected final String indent; + /** + * The maximum desired line length before the serializer attempts to break lines. + * This helps ensure readability by preventing very long lines in the output. + */ + protected final int maxLineLength; + /** + * Whether triples should be grouped by subject in the output (e.g., using ';' and '.'). + * This organizes the output logically around subjects, improving readability. + */ + protected final boolean groupBySubject; // Group triples by subject using ; and . + /** + * Whether subjects should be sorted alphabetically in the output. + * This ensures a consistent and reproducible order of subjects, useful for diffing or testing. + */ + protected final boolean sortSubjects; // Sort subjects alphabetically + /** + * Whether predicates should be sorted alphabetically within a subject group. + * This ensures a consistent and reproducible order of properties for a given subject. + */ + protected final boolean sortPredicates; // Sort predicates alphabetically within a subject group + + /** + * Protected constructor to be used by concrete builder implementations. + * Initializes the Turtle Trig serialization configuration options, calling the superclass + * constructor for common options. + * + * @param builder The builder instance containing the desired configuration values. + * @throws NullPointerException if any required field from the builder is null. + * @throws IllegalArgumentException if incompatible options (e.g., escapeUnicode and useMultilineLiterals) are enabled. + */ + protected AbstractTFamilyConfig(AbstractTFamilyBuilder builder) { + super(builder); + + this.usePrefixes = builder.usePrefixes; + this.autoDeclarePrefixes = builder.autoDeclarePrefixes; + this.prefixOrdering = Objects.requireNonNull(builder.prefixOrdering, "Prefix ordering cannot be null"); + this.customPrefixes = Collections.unmodifiableMap(new HashMap<>(Objects.requireNonNull(builder.customPrefixes, "Custom prefixes map cannot be null"))); + this.useCompactTriples = builder.useCompactTriples; + this.useRdfTypeShortcut = builder.useRdfTypeShortcut; + this.useCollections = builder.useCollections; + this.blankNodeStyle = Objects.requireNonNull(builder.blankNodeStyle, "Blank node style cannot be null"); + this.useMultilineLiterals = builder.useMultilineLiterals; + + this.prettyPrint = builder.prettyPrint; + this.indent = Objects.requireNonNull(builder.indent, "Indentation string cannot be null"); + this.maxLineLength = builder.maxLineLength; + this.groupBySubject = builder.groupBySubject; + this.sortSubjects = builder.sortSubjects; + this.sortPredicates = builder.sortPredicates; + + if (this.escapeUnicode() && this.useMultilineLiterals) { + throw new IllegalArgumentException("Cannot enable both escapeUnicode and useMultilineLiterals in Turtle TriG configs."); + } + } + + + /** + * Checks if prefix declarations should be used for compact IRIs. + * + * @return {@code true} if prefixes are used, {@code false} otherwise. + */ + public boolean usePrefixes() { + return usePrefixes; + } + + /** + * Checks if the serializer should automatically discover and declare prefixes. + * + * @return {@code true} if auto-declaration is enabled, {@code false} otherwise. + */ + public boolean autoDeclarePrefixes() { + return autoDeclarePrefixes; + } + + /** + * Returns the policy for ordering prefix declarations. + * + * @return The {@link PrefixOrderingEnum} for prefix ordering. + */ + public PrefixOrderingEnum getPrefixOrdering() { + return prefixOrdering; + } + + /** + * Returns an unmodifiable map of custom URI prefixes. + * + * @return A map where keys are prefix names and values are namespace URIs. + */ + public Map getCustomPrefixes() { + return customPrefixes; + } + + /** + * Checks if compact triple syntax (using ';' and ',') should be used. + * + * @return {@code true} if compact triples are enabled, {@code false} otherwise. + */ + public boolean useCompactTriples() { + return useCompactTriples; + } + + /** + * Checks if the `a` shortcut should be used for `rdf:type` predicates. + * + * @return {@code true} if the `a` shortcut is enabled, {@code false} otherwise. + */ + public boolean useRdfTypeShortcut() { + return useRdfTypeShortcut; + } + + /** + * Checks if Turtle collection syntax `( item1 item2 )` should be used for `rdf:List` structures. + * + * @return {@code true} if collection syntax is enabled, {@code false} otherwise. + */ + public boolean useCollections() { + return useCollections; + } + + /** + * Returns the preferred style for serializing blank nodes. + * + * @return The {@link BlankNodeStyleEnum} for blank node serialization. + */ + public BlankNodeStyleEnum getBlankNodeStyle() { + return blankNodeStyle; + } + + /** + * Checks if multi-line literal syntax (triple quotes) should be used. + * + * @return {@code true} if multi-line literals are enabled, {@code false} otherwise. + */ + public boolean useMultilineLiterals() { + return useMultilineLiterals; + } + + /** + * Checks if human-readable formatting (pretty-printing) is enabled. + * + * @return {@code true} if pretty-printing is enabled, {@code false} otherwise. + */ + public boolean prettyPrint() { + return prettyPrint; + } + + /** + * Returns the string used for indentation when pretty-printing. + * + * @return The indentation string. + */ + public String getIndent() { + return indent; + } + + /** + * Returns the maximum desired line length before the serializer attempts to break lines. + * + * @return The maximum line length. + */ + public int getMaxLineLength() { + return maxLineLength; + } + + /** + * Checks if triples should be grouped by subject in the output. + * + * @return {@code true} if grouping by subject is enabled, {@code false} otherwise. + */ + public boolean groupBySubject() { + return groupBySubject; + } + + /** + * Checks if subjects should be sorted alphabetically in the output. + * + * @return {@code true} if subject sorting is enabled, {@code false} otherwise. + */ + public boolean sortSubjects() { + return sortSubjects; + } + + /** + * Checks if predicates should be sorted alphabetically within a subject group. + * + * @return {@code true} if predicate sorting is enabled, {@code false} otherwise. + */ + public boolean sortPredicates() { + return sortPredicates; + } + + /** + * Determines if triple quotes should be used for a given literal value. + * This is typically true if multi-line literals are enabled and the value contains newline characters. + * + * @param literalValue The string value of the literal. + * @return {@code true} if triple quotes should be used, {@code false} otherwise. + */ + public boolean shouldUseTripleQuotes(String literalValue) { + return useMultilineLiterals && (literalValue.contains(SerializationConstants.LINE_FEED) || literalValue.contains(SerializationConstants.CARRIAGE_RETURN)); + } + + /** + * Checks if output optimization features (compact triples, subject grouping, pretty-printing) are enabled. + * + * @return {@code true} if any optimization feature is enabled, {@code false} otherwise. + */ + public boolean shouldOptimizeOutput() { + return useCompactTriples || groupBySubject || prettyPrint; + } + + /** + * Checks if inline blank node syntax (`[]`) should be used. + * This is typically true if anonymous blank node style is chosen and compact triples are enabled. + * + * @return {@code true} if inline blank nodes should be used, {@code false} otherwise. + */ + public boolean shouldUseInlineBlankNodes() { + return blankNodeStyle == BlankNodeStyleEnum.ANONYMOUS && useCompactTriples; + } + + /** + * An abstract base builder for {@link AbstractTFamilyConfig}. + * This builder provides methods for setting Turtle Trig serialization configuration options. + * It extends {@link AbstractSerializerConfig.AbstractBuilder} and uses a recursive type + * parameter (`S`) to allow concrete subclass builders to return their own specific type, + * enabling fluent API chaining. + * + * @param The type of the concrete builder extending this abstract builder. + */ + public abstract static class AbstractTFamilyBuilder> + extends AbstractSerializerConfig.AbstractBuilder { + + protected boolean usePrefixes = true; + protected boolean autoDeclarePrefixes = true; + protected PrefixOrderingEnum prefixOrdering = PrefixOrderingEnum.ALPHABETICAL; + protected final Map customPrefixes = new HashMap<>(); + + protected boolean useCompactTriples = true; + protected boolean useRdfTypeShortcut = true; + // Default to false for complexity, specific formats can override + protected boolean useCollections = false; + // Default to NAMED (safer for initial impl), specific formats can override + protected BlankNodeStyleEnum blankNodeStyle = BlankNodeStyleEnum.NAMED; + protected boolean useMultilineLiterals = true; + + // Pretty-Printing Defaults + protected boolean prettyPrint = true; + protected String indent = SerializationConstants.DEFAULT_INDENTATION; + protected int maxLineLength = 80; + protected boolean groupBySubject = true; + protected boolean sortSubjects = false; + protected boolean sortPredicates = false; + + /** + * Sets whether prefix declarations should be used for compact IRIs. + * + * @param usePrefixes {@code true} to use prefixes, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S usePrefixes(boolean usePrefixes) { + this.usePrefixes = usePrefixes; + return self(); + } + + /** + * Sets whether the serializer should automatically discover and declare prefixes. + * + * @param autoDeclarePrefixes {@code true} to enable auto-declaration, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S autoDeclarePrefixes(boolean autoDeclarePrefixes) { + this.autoDeclarePrefixes = autoDeclarePrefixes; + return self(); + } + + /** + * Sets the policy for ordering prefix declarations. + * + * @param prefixOrdering The {@link PrefixOrderingEnum} to set. Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided policy is null. + */ + public S prefixOrdering(PrefixOrderingEnum prefixOrdering) { + this.prefixOrdering = Objects.requireNonNull(prefixOrdering); + return self(); + } + + /** + * Adds a custom prefix mapping to be used for serialization. + * + * @param prefix The prefix name (e.g., "ex"). Must not be null. + * @param namespace The namespace URI (e.g., "http://example.org/"). Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if prefix or namespace is null. + */ + public S addCustomPrefix(String prefix, String namespace) { + Objects.requireNonNull(prefix, "Prefix name cannot be null"); + Objects.requireNonNull(namespace, "Namespace URI cannot be null"); + this.customPrefixes.put(prefix, namespace); + return self(); + } + + /** + * Adds multiple custom prefix mappings from a map. + * + * @param prefixes A map of prefix names to namespace URIs. Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided map is null. + */ + public S addCustomPrefixes(Map prefixes) { + Objects.requireNonNull(prefixes, "Prefixes map cannot be null"); + this.customPrefixes.putAll(prefixes); + return self(); + } + + /** + * Sets whether compact triple syntax (using ';' and ',') should be used. + * + * @param useCompactTriples {@code true} to enable compact triples, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S useCompactTriples(boolean useCompactTriples) { + this.useCompactTriples = useCompactTriples; + return self(); + } + + /** + * Sets whether the `a` shortcut should be used for `rdf:type` predicates. + * + * @param useRdfTypeShortcut {@code true} to enable the `a` shortcut, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S useRdfTypeShortcut(boolean useRdfTypeShortcut) { + this.useRdfTypeShortcut = useRdfTypeShortcut; + return self(); + } + + /** + * Sets whether Turtle collection syntax `( item1 item2 )` should be used for `rdf:List` structures. + * + * @param useCollections {@code true} to enable collection syntax, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S useCollections(boolean useCollections) { + this.useCollections = useCollections; + return self(); + } + + /** + * Sets the preferred style for serializing blank nodes. + * + * @param blankNodeStyle The {@link BlankNodeStyleEnum} to set. Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided style is null. + */ + public S blankNodeStyle(BlankNodeStyleEnum blankNodeStyle) { + this.blankNodeStyle = Objects.requireNonNull(blankNodeStyle); + return self(); + } + + /** + * Sets whether multi-line literal syntax (triple quotes) should be used. + * + * @param useMultilineLiterals {@code true} to enable multi-line literals, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S useMultilineLiterals(boolean useMultilineLiterals) { + this.useMultilineLiterals = useMultilineLiterals; + return self(); + } + + /** + * Sets whether human-readable formatting (pretty-printing) is enabled. + * + * @param prettyPrint {@code true} to enable pretty-printing, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S prettyPrint(boolean prettyPrint) { + this.prettyPrint = prettyPrint; + return self(); + } + + /** + * Sets the string used for indentation when pretty-printing. + * + * @param indent The indentation string. Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided indent string is null. + */ + public S indent(String indent) { + this.indent = Objects.requireNonNull(indent); + return self(); + } + + /** + * Sets the maximum desired line length before the serializer attempts to break lines. + * + * @param maxLineLength The maximum line length. + * @return The builder instance for fluent chaining. + */ + public S maxLineLength(int maxLineLength) { + this.maxLineLength = maxLineLength; + return self(); + } + + /** + * Sets whether triples should be grouped by subject in the output. + * + * @param groupBySubject {@code true} to enable grouping by subject, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S groupBySubject(boolean groupBySubject) { + this.groupBySubject = groupBySubject; + return self(); + } + + /** + * Sets whether subjects should be sorted alphabetically in the output. + * + * @param sortSubjects {@code true} to enable subject sorting, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S sortSubjects(boolean sortSubjects) { + this.sortSubjects = sortSubjects; + return self(); + } + + /** + * Sets whether predicates should be sorted alphabetically within a subject group. + * + * @param sortPredicates {@code true} to enable predicate sorting, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public S sortPredicates(boolean sortPredicates) { + this.sortPredicates = sortPredicates; + return self(); + } + + /** + * Builds and returns a new {@link AbstractTFamilyConfig} instance with the current builder settings. + * This method must be implemented by concrete builder subclasses to return their specific configuration type. + * + * @return A new {@code AbstractTFamilyConfig} instance or a subclass instance. + */ + public abstract AbstractTFamilyConfig build(); + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfig.java new file mode 100644 index 000000000..9a9d69058 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfig.java @@ -0,0 +1,66 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +/** + * Configuration for N-Quads serialization format. + * This class extends {@link AbstractNFamilyConfig} and provides specific defaults + * and options tailored for N-Quads, which extends N-Triples with named graphs. + * + *

    Use the {@link Builder} class to create instances of {@code NQuadsConfig}. + * A predefined default configuration is available via {@link #defaultConfig()}.

    + */ +public class NQuadsConfig extends AbstractNFamilyConfig { + + /** + * Protected constructor to be used by the {@link Builder}. + * + * @param builder The builder instance containing the desired configuration values. + */ + protected NQuadsConfig(Builder builder) { + super(builder); + } + + /** + * Public Builder for {@link NQuadsConfig}. + * Provides a fluent API for constructing {@code NQuadsConfig} instances with default values + * specific to the N-Quads format. + */ + public static class Builder extends AbstractNFamilyConfig.AbstractNFamilyBuilder { + /** + * Default constructor initializes all options with their default values for N-Quads. + */ + public Builder() { + includeContext(true); + } + + /** + * Builds and returns a new {@link NQuadsConfig} instance with the current builder settings. + * + * @return A new {@code NQuadsConfig} instance. + */ + @Override + public NQuadsConfig build() { + return new NQuadsConfig(this); + } + } + + /** + * Returns a default configuration suitable for N-Quads serialization. + * This provides a convenient way to get a standard N-Quads configuration without + * manually building it. + * + * @return A {@code NQuadsConfig} instance with default settings. + */ + public static NQuadsConfig defaultConfig() { + return new Builder().build(); + } + + /** + * Returns a new builder instance for {@link NQuadsConfig}. + * This allows for fluent construction of custom N-Quads configurations. + * + * @return A new {@code Builder} instance. + */ + public static Builder builder() { + return new Builder(); + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfig.java new file mode 100644 index 000000000..b3818ed50 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfig.java @@ -0,0 +1,67 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +/** + * Configuration for N-Triples serialization format. + * This class extends {@link AbstractNFamilyConfig} and provides specific defaults + * and options tailored for N-Triples, which is a simple, line-oriented format. + * + *

    Use the {@link Builder} class to create instances of {@code NTriplesConfig}. + * A predefined default configuration is available via {@link #defaultConfig()}.

    + */ +public class NTriplesConfig extends AbstractNFamilyConfig { + + /** + * Protected constructor to be used by the {@link Builder}. + * + * @param builder The builder instance containing the desired configuration values. + */ + protected NTriplesConfig(Builder builder) { + super(builder); + } + + /** + * Public Builder for {@link NTriplesConfig}. + * Provides a fluent API for constructing {@code NTriplesConfig} instances with default values + * specific to the N-Triples format. + */ + public static class Builder extends AbstractNFamilyConfig.AbstractNFamilyBuilder { + /** + * Default constructor initializes all options with their default values for N-Triples. + */ + public Builder() { + + includeContext(false); + } + + /** + * Builds and returns a new {@link NTriplesConfig} instance with the current builder settings. + * + * @return A new {@code NTriplesConfig} instance. + */ + @Override + public NTriplesConfig build() { + return new NTriplesConfig(this); + } + } + + /** + * Returns a default configuration suitable for N-Triples serialization. + * This provides a convenient way to get a standard N-Triples configuration without + * manually building it. + * + * @return A {@code NTriplesConfig} instance with default settings. + */ + public static NTriplesConfig defaultConfig() { + return new Builder().build(); + } + + /** + * Returns a new builder instance for {@link NTriplesConfig}. + * This allows for fluent construction of custom N-Triples configurations. + * + * @return A new {@code Builder} instance. + */ + public static NTriplesConfig.Builder builder() { + return new NTriplesConfig.Builder(); + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/SerializerConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/SerializerConfig.java deleted file mode 100644 index b888abd2a..000000000 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/SerializerConfig.java +++ /dev/null @@ -1,682 +0,0 @@ -package fr.inria.corese.core.next.impl.common.serialization.config; - -import fr.inria.corese.core.next.api.SerializationConfig; -import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; - -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Objects; - -/** - * Configuration for RDF serialization formats (Turtle, TriG, N-Triples, N-Quads, XML). - * This class provides a comprehensive set of options to control the output - * syntax, pretty-printing, and technical aspects of RDF serialization. - * - *

    Use the {@link Builder} class to create instances of {@code SerializerConfig}. - * Predefined configurations for common RDF formats are available via static methods - * like {@link #ntriplesConfig()}, {@link #nquadsConfig()}, {@link #turtleConfig()}, etc.

    - */ -public class SerializerConfig implements SerializationConfig { - - /** - * Whether prefix declarations (e.g., `@prefix`, `PREFIX`) should be used for compact IRIs. - * This is crucial for human-readable formats like Turtle but not for N-Triples. - */ - private final boolean usePrefixes; - /** - * Whether the serializer should automatically discover and declare prefixes used in the graph. - * This avoids manual prefix configuration but can lead to more prefixes than strictly needed. - */ - private final boolean autoDeclarePrefixes; - /** - * The policy for ordering prefix declarations (e.g., alphabetically, by usage, or custom). - * This impacts the determinism and readability of the prefix block. - */ - private final PrefixOrderingEnum prefixOrdering; - /** - * A map of custom URI prefixes to be used for serialization, in addition to or instead of - * auto-declared prefixes. Useful for enforcing specific prefix names or when {@code autoDeclarePrefixes} is false. - */ - private final Map customPrefixes; // Used for CUSTOM ordering or if autoDeclarePrefixes=false - - /** - * Whether compact triple syntax (e.g., using ';' for subject/predicate reuse and ',' for object lists) - * should be used. This significantly reduces file size and improves readability for formats like Turtle. - */ - private final boolean useCompactTriples; // Includes comma-separated objects and subject/predicate reuse via ';' - /** - * Whether the `a` shortcut should be used for `rdf:type` predicates. - * This is a common Turtle shorthand that improves conciseness and readability. - */ - private final boolean useRdfTypeShortcut; // 'a' instead of 'rdf:type' - /** - * Whether Turtle collection syntax `( item1 item2 )` should be used for `rdf:List` structures. - * This provides a more idiomatic and readable representation of lists in Turtle. - */ - private final boolean useCollections; // Turtle collection syntax ( ) - /** - * The preferred style for serializing blank nodes (e.g., `[]` vs `_:id`). - * This affects both the conciseness and the identifiability of blank nodes in the output. - */ - private final BlankNodeStyleEnum blankNodeStyle; // [] vs _:id - - // --- Pretty-Printing Options --- - /** - * Whether human-readable formatting with indentation and newlines (pretty-printing) is enabled. - * This makes the output easier for humans to read and debug, but increases file size slightly. - */ - private final boolean prettyPrint; - /** - * The string used for indentation (e.g., " ", "\t"). - * This defines the visual spacing for nested structures when pretty-printing. - */ - private final String indent; - /** - * The maximum desired line length before the serializer attempts to break lines. - * This helps ensure readability by preventing very long lines in the output. - */ - private final int maxLineLength; - /** - * Whether triples should be grouped by subject in the output (e.g., using ';' and '.'). - * This organizes the output logically around subjects, improving readability. - */ - private final boolean groupBySubject; // Group triples by subject using ; and . - /** - * Whether subjects should be sorted alphabetically in the output. - * This ensures a consistent and reproducible order of subjects, useful for diffing or testing. - */ - private final boolean sortSubjects; // Sort subjects alphabetically - /** - * Whether predicates should be sorted alphabetically within a subject group. - * This ensures a consistent and reproducible order of properties for a given subject. - */ - private final boolean sortPredicates; // Sort predicates alphabetically within a subject group - - // --- Technical Output Options --- - /** - * The policy for how literal datatypes are printed. - * This determines whether datatypes are always explicit, minimal, or follow specific rules. - */ - private final LiteralDatatypePolicyEnum literalDatatypePolicy; - /** - * Whether non-ASCII characters should be escaped using Unicode escape sequences (e.g., `\ u00E9`). - * This ensures compatibility with systems that might not handle UTF-8 correctly, but makes output less human-readable. - */ - private final boolean escapeUnicode; // XXXX for non-ASCII - /** - * Whether a dot `.` should be added at the end of each triple block or statement. - * This is a syntax requirement for some RDF serialization formats (e.g., Turtle, N-Triples). - */ - private final boolean trailingDot; // Add a dot '.' at the end of each triple block - /** - * The base IRI to be used for the serialization. - * This allows relative IRIs to be resolved and can shorten the output by avoiding full IRIs. - */ - private final String baseIRI; // @base directive - /** - * Whether deterministic blank node IDs (e.g., `_:b0`, `_:b1`) should be generated. - * This is crucial for reproducible outputs, especially in testing environments, as blank node IDs are typically random. - */ - private final boolean stableBlankNodeIds; // Generate deterministic _:bids - - // --- Validation & Context Options --- - /** - * General strictness setting for validation during serialization. - * Enabling this can catch errors or non-standard RDF constructs but might reject valid, less common patterns. - */ - private final boolean strictMode; // General strictness for validation - /** - * Whether URIs should be validated for compliance with RDF/Turtle/N-Triples rules. - * This ensures that generated URIs are valid and will be correctly parsed by other tools. - */ - private final boolean validateURIs; // Specific URI validation - /** - * Whether context information (named graphs) should be included in the serialization output. - * This is essential for formats like N-Quads or TriG which support named graphs. - */ - private final boolean includeContext; // For N-Quads (control writing the 4th element) - /** - * The string used for line endings (e.g., `"\n"` for Unix, `"\r\n"` for Windows). - * This ensures that the generated file has correct line endings for the target operating system. - */ - private final String lineEnding; - - - private final boolean useMultilineLiterals; - - /** - * Private constructor to enforce usage of the Builder. - * - * @param builder The builder instance. - */ - private SerializerConfig(Builder builder) { - - this.usePrefixes = builder.usePrefixes; - this.autoDeclarePrefixes = builder.autoDeclarePrefixes; - this.prefixOrdering = Objects.requireNonNull(builder.prefixOrdering, "Prefix ordering cannot be null"); - this.customPrefixes = Collections.unmodifiableMap(new HashMap<>(Objects.requireNonNull(builder.customPrefixes, "Custom prefixes map cannot be null"))); - - this.useCompactTriples = builder.useCompactTriples; - this.useRdfTypeShortcut = builder.useRdfTypeShortcut; - this.useCollections = builder.useCollections; - this.blankNodeStyle = Objects.requireNonNull(builder.blankNodeStyle, "Blank node style cannot be null"); - - // Pretty-Printing - this.prettyPrint = builder.prettyPrint; - this.indent = Objects.requireNonNull(builder.indent, "Indentation string cannot be null"); - this.maxLineLength = builder.maxLineLength; - this.groupBySubject = builder.groupBySubject; - this.sortSubjects = builder.sortSubjects; - this.sortPredicates = builder.sortPredicates; - - // Technical Output - this.literalDatatypePolicy = Objects.requireNonNull(builder.literalDatatypePolicy, "Literal datatype policy cannot be null"); - this.escapeUnicode = builder.escapeUnicode; - this.trailingDot = builder.trailingDot; - this.baseIRI = builder.baseIRI; // Can be null - this.stableBlankNodeIds = builder.stableBlankNodeIds; - - // Validation & Context - this.strictMode = builder.strictMode; - this.validateURIs = builder.validateURIs; - this.includeContext = builder.includeContext; - this.lineEnding = Objects.requireNonNull(builder.lineEnding, "Line ending cannot be null"); - - if (builder.escapeUnicode && builder.useMultilineLiterals) { - throw new IllegalArgumentException("Cannot enable both escapeUnicode and useMultilineLiterals"); - } - this.useMultilineLiterals = builder.useMultilineLiterals; - } - - - // --- Builder Class --- - - /** - * Builder class for {@link SerializerConfig}. - * Provides a fluent API for constructing SerializerConfig instances with default values. - */ - public static class Builder { - // Syntax Sugar Defaults - private boolean usePrefixes = true; - private boolean autoDeclarePrefixes = true; - private PrefixOrderingEnum prefixOrdering = PrefixOrderingEnum.ALPHABETICAL; - private final Map customPrefixes = new HashMap<>(); - - private boolean useCompactTriples = true; - private boolean useRdfTypeShortcut = true; - // Default to false for complexity - private boolean useCollections = false; - // Default to NAMED (safer for initial impl) - private BlankNodeStyleEnum blankNodeStyle = BlankNodeStyleEnum.NAMED; - - // Pretty-Printing Defaults - private boolean prettyPrint = true; - private String indent = SerializationConstants.DEFAULT_INDENTATION; - private int maxLineLength = 80; - private boolean groupBySubject = true; - private boolean sortSubjects = false; - private boolean sortPredicates = false; - - // Technical Output Defaults - private LiteralDatatypePolicyEnum literalDatatypePolicy = LiteralDatatypePolicyEnum.MINIMAL; - private boolean escapeUnicode = false; - private boolean trailingDot = true; - private String baseIRI = null; - private boolean stableBlankNodeIds = false; - - // Validation & Context Defaults - private boolean strictMode = true; - private boolean validateURIs = true; - private boolean includeContext = false; - private String lineEnding = SerializationConstants.DEFAULT_LINE_ENDING; - private boolean useMultilineLiterals = true; - - /** - * Default constructor initializes all options with their default values. - * The values are directly assigned during field declaration above. - */ - public Builder() { - // No initialized - } - - // --- Builder Methods for Syntax Sugar Options --- - - public Builder usePrefixes(boolean usePrefixes) { - this.usePrefixes = usePrefixes; - return this; - } - - public Builder autoDeclarePrefixes(boolean autoDeclarePrefixes) { - this.autoDeclarePrefixes = autoDeclarePrefixes; - return this; - } - - public Builder prefixOrdering(PrefixOrderingEnum prefixOrdering) { - this.prefixOrdering = Objects.requireNonNull(prefixOrdering, "Prefix ordering cannot be null"); - return this; - } - - public Builder addCustomPrefix(String prefix, String namespace) { - Objects.requireNonNull(prefix, "Prefix name cannot be null"); - Objects.requireNonNull(namespace, "Namespace URI cannot be null"); - this.customPrefixes.put(prefix, namespace); - return this; - } - - public Builder addCustomPrefixes(Map prefixes) { - Objects.requireNonNull(prefixes, "Prefixes map cannot be null"); - this.customPrefixes.putAll(prefixes); - return this; - } - - public Builder useCompactTriples(boolean useCompactTriples) { - this.useCompactTriples = useCompactTriples; - return this; - } - - public Builder useRdfTypeShortcut(boolean useRdfTypeShortcut) { - this.useRdfTypeShortcut = useRdfTypeShortcut; - return this; - } - - public Builder useCollections(boolean useCollections) { - this.useCollections = useCollections; - return this; - } - - public Builder blankNodeStyle(BlankNodeStyleEnum blankNodeStyle) { - this.blankNodeStyle = Objects.requireNonNull(blankNodeStyle, "Blank node style cannot be null"); - return this; - } - - // --- Builder Methods for Pretty-Printing Options --- - - public Builder prettyPrint(boolean prettyPrint) { - this.prettyPrint = prettyPrint; - return this; - } - - public Builder indent(String indent) { - this.indent = Objects.requireNonNull(indent, "Indentation string cannot be null"); - return this; - } - - public Builder maxLineLength(int maxLineLength) { - this.maxLineLength = maxLineLength; - return this; - } - - public Builder groupBySubject(boolean groupBySubject) { - this.groupBySubject = groupBySubject; - return this; - } - - public Builder sortSubjects(boolean sortSubjects) { - this.sortSubjects = sortSubjects; - return this; - } - - public Builder sortPredicates(boolean sortPredicates) { - this.sortPredicates = sortPredicates; - return this; - } - - public Builder useMultilineLiterals(boolean useMultilineLiterals) { - this.useMultilineLiterals = useMultilineLiterals; - return this; - } - - // --- Builder Methods for Technical Output Options --- - - public Builder literalDatatypePolicy(LiteralDatatypePolicyEnum literalDatatypePolicy) { - this.literalDatatypePolicy = Objects.requireNonNull(literalDatatypePolicy, "Literal datatype policy cannot be null"); - return this; - } - - public Builder escapeUnicode(boolean escapeUnicode) { - this.escapeUnicode = escapeUnicode; - return this; - } - - public Builder trailingDot(boolean trailingDot) { - this.trailingDot = trailingDot; - return this; - } - - public Builder baseIRI(String baseIRI) { - this.baseIRI = baseIRI; - return this; - } // Can be null - - public Builder stableBlankNodeIds(boolean stableBlankNodeIds) { - this.stableBlankNodeIds = stableBlankNodeIds; - return this; - } - - // --- Builder Methods for Validation & Context Options --- - - public Builder strictMode(boolean strictMode) { - this.strictMode = strictMode; - return this; - } - - public Builder validateURIs(boolean validateURIs) { - this.validateURIs = validateURIs; - return this; - } - - public Builder includeContext(boolean includeContext) { - this.includeContext = includeContext; - return this; - } - - public Builder lineEnding(String lineEnding) { - this.lineEnding = Objects.requireNonNull(lineEnding, "Line ending cannot be null"); - return this; - } - - /** - * Builds and returns a new {@link SerializerConfig} instance with the current builder settings. - * - * @return A new {@code SerializerConfig} instance. - * @throws NullPointerException if any required field has not been set (should not happen with default values). - */ - public SerializerConfig build() { - return new SerializerConfig(this); - } - } - - // --- Predefined Configurations --- - - /** - * Returns a default configuration suitable for N-Triples serialization. - * N-Triples is a simple, line-oriented format without prefixes, contexts, or complex syntax sugar. - * - * @return A {@code SerializerConfig} instance for N-Triples. - */ - public static SerializerConfig ntriplesConfig() { - return new Builder() - .usePrefixes(false) // N-Triples doesn't use prefixes - .autoDeclarePrefixes(false) - .useCompactTriples(false) // N-Triples is one triple per line - .useRdfTypeShortcut(false) - .useCollections(false) - .blankNodeStyle(BlankNodeStyleEnum.NAMED) // N-Triples uses _:bnodeId - .prettyPrint(false) // N-Triples is usually not "pretty-printed" beyond newlines - .indent(SerializationConstants.EMPTY_STRING) // No indentation - .maxLineLength(0) // No line length limit for simplicity (or can be set very high) - .groupBySubject(false) // Each triple on its own line - .sortSubjects(false) // Order not strictly defined - .sortPredicates(false) // Order not strictly defined - .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) // N-Triples typically shows all datatypes explicitly - .escapeUnicode(true) // N-Triples often requires unicode escaping - .trailingDot(true) - .baseIRI(null) // No @base in N-Triples - .stableBlankNodeIds(true) // Good for reproducible N-Triples tests - .strictMode(true) // Be strict for N-Triples validation - .validateURIs(true) - .useMultilineLiterals(false) - .includeContext(false) // N-Triples does not support contexts - .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) - .build(); - } - - /** - * Returns a default configuration suitable for N-Quads serialization. - * N-Quads extends N-Triples with named graphs. - * - * @return A {@code SerializerConfig} instance for N-Quads. - */ - public static SerializerConfig nquadsConfig() { - return new Builder() - .usePrefixes(false) // N-Quads doesn't use prefixes - .autoDeclarePrefixes(false) - .useCompactTriples(false) - .useRdfTypeShortcut(false) - .useCollections(false) - .blankNodeStyle(BlankNodeStyleEnum.NAMED) - .prettyPrint(false) - .indent(SerializationConstants.EMPTY_STRING) - .maxLineLength(0) - .groupBySubject(false) - .sortSubjects(false) - .sortPredicates(false) - .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) - .escapeUnicode(true) - .trailingDot(true) - .baseIRI(null) - .stableBlankNodeIds(true) - .strictMode(true) - .validateURIs(true) - .useMultilineLiterals(false) - .includeContext(true) // N-Quads includes contexts by definition - .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) - .build(); - } - - /** - * Returns a default configuration suitable for Turtle serialization. - * Turtle is a concise, human-readable format with extensive syntax sugar and pretty-printing. - * - * @return A {@code SerializerConfig} instance for Turtle. - */ - public static SerializerConfig turtleConfig() { - Map commonTurtlePrefixes = new HashMap<>(); - commonTurtlePrefixes.put("rdf", SerializationConstants.RDF_NS); - commonTurtlePrefixes.put("rdfs", SerializationConstants.RDFS_NS); - commonTurtlePrefixes.put("xsd", SerializationConstants.XSD_NS); - commonTurtlePrefixes.put("owl", SerializationConstants.OWL_NS); - - return new Builder() - .usePrefixes(true) - .autoDeclarePrefixes(true) // Auto-declare new prefixes found in the graph - .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) - .addCustomPrefixes(commonTurtlePrefixes) // Start with common prefixes - .useCompactTriples(true) // Enable ; and , - .useRdfTypeShortcut(true) // Use 'a' - .useCollections(true) // Changed to true for comprehensive Turtle output - .blankNodeStyle(BlankNodeStyleEnum.ANONYMOUS) - .prettyPrint(true) - .indent(SerializationConstants.DEFAULT_INDENTATION) - .maxLineLength(80) // Standard line length - .groupBySubject(true) - .sortSubjects(false) // Optional, for reproducible output - .sortPredicates(false) // Optional, for reproducible output - .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) // Turtle's typical literal style - .escapeUnicode(false) // Usually direct UTF-8 for Turtle - .trailingDot(true) - .baseIRI(null) // No default base IRI - .stableBlankNodeIds(false) // Random by default - .strictMode(true) - .validateURIs(true) - .includeContext(false) // Turtle does not support contexts - .useMultilineLiterals(true) - .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) - .build(); - } - - /** - * Returns a default configuration suitable for TriG serialization. - * TriG extends Turtle with named graphs, supporting all Turtle features plus context inclusion. - * - * @return A {@code SerializerConfig} instance for TriG. - */ - public static SerializerConfig trigConfig() { - Map commonTriGPrefixes = new HashMap<>(); - commonTriGPrefixes.put("rdf", SerializationConstants.RDF_NS); - commonTriGPrefixes.put("rdfs", SerializationConstants.RDFS_NS); - commonTriGPrefixes.put("xsd", SerializationConstants.XSD_NS); - commonTriGPrefixes.put("owl", SerializationConstants.OWL_NS); - - return new Builder() - .usePrefixes(true) - .autoDeclarePrefixes(true) - .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) - .addCustomPrefixes(commonTriGPrefixes) - .useCompactTriples(true) - .useRdfTypeShortcut(true) - .useCollections(false) - .blankNodeStyle(BlankNodeStyleEnum.NAMED) - .prettyPrint(true) - .indent(SerializationConstants.DEFAULT_INDENTATION) - .maxLineLength(80) - .groupBySubject(true) - .sortSubjects(false) - .sortPredicates(false) - .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) - .escapeUnicode(false) - .trailingDot(true) - .baseIRI(null) - .stableBlankNodeIds(false) - .strictMode(true) - .validateURIs(true) - .includeContext(true) // TriG includes contexts by definition - .useMultilineLiterals(true) - .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING) - .build(); - } - - /** - * Returns a default configuration suitable for RDF/XML serialization. - * RDF/XML is an XML-based syntax for RDF graphs. - * - * @return A {@code SerializerConfig} instance for RDF/XML. - */ - public static SerializerConfig rdfXmlConfig() { - Map commonRdfXmlPrefixes = new HashMap<>(); - commonRdfXmlPrefixes.put("rdf", SerializationConstants.RDF_NS); - commonRdfXmlPrefixes.put("rdfs", SerializationConstants.RDFS_NS); - commonRdfXmlPrefixes.put("xsd", SerializationConstants.XSD_NS); - commonRdfXmlPrefixes.put("owl", SerializationConstants.OWL_NS); - - return new Builder().usePrefixes(true) - .autoDeclarePrefixes(true) - .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL).addCustomPrefixes(commonRdfXmlPrefixes).useCompactTriples(false) - .useRdfTypeShortcut(false) - .useCollections(false) - .blankNodeStyle(BlankNodeStyleEnum.NAMED) - .prettyPrint(true) - .indent(SerializationConstants.DEFAULT_INDENTATION).maxLineLength(0) - .groupBySubject(false) - .sortSubjects(false) - .sortPredicates(false) - .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) - .escapeUnicode(false) - .trailingDot(false) - .baseIRI(null) - .stableBlankNodeIds(true) - .strictMode(true).validateURIs(true).useMultilineLiterals(true) - .includeContext(false) - .lineEnding(SerializationConstants.DEFAULT_LINE_ENDING).build(); - } - - public boolean shouldUseTripleQuotes(String literalValue) { - return useMultilineLiterals && (literalValue.contains(SerializationConstants.LINE_FEED) || literalValue.contains(SerializationConstants.CARRIAGE_RETURN)); - } - - public boolean shouldOptimizeOutput() { - return useCompactTriples || groupBySubject || prettyPrint; - } - - public boolean shouldUseInlineBlankNodes() { - return blankNodeStyle == BlankNodeStyleEnum.ANONYMOUS && useCompactTriples; - } - // --- Getters for all options --- - - public boolean usePrefixes() { - return usePrefixes; - } - - public boolean autoDeclarePrefixes() { - return autoDeclarePrefixes; - } - - public PrefixOrderingEnum getPrefixOrdering() { - return prefixOrdering; - } - - public Map getCustomPrefixes() { - return customPrefixes; - } - - public boolean useCompactTriples() { - return useCompactTriples; - } - - public boolean useRdfTypeShortcut() { - return useRdfTypeShortcut; - } - - public boolean useCollections() { - return useCollections; - } - - public BlankNodeStyleEnum getBlankNodeStyle() { - return blankNodeStyle; - } - - public boolean prettyPrint() { - return prettyPrint; - } - - public String getIndent() { - return indent; - } - - public int getMaxLineLength() { - return maxLineLength; - } - - public boolean groupBySubject() { - return groupBySubject; - } - - public boolean sortSubjects() { - return sortSubjects; - } - - public boolean sortPredicates() { - return sortPredicates; - } - - public LiteralDatatypePolicyEnum getLiteralDatatypePolicy() { - return literalDatatypePolicy; - } - - public boolean escapeUnicode() { - return escapeUnicode; - } - - public boolean trailingDot() { - return trailingDot; - } - - public String getBaseIRI() { - return baseIRI; - } - - public boolean stableBlankNodeIds() { - return stableBlankNodeIds; - } - - public boolean isStrictMode() { - return strictMode; - } - - public boolean validateURIs() { - return validateURIs; - } - - public boolean includeContext() { - return includeContext; - } - - public String getLineEnding() { - return lineEnding; - } - - public boolean useMultilineLiterals() { - return useMultilineLiterals; - } -} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfig.java new file mode 100644 index 000000000..aa0a2821c --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfig.java @@ -0,0 +1,81 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; + +import java.util.HashMap; +import java.util.Map; + +/** + * Configuration for TriG serialization format. + * This class extends {@link AbstractTFamilyConfig} and provides specific defaults + * and options tailored for TriG, which extends Turtle with named graphs. + * + *

    Use the {@link Builder} class to create instances of {@code TriGConfig}. + * A predefined default configuration is available via {@link #defaultConfig()}.

    + */ +public class TriGConfig extends AbstractTFamilyConfig { + + /** + * Protected constructor to be used by the {@link Builder}. + * + * @param builder The builder instance containing the desired configuration values. + */ + protected TriGConfig(Builder builder) { + super(builder); + } + + /** + * Public Builder for {@link TriGConfig}. + * Provides a fluent API for constructing {@code TriGConfig} instances with default values + * specific to the TriG format. + */ + public static class Builder extends AbstractTFamilyConfig.AbstractTFamilyBuilder { + /** + * Default constructor initializes all options with their default values for TriG. + */ + public Builder() { + includeContext(true); + blankNodeStyle(BlankNodeStyleEnum.NAMED); + useCollections(false); + + Map commonTriGPrefixes = new HashMap<>(); + commonTriGPrefixes.put("rdf", SerializationConstants.RDF_NS); + commonTriGPrefixes.put("rdfs", SerializationConstants.RDFS_NS); + commonTriGPrefixes.put("xsd", SerializationConstants.XSD_NS); + commonTriGPrefixes.put("owl", SerializationConstants.OWL_NS); + addCustomPrefixes(commonTriGPrefixes); + + } + + /** + * Builds and returns a new {@link TriGConfig} instance with the current builder settings. + * + * @return A new {@code TriGConfig} instance. + */ + @Override + public TriGConfig build() { + return new TriGConfig(this); + } + } + + /** + * Returns a default configuration suitable for TriG serialization. + * This provides a convenient way to get a standard TriG configuration without + * manually building it. + * + * @return A {@code TriGConfig} instance with default settings. + */ + public static TriGConfig defaultConfig() { + return new Builder().build(); + } + + /** + * Returns a new builder instance for {@link TriGConfig}. + * This allows for fluent construction of custom TriG configurations. + * + * @return A new {@code Builder} instance. + */ + public static TriGConfig.Builder builder() { + return new TriGConfig.Builder(); + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfig.java new file mode 100644 index 000000000..739169e9c --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfig.java @@ -0,0 +1,84 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; + +import java.util.HashMap; +import java.util.Map; + +/** + * Configuration for Turtle serialization format. + * This class extends {@link AbstractTFamilyConfig} and provides specific defaults + * and options tailored for Turtle, such as using collections and anonymous blank nodes. + * + *

    Use the {@link Builder} class to create instances of {@code TurtleConfig}. + * A predefined default configuration is available via {@link #defaultConfig()}.

    + */ +public class TurtleConfig extends AbstractTFamilyConfig { + + /** + * Protected constructor to be used by the {@link Builder}. + * + * @param builder The builder instance containing the desired configuration values. + */ + protected TurtleConfig(Builder builder) { + super(builder); + } + + /** + * Public Builder for {@link TurtleConfig}. + * Provides a fluent API for constructing {@code TurtleConfig} instances with default values + * specific to the Turtle format. + */ + public static class Builder extends AbstractTFamilyConfig.AbstractTFamilyBuilder { + /** + * Default constructor initializes all options with their default values for Turtle. + */ + public Builder() { + lineEnding(System.lineSeparator()); + validateURIs(false); + useCollections(true); + blankNodeStyle(BlankNodeStyleEnum.ANONYMOUS); + + Map commonTurtlePrefixes = new HashMap<>(); + commonTurtlePrefixes.put("rdf", SerializationConstants.RDF_NS); + commonTurtlePrefixes.put("rdfs", SerializationConstants.RDFS_NS); + commonTurtlePrefixes.put("xsd", SerializationConstants.XSD_NS); + commonTurtlePrefixes.put("owl", SerializationConstants.OWL_NS); + addCustomPrefixes(commonTurtlePrefixes); + + + } + + /** + * Builds and returns a new {@link TurtleConfig} instance with the current builder settings. + * + * @return A new {@code TurtleConfig} instance. + */ + @Override + public TurtleConfig build() { + return new TurtleConfig(this); + } + } + + /** + * Returns a default configuration suitable for Turtle serialization. + * This provides a convenient way to get a standard Turtle configuration without + * manually building it. + * + * @return A {@code TurtleConfig} instance with default settings. + */ + public static TurtleConfig defaultConfig() { + return new Builder().build(); + } + + + /** + * Returns a new builder instance for {@link TurtleConfig}. + * This allows for fluent construction of custom Turtle configurations. + * + * @return A new {@code Builder} instance. + */ + public static TurtleConfig.Builder builder() { + return new TurtleConfig.Builder(); + } +} diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfig.java new file mode 100644 index 000000000..37aba7e28 --- /dev/null +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfig.java @@ -0,0 +1,370 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +/** + * Configuration for RDF/XML serialization format. + * This class extends {@link AbstractSerializerConfig} directly as RDF/XML has + * distinct serialization characteristics not shared by the Turtle or N-Family formats. + * + *

    Use the {@link Builder} class to create instances of {@code XmlConfig}. + * A predefined default configuration is available via {@link #defaultConfig()}.

    + */ +public class XmlConfig extends AbstractSerializerConfig { + + /** + * Whether prefix declarations (e.g., `xmlns:prefix="uri"`) should be used for compact IRIs. + * This is crucial for human-readable formats like RDF/XML. + */ + protected final boolean usePrefixes; + /** + * Whether the serializer should automatically discover and declare prefixes used in the graph. + * This avoids manual prefix configuration but can lead to more prefixes than strictly needed. + */ + protected final boolean autoDeclarePrefixes; + /** + * The policy for ordering prefix declarations (e.g., alphabetically, by usage, or custom). + * This impacts the determinism and readability of the prefix block. + */ + protected final PrefixOrderingEnum prefixOrdering; + /** + * A map of custom URI prefixes to be used for serialization, in addition to or instead of + * auto-declared prefixes. Useful for enforcing specific prefix names or when {@code autoDeclarePrefixes} is false. + * Keys are prefixes, values are namespace URIs. + */ + protected final Map customPrefixes; + /** + * Whether human-readable formatting with indentation and newlines (pretty-printing) is enabled. + * This makes the output easier for humans to read and debug, but increases file size slightly. + */ + protected final boolean prettyPrint; + /** + * The string used for indentation (e.g., " ", "\t"). + * This defines the visual spacing for nested structures when pretty-printing. + */ + protected final String indent; + /** + * The maximum desired line length before the serializer attempts to break lines. + * This helps ensure readability by preventing very long lines in the output. + */ + protected final int maxLineLength; + /** + * Whether subjects should be sorted alphabetically in the output. + * This ensures a consistent and reproducible order of subjects, useful for diffing or testing. + */ + protected final boolean sortSubjects; + /** + * Whether predicates should be sorted alphabetically within a subject group. + * This ensures a consistent and reproducible order of properties for a given subject. + */ + protected final boolean sortPredicates; + /** + * Whether multi-line literal syntax (e.g., CDATA sections or direct text nodes with newlines) + * should be used for literals containing newline characters. + */ + protected final boolean useMultilineLiterals; + + + /** + * Protected constructor to be used by the {@link Builder}. + * + * @param builder The builder instance containing the desired configuration values. + */ + protected XmlConfig(Builder builder) { + super(builder); + + this.usePrefixes = builder.usePrefixes; + this.autoDeclarePrefixes = builder.autoDeclarePrefixes; + this.prefixOrdering = Objects.requireNonNull(builder.prefixOrdering, "Prefix ordering cannot be null"); + this.customPrefixes = Collections.unmodifiableMap(new HashMap<>(Objects.requireNonNull(builder.customPrefixes, "Custom prefixes map cannot be null"))); + this.prettyPrint = builder.prettyPrint; + this.indent = Objects.requireNonNull(builder.indent, "Indentation string cannot be null"); + this.maxLineLength = builder.maxLineLength; + this.sortSubjects = builder.sortSubjects; + this.sortPredicates = builder.sortPredicates; + this.useMultilineLiterals = builder.useMultilineLiterals; + + } + + /** + * Checks if prefix declarations should be used for compact IRIs. + * + * @return {@code true} if prefixes are used, {@code false} otherwise. + */ + public boolean usePrefixes() { + return usePrefixes; + } + + /** + * Checks if the serializer should automatically discover and declare prefixes. + * + * @return {@code true} if auto-declaration is enabled, {@code false} otherwise. + */ + public boolean autoDeclarePrefixes() { + return autoDeclarePrefixes; + } + + /** + * Returns the policy for ordering prefix declarations. + * + * @return The {@link PrefixOrderingEnum} for prefix ordering. + */ + public PrefixOrderingEnum getPrefixOrdering() { + return prefixOrdering; + } + + /** + * Returns an unmodifiable map of custom URI prefixes. + * + * @return A map where keys are prefix names and values are namespace URIs. + */ + public Map getCustomPrefixes() { + return customPrefixes; + } + + /** + * Checks if human-readable formatting (pretty-printing) is enabled. + * + * @return {@code true} if pretty-printing is enabled, {@code false} otherwise. + */ + public boolean prettyPrint() { + return prettyPrint; + } + + /** + * Returns the string used for indentation when pretty-printing. + * + * @return The indentation string. + */ + public String getIndent() { + return indent; + } + + /** + * Returns the maximum desired line length before the serializer attempts to break lines. + * + * @return The maximum line length. + */ + public int getMaxLineLength() { + return maxLineLength; + } + + /** + * Checks if subjects should be sorted alphabetically in the output. + * + * @return {@code true} if subject sorting is enabled, {@code false} otherwise. + */ + public boolean sortSubjects() { + return sortSubjects; + } + + /** + * Checks if predicates should be sorted alphabetically within a subject group. + * + * @return {@code true} if predicate sorting is enabled, {@code false} otherwise. + */ + public boolean sortPredicates() { + return sortPredicates; + } + + /** + * Checks if multi-line literal syntax should be used. + * + * @return {@code true} if multi-line literals are enabled, {@code false} otherwise. + */ + public boolean useMultilineLiterals() { + return useMultilineLiterals; + } + + + /** + * Public Builder for {@link XmlConfig}. + * Provides a fluent API for constructing {@code XmlConfig} instances with default values + * specific to the RDF/XML format. + */ + public static class Builder extends AbstractSerializerConfig.AbstractBuilder { + protected boolean usePrefixes = true; + protected boolean autoDeclarePrefixes = true; + protected PrefixOrderingEnum prefixOrdering = PrefixOrderingEnum.ALPHABETICAL; + protected final Map customPrefixes = new HashMap<>(); + protected boolean prettyPrint = true; + protected String indent = SerializationConstants.DEFAULT_INDENTATION; + protected int maxLineLength = 0; + protected boolean sortSubjects = false; + protected boolean sortPredicates = false; + protected boolean useMultilineLiterals = true; + + + /** + * Default constructor initializes all options with their default values for RDF/XML. + */ + public Builder() { + // Call superclass builder methods for common properties + literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED); // RDF/XML typically types all literals + trailingDot(false); // No trailing dot in RDF/XML + stableBlankNodeIds(true); // Good for reproducible RDF/XML outputs + escapeUnicode(false); // Usually direct UTF-8 for RDF/XML, not unicode escapes + + addCustomPrefix("rdf", SerializationConstants.RDF_NS); + addCustomPrefix("rdfs", SerializationConstants.RDFS_NS); + addCustomPrefix("xsd", SerializationConstants.XSD_NS); + addCustomPrefix("owl", SerializationConstants.OWL_NS); + } + + + /** + * Sets whether prefix declarations should be used for compact IRIs. + * + * @param usePrefixes {@code true} to use prefixes, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public Builder usePrefixes(boolean usePrefixes) { + this.usePrefixes = usePrefixes; + return self(); + } + + /** + * Sets whether the serializer should automatically discover and declare prefixes. + * + * @param autoDeclarePrefixes {@code true} to enable auto-declaration, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public Builder autoDeclarePrefixes(boolean autoDeclarePrefixes) { + this.autoDeclarePrefixes = autoDeclarePrefixes; + return self(); + } + + /** + * Sets the policy for ordering prefix declarations. + * + * @param prefixOrdering The {@link PrefixOrderingEnum} to set. Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided policy is null. + */ + public Builder prefixOrdering(PrefixOrderingEnum prefixOrdering) { + this.prefixOrdering = Objects.requireNonNull(prefixOrdering); + return self(); + } + + /** + * Adds a custom prefix mapping to be used for serialization. + * + * @param prefix The prefix name (e.g., "ex"). Must not be null. + * @param namespace The namespace URI Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if prefix or namespace is null. + */ + public Builder addCustomPrefix(String prefix, String namespace) { + Objects.requireNonNull(prefix, "Prefix name cannot be null"); + Objects.requireNonNull(namespace, "Namespace URI cannot be null"); + this.customPrefixes.put(prefix, namespace); + return self(); + } + + /** + * Adds multiple custom prefix mappings from a map. + * + * @param prefixes A map of prefix names to namespace URIs. Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided map is null. + */ + public Builder addCustomPrefixes(Map prefixes) { + Objects.requireNonNull(prefixes, "Prefixes map cannot be null"); + this.customPrefixes.putAll(prefixes); + return self(); + } + + /** + * Sets whether human-readable formatting (pretty-printing) is enabled. + * + * @param prettyPrint {@code true} to enable pretty-printing, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public Builder prettyPrint(boolean prettyPrint) { + this.prettyPrint = prettyPrint; + return self(); + } + + /** + * Sets the string used for indentation when pretty-printing. + * + * @param indent The indentation string. Must not be null. + * @return The builder instance for fluent chaining. + * @throws NullPointerException if the provided indent string is null. + */ + public Builder indent(String indent) { + this.indent = Objects.requireNonNull(indent); + return self(); + } + + /** + * Sets the maximum desired line length before the serializer attempts to break lines. + * + * @param maxLineLength The maximum line length. + * @return The builder instance for fluent chaining. + */ + public Builder maxLineLength(int maxLineLength) { + this.maxLineLength = maxLineLength; + return self(); + } + + /** + * Sets whether subjects should be sorted alphabetically in the output. + * + * @param sortSubjects {@code true} to enable subject sorting, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public Builder sortSubjects(boolean sortSubjects) { + this.sortSubjects = sortSubjects; + return self(); + } + + /** + * Sets whether predicates should be sorted alphabetically within a subject group. + * + * @param sortPredicates {@code true} to enable predicate sorting, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public Builder sortPredicates(boolean sortPredicates) { + this.sortPredicates = sortPredicates; + return self(); + } + + /** + * Sets whether multi-line literal syntax should be used. + * + * @param useMultilineLiterals {@code true} to enable multi-line literals, {@code false} otherwise. + * @return The builder instance for fluent chaining. + */ + public Builder useMultilineLiterals(boolean useMultilineLiterals) { + this.useMultilineLiterals = useMultilineLiterals; + return self(); + } + + /** + * Builds and returns a new {@link XmlConfig} instance with the current builder settings. + * + * @return A new {@code XmlConfig} instance. + */ + @Override + public XmlConfig build() { + return new XmlConfig(this); + } + } + + /** + * Returns a default configuration suitable for RDF/XML serialization. + * This provides a convenient way to get a standard RDF/XML configuration without + * manually building it. + * + * @return A {@code XmlConfig} instance with default settings. + */ + public static XmlConfig defaultConfig() { + return new Builder().build(); + } +} \ No newline at end of file diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java index 3ab7e6f7e..ef8c8daac 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java @@ -1,114 +1,111 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.RdfSerializer; import fr.inria.corese.core.next.api.Model; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.api.RdfSerializer; +import fr.inria.corese.core.next.api.SerializationConfig; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.MockedConstruction; import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mockConstruction; class DefaultSerializerFactoryTest { private DefaultSerializerFactory factory; private Model mockModel; - private SerializerConfig mockConfig; + private SerializationConfig mockConfig; @BeforeEach void setUp() { factory = new DefaultSerializerFactory(); - - mockModel = org.mockito.Mockito.mock(Model.class); - mockConfig = org.mockito.Mockito.mock(SerializerConfig.class); + mockModel = mock(Model.class); + mockConfig = mock(SerializationConfig.class); } @Test - @DisplayName("createSerializer should return TurtleFormat for TURTLE format") - void createSerializer_shouldReturnTurtleFormat_forTurtleFormat() { + @DisplayName("createSerializer devrait retourner TurtleSerializer pour le format TURTLE") + void createSerializer_shouldReturnTurtleSerializer_forTurtleFormat() { try (MockedConstruction mockedConstruction = mockConstruction(TurtleSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.TURTLE, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof TurtleSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "TurtleFormat constructor should be called once"); + assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de TurtleSerializer devrait être appelé une fois"); } } @Test - @DisplayName("createSerializer should return NTriplesFormat for NTRIPLES format") - void createSerializer_shouldReturnNTriplesFormat_forNTriplesFormat() { + @DisplayName("createSerializer devrait retourner NTriplesSerializer pour le format NTRIPLES") + void createSerializer_shouldReturnNTriplesSerializer_forNTriplesFormat() { try (MockedConstruction mockedConstruction = mockConstruction(NTriplesSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.NTRIPLES, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof NTriplesSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "NTriplesFormat constructor should be called once"); + assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de NTriplesSerializer devrait être appelé une fois"); } } @Test - @DisplayName("createSerializer should return NQuadsFormat for NQUADS format") - void createSerializer_shouldReturnNQuadsFormat_forNQuadsFormat() { + @DisplayName("createSerializer devrait retourner NQuadsSerializer pour le format NQUADS") + void createSerializer_shouldReturnNQuadsSerializer_forNQuadsFormat() { try (MockedConstruction mockedConstruction = mockConstruction(NQuadsSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.NQUADS, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof NQuadsSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "NQuadsFormat constructor should be called once"); + assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de NQuadsSerializer devrait être appelé une fois"); } } @Test - @DisplayName("createSerializer should return TriGFormat for TRIG format") - void createSerializer_shouldReturnTriGFormat_forTriGFormat() { + @DisplayName("createSerializer devrait retourner TriGSerializer pour le format TRIG") + void createSerializer_shouldReturnTriGSerializer_forTriGFormat() { try (MockedConstruction mockedConstruction = mockConstruction(TriGSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.TRIG, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof TriGSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "TriGFormat constructor should be called once"); + assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de TriGSerializer devrait être appelé une fois"); } } @Test - @DisplayName("createSerializer should return XmlSerializer for RDFXML format") + @DisplayName("createSerializer devrait retourner XmlSerializer pour le format RDFXML") void createSerializer_shouldReturnXmlSerializer_forRdfXmlFormat() { try (MockedConstruction mockedConstruction = mockConstruction(XmlSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.RDFXML, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof XmlSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "XmlSerializer constructor should be called once"); + assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de XmlSerializer devrait être appelé une fois"); } } - @Test - @DisplayName("createSerializer should throw NullPointerException for null format") + @DisplayName("createSerializer devrait lever NullPointerException pour un format nul") void createSerializer_shouldThrowNPE_forNullFormat() { assertThrows(NullPointerException.class, () -> factory.createSerializer(null, mockModel, mockConfig), - "Should throw NullPointerException for null RdfFormat"); + "Devrait lever NullPointerException pour RdfFormat nul"); } @Test - @DisplayName("createSerializer should throw NullPointerException for null model") + @DisplayName("createSerializer devrait lever NullPointerException pour un modèle nul") void createSerializer_shouldThrowNPE_forNullModel() { assertThrows(NullPointerException.class, () -> factory.createSerializer(RdfFormat.TURTLE, null, mockConfig), - "Should throw NullPointerException for null Model"); + "Devrait lever NullPointerException pour Model nul"); } @Test - @DisplayName("createSerializer should throw NullPointerException for null config") + @DisplayName("createSerializer devrait lever NullPointerException pour une configuration nulle") void createSerializer_shouldThrowNPE_forNullConfig() { assertThrows(NullPointerException.class, () -> factory.createSerializer(RdfFormat.TURTLE, mockModel, null), - "Should throw NullPointerException for null SerializerConfig"); + "Devrait lever NullPointerException pour SerializationConfig nulle"); } - - } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java index 99426fdfb..2ad1b449e 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.NQuadsConfig; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; @@ -23,16 +23,14 @@ class NQuadsSerializerTest { private Model model; - private SerializerConfig config; + private NQuadsConfig config; private NQuadsSerializer nQuadsSerializer; private Resource mockExPerson; private IRI mockExName; - private IRI mockExKnows; private final String lexJohn = "John Doe"; - private final String hello = "Hello"; private Literal mockLiteralJohn; @@ -43,15 +41,13 @@ class NQuadsSerializerTest { @BeforeEach void setUp() { model = mock(Model.class); - config = SerializerConfig.nquadsConfig(); + config = NQuadsConfig.defaultConfig(); nQuadsSerializer = new NQuadsSerializer(model, config); mockExPerson = createIRI("http://example.org/Person"); mockExName = createIRI("http://example.org/name"); - mockExKnows = createIRI("http://example.org/knows"); - mockLiteralJohn = createLiteral(lexJohn, null, null); mockLiteralHelloEn = createLiteral(hello, null, "en"); @@ -60,20 +56,19 @@ void setUp() { } @Test - @DisplayName("Constructor should throw NullPointerException for null model") + @DisplayName("Le constructeur devrait lever NullPointerException pour un modèle nul") void constructorShouldThrowForNullModel() { assertThrows(NullPointerException.class, () -> new NQuadsSerializer(null), "Model cannot be null"); - assertThrows(NullPointerException.class, () -> new NQuadsSerializer(null, config), "Model cannot be null"); } @Test - @DisplayName("Constructor should throw NullPointerException for null config") + @DisplayName("Le constructeur devrait lever NullPointerException pour une configuration nulle") void constructorShouldThrowForNullConfig() { assertThrows(NullPointerException.class, () -> new NQuadsSerializer(model, null), "Configuration cannot be null"); } @Test - @DisplayName("Write should serialize simple statement correctly (default graph)") + @DisplayName("L'écriture devrait sérialiser une déclaration simple correctement (graphe par défaut)") void writeShouldSerializeSimpleStatement() throws SerializationException { Statement stmt = createStatement( mockExPerson, @@ -85,7 +80,6 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { StringWriter writer = new StringWriter(); nQuadsSerializer.write(writer); - String expected = String.format("<%s> <%s> \"%s\"", mockExPerson.stringValue(), mockExName.stringValue(), @@ -95,7 +89,7 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { } @Test - @DisplayName("Write should handle blank nodes with default prefix") + @DisplayName("L'écriture devrait gérer les nœuds vierges avec le préfixe par défaut") void writeShouldHandleBlankNodes() throws SerializationException { Statement stmt = createStatement( mockBNode1, @@ -116,7 +110,7 @@ void writeShouldHandleBlankNodes() throws SerializationException { } @Test - @DisplayName("Write should handle blank nodes in context with default prefix") + @DisplayName("L'écriture devrait gérer les nœuds vierges dans le contexte avec le préfixe par défaut") void writeShouldHandleBlankNodesInContext() throws SerializationException { Resource blankNodeContext = createBlankNode("b3"); Statement stmt = createStatement( @@ -139,9 +133,8 @@ void writeShouldHandleBlankNodesInContext() throws SerializationException { assertEquals(expected, writer.toString()); } - @Test - @DisplayName("Write should throw SerializationException on IO error") + @DisplayName("L'écriture devrait lever SerializationException en cas d'erreur E/S") void writeShouldThrowOnIOException() throws IOException { Statement stmt = createStatement( mockExPerson, @@ -160,7 +153,7 @@ void writeShouldThrowOnIOException() throws IOException { } @Test - @DisplayName("Write should throw SerializationException on null subject value from Statement in strict mode") + @DisplayName("L'écriture devrait lever SerializationException pour une valeur de sujet nulle dans le mode strict") void writeShouldThrowOnNullSubjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(null); @@ -175,7 +168,7 @@ void writeShouldThrowOnNullSubjectValue() { } @Test - @DisplayName("Write should throw SerializationException on null predicate value from Statement in strict mode") + @DisplayName("L'écriture devrait lever SerializationException pour une valeur de prédicat nulle dans le mode strict") void writeShouldThrowOnNullPredicateValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -190,7 +183,7 @@ void writeShouldThrowOnNullPredicateValue() { } @Test - @DisplayName("Write should throw SerializationException on null object value from Statement in strict mode") + @DisplayName("L'écriture devrait lever SerializationException pour une valeur d'objet nulle dans le mode strict") void writeShouldThrowOnNullObjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -205,9 +198,8 @@ void writeShouldThrowOnNullObjectValue() { } @Test - @DisplayName("Write should correctly handle null context (default graph)") + @DisplayName("L'écriture devrait gérer correctement le contexte nul (graphe par défaut)") void writeShouldHandleNullContext() throws SerializationException { - // Default config (nquadsConfig) has includeContext = true, but this statement has null context. Statement stmt = createStatement( mockExPerson, mockExName, @@ -219,7 +211,6 @@ void writeShouldHandleNullContext() throws SerializationException { StringWriter writer = new StringWriter(); nQuadsSerializer.write(writer); - String expected = String.format("<%s> <%s> \"%s\"", mockExPerson.stringValue(), mockExName.stringValue(), @@ -239,7 +230,7 @@ void writeShouldHandleNullContext() throws SerializationException { "literal with \u0001 (SOH)", "literal with \u007F (DEL)" }) - @DisplayName("Write should handle various literal values with proper escaping (including Unicode)") + @DisplayName("L'écriture devrait gérer diverses valeurs littérales avec un échappement approprié (y compris Unicode)") void writeShouldHandleVariousLiterals(String literalValue) throws SerializationException { Literal literalMock = createLiteral(literalValue, null, null); @@ -253,7 +244,6 @@ void writeShouldHandleVariousLiterals(String literalValue) throws SerializationE StringWriter writer = new StringWriter(); nQuadsSerializer.write(writer); - String expectedEscapedLiteral = escapeNQuadsString(literalValue); String expectedOutput = String.format("<%s> <%s> \"%s\"", mockExPerson.stringValue(), @@ -263,9 +253,8 @@ void writeShouldHandleVariousLiterals(String literalValue) throws SerializationE assertEquals(expectedOutput, writer.toString()); } - @Test - @DisplayName("Should handle literals with language tags") + @DisplayName("Devrait gérer les littéraux avec des balises de langue") void shouldHandleLiteralsWithLanguageTags() throws SerializationException { Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/greeting"), mockLiteralHelloEn); @@ -274,7 +263,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { Writer writer = new StringWriter(); - NQuadsSerializer serializer = new NQuadsSerializer(currentTestModel, SerializerConfig.nquadsConfig()); + NQuadsSerializer serializer = new NQuadsSerializer(currentTestModel, NQuadsConfig.defaultConfig()); serializer.write(writer); String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", @@ -286,17 +275,41 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { assertEquals(expectedOutput, writer.toString()); } + @Test + @DisplayName("Devrait gérer les littéraux avec des types de données personnalisés") + void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { + IRI customDatatype = createIRI("http://example.org/myDataType"); + Literal customLiteral = createLiteral("123", customDatatype, null); + + Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/value"), customLiteral); + + Model currentTestModel = mock(Model.class); + when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); + + NQuadsSerializer serializer = new NQuadsSerializer(currentTestModel, NQuadsConfig.defaultConfig()); + + StringWriter writer = new StringWriter(); + serializer.write(writer); + + String expectedOutput = String.format("<%s> <%s> \"%s\"^^<%s>", + mockExPerson.stringValue(), + createIRI("http://example.org/value").stringValue(), + escapeNQuadsString("123"), + customDatatype.stringValue()) + " .\n"; + + assertEquals(expectedOutput, writer.toString()); + } /** - * Creates a mocked Literal object. - * Important: The `lexicalForm` is the *raw string value* of the literal, - * without N-Quads specific quotes, lang tags, or datatype URIs. - * The `nQuadsSerializer` class is responsible for adding those. + * Crée un objet Literal mocké. + * Important : le `lexicalForm` est la *valeur de chaîne brute* du littéral, + * sans les guillemets spécifiques à N-Quads, les balises de langue ou les URI de type de données. + * La classe `nQuadsSerializer` est chargée d'ajouter ceux-ci. * - * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). - * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. - * @param langTag The language tag (e.g., "en"), or null if not language-tagged. - * @return A mocked Literal instance. + * @param lexicalForm La valeur de chaîne brute du littéral (par exemple, "hello", "123"). + * @param dataTypeIRI L'IRI du type de données du littéral (par exemple, XSD.INTEGER.getIRI()), ou null pour simple/avec balise de langue. + * @param langTag La balise de langue (par exemple, "en"), ou null si non balisé par la langue. + * @return Une instance de Literal mockée. */ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { Literal literal = mock(Literal.class); @@ -315,13 +328,13 @@ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTa } /** - * Escapes a string according to N-Quads literal escaping rules. - * This helper is used in tests to construct the *expected* output strings. - * It mimics the behavior of nQuadsSerializer's internal escapeLiteral method, - * considering that `nquadsConfig().escapeUnicode()` is `true`. + * Échappe une chaîne selon les règles d'échappement des littéraux N-Quads. + * Cette aide est utilisée dans les tests pour construire les chaînes de sortie *attendues*. + * Elle imite le comportement de la méthode interne `escapeLiteral` de `nQuadsSerializer`, + * en considérant que `nquadsConfig().escapeUnicode()` est `true`. * - * @param s The string to escape. - * @return The escaped string. + * @param s La chaîne à échapper. + * @return La chaîne échappée. */ private String escapeNQuadsString(String s) { StringBuilder sb = new StringBuilder(); @@ -350,17 +363,17 @@ private String escapeNQuadsString(String s) { sb.append("\\\\"); break; default: - if (c <= 0x1F || c == 0x7F) { // Control characters + if (c <= 0x1F || c == 0x7F) { sb.append(String.format("\\u%04X", (int) c)); - } else if (c >= 0x80 && c <= 0xFFFF) { // Non-ASCII Basic Multilingual Plane characters + } else if (c >= 0x80 && c <= 0xFFFF) { sb.append(String.format("\\u%04X", (int) c)); - } else if (Character.isHighSurrogate(c)) { // Supplementary characters + } else if (Character.isHighSurrogate(c)) { int codePoint = s.codePointAt(i); if (Character.isValidCodePoint(codePoint)) { sb.append(String.format("\\U%08X", codePoint)); - i++; // Skip the low surrogate char + i++; } else { - sb.append(c); // Append invalid surrogate char directly + sb.append(c); } } else { sb.append(c); @@ -370,7 +383,6 @@ private String escapeNQuadsString(String s) { return sb.toString(); } - private static class MockStatementIterator implements Iterator { private final Statement[] statements; private int index = 0; @@ -420,4 +432,4 @@ private IRI createIRI(String uri) { when(iri.stringValue()).thenReturn(uri); return iri; } -} \ No newline at end of file +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java index ef57064f6..deb707c72 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java @@ -1,12 +1,14 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.NTriplesConfig; import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import java.io.IOException; import java.io.StringWriter; @@ -21,7 +23,7 @@ class NTriplesSerializerTest { private Model model; - private SerializerConfig config; + private NTriplesConfig config; private NTriplesSerializer nTriplesSerializer; private Resource mockExPerson; @@ -29,45 +31,44 @@ class NTriplesSerializerTest { private IRI mockExKnows; private final String lexJohn = "John Doe"; + private final String hello = "Hello"; private Literal mockLiteralJohn; + private Literal mockLiteralHelloEn; private Resource mockBNode1; private Resource mockBNode2; @BeforeEach void setUp() { model = mock(Model.class); - - config = SerializerConfig.ntriplesConfig(); + config = NTriplesConfig.defaultConfig(); nTriplesSerializer = new NTriplesSerializer(model, config); - mockExPerson = createIRI("http://example.org/Person"); mockExName = createIRI("http://example.org/name"); mockExKnows = createIRI("http://example.org/knows"); + mockLiteralJohn = createLiteral(lexJohn, null, null); + mockLiteralHelloEn = createLiteral(hello, null, "en"); mockBNode1 = createBlankNode("b1"); mockBNode2 = createBlankNode("b2"); - - mockLiteralJohn = createLiteral(lexJohn, null, null); } @Test - @DisplayName("Constructor should throw NullPointerException for null model") + @DisplayName("Le constructeur devrait lever NullPointerException pour un modèle nul") void constructorShouldThrowForNullModel() { assertThrows(NullPointerException.class, () -> new NTriplesSerializer(null), "Model cannot be null"); - assertThrows(NullPointerException.class, () -> new NTriplesSerializer(null, config), "Model cannot be null"); } @Test - @DisplayName("Constructor should throw NullPointerException for null config") + @DisplayName("Le constructeur devrait lever NullPointerException pour une configuration nulle") void constructorShouldThrowForNullConfig() { assertThrows(NullPointerException.class, () -> new NTriplesSerializer(model, null), "Configuration cannot be null"); } @Test - @DisplayName("Write should serialize simple statement correctly") + @DisplayName("L'écriture devrait sérialiser une déclaration simple correctement (graphe par défaut)") void writeShouldSerializeSimpleStatement() throws SerializationException { Statement stmt = createStatement( mockExPerson, @@ -79,7 +80,6 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { StringWriter writer = new StringWriter(); nTriplesSerializer.write(writer); - String expected = String.format("<%s> <%s> \"%s\"", mockExPerson.stringValue(), mockExName.stringValue(), @@ -89,7 +89,7 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { } @Test - @DisplayName("Write should serialize statement with context but ignore it (N-Triples)") + @DisplayName("L'écriture devrait sérialiser une déclaration avec contexte mais l'ignorer (N-Triples)") void writeShouldSerializeStatementWithContext() throws SerializationException { IRI mockContext = createIRI("http://example.org/ctx"); Statement stmt = createStatement( @@ -112,7 +112,7 @@ void writeShouldSerializeStatementWithContext() throws SerializationException { } @Test - @DisplayName("Write should handle blank nodes with default N-Triples prefix (_:)") + @DisplayName("L'écriture devrait gérer les nœuds vierges avec le préfixe N-Triples par défaut (_:)") void writeShouldHandleBlankNodes() throws SerializationException { Statement stmt = createStatement( mockBNode1, @@ -133,7 +133,7 @@ void writeShouldHandleBlankNodes() throws SerializationException { } @Test - @DisplayName("Write should throw SerializationException on IO error") + @DisplayName("L'écriture devrait lever SerializationException en cas d'erreur E/S") void writeShouldThrowOnIOException() throws IOException { Statement stmt = createStatement( mockExPerson, @@ -155,12 +155,13 @@ void writeShouldThrowOnIOException() throws IOException { @Test - @DisplayName("Write should throw SerializationException on null subject value from Statement in strict mode") + @DisplayName("L'écriture devrait lever SerializationException pour une valeur de sujet nulle dans le mode strict") void writeShouldThrowOnNullSubjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(null); when(stmt.getPredicate()).thenReturn(mockExName); when(stmt.getObject()).thenReturn(mockLiteralJohn); + when(stmt.getContext()).thenReturn(null); when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); @@ -170,12 +171,13 @@ void writeShouldThrowOnNullSubjectValue() { } @Test - @DisplayName("Write should throw SerializationException on null predicate value from Statement in strict mode") + @DisplayName("L'écriture devrait lever SerializationException pour une valeur de prédicat nulle dans le mode strict") void writeShouldThrowOnNullPredicateValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); when(stmt.getPredicate()).thenReturn(null); when(stmt.getObject()).thenReturn(mockLiteralJohn); + when(stmt.getContext()).thenReturn(null); when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); @@ -184,12 +186,12 @@ void writeShouldThrowOnNullPredicateValue() { } @Test - @DisplayName("Write should throw SerializationException on null object value from Statement in strict mode") + @DisplayName("L'écriture devrait lever SerializationException pour une valeur d'objet nulle dans le mode strict") void writeShouldThrowOnNullObjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); when(stmt.getPredicate()).thenReturn(mockExName); - when(stmt.getObject()).thenReturn(null); // L'objet est null + when(stmt.getObject()).thenReturn(null); when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); @@ -199,38 +201,89 @@ void writeShouldThrowOnNullObjectValue() { @Test - @DisplayName("Should handle literals with language tags correctly") - void shouldHandleLiteralsWithLanguageTags() throws SerializationException { - IRI subject = createIRI("http://example.org/person"); - IRI predicate = createIRI("http://example.org/greeting"); - Literal object = createLiteral("Hello", "en"); // Use the helper that sets rdf:langString + @DisplayName("Devrait gérer correctement le contexte nul (graphe par défaut)") + void writeShouldHandleNullContext() throws SerializationException { + Statement stmt = createStatement( + mockExPerson, + mockExName, + mockLiteralJohn, + null + ); + when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); - Statement stmt = createStatement(subject, predicate, object); + StringWriter writer = new StringWriter(); + nTriplesSerializer.write(writer); - Model modelMock = mock(Model.class); - when(modelMock.iterator()).thenReturn(new MockStatementIterator(stmt)); - SerializerConfig testConfig = new SerializerConfig.Builder() - .strictMode(true) // Keep strict mode enabled to test validation - .build(); + String expected = String.format("<%s> <%s> \"%s\"", + mockExPerson.stringValue(), + mockExName.stringValue(), + escapeNTriplesString(lexJohn)) + " .\n"; + + assertEquals(expected, writer.toString()); + } - NTriplesSerializer serializer = new NTriplesSerializer(modelMock, testConfig); + @ParameterizedTest + @ValueSource(strings = { + "simple literal", + "literal with \"quotes\"", + "literal with \\ backslash", + "literal with \n newline", + "literal with \t tab", + "literal with \r carriage return", + "literal with \u0001 (SOH)", + "literal with \u007F (DEL)" + }) + @DisplayName("L'écriture devrait gérer diverses valeurs littérales avec un échappement approprié (y compris Unicode)") + void writeShouldHandleVariousLiterals(String literalValue) throws SerializationException { + Literal literalMock = createLiteral(literalValue, null, null); + + Statement stmt = createStatement( + mockExPerson, + mockExName, + literalMock + ); + when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); + nTriplesSerializer.write(writer); + + + String expectedEscapedLiteral = escapeNTriplesString(literalValue); + String expectedOutput = String.format("<%s> <%s> \"%s\"", + mockExPerson.stringValue(), + mockExName.stringValue(), + expectedEscapedLiteral) + " .\n"; + + assertEquals(expectedOutput, writer.toString()); + } + + + @Test + @DisplayName("Devrait gérer les littéraux avec des balises de langue") + void shouldHandleLiteralsWithLanguageTags() throws SerializationException { + Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/greeting"), mockLiteralHelloEn); + + Model currentTestModel = mock(Model.class); + when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); + + Writer writer = new StringWriter(); + + NTriplesSerializer serializer = new NTriplesSerializer(currentTestModel, NTriplesConfig.defaultConfig()); serializer.write(writer); String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", - subject.stringValue(), - predicate.stringValue(), - escapeNTriplesString("Hello"), - "en") + " .\n"; + mockExPerson.stringValue(), + createIRI("http://example.org/greeting").stringValue(), + escapeNTriplesString(hello), + mockLiteralHelloEn.getLanguage().get()) + " .\n"; assertEquals(expectedOutput, writer.toString()); } @Test - @DisplayName("Should handle literals with custom datatypes") + @DisplayName("Devrait gérer les littéraux avec des types de données personnalisés") void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { IRI customDatatype = createIRI("http://example.org/myDataType"); Literal customLiteral = createLiteral("123", customDatatype, null); @@ -240,7 +293,7 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { Model currentTestModel = mock(Model.class); when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); - NTriplesSerializer serializer = new NTriplesSerializer(currentTestModel, SerializerConfig.ntriplesConfig()); + NTriplesSerializer serializer = new NTriplesSerializer(currentTestModel, NTriplesConfig.defaultConfig()); StringWriter writer = new StringWriter(); serializer.write(writer); @@ -256,13 +309,40 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { /** - * Escapes a string according to N-Triples literal escaping rules. - * This helper is used in tests to construct the *expected* output strings. - * It mimics the behavior of nTriplesSerializer's internal escapeLiteral method, - * specifically when `escapeUnicode` is true (as per ntriplesConfig() default). + * Crée un objet Literal mocké. + * Important : le `lexicalForm` est la *valeur de chaîne brute* du littéral, + * sans les guillemets spécifiques à N-Triples, les balises de langue ou les URI de type de données. + * La classe `nTriplesSerializer` est chargée d'ajouter ceux-ci. + * + * @param lexicalForm La valeur de chaîne brute du littéral (par exemple, "hello", "123"). + * @param dataTypeIRI L'IRI du type de données du littéral (par exemple, XSD.INTEGER.getIRI()), ou null pour simple/avec balise de langue. + * @param langTag La balise de langue (par exemple, "en"), ou null si non balisé par la langue. + * @return Une instance de Literal mockée. + */ + private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { + Literal literal = mock(Literal.class); + when(literal.isLiteral()).thenReturn(true); + when(literal.isResource()).thenReturn(false); + when(literal.stringValue()).thenReturn(lexicalForm); + + if (langTag != null && !langTag.isEmpty()) { + when(literal.getLanguage()).thenReturn(Optional.of(langTag)); + when(literal.getDatatype()).thenReturn(RDF.langString.getIRI()); + } else { + when(literal.getLanguage()).thenReturn(Optional.empty()); + when(literal.getDatatype()).thenReturn(dataTypeIRI); + } + return literal; + } + + /** + * Échappe une chaîne selon les règles d'échappement des littéraux N-Triples. + * Cette aide est utilisée dans les tests pour construire les chaînes de sortie *attendues*. + * Elle imite le comportement de la méthode interne `escapeLiteral` de `nTriplesSerializer`, + * en considérant que `ntriplesConfig().escapeUnicode()` est `true`. * - * @param s The string to escape. - * @return The escaped string. + * @param s La chaîne à échapper. + * @return La chaîne échappée. */ private String escapeNTriplesString(String s) { StringBuilder sb = new StringBuilder(); @@ -301,7 +381,6 @@ private String escapeNTriplesString(String s) { return sb.toString(); } - private static class MockStatementIterator implements Iterator { private final Statement[] statements; private int index = 0; @@ -321,35 +400,6 @@ public Statement next() { } } - - /** - * Creates a mocked Literal object. - * Important: The `lexicalForm` is the *raw string value* of the literal, - * without N-Triples specific quotes, lang tags, or datatype URIs. - * The `nTriplesSerializer` class is responsible for adding those. - * - * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). - * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. - * @param langTag The language tag (e.g., "en"), or null if not language-tagged. - * @return A mocked Literal instance. - */ - private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { - Literal literal = mock(Literal.class); - when(literal.isLiteral()).thenReturn(true); - when(literal.isResource()).thenReturn(false); - when(literal.stringValue()).thenReturn(lexicalForm); - - if (langTag != null && !langTag.isEmpty()) { - when(literal.getLanguage()).thenReturn(Optional.of(langTag)); - // When a language tag is present, the datatype should be rdf:langString implicitly or explicitly - when(literal.getDatatype()).thenReturn(RDF.langString.getIRI()); - } else { - when(literal.getLanguage()).thenReturn(Optional.empty()); - when(literal.getDatatype()).thenReturn(dataTypeIRI); // Can be XSD.STRING.getIRI() or any custom IRI - } - return literal; - } - private Statement createStatement(Resource subject, IRI predicate, Value object) { return createStatement(subject, predicate, object, null); } @@ -380,14 +430,4 @@ private IRI createIRI(String uri) { when(iri.stringValue()).thenReturn(uri); return iri; } - - public static Literal createLiteral(String value, String lang) { - Literal mockLiteral = mock(Literal.class); - when(mockLiteral.stringValue()).thenReturn(value); // Removed quotes here - when(mockLiteral.getLanguage()).thenReturn(Optional.of(lang)); - when(mockLiteral.isLiteral()).thenReturn(true); - when(mockLiteral.isResource()).thenReturn(false); - when(mockLiteral.getDatatype()).thenReturn(RDF.langString.getIRI()); - return mockLiteral; - } -} \ No newline at end of file +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerConfigTest.java deleted file mode 100644 index 65d915f9e..000000000 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/SerializerConfigTest.java +++ /dev/null @@ -1,189 +0,0 @@ -package fr.inria.corese.core.next.impl.common.serialization; - -import fr.inria.corese.core.next.impl.common.serialization.config.BlankNodeStyleEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; -import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; -import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; - -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.*; - -class SerializerConfigTest { - @Test - @DisplayName("ntriplesConfig() should return correct default config for N-Triples") - void ntriplesConfigReturnsCorrectConfig() { - SerializerConfig config = SerializerConfig.ntriplesConfig(); - - assertFalse(config.usePrefixes()); - assertFalse(config.autoDeclarePrefixes()); - assertFalse(config.useCompactTriples()); - assertFalse(config.useRdfTypeShortcut()); - assertFalse(config.useCollections()); - assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle()); - assertFalse(config.prettyPrint()); - assertEquals("", config.getIndent()); - assertEquals(0, config.getMaxLineLength()); - assertFalse(config.groupBySubject()); - assertFalse(config.sortSubjects()); - assertFalse(config.sortPredicates()); - assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy()); - assertTrue(config.escapeUnicode()); - assertTrue(config.trailingDot()); - assertNull(config.getBaseIRI()); - assertTrue(config.stableBlankNodeIds()); - assertTrue(config.isStrictMode()); - assertTrue(config.validateURIs()); - assertFalse(config.includeContext()); - assertEquals(SerializationConstants.DEFAULT_LINE_ENDING, config.getLineEnding()); - assertTrue(config.getCustomPrefixes().isEmpty()); - } - - @Test - @DisplayName("nquadsConfig() should return correct default config for N-Quads") - void nquadsConfigReturnsCorrectConfig() { - SerializerConfig config = SerializerConfig.nquadsConfig(); - - assertFalse(config.usePrefixes()); - assertFalse(config.autoDeclarePrefixes()); - assertFalse(config.useCompactTriples()); - assertFalse(config.useRdfTypeShortcut()); - assertFalse(config.useCollections()); - assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle()); - assertFalse(config.prettyPrint()); - assertEquals("", config.getIndent()); - assertEquals(0, config.getMaxLineLength()); - assertFalse(config.groupBySubject()); - assertFalse(config.sortSubjects()); - assertFalse(config.sortPredicates()); - assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy()); - assertTrue(config.escapeUnicode()); - assertTrue(config.trailingDot()); - assertNull(config.getBaseIRI()); - assertTrue(config.stableBlankNodeIds()); - assertTrue(config.isStrictMode()); - assertTrue(config.validateURIs()); - assertTrue(config.includeContext()); - assertEquals(SerializationConstants.DEFAULT_LINE_ENDING, config.getLineEnding()); - assertTrue(config.getCustomPrefixes().isEmpty()); - } - - @Test - @DisplayName("rdfXmlConfig() devrait retourner la configuration par défaut correcte pour RDF/XML") - void rdfXmlConfigReturnsCorrectConfig() { - SerializerConfig config = SerializerConfig.rdfXmlConfig(); - - assertTrue(config.usePrefixes()); - assertTrue(config.autoDeclarePrefixes()); - assertEquals(PrefixOrderingEnum.ALPHABETICAL, config.getPrefixOrdering()); - assertFalse(config.useCompactTriples()); - assertFalse(config.useRdfTypeShortcut()); - assertFalse(config.useCollections()); - assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle()); - assertTrue(config.prettyPrint()); - assertEquals(SerializationConstants.DEFAULT_INDENTATION, config.getIndent()); - assertEquals(0, config.getMaxLineLength()); - assertFalse(config.groupBySubject()); - assertFalse(config.sortSubjects()); - assertFalse(config.sortPredicates()); - assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy()); - assertFalse(config.escapeUnicode()); - assertFalse(config.trailingDot()); - assertNull(config.getBaseIRI()); - assertTrue(config.stableBlankNodeIds()); - assertFalse(config.includeContext()); - assertEquals(SerializationConstants.DEFAULT_LINE_ENDING, config.getLineEnding()); - - - Map customPrefixes = config.getCustomPrefixes(); - assertFalse(customPrefixes.isEmpty()); - assertEquals(SerializationConstants.RDF_NS, customPrefixes.get("rdf")); - assertEquals(SerializationConstants.RDFS_NS, customPrefixes.get("rdfs")); - assertEquals(SerializationConstants.XSD_NS, customPrefixes.get("xsd")); - assertEquals(SerializationConstants.OWL_NS, customPrefixes.get("owl")); - } - - - - @Test - @DisplayName("SerializerConfig constructor should be private and only accessible via builder") - void constructorIsPrivateAndAccessibleViaBuilder() { - - SerializerConfig config = new SerializerConfig.Builder().build(); - assertNotNull(config); - } - - @Test - @DisplayName("blankNodeStyle method in Builder should throw NullPointerException for null style") - void blankNodeStyleShouldThrowForNull() { - SerializerConfig.Builder builder = new SerializerConfig.Builder(); - assertThrows(NullPointerException.class, () -> builder.blankNodeStyle(null), - "Setting a null blankNodeStyle should throw NullPointerException"); - } - - @Test - @DisplayName("indent method in Builder should throw NullPointerException for null indent") - void indentShouldThrowForNull() { - SerializerConfig.Builder builder = new SerializerConfig.Builder(); - assertThrows(NullPointerException.class, () -> builder.indent(null), - "Setting a null indent should throw NullPointerException"); - } - - @Test - @DisplayName("lineEnding method in Builder should throw NullPointerException for null lineEnding") - void lineEndingShouldThrowForNull() { - SerializerConfig.Builder builder = new SerializerConfig.Builder(); - assertThrows(NullPointerException.class, () -> builder.lineEnding(null), - "Setting a null lineEnding should throw NullPointerException"); - } - - @Test - @DisplayName("prefixOrdering method in Builder should throw NullPointerException for null prefixOrdering") - void prefixOrderingShouldThrowForNull() { - SerializerConfig.Builder builder = new SerializerConfig.Builder(); - assertThrows(NullPointerException.class, () -> builder.prefixOrdering(null), - "Setting a null prefixOrdering should throw NullPointerException"); - } - - @Test - @DisplayName("Builder should create SerializerConfig with all default values") - void builderShouldCreateWithAllDefaults() { - SerializerConfig config = new SerializerConfig.Builder().build(); - - assertNotNull(config, "SerializerConfig should not be null"); - - // --- Syntax Sugar Defaults --- - assertTrue(config.usePrefixes(), "Default usePrefixes should be true"); - assertTrue(config.autoDeclarePrefixes(), "Default autoDeclarePrefixes should be true"); - assertEquals(PrefixOrderingEnum.ALPHABETICAL, config.getPrefixOrdering(), "Default prefixOrdering should be ALPHABETICAL"); - assertTrue(config.getCustomPrefixes().isEmpty(), "Default customPrefixes map should be empty"); - assertTrue(config.useCompactTriples(), "Default useCompactTriples should be true"); - assertTrue(config.useRdfTypeShortcut(), "Default useRdfTypeShortcut should be true"); - assertFalse(config.useCollections(), "Default useCollections should be false"); - assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle(), "Default blankNodeStyle should be NAMED"); - - // --- Pretty-Printing Defaults --- - assertTrue(config.prettyPrint(), "Default prettyPrint should be true"); - assertEquals(SerializationConstants.DEFAULT_INDENTATION, config.getIndent(), "Default indent should be " + SerializationConstants.DEFAULT_INDENTATION); - assertEquals(80, config.getMaxLineLength(), "Default maxLineLength should be 80"); - assertTrue(config.groupBySubject(), "Default groupBySubject should be true"); - assertFalse(config.sortSubjects(), "Default sortSubjects should be false"); - assertFalse(config.sortPredicates(), "Default sortPredicates should be false"); - - // --- Technical Output Defaults --- - assertEquals(LiteralDatatypePolicyEnum.MINIMAL, config.getLiteralDatatypePolicy(), "Default literalDatatypePolicy should be MINIMAL"); - assertFalse(config.escapeUnicode(), "Default escapeUnicode should be false"); - assertTrue(config.trailingDot(), "Default trailingDot should be true"); - assertNull(config.getBaseIRI(), "Default baseIRI should be null"); - assertFalse(config.stableBlankNodeIds(), "Default stableBlankNodeIds should be false"); - - // --- Validation & Context Defaults --- - assertTrue(config.isStrictMode(), "Default strictMode should be true"); - assertTrue(config.validateURIs(), "Default validateURIs should be true"); - assertFalse(config.includeContext(), "Default includeContext should be false"); - assertEquals(SerializationConstants.DEFAULT_LINE_ENDING, config.getLineEnding(), "Default lineEnding should be " + SerializationConstants.DEFAULT_LINE_ENDING); - } -} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java index 39fe649cc..43f8c8fca 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java @@ -2,15 +2,17 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.TriGConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.StringWriter; -import java.util.*; +import java.util.Collections; +import java.util.Optional; import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -18,11 +20,20 @@ import static org.mockito.Mockito.*; /** - * Test class for {@link TriGSerializerTest} using Mockito to verify serialization behavior + * Test class for {@link TriGSerializer} using Mockito to verify serialization behavior * under various configurations and RDF graph structures. */ class TriGSerializerTest { + private Model mockModel; + private TriGConfig defaultConfig; + + @BeforeEach + void setUp() { + mockModel = mock(Model.class); + defaultConfig = TriGConfig.defaultConfig(); + } + /** * Tests basic TriG serialization of a simple triple. * Verifies that the subject, predicate, and object are correctly formatted @@ -33,40 +44,12 @@ class TriGSerializerTest { */ @Test void testBasicTriGSerialization() throws SerializationException, IOException { - // Given - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - - when(mockSubject.stringValue()).thenReturn("http://example.org/ns/person1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/ns/hasName"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - - when(mockObject.stringValue()).thenReturn("John Doe"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(null); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/ns/person1"), + createIRI("http://example.org/ns/hasName"), + createLiteral("John Doe", null, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -75,20 +58,12 @@ void testBasicTriGSerialization() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TriGSerializer triGSerializer = new TriGSerializer(mockModel, SerializerConfig.trigConfig()); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, defaultConfig); triGSerializer.write(writer); - verify(mockModel, times(2)).stream(); - verify(mockSubject, atLeastOnce()).stringValue(); - verify(mockSubject, atLeastOnce()).isIRI(); - verify(mockPredicate, atLeastOnce()).stringValue(); - verify(mockPredicate, atLeastOnce()).isIRI(); - verify(mockObject, atLeastOnce()).stringValue(); - verify(mockObject, atLeastOnce()).isLiteral(); - String expected = """ @prefix ns: . @@ -115,34 +90,12 @@ void testBasicTriGSerialization() throws SerializationException, IOException { @Test void testRdfTypeShortcut() throws SerializationException, IOException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - IRI mockObject = mock(IRI.class); - - when(mockSubject.stringValue()).thenReturn("http://example.org/ns/person1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - when(mockPredicate.stringValue()).thenReturn(SerializationConstants.RDF_TYPE); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - when(mockObject.stringValue()).thenReturn("http://xmlns.com/foaf/0.1/Person"); - when(mockObject.isIRI()).thenReturn(true); - when(mockObject.isResource()).thenReturn(true); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.isLiteral()).thenReturn(false); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/ns/person1"), + createIRI(SerializationConstants.RDF_TYPE), + createIRI("http://xmlns.com/foaf/0.1/Person"), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -150,7 +103,7 @@ void testRdfTypeShortcut() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TriGSerializer triGSerializer = new TriGSerializer(mockModel); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, defaultConfig); triGSerializer.write(writer); @@ -158,7 +111,7 @@ void testRdfTypeShortcut() throws SerializationException, IOException { verify(mockModel, times(2)).stream(); - String expected = """ + String expected = """ @prefix foaf: . @prefix ns: . @prefix owl: . @@ -184,43 +137,12 @@ void testRdfTypeShortcut() throws SerializationException, IOException { @Test void testLiteralWithLanguageTag() throws SerializationException, IOException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - - when(mockSubject.stringValue()).thenReturn("http://example.org/data/book1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://purl.org/dc/elements/1.1/title"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - when(mockObject.stringValue()).thenReturn("The Odyssey"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.of("en")); - - IRI mockRdfLangString = mock(IRI.class); - when(mockRdfLangString.stringValue()).thenReturn(RDF.LANGSTRING.getIRI().stringValue()); - when(mockRdfLangString.isIRI()).thenReturn(true); - when(mockRdfLangString.isResource()).thenReturn(true); - when(mockObject.getDatatype()).thenReturn(mockRdfLangString); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/data/book1"), + createIRI("http://purl.org/dc/elements/1.1/title"), + createLiteral("The Odyssey", null, "en"), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -230,27 +152,10 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - // Explicitly create SerializerConfig to ensure strictMode is false - Map commonTriGPrefixes = new HashMap<>(); - commonTriGPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - commonTriGPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - commonTriGPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); - commonTriGPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); - - SerializerConfig config = new SerializerConfig.Builder() - .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) - .useRdfTypeShortcut(true) - .useCollections(true) - .groupBySubject(true) - .prettyPrint(true) - .indent(" ") - .lineEnding("\n") - .addCustomPrefixes(commonTriGPrefixes) - .autoDeclarePrefixes(true) - .trailingDot(true) + TriGConfig customConfig = new TriGConfig.Builder() .strictMode(false) .build(); - TriGSerializer triGSerializer = new TriGSerializer(mockModel, config); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, customConfig); triGSerializer.write(writer); @@ -265,7 +170,8 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { @prefix rdfs: . @prefix xsd: . - data:book1 11:title \"The Odyssey\"@en . + data:book1 11:title "The Odyssey"@en . + """; String actual = writer.toString().replace("\r\n", "\n"); assertEquals(expected, actual); @@ -280,45 +186,13 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { */ @Test void testLiteralWithExplicitXsdStringType() throws SerializationException, IOException { - // Given - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - IRI mockDatatype = mock(IRI.class); - - // Configure mocks - when(mockSubject.stringValue()).thenReturn("http://example.org/data/book2"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://purl.org/dc/elements/1.1/creator"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - when(mockDatatype.stringValue()).thenReturn(SerializationConstants.XSD_STRING); - when(mockDatatype.isIRI()).thenReturn(true); - when(mockDatatype.isResource()).thenReturn(true); - - when(mockObject.stringValue()).thenReturn("Homer"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(mockDatatype); - - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + IRI mockDatatype = createIRI(SerializationConstants.XSD_STRING); + Statement mockStatement = createStatement( + createIRI("http://example.org/data/book2"), + createIRI("http://purl.org/dc/elements/1.1/creator"), + createLiteral("Homer", mockDatatype, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -328,35 +202,26 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc StringWriter writer = new StringWriter(); - Map commonTrigPrefixes = new HashMap<>(); - commonTrigPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - commonTrigPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - commonTrigPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); - commonTrigPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); - commonTrigPrefixes.put("dc", "http://purl.org/dc/elements/1.1/"); - - SerializerConfig config = new SerializerConfig.Builder() + TriGConfig customConfig = new TriGConfig.Builder() .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) - .addCustomPrefixes(commonTrigPrefixes) - .usePrefixes(true) - .autoDeclarePrefixes(true) .build(); - TriGSerializer triGSerializer = new TriGSerializer(mockModel, config); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, customConfig); triGSerializer.write(writer); verify(mockModel, times(2)).stream(); - String expected = """ + String expected = """ + @prefix 11: . @prefix data: . - @prefix dc: . @prefix owl: . @prefix rdf: . @prefix rdfs: . @prefix xsd: . - data:book2 dc:creator \"Homer\"^^xsd:string . + data:book2 11:creator "Homer"^^xsd:string . + """; String actual = writer.toString().replace("\r\n", "\n"); assertEquals(expected, actual); @@ -372,38 +237,12 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc */ @Test void testBaseIRI() throws SerializationException, IOException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - when(mockSubject.stringValue()).thenReturn("http://example.org/base/resource1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/base/prop"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - - when(mockObject.stringValue()).thenReturn("Test"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(null); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/base/resource1"), + createIRI("http://example.org/base/prop"), + createLiteral("Test", null, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -413,18 +252,8 @@ void testBaseIRI() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - Map commonTrigPrefixes = new HashMap<>(); - commonTrigPrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - commonTrigPrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - commonTrigPrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); - commonTrigPrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); - commonTrigPrefixes.put("base", "http://example.org/base/"); - - SerializerConfig configWithBase = new SerializerConfig.Builder() + TriGConfig configWithBase = new TriGConfig.Builder() .baseIRI("http://example.org/base/") - .addCustomPrefixes(commonTrigPrefixes) - .usePrefixes(true) - .autoDeclarePrefixes(true) .build(); TriGSerializer triGSerializer = new TriGSerializer(mockModel, configWithBase); @@ -439,7 +268,8 @@ void testBaseIRI() throws SerializationException, IOException { @prefix rdfs: . @prefix xsd: . - base:resource1 base:prop "Test" . + base:resource1 base:prop "Test" . + """; String actual = writer.toString().replace("\r\n", "\n"); assertEquals(expected, actual); @@ -463,7 +293,7 @@ void testEmptyModel() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TriGSerializer triGSerializer = new TriGSerializer(emptyModel); + TriGSerializer triGSerializer = new TriGSerializer(emptyModel, defaultConfig); triGSerializer.write(writer); @@ -491,42 +321,12 @@ void testEmptyModel() throws SerializationException, IOException { @Test void testStrictModeInvalidLiteral() throws SerializationException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - when(mockSubject.stringValue()).thenReturn("http://example.org/s"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/p"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - when(mockObject.stringValue()).thenReturn("invalid"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - IRI mockRdfLangStringDatatype = mock(IRI.class); - when(mockRdfLangStringDatatype.stringValue()).thenReturn(RDF.LANGSTRING.getIRI().stringValue()); - when(mockRdfLangStringDatatype.isIRI()).thenReturn(true); - when(mockRdfLangStringDatatype.isResource()).thenReturn(true); - when(mockObject.getDatatype()).thenReturn(mockRdfLangStringDatatype); - - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/s"), + createIRI("http://example.org/p"), + createLiteral("invalid", RDF.LANGSTRING.getIRI(), null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -535,7 +335,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { StringWriter writer = new StringWriter(); - SerializerConfig strictConfig = new SerializerConfig.Builder().strictMode(true).build(); + TriGConfig strictConfig = new TriGConfig.Builder().strictMode(true).build(); TriGSerializer triGSerializer = new TriGSerializer(mockModel, strictConfig); @@ -557,37 +357,12 @@ void testStrictModeInvalidLiteral() throws SerializationException { @Test void testStrictModeInvalidIRICharacters() throws SerializationException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - IRI mockObject = mock(IRI.class); - - - when(mockSubject.stringValue()).thenReturn("http://example.org/s"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/p"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - - when(mockObject.stringValue()).thenReturn("http://example.org/invalid iri"); - when(mockObject.isIRI()).thenReturn(true); - when(mockObject.isResource()).thenReturn(true); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.isLiteral()).thenReturn(false); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/s"), + createIRI("http://example.org/p"), + createIRI("http://example.org/invalid iri"), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -596,7 +371,7 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { StringWriter writer = new StringWriter(); - SerializerConfig strictConfig = new SerializerConfig.Builder().strictMode(true).validateURIs(true).build(); + TriGConfig strictConfig = new TriGConfig.Builder().strictMode(true).validateURIs(true).build(); TriGSerializer triGSerializer = new TriGSerializer(mockModel, strictConfig); @@ -618,40 +393,14 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { */ @Test void testMultilineLiteralSerialization() throws SerializationException, IOException { - // Given - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - - when(mockSubject.stringValue()).thenReturn("http://example.org/book/1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/properties/description"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); String multilineText = "This is the first line.\nThis is the second line."; - when(mockObject.stringValue()).thenReturn(multilineText); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(null); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/book/1"), + createIRI("http://example.org/properties/description"), + createLiteral(multilineText, null, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -659,32 +408,28 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - SerializerConfig config = new SerializerConfig.Builder() + // Create a TriGConfig with useMultilineLiterals enabled + TriGConfig customConfig = new TriGConfig.Builder() .useMultilineLiterals(true) .prettyPrint(true) - .autoDeclarePrefixes(true) .build(); - TriGSerializer triGSerializer = new TriGSerializer(mockModel, config); + TriGSerializer triGSerializer = new TriGSerializer(mockModel, customConfig); triGSerializer.write(writer); verify(mockModel, times(2)).stream(); - verify(mockSubject, atLeastOnce()).stringValue(); - verify(mockSubject, atLeastOnce()).isIRI(); - verify(mockPredicate, atLeastOnce()).stringValue(); - verify(mockPredicate, atLeastOnce()).isIRI(); - verify(mockObject, atLeastOnce()).stringValue(); - verify(mockObject, atLeastOnce()).isLiteral(); String expected = """ @prefix book: . + @prefix owl: . @prefix properties: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . - book:1 properties:description \"\"\"This is the first line. - This is the second line.\"\"\" . - """; + book:1 properties:description\s""" + "\"\"\"" + multilineText + "\"\"\"" + " .\n\n"; String actual = writer.toString().replace("\r\n", "\n"); assertEquals(expected, actual); @@ -699,74 +444,25 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept */ @Test void testBasicTrigSerializationWithNamedGraph() throws SerializationException, IOException { - // Given - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - IRI mockContext = mock(IRI.class); - - - when(mockSubject.stringValue()).thenReturn("http://example.org/data/person1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/data/name"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - - when(mockObject.stringValue()).thenReturn("Alice"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(null); - - - when(mockContext.stringValue()).thenReturn("http://example.org/graph/g1"); - when(mockContext.isIRI()).thenReturn(true); - when(mockContext.isResource()).thenReturn(true); - when(mockContext.isBNode()).thenReturn(false); - when(mockContext.isLiteral()).thenReturn(false); - - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(mockContext); + Statement mockStatement = createStatement( + createIRI("http://example.org/data/person1"), + createIRI("http://example.org/data/name"), + createLiteral("Alice", null, null), + createIRI("http://example.org/graph/g1") + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) .thenReturn(Stream.of(mockStatement)) .thenReturn(Stream.of(mockStatement)) .thenReturn(Stream.of(mockStatement)); - StringWriter writer = new StringWriter(); - TriGSerializer triGSerializer = new TriGSerializer(mockModel, SerializerConfig.trigConfig()); - + TriGSerializer triGSerializer = new TriGSerializer(mockModel, defaultConfig); triGSerializer.write(writer); - verify(mockModel, times(2)).stream(); - verify(mockSubject, atLeastOnce()).stringValue(); - verify(mockSubject, atLeastOnce()).isIRI(); - verify(mockPredicate, atLeastOnce()).stringValue(); - verify(mockPredicate, atLeastOnce()).isIRI(); - verify(mockObject, atLeastOnce()).stringValue(); - verify(mockObject, atLeastOnce()).isLiteral(); - verify(mockContext, atLeastOnce()).stringValue(); - verify(mockContext, atLeastOnce()).isIRI(); - String expected = """ @prefix data: . @prefix graph: . @@ -784,4 +480,48 @@ void testBasicTrigSerializationWithNamedGraph() throws SerializationException, I String actual = writer.toString().replace("\r\n", "\n"); assertEquals(expected, actual); } + + + private Statement createStatement(Resource subject, IRI predicate, Value object, Resource context) { + Statement stmt = mock(Statement.class); + when(stmt.getSubject()).thenReturn(subject); + when(stmt.getPredicate()).thenReturn(predicate); + when(stmt.getObject()).thenReturn(object); + when(stmt.getContext()).thenReturn(context); + return stmt; + } + + + private IRI createIRI(String uri) { + IRI iri = mock(IRI.class); + when(iri.isResource()).thenReturn(true); + when(iri.isIRI()).thenReturn(true); + when(iri.isBNode()).thenReturn(false); + when(iri.stringValue()).thenReturn(uri); + return iri; + } + + /** + * Creates a mocked Literal object. + * + * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). + * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. + * @param langTag The language tag (e.g., "en"), or null if not language-tagged. + * @return A mocked Literal instance. + */ + private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { + Literal literal = mock(Literal.class); + when(literal.isLiteral()).thenReturn(true); + when(literal.isResource()).thenReturn(false); + when(literal.stringValue()).thenReturn(lexicalForm); + + if (langTag != null && !langTag.isEmpty()) { + when(literal.getLanguage()).thenReturn(Optional.of(langTag)); + when(literal.getDatatype()).thenReturn(RDF.LANGSTRING.getIRI()); + } else { + when(literal.getLanguage()).thenReturn(Optional.empty()); + when(literal.getDatatype()).thenReturn(dataTypeIRI); + } + return literal; + } } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java index b867f53cc..46b38fef4 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java @@ -3,14 +3,18 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; +import fr.inria.corese.core.next.impl.common.serialization.config.TurtleConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.StringWriter; -import java.util.*; +import java.util.Arrays; +import java.util.Collections; +import java.util.Optional; import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -18,11 +22,20 @@ import static org.mockito.Mockito.*; /** - * Test class for {@link TurtleSerializerTest} using Mockito to verify serialization behavior + * Test class for {@link TurtleSerializer} using Mockito to verify serialization behavior * under various configurations and RDF graph structures. */ class TurtleSerializerTest { + private Model mockModel; + private TurtleConfig defaultConfig; + + @BeforeEach + void setUp() { + mockModel = mock(Model.class); + defaultConfig = TurtleConfig.defaultConfig(); + } + /** * Tests basic Turtle serialization of a simple triple. * Verifies that the subject, predicate, and object are correctly formatted @@ -33,41 +46,12 @@ class TurtleSerializerTest { */ @Test void testBasicTurtleSerialization() throws SerializationException, IOException { - // Given - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - // Configure mocks for the subject - when(mockSubject.stringValue()).thenReturn("http://example.org/ns/person1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - // Configure mocks for the predicate - when(mockPredicate.stringValue()).thenReturn("http://example.org/ns/hasName"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - // Configure mocks for the object (literal) - when(mockObject.stringValue()).thenReturn("John Doe"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(null); - - // Configure the statement - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/ns/person1"), + createIRI("http://example.org/ns/hasName"), + createLiteral("John Doe", null, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -75,20 +59,11 @@ void testBasicTurtleSerialization() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, SerializerConfig.turtleConfig()); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, defaultConfig); - // When turtleSerializer.write(writer); - // Then verify(mockModel, times(2)).stream(); - verify(mockSubject, atLeastOnce()).stringValue(); - verify(mockSubject, atLeastOnce()).isIRI(); - verify(mockPredicate, atLeastOnce()).stringValue(); - verify(mockPredicate, atLeastOnce()).isIRI(); - verify(mockObject, atLeastOnce()).stringValue(); - verify(mockObject, atLeastOnce()).isLiteral(); - String expected = """ @prefix ns: . @@ -113,36 +88,13 @@ void testBasicTurtleSerialization() throws SerializationException, IOException { */ @Test void testRdfTypeShortcut() throws SerializationException, IOException { - // Given - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - IRI mockObject = mock(IRI.class); - - // Configure mocks - when(mockSubject.stringValue()).thenReturn("http://example.org/ns/person1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - when(mockPredicate.stringValue()).thenReturn(SerializationConstants.RDF_TYPE); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - when(mockObject.stringValue()).thenReturn("http://xmlns.com/foaf/0.1/Person"); - when(mockObject.isIRI()).thenReturn(true); - when(mockObject.isResource()).thenReturn(true); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.isLiteral()).thenReturn(false); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + + Statement mockStatement = createStatement( + createIRI("http://example.org/ns/person1"), + createIRI(SerializationConstants.RDF_TYPE), + createIRI("http://xmlns.com/foaf/0.1/Person"), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -150,15 +102,14 @@ void testRdfTypeShortcut() throws SerializationException, IOException { .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, defaultConfig); + - // When turtleSerializer.write(writer); - // Then verify(mockModel, times(2)).stream(); - String expected = """ + String expected = """ @prefix foaf: . @prefix ns: . @prefix owl: . @@ -183,43 +134,12 @@ void testRdfTypeShortcut() throws SerializationException, IOException { @Test void testLiteralWithLanguageTag() throws SerializationException, IOException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - - when(mockSubject.stringValue()).thenReturn("http://example.org/data/book1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://purl.org/dc/elements/1.1/title"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - when(mockObject.stringValue()).thenReturn("The Odyssey"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.of("en")); - - IRI mockRdfLangString = mock(IRI.class); - when(mockRdfLangString.stringValue()).thenReturn(RDF.LANGSTRING.getIRI().stringValue()); - when(mockRdfLangString.isIRI()).thenReturn(true); - when(mockRdfLangString.isResource()).thenReturn(true); - when(mockObject.getDatatype()).thenReturn(mockRdfLangString); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/data/book1"), + createIRI("http://purl.org/dc/elements/1.1/title"), + createLiteral("The Odyssey", null, "en"), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -229,14 +149,7 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - // Explicitly create SerializerConfig to ensure strictMode is false - Map commonTurtlePrefixes = new HashMap<>(); - commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); - commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); - - SerializerConfig config = new SerializerConfig.Builder() + TurtleConfig config = new TurtleConfig.Builder() .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) .useRdfTypeShortcut(true) .useCollections(true) @@ -244,17 +157,16 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { .prettyPrint(true) .indent(" ") .lineEnding("\n") - .addCustomPrefixes(commonTurtlePrefixes) .autoDeclarePrefixes(true) .trailingDot(true) .strictMode(false) .build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, config); - // When + turtleSerializer.write(writer); - // Then + verify(mockModel, times(2)).stream(); String expected = """ @prefix 11: . @@ -264,7 +176,7 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { @prefix rdfs: . @prefix xsd: . - data:book1 11:title \"The Odyssey\"@en . + data:book1 11:title "The Odyssey"@en . """; String actual = writer.toString().replace("\r\n", "\n"); assertEquals(expected, actual); @@ -278,46 +190,16 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { * @throws IOException if an I/O error occurs during writing. */ @Test + @DisplayName("Should serialize literal with xsd:string datatype (minimal policy)") void testLiteralWithExplicitXsdStringType() throws SerializationException, IOException { - // Given - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - IRI mockDatatype = mock(IRI.class); - - // Configure mocks - when(mockSubject.stringValue()).thenReturn("http://example.org/data/book2"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://purl.org/dc/elements/1.1/creator"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - when(mockDatatype.stringValue()).thenReturn(SerializationConstants.XSD_STRING); - when(mockDatatype.isIRI()).thenReturn(true); - when(mockDatatype.isResource()).thenReturn(true); - - when(mockObject.stringValue()).thenReturn("Homer"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(mockDatatype); - - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + + IRI mockDatatype = createIRI(SerializationConstants.XSD_STRING); + Statement mockStatement = createStatement( + createIRI("http://example.org/data/book2"), + createIRI("http://purl.org/dc/elements/1.1/creator"), + createLiteral("Homer", mockDatatype, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -327,27 +209,21 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc StringWriter writer = new StringWriter(); - Map commonTurtlePrefixes = new HashMap<>(); - commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); - commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); - commonTurtlePrefixes.put("dc", "http://purl.org/dc/elements/1.1/"); - SerializerConfig config = new SerializerConfig.Builder() + TurtleConfig config = new TurtleConfig.Builder() .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) - .addCustomPrefixes(commonTurtlePrefixes) .usePrefixes(true) .autoDeclarePrefixes(true) + .addCustomPrefix("dc", "http://purl.org/dc/elements/1.1/") .build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, config); - // When + turtleSerializer.write(writer); - // Then + verify(mockModel, times(2)).stream(); - String expected = """ + String expected = """ @prefix data: . @prefix dc: . @prefix owl: . @@ -355,7 +231,7 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc @prefix rdfs: . @prefix xsd: . - data:book2 dc:creator \"Homer\"^^xsd:string . + data:book2 dc:creator "Homer"^^xsd:string . """; String actual = writer.toString().replace("\r\n", "\n"); assertEquals(expected, actual); @@ -370,72 +246,27 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc */ @Test void testBlankNodeSerialization() throws SerializationException, IOException { - Model mockModel = mock(Model.class); - - Resource mockBNode = mock(Resource.class); - IRI mockBNodeProperty = mock(IRI.class); - Literal mockBNodeObject = mock(Literal.class); - - - IRI mockMainSubject = mock(IRI.class); - IRI mockMainPredicate = mock(IRI.class); - Statement mainStatement = mock(Statement.class); - - - Statement bNodePropertyStatement = mock(Statement.class); - - - when(mockBNode.stringValue()).thenReturn("b1"); - when(mockBNode.isBNode()).thenReturn(true); - when(mockBNode.isResource()).thenReturn(true); - when(mockBNode.isIRI()).thenReturn(false); - when(mockBNode.isLiteral()).thenReturn(false); - - when(mockBNodeProperty.stringValue()).thenReturn("http://example.org/ns/hasValue"); - when(mockBNodeProperty.isIRI()).thenReturn(true); - when(mockBNodeProperty.isResource()).thenReturn(true); - when(mockBNodeProperty.isBNode()).thenReturn(false); - when(mockBNodeProperty.isLiteral()).thenReturn(false); - - when(mockBNodeObject.stringValue()).thenReturn("Value of BNode"); - when(mockBNodeObject.isLiteral()).thenReturn(true); - when(mockBNodeObject.isIRI()).thenReturn(false); - when(mockBNodeObject.isResource()).thenReturn(false); - when(mockBNodeObject.isBNode()).thenReturn(false); - when(mockBNodeObject.getLanguage()).thenReturn(Optional.empty()); - when(mockBNodeObject.getDatatype()).thenReturn(null); - - - when(bNodePropertyStatement.getSubject()).thenReturn(mockBNode); - when(bNodePropertyStatement.getPredicate()).thenReturn(mockBNodeProperty); - when(bNodePropertyStatement.getObject()).thenReturn(mockBNodeObject); - when(bNodePropertyStatement.getContext()).thenReturn(null); - - - when(mockMainSubject.stringValue()).thenReturn("http://example.org/ns/mainSubject"); - when(mockMainSubject.isIRI()).thenReturn(true); - when(mockMainSubject.isResource()).thenReturn(true); - when(mockMainSubject.isBNode()).thenReturn(false); - when(mockMainSubject.isLiteral()).thenReturn(false); - - when(mockMainPredicate.stringValue()).thenReturn("http://example.org/ns/refersTo"); - when(mockMainPredicate.isIRI()).thenReturn(true); - when(mockMainPredicate.isResource()).thenReturn(true); - when(mockMainPredicate.isBNode()).thenReturn(false); - when(mockMainPredicate.isLiteral()).thenReturn(false); - - when(mainStatement.getSubject()).thenReturn(mockMainSubject); - when(mainStatement.getPredicate()).thenReturn(mockMainPredicate); - when(mainStatement.getObject()).thenReturn(mockBNode); - when(mainStatement.getContext()).thenReturn(null); - + + Statement mainStatement = createStatement( + createIRI("http://example.org/ns/mainSubject"), + createIRI("http://example.org/ns/refersTo"), + createBlankNode("b1"), + null + ); + + Statement bNodePropertyStatement = createStatement( + createBlankNode("b1"), + createIRI("http://example.org/ns/hasValue"), + createLiteral("Value of BNode", null, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Arrays.asList(mainStatement, bNodePropertyStatement).iterator()); when(mockModel.stream()).thenAnswer(invocation -> Stream.of(mainStatement, bNodePropertyStatement)); StringWriter writer = new StringWriter(); - TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, SerializerConfig.turtleConfig()); + TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, defaultConfig); turtleSerializer.write(writer); @@ -449,9 +280,7 @@ void testBlankNodeSerialization() throws SerializationException, IOException { @prefix rdfs: . @prefix xsd: . - ns:mainSubject ns:refersTo [ - ns:hasValue "Value of BNode" - ] . + ns:mainSubject ns:refersTo _:b1 . """; String actual = writer.toString().replace("\r\n", "\n"); @@ -467,38 +296,12 @@ void testBlankNodeSerialization() throws SerializationException, IOException { */ @Test void testBaseIRI() throws SerializationException, IOException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - when(mockSubject.stringValue()).thenReturn("http://example.org/base/resource1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/base/prop"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - - when(mockObject.stringValue()).thenReturn("Test"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(null); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/base/resource1"), + createIRI("http://example.org/base/prop"), + createLiteral("Test", null, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -508,16 +311,8 @@ void testBaseIRI() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - Map commonTurtlePrefixes = new HashMap<>(); - commonTurtlePrefixes.put("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); - commonTurtlePrefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); - commonTurtlePrefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#"); - commonTurtlePrefixes.put("owl", "http://www.w3.org/2002/07/owl#"); - commonTurtlePrefixes.put("base", "http://example.org/base/"); - - SerializerConfig configWithBase = new SerializerConfig.Builder() + TurtleConfig configWithBase = new TurtleConfig.Builder() .baseIRI("http://example.org/base/") - .addCustomPrefixes(commonTurtlePrefixes) .usePrefixes(true) .autoDeclarePrefixes(true) .build(); @@ -558,7 +353,7 @@ void testEmptyModel() throws SerializationException, IOException { StringWriter writer = new StringWriter(); - TurtleSerializer turtleSerializer = new TurtleSerializer(emptyModel); + TurtleSerializer turtleSerializer = new TurtleSerializer(emptyModel, defaultConfig); turtleSerializer.write(writer); @@ -586,42 +381,12 @@ void testEmptyModel() throws SerializationException, IOException { @Test void testStrictModeInvalidLiteral() throws SerializationException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - when(mockSubject.stringValue()).thenReturn("http://example.org/s"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/p"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - when(mockObject.stringValue()).thenReturn("invalid"); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - IRI mockRdfLangStringDatatype = mock(IRI.class); - when(mockRdfLangStringDatatype.stringValue()).thenReturn(RDF.LANGSTRING.getIRI().stringValue()); - when(mockRdfLangStringDatatype.isIRI()).thenReturn(true); - when(mockRdfLangStringDatatype.isResource()).thenReturn(true); - when(mockObject.getDatatype()).thenReturn(mockRdfLangStringDatatype); - - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/s"), + createIRI("http://example.org/p"), + createLiteral("invalid", RDF.LANGSTRING.getIRI(), null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -630,7 +395,7 @@ void testStrictModeInvalidLiteral() throws SerializationException { StringWriter writer = new StringWriter(); - SerializerConfig strictConfig = new SerializerConfig.Builder().strictMode(true).build(); + TurtleConfig strictConfig = new TurtleConfig.Builder().strictMode(true).build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, strictConfig); @@ -652,37 +417,12 @@ void testStrictModeInvalidLiteral() throws SerializationException { @Test void testStrictModeInvalidIRICharacters() throws SerializationException { - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - IRI mockObject = mock(IRI.class); // Invalid IRI - - - when(mockSubject.stringValue()).thenReturn("http://example.org/s"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - - when(mockPredicate.stringValue()).thenReturn("http://example.org/p"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - - - when(mockObject.stringValue()).thenReturn("http://example.org/invalid iri"); // Contains a space - when(mockObject.isIRI()).thenReturn(true); - when(mockObject.isResource()).thenReturn(true); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.isLiteral()).thenReturn(false); - - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/s"), + createIRI("http://example.org/p"), + createIRI("http://example.org/invalid iri"), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -691,7 +431,7 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { StringWriter writer = new StringWriter(); - SerializerConfig strictConfig = new SerializerConfig.Builder().strictMode(true).validateURIs(true).build(); + TurtleConfig strictConfig = new TurtleConfig.Builder().strictMode(true).validateURIs(true).build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, strictConfig); @@ -713,39 +453,13 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { */ @Test void testMultilineLiteralSerialization() throws SerializationException, IOException { - // Given - Model mockModel = mock(Model.class); - Statement mockStatement = mock(Statement.class); - IRI mockSubject = mock(IRI.class); - IRI mockPredicate = mock(IRI.class); - Literal mockObject = mock(Literal.class); - - when(mockSubject.stringValue()).thenReturn("http://example.org/book/1"); - when(mockSubject.isIRI()).thenReturn(true); - when(mockSubject.isResource()).thenReturn(true); - when(mockSubject.isBNode()).thenReturn(false); - when(mockSubject.isLiteral()).thenReturn(false); - - when(mockPredicate.stringValue()).thenReturn("http://example.org/properties/description"); - when(mockPredicate.isIRI()).thenReturn(true); - when(mockPredicate.isResource()).thenReturn(true); - when(mockPredicate.isBNode()).thenReturn(false); - when(mockPredicate.isLiteral()).thenReturn(false); - String multilineText = "This is the first line.\nThis is the second line."; - when(mockObject.stringValue()).thenReturn(multilineText); - when(mockObject.isLiteral()).thenReturn(true); - when(mockObject.isIRI()).thenReturn(false); - when(mockObject.isResource()).thenReturn(false); - when(mockObject.isBNode()).thenReturn(false); - when(mockObject.getLanguage()).thenReturn(Optional.empty()); - when(mockObject.getDatatype()).thenReturn(null); // Assuming no specific datatype for simplicity - - // Configure the statement - when(mockStatement.getSubject()).thenReturn(mockSubject); - when(mockStatement.getPredicate()).thenReturn(mockPredicate); - when(mockStatement.getObject()).thenReturn(mockObject); - when(mockStatement.getContext()).thenReturn(null); + Statement mockStatement = createStatement( + createIRI("http://example.org/book/1"), + createIRI("http://example.org/properties/description"), + createLiteral(multilineText, null, null), + null + ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); when(mockModel.stream()) @@ -753,36 +467,80 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - // Configure SerializerConfig to enable multiline literals - SerializerConfig config = new SerializerConfig.Builder() + TurtleConfig config = new TurtleConfig.Builder() .useMultilineLiterals(true) .prettyPrint(true) .autoDeclarePrefixes(true) .build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, config); - // When turtleSerializer.write(writer); - // Then verify(mockModel, times(2)).stream(); - verify(mockSubject, atLeastOnce()).stringValue(); - verify(mockSubject, atLeastOnce()).isIRI(); - verify(mockPredicate, atLeastOnce()).stringValue(); - verify(mockPredicate, atLeastOnce()).isIRI(); - verify(mockObject, atLeastOnce()).stringValue(); - verify(mockObject, atLeastOnce()).isLiteral(); - - // Corrected expected string + String expected = """ @prefix book: . + @prefix owl: . @prefix properties: . + @prefix rdf: . + @prefix rdfs: . + @prefix xsd: . - book:1 properties:description \"\"\"This is the first line. - This is the second line.\"\"\" . - """; + book:1 properties:description\s""" + "\"\"\"" + multilineText + "\"\"\"" + " .\n"; String actual = writer.toString().replace("\r\n", "\n"); assertEquals(expected, actual); } + + + private Statement createStatement(Resource subject, IRI predicate, Value object, Resource context) { + Statement stmt = mock(Statement.class); + when(stmt.getSubject()).thenReturn(subject); + when(stmt.getPredicate()).thenReturn(predicate); + when(stmt.getObject()).thenReturn(object); + when(stmt.getContext()).thenReturn(context); + return stmt; + } + + private Resource createBlankNode(String id) { + Resource blankNode = mock(Resource.class); + when(blankNode.isResource()).thenReturn(true); + when(blankNode.isBNode()).thenReturn(true); + when(blankNode.isIRI()).thenReturn(false); + when(blankNode.stringValue()).thenReturn(id); + return blankNode; + } + + private IRI createIRI(String uri) { + IRI iri = mock(IRI.class); + when(iri.isResource()).thenReturn(true); + when(iri.isIRI()).thenReturn(true); + when(iri.isBNode()).thenReturn(false); + when(iri.stringValue()).thenReturn(uri); + return iri; + } + + /** + * Creates a mocked Literal object. + * + * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). + * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. + * @param langTag The language tag (e.g., "en"), or null if not language-tagged. + * @return A mocked Literal instance. + */ + private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { + Literal literal = mock(Literal.class); + when(literal.isLiteral()).thenReturn(true); + when(literal.isResource()).thenReturn(false); + when(literal.stringValue()).thenReturn(lexicalForm); + + if (langTag != null && !langTag.isEmpty()) { + when(literal.getLanguage()).thenReturn(Optional.of(langTag)); + when(literal.getDatatype()).thenReturn(RDF.LANGSTRING.getIRI()); + } else { + when(literal.getLanguage()).thenReturn(Optional.empty()); + when(literal.getDatatype()).thenReturn(dataTypeIRI); + } + return literal; + } } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java index a64d47cfc..12134558b 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java @@ -1,9 +1,9 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.serialization.config.SerializerConfig; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; +import fr.inria.corese.core.next.impl.common.serialization.config.XmlConfig; import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; @@ -13,14 +13,13 @@ import org.mockito.MockitoAnnotations; import java.io.StringWriter; -import java.util.HashMap; -import java.util.Map; import java.util.Optional; import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; /** * Unit tests for the XmlSerializer class. @@ -29,8 +28,7 @@ class XmlSerializerTest { @Mock private Model mockModel; - @Mock - private SerializerConfig mockConfig; + XmlConfig mockConfig; @Mock private Resource mockResource; @Mock @@ -47,17 +45,8 @@ void setUp() { MockitoAnnotations.openMocks(this); writer = new StringWriter(); + mockConfig = XmlConfig.defaultConfig(); - when(mockConfig.getIndent()).thenReturn(" "); - when(mockConfig.getLineEnding()).thenReturn("\n"); - when(mockConfig.usePrefixes()).thenReturn(true); - when(mockConfig.autoDeclarePrefixes()).thenReturn(true); - when(mockConfig.getCustomPrefixes()).thenReturn(new HashMap<>()); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.CUSTOM); - when(mockConfig.sortSubjects()).thenReturn(false); - when(mockConfig.sortPredicates()).thenReturn(false); - when(mockConfig.getLiteralDatatypePolicy()).thenReturn(LiteralDatatypePolicyEnum.MINIMAL); - when(mockConfig.stableBlankNodeIds()).thenReturn(true); } @@ -68,21 +57,21 @@ void shouldSerializeSimpleIriTriple() throws SerializationException { when(mockModel.stream()).thenReturn(Stream.of(stmt)); + XmlConfig testConfig = new XmlConfig.Builder() + .autoDeclarePrefixes(true) + .usePrefixes(true) + .addCustomPrefix("foaf", "http://xmlns.com/foaf/0.1/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - Map customPrefixes = new HashMap<>(); - - customPrefixes.put("http://xmlns.com/foaf/0.1/", "foaf"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + @@ -99,20 +88,18 @@ void shouldHandleBlankNodeSubject() throws SerializationException { when(mockModel.stream()).thenReturn(Stream.of(stmt)); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://xmlns.com/foaf/0.1/", "foaf"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - - - when(mockConfig.stableBlankNodeIds()).thenReturn(true); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .stableBlankNodeIds(true) + .addCustomPrefix("foaf", "http://xmlns.com/foaf/0.1/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + @@ -130,20 +117,19 @@ void shouldHandleBlankNodeObject() throws SerializationException { when(mockModel.stream()).thenReturn(Stream.of(stmt)); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://purl.org/dc/elements/1.1/", "dc"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); + XmlConfig testConfig = new XmlConfig.Builder() + .stableBlankNodeIds(true) + .addCustomPrefix("dc", "http://purl.org/dc/elements/1.1/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - when(mockConfig.stableBlankNodeIds()).thenReturn(true); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); - - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + @@ -160,19 +146,19 @@ void shouldSerializeLiteralWithStringDatatypeMinimalPolicy() throws Serializatio null); when(mockModel.stream()).thenReturn(Stream.of(stmt)); - when(mockConfig.getLiteralDatatypePolicy()).thenReturn(LiteralDatatypePolicyEnum.MINIMAL); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://xmlns.com/foaf/0.1/", "foaf"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) + .addCustomPrefix("foaf", "http://xmlns.com/foaf/0.1/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + John Doe @@ -187,20 +173,20 @@ void shouldSerializeLiteralWithCustomDatatypeMinimalPolicy() throws Serializatio Statement stmt = createMockLiteralStatement("http://example.org/data", "http://example.org/vocabulary/value", "123", SerializationConstants.XSD_INTEGER, null); when(mockModel.stream()).thenReturn(Stream.of(stmt)); - when(mockConfig.getLiteralDatatypePolicy()).thenReturn(LiteralDatatypePolicyEnum.MINIMAL); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://example.org/vocabulary/", "ex"); - customPrefixes.put("http://www.w3.org/2001/XMLSchema#", "xsd"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) + .addCustomPrefix("ex", "http://example.org/vocabulary/") + .addCustomPrefix("xsd", "http://www.w3.org/2001/XMLSchema#") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + 123 @@ -216,17 +202,17 @@ void shouldSerializeLiteralWithLanguage() throws SerializationException { when(mockModel.stream()).thenReturn(Stream.of(stmt)); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://purl.org/dc/elements/1.1/", "dc"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .addCustomPrefix("dc", "http://purl.org/dc/elements/1.1/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + The Book @@ -244,20 +230,20 @@ void shouldRespectPrefixOrderingAlphabetical() throws SerializationException { when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://ex.org/", "exorg"); - customPrefixes.put("http://ex.com/", "excom"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); - when(mockConfig.sortSubjects()).thenReturn(false); + XmlConfig testConfig = new XmlConfig.Builder() + .addCustomPrefix("exorg", "http://ex.org/") + .addCustomPrefix("excom", "http://ex.com/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .sortSubjects(false) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + @@ -278,14 +264,14 @@ void shouldRespectPrefixOrderingDefault() throws SerializationException { when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://ex.org/", "exorg"); - customPrefixes.put("http://ex.com/", "excom"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.USAGE_ORDER); - when(mockConfig.sortSubjects()).thenReturn(false); + XmlConfig testConfig = new XmlConfig.Builder() + .addCustomPrefix("exorg", "http://ex.org/") + .addCustomPrefix("excom", "http://ex.com/") + .prefixOrdering(PrefixOrderingEnum.USAGE_ORDER) + .sortSubjects(false) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String actual = writer.toString(); @@ -311,19 +297,19 @@ void shouldSortSubjectsAlphabetically() throws SerializationException { Statement stmt2 = createMockStatement("http://ex.org/A", "http://ex.org/p", "http://ex.org/o"); when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); - when(mockConfig.sortSubjects()).thenReturn(true); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://ex.org/", "ex"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .sortSubjects(true) + .addCustomPrefix("ex", "http://ex.org/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + @@ -343,14 +329,17 @@ void shouldEscapeXmlAttributeValues() throws SerializationException { Statement stmt = createMockStatement("http://example.org/sub&ject<", "http://example.org/pred", "http://example.org/obj\"ect'"); when(mockModel.stream()).thenReturn(Stream.of(stmt)); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlConfig testConfig = new XmlConfig.Builder() + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); + + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + @@ -368,20 +357,20 @@ void shouldEscapeXmlContentValues() throws SerializationException { ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); - when(mockConfig.getLiteralDatatypePolicy()).thenReturn(LiteralDatatypePolicyEnum.ALWAYS_TYPED); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://example.org/", "ex"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) + .addCustomPrefix("ex", "http://example.org/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + Value with <tags> & entities @@ -398,18 +387,19 @@ void shouldNotAutoDeclarePrefixesIfDisabled() throws SerializationException { Statement stmt = createMockStatement("http://example.org/subject", "http://xmlns.com/foaf/0.1/name", "http://example.org/object"); when(mockModel.stream()).thenReturn(Stream.of(stmt)); - when(mockConfig.autoDeclarePrefixes()).thenReturn(false); - when(mockConfig.usePrefixes()).thenReturn(true); - when(mockConfig.getCustomPrefixes()).thenReturn(new HashMap<>()); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .autoDeclarePrefixes(false) + .usePrefixes(true) + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + @@ -417,7 +407,6 @@ void shouldNotAutoDeclarePrefixesIfDisabled() throws SerializationException { """; assertEquals(expected, writer.toString()); - verify(mockConfig, times(1)).autoDeclarePrefixes(); } @Test @@ -426,15 +415,14 @@ void shouldNotUsePrefixesIfDisabled() throws SerializationException { Statement stmt = createMockStatement("http://example.org/subject", "http://xmlns.com/foaf/0.1/name", "http://example.org/object"); when(mockModel.stream()).thenReturn(Stream.of(stmt)); - when(mockConfig.usePrefixes()).thenReturn(false); - when(mockConfig.autoDeclarePrefixes()).thenReturn(true); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://xmlns.com/foaf/0.1/", "foaf"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .usePrefixes(false) + .autoDeclarePrefixes(true) + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ @@ -447,7 +435,6 @@ void shouldNotUsePrefixesIfDisabled() throws SerializationException { """; assertEquals(expected, writer.toString()); - verify(mockConfig, times(2)).usePrefixes(); } @@ -458,21 +445,21 @@ void shouldNotGenerateStableBlankNodeIds() throws SerializationException { Statement stmt2 = createMockBlankNodeObjectStatement("http://example.org/s", "http://example.org/p", "bnode-xyz"); when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); - when(mockConfig.stableBlankNodeIds()).thenReturn(false); - when(mockConfig.sortSubjects()).thenReturn(true); - Map customPrefixes = new HashMap<>(); - customPrefixes.put("http://example.org/", "ex"); - when(mockConfig.getCustomPrefixes()).thenReturn(customPrefixes); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); + XmlConfig testConfig = new XmlConfig.Builder() + .stableBlankNodeIds(false) + .sortSubjects(true) + .addCustomPrefix("ex", "http://example.org/") + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + @@ -489,14 +476,17 @@ void shouldNotGenerateStableBlankNodeIds() throws SerializationException { @DisplayName("Should handle an empty model") void shouldHandleEmptyModel() throws SerializationException { when(mockModel.stream()).thenReturn(Stream.empty()); - when(mockConfig.getPrefixOrdering()).thenReturn(PrefixOrderingEnum.ALPHABETICAL); - XmlSerializer serializer = new XmlSerializer(mockModel, mockConfig); + XmlConfig testConfig = new XmlConfig.Builder() + .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) + .build(); + + XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); serializer.write(writer); String expected = """ - + """; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfigTest.java new file mode 100644 index 000000000..bc7863e44 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfigTest.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +public class NQuadsConfigTest { +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfigTest.java new file mode 100644 index 000000000..ea9dd9f1e --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfigTest.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +public class NTriplesConfigTest { +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfigTest.java new file mode 100644 index 000000000..7d375db5b --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfigTest.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +public class TriGConfigTest { +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfigTest.java new file mode 100644 index 000000000..8029739c1 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfigTest.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +public class TurtleConfigTest { +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfigTest.java new file mode 100644 index 000000000..d72cdf3f7 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfigTest.java @@ -0,0 +1,4 @@ +package fr.inria.corese.core.next.impl.common.serialization.config; + +public class XmlConfigTest { +} From c43fa3a14837c8a3ef7951c23c9d835acc3cf8a8 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 4 Jul 2025 14:25:55 +0200 Subject: [PATCH 22/27] java Doc anglais --- .../DefaultSerializerFactoryTest.java | 39 ++++++++------- .../serialization/NQuadsSerializerTest.java | 48 ++++++------------- .../serialization/NTriplesSerializerTest.java | 47 ++++++------------ 3 files changed, 52 insertions(+), 82 deletions(-) diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java index ef8c8daac..b6ad13c7e 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/DefaultSerializerFactoryTest.java @@ -12,12 +12,19 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mockConstruction; +/** + * Unit tests for the {@link DefaultSerializerFactory} class. + * This class verifies that the factory correctly creates instances of + * various {@link RdfSerializer} implementations based on the provided + * {@link RdfFormat} and handles null inputs gracefully. + */ class DefaultSerializerFactoryTest { private DefaultSerializerFactory factory; private Model mockModel; private SerializationConfig mockConfig; + @BeforeEach void setUp() { factory = new DefaultSerializerFactory(); @@ -26,86 +33,86 @@ void setUp() { } @Test - @DisplayName("createSerializer devrait retourner TurtleSerializer pour le format TURTLE") + @DisplayName("createSerializer should return TurtleSerializer for TURTLE format") void createSerializer_shouldReturnTurtleSerializer_forTurtleFormat() { try (MockedConstruction mockedConstruction = mockConstruction(TurtleSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.TURTLE, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof TurtleSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de TurtleSerializer devrait être appelé une fois"); + assertEquals(1, mockedConstruction.constructed().size(), "TurtleSerializer constructor should be called once"); } } @Test - @DisplayName("createSerializer devrait retourner NTriplesSerializer pour le format NTRIPLES") + @DisplayName("createSerializer should return NTriplesSerializer for NTRIPLES format") void createSerializer_shouldReturnNTriplesSerializer_forNTriplesFormat() { try (MockedConstruction mockedConstruction = mockConstruction(NTriplesSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.NTRIPLES, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof NTriplesSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de NTriplesSerializer devrait être appelé une fois"); + assertEquals(1, mockedConstruction.constructed().size(), "NTriplesSerializer constructor should be called once"); } } @Test - @DisplayName("createSerializer devrait retourner NQuadsSerializer pour le format NQUADS") + @DisplayName("createSerializer should return NQuadsSerializer for NQUADS format") void createSerializer_shouldReturnNQuadsSerializer_forNQuadsFormat() { try (MockedConstruction mockedConstruction = mockConstruction(NQuadsSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.NQUADS, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof NQuadsSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de NQuadsSerializer devrait être appelé une fois"); + assertEquals(1, mockedConstruction.constructed().size(), "NQuadsSerializer constructor should be called once"); } } @Test - @DisplayName("createSerializer devrait retourner TriGSerializer pour le format TRIG") + @DisplayName("createSerializer should return TriGSerializer for TRIG format") void createSerializer_shouldReturnTriGSerializer_forTriGFormat() { try (MockedConstruction mockedConstruction = mockConstruction(TriGSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.TRIG, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof TriGSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de TriGSerializer devrait être appelé une fois"); + assertEquals(1, mockedConstruction.constructed().size(), "TriGSerializer constructor should be called once"); } } @Test - @DisplayName("createSerializer devrait retourner XmlSerializer pour le format RDFXML") + @DisplayName("createSerializer should return XmlSerializer for RDFXML format") void createSerializer_shouldReturnXmlSerializer_forRdfXmlFormat() { try (MockedConstruction mockedConstruction = mockConstruction(XmlSerializer.class)) { RdfSerializer serializer = factory.createSerializer(RdfFormat.RDFXML, mockModel, mockConfig); assertNotNull(serializer); assertTrue(serializer instanceof XmlSerializer); - assertEquals(1, mockedConstruction.constructed().size(), "Le constructeur de XmlSerializer devrait être appelé une fois"); + assertEquals(1, mockedConstruction.constructed().size(), "XmlSerializer constructor should be called once"); } } @Test - @DisplayName("createSerializer devrait lever NullPointerException pour un format nul") + @DisplayName("createSerializer should throw NullPointerException for a null format") void createSerializer_shouldThrowNPE_forNullFormat() { assertThrows(NullPointerException.class, () -> factory.createSerializer(null, mockModel, mockConfig), - "Devrait lever NullPointerException pour RdfFormat nul"); + "Should throw NullPointerException for null RdfFormat"); } @Test - @DisplayName("createSerializer devrait lever NullPointerException pour un modèle nul") + @DisplayName("createSerializer should throw NullPointerException for a null model") void createSerializer_shouldThrowNPE_forNullModel() { assertThrows(NullPointerException.class, () -> factory.createSerializer(RdfFormat.TURTLE, null, mockConfig), - "Devrait lever NullPointerException pour Model nul"); + "Should throw NullPointerException for null Model"); } @Test - @DisplayName("createSerializer devrait lever NullPointerException pour une configuration nulle") + @DisplayName("createSerializer should throw NullPointerException for a null config") void createSerializer_shouldThrowNPE_forNullConfig() { assertThrows(NullPointerException.class, () -> factory.createSerializer(RdfFormat.TURTLE, mockModel, null), - "Devrait lever NullPointerException pour SerializationConfig nulle"); + "Should throw NullPointerException for null SerializationConfig"); } } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java index 2ad1b449e..aed44f74c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java @@ -56,19 +56,19 @@ void setUp() { } @Test - @DisplayName("Le constructeur devrait lever NullPointerException pour un modèle nul") + @DisplayName("Constructor should throw NullPointerException for null model") void constructorShouldThrowForNullModel() { assertThrows(NullPointerException.class, () -> new NQuadsSerializer(null), "Model cannot be null"); } @Test - @DisplayName("Le constructeur devrait lever NullPointerException pour une configuration nulle") + @DisplayName("Constructor should throw NullPointerException for null configuration") void constructorShouldThrowForNullConfig() { assertThrows(NullPointerException.class, () -> new NQuadsSerializer(model, null), "Configuration cannot be null"); } @Test - @DisplayName("L'écriture devrait sérialiser une déclaration simple correctement (graphe par défaut)") + @DisplayName("Write should serialize a simple statement correctly (default graph)") void writeShouldSerializeSimpleStatement() throws SerializationException { Statement stmt = createStatement( mockExPerson, @@ -89,7 +89,7 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { } @Test - @DisplayName("L'écriture devrait gérer les nœuds vierges avec le préfixe par défaut") + @DisplayName("Write should handle blank nodes with default prefix") void writeShouldHandleBlankNodes() throws SerializationException { Statement stmt = createStatement( mockBNode1, @@ -110,7 +110,7 @@ void writeShouldHandleBlankNodes() throws SerializationException { } @Test - @DisplayName("L'écriture devrait gérer les nœuds vierges dans le contexte avec le préfixe par défaut") + @DisplayName("Write should handle blank nodes in context with default prefix") void writeShouldHandleBlankNodesInContext() throws SerializationException { Resource blankNodeContext = createBlankNode("b3"); Statement stmt = createStatement( @@ -134,7 +134,7 @@ void writeShouldHandleBlankNodesInContext() throws SerializationException { } @Test - @DisplayName("L'écriture devrait lever SerializationException en cas d'erreur E/S") + @DisplayName("Write should throw SerializationException on IO error") void writeShouldThrowOnIOException() throws IOException { Statement stmt = createStatement( mockExPerson, @@ -153,7 +153,7 @@ void writeShouldThrowOnIOException() throws IOException { } @Test - @DisplayName("L'écriture devrait lever SerializationException pour une valeur de sujet nulle dans le mode strict") + @DisplayName("Write should throw SerializationException for null subject value in strict mode") void writeShouldThrowOnNullSubjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(null); @@ -168,7 +168,7 @@ void writeShouldThrowOnNullSubjectValue() { } @Test - @DisplayName("L'écriture devrait lever SerializationException pour une valeur de prédicat nulle dans le mode strict") + @DisplayName("Write should throw SerializationException for null predicate value in strict mode") void writeShouldThrowOnNullPredicateValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -183,7 +183,7 @@ void writeShouldThrowOnNullPredicateValue() { } @Test - @DisplayName("L'écriture devrait lever SerializationException pour une valeur d'objet nulle dans le mode strict") + @DisplayName("Write should throw SerializationException for null object value in strict mode") void writeShouldThrowOnNullObjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -198,7 +198,7 @@ void writeShouldThrowOnNullObjectValue() { } @Test - @DisplayName("L'écriture devrait gérer correctement le contexte nul (graphe par défaut)") + @DisplayName("Write should handle null context correctly (default graph)") void writeShouldHandleNullContext() throws SerializationException { Statement stmt = createStatement( mockExPerson, @@ -230,7 +230,7 @@ void writeShouldHandleNullContext() throws SerializationException { "literal with \u0001 (SOH)", "literal with \u007F (DEL)" }) - @DisplayName("L'écriture devrait gérer diverses valeurs littérales avec un échappement approprié (y compris Unicode)") + @DisplayName("Write should handle various literal values with appropriate escaping (including Unicode)") void writeShouldHandleVariousLiterals(String literalValue) throws SerializationException { Literal literalMock = createLiteral(literalValue, null, null); @@ -254,7 +254,7 @@ void writeShouldHandleVariousLiterals(String literalValue) throws SerializationE } @Test - @DisplayName("Devrait gérer les littéraux avec des balises de langue") + @DisplayName("Should handle literals with language tags") void shouldHandleLiteralsWithLanguageTags() throws SerializationException { Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/greeting"), mockLiteralHelloEn); @@ -276,7 +276,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { } @Test - @DisplayName("Devrait gérer les littéraux avec des types de données personnalisés") + @DisplayName("Should handle literals with custom datatypes") void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { IRI customDatatype = createIRI("http://example.org/myDataType"); Literal customLiteral = createLiteral("123", customDatatype, null); @@ -300,17 +300,7 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { assertEquals(expectedOutput, writer.toString()); } - /** - * Crée un objet Literal mocké. - * Important : le `lexicalForm` est la *valeur de chaîne brute* du littéral, - * sans les guillemets spécifiques à N-Quads, les balises de langue ou les URI de type de données. - * La classe `nQuadsSerializer` est chargée d'ajouter ceux-ci. - * - * @param lexicalForm La valeur de chaîne brute du littéral (par exemple, "hello", "123"). - * @param dataTypeIRI L'IRI du type de données du littéral (par exemple, XSD.INTEGER.getIRI()), ou null pour simple/avec balise de langue. - * @param langTag La balise de langue (par exemple, "en"), ou null si non balisé par la langue. - * @return Une instance de Literal mockée. - */ + private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { Literal literal = mock(Literal.class); when(literal.isLiteral()).thenReturn(true); @@ -327,15 +317,7 @@ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTa return literal; } - /** - * Échappe une chaîne selon les règles d'échappement des littéraux N-Quads. - * Cette aide est utilisée dans les tests pour construire les chaînes de sortie *attendues*. - * Elle imite le comportement de la méthode interne `escapeLiteral` de `nQuadsSerializer`, - * en considérant que `nquadsConfig().escapeUnicode()` est `true`. - * - * @param s La chaîne à échapper. - * @return La chaîne échappée. - */ + private String escapeNQuadsString(String s) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < s.length(); i++) { diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java index deb707c72..0af79843c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java @@ -56,19 +56,19 @@ void setUp() { } @Test - @DisplayName("Le constructeur devrait lever NullPointerException pour un modèle nul") + @DisplayName("Constructor should throw NullPointerException for null model") void constructorShouldThrowForNullModel() { assertThrows(NullPointerException.class, () -> new NTriplesSerializer(null), "Model cannot be null"); } @Test - @DisplayName("Le constructeur devrait lever NullPointerException pour une configuration nulle") + @DisplayName("Constructor should throw NullPointerException for null configuration") void constructorShouldThrowForNullConfig() { assertThrows(NullPointerException.class, () -> new NTriplesSerializer(model, null), "Configuration cannot be null"); } @Test - @DisplayName("L'écriture devrait sérialiser une déclaration simple correctement (graphe par défaut)") + @DisplayName("Write should serialize a simple statement correctly (default graph)") void writeShouldSerializeSimpleStatement() throws SerializationException { Statement stmt = createStatement( mockExPerson, @@ -89,7 +89,7 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { } @Test - @DisplayName("L'écriture devrait sérialiser une déclaration avec contexte mais l'ignorer (N-Triples)") + @DisplayName("Write should serialize a statement with context but ignore it (N-Triples)") void writeShouldSerializeStatementWithContext() throws SerializationException { IRI mockContext = createIRI("http://example.org/ctx"); Statement stmt = createStatement( @@ -112,7 +112,7 @@ void writeShouldSerializeStatementWithContext() throws SerializationException { } @Test - @DisplayName("L'écriture devrait gérer les nœuds vierges avec le préfixe N-Triples par défaut (_:)") + @DisplayName("Write should handle blank nodes with default N-Triples prefix (_:)") void writeShouldHandleBlankNodes() throws SerializationException { Statement stmt = createStatement( mockBNode1, @@ -133,7 +133,7 @@ void writeShouldHandleBlankNodes() throws SerializationException { } @Test - @DisplayName("L'écriture devrait lever SerializationException en cas d'erreur E/S") + @DisplayName("Write should throw SerializationException on IO error") void writeShouldThrowOnIOException() throws IOException { Statement stmt = createStatement( mockExPerson, @@ -155,7 +155,7 @@ void writeShouldThrowOnIOException() throws IOException { @Test - @DisplayName("L'écriture devrait lever SerializationException pour une valeur de sujet nulle dans le mode strict") + @DisplayName("Write should throw SerializationException for null subject value in strict mode") void writeShouldThrowOnNullSubjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(null); @@ -171,7 +171,7 @@ void writeShouldThrowOnNullSubjectValue() { } @Test - @DisplayName("L'écriture devrait lever SerializationException pour une valeur de prédicat nulle dans le mode strict") + @DisplayName("Write should throw SerializationException for null predicate value in strict mode") void writeShouldThrowOnNullPredicateValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -186,7 +186,7 @@ void writeShouldThrowOnNullPredicateValue() { } @Test - @DisplayName("L'écriture devrait lever SerializationException pour une valeur d'objet nulle dans le mode strict") + @DisplayName("Write should throw SerializationException for null object value in strict mode") void writeShouldThrowOnNullObjectValue() { Statement stmt = mock(Statement.class); when(stmt.getSubject()).thenReturn(mockExPerson); @@ -201,7 +201,7 @@ void writeShouldThrowOnNullObjectValue() { @Test - @DisplayName("Devrait gérer correctement le contexte nul (graphe par défaut)") + @DisplayName("Should handle null context correctly (default graph)") void writeShouldHandleNullContext() throws SerializationException { Statement stmt = createStatement( mockExPerson, @@ -234,7 +234,7 @@ void writeShouldHandleNullContext() throws SerializationException { "literal with \u0001 (SOH)", "literal with \u007F (DEL)" }) - @DisplayName("L'écriture devrait gérer diverses valeurs littérales avec un échappement approprié (y compris Unicode)") + @DisplayName("Write should handle various literal values with appropriate escaping (including Unicode)") void writeShouldHandleVariousLiterals(String literalValue) throws SerializationException { Literal literalMock = createLiteral(literalValue, null, null); @@ -260,7 +260,7 @@ void writeShouldHandleVariousLiterals(String literalValue) throws SerializationE @Test - @DisplayName("Devrait gérer les littéraux avec des balises de langue") + @DisplayName("Should handle literals with language tags") void shouldHandleLiteralsWithLanguageTags() throws SerializationException { Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/greeting"), mockLiteralHelloEn); @@ -283,7 +283,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { @Test - @DisplayName("Devrait gérer les littéraux avec des types de données personnalisés") + @DisplayName("Should handle literals with custom datatypes") void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { IRI customDatatype = createIRI("http://example.org/myDataType"); Literal customLiteral = createLiteral("123", customDatatype, null); @@ -308,17 +308,6 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { } - /** - * Crée un objet Literal mocké. - * Important : le `lexicalForm` est la *valeur de chaîne brute* du littéral, - * sans les guillemets spécifiques à N-Triples, les balises de langue ou les URI de type de données. - * La classe `nTriplesSerializer` est chargée d'ajouter ceux-ci. - * - * @param lexicalForm La valeur de chaîne brute du littéral (par exemple, "hello", "123"). - * @param dataTypeIRI L'IRI du type de données du littéral (par exemple, XSD.INTEGER.getIRI()), ou null pour simple/avec balise de langue. - * @param langTag La balise de langue (par exemple, "en"), ou null si non balisé par la langue. - * @return Une instance de Literal mockée. - */ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { Literal literal = mock(Literal.class); when(literal.isLiteral()).thenReturn(true); @@ -335,15 +324,7 @@ private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTa return literal; } - /** - * Échappe une chaîne selon les règles d'échappement des littéraux N-Triples. - * Cette aide est utilisée dans les tests pour construire les chaînes de sortie *attendues*. - * Elle imite le comportement de la méthode interne `escapeLiteral` de `nTriplesSerializer`, - * en considérant que `ntriplesConfig().escapeUnicode()` est `true`. - * - * @param s La chaîne à échapper. - * @return La chaîne échappée. - */ + private String escapeNTriplesString(String s) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < s.length(); i++) { From 1967d7e7bdb6d5e1c7c3b5be0664316f31227fa5 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 4 Jul 2025 15:50:54 +0200 Subject: [PATCH 23/27] A factory class to create mocked components --- .../serialization/NQuadsSerializerTest.java | 95 ++----- .../serialization/NTriplesSerializerTest.java | 94 ++----- .../serialization/TestStatementFactory.java | 106 ++++++++ .../serialization/TriGSerializerTest.java | 126 ++++------ .../serialization/TurtleSerializerTest.java | 154 ++++-------- .../serialization/XmlSerializerTest.java | 235 +++++++----------- 6 files changed, 340 insertions(+), 470 deletions(-) create mode 100644 src/test/java/fr/inria/corese/core/next/impl/common/serialization/TestStatementFactory.java diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java index aed44f74c..2feaa385b 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NQuadsSerializerTest.java @@ -2,7 +2,6 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.serialization.config.NQuadsConfig; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -14,7 +13,6 @@ import java.io.StringWriter; import java.io.Writer; import java.util.Iterator; -import java.util.Optional; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -25,6 +23,7 @@ class NQuadsSerializerTest { private Model model; private NQuadsConfig config; private NQuadsSerializer nQuadsSerializer; + private TestStatementFactory factory; private Resource mockExPerson; private IRI mockExName; @@ -43,16 +42,17 @@ void setUp() { model = mock(Model.class); config = NQuadsConfig.defaultConfig(); nQuadsSerializer = new NQuadsSerializer(model, config); + factory = new TestStatementFactory(); - mockExPerson = createIRI("http://example.org/Person"); - mockExName = createIRI("http://example.org/name"); - mockExKnows = createIRI("http://example.org/knows"); + mockExPerson = factory.createIRI("http://example.org/Person"); + mockExName = factory.createIRI("http://example.org/name"); + mockExKnows = factory.createIRI("http://example.org/knows"); - mockLiteralJohn = createLiteral(lexJohn, null, null); - mockLiteralHelloEn = createLiteral(hello, null, "en"); + mockLiteralJohn = factory.createLiteral(lexJohn, null, null); + mockLiteralHelloEn = factory.createLiteral(hello, null, "en"); - mockBNode1 = createBlankNode("b1"); - mockBNode2 = createBlankNode("b2"); + mockBNode1 = factory.createBlankNode("b1"); + mockBNode2 = factory.createBlankNode("b2"); } @Test @@ -70,7 +70,7 @@ void constructorShouldThrowForNullConfig() { @Test @DisplayName("Write should serialize a simple statement correctly (default graph)") void writeShouldSerializeSimpleStatement() throws SerializationException { - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockExPerson, mockExName, mockLiteralJohn @@ -91,7 +91,7 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { @Test @DisplayName("Write should handle blank nodes with default prefix") void writeShouldHandleBlankNodes() throws SerializationException { - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockBNode1, mockExKnows, mockBNode2 @@ -112,8 +112,8 @@ void writeShouldHandleBlankNodes() throws SerializationException { @Test @DisplayName("Write should handle blank nodes in context with default prefix") void writeShouldHandleBlankNodesInContext() throws SerializationException { - Resource blankNodeContext = createBlankNode("b3"); - Statement stmt = createStatement( + Resource blankNodeContext = factory.createBlankNode("b3"); + Statement stmt = factory.createStatement( mockBNode1, mockExKnows, mockExPerson, @@ -136,7 +136,7 @@ void writeShouldHandleBlankNodesInContext() throws SerializationException { @Test @DisplayName("Write should throw SerializationException on IO error") void writeShouldThrowOnIOException() throws IOException { - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockExPerson, mockExName, mockLiteralJohn @@ -189,7 +189,6 @@ void writeShouldThrowOnNullObjectValue() { when(stmt.getSubject()).thenReturn(mockExPerson); when(stmt.getPredicate()).thenReturn(mockExName); when(stmt.getObject()).thenReturn(null); - when(stmt.getContext()).thenReturn(null); when(model.iterator()).thenReturn(new MockStatementIterator(stmt)); StringWriter writer = new StringWriter(); @@ -200,7 +199,7 @@ void writeShouldThrowOnNullObjectValue() { @Test @DisplayName("Write should handle null context correctly (default graph)") void writeShouldHandleNullContext() throws SerializationException { - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockExPerson, mockExName, mockLiteralJohn, @@ -232,9 +231,9 @@ void writeShouldHandleNullContext() throws SerializationException { }) @DisplayName("Write should handle various literal values with appropriate escaping (including Unicode)") void writeShouldHandleVariousLiterals(String literalValue) throws SerializationException { - Literal literalMock = createLiteral(literalValue, null, null); + Literal literalMock = factory.createLiteral(literalValue, null, null); - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockExPerson, mockExName, literalMock @@ -256,7 +255,7 @@ void writeShouldHandleVariousLiterals(String literalValue) throws SerializationE @Test @DisplayName("Should handle literals with language tags") void shouldHandleLiteralsWithLanguageTags() throws SerializationException { - Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/greeting"), mockLiteralHelloEn); + Statement stmt = factory.createStatement(mockExPerson, factory.createIRI("http://example.org/greeting"), mockLiteralHelloEn); Model currentTestModel = mock(Model.class); when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); @@ -268,7 +267,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", mockExPerson.stringValue(), - createIRI("http://example.org/greeting").stringValue(), + factory.createIRI("http://example.org/greeting").stringValue(), escapeNQuadsString(hello), mockLiteralHelloEn.getLanguage().get()) + " .\n"; @@ -278,10 +277,10 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { @Test @DisplayName("Should handle literals with custom datatypes") void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { - IRI customDatatype = createIRI("http://example.org/myDataType"); - Literal customLiteral = createLiteral("123", customDatatype, null); + IRI customDatatype = factory.createIRI("http://example.org/myDataType"); + Literal customLiteral = factory.createLiteral("123", customDatatype, null); - Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/value"), customLiteral); + Statement stmt = factory.createStatement(mockExPerson, factory.createIRI("http://example.org/value"), customLiteral); Model currentTestModel = mock(Model.class); when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); @@ -293,7 +292,7 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { String expectedOutput = String.format("<%s> <%s> \"%s\"^^<%s>", mockExPerson.stringValue(), - createIRI("http://example.org/value").stringValue(), + factory.createIRI("http://example.org/value").stringValue(), escapeNQuadsString("123"), customDatatype.stringValue()) + " .\n"; @@ -301,23 +300,6 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { } - private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { - Literal literal = mock(Literal.class); - when(literal.isLiteral()).thenReturn(true); - when(literal.isResource()).thenReturn(false); - when(literal.stringValue()).thenReturn(lexicalForm); - - if (langTag != null && !langTag.isEmpty()) { - when(literal.getLanguage()).thenReturn(Optional.of(langTag)); - when(literal.getDatatype()).thenReturn(RDF.langString.getIRI()); - } else { - when(literal.getLanguage()).thenReturn(Optional.empty()); - when(literal.getDatatype()).thenReturn(dataTypeIRI); - } - return literal; - } - - private String escapeNQuadsString(String s) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < s.length(); i++) { @@ -383,35 +365,4 @@ public Statement next() { return statements[index++]; } } - - private Statement createStatement(Resource subject, IRI predicate, Value object) { - return createStatement(subject, predicate, object, null); - } - - private Statement createStatement(Resource subject, IRI predicate, Value object, Resource context) { - Statement stmt = mock(Statement.class); - when(stmt.getSubject()).thenReturn(subject); - when(stmt.getPredicate()).thenReturn(predicate); - when(stmt.getObject()).thenReturn(object); - when(stmt.getContext()).thenReturn(context); - return stmt; - } - - private Resource createBlankNode(String id) { - Resource blankNode = mock(Resource.class); - when(blankNode.isResource()).thenReturn(true); - when(blankNode.isBNode()).thenReturn(true); - when(blankNode.isIRI()).thenReturn(false); - when(blankNode.stringValue()).thenReturn(id); - return blankNode; - } - - private IRI createIRI(String uri) { - IRI iri = mock(IRI.class); - when(iri.isResource()).thenReturn(true); - when(iri.isIRI()).thenReturn(true); - when(iri.isBNode()).thenReturn(false); - when(iri.stringValue()).thenReturn(uri); - return iri; - } } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java index 0af79843c..aa51f1536 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/NTriplesSerializerTest.java @@ -2,7 +2,6 @@ import fr.inria.corese.core.next.api.*; import fr.inria.corese.core.next.impl.common.serialization.config.NTriplesConfig; -import fr.inria.corese.core.next.impl.common.vocabulary.RDF; import fr.inria.corese.core.next.impl.exception.SerializationException; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -14,7 +13,6 @@ import java.io.StringWriter; import java.io.Writer; import java.util.Iterator; -import java.util.Optional; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -25,6 +23,7 @@ class NTriplesSerializerTest { private Model model; private NTriplesConfig config; private NTriplesSerializer nTriplesSerializer; + private TestStatementFactory factory; private Resource mockExPerson; private IRI mockExName; @@ -43,16 +42,17 @@ void setUp() { model = mock(Model.class); config = NTriplesConfig.defaultConfig(); nTriplesSerializer = new NTriplesSerializer(model, config); + factory = new TestStatementFactory(); - mockExPerson = createIRI("http://example.org/Person"); - mockExName = createIRI("http://example.org/name"); - mockExKnows = createIRI("http://example.org/knows"); + mockExPerson = factory.createIRI("http://example.org/Person"); + mockExName = factory.createIRI("http://example.org/name"); + mockExKnows = factory.createIRI("http://example.org/knows"); - mockLiteralJohn = createLiteral(lexJohn, null, null); - mockLiteralHelloEn = createLiteral(hello, null, "en"); + mockLiteralJohn = factory.createLiteral(lexJohn, null, null); + mockLiteralHelloEn = factory.createLiteral(hello, null, "en"); - mockBNode1 = createBlankNode("b1"); - mockBNode2 = createBlankNode("b2"); + mockBNode1 = factory.createBlankNode("b1"); + mockBNode2 = factory.createBlankNode("b2"); } @Test @@ -70,7 +70,7 @@ void constructorShouldThrowForNullConfig() { @Test @DisplayName("Write should serialize a simple statement correctly (default graph)") void writeShouldSerializeSimpleStatement() throws SerializationException { - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockExPerson, mockExName, mockLiteralJohn @@ -91,8 +91,8 @@ void writeShouldSerializeSimpleStatement() throws SerializationException { @Test @DisplayName("Write should serialize a statement with context but ignore it (N-Triples)") void writeShouldSerializeStatementWithContext() throws SerializationException { - IRI mockContext = createIRI("http://example.org/ctx"); - Statement stmt = createStatement( + IRI mockContext = factory.createIRI("http://example.org/ctx"); + Statement stmt = factory.createStatement( mockExPerson, mockExName, mockLiteralJohn, @@ -114,7 +114,7 @@ void writeShouldSerializeStatementWithContext() throws SerializationException { @Test @DisplayName("Write should handle blank nodes with default N-Triples prefix (_:)") void writeShouldHandleBlankNodes() throws SerializationException { - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockBNode1, mockExKnows, mockBNode2 @@ -135,7 +135,7 @@ void writeShouldHandleBlankNodes() throws SerializationException { @Test @DisplayName("Write should throw SerializationException on IO error") void writeShouldThrowOnIOException() throws IOException { - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockExPerson, mockExName, mockLiteralJohn @@ -203,7 +203,7 @@ void writeShouldThrowOnNullObjectValue() { @Test @DisplayName("Should handle null context correctly (default graph)") void writeShouldHandleNullContext() throws SerializationException { - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockExPerson, mockExName, mockLiteralJohn, @@ -236,9 +236,9 @@ void writeShouldHandleNullContext() throws SerializationException { }) @DisplayName("Write should handle various literal values with appropriate escaping (including Unicode)") void writeShouldHandleVariousLiterals(String literalValue) throws SerializationException { - Literal literalMock = createLiteral(literalValue, null, null); + Literal literalMock = factory.createLiteral(literalValue, null, null); - Statement stmt = createStatement( + Statement stmt = factory.createStatement( mockExPerson, mockExName, literalMock @@ -262,7 +262,7 @@ void writeShouldHandleVariousLiterals(String literalValue) throws SerializationE @Test @DisplayName("Should handle literals with language tags") void shouldHandleLiteralsWithLanguageTags() throws SerializationException { - Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/greeting"), mockLiteralHelloEn); + Statement stmt = factory.createStatement(mockExPerson, factory.createIRI("http://example.org/greeting"), mockLiteralHelloEn); Model currentTestModel = mock(Model.class); when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); @@ -274,7 +274,7 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { String expectedOutput = String.format("<%s> <%s> \"%s\"@%s", mockExPerson.stringValue(), - createIRI("http://example.org/greeting").stringValue(), + factory.createIRI("http://example.org/greeting").stringValue(), escapeNTriplesString(hello), mockLiteralHelloEn.getLanguage().get()) + " .\n"; @@ -285,10 +285,10 @@ void shouldHandleLiteralsWithLanguageTags() throws SerializationException { @Test @DisplayName("Should handle literals with custom datatypes") void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { - IRI customDatatype = createIRI("http://example.org/myDataType"); - Literal customLiteral = createLiteral("123", customDatatype, null); + IRI customDatatype = factory.createIRI("http://example.org/myDataType"); + Literal customLiteral = factory.createLiteral("123", customDatatype, null); - Statement stmt = createStatement(mockExPerson, createIRI("http://example.org/value"), customLiteral); + Statement stmt = factory.createStatement(mockExPerson, factory.createIRI("http://example.org/value"), customLiteral); Model currentTestModel = mock(Model.class); when(currentTestModel.iterator()).thenReturn(new MockStatementIterator(stmt)); @@ -300,7 +300,7 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { String expectedOutput = String.format("<%s> <%s> \"%s\"^^<%s>", mockExPerson.stringValue(), - createIRI("http://example.org/value").stringValue(), + factory.createIRI("http://example.org/value").stringValue(), escapeNTriplesString("123"), customDatatype.stringValue()) + " .\n"; @@ -308,23 +308,6 @@ void shouldHandleLiteralsWithCustomDatatypes() throws SerializationException { } - private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { - Literal literal = mock(Literal.class); - when(literal.isLiteral()).thenReturn(true); - when(literal.isResource()).thenReturn(false); - when(literal.stringValue()).thenReturn(lexicalForm); - - if (langTag != null && !langTag.isEmpty()) { - when(literal.getLanguage()).thenReturn(Optional.of(langTag)); - when(literal.getDatatype()).thenReturn(RDF.langString.getIRI()); - } else { - when(literal.getLanguage()).thenReturn(Optional.empty()); - when(literal.getDatatype()).thenReturn(dataTypeIRI); - } - return literal; - } - - private String escapeNTriplesString(String s) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < s.length(); i++) { @@ -380,35 +363,4 @@ public Statement next() { return statements[index++]; } } - - private Statement createStatement(Resource subject, IRI predicate, Value object) { - return createStatement(subject, predicate, object, null); - } - - private Statement createStatement(Resource subject, IRI predicate, Value object, Resource context) { - Statement stmt = mock(Statement.class); - when(stmt.getSubject()).thenReturn(subject); - when(stmt.getPredicate()).thenReturn(predicate); - when(stmt.getObject()).thenReturn(object); - when(stmt.getContext()).thenReturn(context); - return stmt; - } - - private Resource createBlankNode(String id) { - Resource blankNode = mock(Resource.class); - when(blankNode.isResource()).thenReturn(true); - when(blankNode.isBNode()).thenReturn(true); - when(blankNode.isIRI()).thenReturn(false); - when(blankNode.stringValue()).thenReturn(id); - return blankNode; - } - - private IRI createIRI(String uri) { - IRI iri = mock(IRI.class); - when(iri.isResource()).thenReturn(true); - when(iri.isIRI()).thenReturn(true); - when(iri.isBNode()).thenReturn(false); - when(iri.stringValue()).thenReturn(uri); - return iri; - } } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TestStatementFactory.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TestStatementFactory.java new file mode 100644 index 000000000..3fd8dc034 --- /dev/null +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TestStatementFactory.java @@ -0,0 +1,106 @@ +package fr.inria.corese.core.next.impl.common.serialization; + +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Literal; +import fr.inria.corese.core.next.api.Resource; +import fr.inria.corese.core.next.api.Statement; +import fr.inria.corese.core.next.api.Value; +import fr.inria.corese.core.next.impl.common.vocabulary.RDF; + +import java.util.Optional; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +/** + * A factory class to create mocked RDF components (Statements, IRIs, Literals, Blank Nodes) + * for use in unit tests. This centralizes the creation logic and reduces duplication + * across various serializer test classes. + */ +public class TestStatementFactory { + + /** + * Creates a mocked Statement object with a subject, predicate, and object. + * The context (named graph) is set to null. + * + * @param subject The mocked Resource representing the subject. + * @param predicate The mocked IRI representing the predicate. + * @param object The mocked Value representing the object (IRI, Literal, or Blank Node). + * @return A mocked Statement instance. + */ + public Statement createStatement(Resource subject, IRI predicate, Value object) { + return createStatement(subject, predicate, object, null); + } + + /** + * Creates a mocked Statement object with a subject, predicate, object, and an optional context. + * + * @param subject The mocked Resource representing the subject. + * @param predicate The mocked IRI representing the predicate. + * @param object The mocked Value representing the object (IRI, Literal, or Blank Node). + * @param context The mocked Resource representing the context (named graph), or null if none. + * @return A mocked Statement instance. + */ + public Statement createStatement(Resource subject, IRI predicate, Value object, Resource context) { + Statement stmt = mock(Statement.class); + when(stmt.getSubject()).thenReturn(subject); + when(stmt.getPredicate()).thenReturn(predicate); + when(stmt.getObject()).thenReturn(object); + when(stmt.getContext()).thenReturn(context); + return stmt; + } + + /** + * Creates a mocked Blank Node (Resource) object with a given ID. + * + * @param id The string identifier for the blank node (e.g., "b1"). + * @return A mocked Resource instance representing a blank node. + */ + public Resource createBlankNode(String id) { + Resource blankNode = mock(Resource.class); + when(blankNode.isResource()).thenReturn(true); + when(blankNode.isBNode()).thenReturn(true); + when(blankNode.isIRI()).thenReturn(false); + when(blankNode.stringValue()).thenReturn(id); + return blankNode; + } + + /** + * Creates a mocked IRI object with a given URI string. + * + * @param uri The string URI for the IRI (e.g., "http://example.org/Person"). + * @return A mocked IRI instance. + */ + public IRI createIRI(String uri) { + IRI iri = mock(IRI.class); + when(iri.isResource()).thenReturn(true); + when(iri.isIRI()).thenReturn(true); + when(iri.isBNode()).thenReturn(false); + when(iri.stringValue()).thenReturn(uri); + return iri; + } + + /** + * Creates a mocked Literal object. + * + * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). + * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. + * @param langTag The language tag (e.g., "en"), or null if not language-tagged. + * @return A mocked Literal instance. + */ + public Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { + Literal literal = mock(Literal.class); + when(literal.isLiteral()).thenReturn(true); + when(literal.isResource()).thenReturn(false); + when(literal.stringValue()).thenReturn(lexicalForm); + + if (langTag != null && !langTag.isEmpty()) { + when(literal.getLanguage()).thenReturn(Optional.of(langTag)); + when(literal.getDatatype()).thenReturn(RDF.langString.getIRI()); + } else { + when(literal.getLanguage()).thenReturn(Optional.empty()); + when(literal.getDatatype()).thenReturn(dataTypeIRI); + } + return literal; + } +} diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java index 43f8c8fca..cda7322cc 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TriGSerializerTest.java @@ -1,6 +1,8 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Statement; import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.TriGConfig; @@ -12,7 +14,6 @@ import java.io.IOException; import java.io.StringWriter; import java.util.Collections; -import java.util.Optional; import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -27,11 +28,13 @@ class TriGSerializerTest { private Model mockModel; private TriGConfig defaultConfig; + private TestStatementFactory factory; @BeforeEach void setUp() { mockModel = mock(Model.class); defaultConfig = TriGConfig.defaultConfig(); + factory = new TestStatementFactory(); } /** @@ -44,10 +47,10 @@ void setUp() { */ @Test void testBasicTriGSerialization() throws SerializationException, IOException { - Statement mockStatement = createStatement( - createIRI("http://example.org/ns/person1"), - createIRI("http://example.org/ns/hasName"), - createLiteral("John Doe", null, null), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/ns/person1"), + factory.createIRI("http://example.org/ns/hasName"), + factory.createLiteral("John Doe", null, null), null ); @@ -90,10 +93,10 @@ void testBasicTriGSerialization() throws SerializationException, IOException { @Test void testRdfTypeShortcut() throws SerializationException, IOException { - Statement mockStatement = createStatement( - createIRI("http://example.org/ns/person1"), - createIRI(SerializationConstants.RDF_TYPE), - createIRI("http://xmlns.com/foaf/0.1/Person"), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/ns/person1"), + factory.createIRI(SerializationConstants.RDF_TYPE), + factory.createIRI("http://xmlns.com/foaf/0.1/Person"), null ); @@ -137,10 +140,10 @@ void testRdfTypeShortcut() throws SerializationException, IOException { @Test void testLiteralWithLanguageTag() throws SerializationException, IOException { - Statement mockStatement = createStatement( - createIRI("http://example.org/data/book1"), - createIRI("http://purl.org/dc/elements/1.1/title"), - createLiteral("The Odyssey", null, "en"), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/data/book1"), + factory.createIRI("http://purl.org/dc/elements/1.1/title"), + factory.createLiteral("The Odyssey", null, "en"), null ); @@ -186,11 +189,11 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { */ @Test void testLiteralWithExplicitXsdStringType() throws SerializationException, IOException { - IRI mockDatatype = createIRI(SerializationConstants.XSD_STRING); - Statement mockStatement = createStatement( - createIRI("http://example.org/data/book2"), - createIRI("http://purl.org/dc/elements/1.1/creator"), - createLiteral("Homer", mockDatatype, null), + IRI mockDatatype = factory.createIRI(SerializationConstants.XSD_STRING); + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/data/book2"), + factory.createIRI("http://purl.org/dc/elements/1.1/creator"), + factory.createLiteral("Homer", mockDatatype, null), null ); @@ -237,10 +240,10 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc */ @Test void testBaseIRI() throws SerializationException, IOException { - Statement mockStatement = createStatement( - createIRI("http://example.org/base/resource1"), - createIRI("http://example.org/base/prop"), - createLiteral("Test", null, null), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/base/resource1"), + factory.createIRI("http://example.org/base/prop"), + factory.createLiteral("Test", null, null), null ); @@ -321,10 +324,10 @@ void testEmptyModel() throws SerializationException, IOException { @Test void testStrictModeInvalidLiteral() throws SerializationException { - Statement mockStatement = createStatement( - createIRI("http://example.org/s"), - createIRI("http://example.org/p"), - createLiteral("invalid", RDF.LANGSTRING.getIRI(), null), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/s"), + factory.createIRI("http://example.org/p"), + factory.createLiteral("invalid", RDF.LANGSTRING.getIRI(), null), null ); @@ -357,10 +360,10 @@ void testStrictModeInvalidLiteral() throws SerializationException { @Test void testStrictModeInvalidIRICharacters() throws SerializationException { - Statement mockStatement = createStatement( - createIRI("http://example.org/s"), - createIRI("http://example.org/p"), - createIRI("http://example.org/invalid iri"), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/s"), + factory.createIRI("http://example.org/p"), + factory.createIRI("http://example.org/invalid iri"), null ); @@ -395,10 +398,10 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { void testMultilineLiteralSerialization() throws SerializationException, IOException { String multilineText = "This is the first line.\nThis is the second line."; - Statement mockStatement = createStatement( - createIRI("http://example.org/book/1"), - createIRI("http://example.org/properties/description"), - createLiteral(multilineText, null, null), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/book/1"), + factory.createIRI("http://example.org/properties/description"), + factory.createLiteral(multilineText, null, null), null ); @@ -408,7 +411,6 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept .thenReturn(Stream.of(mockStatement)); StringWriter writer = new StringWriter(); - // Create a TriGConfig with useMultilineLiterals enabled TriGConfig customConfig = new TriGConfig.Builder() .useMultilineLiterals(true) .prettyPrint(true) @@ -444,11 +446,11 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept */ @Test void testBasicTrigSerializationWithNamedGraph() throws SerializationException, IOException { - Statement mockStatement = createStatement( - createIRI("http://example.org/data/person1"), - createIRI("http://example.org/data/name"), - createLiteral("Alice", null, null), - createIRI("http://example.org/graph/g1") + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/data/person1"), + factory.createIRI("http://example.org/data/name"), + factory.createLiteral("Alice", null, null), + factory.createIRI("http://example.org/graph/g1") ); when(mockModel.iterator()).thenAnswer(invocation -> Collections.singletonList(mockStatement).iterator()); @@ -482,46 +484,4 @@ void testBasicTrigSerializationWithNamedGraph() throws SerializationException, I } - private Statement createStatement(Resource subject, IRI predicate, Value object, Resource context) { - Statement stmt = mock(Statement.class); - when(stmt.getSubject()).thenReturn(subject); - when(stmt.getPredicate()).thenReturn(predicate); - when(stmt.getObject()).thenReturn(object); - when(stmt.getContext()).thenReturn(context); - return stmt; - } - - - private IRI createIRI(String uri) { - IRI iri = mock(IRI.class); - when(iri.isResource()).thenReturn(true); - when(iri.isIRI()).thenReturn(true); - when(iri.isBNode()).thenReturn(false); - when(iri.stringValue()).thenReturn(uri); - return iri; - } - - /** - * Creates a mocked Literal object. - * - * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). - * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. - * @param langTag The language tag (e.g., "en"), or null if not language-tagged. - * @return A mocked Literal instance. - */ - private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { - Literal literal = mock(Literal.class); - when(literal.isLiteral()).thenReturn(true); - when(literal.isResource()).thenReturn(false); - when(literal.stringValue()).thenReturn(lexicalForm); - - if (langTag != null && !langTag.isEmpty()) { - when(literal.getLanguage()).thenReturn(Optional.of(langTag)); - when(literal.getDatatype()).thenReturn(RDF.LANGSTRING.getIRI()); - } else { - when(literal.getLanguage()).thenReturn(Optional.empty()); - when(literal.getDatatype()).thenReturn(dataTypeIRI); - } - return literal; - } } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java index 46b38fef4..053e111ef 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/TurtleSerializerTest.java @@ -1,6 +1,8 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.api.IRI; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Statement; import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.TurtleConfig; @@ -14,7 +16,6 @@ import java.io.StringWriter; import java.util.Arrays; import java.util.Collections; -import java.util.Optional; import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -29,11 +30,13 @@ class TurtleSerializerTest { private Model mockModel; private TurtleConfig defaultConfig; + private TestStatementFactory factory; @BeforeEach void setUp() { mockModel = mock(Model.class); defaultConfig = TurtleConfig.defaultConfig(); + factory = new TestStatementFactory(); } /** @@ -46,10 +49,10 @@ void setUp() { */ @Test void testBasicTurtleSerialization() throws SerializationException, IOException { - Statement mockStatement = createStatement( - createIRI("http://example.org/ns/person1"), - createIRI("http://example.org/ns/hasName"), - createLiteral("John Doe", null, null), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/ns/person1"), + factory.createIRI("http://example.org/ns/hasName"), + factory.createLiteral("John Doe", null, null), null ); @@ -88,11 +91,11 @@ void testBasicTurtleSerialization() throws SerializationException, IOException { */ @Test void testRdfTypeShortcut() throws SerializationException, IOException { - - Statement mockStatement = createStatement( - createIRI("http://example.org/ns/person1"), - createIRI(SerializationConstants.RDF_TYPE), - createIRI("http://xmlns.com/foaf/0.1/Person"), + + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/ns/person1"), + factory.createIRI(SerializationConstants.RDF_TYPE), + factory.createIRI("http://xmlns.com/foaf/0.1/Person"), null ); @@ -134,10 +137,10 @@ void testRdfTypeShortcut() throws SerializationException, IOException { @Test void testLiteralWithLanguageTag() throws SerializationException, IOException { - Statement mockStatement = createStatement( - createIRI("http://example.org/data/book1"), - createIRI("http://purl.org/dc/elements/1.1/title"), - createLiteral("The Odyssey", null, "en"), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/data/book1"), + factory.createIRI("http://purl.org/dc/elements/1.1/title"), + factory.createLiteral("The Odyssey", null, "en"), null ); @@ -163,10 +166,10 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { .build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, config); - + turtleSerializer.write(writer); - + verify(mockModel, times(2)).stream(); String expected = """ @prefix 11: . @@ -192,12 +195,12 @@ void testLiteralWithLanguageTag() throws SerializationException, IOException { @Test @DisplayName("Should serialize literal with xsd:string datatype (minimal policy)") void testLiteralWithExplicitXsdStringType() throws SerializationException, IOException { - - IRI mockDatatype = createIRI(SerializationConstants.XSD_STRING); - Statement mockStatement = createStatement( - createIRI("http://example.org/data/book2"), - createIRI("http://purl.org/dc/elements/1.1/creator"), - createLiteral("Homer", mockDatatype, null), + + IRI mockDatatype = factory.createIRI(SerializationConstants.XSD_STRING); + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/data/book2"), + factory.createIRI("http://purl.org/dc/elements/1.1/creator"), + factory.createLiteral("Homer", mockDatatype, null), null ); @@ -218,10 +221,10 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc .build(); TurtleSerializer turtleSerializer = new TurtleSerializer(mockModel, config); - + turtleSerializer.write(writer); - + verify(mockModel, times(2)).stream(); String expected = """ @prefix data: . @@ -246,18 +249,18 @@ void testLiteralWithExplicitXsdStringType() throws SerializationException, IOExc */ @Test void testBlankNodeSerialization() throws SerializationException, IOException { - - Statement mainStatement = createStatement( - createIRI("http://example.org/ns/mainSubject"), - createIRI("http://example.org/ns/refersTo"), - createBlankNode("b1"), + + Statement mainStatement = factory.createStatement( + factory.createIRI("http://example.org/ns/mainSubject"), + factory.createIRI("http://example.org/ns/refersTo"), + factory.createBlankNode("b1"), null ); - Statement bNodePropertyStatement = createStatement( - createBlankNode("b1"), - createIRI("http://example.org/ns/hasValue"), - createLiteral("Value of BNode", null, null), + Statement bNodePropertyStatement = factory.createStatement( + factory.createBlankNode("b1"), + factory.createIRI("http://example.org/ns/hasValue"), + factory.createLiteral("Value of BNode", null, null), null ); @@ -296,10 +299,10 @@ void testBlankNodeSerialization() throws SerializationException, IOException { */ @Test void testBaseIRI() throws SerializationException, IOException { - Statement mockStatement = createStatement( - createIRI("http://example.org/base/resource1"), - createIRI("http://example.org/base/prop"), - createLiteral("Test", null, null), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/base/resource1"), + factory.createIRI("http://example.org/base/prop"), + factory.createLiteral("Test", null, null), null ); @@ -381,10 +384,10 @@ void testEmptyModel() throws SerializationException, IOException { @Test void testStrictModeInvalidLiteral() throws SerializationException { - Statement mockStatement = createStatement( - createIRI("http://example.org/s"), - createIRI("http://example.org/p"), - createLiteral("invalid", RDF.LANGSTRING.getIRI(), null), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/s"), + factory.createIRI("http://example.org/p"), + factory.createLiteral("invalid", RDF.LANGSTRING.getIRI(), null), null ); @@ -417,10 +420,10 @@ void testStrictModeInvalidLiteral() throws SerializationException { @Test void testStrictModeInvalidIRICharacters() throws SerializationException { - Statement mockStatement = createStatement( - createIRI("http://example.org/s"), - createIRI("http://example.org/p"), - createIRI("http://example.org/invalid iri"), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/s"), + factory.createIRI("http://example.org/p"), + factory.createIRI("http://example.org/invalid iri"), null ); @@ -454,10 +457,10 @@ void testStrictModeInvalidIRICharacters() throws SerializationException { @Test void testMultilineLiteralSerialization() throws SerializationException, IOException { String multilineText = "This is the first line.\nThis is the second line."; - Statement mockStatement = createStatement( - createIRI("http://example.org/book/1"), - createIRI("http://example.org/properties/description"), - createLiteral(multilineText, null, null), + Statement mockStatement = factory.createStatement( + factory.createIRI("http://example.org/book/1"), + factory.createIRI("http://example.org/properties/description"), + factory.createLiteral(multilineText, null, null), null ); @@ -492,55 +495,4 @@ void testMultilineLiteralSerialization() throws SerializationException, IOExcept assertEquals(expected, actual); } - - private Statement createStatement(Resource subject, IRI predicate, Value object, Resource context) { - Statement stmt = mock(Statement.class); - when(stmt.getSubject()).thenReturn(subject); - when(stmt.getPredicate()).thenReturn(predicate); - when(stmt.getObject()).thenReturn(object); - when(stmt.getContext()).thenReturn(context); - return stmt; - } - - private Resource createBlankNode(String id) { - Resource blankNode = mock(Resource.class); - when(blankNode.isResource()).thenReturn(true); - when(blankNode.isBNode()).thenReturn(true); - when(blankNode.isIRI()).thenReturn(false); - when(blankNode.stringValue()).thenReturn(id); - return blankNode; - } - - private IRI createIRI(String uri) { - IRI iri = mock(IRI.class); - when(iri.isResource()).thenReturn(true); - when(iri.isIRI()).thenReturn(true); - when(iri.isBNode()).thenReturn(false); - when(iri.stringValue()).thenReturn(uri); - return iri; - } - - /** - * Creates a mocked Literal object. - * - * @param lexicalForm The raw string value of the literal (e.g., "hello", "123"). - * @param dataTypeIRI The IRI of the literal's datatype (e.g., XSD.INTEGER.getIRI()), or null for plain/lang-tagged. - * @param langTag The language tag (e.g., "en"), or null if not language-tagged. - * @return A mocked Literal instance. - */ - private Literal createLiteral(String lexicalForm, IRI dataTypeIRI, String langTag) { - Literal literal = mock(Literal.class); - when(literal.isLiteral()).thenReturn(true); - when(literal.isResource()).thenReturn(false); - when(literal.stringValue()).thenReturn(lexicalForm); - - if (langTag != null && !langTag.isEmpty()) { - when(literal.getLanguage()).thenReturn(Optional.of(langTag)); - when(literal.getDatatype()).thenReturn(RDF.LANGSTRING.getIRI()); - } else { - when(literal.getLanguage()).thenReturn(Optional.empty()); - when(literal.getDatatype()).thenReturn(dataTypeIRI); - } - return literal; - } } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java index 12134558b..056fd4ca7 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java @@ -1,6 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; import fr.inria.corese.core.next.api.*; +import fr.inria.corese.core.next.impl.common.literal.RDF; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.config.XmlConfig; @@ -29,14 +30,7 @@ class XmlSerializerTest { @Mock private Model mockModel; XmlConfig mockConfig; - @Mock - private Resource mockResource; - @Mock - private IRI mockIRI; - @Mock - private Literal mockLiteral; - @Mock - private Statement mockStatement; + private TestStatementFactory factory; private StringWriter writer; @@ -44,16 +38,20 @@ class XmlSerializerTest { void setUp() { MockitoAnnotations.openMocks(this); writer = new StringWriter(); + factory = new TestStatementFactory(); mockConfig = XmlConfig.defaultConfig(); - } @Test @DisplayName("Should serialize a simple IRI triple with auto-declared namespaces") void shouldSerializeSimpleIriTriple() throws SerializationException { - Statement stmt = createMockStatement("http://example.org/subject", "http://xmlns.com/foaf/0.1/name", "http://example.org/object"); + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/subject"), + factory.createIRI("http://xmlns.com/foaf/0.1/name"), + factory.createIRI("http://example.org/object") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -84,7 +82,11 @@ void shouldSerializeSimpleIriTriple() throws SerializationException { @Test @DisplayName("Should handle blank node subject") void shouldHandleBlankNodeSubject() throws SerializationException { - Statement stmt = createMockBlankNodeSubjectStatement("b1", "http://xmlns.com/foaf/0.1/name", "http://example.org/Alice"); + Statement stmt = factory.createStatement( + factory.createBlankNode("b1"), + factory.createIRI("http://xmlns.com/foaf/0.1/name"), + factory.createIRI("http://example.org/Alice") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -113,7 +115,11 @@ void shouldHandleBlankNodeSubject() throws SerializationException { @Test @DisplayName("Should handle blank node object with correct namespace ordering") void shouldHandleBlankNodeObject() throws SerializationException { - Statement stmt = createMockBlankNodeObjectStatement("http://example.org/book", "http://purl.org/dc/elements/1.1/creator", "b2"); + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/book"), + factory.createIRI("http://purl.org/dc/elements/1.1/creator"), + factory.createBlankNode("b2") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -142,8 +148,11 @@ void shouldHandleBlankNodeObject() throws SerializationException { @Test @DisplayName("Should serialize literal with xsd:string datatype (minimal policy)") void shouldSerializeLiteralWithStringDatatypeMinimalPolicy() throws SerializationException { - Statement stmt = createMockLiteralStatement("http://example.org/person", "http://xmlns.com/foaf/0.1/name", "John Doe", SerializationConstants.XSD_STRING, - null); + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/person"), + factory.createIRI("http://xmlns.com/foaf/0.1/name"), + factory.createLiteral("John Doe", factory.createIRI(SerializationConstants.XSD_STRING), null) + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -170,7 +179,11 @@ void shouldSerializeLiteralWithStringDatatypeMinimalPolicy() throws Serializatio @Test @DisplayName("Should serialize literal with custom datatype using minimal policy") void shouldSerializeLiteralWithCustomDatatypeMinimalPolicy() throws SerializationException { - Statement stmt = createMockLiteralStatement("http://example.org/data", "http://example.org/vocabulary/value", "123", SerializationConstants.XSD_INTEGER, null); + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/data"), + factory.createIRI("http://example.org/vocabulary/value"), + factory.createLiteral("123", factory.createIRI(SerializationConstants.XSD_INTEGER), null) + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -198,7 +211,11 @@ void shouldSerializeLiteralWithCustomDatatypeMinimalPolicy() throws Serializatio @Test @DisplayName("Should serialize literal with language tag") void shouldSerializeLiteralWithLanguage() throws SerializationException { - Statement stmt = createMockLiteralStatement("http://example.org/book", "http://purl.org/dc/elements/1.1/title", "The Book", null, "en"); + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/book"), + factory.createIRI("http://purl.org/dc/elements/1.1/title"), + factory.createLiteral("The Book", null, "en") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -225,8 +242,16 @@ void shouldSerializeLiteralWithLanguage() throws SerializationException { @Test @DisplayName("Should respect alphabetical prefix ordering") void shouldRespectPrefixOrderingAlphabetical() throws SerializationException { - Statement stmt1 = createMockStatement("http://ex.org/s1", "http://ex.org/p1", "http://ex.org/o1"); - Statement stmt2 = createMockStatement("http://ex.com/s2", "http://ex.com/p2", "http://ex.com/o2"); + Statement stmt1 = factory.createStatement( + factory.createIRI("http://ex.org/s1"), + factory.createIRI("http://ex.org/p1"), + factory.createIRI("http://ex.org/o1") + ); + Statement stmt2 = factory.createStatement( + factory.createIRI("http://ex.com/s2"), + factory.createIRI("http://ex.com/p2"), + factory.createIRI("http://ex.com/o2") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); @@ -259,8 +284,16 @@ void shouldRespectPrefixOrderingAlphabetical() throws SerializationException { @Test @DisplayName("Should respect default prefix ordering (non-deterministic for subjects)") void shouldRespectPrefixOrderingDefault() throws SerializationException { - Statement stmt1 = createMockStatement("http://ex.org/s1", "http://ex.org/p1", "http://ex.org/o1"); - Statement stmt2 = createMockStatement("http://ex.com/s2", "http://ex.com/p2", "http://ex.com/o2"); + Statement stmt1 = factory.createStatement( + factory.createIRI("http://ex.org/s1"), + factory.createIRI("http://ex.org/p1"), + factory.createIRI("http://ex.org/o1") + ); + Statement stmt2 = factory.createStatement( + factory.createIRI("http://ex.com/s2"), + factory.createIRI("http://ex.com/p2"), + factory.createIRI("http://ex.com/o2") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); @@ -293,8 +326,16 @@ void shouldRespectPrefixOrderingDefault() throws SerializationException { @Test @DisplayName("Should sort subjects alphabetically") void shouldSortSubjectsAlphabetically() throws SerializationException { - Statement stmt1 = createMockStatement("http://ex.org/B", "http://ex.org/p", "http://ex.org/o"); - Statement stmt2 = createMockStatement("http://ex.org/A", "http://ex.org/p", "http://ex.org/o"); + Statement stmt1 = factory.createStatement( + factory.createIRI("http://ex.org/B"), + factory.createIRI("http://ex.org/p"), + factory.createIRI("http://ex.org/o") + ); + Statement stmt2 = factory.createStatement( + factory.createIRI("http://ex.org/A"), + factory.createIRI("http://ex.org/p"), + factory.createIRI("http://ex.org/o") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); @@ -326,7 +367,11 @@ void shouldSortSubjectsAlphabetically() throws SerializationException { @Test @DisplayName("Should escape XML attribute values") void shouldEscapeXmlAttributeValues() throws SerializationException { - Statement stmt = createMockStatement("http://example.org/sub&ject<", "http://example.org/pred", "http://example.org/obj\"ect'"); + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/sub&ject<"), + factory.createIRI("http://example.org/pred"), + factory.createIRI("http://example.org/obj\"ect'") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -352,8 +397,10 @@ void shouldEscapeXmlAttributeValues() throws SerializationException { @Test @DisplayName("Should escape XML content values") void shouldEscapeXmlContentValues() throws SerializationException { - Statement stmt = createMockLiteralStatement("http://example.org/item", "http://example.org/prop", "Value with & entities", null, - null + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/item"), + factory.createIRI("http://example.org/prop"), + factory.createLiteral("Value with & entities", null, null) ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -384,7 +431,11 @@ void shouldEscapeXmlContentValues() throws SerializationException { @Test @DisplayName("Should not auto-declare prefixes if disabled in configuration") void shouldNotAutoDeclarePrefixesIfDisabled() throws SerializationException { - Statement stmt = createMockStatement("http://example.org/subject", "http://xmlns.com/foaf/0.1/name", "http://example.org/object"); + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/subject"), + factory.createIRI("http://xmlns.com/foaf/0.1/name"), + factory.createIRI("http://example.org/object") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -412,7 +463,11 @@ void shouldNotAutoDeclarePrefixesIfDisabled() throws SerializationException { @Test @DisplayName("Should not use prefixes if disabled in configuration") void shouldNotUsePrefixesIfDisabled() throws SerializationException { - Statement stmt = createMockStatement("http://example.org/subject", "http://xmlns.com/foaf/0.1/name", "http://example.org/object"); + Statement stmt = factory.createStatement( + factory.createIRI("http://example.org/subject"), + factory.createIRI("http://xmlns.com/foaf/0.1/name"), + factory.createIRI("http://example.org/object") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt)); @@ -441,8 +496,16 @@ void shouldNotUsePrefixesIfDisabled() throws SerializationException { @Test @DisplayName("Should not generate stable blank node IDs and sort subjects alphabetically") void shouldNotGenerateStableBlankNodeIds() throws SerializationException { - Statement stmt1 = createMockBlankNodeSubjectStatement("bnode-abc", "http://example.org/p", "http://example.org/o"); - Statement stmt2 = createMockBlankNodeObjectStatement("http://example.org/s", "http://example.org/p", "bnode-xyz"); + Statement stmt1 = factory.createStatement( + factory.createBlankNode("bnode-abc"), + factory.createIRI("http://example.org/p"), + factory.createIRI("http://example.org/o") + ); + Statement stmt2 = factory.createStatement( + factory.createIRI("http://example.org/s"), + factory.createIRI("http://example.org/p"), + factory.createBlankNode("bnode-xyz") + ); when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); @@ -492,118 +555,4 @@ void shouldHandleEmptyModel() throws SerializationException { assertEquals(expected, writer.toString()); } - - - /** - * Helper method to create a mock Statement with IRI subject, predicate, and object. - * Completes all necessary stubbing for these mocks. - */ - private Statement createMockStatement(String subjectUri, String predicateUri, String objectUri) { - Resource subject = mock(Resource.class); - when(subject.isIRI()).thenReturn(true); - when(subject.isBNode()).thenReturn(false); - when(subject.stringValue()).thenReturn(subjectUri); - - IRI predicate = mock(IRI.class); - when(predicate.isIRI()).thenReturn(true); - when(predicate.isBNode()).thenReturn(false); - when(predicate.stringValue()).thenReturn(predicateUri); - - IRI object = mock(IRI.class); - when(object.isIRI()).thenReturn(true); - when(object.isBNode()).thenReturn(false); - when(object.stringValue()).thenReturn(objectUri); - - Statement statement = mock(Statement.class); - when(statement.getSubject()).thenReturn(subject); - when(statement.getPredicate()).thenReturn(predicate); - when(statement.getObject()).thenReturn(object); - - return statement; - } - - /** - * Helper method to create a mock Statement with a blank node subject. - */ - private Statement createMockBlankNodeSubjectStatement(String blankNodeId, String predicateUri, String objectUri) { - Resource subject = mock(Resource.class); - when(subject.isIRI()).thenReturn(false); - when(subject.isBNode()).thenReturn(true); - when(subject.stringValue()).thenReturn("_:" + blankNodeId); - - IRI predicate = mock(IRI.class); - when(predicate.isIRI()).thenReturn(true); - when(predicate.stringValue()).thenReturn(predicateUri); - - IRI object = mock(IRI.class); - when(object.isIRI()).thenReturn(true); - when(object.stringValue()).thenReturn(objectUri); - - Statement statement = mock(Statement.class); - when(statement.getSubject()).thenReturn(subject); - when(statement.getPredicate()).thenReturn(predicate); - when(statement.getObject()).thenReturn(object); - - return statement; - } - - /** - * Helper method to create a mock Statement with a blank node object. - */ - private Statement createMockBlankNodeObjectStatement(String subjectUri, String predicateUri, String blankNodeId) { - Resource subject = mock(Resource.class); - when(subject.isIRI()).thenReturn(true); - when(subject.stringValue()).thenReturn(subjectUri); - - IRI predicate = mock(IRI.class); - when(predicate.isIRI()).thenReturn(true); - when(predicate.stringValue()).thenReturn(predicateUri); - - Resource object = mock(Resource.class); - when(object.isIRI()).thenReturn(false); - when(object.isBNode()).thenReturn(true); - when(object.stringValue()).thenReturn("_:" + blankNodeId); - - Statement statement = mock(Statement.class); - when(statement.getSubject()).thenReturn(subject); - when(statement.getPredicate()).thenReturn(predicate); - when(statement.getObject()).thenReturn(object); - - return statement; - } - - /** - * Helper method to create a mock Statement with a literal object. - */ - private Statement createMockLiteralStatement(String subjectUri, String predicateUri, String literalValue, String datatypeUri, String langTag) { - Resource subject = mock(Resource.class); - when(subject.isIRI()).thenReturn(true); - when(subject.stringValue()).thenReturn(subjectUri); - - IRI predicate = mock(IRI.class); - when(predicate.isIRI()).thenReturn(true); - when(predicate.stringValue()).thenReturn(predicateUri); - - Literal literal = mock(Literal.class); - when(literal.isIRI()).thenReturn(false); - when(literal.isBNode()).thenReturn(false); - when(literal.isLiteral()).thenReturn(true); - when(literal.stringValue()).thenReturn(literalValue); - when(literal.getLanguage()).thenReturn(Optional.ofNullable(langTag)); - if (datatypeUri != null) { - IRI datatype = mock(IRI.class); - when(datatype.stringValue()).thenReturn(datatypeUri); - when(literal.getDatatype()).thenReturn(datatype); - } else { - when(literal.getDatatype()).thenReturn(null); - } - - Statement statement = mock(Statement.class); - when(statement.getSubject()).thenReturn(subject); - when(statement.getPredicate()).thenReturn(predicate); - when(statement.getObject()).thenReturn(literal); - - return statement; - } - } From ff73b8501a9f121f1040b0eb961765a3ef405096 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Fri, 4 Jul 2025 16:36:38 +0200 Subject: [PATCH 24/27] ajouter n quads config test --- .../serialization/XmlSerializerTest.java | 51 +------- .../config/NQuadsConfigTest.java | 121 +++++++++++++++++- 2 files changed, 124 insertions(+), 48 deletions(-) diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java index 056fd4ca7..54d27e46c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/XmlSerializerTest.java @@ -1,7 +1,7 @@ package fr.inria.corese.core.next.impl.common.serialization; -import fr.inria.corese.core.next.api.*; -import fr.inria.corese.core.next.impl.common.literal.RDF; +import fr.inria.corese.core.next.api.Model; +import fr.inria.corese.core.next.api.Statement; import fr.inria.corese.core.next.impl.common.serialization.config.LiteralDatatypePolicyEnum; import fr.inria.corese.core.next.impl.common.serialization.config.PrefixOrderingEnum; import fr.inria.corese.core.next.impl.common.serialization.config.XmlConfig; @@ -14,12 +14,10 @@ import org.mockito.MockitoAnnotations; import java.io.StringWriter; -import java.util.Optional; import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; /** @@ -239,47 +237,6 @@ void shouldSerializeLiteralWithLanguage() throws SerializationException { assertEquals(expected, writer.toString()); } - @Test - @DisplayName("Should respect alphabetical prefix ordering") - void shouldRespectPrefixOrderingAlphabetical() throws SerializationException { - Statement stmt1 = factory.createStatement( - factory.createIRI("http://ex.org/s1"), - factory.createIRI("http://ex.org/p1"), - factory.createIRI("http://ex.org/o1") - ); - Statement stmt2 = factory.createStatement( - factory.createIRI("http://ex.com/s2"), - factory.createIRI("http://ex.com/p2"), - factory.createIRI("http://ex.com/o2") - ); - - when(mockModel.stream()).thenReturn(Stream.of(stmt1, stmt2)); - - XmlConfig testConfig = new XmlConfig.Builder() - .addCustomPrefix("exorg", "http://ex.org/") - .addCustomPrefix("excom", "http://ex.com/") - .prefixOrdering(PrefixOrderingEnum.ALPHABETICAL) - .sortSubjects(false) - .build(); - - XmlSerializer serializer = new XmlSerializer(mockModel, testConfig); - serializer.write(writer); - - - String expected = """ - - - - - - - - - - """; - - assertEquals(expected, writer.toString()); - } @Test @DisplayName("Should respect default prefix ordering (non-deterministic for subjects)") @@ -523,11 +480,11 @@ void shouldNotGenerateStableBlankNodeIds() throws SerializationException { String expected = """ - + - + """; diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfigTest.java index bc7863e44..8fdb09247 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfigTest.java @@ -1,4 +1,123 @@ package fr.inria.corese.core.next.impl.common.serialization.config; -public class NQuadsConfigTest { +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for the {@link NQuadsConfig} class. + * These tests verify the default configuration settings and the functionality + * of the builder pattern for customizing N-Quads serialization options. + */ +class NQuadsConfigTest { + + @Test + @DisplayName("defaultConfig() should return a config with expected N-Quads defaults") + void defaultConfig_shouldReturnExpectedDefaults() { + NQuadsConfig config = NQuadsConfig.defaultConfig(); + + assertNotNull(config, "Default config should not be null"); + + assertTrue(config.strictMode, "Default strictMode should be true for N-Quads"); + assertTrue(config.escapeUnicode(), "Default escapeUnicode should be true for N-Quads"); + assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy(), "Default literalDatatypePolicy should be ALWAYS_TYPED"); + assertNull(config.getBaseIRI(), "Default baseIRI should be null"); + assertFalse(config.stableBlankNodeIds(), "Default stableBlankNodeIds should be false"); + + assertTrue(config.includeContext(), "Default includeContext should be true for N-Quads"); + } + + @Test + @DisplayName("Builder should allow overriding includeContext") + void builder_shouldAllowOverridingIncludeContext() { + NQuadsConfig config = NQuadsConfig.builder() + .includeContext(false) + .build(); + + assertFalse(config.includeContext(), "includeContext should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding literalDatatypePolicy") + void builder_shouldAllowOverridingLiteralDatatypePolicy() { + NQuadsConfig config = NQuadsConfig.builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) + .build(); + + assertEquals(LiteralDatatypePolicyEnum.MINIMAL, config.getLiteralDatatypePolicy(), "literalDatatypePolicy should be overridden to MINIMAL"); + } + + @Test + @DisplayName("Builder should allow overriding escapeUnicode") + void builder_shouldAllowOverridingEscapeUnicode() { + NQuadsConfig config = NQuadsConfig.builder() + .escapeUnicode(false) + .build(); + + assertFalse(config.escapeUnicode(), "escapeUnicode should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding strictMode") + void builder_shouldAllowOverridingStrictMode() { + NQuadsConfig config = NQuadsConfig.builder() + .strictMode(false) + .build(); + + assertFalse(config.strictMode, "strictMode should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow setting baseIRI") + void builder_shouldAllowSettingBaseIRI() { + String testBaseIRI = "http://example.org/base/"; + NQuadsConfig config = NQuadsConfig.builder() + .baseIRI(testBaseIRI) + .build(); + + assertEquals(testBaseIRI, config.getBaseIRI(), "baseIRI should be set correctly"); + } + + @Test + @DisplayName("Builder should allow setting lineEnding") + void builder_shouldAllowSettingLineEnding() { + String customLineEnding = "\r\n"; + NQuadsConfig config = NQuadsConfig.builder() + .lineEnding(customLineEnding) + .build(); + + assertEquals(customLineEnding, config.getLineEnding(), "lineEnding should be set correctly"); + } + + @Test + @DisplayName("Builder should allow overriding validateURIs") + void builder_shouldAllowOverridingValidateURIs() { + NQuadsConfig config = NQuadsConfig.builder() + .validateURIs(true) + .build(); + + assertTrue(config.validateURIs(), "validateURIs should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding stableBlankNodeIds") + void builder_shouldAllowOverridingStableBlankNodeIds() { + NQuadsConfig config = NQuadsConfig.builder() + .stableBlankNodeIds(true) + .build(); + + assertTrue(config.stableBlankNodeIds(), "stableBlankNodeIds should be overridden to true"); + } + + @Test + @DisplayName("Builder should handle null values for optional fields gracefully (e.g., baseIRI)") + void builder_shouldHandleNullForOptionalFields() { + NQuadsConfig config = NQuadsConfig.builder() + .baseIRI(null) + .build(); + + assertNull(config.getBaseIRI(), "baseIRI should be null when explicitly set to null"); + } + } From 47c15bae9500d62a107b7fb1c076100c0e51cd1e Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Mon, 7 Jul 2025 09:20:21 +0200 Subject: [PATCH 25/27] ajouter TU de Ntriples config --- .../serialization/config/NQuadsConfig.java | 2 +- .../config/NTriplesConfigTest.java | 122 +++++++++++++++++- 2 files changed, 122 insertions(+), 2 deletions(-) diff --git a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfig.java b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfig.java index 9a9d69058..f39c1e630 100644 --- a/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfig.java +++ b/src/main/java/fr/inria/corese/core/next/impl/common/serialization/config/NQuadsConfig.java @@ -3,7 +3,7 @@ /** * Configuration for N-Quads serialization format. * This class extends {@link AbstractNFamilyConfig} and provides specific defaults - * and options tailored for N-Quads, which extends N-Triples with named graphs. + * and options tailored for N-Quads, which extends N-Quads with named graphs. * *

    Use the {@link Builder} class to create instances of {@code NQuadsConfig}. * A predefined default configuration is available via {@link #defaultConfig()}.

    diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfigTest.java index ea9dd9f1e..0f7ec0927 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/NTriplesConfigTest.java @@ -1,4 +1,124 @@ package fr.inria.corese.core.next.impl.common.serialization.config; -public class NTriplesConfigTest { +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for the {@link NTriplesConfig} class. + * These tests verify the default configuration settings and the functionality + * of the builder pattern for customizing N-Triples serialization options. + */ +class NTriplesConfigTest { + + @Test + @DisplayName("defaultConfig() should return a config with expected N-Triples defaults") + void defaultConfig_shouldReturnExpectedDefaults() { + NTriplesConfig config = NTriplesConfig.defaultConfig(); + + assertNotNull(config, "Default config should not be null"); + + assertTrue(config.strictMode, "Default strictMode should be true for N-Triples"); + assertTrue(config.escapeUnicode(), "Default escapeUnicode should be true for N-Triples"); + assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy(), "Default literalDatatypePolicy should be ALWAYS_TYPED"); + assertNull(config.getBaseIRI(), "Default baseIRI should be null"); + assertFalse(config.stableBlankNodeIds(), "Default stableBlankNodeIds should be false"); + + assertFalse(config.includeContext(), "Default includeContext should be false for N-Triples"); + } + + @Test + @DisplayName("Builder should allow overriding includeContext") + void builder_shouldAllowOverridingIncludeContext() { + NTriplesConfig config = NTriplesConfig.builder() + .includeContext(true) + .build(); + + assertTrue(config.includeContext(), "includeContext should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding literalDatatypePolicy") + void builder_shouldAllowOverridingLiteralDatatypePolicy() { + NTriplesConfig config = NTriplesConfig.builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) + .build(); + + assertEquals(LiteralDatatypePolicyEnum.MINIMAL, config.getLiteralDatatypePolicy(), "literalDatatypePolicy should be overridden to MINIMAL"); + } + + @Test + @DisplayName("Builder should allow overriding escapeUnicode") + void builder_shouldAllowOverridingEscapeUnicode() { + NTriplesConfig config = NTriplesConfig.builder() + .escapeUnicode(false) + .build(); + + assertFalse(config.escapeUnicode(), "escapeUnicode should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding strictMode") + void builder_shouldAllowOverridingStrictMode() { + NTriplesConfig config = NTriplesConfig.builder() + .strictMode(false) + .build(); + + assertFalse(config.strictMode, "strictMode should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow setting baseIRI") + void builder_shouldAllowSettingBaseIRI() { + String testBaseIRI = "http://example.org/base/"; + NTriplesConfig config = NTriplesConfig.builder() + .baseIRI(testBaseIRI) + .build(); + + assertEquals(testBaseIRI, config.getBaseIRI(), "baseIRI should be set correctly"); + } + + @Test + @DisplayName("Builder should allow setting lineEnding") + void builder_shouldAllowSettingLineEnding() { + String customLineEnding = "\r\n"; + NTriplesConfig config = NTriplesConfig.builder() + .lineEnding(customLineEnding) + .build(); + + assertEquals(customLineEnding, config.getLineEnding(), "lineEnding should be set correctly"); + } + + @Test + @DisplayName("Builder should allow overriding validateURIs") + void builder_shouldAllowOverridingValidateURIs() { + NTriplesConfig config = NTriplesConfig.builder() + .validateURIs(true) + .build(); + + assertTrue(config.validateURIs(), "validateURIs should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding stableBlankNodeIds") + void builder_shouldAllowOverridingStableBlankNodeIds() { + NTriplesConfig config = NTriplesConfig.builder() + .stableBlankNodeIds(true) + .build(); + + assertTrue(config.stableBlankNodeIds(), "stableBlankNodeIds should be overridden to true"); + } + + @Test + @DisplayName("Builder should handle null values for optional fields gracefully (e.g., baseIRI)") + void builder_shouldHandleNullForOptionalFields() { + NTriplesConfig config = NTriplesConfig.builder() + .baseIRI(null) + .build(); + + assertNull(config.getBaseIRI(), "baseIRI should be null when explicitly set to null"); + } + + } From 0e119743c6c5e0319b2dad587355ced8b269eb18 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Mon, 7 Jul 2025 14:40:04 +0200 Subject: [PATCH 26/27] ajouter TU de turtle et trig config --- .../serialization/config/TriGConfigTest.java | 266 +++++++++++++++++- .../config/TurtleConfigTest.java | 266 +++++++++++++++++- 2 files changed, 530 insertions(+), 2 deletions(-) diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfigTest.java index 7d375db5b..ff16f055f 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TriGConfigTest.java @@ -1,4 +1,268 @@ package fr.inria.corese.core.next.impl.common.serialization.config; -public class TriGConfigTest { +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for the {@link TriGConfig} class. + * These tests verify the default configuration settings and the functionality + * of the builder pattern for customizing TriG serialization options. + */ +class TriGConfigTest { + + @Test + @DisplayName("defaultConfig() should return a config with expected TriG defaults") + void defaultConfig_shouldReturnExpectedDefaults() { + TriGConfig config = TriGConfig.defaultConfig(); + + assertNotNull(config, "Default config should not be null"); + + assertTrue(config.includeContext(), "Default includeContext should be true for TriG"); + assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle(), "Default blankNodeStyle should be NAMED for TriG"); + assertFalse(config.useCollections(), "Default useCollections should be false for TriG"); + + Map expectedPrefixes = new HashMap<>(); + expectedPrefixes.put("rdf", SerializationConstants.RDF_NS); + expectedPrefixes.put("rdfs", SerializationConstants.RDFS_NS); + expectedPrefixes.put("xsd", SerializationConstants.XSD_NS); + expectedPrefixes.put("owl", SerializationConstants.OWL_NS); + assertEquals(expectedPrefixes.size(), config.getCustomPrefixes().size(), "Default custom prefixes size mismatch"); + assertTrue(config.getCustomPrefixes().entrySet().containsAll(expectedPrefixes.entrySet()), "Default custom prefixes should contain common RDF prefixes"); + + assertTrue(config.usePrefixes(), "Default usePrefixes should be true"); + assertTrue(config.autoDeclarePrefixes(), "Default autoDeclarePrefixes should be true"); + assertEquals(PrefixOrderingEnum.ALPHABETICAL, config.getPrefixOrdering(), "Default prefixOrdering should be ALPHABETICAL"); + assertTrue(config.useCompactTriples(), "Default useCompactTriples should be true"); + assertTrue(config.useRdfTypeShortcut(), "Default useRdfTypeShortcut should be true"); + assertTrue(config.useMultilineLiterals(), "Default useMultilineLiterals should be true"); + assertTrue(config.prettyPrint(), "Default prettyPrint should be true"); + assertEquals(SerializationConstants.DEFAULT_INDENTATION, config.getIndent(), "Default indent should be " + SerializationConstants.DEFAULT_INDENTATION); + assertEquals(80, config.getMaxLineLength(), "Default maxLineLength should be 80"); + assertTrue(config.groupBySubject(), "Default groupBySubject should be true"); + assertFalse(config.sortSubjects(), "Default sortSubjects should be false"); + assertFalse(config.sortPredicates(), "Default sortPredicates should be false"); + + assertTrue(config.strictMode, "Default strictMode should be true"); + assertFalse(config.escapeUnicode(), "Default escapeUnicode should be false"); + assertEquals(LiteralDatatypePolicyEnum.MINIMAL, config.getLiteralDatatypePolicy(), "Default literalDatatypePolicy should be MINIMAL"); + assertNull(config.getBaseIRI(), "Default baseIRI should be null"); + } + + @Test + @DisplayName("Builder should allow overriding includeContext") + void builder_shouldAllowOverridingIncludeContext() { + TriGConfig config = TriGConfig.builder() + .includeContext(false) + .build(); + assertFalse(config.includeContext(), "includeContext should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding blankNodeStyle") + void builder_shouldAllowOverridingBlankNodeStyle() { + TriGConfig config = TriGConfig.builder() + .blankNodeStyle(BlankNodeStyleEnum.ANONYMOUS) + .build(); + assertEquals(BlankNodeStyleEnum.ANONYMOUS, config.getBlankNodeStyle(), "blankNodeStyle should be overridden to ANONYMOUS"); + } + + @Test + @DisplayName("Builder should allow overriding useCollections") + void builder_shouldAllowOverridingUseCollections() { + TriGConfig config = TriGConfig.builder() + .useCollections(true) + .build(); + assertTrue(config.useCollections(), "useCollections should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow adding custom prefixes") + void builder_shouldAllowAddingCustomPrefixes() { + String customPrefix = "my"; + String customNamespace = "http://my.example.org/"; + TriGConfig config = TriGConfig.builder() + .addCustomPrefix(customPrefix, customNamespace) + .build(); + + assertTrue(config.getCustomPrefixes().containsKey(customPrefix), "Custom prefix should be added"); + assertEquals(customNamespace, config.getCustomPrefixes().get(customPrefix), "Custom prefix namespace should be correct"); + assertTrue(config.getCustomPrefixes().containsKey("rdf")); + assertTrue(config.getCustomPrefixes().containsKey("xsd")); + } + + @Test + @DisplayName("Builder should allow overriding usePrefixes") + void builder_shouldAllowOverridingUsePrefixes() { + TriGConfig config = TriGConfig.builder() + .usePrefixes(false) + .build(); + assertFalse(config.usePrefixes(), "usePrefixes should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding autoDeclarePrefixes") + void builder_shouldAllowOverridingAutoDeclarePrefixes() { + TriGConfig config = TriGConfig.builder() + .autoDeclarePrefixes(false) + .build(); + assertFalse(config.autoDeclarePrefixes(), "autoDeclarePrefixes should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding prefixOrdering") + void builder_shouldAllowOverridingPrefixOrdering() { + TriGConfig config = TriGConfig.builder() + .prefixOrdering(PrefixOrderingEnum.USAGE_ORDER) + .build(); + assertEquals(PrefixOrderingEnum.USAGE_ORDER, config.getPrefixOrdering(), "prefixOrdering should be overridden to USAGE_ORDER"); + } + + @Test + @DisplayName("Builder should allow overriding useCompactTriples") + void builder_shouldAllowOverridingUseCompactTriples() { + TriGConfig config = TriGConfig.builder() + .useCompactTriples(false) + .build(); + assertFalse(config.useCompactTriples(), "useCompactTriples should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding useRdfTypeShortcut") + void builder_shouldAllowOverridingUseRdfTypeShortcut() { + TriGConfig config = TriGConfig.builder() + .useRdfTypeShortcut(false) + .build(); + assertFalse(config.useRdfTypeShortcut(), "useRdfTypeShortcut should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding useMultilineLiterals") + void builder_shouldAllowOverridingUseMultilineLiterals() { + TriGConfig config = TriGConfig.builder() + .useMultilineLiterals(false) + .build(); + assertFalse(config.useMultilineLiterals(), "useMultilineLiterals should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding prettyPrint") + void builder_shouldAllowOverridingPrettyPrint() { + TriGConfig config = TriGConfig.builder() + .prettyPrint(false) + .build(); + assertFalse(config.prettyPrint(), "prettyPrint should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding indent") + void builder_shouldAllowOverridingIndent() { + String customIndent = "\t"; + TriGConfig config = TriGConfig.builder() + .indent(customIndent) + .build(); + assertEquals(customIndent, config.getIndent(), "indent should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding maxLineLength") + void builder_shouldAllowOverridingMaxLineLength() { + int customLength = 120; + TriGConfig config = TriGConfig.builder() + .maxLineLength(customLength) + .build(); + assertEquals(customLength, config.getMaxLineLength(), "maxLineLength should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding groupBySubject") + void builder_shouldAllowOverridingGroupBySubject() { + TriGConfig config = TriGConfig.builder() + .groupBySubject(false) + .build(); + assertFalse(config.groupBySubject(), "groupBySubject should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding sortSubjects") + void builder_shouldAllowOverridingSortSubjects() { + TriGConfig config = TriGConfig.builder() + .sortSubjects(true) + .build(); + assertTrue(config.sortSubjects(), "sortSubjects should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding sortPredicates") + void builder_shouldAllowOverridingSortPredicates() { + TriGConfig config = TriGConfig.builder() + .sortPredicates(true) + .build(); + assertTrue(config.sortPredicates(), "sortPredicates should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding strictMode") + void builder_shouldAllowOverridingStrictMode() { + TriGConfig config = TriGConfig.builder() + .strictMode(false) + .build(); + assertFalse(config.strictMode, "strictMode should be overridden to false"); + } + + + @Test + @DisplayName("Builder should allow overriding literalDatatypePolicy") + void builder_shouldAllowOverridingLiteralDatatypePolicy() { + TriGConfig config = TriGConfig.builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) + .build(); + assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy(), "literalDatatypePolicy should be overridden to ALWAYS_TYPED"); + } + + @Test + @DisplayName("Builder should allow setting baseIRI") + void builder_shouldAllowSettingBaseIRI() { + String testBaseIRI = "http://example.org/base/"; + TriGConfig config = TriGConfig.builder() + .baseIRI(testBaseIRI) + .build(); + assertEquals(testBaseIRI, config.getBaseIRI(), "baseIRI should be set correctly"); + } + + @Test + @DisplayName("Builder should allow overriding lineEnding") + void builder_shouldAllowOverridingLineEnding() { + String customLineEnding = "\r\n"; + TriGConfig config = TriGConfig.builder() + .lineEnding(customLineEnding) + .build(); + assertEquals(customLineEnding, config.getLineEnding(), "lineEnding should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding validateURIs") + void builder_shouldAllowOverridingValidateURIs() { + TriGConfig config = TriGConfig.builder() + .validateURIs(true) + .build(); + assertTrue(config.validateURIs(), "validateURIs should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding stableBlankNodeIds") + void builder_shouldAllowOverridingStableBlankNodeIds() { + TriGConfig config = TriGConfig.builder() + .stableBlankNodeIds(true) + .build(); + assertTrue(config.stableBlankNodeIds(), "stableBlankNodeIds should be overridden to true"); + } + + + } diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfigTest.java index 8029739c1..482d9718c 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/TurtleConfigTest.java @@ -1,4 +1,268 @@ package fr.inria.corese.core.next.impl.common.serialization.config; -public class TurtleConfigTest { +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for the {@link TurtleConfig} class. + * These tests verify the default configuration settings and the functionality + * of the builder pattern for customizing Turtle serialization options. + */ +class TurtleConfigTest { + + @Test + @DisplayName("defaultConfig() should return a config with expected Turtle defaults") + void defaultConfig_shouldReturnExpectedDefaults() { + TurtleConfig config = TurtleConfig.defaultConfig(); + + assertNotNull(config, "Default config should not be null"); + + assertTrue(config.useCollections(), "Default useCollections should be true for Turtle"); + assertEquals(BlankNodeStyleEnum.ANONYMOUS, config.getBlankNodeStyle(), "Default blankNodeStyle should be ANONYMOUS for Turtle"); + + Map expectedPrefixes = new HashMap<>(); + expectedPrefixes.put("rdf", SerializationConstants.RDF_NS); + expectedPrefixes.put("rdfs", SerializationConstants.RDFS_NS); + expectedPrefixes.put("xsd", SerializationConstants.XSD_NS); + expectedPrefixes.put("owl", SerializationConstants.OWL_NS); + assertEquals(expectedPrefixes.size(), config.getCustomPrefixes().size(), "Default custom prefixes size mismatch"); + assertTrue(config.getCustomPrefixes().entrySet().containsAll(expectedPrefixes.entrySet()), "Default custom prefixes should contain common RDF prefixes"); + + + assertTrue(config.usePrefixes(), "Default usePrefixes should be true"); + assertTrue(config.autoDeclarePrefixes(), "Default autoDeclarePrefixes should be true"); + assertEquals(PrefixOrderingEnum.ALPHABETICAL, config.getPrefixOrdering(), "Default prefixOrdering should be ALPHABETICAL"); + assertTrue(config.useCompactTriples(), "Default useCompactTriples should be true"); + assertTrue(config.useRdfTypeShortcut(), "Default useRdfTypeShortcut should be true"); + assertTrue(config.useMultilineLiterals(), "Default useMultilineLiterals should be true"); + assertTrue(config.prettyPrint(), "Default prettyPrint should be true"); + assertEquals(SerializationConstants.DEFAULT_INDENTATION, config.getIndent(), "Default indent should be " + SerializationConstants.DEFAULT_INDENTATION); + assertEquals(80, config.getMaxLineLength(), "Default maxLineLength should be 80"); + assertTrue(config.groupBySubject(), "Default groupBySubject should be true"); + + assertTrue(config.strictMode, "Default strictMode should be true"); + assertFalse(config.escapeUnicode(), "Default escapeUnicode should be false"); + assertEquals(LiteralDatatypePolicyEnum.MINIMAL, config.getLiteralDatatypePolicy(), "Default literalDatatypePolicy should be MINIMAL"); + assertNull(config.getBaseIRI(), "Default baseIRI should be null"); + assertEquals(System.lineSeparator(), config.getLineEnding(), "Default lineEnding should be system's line separator"); + assertFalse(config.validateURIs(), "Default validateURIs should be false"); + assertFalse(config.stableBlankNodeIds(), "Default stableBlankNodeIds should be false"); + } + + @Test + @DisplayName("Builder should allow overriding useCollections") + void builder_shouldAllowOverridingUseCollections() { + TurtleConfig config = new TurtleConfig.Builder() + .useCollections(false) + .build(); + assertFalse(config.useCollections(), "useCollections should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding blankNodeStyle") + void builder_shouldAllowOverridingBlankNodeStyle() { + TurtleConfig config = new TurtleConfig.Builder() + .blankNodeStyle(BlankNodeStyleEnum.NAMED) + .build(); + assertEquals(BlankNodeStyleEnum.NAMED, config.getBlankNodeStyle(), "blankNodeStyle should be overridden to NAMED"); + } + + @Test + @DisplayName("Builder should allow adding custom prefixes") + void builder_shouldAllowAddingCustomPrefixes() { + String customPrefix = "my"; + String customNamespace = "http://my.example.org/"; + TurtleConfig config = new TurtleConfig.Builder() + .addCustomPrefix(customPrefix, customNamespace) + .build(); + + assertTrue(config.getCustomPrefixes().containsKey(customPrefix), "Custom prefix should be added"); + assertEquals(customNamespace, config.getCustomPrefixes().get(customPrefix), "Custom prefix namespace should be correct"); + assertTrue(config.getCustomPrefixes().containsKey("rdf")); + assertTrue(config.getCustomPrefixes().containsKey("xsd")); + } + + @Test + @DisplayName("Builder should allow overriding usePrefixes") + void builder_shouldAllowOverridingUsePrefixes() { + TurtleConfig config = new TurtleConfig.Builder() + .usePrefixes(false) + .build(); + assertFalse(config.usePrefixes(), "usePrefixes should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding autoDeclarePrefixes") + void builder_shouldAllowOverridingAutoDeclarePrefixes() { + TurtleConfig config = new TurtleConfig.Builder() + .autoDeclarePrefixes(false) + .build(); + assertFalse(config.autoDeclarePrefixes(), "autoDeclarePrefixes should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding prefixOrdering") + void builder_shouldAllowOverridingPrefixOrdering() { + TurtleConfig config = new TurtleConfig.Builder() + .prefixOrdering(PrefixOrderingEnum.USAGE_ORDER) + .build(); + assertEquals(PrefixOrderingEnum.USAGE_ORDER, config.getPrefixOrdering(), "prefixOrdering should be overridden to USAGE_ORDER"); + } + + @Test + @DisplayName("Builder should allow overriding useCompactTriples") + void builder_shouldAllowOverridingUseCompactTriples() { + TurtleConfig config = new TurtleConfig.Builder() + .useCompactTriples(false) + .build(); + assertFalse(config.useCompactTriples(), "useCompactTriples should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding useRdfTypeShortcut") + void builder_shouldAllowOverridingUseRdfTypeShortcut() { + TurtleConfig config = new TurtleConfig.Builder() + .useRdfTypeShortcut(false) + .build(); + assertFalse(config.useRdfTypeShortcut(), "useRdfTypeShortcut should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding useMultilineLiterals") + void builder_shouldAllowOverridingUseMultilineLiterals() { + TurtleConfig config = new TurtleConfig.Builder() + .useMultilineLiterals(false) + .build(); + assertFalse(config.useMultilineLiterals(), "useMultilineLiterals should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding prettyPrint") + void builder_shouldAllowOverridingPrettyPrint() { + TurtleConfig config = new TurtleConfig.Builder() + .prettyPrint(false) + .build(); + assertFalse(config.prettyPrint(), "prettyPrint should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding indent") + void builder_shouldAllowOverridingIndent() { + String customIndent = "\t"; + TurtleConfig config = new TurtleConfig.Builder() + .indent(customIndent) + .build(); + assertEquals(customIndent, config.getIndent(), "indent should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding maxLineLength") + void builder_shouldAllowOverridingMaxLineLength() { + int customLength = 120; + TurtleConfig config = new TurtleConfig.Builder() + .maxLineLength(customLength) + .build(); + assertEquals(customLength, config.getMaxLineLength(), "maxLineLength should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding groupBySubject") + void builder_shouldAllowOverridingGroupBySubject() { + TurtleConfig config = new TurtleConfig.Builder() + .groupBySubject(false) + .build(); + assertFalse(config.groupBySubject(), "groupBySubject should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding sortSubjects") + void builder_shouldAllowOverridingSortSubjects() { + TurtleConfig config = new TurtleConfig.Builder() + .sortSubjects(true) + .build(); + assertTrue(config.sortSubjects(), "sortSubjects should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding sortPredicates") + void builder_shouldAllowOverridingSortPredicates() { + TurtleConfig config = new TurtleConfig.Builder() + .sortPredicates(true) + .build(); + assertTrue(config.sortPredicates(), "sortPredicates should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding strictMode") + void builder_shouldAllowOverridingStrictMode() { + TurtleConfig config = new TurtleConfig.Builder() + .strictMode(false) + .build(); + assertFalse(config.strictMode, "strictMode should be overridden to false"); + } + + + @Test + @DisplayName("Builder should allow overriding literalDatatypePolicy") + void builder_shouldAllowOverridingLiteralDatatypePolicy() { + TurtleConfig config = new TurtleConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.ALWAYS_TYPED) + .build(); + assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy(), "literalDatatypePolicy should be overridden to ALWAYS_TYPED"); + } + + @Test + @DisplayName("Builder should allow setting baseIRI") + void builder_shouldAllowSettingBaseIRI() { + String testBaseIRI = "http://example.org/base/"; + TurtleConfig config = new TurtleConfig.Builder() + .baseIRI(testBaseIRI) + .build(); + assertEquals(testBaseIRI, config.getBaseIRI(), "baseIRI should be set correctly"); + } + + @Test + @DisplayName("Builder should allow overriding lineEnding") + void builder_shouldAllowOverridingLineEnding() { + String customLineEnding = "\r\n"; + TurtleConfig config = new TurtleConfig.Builder() + .lineEnding(customLineEnding) + .build(); + assertEquals(customLineEnding, config.getLineEnding(), "lineEnding should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding validateURIs") + void builder_shouldAllowOverridingValidateURIs() { + TurtleConfig config = new TurtleConfig.Builder() + .validateURIs(true) + .build(); + assertTrue(config.validateURIs(), "validateURIs should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding stableBlankNodeIds") + void builder_shouldAllowOverridingStableBlankNodeIds() { + TurtleConfig config = new TurtleConfig.Builder() + .stableBlankNodeIds(true) + .build(); + assertTrue(config.stableBlankNodeIds(), "stableBlankNodeIds should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding includeContext") + void builder_shouldAllowOverridingIncludeContext() { + TurtleConfig config = new TurtleConfig.Builder() + .includeContext(true) + .build(); + assertTrue(config.includeContext(), "includeContext should be overridden to true"); + } + + } From 3783b50158b14eaf1e8c2d15df3ca9d50517b964 Mon Sep 17 00:00:00 2001 From: "AD\\aabdoun" Date: Mon, 7 Jul 2025 17:00:43 +0200 Subject: [PATCH 27/27] ajouter TU de XML config --- .../serialization/config/XmlConfigTest.java | 223 +++++++++++++++++- 1 file changed, 222 insertions(+), 1 deletion(-) diff --git a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfigTest.java b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfigTest.java index d72cdf3f7..7e55fd903 100644 --- a/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfigTest.java +++ b/src/test/java/fr/inria/corese/core/next/impl/common/serialization/config/XmlConfigTest.java @@ -1,4 +1,225 @@ package fr.inria.corese.core.next.impl.common.serialization.config; -public class XmlConfigTest { +import fr.inria.corese.core.next.impl.common.serialization.util.SerializationConstants; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for the {@link XmlConfig} class. + * These tests verify the default configuration settings and the functionality + * of the builder pattern for customizing RDF/XML serialization options. + */ +class XmlConfigTest { + + @Test + @DisplayName("defaultConfig() should return a config with expected RDF/XML defaults") + void defaultConfig_shouldReturnExpectedDefaults() { + XmlConfig config = XmlConfig.defaultConfig(); + + assertNotNull(config, "Default config should not be null"); + + assertTrue(config.usePrefixes(), "Default usePrefixes should be true for XML"); + assertTrue(config.autoDeclarePrefixes(), "Default autoDeclarePrefixes should be true for XML"); + assertEquals(PrefixOrderingEnum.ALPHABETICAL, config.getPrefixOrdering(), "Default prefixOrdering should be ALPHABETICAL for XML"); + + Map expectedPrefixes = new HashMap<>(); + expectedPrefixes.put("rdf", SerializationConstants.RDF_NS); + expectedPrefixes.put("rdfs", SerializationConstants.RDFS_NS); + expectedPrefixes.put("xsd", SerializationConstants.XSD_NS); + expectedPrefixes.put("owl", SerializationConstants.OWL_NS); + assertEquals(expectedPrefixes.size(), config.getCustomPrefixes().size(), "Default custom prefixes size mismatch"); + assertTrue(config.getCustomPrefixes().entrySet().containsAll(expectedPrefixes.entrySet()), "Default custom prefixes should contain common RDF prefixes"); + + assertTrue(config.prettyPrint(), "Default prettyPrint should be true for XML"); + assertEquals(SerializationConstants.DEFAULT_INDENTATION, config.getIndent(), "Default indent should be " + SerializationConstants.DEFAULT_INDENTATION); + assertEquals(0, config.getMaxLineLength(), "Default maxLineLength should be 0 (no line length constraint) for XML"); + assertFalse(config.sortSubjects(), "Default sortSubjects should be false for XML"); + assertFalse(config.sortPredicates(), "Default sortPredicates should be false for XML"); + assertTrue(config.useMultilineLiterals(), "Default useMultilineLiterals should be true for XML"); + + assertTrue(config.strictMode, "Default strictMode should be true"); + assertFalse(config.escapeUnicode(), "Default escapeUnicode should be false for XML"); + assertEquals(LiteralDatatypePolicyEnum.ALWAYS_TYPED, config.getLiteralDatatypePolicy(), "Default literalDatatypePolicy should be ALWAYS_TYPED for XML"); + assertNull(config.getBaseIRI(), "Default baseIRI should be null"); + assertFalse(config.includeContext(), "Default includeContext should be false for XML (RDF/XML doesn't support named graphs)"); + } + + @Test + @DisplayName("Builder should allow overriding usePrefixes") + void builder_shouldAllowOverridingUsePrefixes() { + XmlConfig config = new XmlConfig.Builder() + .usePrefixes(false) + .build(); + assertFalse(config.usePrefixes(), "usePrefixes should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding autoDeclarePrefixes") + void builder_shouldAllowOverridingAutoDeclarePrefixes() { + XmlConfig config = new XmlConfig.Builder() + .autoDeclarePrefixes(false) + .build(); + assertFalse(config.autoDeclarePrefixes(), "autoDeclarePrefixes should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding prefixOrdering") + void builder_shouldAllowOverridingPrefixOrdering() { + XmlConfig config = new XmlConfig.Builder() + .prefixOrdering(PrefixOrderingEnum.USAGE_ORDER) + .build(); + assertEquals(PrefixOrderingEnum.USAGE_ORDER, config.getPrefixOrdering(), "prefixOrdering should be overridden to USAGE_ORDER"); + } + + @Test + @DisplayName("Builder should allow adding custom prefixes") + void builder_shouldAllowAddingCustomPrefixes() { + String customPrefix = "my"; + String customNamespace = "http://my.example.org/"; + XmlConfig config = new XmlConfig.Builder() + .addCustomPrefix(customPrefix, customNamespace) + .build(); + + assertTrue(config.getCustomPrefixes().containsKey(customPrefix), "Custom prefix should be added"); + assertEquals(customNamespace, config.getCustomPrefixes().get(customPrefix), "Custom prefix namespace should be correct"); + assertTrue(config.getCustomPrefixes().containsKey("rdf")); + assertTrue(config.getCustomPrefixes().containsKey("xsd")); + } + + @Test + @DisplayName("Builder should allow overriding prettyPrint") + void builder_shouldAllowOverridingPrettyPrint() { + XmlConfig config = new XmlConfig.Builder() + .prettyPrint(false) + .build(); + assertFalse(config.prettyPrint(), "prettyPrint should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding indent") + void builder_shouldAllowOverridingIndent() { + String customIndent = "\t"; + XmlConfig config = new XmlConfig.Builder() + .indent(customIndent) + .build(); + assertEquals(customIndent, config.getIndent(), "indent should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding maxLineLength") + void builder_shouldAllowOverridingMaxLineLength() { + int customLength = 120; + XmlConfig config = new XmlConfig.Builder() + .maxLineLength(customLength) + .build(); + assertEquals(customLength, config.getMaxLineLength(), "maxLineLength should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding sortSubjects") + void builder_shouldAllowOverridingSortSubjects() { + XmlConfig config = new XmlConfig.Builder() + .sortSubjects(true) + .build(); + assertTrue(config.sortSubjects(), "sortSubjects should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding sortPredicates") + void builder_shouldAllowOverridingSortPredicates() { + XmlConfig config = new XmlConfig.Builder() + .sortPredicates(true) + .build(); + assertTrue(config.sortPredicates(), "sortPredicates should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding useMultilineLiterals") + void builder_shouldAllowOverridingUseMultilineLiterals() { + XmlConfig config = new XmlConfig.Builder() + .useMultilineLiterals(false) + .build(); + assertFalse(config.useMultilineLiterals(), "useMultilineLiterals should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding strictMode") + void builder_shouldAllowOverridingStrictMode() { + XmlConfig config = new XmlConfig.Builder() + .strictMode(false) + .build(); + assertFalse(config.strictMode, "strictMode should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding escapeUnicode") + void builder_shouldAllowOverridingEscapeUnicode() { + XmlConfig config = new XmlConfig.Builder() + .escapeUnicode(true) + .build(); + assertTrue(config.escapeUnicode(), "escapeUnicode should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding literalDatatypePolicy") + void builder_shouldAllowOverridingLiteralDatatypePolicy() { + XmlConfig config = new XmlConfig.Builder() + .literalDatatypePolicy(LiteralDatatypePolicyEnum.MINIMAL) + .build(); + assertEquals(LiteralDatatypePolicyEnum.MINIMAL, config.getLiteralDatatypePolicy(), "literalDatatypePolicy should be overridden to MINIMAL"); + } + + @Test + @DisplayName("Builder should allow setting baseIRI") + void builder_shouldAllowSettingBaseIRI() { + String testBaseIRI = "http://example.org/base/"; + XmlConfig config = new XmlConfig.Builder() + .baseIRI(testBaseIRI) + .build(); + assertEquals(testBaseIRI, config.getBaseIRI(), "baseIRI should be set correctly"); + } + + @Test + @DisplayName("Builder should allow overriding lineEnding") + void builder_shouldAllowOverridingLineEnding() { + String customLineEnding = "\r\n"; + XmlConfig config = new XmlConfig.Builder() + .lineEnding(customLineEnding) + .build(); + assertEquals(customLineEnding, config.getLineEnding(), "lineEnding should be overridden to custom value"); + } + + @Test + @DisplayName("Builder should allow overriding validateURIs") + void builder_shouldAllowOverridingValidateURIs() { + XmlConfig config = new XmlConfig.Builder() + .validateURIs(true) + .build(); + assertTrue(config.validateURIs(), "validateURIs should be overridden to true"); + } + + @Test + @DisplayName("Builder should allow overriding stableBlankNodeIds") + void builder_shouldAllowOverridingStableBlankNodeIds() { + XmlConfig config = new XmlConfig.Builder() + .stableBlankNodeIds(false) + .build(); + assertFalse(config.stableBlankNodeIds(), "stableBlankNodeIds should be overridden to false"); + } + + @Test + @DisplayName("Builder should allow overriding includeContext") + void builder_shouldAllowOverridingIncludeContext() { + XmlConfig config = new XmlConfig.Builder() + .includeContext(true) + .build(); + assertTrue(config.includeContext(), "includeContext should be overridden to true"); + } + + }