org.cactoos.iterable.Joined Java Examples

/**
 * Make head.
 * @param origin Original response
 * @param status Status
 * @param reason Reason
 * @return Head
 * @throws IOException If fails
 */
private static Iterable<String> head(final Response origin,
    final int status, final CharSequence reason) throws IOException {
    // @checkstyle MagicNumber (1 line)
    if (status < 100 || status > 999) {
        throw new IllegalArgumentException(
            String.format(
                // @checkstyle LineLength (1 line)
                "according to RFC 7230 HTTP status code must have three digits: %d",
                status
            )
        );
    }
    return new Joined<>(
        new FormattedText(
            "HTTP/1.1 %d %s", status, reason
        ).asString(),
        new Filtered<>(
            item -> new Not(
                new StartsWith(item, "HTTP/")
            ).value(),
            origin.head()
        )
    );
}
 

@Override
public Response act(final Request req) {
    return new RsPage(
        req, "all",
        () -> new IterableOf<>(
            new XeAppend(
                "recent",
                new XeDirectives(
                    new Joined<>(
                        new Results().all()
                    )
                )
            )
        )
    );
}
 

@Override
public Response act(final Request req) {
    return new RsPage(
        req, "mistakes",
        () -> new IterableOf<>(
            new XeAppend(
                "worst",
                new XeDirectives(
                    new Joined<>(
                        new HeadOf<Iterable<Directive>>(
                            // @checkstyle MagicNumber (1 line)
                            20, new Mistakes().worst()
                        )
                    )
                )
            )
        )
    );
}
 

@Test
public void behaveAsSetMergedCollectionsOfLiteralsWithDuplicates() {
    new Assertion<>(
        "Must keep unique string literals",
        new SetOf<String>(
            new Joined<String>(
                new IterableOf<>("cc", "ff"),
                new IterableOf<>("aa", "bb", "cc", "dd")
            )
        ),
        new AllOf<>(
            new IterableOf<Matcher<? super SetOf<String>>>(
                new HasSize(5),
                new IsCollectionContaining<>(new IsEqual<>("aa")),
                new IsCollectionContaining<>(new IsEqual<>("bb")),
                new IsCollectionContaining<>(new IsEqual<>("cc")),
                new IsCollectionContaining<>(new IsEqual<>("dd")),
                new IsCollectionContaining<>(new IsEqual<>("ff"))
            )
        )
    ).affirm();
}
 

/**
 * Ctor.
 * @param rsp Response
 */
public HtCookies(final Input rsp) {
    super(() -> new Grouped<>(
        new Mapped<>(
            (Text entry) -> {
                final Iterable<Text> parts = new Split(entry, "=");
                if (new LengthOf(parts).intValue() != 2) {
                    throw new IllegalArgumentException(
                        "Incorrect HTTP Response cookie"
                    );
                }
                final Iterator<Text> iter = parts.iterator();
                return new MapEntry<>(
                    iter.next().asString(),
                    iter.next().asString()
                );
            },
            new Joined<>(
                new Mapped<>(
                    e -> new Split(e, ";\\s+"),
                    new HtHeaders(rsp).get("set-cookie")
                )
            )
        ),
        MapEntry::getKey,
        MapEntry::getValue
    ));
}
 

@Override
public Response act(final Request req) {
    return new RsPage(
        req, "index",
        () -> new IterableOf<>(
            new XeAppend(
                "best",
                new XeDirectives(
                    new Joined<>(
                        new HeadOf<>(
                            // @checkstyle MagicNumber (1 line)
                            20, new Results().best()
                        )
                    )
                )
            ),
            new XeAppend(
                "recent",
                new XeDirectives(
                    new Joined<>(
                        new HeadOf<>(
                            // @checkstyle MagicNumber (1 line)
                            25, new Results().recent()
                        )
                    )
                )
            )
        )
    );
}
 

/**
 * Ctor.
 * @param src Map to extend
 * @param list List of the entries
 * @since 0.12
 */
@SuppressWarnings("unchecked")
public MapOf(final Map<X, Y> src,
    final Iterable<Map.Entry<X, Y>> list) {
    this(
        new Joined<>(
            src.entrySet(), list
        )
    );
}
 

/**
 * Ctor.
 * @param uri Request uri
 * @param client Http client
 * @param parameters Parameters
 */
public ApacheWire(
    final String uri,
    final ApacheClient client,
    final Iterable<DictInput> parameters
) {
    this(
        client,
        new Joined<DictInput>(new RequestUri(uri), parameters)
    );
}
 

/**
 * Ctor.
 * @param uri Uri
 * @param method Http method
 * @param inputs Inputs
 */
public Request(
    final String uri, final String method, final Iterable<DictInput> inputs
) {
    super(
        () -> new DictOf(
            new Joined<DictInput>(
                new IterableOf<>(
                    new Path(uri), new Method(method)
                ),
                inputs
            )
        )
    );
}
 

/**
 * Ctor.
 * @param status Status
 * @param additional Additional statuses
 */
public ExpectedStatus(final Integer status, final Integer... additional) {
    this(
        new Joined<>(status, new IterableOf<>(additional)), new TextOf("")
    );
}
 

@Override
public Iterable<Path> files() throws IOException {
    return new Joined<Path>(this.left.files(), this.right.files());
}
 

/**
 * Ctor.
 * @param matches Matches
 */
public GetMatch(final Iterable<MatchingCriteria> matches) {
    super(new Joined<>(new MethodMatch(new IsEqual<>("GET")), matches));
}
 

/**
 * Ctor.
 * @param arg Required argument
 * @param src The numbers
 */
public MultiplicationOf(final Number arg, final Number... src) {
    this(new Joined<>(arg, new IterableOf<>(src)));
}
 

/**
 * Ctor.
 * @param dicts Dictionaries
 */
public JoinedDict(final Dict... dicts) {
    super(() -> new HashDict(new Joined<>(dicts)));
}
 

/**
 * Ctor.
 * @param matches Matches
 */
public PutMatch(final Iterable<MatchingCriteria> matches) {
    super(new Joined<>(new MethodMatch(new IsEqual<>("PUT")), matches));
}
 

/**
 * Ctor.
 * @param matches Matches
 */
public DeleteMatch(final Iterable<MatchingCriteria> matches) {
    super(new Joined<>(new MethodMatch(new IsEqual<>("DELETE")), matches));
}
 

/**
 * Ctor.
 * @param matches Matches
 */
public PostMatch(final Iterable<MatchingCriteria> matches) {
    super(new Joined<>(new MethodMatch(new IsEqual<>("POST")), matches));
}