Docs & rules

yegor256/takesGitHub

This is a public, read-only report. Striff reads this repository's docs, turns each sentence that makes a claim about the code into a rule, and checks the rule against the code on the default branch. How this works

5 stale names in these docs.

masterca8ea8cLast read Oct 7

Is this yours? Install to manage it

Once installed, Striff checks every pull request.

Rules summary
Documents
Rules
37
5 stale names37
1 doc
yegor256/takesOpen repository

Stale names in these docs5

Each sentence below has a stale name: a type the default branch doesn't declare, or declares somewhere else. Edit the doc so it matches the code, or bring the type back.

  • RenamedRsJSON
    RsJSON

    Renamed: RsJSON is now RsJson, at src/main/java/org/takes/rs/RsJson.java. Renamed in 3b82af1

    View on GitHub

  • RenamedRsHTML
    return new RsHTML(

    Renamed: RsHTML is now RsHtml, at src/main/java/org/takes/rs/RsHtml.java. Renamed in 3b82af1

    View on GitHub

  • RenamedTkHTML
    new FkRegex("/", new TkHTML("Hello, check <a href='/acc'>account</a>")),

    Renamed: TkHTML is now TkHtml, at src/main/java/org/takes/tk/TkHtml.java. Renamed in 3b82af1

    View on GitHub

  • RenamedCcXOR
    new CcSafe(new CcHex(new CcXOR(new CcCompact(), "secret-code")))

    Renamed: CcXOR is now CcXor, at src/main/java/org/takes/facets/auth/codecs/CcXor.java. Renamed in 3b82af1

    View on GitHub

  • RenamedFtCLI
    There is a convenient FtCLI class that parses command-line arguments and starts the necessary Front accordingly.

    Renamed: FtCLI is now FtCli, at src/main/java/org/takes/http/FtCli.java. Renamed in 3b82af1

    View on GitHub

yegor256/takes — documented rules

37 of 37 rules, printed November 17, 2026.

The sentence in your docs
Then, it gives requests to the instance of TkFork (tk stands for "take") and expects it to return an instance of Take back.
TkFork depends on Take
Holds
We are using TkRegex instead of Take, in order to work with RqRegex instead of a more generic Request.
TkRegex depends on RqRegex
Holds
An essential part of the Bigger Example is the Front interface.
Front is a contract
Holds
FtBasic, which is a basic front, implements that interface - you have seen its usage in the above-mentioned example.
FtBasic implements Front
Holds
The Back interface is the back-end that is responsible for IO operations on TCP network level.
Back is a contract
Holds
There are various useful implementations of that interface: The BkBasic class is a basic implementation of the Back interface. It is responsible for accepting the request from Socket, converting the socket's input to the Request, dispatching it to the provided Take instance, getting the result and printing it to the socket's output until the request is fulfilled.
2 rules from this sentence
BkBasic depends on Request
Holds
BkBasic depends on Take
Holds
The BkBasic class is a basic implementation of the Back interface.
BkBasic implements Back
Holds
The BkTimeable class is a decorator of the Back interface, that is responsible for running the back-end for a specified maximum lifetime in milliseconds.
BkTimeable implements Back
Holds
The BkWrap class is a convenient wrap over the original Back instance.
BkWrap implements Back
Holds
The BkWrap class is a convenient wrap over the original Back instance. It just delegates the accept to that Back and might be useful if you want to add your own decorators of the Back interface. This class is used in BkParallel and BkSafe as a parent class.
2 rules from this sentence
BkParallel extends BkWrap
Holds
BkSafe extends BkWrap
Holds
TkFallback decorates an instance of Take and catches all exceptions any of its Takes may throw.
TkFallback implements Take
Holds
Everything is a composable interface, never a framework base class. The entire framework rests on three interfaces: Take (converts a request into a response), Request, and Response.
3 rules from this sentence
Take is a contract
Holds
Request is a contract
Holds
Response is a contract
Holds
Both Request and Response extend Head (HTTP header lines) and Body (a raw InputStream).
4 rules from this sentence
Request extends Head
Holds
Request extends Body
Holds
Response extends Head
Holds
Response extends Body
Holds
TkWrap and RsWrap are the base decorators for takes and responses respectively. Cross-cutting concerns — logging (TkSlf4j), GZIP compression (TkGzip), authentication (TkAuth), error fallback (TkFallback) — are each a thin wrapper around any other Take.
TkWrap implements Take
Holds
Cross-cutting concerns — logging (TkSlf4j), GZIP compression (TkGzip), authentication (TkAuth), error fallback (TkFallback) — are each a thin wrapper around any other Take.
3 rules from this sentence
TkSlf4j implements Take
Holds
TkGzip implements Take
Holds
TkAuth implements Take
Holds
The server is split into a Front and a Back, each independently composable. Front owns the TCP socket lifecycle (accept connections, honour Exit), while Back owns the HTTP lifecycle for a single socket (parse request, call Take, write response). BkBasic provides sequential request handling; BkParallel wraps it with a thread pool;
BkParallel implements Back
Holds
The server is split into a Front and a Back, each independently composable. Front owns the TCP socket lifecycle (accept connections, honour Exit), while Back owns the HTTP lifecycle for a single socket (parse request, call Take, write response).
Front depends on Exit
Holds
BkSafe suppresses exceptions; BkTimeable enforces a per-request timeout. Each layer is a decorator of the same Back interface, so you can combine them independently without touching routing or business logic.
BkSafe implements Back
Holds
Routing is a chain of explicit Fork predicates, not a registry of annotated methods. TkFork iterates over Fork instances and returns the first that matches.
TkFork depends on Fork
Holds
Routing is a chain of explicit Fork predicates, not a registry of annotated methods. TkFork iterates over Fork instances and returns the first that matches. Built-in forks match on URI path regex (FkRegex), HTTP method (FkMethods), query parameters, or Accept header.
2 rules from this sentence
FkRegex implements Fork
Holds
FkMethods implements Fork
Holds
Authentication is a pair of enter/exit methods on a Pass interface, composable like any other object. Pass has two methods: enter(Request) returns the authenticated Identity (or Opt.Empty), and exit(Response, Identity) attaches session information (e.g. a cookie) to the outgoing response.
5 rules from this sentence
Pass depends on Identity
Holds
Pass depends on Response
Holds
Pass depends on Opt
Holds
Pass has an enter method
Holds
Pass has an exit method
Holds
Providers — OAuth via Facebook, GitHub, Google, or cookie-based — all implement Pass and can be chained with PsChain or combined with PsAll.
2 rules from this sentence
PsChain implements Pass
Holds
PsAll implements Pass
Holds
37 rules from 1 doc

More open-source reports

Every report →

Other public repositories whose docs Striff read and checked against their code.