EXPRESS parser and toolkit for Ruby. Parse, analyze, and transform EXPRESS data models with a comprehensive Ruby API.

---

Table of Contents

• What is Expressir?
  • Key Features
• Quick Start
  • Installation
  • Parse Your First Schema
  • Use the CLI
• Documentation Structure
  • Core Topics
  • Tutorials
  • Guides
  • References
• Common Use Cases
  • For Data Modelers
  • For Developers
  • For Organizations
• Performance
• Architecture
• Support
• License
• Credits

What is Expressir?

Expressir ("EXPRESS in Ruby") is a comprehensive Ruby parser and toolkit for working with EXPRESS data models, the data modeling language defined in ISO 10303-11. It enables you to:

• Parse EXPRESS schemas from multiple formats

• Analyze complex data models and their relationships

• Transform schemas using a rich Ruby API

• Generate documentation using Liquid templates

• Package schemas into efficient LER (LutaML EXPRESS Repository) bundles

• Track schema changes across versions

Key Features

Feature	Description
Multiple Format Support	Parse EXPRESS (ISO 10303-11), STEPmod XML, and EXPRESS XML formats
Rich Data Model	Complete Ruby representation of EXPRESS schemas with full type information
LER Packages	Pre-indexed, fast-loading schema bundles with 20x+ performance improvement
Schema Analysis	Built-in tools for documentation coverage, validation, and dependency analysis
Liquid Integration	Generate documentation and reports using flexible Liquid templates
CLI Tools	Command-line interface for formatting, validation, benchmarking, and more
Changes Tracking	Track and manage schema modifications across versions
Ruby-First Design	Idiomatic Ruby API with comprehensive test coverage

Quick Start

Installation

Add Expressir to your Gemfile:

gem 'expressir'

Or install directly:

gem install expressir

Parse Your First Schema

require 'expressir'

# Parse an EXPRESS file
repository = Expressir::Express::Parser.from_file('schema.exp')

# Access schemas
repository.schemas.each do |schema|
  puts "Schema: #{schema.id}"
  puts "Entities: #{schema.entities.size}"
  puts "Types: #{schema.types.size}"
end

Use the CLI

# Format a schema
expressir format schema.exp

# Validate schemas
expressir validate schema.exp

# Check documentation coverage
expressir coverage schema.exp

# Create an LER package
expressir package build schema.exp output.ler

Documentation Structure

This documentation is organized into four main sections:

Core Topics

Fundamental concepts and essential information:

• Introduction - What is Expressir and when to use it

• Getting Started - Installation and first steps

• EXPRESS Language - Understanding EXPRESS data modeling

• Data Model - Expressir’s Ruby data model

• Parsers - Parsing EXPRESS files

• Schema Manifests - Managing collections of EXPRESS schemas

• LER Packages - High-performance schema packages

Tutorials

Step-by-step guides for common workflows:

• Parsing Your First Schema

• Working with Multiple Schemas

• Creating LER Packages

• Querying Schemas

• Liquid Templates

• Documentation Coverage

Guides

Task-oriented how-to documentation:

• CLI Commands - Command-line interface usage

• Ruby API - Programmatic usage

• LER - Working with LER packages

• Manifests - Managing schema collections

• Changes - Tracking schema changes

• Liquid - Template integration

References

Detailed technical specifications:

• CLI Commands Reference

• Ruby API Reference

• Data Model Reference

• Liquid Drops Reference

• LER Format Specification

• Changes Format Specification

Common Use Cases

For Data Modelers

• Parse and validate EXPRESS schemas

• Check documentation coverage

• Format and clean schemas

• Track changes between versions

For Developers

• Integrate EXPRESS parsing into Ruby applications

• Build schema analysis tools

• Generate documentation from schemas

• Create custom schema transformations

For Organizations

• Package large schema collections for distribution

• Maintain schema version history

• Automate schema validation in CI/CD

• Generate standardized documentation

Performance

Expressir is designed for performance:

Operation	Traditional	With LER
Parse 40+ schemas	10-15 seconds	<500ms (20x+ faster)
Entity lookup	O(n) scan	O(1) indexed (<1ms)
Type resolution	Multiple passes	Pre-resolved

Architecture

Expressir consists of three main components:

┌─────────────────────────────────────┐
│          Ruby API / CLI             │  ← Your Application
├─────────────────────────────────────┤
│         Expressir Model             │  ← Rich Data Model
│  (Entities, Types, Schemas, etc.)   │
├─────────────────────────────────────┤
│          EXPRESS Parser             │  ← Multiple Formats
│  (EXPRESS, STEPmod, EXPRESS XML)    │
└─────────────────────────────────────┘

Support

• Issues: GitHub Issues

• Discussions: GitHub Discussions

• Contributing: Contributing Guide

License

Expressir is distributed under the BSD-2-Clause license. See the LICENSE file for details.

Credits

Copyright © 2025 Ribose Inc.

Expressir is developed and maintained by Ribose Inc. as part of the LutaML project family.