Fr3nch13/CakePHP Utilities

Application

Interfaces

StorageInterface: Describes the methods that any class representing an Auth data storage should comply with.
CacheEngineInterface: Interface for cache engines that defines methods outside of the PSR16 interface that are used by `Cache`.
CollectionInterface: Describes the methods a Collection should implement. A collection is an immutable list of elements exposing a number of traversing and extracting method for generating other collections.
CommandCollectionAwareInterface: An interface for shells that take a CommandCollection during initialization.
CommandFactoryInterface: An interface for abstracting creation of command and shell instances.
CommandInterface: Describe the interface between a command and the surrounding console libraries.
ConfigEngineInterface: An interface for creating objects compatible with Configure::load()
ConsoleApplicationInterface: An interface defining the methods that the console runner depend on.
ContainerApplicationInterface: Interface for applications that configure and use a dependency injection container.
ContainerInterface: Interface for the Dependency Injection Container in CakePHP applications
HttpApplicationInterface: An interface defining the methods that the http server depend on.
PluginApplicationInterface: Interface for Applications that leverage plugins & events.
PluginInterface: Plugin Interface
RetryStrategyInterface: Used to instruct a CommandRetry object on whether a retry for an action should be performed
ConstraintsInterface: Defines the interface for a fixture that needs to manage constraints.
DriverInterface: Interface for database driver.
FieldInterface: Describes a getter and a setter for the a field property. Useful for expressions that contain an identifier to compare against.
WindowInterface: This defines the functions used for building window expressions.
ExpressionInterface: An interface used by Expression objects.
CollectionInterface: Represents a database schema collection
SqlGeneratorInterface: An interface used by TableSchema objects.
TableSchemaAwareInterface: Defines the interface for getting the schema.
TableSchemaInterface: An interface used by database TableSchema objects.
StatementInterface: Represents a database statement. Concrete implementations can either use PDOStatement or a native driver
BatchCastingInterface: Denotes type objects capable of converting many values from their original database representation to php values.
ColumnSchemaAwareInterface
ExpressionTypeInterface: An interface used by Type objects to signal whether the value should be converted to an ExpressionInterface instead of a string when sent to the database.
OptionalConvertInterface: An interface used by Type objects to signal whether the casting is actually required.
TypedResultInterface: Represents an expression that is known to return a specific type
TypeInterface: Encapsulates all conversion functions for values coming from a database into PHP and going from PHP into a database.
ConnectionInterface: This interface defines the methods you can depend on in a connection.
EntityInterface: Describes the methods that any class representing a data storage should comply with.
FixtureInterface: Defines the interface that testing fixtures use.
InvalidPropertyInterface: Describes the methods that any class representing a data storage should comply with.
LocatorInterface: Registries for repository objects should implement this interface.
PaginatorInterface: This interface describes the methods for paginator instance.
QueryInterface: The basis for every query object
RepositoryInterface: Describes the methods that any class representing a data storage should comply with.
ResultSetInterface: Describes how a collection of datasource results should look like
SchemaInterface: An interface used by TableSchema objects.
FormatterInterface: Interface for formatters used by Debugger::exportVar()
NodeInterface: Interface for Debugs
ErrorLoggerInterface: Interface for error logging handlers.
ErrorRendererInterface: Interface for PHP error rendering implementations
ExceptionRendererInterface: Interface ExceptionRendererInterface
EventDispatcherInterface: Objects implementing this interface can emit events.
EventInterface: Represents the transport class of events across the system. It receives a name, subject and an optional payload. The name can be any string that uniquely identifies the event across the application, while the subject represents the object that the event applies to.
EventListenerInterface: Objects implementing this interface should declare the `implementedEvents()` method to notify the event manager what methods should be called when an event is triggered.
EventManagerInterface: Interface EventManagerInterface
AdapterInterface: Http client adapter interface.
ControllerFactoryInterface: Factory method for building controllers from request/response pairs.
CookieInterface: Cookie Interface
FormatterInterface: Formatter Interface
I18nDateTimeInterface: Interface for date formatting methods shared by both Time & Date.
TranslateStrategyInterface: This interface describes the methods for translate behavior strategies.
LocatorInterface: Registries for Table objects should implement this interface.
PropertyMarshalInterface: Behaviors implementing this interface can participate in entity marshalling.
RoutingApplicationInterface: Interface for applications that use routing.
FixtureStrategyInterface: Base interface for strategies used to manage fixtures for TestCase.
ValidatableInterface: Describes objects that can be validated by passing a Validator object.
ValidatorAwareInterface: Provides methods for managing multiple validators.
ContextInterface: Interface for FormHelper context implementations.
WidgetInterface: Interface for input widgets.
ChronosInterface: An extension to the DateTimeInterface for a friendlier API
DifferenceFormatterInterface: Interface for formatting differences in text.
ExceptionInterface: Marker interface for package-specific exceptions.
FilterServerRequestInterface: Filter/initialize a server request.
EmitterInterface
ExceptionInterface: Marker interface for package exceptions.
RequestHandlerRunnerInterface: "Run" a request handler.
ArgumentInterface
ArgumentResolverInterface
DefaultValueInterface
LiteralArgumentInterface
ResolvableArgumentInterface
ContainerAwareInterface
DefinitionAggregateInterface
DefinitionInterface
DefinitionContainerInterface: Describes the interface of a container that exposes methods to read its entries.
InflectorAggregateInterface
InflectorInterface
BootableServiceProviderInterface
ServiceProviderAggregateInterface
ServiceProviderInterface
ContainerExceptionInterface: Base interface representing a generic exception in a container.
ContainerInterface: Describes the interface of a container that exposes methods to read its entries.
NotFoundExceptionInterface: No entry was found in the container.
ClientExceptionInterface: Every HTTP client related exception MUST implement this interface.
ClientInterface
NetworkExceptionInterface: Thrown when the request cannot be completed because of network issues.
RequestExceptionInterface: Exception for when a request failed.
RequestFactoryInterface
ResponseFactoryInterface
ServerRequestFactoryInterface
StreamFactoryInterface
UploadedFileFactoryInterface
UriFactoryInterface
MessageInterface: HTTP messages consist of requests from a client to a server and responses from a server to a client. This interface defines the methods common to each.
RequestInterface: Representation of an outgoing, client-side request.
ResponseInterface: Representation of an outgoing, server-side response.
ServerRequestInterface: Representation of an incoming, server-side HTTP request.
StreamInterface: Describes a data stream.
UploadedFileInterface: Value object representing a file uploaded through an HTTP request.
UriInterface: Value object representing a URI.
RequestHandlerInterface: Handles a server request and produces a response.
MiddlewareInterface: Participant in processing a server request and response.
LoggerAwareInterface: Describes a logger-aware instance.
LoggerInterface: Describes a logger instance.
CacheException: Interface used for all types of exceptions thrown by the implementing library.
CacheInterface
InvalidArgumentException: Exception interface for invalid cache arguments.

Classes

