@Override public String parse( Args parsedArgs ) { return parsedArgs.orphans().get( position ); } }
private void validate() throws IncorrectUsage { for ( String o : parsedArgs.asMap().keySet() ) { if ( !namedArgs.containsKey( o ) ) { throw new IncorrectUsage( format( "unrecognized option: '%s'", o ) ); } } long mandatoryPositionalArgs = positionalArgs.stream() .filter( o -> o instanceof MandatoryPositionalArgument ) .count(); if ( parsedArgs.orphans().size() < mandatoryPositionalArgs ) { throw new IncorrectUsage( "not enough arguments" ); } String excessArgs = parsedArgs.orphans().stream() .skip( positionalArgs.size() ) .collect( Collectors.joining( " " ) ); if ( !excessArgs.isEmpty() ) { throw new IncorrectUsage( format( "unrecognized arguments: '%s'", excessArgs ) ); } }
private File determineStoreDirectory( Args arguments ) throws ToolFailureException { List<String> unprefixedArguments = arguments.orphans(); if ( unprefixedArguments.size() != 1 ) { throw new ToolFailureException( usage() ); } File storeDir = new File( unprefixedArguments.get( 0 ) ); if ( !storeDir.isDirectory() ) { throw new ToolFailureException( Strings.joinAsLines( String.format( "'%s' is not a directory", storeDir ) ) + usage() ); } return storeDir; }
private static boolean asksForUsage( Args args ) { for ( String orphan : args.orphans() ) { if ( isHelpKey( orphan ) ) { return true; } } for ( Entry<String,String> option : args.asMap().entrySet() ) { if ( isHelpKey( option.getKey() ) ) { return true; } } return false; }
Set<String> classifiers = new TreeSet<>( args.orphans() ); if ( classifiers.contains( "all" ) )
public static void main( String[] args ) throws Exception { Args arg = Args.withFlags( HEAP ).parse( args == null ? new String[0] : args ); boolean doHeapDump = arg.getBoolean( HEAP, false, true ); String[] containing = arg.orphans().toArray( new String[arg.orphans().size()] ); String dumpDir = arg.get( DIR, "data" ); new DumpProcessInformation( FormattedLogProvider.toOutputStream( System.out ), new File( dumpDir ) ).dumpRunningProcesses( doHeapDump, containing ); }
@Test void shouldHandleLastOrphanParam() { // Given Args args = Args.withFlags("recovery").parse( "--recovery", "/tmp/graph.db" ); // When List<String> orphans = args.orphans(); // Then assertEquals( Arrays.asList( "/tmp/graph.db" ), orphans ); }
@Test void testInterleavedEqualsArgsAndSplitKeyValue() { String[] line = { "-host=localhost", "-v", "--port", "1234", "param1", "-name=Something", "param2" }; Args args = Args.parse( line ); assertEquals( "localhost", args.get( "host", null ) ); assertTrue( args.has( "v" ) ); assertEquals( 1234, args.getNumber( "port", null ).intValue() ); assertEquals( "Something", args.get( "name", null ) ); assertEquals( 2, args.orphans().size() ); assertEquals( "param1", args.orphans().get( 0 ) ); assertEquals( "param2", args.orphans().get( 1 ) ); }
@Test void testParameterWithDashValue() { String [] line = { "-file", "-" }; Args args = Args.parse( line ); assertEquals( 1, args.asMap().size() ); assertEquals( "-", args.get( "file", null ) ); assertTrue( args.orphans().isEmpty() ); }
@Test void shouldStillAllowExplicitValuesForFlags() { // Given Args args = Args.withFlags( "foo", "bar" ).parse("-foo=false", "--bar"); // When List<String> orphans = args.orphans(); // Then assertEquals( Arrays.<String>asList() , orphans ); assertFalse( args.getBoolean( "foo", false, false ) ); assertTrue( args.getBoolean( "bar", false, true ) ); }
@Test void shouldHandleOnlyFlagsAndNoArgs() { // Given Args args = Args.withFlags( "foo", "bar" ).parse("-foo", "--bar"); // When List<String> orphans = args.orphans(); // Then assertEquals( Collections.<String>emptyList(), orphans ); assertTrue( args.getBoolean( "foo", false, true ) ); assertTrue( args.getBoolean( "bar", false, true ) ); }
@Test void testInterleavedParametersWithValuesAndNot() { String[] line = { "-host", "machine.foo.com", "-port", "1234", "-v", "-name", "othershell" }; Args args = Args.parse( line ); assertEquals( "machine.foo.com", args.get( "host", null ) ); assertEquals( "1234", args.get( "port", null ) ); assertEquals( 1234, args.getNumber( "port", null ).intValue() ); assertEquals( "othershell", args.get( "name", null ) ); assertTrue( args.has( "v" ) ); assertTrue( args.orphans().isEmpty() ); }
@Test void shouldRecognizeFlagsOfAnyForm() { // Given Args args = Args.withFlags( "flag1", "flag2", "flag3" ).parse( "-key1=Foo", "-flag1", "-key1", "Bar", "-flag2=true", "-key3=Baz", "-flag3", "true" ); // When List<String> orphans = args.orphans(); // Then assertTrue( orphans.isEmpty(), "Orphan args expected to be empty, but were: " + orphans ); assertTrue( args.getBoolean( "flag1", false, true ) ); assertTrue( args.getBoolean( "flag2", false, false ) ); assertTrue( args.getBoolean( "flag3", false, false ) ); }
@Test void shouldHandleMixtureOfFlagsAndOrphanParams() { // Given Args args = Args.withFlags( "big", "soft", "saysMeow" ).parse( "-big", "-size=120", "-soft=true", "withStripes", "-saysMeow=false", "-name=ShereKhan", "badTiger" ); // When List<String> orphans = args.orphans(); // Then assertEquals( Arrays.asList( "withStripes", "badTiger" ), orphans ); assertEquals( 120, args.getNumber( "size", 0 ).intValue() ); assertEquals( "ShereKhan", args.get( "name" ) ); assertTrue( args.getBoolean( "big", false, true ) ); assertTrue( args.getBoolean( "soft", false, false ) ); assertFalse( args.getBoolean( "saysMeow", true, true ) ); }
@Test void shouldHandleFlagSpecifiedAsLastArgument() { // Given Args args = Args.withFlags( "flag1", "flag2" ).parse( "-key=Foo", "-flag1", "false", "-value", "Bar", "-flag2", "false" ); // When List<String> orphans = args.orphans(); // Then assertTrue( orphans.isEmpty(), "Orphan args expected to be empty, but were: " + orphans ); assertEquals( "Foo", args.get( "key" ) ); assertEquals( "Bar", args.get( "value" ) ); assertFalse( args.getBoolean( "flag1", true ) ); assertFalse( args.getBoolean( "flag2", true ) ); }
private static boolean asksForUsage( Args args ) { for ( String orphan : args.orphans() ) { if ( isHelpKey( orphan ) ) { return true; } } for ( Entry<String,String> option : args.asMap().entrySet() ) { if ( isHelpKey( option.getKey() ) ) { return true; } } return false; }
Set<String> classifiers = new TreeSet<>( args.orphans() ); if ( classifiers.contains( "all" ) )
public static void main( String[] args ) { Args arguments = Args.withFlags( TO_FILE ).parse( args ); try ( Printer printer = getPrinter( arguments ) ) { for ( String fileAsString : arguments.orphans() ) { System.out.println( "Reading file " + fileAsString ); try ( DefaultFileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction() ) { new DumpSegmentedRaftLog( fileSystem, new CoreReplicatedContentMarshal() ) .dump( fileAsString, printer.getFor( fileAsString ) ); } catch ( IOException | DisposedException | DamagedLogStorageException e ) { e.printStackTrace(); } } } }
public static void main( String[] args ) throws IOException, DisposedException, DamagedLogStorageException { Args arguments = Args.withFlags( TO_FILE ).parse( args ); try ( Printer printer = getPrinter( arguments ) ) { for ( String fileAsString : arguments.orphans() ) { System.out.println( "Reading file " + fileAsString ); new DumpSegmentedRaftLog( new DefaultFileSystemAbstraction(), new CoreReplicatedContentMarshal() ) .dump( fileAsString, printer.getFor( fileAsString ) ); } } }