org.cactoos.Text Java Examples

@Override
public void visitMethodInsn(final int opcode,
    final String owner, final String mtd,
    final String dsc, final boolean itf) {
    super.visitMethodInsn(opcode, owner, mtd, dsc, itf);
    this.target.strict(1).addIf("ops").add("op");
    this.target
        .attr("code", "call")
        .add("name")
        .set(owner.replace("/", ".").concat(".").concat(mtd))
        .up().add("args");
    final Iterable<Text> args = new Split(
        new Sub(dsc, dsc.indexOf('(') + 1, dsc.indexOf(')')),
        ";"
    );
    for (final Text arg : args) {
        this.target.add("arg").attr("type", arg).set("?").up();
    }
    this.target.up().up().up();
}
 

/**
 * New formatted string with specified locale.
 *
 * @param ptn Pattern
 * @param locale Format locale
 * @param args Arguments
 */
public FormattedText(
    final Text ptn,
    final Locale locale,
    final Collection<Object> args
) {
    super(new Scalar<String>() {
        @Override
        public String value() throws Exception {
            final StringBuilder out = new StringBuilder(0);
            try (Formatter fmt = new Formatter(out, locale)) {
                fmt.format(
                    ptn.asString(),
                    args.toArray()
                );
            }
            return out.toString();
        }
    });
}
 

@Override
public boolean matchesSafely(final T item) {
    try {
        final Iterator<String> headers = HmHeader.headers(item).iterator();
        final Collection<String> values = new ArrayList<>(0);
        while (headers.hasNext()) {
            final String[] parts = HmHeader.split(headers.next());
            final UncheckedText first = new UncheckedText(
                new Trimmed(new TextOf(parts[0]))
            );
            if (this.header.matches(first.asString())) {
                final Text second = new Trimmed(new TextOf(parts[1]));
                values.add(new UncheckedText(second).asString());
            }
        }
        final boolean result = this.value.matches(values);
        if (!result) {
            this.failed = values;
        }
        return result;
    } catch (final IOException ex) {
        throw new IllegalStateException(ex);
    }
}
 

/**
 * Ctor.
 * @param text The text
 */
public NoNulls(final Text text) {
    super(new Scalar<String>() {
        @Override
        public String value() throws Exception {
            if (text == null) {
                throw new IllegalArgumentException(
                    "NULL instead of a valid text"
                );
            }
            final String string = text.asString();
            if (string == null) {
                throw new IllegalStateException(
                    "NULL instead of a valid result string"
                );
            }
            return string;
        }
    });
}
 

/**
 * Ctor.
 * Creates new folder in temporary directory.
 * @param path Relative path to new directory.
 * @since 1.0
 */
public TempFolder(final Text path) {
    this(
        new Sticky<>(
            () -> Files.createDirectory(
                Paths.get(
                    new Joined(
                        File.separator,
                        System.getProperty("java.io.tmpdir"),
                        path.asString()
                    ).asString()
                )
            )
        )
    );
}
 

/**
 * Ctor.
 * @param text Number-text
 */
public NumberOf(final Text text) {
    this.envelope = new Sealed(
        new Sticky<>(
            () -> Long.parseLong(text.asString())
        ),
        new Sticky<>(
            () -> Integer.parseInt(text.asString())
        ),
        new Sticky<>(
            () -> Float.parseFloat(text.asString())
        ),
        new Sticky<>(
            () -> Double.parseDouble(text.asString())
        )
    );
}
 

/**
 * Ctor.
 * @param text The Text
 * @param max Max width of the result string
 */
@SuppressWarnings({
    "PMD.CallSuperInConstructor",
    "PMD.ConstructorOnlyInitializesOrCallOtherConstructors"
    })
public Abbreviated(final Text text, final int max) {
    super((Scalar<String>) () -> {
        final Text abbreviated;
        if (text.asString().length() <= max) {
            abbreviated = text;
        } else {
            abbreviated = new FormattedText(
                "%s...",
                new Sub(
                    text,
                    0,
                    max - Abbreviated.ELLIPSES_WIDTH
                ).asString()
            );
        }
        return abbreviated.asString();
    });
}
 

/**
 * Ctor.
 * @param text Text to parse
 * @return List of media types
 */
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
private static SortedSet<MediaType> parse(final String text) {
    final SortedSet<MediaType> list = new TreeSet<>();
    final Iterable<Text> parts = new Split(
        new UncheckedText(new Lowered(text)),
        ","
    );
    for (final Text part : parts) {
        final String name = new UncheckedText(part).asString();
        if (!name.isEmpty()) {
            list.add(new MediaType(name));
        }
    }
    return list;
}
 