InitialMigration
PackagesCommand: Packages Command
AppController: App Controller
CoursesController: Courses Controller
InvalidCharException: Throw when a character is invalid.
MissingMethodException: Throws when a method is missing.
UtilitiesException: The base/generic exception for this plugin.
CommonNetwork: Holds common functions needed for translating different ipv4 stuff.
Hlls: hue, lightness, luminosity, and saturation object for color
Memory: Tracks Memory and time usage, mainly for cron jobs.
MemoryBehavior: Basically a wrapper for the Mimory Library for the Model/Tables to use.
SluggableBehavior: Used mainly for when you're importing data from an external source like an excel file, csv file, etc. where each record doesn't have an explicit unique id.
Book: Book Entity
Course: Course Entity
CoursesStudent: Courses Student Entity
Student: Student Entity
BooksTable: Books Model
CoursesStudentsTable: Courses Students Model
CoursesTable: Courses Model
StudentsTable: Students Model
Plugin: CakePHP Utilities Plugin
ProgressinfoHelper: Progress Info Helper
ColorHelper: Color Helper
GravatarHelper: Gravatar Helper
VersionsHelper: Versions Helper
ColorWidget: Color Widget
BooksFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
CoursesFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
CoursesStudentsFixture: Yes, ok before this goes out into the open world: I didn't look up if they were in these courses, or what their grades were.
StudentsFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
PackagesCommandTest: Cake TestCase class
CoursesControllerTest: CoursesControllerTest class
CommonNetworkTest: Cake TestCase class
CoursesTableTest: CoursesTable Test
StudentsTableTest: StudentsTable Test
PluginTest: PluginTest class
ProgressinfoHelperTest: ProgressinfoHelper Test Class
ColorHelperTest: Cake TestCase class
GravatarHelperTest: GravatarHelper Test Class
VersionsHelperTest: Cake TestCase class
ColorWidgetTest: Basic input test.
AbstractPasswordHasher: Abstract password hashing class
BaseAuthenticate: Base Authentication class with common methods and properties.
BaseAuthorize: Abstract base authorization adapter for AuthComponent.
BasicAuthenticate: Basic Authentication adapter for AuthComponent.
ControllerAuthorize: An authorization adapter for AuthComponent. Provides the ability to authorize using a controller callback. Your controller's isAuthorized() method should return a boolean to indicate whether the user is authorized.
DefaultPasswordHasher: Default password hashing class.
DigestAuthenticate: Digest Authentication adapter for AuthComponent.
FallbackPasswordHasher: A password hasher that can use multiple different hashes where only one is the preferred one. This is useful when trying to migrate an existing database of users from one password type to another.
FormAuthenticate: Form authentication adapter for AuthComponent.
PasswordHasherFactory: Builds password hashing objects
MemoryStorage: Memory based non-persistent storage for authenticated user record.
SessionStorage: Session based persistent storage for authenticated user record.
WeakPasswordHasher: Password hashing class that use weak hashing algorithms. This class is intended only to be used with legacy databases where passwords have not been migrated to a stronger algorithm yet.
Cache: Cache provides a consistent interface to Caching in your application. It allows you to use several different Cache engines, without coupling your application to a specific implementation. It also allows you to change out cache storage or configuration without effecting the rest of your application.
CacheEngine: Storage engine for CakePHP caching
CacheRegistry: An object registry for cache engines.
ApcuEngine: APCu storage engine for cache
ArrayEngine: Array storage engine for cache.
FileEngine: File Storage engine for cache. Filestorage is the slowest cache storage to read and write. However, it is good for servers that don't have other storage engine available, or have content which is not performance sensitive.
MemcachedEngine: Memcached storage engine for cache. Memcached has some limitations in the amount of control you have over expire times far in the future. See MemcachedEngine::write() for more information.
NullEngine: Null cache engine, all operations appear to work, but do nothing.
RedisEngine: Redis storage engine for cache.
WincacheEngine: Wincache storage engine for cache
InvalidArgumentException: Exception raised when cache keys are invalid.
Collection: A collection is an immutable list of elements with a handful of functions to iterate, group, transform and extract information from it.
BufferedIterator: Creates an iterator from another iterator that will keep the results of the inner iterator in memory, so that results don't have to be re-calculated.
ExtractIterator: Creates an iterator from another iterator that extract the requested column or property based on a path
FilterIterator: Creates a filtered iterator from another iterator. The filtering is done by passing a callback function to each of the elements and taking them out if it does not return true.
InsertIterator: This iterator will insert values into a property of each of the records returned.
MapReduce: Implements a simplistic version of the popular Map-Reduce algorithm. Acts like an iterator for the original passed data after each result has been processed, thus offering a transparent wrapper for results coming from any source.
NestIterator: A type of collection that is aware of nested items and exposes methods to check or retrieve them
NoChildrenIterator: An iterator that can be used as an argument for other iterators that require a RecursiveIterator but do not want children. This iterator will always behave as having no nested items.
ReplaceIterator: Creates an iterator from another iterator that will modify each of the values by converting them using a callback function.
SortIterator: An iterator that will return the passed items in order. The order is given by the value returned in a callback function that maps each of the elements.
TreeIterator: A Recursive iterator used to flatten nested structures and also exposes all Collection methods
TreePrinter: Iterator for flattening elements in a tree structure while adding some visual markers for their relative position in the tree
ZipIterator: Creates an iterator that returns elements grouped in pairs
CacheClearallCommand: CacheClearall command.
CacheClearCommand: CacheClear command.
CacheListCommand: CacheList command.
Command: Base class for commands using the full stack CakePHP Framework.
CompletionCommand: Provide command completion shells such as bash.
I18nCommand: Command for interactive I18N management.
I18nExtractCommand: Language string extractor
I18nInitCommand: Command for interactive I18N management.
PluginAssetsCopyCommand: Command for copying plugin assets to app's webroot.
PluginAssetsRemoveCommand: Command for removing plugin assets from app's webroot.
PluginAssetsSymlinkCommand: Command for symlinking / copying plugin assets to app's webroot.
PluginLoadCommand: Command for loading plugins.
PluginLoadedCommand: Displays all currently loaded plugins.
PluginUnloadCommand: Command for unloading plugins.
RoutesCheckCommand: Provides interactive CLI tool for testing routes.
RoutesCommand: Provides interactive CLI tools for routing.
RoutesGenerateCommand: Provides interactive CLI tools for URL generation
SchemacacheBuildCommand: Provides CLI tool for updating schema cache.
SchemacacheClearCommand: Provides CLI tool for clearing schema cache.
ServerCommand: built-in Server command
VersionCommand: Print out the version of CakePHP in use.
Arguments: Provides an interface for interacting with a command's options and arguments.
BaseCommand: Base class for console commands.
HelpCommand: Print out command list
CommandCollection: Collection for Commands.
CommandFactory: This is a factory for creating Command and Shell instances.
CommandRunner: Run CLI commands for the provided application.
ConsoleInput: Object wrapper for interacting with stdin
ConsoleInputArgument: An object to represent a single argument used in the command line.
ConsoleInputOption: An object to represent a single option used in the command line.
ConsoleInputSubcommand: An object to represent a single subcommand used in the command line.
ConsoleIo: A wrapper around the various IO operations shell tasks need to do.
ConsoleOptionParser: Handles parsing the ARGV in the command line and provides support for GetOpt compatible option definition. Provides a builder pattern implementation for creating shell option parsers.
ConsoleOutput: Object wrapper for outputting information from a shell application.
ConsoleException: Exception class for Console libraries. This exception will be thrown from Console library classes when they encounter an error.
MissingHelperException: Used when a Helper cannot be found.
MissingOptionException: Exception raised with suggestions
MissingShellException: Used when a shell cannot be found.
MissingShellMethodException: Used when a shell method cannot be found.
MissingTaskException: Used when a Task cannot be found.
StopException: Exception class for halting errors in console tasks
Helper: Base class for Helpers.
HelperRegistry: Registry for Helpers. Provides features for lazily loading helpers.
HelpFormatter: HelpFormatter formats help for console shells. Can format to either text or XML formats. Uses ConsoleOptionParser methods to generate help.
Shell: Base class for command-line utilities for automating programmer chores.
ShellDispatcher: Shell dispatcher handles dispatching CLI commands.
TaskRegistry: Registry for Tasks. Provides features for lazily loading tasks.
LegacyCommandRunner: Class that dispatches to the legacy ShellDispatcher using the same signature as the newer CommandRunner
LegacyShellDispatcher: Allows injecting mock IO into shells
MissingConsoleInputException: Exception class used to indicate missing console input.
StubConsoleInput: Stub class used by the console integration harness.
StubConsoleOutput: StubOutput makes testing shell commands/shell helpers easier.
AuthComponent: Authentication control component class.
CheckHttpCacheComponent: Use HTTP caching headers to see if rendering can be skipped.
FlashComponent: The CakePHP FlashComponent provides a way for you to write a flash variable to the session from your controllers, to be rendered in a view with the FlashHelper.
FormProtectionComponent: Protects against form tampering. It ensures that:
PaginatorComponent: This component is used to handle automatic model data pagination. The primary way to use this component is to call the paginate() method. There is a convenience wrapper on Controller as well.
RequestHandlerComponent: Request object handling for alternative HTTP requests.
SecurityComponent: The Security Component creates an easy way to integrate tighter security in your application. It provides methods for these tasks:
Component: Base class for an individual Component. Components provide reusable bits of controller logic that can be composed into a controller. Components also provide request life-cycle callbacks for injecting logic at specific points.
ComponentRegistry: ComponentRegistry is a registry for loaded components
Controller: Application controller class for organization of business logic.
ControllerFactory: Factory method for building controllers for request.
ErrorController: Error Handling Controller
AuthSecurityException: Auth Security exception - used when SecurityComponent detects any issue with the current request
InvalidParameterException: Used when a passed parameter or action parameter type declaration is missing or invalid.
MissingActionException: Missing Action exception - used when a controller action cannot be found, or when the controller's isAction() method returns false.
MissingComponentException: Used when a component cannot be found.
SecurityException: Security exception - used when SecurityComponent detects any issue with the current request
App: App is responsible for resource location, and path management.
BasePlugin: Base Plugin Class
ClassLoader: ClassLoader
IniConfig: Ini file configuration engine.
JsonConfig: JSON engine allows Configure to load configuration values from files containing JSON strings.
PhpConfig: PHP engine allows Configure to load configuration values from files containing simple PHP arrays.
Configure: Configuration class. Used for managing runtime configuration information.
Container: Dependency Injection container
CakeException: Base class that all CakePHP Exceptions extend.
MissingPluginException: Exception raised when a plugin could not be found
ObjectRegistry: Acts as a registry/factory for objects.
Plugin: Plugin is used to load and locate plugins.
PluginCollection: Plugin Collection
CommandRetry: Allows any action to be retried in case of an exception.
ServiceConfig: Read-only wrapper for configuration data
ServiceProvider: Container ServiceProvider
Connection: Represents a connection with a database server.
Mysql: MySQL Driver
Postgres: Class Postgres
Sqlite: Class Sqlite
Sqlserver: SQLServer driver.
Driver: Represents a database driver containing all specificities for a database engine including its SQL dialect.
DatabaseException: Exception for the database package.
MissingConnectionException: Class MissingConnectionException
MissingDriverException: Class MissingDriverException
MissingExtensionException: Class MissingExtensionException
NestedTransactionRollbackException: Class NestedTransactionRollbackException
AggregateExpression: This represents an SQL aggregate function expression in an SQL statement.
BetweenExpression: An expression object that represents a SQL BETWEEN snippet
CaseExpression: This class represents a SQL Case statement
CaseStatementExpression: Represents a SQL case statement with a fluid API
CommonTableExpression: An expression that represents a common table expression definition.
ComparisonExpression: A Comparison is a type of query expression that represents an operation involving a field an operator and a value. In its most common form the string representation of a comparison is `field = value`
FunctionExpression: This class represents a function call string in a SQL statement. Calls can be constructed by passing the name of the function and a list of params.
IdentifierExpression: Represents a single identifier name in the database.
OrderByExpression: An expression object for ORDER BY clauses
OrderClauseExpression: An expression object for complex ORDER BY clauses
QueryExpression: Represents a SQL Query expression. Internally it stores a tree of expressions that can be compiled by converting this object to string and will contain a correctly parenthesized and nested expression.
StringExpression: String expression with collation.
TupleComparison: This expression represents SQL fragments that are used for comparing one tuple to another, one tuple to a set of other tuples or one tuple to an expression
UnaryExpression: An expression object that represents an expression with only a single operand.
ValuesExpression: An expression object to contain values being inserted.
WhenThenExpression: Represents a SQL when/then clause with a fluid API
WindowExpression: This represents a SQL window expression used by aggregate and window functions.
FieldTypeConverter: A callable class to be used for processing each of the rows in a statement result, so that the values are converted to the right PHP types.
FunctionsBuilder: Contains methods related to generating FunctionExpression objects with most commonly used SQL functions.
Query: This class represents a Relational database SQL Query. A query can be of different types like select, update, insert and delete. Exposes the methods for dynamically constructing each query part, execute it and transform it to a specific SQL dialect.
CachedCollection: Decorates a schema collection and adds caching
Collection: Represents a database schema collection
SchemaDialect: Base class for schema implementations.
TableSchema: Represents a single table in a database schema.
SchemaCache: Schema Cache.
BufferedStatement: A statement decorator that implements buffered results.
CallbackStatement: Wraps a statement in a callback that allows row results to be modified when being fetched.
PDOStatement: Decorator for \PDOStatement class mainly used for converting human readable fetch modes into PDO constants.
StatementDecorator: Represents a database statement. Statements contains queries that can be executed multiple times by binding different values on each call. This class also helps convert values to their valid representation for the corresponding types.
BaseType: Base type class.
BinaryType: Binary type converter.
BinaryUuidType: Binary UUID type converter.
BoolType: Bool type converter.
DateTimeFractionalType: Extends DateTimeType with support for fractional seconds up to microseconds.
DateTimeTimezoneType: Extends DateTimeType with support for time zones.
DateTimeType: Datetime type converter.
DateType: Class DateType
DecimalType: Decimal type converter.
FloatType: Float type converter.
IntegerType: Integer type converter.
JsonType: JSON type converter.
StringType: String type converter.
TimeType: Time type converter.
UuidType: Provides behavior for the UUID type
TypeFactory: Factory for building database type classes.
TypeMap: Implements default and single-use mappings for columns to their associated types
ConnectionManager: Manages and loads instances of Connection
ConnectionRegistry: A registry object for connection instances.
InvalidPrimaryKeyException: Exception raised when the provided primary key does not match the table primary key
MissingDatasourceConfigException: Exception class to be thrown when a datasource configuration is not found
MissingDatasourceException: Used when a datasource cannot be found.
MissingModelException: Used when a model cannot be found.
RecordNotFoundException: Exception raised when a particular record was not found
FactoryLocator: Class FactoryLocator
AbstractLocator: Provides an abstract registry/factory for repository objects.
PageOutOfBoundsException: Exception raised when requested page number does not exist.
NumericPaginator: This class is used to handle automatic model data pagination.
SimplePaginator: Simplified paginator which avoids potentially expensives queries to get the total count of records.
ResultSetDecorator: Generic ResultSet decorator. This will make any traversable object appear to be a database result
RulesChecker: Contains logic for storing and checking rules on entities
BaseErrorHandler: Base error handler that provides logic common to the CLI + web error/exception handlers.
ConsoleErrorHandler: Error Handler for Cake console. Does simple printing of the exception that occurred and the stack trace of the error.
ArrayItemNode: Dump node for Array Items.
ArrayNode: Dump node for Array values.
ClassNode: Dump node for objects/class instances.
PropertyNode: Dump node for object properties.
ReferenceNode: Dump node for class references.
ScalarNode: Dump node for scalar values.
SpecialNode: Debug node for special messages like errors or recursion warnings.
Debugger: Provide custom logging and error handling.
ErrorHandler: Error Handler provides basic error and exception handling for your application. It captures and handles all unhandled exceptions and errors. Displays helpful framework errors when debug mode is on.
ErrorLogger: Log errors and unhandled exceptions to `Cake\Log\Log`
ErrorTrap: Entry point to CakePHP's error handling.
ExceptionRenderer: Backwards compatible Exception Renderer.
ExceptionTrap: Entry point to CakePHP's exception handling.
FatalErrorException: Represents a fatal error
ErrorHandlerMiddleware: Error handling middleware.
PhpError: Object wrapper around PHP errors that are emitted by `trigger_error()`
ConsoleErrorRenderer: Plain text error rendering with a stack trace.
ConsoleExceptionRenderer: Plain text exception rendering with a stack trace.
HtmlErrorRenderer: Interactive HTML error rendering with a stack trace.
TextErrorRenderer: Plain text error rendering with a stack trace.
TextExceptionRenderer: Plain text exception rendering with a stack trace.
WebExceptionRenderer: Web Exception Renderer.
AbstractDecorator: Common base class for event decorator subclasses.
ConditionDecorator: Event Condition Decorator
SubjectFilterDecorator: Event Subject Filter Decorator
Event: Class Event
EventList: The Event List
EventManager: The event manager is responsible for keeping track of event listeners, passing the correct data to them, and firing them in the correct order, when associated events are triggered. You can create multiple instances of this object to manage local events or keep a single instance and pass it around to manage all events in your app.
File: Convenience class for reading, writing and appending to files.
Folder: Folder structure browser, lists folders and files.
Form: Form abstraction used to create forms not tied to ORM backed models, or to other permanent datastores. Ideal for implementing forms on top of API services, or contact forms.
Schema: Contains the schema information for Form instances.
BaseApplication: Base class for full-stack applications
Curl: Implements sending Cake\Http\Client\Request via ext/curl.
Stream: Implements sending Cake\Http\Client\Request via php's stream API.
Basic: Basic authentication adapter for Cake\Http\Client
Digest: Digest authentication adapter for Cake\Http\Client
Oauth: Oauth 1 authentication strategy for Cake\Http\Client
ClientException: Thrown when a request cannot be sent or response cannot be parsed into a PSR-7 response object.
MissingResponseException: Used to indicate that a request did not have a matching mock response.
NetworkException: Thrown when the request cannot be completed because of network issues.
RequestException: Exception for when a request failed.
FormData: Provides an interface for building multipart/form-encoded message bodies.
Message: Base class for other HTTP requests/responses
Request: Implements methods for HTTP requests.
Response: Implements methods for HTTP responses.
Client: The end user interface for doing HTTP requests.
ContentTypeNegotiation: Negotiates the prefered content type from what the application provides and what the request has in its Accept header.
Cookie: Cookie object to build a cookie and turn it into a header value
CookieCollection: Cookie Collection
CorsBuilder: A builder object that assists in defining Cross Origin Request related headers.
BadRequestException: Represents an HTTP 400 error.
ConflictException: Represents an HTTP 409 error.
ForbiddenException: Represents an HTTP 403 error.
GoneException: Represents an HTTP 410 error.
HttpException: Parent class for all the HTTP related exceptions in CakePHP.
InternalErrorException: Represents an HTTP 500 error.
InvalidCsrfTokenException: Represents an HTTP 403 error caused by an invalid CSRF token
MethodNotAllowedException: Represents an HTTP 405 error.
MissingControllerException: Missing Controller exception - used when a controller cannot be found.
NotAcceptableException: Represents an HTTP 406 error.
NotFoundException: Represents an HTTP 404 error.
NotImplementedException: Not Implemented Exception - used when an API method is not implemented
RedirectException: An exception subclass used by routing and application code to trigger a redirect.
ServiceUnavailableException: Represents an HTTP 503 error.
UnauthorizedException: Represents an HTTP 401 error.
UnavailableForLegalReasonsException: Represents an HTTP 451 error.
FlashMessage: The FlashMessage class provides a way for you to write a flash variable to the session, to be rendered in a view with the FlashHelper.
BodyParserMiddleware: Parse encoded request body data.
ClosureDecoratorMiddleware: Decorate closures as PSR-15 middleware.
CspMiddleware: Content Security Policy Middleware
CsrfProtectionMiddleware: Provides CSRF protection & validation.
DoublePassDecoratorMiddleware: Decorate double-pass middleware as PSR-15 middleware.
EncryptedCookieMiddleware: Middleware for encrypting & decrypting cookies.
HttpsEnforcerMiddleware: Enforces use of HTTPS (SSL) for requests.
SecurityHeadersMiddleware: Handles common security headers in a convenient way
SessionCsrfProtectionMiddleware: Provides CSRF protection via session based tokens.
MiddlewareApplication: Base class for standalone HTTP applications
MiddlewareQueue: Provides methods for creating and manipulating a "queue" of middlewares.
Response: Responses contain the response text, status and headers of a HTTP response.
ResponseEmitter: Emits a Response to the PHP Server API.
Runner: Executes the middleware queue and provides the `next` callable that allows the queue to be iterated.
Server: Runs an application invoking all the PSR7 middleware and the registered application.
ServerRequest: A class that helps wrap Request information and particulars about a single request.
ServerRequestFactory: Factory for making ServerRequest instances.
CacheSession: CacheSession provides method for saving sessions into a Cache engine. Used with Session
DatabaseSession: DatabaseSession provides methods to be used with Session.
Session: This class is a wrapper for the native PHP session functions. It provides several defaults for the most common session configuration via external handlers and helps with using session in CLI without any warnings.
ChainMessagesLoader: Wraps multiple message loaders calling them one after another until one of them returns a non-empty package.
Date: Extends the Date class provided by Chronos.
I18nException: I18n exception.
IcuFormatter: A formatter that will interpolate variables using the MessageFormatter class
SprintfFormatter: A formatter that will interpolate variables using sprintf and select the correct plural form when required
FrozenDate: Extends the Date class provided by Chronos.
FrozenTime: Extends the built-in DateTime class to provide handy methods and locale-aware formatting helpers
I18n: I18n handles translation of Text and time format strings.
MessagesFileLoader: A generic translations package factory that will load translations files based on the file extension and the package name.
LocaleSelectorMiddleware: Sets the runtime default locale for the request based on the Accept-Language header. The default will only be set if it matches the list of passed valid locales.
Number: Number helper library.
Package: Message Catalog
MoFileParser: Parses file in MO format
PoFileParser: Parses file in PO format
Time: Extends the built-in DateTime class to provide handy methods and locale-aware formatting helpers
TranslatorRegistry: Constructs and stores instances of translators that can be retrieved by name and locale.
ArrayLog: Array logger.
BaseLog: Base log engine class.
ConsoleLog: Console logging. Writes logs to console output.
FileLog: File Storage stream for Logging. Writes logs to different files based on the level of log it is.
SyslogLog: Syslog stream for Logging. Writes logs to the system logger
AbstractFormatter
DefaultFormatter
JsonFormatter
LegacySyslogFormatter
Log: Logs messages to configured Log adapters. One or more adapters can be configured using Cake Logs's methods. If you don't configure any adapters, and write to Log, the messages will be ignored.
LogEngineRegistry: Registry of loaded log engines
AbstractTransport: Abstract transport for sending email
Email: CakePHP Email class.
MissingActionException: Missing Action exception - used when a mailer action cannot be found.
MissingMailerException: Used when a mailer cannot be found.
Mailer: Mailer base class.
Message: Email message class.
Renderer: Class for rendering email message.
DebugTransport: Debug Transport class, useful for emulating the email sending process and inspecting the resultant email message before actually sending it during development
MailTransport: Send mail using mail() function
SmtpTransport: Send mail using SMTP protocol
TransportFactory: Factory class for generating email transport instances.
TransportRegistry: An object registry for mailer transports.
SocketException: Exception class for Socket. This exception will be thrown from Socket, Email, HttpSocket SmtpTransport, MailTransport and HttpResponse when it encounters an error.
Socket: CakePHP network socket connection class.
BelongsTo: Represents an 1 - N relationship where the source side of the relation is related to only one record in the target table.
BelongsToMany: Represents an M - N relationship where there exists a junction - or join - table that contains the association fields between the source and the target table.
HasMany: Represents an N - 1 relationship where the target side of the relationship will have one or multiple records per each one in the source side.
HasOne: Represents an 1 - 1 relationship where the source side of the relation is related to only one record in the target table and vice versa.
Association: An Association is a relationship established between two tables and is used to configure and customize the way interconnected records are retrieved.
AssociationCollection: A container/collection for association classes.
CounterCacheBehavior: CounterCache behavior
TimestampBehavior: Class TimestampBehavior
EavStrategy: This class provides a way to translate dynamic data by keeping translations in a separate table linked to the original record from another one. Translated fields can be configured to override those in the main table when fetched or put aside into another property for the same entity.
ShadowTableStrategy: This class provides a way to translate dynamic data by keeping translations in a separate shadow table where each row corresponds to a row of primary table.
TranslateBehavior: This behavior provides a way to translate dynamic data by keeping translations in a separate table linked to the original record from another one. Translated fields can be configured to override those in the main table when fetched or put aside into another property for the same entity.
TreeBehavior: Makes the table to which this is attached to behave like a nested set and provides methods for managing and retrieving information out of the derived hierarchical structure.
Behavior: Base class for behaviors.
BehaviorRegistry: BehaviorRegistry is used as a registry for loaded behaviors and handles loading and constructing behavior objects.
EagerLoader: Exposes the methods for storing the associations that should be eager loaded for a table once a query is provided and delegates the job of creating the required joins and decorating the results so that those associations can be part of the result set.
Entity: An entity represents a single result row from a repository. It exposes the methods for retrieving and storing properties associated in this row.
MissingBehaviorException: Used when a behavior cannot be found.
MissingEntityException: Exception raised when an Entity could not be found.
MissingTableClassException: Exception raised when a Table could not be found.
PersistenceFailedException: Used when a strict save or delete fails
RolledbackTransactionException: Used when a transaction was rolled back from a callback event.
TableLocator: Provides a default registry/factory for Table objects.
Marshaller: Contains logic to convert array data into entities.
Query: Extends the base Query class to provide new methods related to association loading, automatic fields selection, automatic type casting and to wrap results into a specific iterator that will be responsible for hydrating results if required.
ResultSet: Represents the results obtained after executing a query for a specific table This object is responsible for correctly nesting result keys reported from the query, casting each field to the correct type and executing the extra queries required for eager loading external associations.
ExistsIn: Checks that the value provided in a field exists as the primary key of another table.
IsUnique: Checks that a list of fields from an entity are unique in the table
LinkConstraint: Checks whether links to a given association exist / do not exist.
ValidCount: Validates the count of associated records.
RulesChecker: ORM flavoured rules checker.
SaveOptionsBuilder: OOP style Save Option Builder.
Table: Represents a single database table.
TableRegistry: Provides a registry/factory for Table objects.
Asset: Class for generating asset URLs.
DuplicateNamedRouteException: Exception raised when a route names used twice.
FailedRouteCacheException: Thrown when unable to cache route collection.
MissingDispatcherFilterException: Exception raised when a Dispatcher filter could not be found
MissingRouteException: Exception raised when a URL cannot be reverse routed or when a URL cannot be parsed.
RedirectException: An exception subclass used by the routing layer to indicate that a route has resolved to a redirect.
AssetMiddleware: Handles serving plugin assets in development mode.
RoutingMiddleware: Applies routing rules to the request and creates the controller instance if possible.
DashedRoute: This route class will transparently inflect the controller, action and plugin routing parameters, so that requesting `/my-plugin/my-controller/my-action` is parsed as `['plugin' => 'MyPlugin', 'controller' => 'MyController', 'action' => 'myAction']`
EntityRoute: Matches entities to routes
InflectedRoute: This route class will transparently inflect the controller and plugin routing parameters, so that requesting `/my_controller` is parsed as `['controller' => 'MyController']`
PluginShortRoute: Plugin short route, that copies the plugin param to the controller parameters It is used for supporting /{plugin} routes.
RedirectRoute: Redirect route will perform an immediate redirect. Redirect routes are useful when you want to have Routing layer redirects occur in your application, for when URLs move.
Route: A single Route used by the Router to connect requests to parameter maps.
RouteBuilder: Provides features for building routes inside scopes.
Router: Parses the request URL into controller, action, and parameters. Uses the connected routes to match the incoming URL string to parameters that will allow the request to be dispatched. Also handles converting parameter lists into URL strings, using the connected routes. Routing allows you to decouple the way the world interacts with your application (URLs) and the implementation (controllers and actions).
ProgressHelper: Create a progress bar using a supplied callback.
TableHelper: Create a visually pleasing ASCII art table from 2 dimensional array data.
ConsoleIntegrationTestCase: A test case class intended to make integration tests of cake console commands easier.
FixtureHelper: Helper for managing fixtures.
FixtureInjector: Test listener used to inject a fixture manager in all tests that are composed inside a Test Suite
FixtureManager: A factory class to manage the life cycle of test fixtures
PHPUnitExtension: PHPUnit extension to integrate CakePHP's data-only fixtures.
SchemaLoader: Create test database schema from one or more SQL dump files.
TestFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
TransactionStrategy: Fixture strategy that wraps fixtures in a transaction that is rolled back after each test.
TruncateStrategy: Fixture strategy that truncates all fixture ables at the end of test.
IntegrationTestCase: A test case class intended to make integration tests of your controllers easier.
TestCase: Cake TestCase class
TestEmailTransport: TestEmailTransport
TestSession: Read only access to the session during testing.
TestSuite: A class to contain test cases and run them with shared fixtures
XmlException: Exception class for Xml. This exception will be thrown from Xml when it encounters an error.
Hash: Library of array functions for manipulating and extracting data from arrays or 'sets' of data.
Inflector: Pluralize and singularize English words.
Security: Security Library contains utility methods related to security
Text: Text handling methods.
Xml: XML handling for CakePHP.
RulesProvider: A Proxy class used to remove any extra arguments when the user intended to call a method in another class that is not aware of validation providers signature
Validation: Validation Class. Used for validation of model data
ValidationRule: ValidationRule object. Represents a validation method, error message and rules for applying such method to a field.
ValidationSet: ValidationSet object. Holds all validation rules for a field and exposes methods to dynamically add or remove validation rules
Validator: Validator object encapsulates all methods related to data validations for a model It also provides an API to dynamically change validation rules for each model field.
AjaxView: A view class that is used for AJAX responses.
Cell: Cell base.
MissingCellException: Used when a cell class file cannot be found.
MissingCellTemplateException: Used when a template file for a cell cannot be found.
MissingElementException: Used when an element file cannot be found.
MissingHelperException: Used when a helper cannot be found.
MissingLayoutException: Used when a layout file cannot be found.
MissingTemplateException: Used when a template file cannot be found.
MissingViewException: Used when a view class file cannot be found.
SerializationFailureException: Used when a SerializedView class fails to serialize data.
ArrayContext: Provides a basic array based context provider for FormHelper.
ContextFactory: Factory for getting form context instance based on provided data.
EntityContext: Provides a form context around a single entity and its relations.
FormContext: Provides a context provider for {@link \Cake\Form\Form} instances.
NullContext: Provides a context provider that does nothing.
BreadcrumbsHelper: BreadcrumbsHelper to register and display a breadcrumb trail for your views
FlashHelper: FlashHelper class to render flash messages.
FormHelper: Form helper library.
HtmlHelper: Html Helper class for easy use of HTML widgets.
NumberHelper: Number helper library.
PaginatorHelper: Pagination Helper class for easy generation of pagination links.
TextHelper: Text helper library.
TimeHelper: Time Helper class for easy use of time data.
UrlHelper: UrlHelper class for generating URLs.
Helper: Abstract base class for all other Helpers in CakePHP.
HelperRegistry: HelperRegistry is used as a registry for loaded helpers and handles loading and constructing helper class objects.
JsonView: A view class that is used for JSON responses.
NegotiationRequiredView: A view class that responds to any content-type and can be used to create an empty body 406 status code response.
SerializedView: Parent class for view classes generating serialized outputs like JsonView and XmlView.
StringTemplate: Provides an interface for registering and inserting content into simple logic-less string templates.
View: View, the V in the MVC triad. View interacts with Helpers and view variables passed in from the controller to render the results of the controller action. Often this is HTML, but can also take the form of JSON, XML, PDF's or streaming files.
ViewBlock: ViewBlock implements the concept of Blocks or Slots in the View layer.
ViewBuilder: Provides an API for iteratively building a view up.
BasicWidget: Basic input class.
ButtonWidget: Button input class
CheckboxWidget: Input widget for creating checkbox widgets.
DateTimeWidget: Input widget class for generating a date time input widget.
FileWidget: Input widget class for generating a file upload control.
LabelWidget: Form 'widget' for creating labels.
MultiCheckboxWidget: Input widget class for generating multiple checkboxes.
NestingLabelWidget: Form 'widget' for creating labels that contain their input.
RadioWidget: Input widget class for generating a set of radio buttons.
SelectBoxWidget: Input widget class for generating a selectbox.
TextareaWidget: Input widget class for generating a textarea control.
WidgetLocator: A registry/factory for input widgets.
YearWidget: Input widget class for generating a calendar year select box.
XmlView: A view class that is used for creating XML responses.
ArticlesFixture: Short description for class.
ArticlesMoreTranslationsFixture: Class ArticlesTranslationsFixture
ArticlesTagsBindingKeysFixture: Fixture for testing bindingKey in belongstomany associations.
ArticlesTagsFixture: Short description for class.
ArticlesTranslationsFixture: Class ArticlesTranslationsFixture
AssertIntegrationTestCase: This class helps in indirectly testing the functionality of IntegrationTestCase
AttachmentsFixture: Short description for class.
AuthorsFixture: Short description for class.
AuthorsTagsFixture: AuthorsTags fixture
AuthorsTranslationsFixture: Class AuthorsTranslationsFixture
AuthUsersFixture: Short description for class.
BinaryUuidItemsBinaryUuidTagsFixture: BinaryUuidItemsBinaryUuidTagsFixture
BinaryUuidItemsFixture: BinaryUuidItemsFixture
BinaryUuidTagsFixture: BinaryUuidTagsFixture
CakeSessionsFixture: SessionFixture
CategoriesFixture: Short description for class.
ColumnSchemaAwareTypeValuesFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
CommentsFixture: Short description for class.
CommentsTranslationsFixture: Class CommentsTranslationsFixture
CompositeIncrementsFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
CompositeKeyArticlesFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
CompositeKeyArticlesTagsFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
CounterCacheCategoriesFixture: Short description for class.
CounterCacheCommentsFixture: Counter Cache Test Fixtures
CounterCachePostsFixture: Counter Cache Test Fixtures
CounterCacheUserCategoryPostsFixture: CounterCache test fixture for testing binding keys.
CounterCacheUsersFixture: Short description for class.
DatatypesFixture: Fixture for testing decimal, float and bigint types
DateKeysFixture: Fixture for testing complex types as primary keys
FeaturedTagsFixture: FeaturedTagsFixture
FixturizedTestCase: This class helps in testing the life-cycle of fixtures inside a CakeTestCase
MembersFixture: MembersFixture
MenuLinkTreesFixture: NumberTreeFixture
NullableAuthorsFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
NumberTreesArticlesFixture: Short description for class.
NumberTreesFixture: NumberTreeFixture
OrderedUuidItemsFixture: Class OrderedUuiditemFixture
OrdersFixture: OrdersFixture
OtherArticlesFixture: A fixture attached to the non-default connection that implements the interface with none of the safe-guards from TestFixture.
PolymorphicTaggedFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
PostsFixture: PostFixture
ProductsFixture: ProductsFixture
ProfilesFixture: ProfileFixture
SectionsFixture: SectionsFixture
SectionsMembersFixture: SectionsMembersFixture
SectionsTranslationsFixture: Class SectionsTranslationsFixture
SessionsFixture: SessionFixture
SiteArticlesFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
SiteArticlesTagsFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
SiteAuthorsFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
SiteTagsFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
SpecialTagsFixture: A fixture for a join table containing additional data
SpecialTagsTranslationsFixture: Class SpecialTagsTranslationsFixture
TagsFixture: TagFixture
TagsShadowTranslationsFixture: Class TagsShadowTranslationsFixture
TagsTranslationsFixture: TagsTranslationsFixture
TestPluginCommentsFixture: TestPluginCommentFixture
ThingsFixture: Cake TestFixture is responsible for building and destroying tables to be used during testing.
TranslatesFixture: TranslateFixture
UniqueAuthorsFixture: Tables of unique author ids
UsersFixture: UserFixture
UuidItemsFixture: UuiditemFixture
AssociationTableMixinClassReflectionExtension
TableFindByPropertyMethodReflection
Chronos: An Immutable extension on the native DateTime object.
ChronosDate: An immutable date object that converts all time components into 00:00:00.
ChronosInterval: A simple API extension for DateInterval.
DifferenceFormatter: Handles formatting differences in text.
MutableDate: A mutable date object that converts all time components into 00:00:00.
MutableDateTime: A mutable datetime instance that implements the ChronosInterface.
Translator: Basic english only 'translator' for diffForHumans()
ComposerAutoloaderInita4eaec22380742bf6e4fca7dd7366920
ComposerStaticInita4eaec22380742bf6e4fca7dd7366920
CaBundle
ClassLoader: ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
InstalledVersions: This class is copied in every Composer installed project and available to all
ComposerInfo: The main entrypoint for this library.
Package: Contains the details of specific packages.
PackagesCollection: The list of packages found in the lock file.
RuntimeException
ComposerInfoTest: Tests src/ComposerInfo.php
PackagesCollectionTest: Tests src/Package.php
PackageTest: Tests src/Package.php
AbstractSerializer: Provides base functionality for request and response de/serialization strategies, including functionality for retrieving a line at a time from the message, splitting headers from the body, and serializing headers.
CallbackStream: Implementation of PSR HTTP streams
ConfigProvider
DeserializationException
InvalidArgumentException
InvalidForwardedHeaderNameException
InvalidProxyAddressException
InvalidStreamPointerPositionException
RuntimeException
SerializationException
UnreadableStreamException
UnrecognizedProtocolVersionException
UnrewindableStreamException
UnseekableStreamException
UntellableStreamException
UnwritableStreamException
UploadedFileAlreadyMovedException
UploadedFileErrorException
HeaderSecurity: Provide security tools around HTTP headers to prevent common injection vectors.
Module
PhpInputStream: Caching version of php://input
RelativeStream: Wrapper for default Stream class, representing subpart (starting from given offset) of initial stream.
ArraySerializer: Serialize or deserialize request messages to/from arrays.
Serializer: Serialize (cast to string) or deserialize (cast string to Request) messages.
Request: HTTP Request encapsulation
RequestFactory
ArraySerializer: Serialize or deserialize response messages to/from arrays.
EmptyResponse: A class representing empty HTTP responses.
HtmlResponse: HTML response.
JsonResponse: JSON response.
RedirectResponse: Produce a redirect response.
Serializer: Provides base functionality for request and response de/serialization strategies, including functionality for retrieving a line at a time from the message, splitting headers from the body, and serializing headers.
TextResponse: Plain text response.
XmlResponse: XML response.
Response: HTTP response encapsulation.
ResponseFactory
ServerRequest: Server-side HTTP request
ServerRequestFactory: Class for marshaling a request object from the current PHP environment.
DoNotFilter
FilterUsingXForwardedHeaders: Modify the URI to reflect the X-Forwarded-* headers.
Stream: Implementation of PSR HTTP streams
StreamFactory
UploadedFile
UploadedFileFactory
Uri: Implementation of Psr\Http\UriInterface.
UriFactory
ConfigProvider
EmitterStack: Provides an EmitterInterface implementation that acts as a stack of Emitters.
SapiEmitter
SapiStreamEmitter
EmitterException
InvalidEmitterException
RequestHandlerRunner: "Run" a request handler.
DefaultValueArgument
ArrayArgument
BooleanArgument
CallableArgument
FloatArgument
IntegerArgument
ObjectArgument
StringArgument
LiteralArgument
ResolvableArgument
Container
Definition
DefinitionAggregate
ContainerException
NotFoundException
Inflector
InflectorAggregate
ReflectionContainer
AbstractServiceProvider
ServiceProviderAggregate
AbstractLogger: This is a simple Logger implementation that other Loggers can inherit from.
InvalidArgumentException
LogLevel: Describes log levels.
NullLogger: This Logger can be used to avoid conditional log calls.

