Overview

• Introduction
  • Features
• How it works
  • Addons
    • Plugins
    • Processors
    • Hooks
    • Example
  • File Structure

You can access the API by either using the binding, contract or facade.

Check out the Processors & Hooks documentaiton.

Inline code

Api access

Contract

use Codex\Contracts\Codex;
public function __construct(Codex $codex){
    $dir = $codex->getRootDir();
}

Facade

$dir = codex()->getDocsPath();

Binding

$dir = app('codex')->getDocsPath();

Overview

For details on the specific methods, check the API documentation

$codex->log($level, $message, $context = [ ]);
$codex->stack($viewName, $data = null, $appendTo = 'codex::layouts.default');

# @var string $path
$path       = $codex->getRootDir();

# @var string $url
$url        = $codex->url($project = null, $ref = null, $doc = null);

# @var boolean $hasProject
$hasProject = $codex->projects->has('codex-core');

/** @var \Codex\Projects\Project $project */
$project    = $codex->projects->get('codex-core');

# @var \Codex\Core\Components\Factory\Projects $projects
$projects   = $codex->projects;

# @var \Codex\Core\Projects[] $projects
$projects = ->all()
$projects   = $codex->projects->toArray();
foreach($projects as $project){
    $url = $project->url($doc = 'index', $ref = null);
    $project->path($path = null);           # string
    $project->hasEnabledProcessor($filter);    # bool
    $project->hasEnabledHook($hook);        # bool
    $project->getRef();                     # string
    $project->getDefaultRef();              # string
    $project->getRefs();                    # array[string]
    $project->getSortedRefs();              # array[string]
    $project->getName();                    # string
    $project->getPath();                    # string
    $project->getBranches();                # array[string]
    $project->getVersions();                # array[string]

    $project->documents->setExtensions(['md']);
    $project->documents->has($path); // without extension
    $project->documents->get($path); // without extension
    $documents = $project->documents->all();
}


# @var \Codex\Core\Projects[] $projects
$documents = $codex->projects->get('codex-core')->documents->all()

# @var \Codex\Core\Projects[] $projects
$document = $codex->projects->get('codex-core')->documents->get('api-uasge')

$document->render();
$document->attr($key = null, $default = null)
$document->url()
$document->getBreadcrumb()
$document->getPath()
$document->getContent()
$document->setContent($content)
$document->getAttributes((
$document->setAttributes(array $attr = [])
$document->mergeAttributes(array $attr = [])
$document->getProject()
$document->setPath($path)

Introduction

Codex is a file-based documentation platform built on top of Laravel. It's completely customizable and dead simple to use to create beautiful documentation.

Codex is able to do things like transforming markdown or automaticaly fetching documentation from a Bitbucket/Github repositories. Most of it's features are provided by addons. Codex is extenable, themeable, hackable and simple to setup and use.

Features

• Laravel 5
• Markdown, Creole or custom document parsers
• Host a unlimited number of projects/manuals with accompanying versions
• Extenable, themeable, hackable
• Simple to setup and use
• Syntax Highlighting
• Easy navigation defined in YAML
• SEO Friendly URLs
• Default theme build on Laravels theme
• Multiple storage methods (local, dropbox, amazon, etc)
• Can be installed as stand-alone or sub-component in your own (Laravel) project.
• (Addon Feature) Github/Bitbucket (auto webhook) synchronisation based on tags/branches.
• (Addon Feature) Smooth working, custom PHPDoc integration
• (Addon Feature) Access restriction on projects using Github/Bitbucket login
• Much, much more!

How it works

Codex > Projects > Refs (versions) > Documents > Processors

• Codex can provide documentation for multiple Projects.
• Each Project has one or more Refs (versions) containing your Documents.
• Documents are passed trough Processors, modifying it's content before displaying.

Addons

The addon-* packages are a collection of Plugins, Hooks and Processors.

Plugins

Plugins are used to alter Codex. They are capable of doing something very minor or completely alter the way Codex works.

• Adding routes/controllers
• Define custom document types
• Adding/changing views
• Adding/chaning assets
• Many more things.
• Extend the Codex API and structure with new features and functionality

Processors

Processors are used to alter the output of documents.

• Reading document attributes
• Parsing Markdown/Creole/Anything to HTML
• Adding tooltips
• Inject HTML/Javascript
• Generate table of contents
• Altering links
• Many more things.

Hooks

Hooks are able to execute when Codex executes code which have hook-points defined. This could be seen as a event dispatcher/listener.

• Allows minor or major modifications to Codex its inner workings.
• Codex is full of hook points with getters/setters to adjust class properties.
• Ensures code that doesn't have to be executed, won't be executed.

Example

The data is provided by the PHPDoc Addon. It uses the LinksProcessor to alter the links based on the information provided by PHPDoc Addon.

• More information on how to use the LinksProcessor can be found here.
• More information on the PHPDoc Addon should be here.

File Structure

A example file structure for Codex might look similar to:

- docs
    - my-awesome-project
        - config.php
        - v1.0.0
            - menu.yml
            - index.md
            - contributing.md
        - v1.1.0
            - menu.yml
            - index.md
            - contributing.md
        - master
            - menu.yml
            - index.md
            - contributing.md
            - installation.md
            - configuration.md
        - develop
            - menu.yml
            - index.md
    - my-second-project
        - ...