/**
 * Ctor.
 * @param head Response head part
 */
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
public HtHeaders(final Input head) {
    super(() -> {
        final Map<String, List<String>> map = new HashMap<>();
        final ListOf<Text> texts = new ListOf<>(
            new Split(new TextOf(head), "\r\n")
        );
        for (final Text line : texts.subList(1, texts.size())) {
            final String[] parts = line.asString().split(":", 2);
            map.merge(
                new Lowered(
                    new Trimmed(new TextOf(parts[0])), Locale.ENGLISH
                ).asString(),
                new ListOf<>(
                    new Trimmed(new TextOf(parts[1])).asString()
                ),
                (first, second) -> new Joined<String>(first, second)
            );
        }
        return map;
    });
}
 

/**
 * Ctor.
 * @param text The text
 * @param shift The shift
 */
@SuppressWarnings({"PMD.CallSuperInConstructor",
    "PMD.ConstructorOnlyInitializesOrCallOtherConstructors"})
public Rotated(final Text text, final int shift) {
    super((Scalar<String>) () -> {
        String origin = text.asString();
        final int length = origin.length();
        if (length != 0 && shift != 0 && shift % length != 0) {
            final StringBuilder builder = new StringBuilder(length);
            int offset = -(shift % length);
            if (offset < 0) {
                offset = origin.length() + offset;
            }
            origin = builder.append(
                origin.substring(offset)
            ).append(
                origin.substring(0, offset)
            ).toString();
        }
        return origin;
    });
}
 

/**
 * RsXSLT can load XSL stylesheets from the web.
 * @throws IOException If some problem inside
 */
@Test
public void loadsExternalImports() throws IOException {
    final Text xml = new Joined(
        " ",
        "<?xml-stylesheet   ",
        " href='/org/takes/rs/stylesheet-with-include.xsl'",
        " type='text/xsl'?><page sla='0.324'/>"
    );
    MatcherAssert.assertThat(
        IOUtils.toString(
            new RsXslt(
                new RsText(new InputStreamOf(xml))
            ).body(),
            StandardCharsets.UTF_8
        ),
        XhtmlMatchers.hasXPath(
            "/xhtml:html/xhtml:span[starts-with(@class, 'sla ')]"
        )
    );
}
 

@Test
public void transformsList() throws Exception {
    MatcherAssert.assertThat(
        "Can't transform an iterable",
        new Mapped<String, Text>(
            input -> new Upper(new TextOf(input)),
            new IterableOf<>("hello", "world", "друг")
        ).iterator().next().asString(),
        new IsEqual<>("HELLO")
    );
}
 

/**
 * New formatted string with specified locale.
 *
 * @param ptn Pattern
 * @param locale Format locale
 * @param arguments Arguments
 */
public FormattedText(
    final Text ptn,
    final Locale locale,
    final Object... arguments
) {
    this(ptn, locale, new ListOf<>(arguments));
}
 

@Test
public void worksNormallyWhenNoExceptionIsThrown() throws Exception {
    final Text source = new TextOf("hello, cactoos!");
    new Assertion<>(
        "Must works normally when no exception is thrown",
        new UncheckedBytes(
            new BytesOf(source)
        ).asBytes(),
        Matchers.equalTo(
            new BytesOf(source).asBytes()
        )
    ).affirm();
}
 

/**
 * Ctor.
 * @param text A Text
 */
public Normalized(final Text text) {
    super(
        (Scalar<String>) () -> new Replaced(
            new Trimmed(text),
            "\\s+",
            " "
        ).asString()
    );
}
 

/**
 * RsXSLT closes decorated Response body's InputStream when XML conversion
 * is done.
 * @throws Exception If some problem inside
 */
@Test
public void closesDecoratedResponseInputStream() throws Exception {
    final Text xml = new Joined(
        " ",
        "<?xml-stylesheet href='/b.xsl' type='text/xsl'?>",
        "<subject>World</subject>"
    );
    final Text xsl =
        new Joined(
            " ",
            "<stylesheet xmlns='http://www.w3.org/1999/XSL/Transform'  ",
            " xmlns:x='http://www.w3.org/1999/xhtml' version='2.0'  >",
            "<output method='text'/><template match='/'> ",
            "Hello, <value-of select='/subject'/>!</template></stylesheet>"
        );
    final StateAwareInputStream stream = new StateAwareInputStream(
        new InputStreamOf(xml)
    );
    MatcherAssert.assertThat(
        new RsPrint(
            new RsXslt(
                new RsText(stream),
                (href, base) -> new StreamSource(new InputStreamOf(xsl))
            )
        ),
        new EndsWith("Hello, World!")
    );
    MatcherAssert.assertThat(
        stream.isClosed(),
        Matchers.is(true)
    );
}
 

@Test
public void transformsEmptyList() {
    MatcherAssert.assertThat(
        "Can't transform an empty iterable",
        new Mapped<String, Text>(
            input -> new Upper(new TextOf(input)),
            Collections.emptyList()
        ),
        Matchers.emptyIterable()
    );
}
 