Traits

FuModelFindTrait: Fu Model Find Trait
MergeDeleteTrait: Merge/Delete Trait
ToggleTrait: Toggle Trait
ApplySettingsTrait: Be careful using this as it can easily abused since it doesn't do any complex data validation.
CheckAddTrait: Common methods checking if a record exists, and adds the object if it doesn't.
MergeDeleteTrait: Merge/Delete Trait
ToggleTrait: Toggle Trait
CollectionTrait: Offers a handful of methods to manipulate iterators
ExtractTrait: Provides utility protected methods for extracting a property or column from an array or object.
ConsoleIntegrationTestTrait: A bundle of methods that makes testing commands and shell classes easier.
FileConfigTrait: Trait providing utility methods for file based config engines.
ConventionsTrait: Provides methods that allow other classes access to conventions based inflections.
InstanceConfigTrait: A trait for reading and writing instance config
StaticConfigTrait: A trait that provides a set of static methods to manage configuration for classes that provide an adapter facade or need to have sets of configuration data registered and manipulated.
ContainerStubTrait: A set of methods used for defining container services in test cases.
FieldTrait: Contains the field property with a getter and a setter for it
ExpressionTypeCasterTrait: Offers a method to convert values to ExpressionInterface objects if the type they should be converted to implements ExpressionTypeInterface
TypeConverterTrait: Type converter trait
TypedResultTrait: Implements the TypedResultInterface
TypeMapTrait: Trait TypeMapTrait
EntityTrait: An entity represents a single result row from a repository. It exposes the methods for retrieving and storing fields associated in this row.
ModelAwareTrait: Provides functionality for loading table classes and other repositories onto properties of the host object.
QueryTrait: Contains the characteristics for an object that is attached to a repository and can retrieve results based on any criteria.
RulesAwareTrait: A trait that allows a class to build and apply application.
EventDispatcherTrait: Implements Cake\Event\EventDispatcherInterface.
HttpClientTrait: Define mock responses and have mocks automatically cleared.
DateFormatTrait: Trait for date formatting methods shared by both Time & Date.
LogTrait: A trait providing an object short-cut method to logging.
MailerAwareTrait: Provides functionality for loading mailer classes onto properties of the host object.
AssociationsNormalizerTrait: Contains methods for parsing the associated tables array that is typically passed to a save operation
TranslateStrategyTrait: Contains common code needed by TranslateBehavior strategy classes.
TranslateTrait: Contains a translation method aimed to help managing multiple translations for an entity.
LocatorAwareTrait: Contains method for setting and accessing LocatorInterface instance
EmailTrait: Make assertions on emails sent through the Cake\TestSuite\TestEmailTransport
IntegrationTestTrait: A trait intended to make integration tests of your controllers easier.
StringCompareTrait: Compare a string to the contents of a file
TestListenerTrait: Implements empty default methods for PHPUnit\Framework\TestListener.
CookieCryptTrait: Cookie Crypt Trait.
MergeVariablesTrait: Provides features for merging object properties recursively with parent classes.
ValidatorAwareTrait: A trait that provides methods for building and interacting with Validators.
CellTrait: Provides cell() method for usage in Controller and View classes.
IdGeneratorTrait: A trait that provides id generating methods to be used in various widget classes.
StringTemplateTrait: Adds string template functionality to any class by providing methods to load and parse string templates.
ViewVarsTrait: Provides the set() method for collecting template context.
ComparisonTrait: Provides various comparison operator methods for datetime objects.
CopyTrait: Provides methods for copying datetime objects.
DifferenceTrait: Provides methods for getting differences between datetime objects.
FactoryTrait: Provides a number of datetime related factory methods.
FormattingTrait: Provides string formatting methods for datetime instances.
FrozenTimeTrait: A trait for freezing the time aspect of a DateTime.
MagicPropertyTrait: Provides the magic methods that allow read access to magic properties.
ModifierTrait: Provides a suite of modifier methods.
RelativeKeywordTrait: Provides methods for testing if strings contain relative keywords.
TestingAidTrait: Provides methods for setting a 'test' now. This lets you retrieve pre-determined times with now().
TimezoneTrait: Methods for modifying/reading timezone data.
MessageTrait: Trait implementing the various methods defined in MessageInterface.
RequestTrait: Trait with common request behaviors.
InjectContentTypeTrait
SapiEmitterTrait
ArgumentResolverTrait
ContainerAwareTrait
LoggerAwareTrait: Basic Implementation of LoggerAwareInterface.
LoggerTrait: This is a simple Logger trait that classes unable to extend AbstractLogger (because they extend another class, etc) can include.

