private static <T> void handle(Class<T> commandClass, String line) throws Exception { ObjectCommandDescriptor<T> descriptor = CommandFactory.DEFAULT.create(commandClass); HelpDescriptor<Instance<T>> helpDescriptor = HelpDescriptor.create(descriptor); InvocationMatcher<Instance<T>> matcher = helpDescriptor.matcher(); InvocationMatch<Instance<T>> match = matcher.parse(line); final T instance = commandClass.newInstance(); Object o = match.invoke(Util.wrap(instance)); if (o != null) { System.out.println(o); } } }
public static void main(String[] args) throws Exception { StringBuilder line = new StringBuilder(); for (int i = 0;i < args.length;i++) { if (i > 0) { line.append(' '); } Delimiter.EMPTY.escape(args[i], line); } // CRaSH main = new CRaSH(); InvocationMatcher<Instance<CRaSH>> matcher = main.descriptor.matcher(); InvocationMatch<Instance<CRaSH>> match = matcher.parse(line.toString()); match.invoke(Util.wrap(main)); } }
@Override public void run() { try { CommandDescriptor<Instance<Agent>> c = CommandFactory.DEFAULT.create(Agent.class); InvocationMatcher<Instance<Agent>> matcher = c.matcher(); InvocationMatch<Instance<Agent>> match = matcher.parse(agentArgs); match.invoke(Util.wrap(new Agent(inst))); } catch (Exception e) { e.printStackTrace(); } } };
public void testBooleanParameter() throws Exception { class A implements Runnable { @Option(names = "o") boolean o; public void run() {} } CommandDescriptor<Instance<A>> desc = CommandFactory.DEFAULT.create(A.class); InvocationMatcher<Instance<A>> analyzer = desc.matcher(); // A a = new A(); analyzer.parse("-o").invoke(Util.wrap(a)); assertEquals(true, a.o); a = new A(); analyzer.option("o", Collections.singletonList(true)).arguments(Collections.emptyList()).invoke(Util.wrap(a)); assertEquals(true, a.o); }
@Override List<String> invoke(String line) throws Exception { BC2 object = new BC2(); desc2.matcher().parse(line).invoke(Util.wrap(object)); return object.s; } };
@Override List<String> invoke(String line) throws Exception { BC1 object = new BC1(); desc1.matcher().parse(line).invoke(Util.wrap(object)); return object.s; } };
public void testImplicitSubordinateOption() throws Exception { CommandDescriptor<Instance<M>> desc = CommandFactory.DEFAULT.create(M.class); M m = new M(); desc.matcher().parse("-o foo").invoke(Util.wrap(m)); assertEquals("foo", m.opt); m = new M(); desc.matcher().option("o", Collections.singletonList("foo")).arguments(Collections.emptyList()).invoke(Util.wrap(m)); assertEquals("foo", m.opt); }
public void testOptionList() throws Exception { CommandDescriptor<Instance<F>> desc = CommandFactory.DEFAULT.create(F.class); // F f = new F(); desc.matcher().parse("foo -o a").invoke(Util.wrap(f)); assertEquals(Arrays.asList("a"), f.s); f = new F(); desc.matcher().subordinate("foo").option("o", Collections.singletonList("a")).arguments(Collections.emptyList()).invoke(Util.wrap(f)); assertEquals(Arrays.asList("a"), f.s); // f = new F(); desc.matcher().parse("foo -o a -o b").invoke(Util.wrap(f)); assertEquals(Arrays.asList("a", "b"), f.s); f = new F(); desc.matcher().subordinate("foo").option("o", Arrays.asList("a", "b")).arguments(Collections.emptyList()).invoke(Util.wrap(f)); assertEquals(Arrays.asList("a", "b"), f.s); }
public void testSpecifySubordinateOptionAfterSubordinate() throws Exception { CommandDescriptor<Instance<L>> desc = CommandFactory.DEFAULT.create(L.class); L l = new L(); desc.matcher().parse("cmd -o foo").invoke(Util.wrap(l)); assertEquals("foo", l.opt); l = new L(); desc.matcher().subordinate("cmd").option("o", Collections.singletonList("foo")).arguments(Collections.emptyList()).invoke(Util.wrap(l)); assertEquals("foo", l.opt); }
public void testSpecifyClassOptionAfterSubordinate() throws Exception { CommandDescriptor<Instance<K>> desc = CommandFactory.DEFAULT.create(K.class); K k = new K(); desc.matcher().parse("cmd -o foo").invoke(Util.wrap(k)); assertEquals(null, k.opt); k = new K(); desc.matcher().subordinate("cmd").option("o", Collections.singletonList("foo")).arguments(Collections.emptyList()).invoke(Util.wrap(k)); assertEquals(null, k.opt); }
public void testMainMethodInvocation() throws Exception { CommandDescriptor<Instance<B>> desc = CommandFactory.DEFAULT.create(B.class); // B b = new B(); desc.matcher().parse("").invoke(Util.wrap(b)); assertEquals(1, b.count); b = new B(); desc.matcher().arguments(Collections.emptyList()).invoke(Util.wrap(b)); assertEquals(1, b.count); }
public void testOptionalClassOption() throws Exception { class A implements Runnable { @Option(names = "o") String s; public void run() {} } CommandDescriptor<Instance<A>> desc = CommandFactory.DEFAULT.create(A.class); InvocationMatcher<Instance<A>> analyzer = desc.matcher(); A a = new A(); analyzer.parse("-o foo").invoke(Util.wrap(a)); assertEquals("foo", a.s); a = new A(); analyzer.parse("").invoke(Util.wrap(a)); assertEquals(null, a.s); }
public void testSpecifyClassOptionBeforeSubordinate() throws Exception { CommandDescriptor<Instance<K>> desc = CommandFactory.DEFAULT.create(K.class); K k = new K(); desc.matcher().parse("-o foo cmd").invoke(Util.wrap(k)); assertEquals("foo", k.opt); k = new K(); desc.matcher().option("o", Collections.singletonList("foo")).subordinate("cmd").arguments(Collections.emptyList()).invoke(Util.wrap(k)); assertEquals("foo", k.opt); }
public void testSpecifySubordinateOptionBeforeSubordinate() throws Exception { CommandDescriptor<Instance<L>> desc = CommandFactory.DEFAULT.create(L.class); L l = new L(); desc.matcher().parse("-o foo cmd").invoke(Util.wrap(l)); assertEquals(null, l.opt); l = new L(); desc.matcher().option("o", Collections.singletonList("foo")).subordinate("cmd").arguments(Collections.emptyList()).invoke(Util.wrap(l)); assertEquals(null, l.opt); }
public void testError() throws Exception { CommandDescriptor<Instance<J>> desc = CommandFactory.DEFAULT.create(J.class); // J j = new J(); InvocationMatch<Instance<J>> matcher = desc.matcher().parse("foo"); try { matcher.invoke(Util.wrap(j)); fail(); } catch (Error e) { assertEquals("fooerror", e.getMessage()); } }
public void testValue() throws Exception { // CommandDescriptor<Instance<G>> desc = new CommandFactory(MatcherTestCase.class.getClassLoader()).create(G.class); // G g = new G(); desc.matcher().parse("foo -o a").invoke(Util.wrap(g)); assertEquals(new Custom("a"), g.o); g = new G(); desc.matcher().subordinate("foo").option("o", Collections.singletonList("a")).arguments(Collections.emptyList()).invoke(Util.wrap(g)); assertEquals(new Custom("a"), g.o); }
public void testInvocationTypeConversionInjection() throws Exception { CommandDescriptor<Instance<D>> desc = CommandFactory.DEFAULT.create(D.class); // D d = new D(); desc.matcher().parse("a -o 5").invoke(Util.wrap(d)); assertEquals((Integer)5, d.i); // d = new D(); desc.matcher().parse("b -o 5").invoke(Util.wrap(d)); assertEquals((Integer)5, d.i); }
public void testQuoted() throws Exception { CommandDescriptor<Instance<E>> desc = CommandFactory.DEFAULT.create(E.class); // E e = new E(); desc.matcher().parse("a -o a").invoke(Util.wrap(e)); assertEquals("a", e.i); // e = new E(); desc.matcher().parse("a -o \"a\"").invoke(Util.wrap(e)); assertEquals("\"a\"", e.i); }
public void testException() throws Exception { CommandDescriptor<Instance<H>> desc = CommandFactory.DEFAULT.create(H.class); // H h = new H(); InvocationMatch<Instance<H>> matcher = desc.matcher().parse("foo"); try { matcher.invoke(Util.wrap(h)); fail(); } catch (CLIException e) { assertEquals(Exception.class, e.getCause().getClass()); assertEquals("fooexception", e.getCause().getMessage()); } }
public void testRuntimeException() throws Exception { CommandDescriptor<Instance<I>> desc = CommandFactory.DEFAULT.create(I.class); // I i = new I(); InvocationMatch<Instance<I>> matcher = desc.matcher().parse("foo"); try { matcher.invoke(Util.wrap(i)); fail(); } catch (CLIException e) { assertEquals(RuntimeException.class, e.getCause().getClass()); assertEquals("fooruntimeexception", e.getCause().getMessage()); } }