/**
 * Ctor.
 * @param dir The directory in which to create the temp file
 * @param prefix The temp filename's prefix
 * @param suffix The temp filename's suffix
 * @since 1.0
 */
public TempFile(
    final Scalar<Path> dir,
    final Text prefix,
    final Text suffix) {
    this(
        new Sticky<>(
            () -> Files.createTempFile(
                dir.value(),
                prefix.asString(),
                suffix.asString()
            )
        )
    );
}
 

@Test
public void equalsToItself() {
    final Text text = new TextOf("text");
    new Assertion<>(
        "Does not equal to itself",
        text,
        new TextIs(text)
    ).affirm();
}
 

/**
 * Ctor.
 *
 * @param text The text
 */
public Reversed(final Text text) {
    super((Scalar<String>) () -> new StringBuilder(
        text.asString()
        ).reverse().toString()
    );
}
 

/**
 * Ctor.
 * @param predicate The Func as a predicate
 * @param origin The Text
 */
public Strict(final Func<String, Boolean> predicate, final Text origin) {
    super((Scalar<String>) () -> {
        final String str = origin.asString();
        if (!predicate.apply(str)) {
            throw new IllegalArgumentException(
                new FormattedText(
                    "String '%s' does not match a given predicate",
                    str
                ).asString()
            );
        }
        return str;
    });
}
 

/**
 * Ctor.
 * @param statuses Statuses
 * @param message Error message
 */
public ExpectedStatus(
    final Iterable<Integer> statuses, final Text message
) {
    this.statuses = statuses;
    this.message = new UncheckedText(message);
}
 

/**
 * Ctor.
 * @param text The Text
 * @param count How many times repeat the Text
 */
public Repeated(final Text text, final int count) {
    super((Scalar<String>) () -> {
        final StringBuilder out = new StringBuilder();
        for (int cnt = 0; cnt < count; ++cnt) {
            out.append(text.asString());
        }
        return out.toString();
    });
}
 

/**
 * Ctor.
 *
 * @param origin Origin text
 */
public Base64Decoded(final Text origin) {
    super(new TextOf(
        new Base64Bytes(
            new BytesOf(origin)
        )
    ));
}
 

@Test
public void splitTextWithStringRegexAndLimit() throws Exception {
    final Text txt = new TextOf("Cact!4Primitives");
    new Assertion<>(
        "Must split text with string regex and limit",
        new Split(txt, "4", 1),
        new IsEqual<>(new IterableOf<>(txt))
    ).affirm();
}
 

/**
 * Returns the low part of the media type.
 * @param text The media type text.
 * @return The low part of the media type.
 */
private static String lowPart(final String text) {
    final String[] sectors = MediaType.sectors(text);
    final Text sector;
    if (sectors.length > 1) {
        sector = new Trimmed(new TextOf(sectors[1]));
    } else {
        sector = new TextOf("");
    }
    return new UncheckedText(sector).asString();
}
 

/**
 * Ctor.
 * @param text The text
 * @param rgx The regex
 * @param lmt The limit
 * @see String#split(String, int)
 */
public Split(final UncheckedText text, final UncheckedText rgx, final int lmt) {
    super(
        new Mapped<String, Text>(
            TextOf::new,
            new IterableOf<>(
                text.asString().split(rgx.asString(), lmt)
            )
        )
    );
}
 

/**
 * Ctor.
 * @param text The text
 * @param length The minimum length of the resulting string
 * @param symbol The padding symbol
 */
public PaddedStart(
    final Text text, final int length, final char symbol) {
    super((Scalar<String>) () -> {
        final String original = text.asString();
        return new Joined(
            new TextOf(""),
            new Repeated(
                new TextOf(symbol), length - original.length()
            ),
            text
        ).asString();
    });
}
 

@Test
public void asBytes() throws Exception {
    final Text text = new TextOf("Hello!");
    new Assertion<>(
        "Can't convert text into bytes",
        new BytesOf(
            new InputOf(text)
        ).asBytes(),
        new IsEqual<>(
            new BytesOf(text.asString()).asBytes()
        )
    ).affirm();
}
 

@Override
public Href href() throws IOException {
    final String uri = new RqRequestLine.Base(this).uri();
    final Iterator<String> hosts = new RqHeaders.Base(this)
        .header("host").iterator();
    final Iterator<String> protos = new RqHeaders.Base(this)
        .header("x-forwarded-proto").iterator();
    final Text host;
    if (hosts.hasNext()) {
        host = new Trimmed(new TextOf(hosts.next()));
    } else {
        host = new TextOf("localhost");
    }
    final Text proto;
    if (protos.hasNext()) {
        proto = new Trimmed(new TextOf(protos.next()));
    } else {
        proto = new TextOf("http");
    }
    return new Href(
        String.format(
            "%s://%s%s",
            new UncheckedText(proto).asString(),
            new UncheckedText(host).asString(),
            uri
        )
    );
}