Constants

APP = \TEST_APP . 'TestApp' . \DS
APP_DIR = 'TestApp'
CACHE = \TMP . 'cache' . \DS
CAKE = \CORE_PATH . 'src' . \DS
CAKE_CORE_INCLUDE_PATH = \ROOT
CONFIG = \TEST_APP . 'config' . \DS
CORE_PATH = \CAKE_CORE_INCLUDE_PATH . \DS
CORE_TEST_CASES = \CORE_TESTS . 'TestCase'
CORE_TESTS = \CORE_PATH . 'tests' . \DS
DAY = 86400
DS = \DIRECTORY_SEPARATOR: Defines DS as short form of DIRECTORY_SEPARATOR.
DS = \DIRECTORY_SEPARATOR
E_RECOVERABLE_ERROR = 4096
HOUR = 3600
LOGS = \TMP . 'logs' . \DS
MINUTE = 60
MONTH = 2592000
ROOT = \dirname(__DIR__)
SECOND = 1
SESSIONS = \TMP . 'sessions' . \DS
TEST_APP = \CORE_TESTS . 'test_app' . \DS
TESTS = __DIR__ . \DS
TIME_START = \microtime(\true)
TMP = \sys_get_temp_dir() . \DS
WEEK = 604800
WWW_ROOT = \TEST_APP . 'webroot' . \DS
YEAR = 31536000

