public static String remove(String path) {
    final Deque<CharSequence> segments = new ArrayDeque<CharSequence>();
    segment.findMatches(path).replace(notMatched -> {
        segments.add(notMatched);
        return null;
    }, match -> {
        switch (match.group(1)) {
            case ".":
                return null;
            case "..":
                if (!segments.isEmpty()) segments.removeLast();
                break;
            default:
                segments.add(match.group());
                break;
        }
        return null;
    });
    return Sequences.toString(segments, "");
}
 

public CompletionResult call(String expression) throws Exception {
    final int lastSeparator = lastIndexOfSeparator(characters(" "), expression) + 1;
    final String packagePart = expression.substring(lastSeparator);

    Option<Pair<Class<?>, String>> completion = completionFor(packagePart);

    if (!completion.isEmpty()) {
        Function1<CompletionCandidate, String> value = CompletionCandidate::value;
        Sequence<CompletionCandidate> candidates = reflectionOf(completion.get().first())
                .declaredMembers()
                .filter(isStatic().and(isPublic()).and(not(isSynthetic())))
                .groupBy(candidateName())
                .map(candidate())
                .filter(where(value, startsWith(completion.get().second())));

        final int beginIndex = packagePart.lastIndexOf('.') + 1;
        return new CompletionResult(expression, lastSeparator + beginIndex, candidates);
    } else {
        return new CompletionResult(expression, 0, Sequences.empty(CompletionCandidate.class));
    }
}
 

public static Sequence<Class<? extends Command>> defaultCommands() {
    return Sequences.<Class<? extends Command>>sequence()
            .append(ClearScreen.class)
            .append(QuitApplication.class)
            .append(ShowHistory.class)
            .append(SearchHistory.class)
            .append(EvaluateFromHistory.class)
            .append(ResetAllEvaluations.class)
            .append(ReplayAllEvaluations.class)
            .append(EvaluateFile.class)
            .append(AddToClasspath.class)
            .append(LoadSourceFile.class)
            .append(ListValues.class)
            .append(ShowLastSource.class)
            .append(ShowTypeOfExpression.class)
            .append(CheckExpression.class);
}
 

@Test
public void rendersTemplateForMethod() {
    assertThat(renderExpressionClass(evaluationContext(), "AClass", new Method("someMethod", Object.class, "someMethodName", Sequences.<Class<?>>empty())), is(new StringBuilder()
            .append("import java.lang.*;\n")
            .append("import java.util.*;\n")
            .append("import java.math.*;\n")
            .append("import static java.lang.Math.*;\n")
            .append("import java.util.function.*;\n")
            .append("public final class AClass extends javarepl.EvaluationTemplate {\n")
            .append("  public AClass(javarepl.EvaluationContext context) { super(context); }\n")
            .append("  $JAVAREPL_EXPRESSION_TOKEN$\n")
            .append("\n")
            .append("  public void evaluate() throws Exception {\n")
            .append("  }\n")
            .append("}")
            .toString()));
}
 

public Iterable<SequenceDiagramMessage> messages(CapturedInputAndOutputs inputAndOutputs) {
    Sequence<SequenceDiagramMessage> result = Sequences.empty();
    Set<String> keys = inputAndOutputs.getTypes().keySet();
    for (String key : keys) {
        Matcher matcher = pattern.matcher(key);
        if (matcher.matches()) {
            final String what = matcher.group(1).trim();
            final String from = matcher.group(2).trim();
            final String to = matcher.group(3).trim();
            result = result.append(new SequenceDiagramMessage(from, to, what, key.replaceAll(" ","_").replaceAll("\\(","_").replaceAll("\\)","_")));
        }
    }
    return result;
}
 

