Convert Anything to path/case

path/case Converter,Convert Text to path/case

When a name represents a hierarchy, path/case makes each word a segment. Filesystem paths, URL path segments, Go module import paths, and route pattern segments all follow this structure.

Yet path/case is not the same as a URL path. URL paths may include query strings, fragments, and protocol prefixes that this converter strips away. The output is the path segment format only, lowercase words joined by slashes.

Where path/case is used

Go module import paths follow path/case convention: "github.com/user/my-package" uses a mix of path segments.¹ HTTP URL path segments are lowercase and slash-separated, per Google's URL structure recommendations.² Filesystem paths on Linux and macOS are case-sensitive and commonly lowercase, making path/case the default for directory naming. Building on this, routing libraries like Express.js and FastAPI parse slash-separated URL segments, and matching those to code identifiers is cleaner when both follow path/case. REST API resource hierarchies map naturally to path/case: "/api/v1/order-line-items" represents a nested collection in a URL.³ AWS S3 object keys, Azure Blob Storage paths, and Google Cloud Storage prefixes all use forward-slash hierarchies, making path/case the standard for cloud storage organization. Even Windows file paths, which use backslashes internally, are often represented with forward slashes in cross-platform tools and configuration files.

Edge cases: existing slashes, uppercase, and empty segments

Existing forward slashes in the input are treated as word separators and do not get duplicated. Backslashes (Windows paths) are also treated as separators and replaced with forward slashes. Consecutive separators produce single slashes in the output, eliminating empty path segments. Consequently, converting "tools/Text/Case Converter" produces "tools/text/case/converter" without any double slashes or empty segments. CamelCase or PascalCase segments within an existing path, like "api/UserProfile/settings", split on word boundaries and produce "api/user/profile/settings". Leading slashes are preserved, so "/api/V2/Errors" becomes "/api/v2/errors". Trailing slashes are stripped from the final segment, preventing empty path components that would cause routing mismatches. Mixed OS path notation like "src\main/java/com/example" normalizes to "src/main/java/com/example" with consistent forward slashes regardless of the original separator style. Handling all of these edge cases in a single pass is what makes the converter reliable when you are migrating a mixed-format directory structure to a consistent path/case convention.

Workflow: generating file paths from feature names

Building on this, a common use case: you have a list of feature module names in PascalCase and need to generate the corresponding directory paths. "UserAuthentication" becomes "user/authentication", "PaymentGateway" becomes "payment/gateway". This conversion is the first step when scaffolding a new project structure from a domain model: each entity or service name becomes a directory path that mirrors the conceptual hierarchy. Getting the paths right before scaffolding prevents a tangle of broken imports across dozens of files that would require a dedicated cleanup pass after the project structure changes.

Directory paths from module names

When organizing a codebase, module names in PascalCase or camelCase need to map to lowercase directory paths with forward slashes. "UserAuthentication" becomes "user/authentication", and "PaymentGateway" becomes "payment/gateway". CapyToolkit converts each line independently, so you can scaffold directory paths from module names in one pass. These paths map directly to Go import paths or URL routing segments. For monorepo setups using Nx or Turborepo, the library path in project.json or package.json follows the same convention: a library named "UserAuthentication" lives at "libs/user/authentication". Converting your planned library names to path/case before running the scaffolding command ensures the generated directory structure follows your naming convention from the start, which prevents a later refactor of import paths across dozens of files.

A single path generates from one module name in several downstream places: the directory on disk, the import statement in code, the route template in a web framework, and the documentation URL. Keeping every one of those derived from the same path/case value avoids the drift where the folder says one thing and the import says another. When the tool produces the path once, you can paste it into each location rather than retyping and risking a casing mismatch that a linter or the compiler later rejects.

Go module import paths and the GOPATH module naming conventions

Go module paths follow the path/case format exclusively. A module hosted at github.com/user/my-package uses a path-case module path, and every package inside it follows the same convention. Go's toolchain validates that import paths are valid URLs, which makes camelCase or PascalCase segments in the module path unusual and potentially problematic for tooling.

Go's standard library uses short, lowercase, single-word package names where possible: net/http, encoding/json, database/sql.⁴ Multi-word packages use lowercase without separators: crypto/tls, net/textproto. When you add a new package to a Go project, the path segment should be lowercase. Paste your planned package name from PascalCase or camelCase and copy the path.case output as the directory name and import path segment.

Package documentation URLs in pkg.go.dev

Go package documentation is hosted at pkg.go.dev/<module-path>/<package-name>. Uppercase letters in module or package paths create URLs that are technically case-sensitive and visually inconsistent with Go conventions. All major Go open source packages use entirely lowercase paths. Paste your module and package names into this converter before initializing the repository to verify the path.case format before the module path is set in go.mod. After running go mod init, changing the module path requires updating every import statement across the entire codebase, which is a time-consuming and error-prone process.

Express.js and FastAPI route naming conventions with path/case segments

Express.js and FastAPI both parse URL path segments as route parameters. The naming convention for those segments influences how you name the corresponding function parameters in your handler code, which should follow each language's own naming convention. Keeping the URL structure and the parameter naming format visually distinct prevents confusion when reading route definitions that span both the path template and the function signature in the same file.

Express.js uses kebab-case for static route segments by convention and camelCase for route parameter names: router.get('/user-profile/:userId', handler).⁵ FastAPI follows the same split: route segments are kebab-case, Python function parameter names are snake_case.⁶ Converting a URL path to path/case first, then splitting the segments for use in route and parameter naming, keeps the two formats visually separate.

Mapping path/case URL segments to Python function names in FastAPI

A FastAPI route like @app.get("/order-line-item/{order_id}") has a kebab-case path segment and a snake_case path parameter. When you design a new endpoint, paste the resource name into this converter to get the path/case URL structure, then convert the individual segments to snake_case for parameter names. "orderLineItem" becomes "order/line/item" as the path structure. CapyToolkit converts each line independently, so converting a full list of REST resources to their URL path segments takes one paste.

When to use this

Use this when generating URL path segments from module names, creating Go import paths from package identifiers, or converting category hierarchies to filesystem directory paths.

Examples

UserAuthentication
PaymentGateway
OrderManagement

user/authentication
payment/gateway
order/management

Audio Tools
Text Utilities
Network Analysis

audio/tools
text/utilities
network/analysis