Functions

debug() : mixed: Prints out debug information about given variable and returns the variable that was passed.
stackTrace() : void: Outputs a stack trace based on the supplied options.
breakpoint() : string|null: Command to return the eval-able code to startup PsySH in interactive debugger Works the same way as eval(\Psy\sh()); psy/psysh must be loaded in your project
dd() : void: Prints out debug information about given variable and dies.
collection() : Collection: Returns a new {@link \Cake\Collection\Collection} object wrapping the passed argument.
h() : mixed: Convenience method for htmlspecialchars.
pluginSplit() : array<string|int, mixed>: Splits a dot syntax plugin name into its plugin and class name.
namespaceSplit() : array<string|int, string>: Split the namespace from the classname.
pr() : mixed: print_r() convenience function.
pj() : mixed: JSON pretty print convenience function.
env() : string|bool|null: Gets an environment variable from available sources, and provides emulation for unsupported or inconsistent environment variables (i.e. DOCUMENT_ROOT on IIS, or SCRIPT_NAME in CGI mode). Also exposes some additional custom environment information.
triggerWarning() : void: Triggers an E_USER_WARNING.
deprecationWarning() : void: Helper method for outputting deprecation warnings
getTypeName() : string: Returns the objects class or var type of it's not an object
__() : string: Returns a translated string if one is found; Otherwise, the submitted message.
__n() : string: Returns correct plural form of message identified by $singular and $plural for count $count.
__d() : string: Allows you to override the current domain for a single message lookup.
__dn() : string: Allows you to override the current domain for a single plural message lookup.
__x() : string: Returns a translated string if one is found; Otherwise, the submitted message.
__xn() : string: Returns correct plural form of message identified by $singular and $plural for count $count.
__dx() : string: Allows you to override the current domain for a single message lookup.
__dxn() : string: Returns correct plural form of message identified by $singular and $plural for count $count.
urlArray() : array<string|int, mixed>: Returns an array URL from a route path string.
createUploadedFile() : UploadedFile
createUploadedFile() : UploadedFile: Create an uploaded file instance from an array of values.
marshalHeadersFromSapi() : array<string|int, mixed>
marshalHeadersFromSapi() : array<string|int, mixed>
marshalMethodFromSapi() : string
marshalMethodFromSapi() : string: Retrieve the request method from the SAPI parameters.
marshalProtocolVersionFromSapi() : string
marshalProtocolVersionFromSapi() : string: Return HTTP protocol version (X.Y) as discovered within a `$_SERVER` array.
marshalUriFromSapi() : Uri
marshalUriFromSapi() : Uri: Marshal a Uri instance based on the values presnt in the $_SERVER array and headers.
normalizeServer() : array<string|int, mixed>
normalizeServer() : array<string|int, mixed>: Marshal the $_SERVER array
normalizeUploadedFiles() : array<string|int, mixed>
normalizeUploadedFiles() : array<string|int, UploadedFileInterface>: Normalize uploaded files
parseCookieHeader() : array<non-empty-string, string>
parseCookieHeader() : array<non-empty-string, string>: Parse a cookie header according to RFC 6265.