public static <T> LogicalPredicate<T> and(Iterable<? extends Predicate<? super T>> predicates) {
    Sequence<Predicate<T>> sequence = Sequences.sequence(predicates).<Predicate<T>>unsafeCast().
            flatMap(AndPredicate.<T>asPredicates());
    if (sequence.exists(instanceOf(AlwaysFalse.class))) return Predicates.alwaysFalse();

    Sequence<Predicate<T>> collapsed = sequence.
            filter(instanceOf(AlwaysTrue.class).not());
    if (collapsed.isEmpty()) return Predicates.alwaysTrue();
    if (collapsed.size() == 1) return logicalPredicate(collapsed.head());
    if (collapsed.forAll(instanceOf(Not.class)))
        return Predicates.not(Predicates.<T>or(sequence.<Not<T>>unsafeCast().map(Not.functions.<T>predicate())));
    return new AndPredicate<T>(collapsed);
}
 

public static <T> LogicalPredicate<T> or(Iterable<? extends Predicate<? super T>> predicates) {
    Sequence<Predicate<T>> sequence = Sequences.sequence(predicates).<Predicate<T>>unsafeCast().
            flatMap(OrPredicate.<T>asPredicates());
    if (sequence.exists(instanceOf(AlwaysTrue.class))) return Predicates.alwaysTrue();

    Sequence<Predicate<T>> collapsed = sequence.
            filter(instanceOf(AlwaysFalse.class).not());
    if (collapsed.isEmpty()) return Predicates.alwaysFalse();
    if (collapsed.size() == 1) return logicalPredicate(collapsed.head());
    if (collapsed.forAll(instanceOf(Not.class)))
        return Predicates.not(Predicates.<T>and(sequence.<Not<T>>unsafeCast().map(Not.functions.<T>predicate())));
    return new OrPredicate<T>(sequence);
}
 

@Override
default Receiver<T> apply(Receiver<Group<K, T>> receiver) {
    return new Receiver<T>() {
        private final Map<K, Group<K, T>> groups = new ConcurrentHashMap<>();

        @Override
        public State start() {
            receivers().each(Receiver::start);
            return receiver.start();
        }

        @Override
        public State next(T item) {
            groups.computeIfAbsent(keyExtractor().apply(item), k -> {
                Group<K, T> group = new Group<>(k);
                receiver.next(group);
                return group;
            }).next(item);
            return State.Continue;
        }

        @Override
        public State error(Throwable throwable) {
            receivers().each(o -> o.error(throwable));
            return receiver.error(throwable);
        }

        @Override
        public void finish() {
            receivers().each(Receiver::finish);
            receiver.finish();
        }

        private Sequence<Receiver<T>> receivers() {
            return Sequences.sequence(groups.values());
        }
    };
}
 

private static Sequence<Node> internalSelectNodes(final Node node, final String expression) {
    try {
        return sequence((NodeList) xpathExpression(expression).evaluate(node, XPathConstants.NODESET));
    } catch (XPathExpressionException e) {
        try {
            String nodeAsString = (String) xpathExpression(expression).evaluate(node, XPathConstants.STRING);
            return Sequences.<Node>sequence(documentFor(node).createTextNode(nodeAsString));
        } catch (XPathExpressionException ignore) {
            throw new IllegalArgumentException(String.format("Failed to compile xpath '%s'", expression), e);
        }
    }
}
 

/**
 * Test case for issue #14
 */
@Test
public void supportsShort() {
    assertThat(numbers((short)0, (short)0 ,(short)1).reduceLeft(Numbers.maximum), NumberMatcher.is((short) 1));

    Sequence<Short> s = Sequences.sequence((short)0, (short)0 ,(short)1);
    Number result = s.reduceLeft(Numbers.maximum());
    assertEquals(Short.class, result.getClass());
    assertThat(result, NumberMatcher.is(Short.valueOf((short) 1)));
}
 

public Sequence<String> history() {
    createProcess();

    try {
        return new JavaREPLClient("localhost", port.get()).history();
    } catch (Exception e) {
        e.printStackTrace();
        return Sequences.empty();
    }
}
 

