Pascal Case

Text Processing String Manipulation

Synopsis

Converts strings to PascalCase format.

Schema

- pascalcase:
    field: <ident>
    target_field: <string>
    fields: <array>
    exclude: <array>
    description: <text>
    if: <script>
    ignore_failure: <boolean>
    ignore_missing: <boolean>
    on_failure: <processor[]>
    on_success: <processor[]>
    tag: <string>

Configuration

The following fields are used to define the processor:

Field	Required	Default	Description
field	N	-	Selects value mode: converts the value of this field to PascalCase. The value must be a string or an array of strings. Mutually exclusive with fields — when field is set, fields and exclude are ignored
target_field	N	Same as field	Where the converted value is written in value mode. Ignored in name mode
fields	N	["*"]	Selects name mode: glob patterns matching field names to rename to PascalCase. The values are left untouched. a.* renames the keys inside object a, *.* those of every root object. Omitting both field and fields renames every root-level field name; names beginning with _ are never renamed
exclude	N	-	Field names to leave alone in name mode. Has no effect in value mode
description	N	-	Explanatory note
if	N	-	Condition to run
ignore_failure	N	false	Continue processing if conversion fails
ignore_missing	N	false	Skip processing if referenced field doesn't exist
on_failure	N	-	See Handling Failures
on_success	N	-	See Handling Success
tag	N	-	Identifier
disabled	N	false	When true, the processor is skipped and the event continues to the next one. Lets you take a processor out of the path without removing its configuration

Details

Converts string values to PascalCase format by removing spaces, hyphens, underscores, and other separators, then capitalizing the first letter of each word including the first word. This format is commonly used in programming for class names, type names, and other identifiers.

PascalCase is similar to camelCase but capitalizes the very first letter as well, making it suitable for naming conventions in many programming languages.

note

PascalCase format capitalizes the first letter of every word including the first, resulting in format like "FirstName", "UserAccountName", or "DataProcessingComplete". This differs from camelCase where the first letter remains lowercase.

The processor handles various input formats and converts them to the standard PascalCase naming convention used in object-oriented programming.

warning

If the field contains non-string values, the processor will attempt to convert them to strings before applying PascalCase conversion. Complex objects or arrays may produce unexpected results.

Examples

Basic Conversion

Converting snake_case to PascalCase...	{ "class_name": "user_account_manager" } - pascalcase: field: class_name target_field: pascal_name
converts to PascalCase:	{ "class_name": "user_account_manager", "pascal_name": "UserAccountManager" }

Type Name Generation

Creating type names from descriptions...	{ "component_type": "data processing pipeline" } - pascalcase: field: component_type target_field: type_name
generates programming identifier:	{ "component_type": "data processing pipeline", "type_name": "DataProcessingPipeline" }

Mixed Format Input

Normalizing mixed separators to PascalCase...	{ "interface_name": "api-response_handler with events" } - pascalcase: field: interface_name
standardizes to PascalCase:	{ "interface_name": "ApiResponseHandlerWithEvents" }

Multiple Fields

Renaming field names to PascalCase, leaving values untouched...	{ "model_name": "user_profile", "service_name": "authentication_service", "controller_name": "api_controller" } - pascalcase: fields: ["model_name", "service_name", "controller_name"]
renames the matched names; the values are unchanged:	{ "ModelName": "user_profile", "ServiceName": "authentication_service", "ControllerName": "api_controller" }

Namespace Generation

Creating namespace identifiers...	{ "module_path": "data.stream.processors" } - pascalcase: field: module_path target_field: namespace
generates namespace identifier:	{ "module_path": "data.stream.processors", "namespace": "DataStreamProcessors" }