APP


    public
        mixed
    APP
    = \TEST_APP . 'TestApp' . \DS

APP_DIR


    public
        mixed
    APP_DIR
    = 'TestApp'

CACHE


    public
        mixed
    CACHE
    = \TMP . 'cache' . \DS

CAKE


    public
        mixed
    CAKE
    = \CORE_PATH . 'src' . \DS

CAKE_CORE_INCLUDE_PATH


    public
        mixed
    CAKE_CORE_INCLUDE_PATH
    = \ROOT

CONFIG


    public
        mixed
    CONFIG
    = \TEST_APP . 'config' . \DS

CORE_PATH


    public
        mixed
    CORE_PATH
    = \CAKE_CORE_INCLUDE_PATH . \DS

CORE_TEST_CASES


    public
        mixed
    CORE_TEST_CASES
    = \CORE_TESTS . 'TestCase'

CORE_TESTS


    public
        mixed
    CORE_TESTS
    = \CORE_PATH . 'tests' . \DS

DAY


    public
        mixed
    DAY
    = 86400

DS

Defines DS as short form of DIRECTORY_SEPARATOR.


    public
        mixed
    DS
    = \DIRECTORY_SEPARATOR

DS


    public
        mixed
    DS
    = \DIRECTORY_SEPARATOR