private Option<Pair<Class<?>, String>> completionFor(String expression) {
    Option<Pair<String, Sequence<String>>> parsedClass = parseExpression(pair(expression, Sequences.empty(String.class)));

    if (!parsedClass.isEmpty() && !parsedClass.get().second().isEmpty()) {
        return some(Pair.<Class<?>, String>pair(
                evaluator.classFrom(parsedClass.get().first()).get(),
                parsedClass.get().second().toString(".").trim()));
    } else {
        return none();
    }
}
 

public static CompletionResult fromJson(String json) {
    Map<String, Object> jsonMap = map(Json.map(json));

    Sequence<Map<String, Object>> candidates = CANDIDATES.map(Sequences::sequence).apply(jsonMap);

    return new CompletionResult(
            EXPRESSION.apply(jsonMap),
            POSITION.map(Integer::valueOf).apply(jsonMap),
            candidates.map(candidate -> new CompletionCandidate(VALUE.apply(candidate), FORMS.map(Sequences::sequence).apply(candidate)))
    );
}
 

public CompletionResult call(String expression) throws Exception {
    final int lastSeparator = lastIndexOfSeparator(characters(" "), expression) + 1;
    final String packagePart = expression.substring(lastSeparator);
    final Boolean canComplete = packagePart.matches("[a-zA-Z0-9\\$_\\\\.\\(\\[\\]]*") && packagePart.contains(".");

    final int beginIndex = packagePart.lastIndexOf('.') + 1;
    Option<Class<?>> aClass = canComplete
            ? evaluator.typeOfExpression(packagePart.substring(0, beginIndex - 1)).map(Types::classOf)
            : none();

    if (aClass.isDefined()) {
        ClassReflection classReflection = reflectionOf(aClass.get());

        Sequence<MemberReflection<?>> join = Sequences.empty()
                .join(classReflection.declaredFields())
                .join(classReflection.declaredMethods())
                .unique()
                .unsafeCast();

        Sequence<CompletionCandidate> candidates = join
                .filter(isPublic().and(not(isStatic())))
                .groupBy(candidateName())
                .map(candidate())
                .filter(where(CompletionCandidate::value, startsWith(packagePart.substring(beginIndex))));

        return new CompletionResult(expression, lastSeparator + beginIndex, candidates);
    } else {
        return new CompletionResult(expression, 0, Sequences.empty(CompletionCandidate.class));
    }
}
 

public Option<String> readExpression() {
    Sequence<String> lines = Sequences.empty();

    do {
        lines = lines.append(lineReader.apply(lines));
    } while (!expressionIsTerminated(lines));

    return lines.contains(null)
            ? none(String.class)
            : some(lines.toString("\n").trim());
}
 

public Option<String> readExpression(String line) {
    lines = lines.append(line);
    if (expressionIsTerminated(lines)) {
        Option<String> result = some(lines.toString("\n"));
        lines = Sequences.empty();
        return result;
    } else {
        return none();
    }
}
 

public synchronized Option<EvaluationResult> execute(String expr) throws Exception {
    String json = client.handle(post(url("execute")).form("expression", expr)).entity().toString();

    if (json.isEmpty())
        return none();

    Map<String, Object> response = map(json);
    Sequence<Map<String, Object>> logs = LOGS.map(Sequences::sequence).call(response);
    String expression = EXPRESSION.call(response);

    return some(new EvaluationResult(expression, logs.map(modelToEvaluationLog())));
}
 