E_RECOVERABLE_ERROR


    public
        mixed
    E_RECOVERABLE_ERROR
    = 4096

HOUR


    public
        mixed
    HOUR
    = 3600

LOGS


    public
        mixed
    LOGS
    = \TMP . 'logs' . \DS

MINUTE


    public
        mixed
    MINUTE
    = 60

MONTH


    public
        mixed
    MONTH
    = 2592000

ROOT


    public
        mixed
    ROOT
    = \dirname(__DIR__)

SECOND


    public
        mixed
    SECOND
    = 1

SESSIONS


    public
        mixed
    SESSIONS
    = \TMP . 'sessions' . \DS

TEST_APP


    public
        mixed
    TEST_APP
    = \CORE_TESTS . 'test_app' . \DS

TESTS


    public
        mixed
    TESTS
    = __DIR__ . \DS

TIME_START


    public
        float
    TIME_START
    = \microtime(\true)

TMP


    public
        mixed
    TMP
    = \sys_get_temp_dir() . \DS

WEEK


    public
        mixed
    WEEK
    = 604800

WWW_ROOT


    public
        mixed
    WWW_ROOT
    = \TEST_APP . 'webroot' . \DS

YEAR


    public
        mixed
    YEAR
    = 31536000

debug()

Prints out debug information about given variable and returns the variable that was passed.


    
                    debug(mixed $var[, bool|null $showHtml = null ][, bool $showFrom = true ]) : mixed

Only runs if debug mode is enabled.

Parameters

$var : mixed: Variable to show debug information for.
$showHtml : bool|null = null: If set to true, the method prints the debug data in a browser-friendly way.
$showFrom : bool = true: If set to true, the method prints from where the function was called.

Return values

mixed —

The same $var that was passed

stackTrace()

Outputs a stack trace based on the supplied options.


    
                    stackTrace([array<string, mixed> $options = [] ]) : void

Options

depth - The number of stack frames to return. Defaults to 999
args - Should arguments for functions be shown? If true, the arguments for each method call will be displayed.
start - The stack frame to start generating a trace from. Defaults to 1

Parameters

$options : array<string, mixed> = []: Format for outputting stack trace

breakpoint()

Command to return the eval-able code to startup PsySH in interactive debugger Works the same way as eval(\Psy\sh()); psy/psysh must be loaded in your project


    
                    breakpoint() : string|null

eval(breakpoint());

Return values

string|null

dd()

Prints out debug information about given variable and dies.


    
                    dd(mixed $var[, bool|null $showHtml = null ]) : void

Only runs if debug mode is enabled. It will otherwise just continue code execution and ignore this function.

Parameters

$var : mixed: Variable to show debug information for.
$showHtml : bool|null = null: If set to true, the method prints the debug data in a browser-friendly way.

collection()

Returns a new {@link \Cake\Collection\Collection} object wrapping the passed argument.


    
                    collection(iterable<string|int, mixed> $items) : Collection

Parameters

$items : iterable<string|int, mixed>: The items from which the collection will be built.

Return values

Collection

h()

Convenience method for htmlspecialchars.


    
                    h(mixed $text[, bool $double = true ][, string|null $charset = null ]) : mixed

Parameters

$text : mixed: Text to wrap through htmlspecialchars. Also works with arrays, and objects. Arrays will be mapped and have all their elements escaped. Objects will be string cast if they implement a __toString method. Otherwise, the class name will be used. Other scalar types will be returned unchanged.
$double : bool = true: Encode existing html entities.
$charset : string|null = null: Character set to use when escaping. Defaults to config value in mb_internal_encoding() or 'UTF-8'.

Return values

mixed —

Wrapped text.

pluginSplit()

Splits a dot syntax plugin name into its plugin and class name.


    
                    pluginSplit(string $name[, bool $dotAppend = false ][, string|null $plugin = null ]) : array<string|int, mixed>

If $name does not have a dot, then index 0 will be null.

Commonly used like

list($plugin, $name) = pluginSplit($name);

Parameters

$name : string: The name you want to plugin split.
$dotAppend : bool = false: Set to true if you want the plugin to have a '.' appended to it.
$plugin : string|null = null: Optional default plugin to use if no plugin is found. Defaults to null.

Return values

array<string|int, mixed> —

Array with 2 indexes. 0 => plugin name, 1 => class name.

namespaceSplit()

Split the namespace from the classname.


    
                    namespaceSplit(string $class) : array<string|int, string>

Commonly used like list($namespace, $className) = namespaceSplit($class);.

Parameters

$class : string: The full class name, ie Cake\Core\App.

Return values

array<string|int, string> —

Array with 2 indexes. 0 => namespace, 1 => classname.

pr()

print_r() convenience function.


    
                    pr(mixed $var) : mixed

In terminals this will act similar to using print_r() directly, when not run on CLI print_r() will also wrap <pre> tags around the output of given variable. Similar to debug().

This function returns the same variable that was passed.

Parameters

$var : mixed: Variable to print out.

Return values

mixed —

the same $var that was passed to this function

pj()

JSON pretty print convenience function.


    
                    pj(mixed $var) : mixed

In terminals this will act similar to using json_encode() with JSON_PRETTY_PRINT directly, when not run on CLI will also wrap <pre> tags around the output of given variable. Similar to pr().

This function returns the same variable that was passed.

Parameters

$var : mixed: Variable to print out.

Return values

mixed —

the same $var that was passed to this function

env()

Gets an environment variable from available sources, and provides emulation for unsupported or inconsistent environment variables (i.e. DOCUMENT_ROOT on IIS, or SCRIPT_NAME in CGI mode). Also exposes some additional custom environment information.


    
                    env(string $key[, string|bool|null $default = null ]) : string|bool|null

Parameters

$key : string: Environment variable name.
$default : string|bool|null = null: Specify a default value in case the environment variable is not defined.

Return values

string|bool|null —

Environment variable setting.

triggerWarning()

Triggers an E_USER_WARNING.


    
                    triggerWarning(string $message) : void

Parameters

$message : string: The warning message.

deprecationWarning()

Helper method for outputting deprecation warnings


    
                    deprecationWarning(string $message[, int $stackFrame = 1 ]) : void

Parameters

$message : string: The message to output as a deprecation warning.
$stackFrame : int = 1: The stack frame to include in the error. Defaults to 1 as that should point to application/plugin code.

getTypeName()

Returns the objects class or var type of it's not an object


    
                    getTypeName(mixed $var) : string

Parameters

$var : mixed: Variable to check

Return values

string —

Returns the class name or variable type

__()

Returns a translated string if one is found; Otherwise, the submitted message.


    
                    __(string $singular, mixed ...$args) : string

Parameters

$singular : string: Text to translate.
$args : mixed: Array with arguments or multiple arguments in function.

Return values

string —

The translated text.

__n()

Returns correct plural form of message identified by $singular and $plural for count $count.


    
                    __n(string $singular, string $plural, int $count, mixed ...$args) : string

Some languages have more than one form for plural messages dependent on the count.

Parameters

$singular : string: Singular text to translate.
$plural : string: Plural text.
$count : int: Count.
$args : mixed: Array with arguments or multiple arguments in function.

Return values