@Test
public void rendersPreviousResultsMethodsAndImports() {
    EvaluationContext context = evaluationContext()
            .addResult(result("result1", "value1"))
            .addResult(result("result2", "value2"))
            .addExpression(new Import("import java.net.URL", "java.net.URL"))
            .addExpression(new Import("import java.io.File;", "java.io.File"))
            .addExpression(new Method("int method1(int i){\nreturn i;\n}", int.class, "method1", Sequences.<Class<?>>sequence(int.class)))
            .addExpression(new Method("char method1(char i){\nreturn i;\n}", char.class, "method2", Sequences.<Class<?>>sequence(char.class)));

    assertThat(renderExpressionClass(context, "AClass", new Statement("someStatement")), is(new StringBuilder()
            .append("import java.lang.*;\n")
            .append("import java.util.*;\n")
            .append("import java.math.*;\n")
            .append("import static java.lang.Math.*;\n")
            .append("import java.util.function.*;\n")
            .append("import java.net.URL;\n")
            .append("import java.io.File;;\n")
            .append("public final class AClass extends javarepl.EvaluationTemplate {\n")
            .append("  public AClass(javarepl.EvaluationContext context) { super(context); }\n")
            .append("  public java.lang.String result1 = valueOf(\"result1\");\n")
            .append("  public java.lang.String result2 = valueOf(\"result2\");\n")
            .append("  int method1(int i){\n")
            .append("  return i;\n")
            .append("  }\n")
            .append("\n")
            .append("  char method1(char i){\n")
            .append("  return i;\n")
            .append("  }\n")
            .append("  public void evaluate() throws Exception {\n")
            .append("    $JAVAREPL_EXPRESSION_TOKEN$;\n")
            .append("  }\n")
            .append("}")
            .toString()));
}
 

public Iterable<String> tags(TestMethod testMethod) {
    return notes(testMethod.getAnnotations())
            .map(notesToTags())
            .getOrElse(Sequences.<String>empty());
}
 

@Test
public void loggerShouldHandleNamingForMultiThreadCalls() {
    final TestState state = new TestState();
    sequence(Sequences.repeat(pair("logTitle", "content")).take(1000)).mapConcurrently(log(state), newFixedThreadPool(1000)).realise();
    assertThat(state.capturedInputAndOutputs.getTypes().size(), is(1000));
}
 

static <A> ListParser<A> list(final Iterable<? extends Parser<? extends A>> parsers) {
    return new ListParser<A>(Sequences.sequence(parsers));
}
 

static Parser<String> string(Iterable<? extends Predicate<? super Character>> predicates) {
    return new PredicatesParser(Sequences.sequence(predicates));
}
 

@SafeVarargs
static Parser<String> string(Predicate<? super Character>... predicates) {
    return new PredicatesParser(Sequences.sequence(predicates));
}
 

default Parser<List<A>> times(int number) {
    return Parsers.list(Sequences.repeat(this).take(number));
}
 

static <A> OrParser<A> or(Iterable<? extends Parser<? extends A>> parsers) {
    return new OrParser<A>(Sequences.sequence(parsers).<Parser<A>>unsafeCast());
}
 

public static <T> Matcher<Iterable<T>> isEmpty() {
    return IterableMatcher.<T>hasExactly(Sequences.<T>empty());
}
 

public static <T> AllOfValidator<T> allOf(Validator<? super T> first, Validator<? super T> second) {
    return allOf(Sequences.<Validator<? super T>>sequence(first, second));
}
 

public static <T> AllOfValidator<T> allOf(Validator<? super T> first, Validator<? super T> second, Validator<? super T> third) {
    return allOf(Sequences.<Validator<? super T>>sequence(first, second, third));
}
 

public static <T> AllOfValidator<T> allOf(Validator<? super T> first, Validator<? super T> second, Validator<? super T> third, Validator<? super T> fourth) {
    return allOf(Sequences.<Validator<? super T>>sequence(first, second, third, fourth));
}
 

public static <T> AllOfValidator<T> allOf(Validator<? super T> first, Validator<? super T> second, Validator<? super T> third, Validator<? super T> fourth, Validator<? super T> fifth) {
    return allOf(Sequences.<Validator<? super T>>sequence(first, second, third, fourth, fifth));
}