string —

Plural form of translated string.

__d()

Allows you to override the current domain for a single message lookup.


    
                    __d(string $domain, string $msg, mixed ...$args) : string

Parameters

$domain : string: Domain.
$msg : string: String to translate.
$args : mixed: Array with arguments or multiple arguments in function.

Return values

string —

Translated string.

__dn()

Allows you to override the current domain for a single plural message lookup.


    
                    __dn(string $domain, string $singular, string $plural, int $count, mixed ...$args) : string

Returns correct plural form of message identified by $singular and $plural for count $count from domain $domain.

Parameters

$domain : string: Domain.
$singular : string: Singular string to translate.
$plural : string: Plural.
$count : int: Count.
$args : mixed: Array with arguments or multiple arguments in function.

Return values

string —

Plural form of translated string.

__x()

Returns a translated string if one is found; Otherwise, the submitted message.


    
                    __x(string $context, string $singular, mixed ...$args) : string

The context is a unique identifier for the translations string that makes it unique within the same domain.

Parameters

$context : string: Context of the text.
$singular : string: Text to translate.
$args : mixed: Array with arguments or multiple arguments in function.

Return values

string —

Translated string.

__xn()

Returns correct plural form of message identified by $singular and $plural for count $count.


    
                    __xn(string $context, string $singular, string $plural, int $count, mixed ...$args) : string

Some languages have more than one form for plural messages dependent on the count. The context is a unique identifier for the translations string that makes it unique within the same domain.

Parameters

$context : string: Context of the text.
$singular : string: Singular text to translate.
$plural : string: Plural text.
$count : int: Count.
$args : mixed: Array with arguments or multiple arguments in function.

Return values

string —

Plural form of translated string.

__dx()

Allows you to override the current domain for a single message lookup.


    
                    __dx(string $domain, string $context, string $msg, mixed ...$args) : string

The context is a unique identifier for the translations string that makes it unique within the same domain.

Parameters

$domain : string: Domain.
$context : string: Context of the text.
$msg : string: String to translate.
$args : mixed: Array with arguments or multiple arguments in function.

Return values

string —

Translated string.

__dxn()

Returns correct plural form of message identified by $singular and $plural for count $count.


    
                    __dxn(string $domain, string $context, string $singular, string $plural, int $count, mixed ...$args) : string

Allows you to override the current domain for a single message lookup. The context is a unique identifier for the translations string that makes it unique within the same domain.

Parameters

$domain : string: Domain.
$context : string: Context of the text.
$singular : string: Singular text to translate.
$plural : string: Plural text.
$count : int: Count.
$args : mixed: Array with arguments or multiple arguments in function.

Return values

string —

Plural form of translated string.

urlArray()

Returns an array URL from a route path string.


    
                    urlArray(string $path[, array<string|int, mixed> $params = [] ]) : array<string|int, mixed>

Parameters

$path : string: Route path.
$params : array<string|int, mixed> = []: An array specifying any additional parameters. Can be also any special parameters supported by Router::url().

Return values

array<string|int, mixed> —

URL

createUploadedFile()

Use Laminas\Diactoros\createUploadedFile instead


    
                    createUploadedFile(array<string|int, mixed> $spec) : UploadedFile

Parameters

$spec : array<string|int, mixed>

Return values

UploadedFile

createUploadedFile()

Create an uploaded file instance from an array of values.


    
                    createUploadedFile(array<string|int, mixed> $spec) : UploadedFile

Parameters

$spec : array<string|int, mixed>: A single $_FILES entry.

Return values

UploadedFile

marshalHeadersFromSapi()

Use Laminas\Diactoros\marshalHeadersFromSapi instead


    
                    marshalHeadersFromSapi(array<string|int, mixed> $server) : array<string|int, mixed>

Parameters

$server : array<string|int, mixed>

Return values

array<string|int, mixed>

marshalHeadersFromSapi()


    
                    marshalHeadersFromSapi(array<string|int, mixed> $server) : array<string|int, mixed>

Parameters

$server : array<string|int, mixed>: Values obtained from the SAPI (generally $_SERVER).

Return values

array<string|int, mixed> —

Header/value pairs

marshalMethodFromSapi()

Use Laminas\Diactoros\marshalMethodFromSapi instead


    
                    marshalMethodFromSapi(array<string|int, mixed> $server) : string

Parameters

$server : array<string|int, mixed>

Return values

string

marshalMethodFromSapi()

Retrieve the request method from the SAPI parameters.


    
                    marshalMethodFromSapi(array<string|int, mixed> $server) : string

Parameters

$server : array<string|int, mixed>

Return values

string

marshalProtocolVersionFromSapi()

Use Laminas\Diactoros\marshalProtocolVersionFromSapi instead


    
                    marshalProtocolVersionFromSapi(array<string|int, mixed> $server) : string

Parameters

$server : array<string|int, mixed>

Return values

string

marshalProtocolVersionFromSapi()

Return HTTP protocol version (X.Y) as discovered within a `$_SERVER` array.


    
                    marshalProtocolVersionFromSapi(array<string|int, mixed> $server) : string

Parameters

$server : array<string|int, mixed>

Return values

string

marshalUriFromSapi()

Use Laminas\Diactoros\marshalUriFromSapi instead


    
                    marshalUriFromSapi(array<string|int, mixed> $server, array<string|int, mixed> $headers) : Uri

Parameters

$server : array<string|int, mixed>
$headers : array<string|int, mixed>

Return values

Uri

marshalUriFromSapi()

Marshal a Uri instance based on the values presnt in the $_SERVER array and headers.

This function is deprecated as of 2.11.1, and will be removed in 3.0.0. As of 2.11.1, it is no longer used internally.


    
                    marshalUriFromSapi(array<string|int, mixed> $server, array<string|int, mixed> $headers) : Uri

Parameters

$server : array<string|int, mixed>: SAPI parameters
$headers : array<string|int, mixed>: HTTP request headers

Return values

Uri

normalizeServer()

Use Laminas\Diactoros\normalizeServer instead


    
                    normalizeServer(array<string|int, mixed> $server[, callable|null $apacheRequestHeaderCallback = null ]) : array<string|int, mixed>

Parameters

$server : array<string|int, mixed>
$apacheRequestHeaderCallback : callable|null = null

Return values

array<string|int, mixed>

normalizeServer()

Marshal the $_SERVER array


    
                    normalizeServer(array<string|int, mixed> $server[, null|callable $apacheRequestHeaderCallback = null ]) : array<string|int, mixed>

Pre-processes and returns the $_SERVER superglobal. In particularly, it attempts to detect the Authorization header, which is often not aggregated correctly under various SAPI/httpd combinations.

Parameters

$server : array<string|int, mixed>
$apacheRequestHeaderCallback : null|callable = null: Callback that can be used to retrieve Apache request headers. This defaults to apache_request_headers under the Apache mod_php.

Return values

array<string|int, mixed> —

Either $server verbatim, or with an added HTTP_AUTHORIZATION header.

normalizeUploadedFiles()

Use Laminas\Diactoros\normalizeUploadedFiles instead


    
                    normalizeUploadedFiles(array<string|int, mixed> $files) : array<string|int, mixed>

Parameters

$files : array<string|int, mixed>

Return values

array<string|int, mixed>

normalizeUploadedFiles()

Normalize uploaded files


    
                    normalizeUploadedFiles(array<string|int, mixed> $files) : array<string|int, UploadedFileInterface>

Transforms each value into an UploadedFile instance, and ensures that nested arrays are normalized.

Parameters

$files : array<string|int, mixed>

Return values

array<string|int, UploadedFileInterface>

parseCookieHeader()

Use parseCookieHeader instead


    
                    parseCookieHeader(string $cookieHeader) : array<non-empty-string, string>

Parameters

$cookieHeader : string: A string cookie header value.

Return values

array<non-empty-string, string> —

key/value cookie pairs.

parseCookieHeader()

Parse a cookie header according to RFC 6265.


    
                    parseCookieHeader(string $cookieHeader) : array<non-empty-string, string>

PHP will replace special characters in cookie names, which results in other cookies not being available due to overwriting. Thus, the server request should take the cookies from the request header instead.

Parameters

$cookieHeader : string: A string cookie header value.

Return values

array<non-empty-string, string> —

key/value cookie pairs.

Application

Table of Contents

Interfaces

Classes

Traits

Constants

Functions

Constants

APP

APP_DIR

CACHE

CAKE

CAKE_CORE_INCLUDE_PATH

CONFIG

CORE_PATH

CORE_TEST_CASES

CORE_TESTS

DAY

DS

DS

E_RECOVERABLE_ERROR

HOUR

LOGS

MINUTE

MONTH

ROOT

SECOND

SESSIONS

TEST_APP

TESTS

TIME_START

TMP

WEEK

WWW_ROOT

YEAR

Functions

debug()

Parameters

Tags

Return values

stackTrace()

Options

Parameters

breakpoint()

Tags

Return values

dd()

Parameters

Tags

collection()

Parameters

Return values

h()

Parameters

Tags

Return values

pluginSplit()

Parameters

Tags

Return values

namespaceSplit()

Parameters

Return values

pr()

Parameters

Tags

Return values

pj()

Parameters

Tags

Return values

env()

Parameters

Tags

Return values

triggerWarning()

Parameters

deprecationWarning()

Parameters

getTypeName()