3rd-party
/
catch2
mirror of https://github.com/catchorg/Catch2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Clara: some refactoring 

- moved all internal stuff into Detail
- moved Parser out of CommandLine, encapsulates tokens.
- allow unused tokens to be feed into different CommandLine processors
This commit is contained in:
Phil Nash 2013-05-16 19:07:50 +01:00
parent 58846c395c
commit 8333e644f2
1 changed files with 300 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

256
projects/SelfTest/CmdLineTests.cpp
View File

@ -13,7 +13,7 @@
#include "catch_text.h" #include "catch_text.h"
namespace Clara { namespace Clara {
namespace Detail {
template<typename T> struct RemoveConstRef{ typedef T type; }; template<typename T> struct RemoveConstRef{ typedef T type; };
template<typename T> struct RemoveConstRef<T&>{ typedef T type; }; template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
template<typename T> struct RemoveConstRef<T const&>{ typedef T type; }; template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
@ -144,23 +144,53 @@ namespace Clara {
BoundField<C> makeBoundField( void (C::*_member)() ) { BoundField<C> makeBoundField( void (C::*_member)() ) {
return BoundField<C>( new BoundNullaryMethod<C>( _member ) ); return BoundField<C>( new BoundNullaryMethod<C>( _member ) );
} }
} // namespace Detail
struct Parser {
Parser() : separators( " \t=:" ) {}
struct Token {
enum Type { Positional, ShortOpt, LongOpt };
Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
Type type;
std::string data;
};
void parseIntoTokens( int argc, char const* argv[], std::vector<Parser::Token>& tokens ) const {
for( int i = 1; i < argc; ++i )
parseIntoTokens( argv[i] , tokens);
}
void parseIntoTokens( std::string arg, std::vector<Parser::Token>& tokens ) const {
while( !arg.empty() ) {
Parser::Token token( Parser::Token::Positional, arg );
arg = "";
if( token.data[0] == '-' ) {
if( token.data.size() > 1 && token.data[1] == '-' ) {
token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) );
}
else {
token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) );
if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) {
arg = "-" + token.data.substr( 1 );
token.data = token.data.substr( 0, 1 );
}
}
}
if( token.type != Parser::Token::Positional ) {
std::size_t pos = token.data.find_first_of( separators );
if( pos != std::string::npos ) {
arg = token.data.substr( pos+1 );
token.data = token.data.substr( 0, pos );
}
}
tokens.push_back( token );
}
}
std::string separators;
};
template<typename ConfigT> template<typename ConfigT>
class CommandLine { class CommandLine {
struct ArgToken {
enum TokenType {
Positional,
ShortOpt,
LongOpt
};
ArgToken() : type( Positional ) {}
ArgToken( TokenType _type, std::string const& _arg )
: type( _type ), arg( _arg ) {}
TokenType type;
std::string arg;
};
class ArgBinder { class ArgBinder {
public: public:
@ -168,26 +198,25 @@ namespace Clara {
template<typename F> template<typename F>
ArgBinder& bind( F f ) { ArgBinder& bind( F f ) {
if( !m_cl->opts.empty() ) if( !m_cl->m_args.empty() )
m_cl->opts.back().validate(); m_cl->m_args.back().validate();
m_cl->opts.push_back( Opt( makeBoundField( f ) ) ); m_cl->m_args.push_back( Arg( Detail::makeBoundField( f ) ) );
return *this; return *this;
} }
ArgBinder& shortOpt( std::string const& name ) { ArgBinder& shortOpt( std::string const& name ) {
m_cl->opts.back().shortNames.push_back( name ); m_cl->m_args.back().shortNames.push_back( name );
return *this; return *this;
} }
ArgBinder& longOpt( std::string const& name ) { ArgBinder& longOpt( std::string const& name ) {
m_cl->opts.back().longName = name; m_cl->m_args.back().longName = name;
return *this; return *this;
} }
ArgBinder& describe( std::string const& description ) { ArgBinder& describe( std::string const& description ) {
m_cl->opts.back().description = description; m_cl->m_args.back().description = description;
return *this; return *this;
} }
ArgBinder& argName( std::string const& argName ) { ArgBinder& argName( std::string const& argName ) {
m_cl->opts.back().argName = argName; m_cl->m_args.back().argName = argName;
return *this; return *this;
} }
ArgBinder& position( int /*position*/ ) { ArgBinder& position( int /*position*/ ) {
@ -198,9 +227,8 @@ namespace Clara {
CommandLine* m_cl; CommandLine* m_cl;
}; };
struct Opt { struct Arg {
public: Arg( Detail::BoundField<ConfigT> const& _boundField ) : boundField( _boundField ) {}
Opt( BoundField<ConfigT> const& _boundField ) : boundField( _boundField ) {}
bool hasShortName( std::string const& shortName ) const { bool hasShortName( std::string const& shortName ) const {
for( std::vector<std::string>::const_iterator for( std::vector<std::string>::const_iterator
@ -227,12 +255,10 @@ namespace Clara {
return "-" + shortNames[0]; return "-" + shortNames[0];
return "positional args"; return "positional args";
} }
void validate() const { void validate() const {
if( boundField.takesArg() && !takesArg() ) if( boundField.takesArg() && !takesArg() )
throw std::logic_error( dbgName() + " must specify an arg name" ); throw std::logic_error( dbgName() + " must specify an arg name" );
} }
std::string commands() const { std::string commands() const {
std::ostringstream oss; std::ostringstream oss;
bool first = true; bool first = true;
@ -254,7 +280,7 @@ namespace Clara {
return oss.str(); return oss.str();
} }
BoundField<ConfigT> boundField; Detail::BoundField<ConfigT> boundField;
std::vector<std::string> shortNames; std::vector<std::string> shortNames;
std::string longName; std::string longName;
std::string description; std::string description;
@ -262,8 +288,6 @@ namespace Clara {
}; };
public: public:
CommandLine() : seperators( " \t=:" ) {}
template<typename F> template<typename F>
ArgBinder bind( F f ) { ArgBinder bind( F f ) {
ArgBinder binder( this ); ArgBinder binder( this );
@ -271,18 +295,8 @@ namespace Clara {
return binder; return binder;
} }
void parseInto( int argc, char const* argv[], ConfigT& config ) const {
if( opts.empty() )
throw std::logic_error( "No options or arguments specified" );
opts.back().validate();
std::vector<ArgToken> tokens;
parseIntoTokens( argc, argv, tokens );
setFromTokens( tokens, config );
}
void usage( std::ostream& os ) const { void usage( std::ostream& os ) const {
typename std::vector<Opt>::const_iterator itBegin = opts.begin(), itEnd = opts.end(), it; typename std::vector<Arg>::const_iterator itBegin = m_args.begin(), itEnd = m_args.end(), it;
std::size_t maxWidth = 0; std::size_t maxWidth = 0;
for( it = itBegin; it != itEnd; ++it ) for( it = itBegin; it != itEnd; ++it )
maxWidth = (std::max)( maxWidth, it->commands().size() ); maxWidth = (std::max)( maxWidth, it->commands().size() );
@ -302,7 +316,6 @@ namespace Clara {
os << "\n"; os << "\n";
} }
} }
} }
std::string usage() const { std::string usage() const {
std::ostringstream oss; std::ostringstream oss;
@ -314,68 +327,50 @@ namespace Clara {
return os; return os;
} }
private: std::vector<Parser::Token> parseInto( int argc, char const* argv[], ConfigT& config ) const {
void parseIntoTokens( int argc, char const* argv[], std::vector<ArgToken>& tokens ) const { std::vector<Parser::Token> tokens;
for( int i = 1; i < argc; ++i ) { Parser parser;
std::string arg = argv[i]; parser.parseIntoTokens( argc, argv, tokens );
while( !arg.empty() ) { return populate( tokens, config );
ArgToken token( ArgToken::Positional, arg );
arg = "";
if( token.arg[0] == '-' ) {
if( token.arg.size() > 1 && token.arg[1] == '-' ) {
token = ArgToken( ArgToken::LongOpt, token.arg.substr( 2 ) );
} }
else {
token = ArgToken( ArgToken::ShortOpt, token.arg.substr( 1 ) );
if( token.arg.size() > 1 && seperators.find( token.arg[1] ) == std::string::npos ) {
arg = "-" + token.arg.substr( 1 );
token.arg = token.arg.substr( 0, 1 );
}
}
}
if( token.type != ArgToken::Positional ) {
std::size_t pos = token.arg.find_first_of( seperators );
if( pos != std::string::npos ) {
arg = token.arg.substr( pos+1 );
token.arg = token.arg.substr( 0, pos );
}
}
tokens.push_back( token );
}
}
}
void setFromTokens( std::vector<ArgToken>const & tokens, ConfigT& config ) const {
for( std::size_t i = 0; i < tokens.size(); ++i ) {
ArgToken const& token = tokens[i];
typename std::vector<Opt>::const_iterator it = opts.begin(), itEnd = opts.end();
for(; it != itEnd; ++it ) {
Opt const& opt = *it;
if( ( token.type == ArgToken::ShortOpt && opt.hasShortName( token.arg ) ) || std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
( token.type == ArgToken::LongOpt && opt.hasLongName( token.arg ) ) ) { if( m_args.empty() )
if( opt.takesArg() ) { throw std::logic_error( "No options or arguments specified" );
if( i == tokens.size()-1 || tokens[i+1].type != ArgToken::Positional ) m_args.back().validate();
throw std::domain_error( "Expected argument to option " + token.arg );
opt.boundField.set( config, tokens[++i].arg ); std::vector<Parser::Token> unusedTokens;
for( std::size_t i = 0; i < tokens.size(); ++i ) {
Parser::Token const& token = tokens[i];
typename std::vector<Arg>::const_iterator it = m_args.begin(), itEnd = m_args.end();
for(; it != itEnd; ++it ) {
Arg const& arg = *it;
if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
if( arg.takesArg() ) {
if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
throw std::domain_error( "Expected argument to option " + token.data );
arg.boundField.set( config, tokens[++i].data );
} }
else { else {
opt.boundField.setFlag( config ); arg.boundField.setFlag( config );
} }
break; break;
} }
else if( token.type == ArgToken::Positional && opt.isPositional() ) { else if( token.type == Parser::Token::Positional && arg.isPositional() ) {
opt.boundField.set( config, token.arg ); arg.boundField.set( config, token.data );
break; break;
} }
} }
if( it == itEnd ) if( it == itEnd )
unhandledTokens.push_back( token ); unusedTokens.push_back( token );
} }
return unusedTokens;
} }
std::string seperators; private:
std::vector<Opt> opts; std::vector<Arg> m_args;
mutable std::vector<ArgToken> unhandledTokens; // !TBD
}; };
} // end namespace Clara } // end namespace Clara
@ -401,11 +396,11 @@ struct TestOpt2 {
#ifdef CATCH_CONFIG_VARIADIC_MACROS #ifdef CATCH_CONFIG_VARIADIC_MACROS
TEST_CASE( "cmdline", "" ) { TEST_CASE( "cmdline" ) {
TestOpt config; TestOpt config;
Clara::CommandLine<TestOpt> parser; Clara::CommandLine<TestOpt> cli;
parser.bind( &TestOpt::fileName ) cli.bind( &TestOpt::fileName )
.describe( "specifies output file" ) .describe( "specifies output file" )
.shortOpt( "o" ) .shortOpt( "o" )
.longOpt( "output" ) .longOpt( "output" )
@ -414,42 +409,42 @@ TEST_CASE( "cmdline", "" ) {
SECTION( "plain filename" ) { SECTION( "plain filename" ) {
const char* argv[] = { "test", "-o filename.ext" }; const char* argv[] = { "test", "-o filename.ext" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ); cli.parseInto( sizeof(argv)/sizeof(char*), argv, config );
CHECK( config.fileName == "filename.ext" ); CHECK( config.fileName == "filename.ext" );
} }
SECTION( "plain filename with colon" ) { SECTION( "plain filename with colon" ) {
const char* argv[] = { "test", "-o:filename.ext" }; const char* argv[] = { "test", "-o:filename.ext" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ); cli.parseInto( sizeof(argv)/sizeof(char*), argv, config );
CHECK( config.fileName == "filename.ext" ); CHECK( config.fileName == "filename.ext" );
} }
SECTION( "plain filename with =" ) { SECTION( "plain filename with =" ) {
const char* argv[] = { "test", "-o=filename.ext" }; const char* argv[] = { "test", "-o=filename.ext" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ); cli.parseInto( sizeof(argv)/sizeof(char*), argv, config );
CHECK( config.fileName == "filename.ext" ); CHECK( config.fileName == "filename.ext" );
} }
SECTION( "long opt" ) { SECTION( "long opt" ) {
const char* argv[] = { "test", "--output %stdout" }; const char* argv[] = { "test", "--output %stdout" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ); cli.parseInto( sizeof(argv)/sizeof(char*), argv, config );
CHECK( config.fileName == "%stdout" ); CHECK( config.fileName == "%stdout" );
} }
parser.bind( &TestOpt::number ) cli.bind( &TestOpt::number )
.shortOpt( "n" ) .shortOpt( "n" )
.argName( "<an integral value>" ); .argName( "<an integral value>" );
SECTION( "a number" ) { SECTION( "a number" ) {
const char* argv[] = { "test", "-n 42" }; const char* argv[] = { "test", "-n 42" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ); cli.parseInto( sizeof(argv)/sizeof(char*), argv, config );
CHECK( config.number == 42 ); CHECK( config.number == 42 );
} }
SECTION( "not a number" ) { SECTION( "not a number" ) {
const char* argv[] = { "test", "-n forty-two" }; const char* argv[] = { "test", "-n forty-two" };
CHECK_THROWS( parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ) ); CHECK_THROWS( cli.parseInto( sizeof(argv)/sizeof(char*), argv, config ) );
CHECK( config.number == 0 ); CHECK( config.number == 0 );
} }
@ -457,9 +452,9 @@ TEST_CASE( "cmdline", "" ) {
TestOpt config1; TestOpt config1;
TestOpt2 config2; TestOpt2 config2;
Clara::CommandLine<TestOpt2> parser2; Clara::CommandLine<TestOpt2> cli2;
parser2.bind( &TestOpt2::description ) cli2.bind( &TestOpt2::description )
.describe( "description" ) .describe( "description" )
.shortOpt( "d" ) .shortOpt( "d" )
.longOpt( "description" ) .longOpt( "description" )
@ -467,17 +462,16 @@ TEST_CASE( "cmdline", "" ) {
const char* argv[] = { "test", "-n 42", "-d some text" }; const char* argv[] = { "test", "-n 42", "-d some text" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config1 ); std::vector<Clara::Parser::Token> unusedTokens = cli.parseInto( sizeof(argv)/sizeof(char*), argv, config1 );
CHECK( config1.number == 42 ); CHECK( config1.number == 42 );
// !TBD REQUIRE_FALSE( unusedTokens.empty() );
// parser2.parseRemainingArgs( parser, config2 ); cli2.populate( unusedTokens, config2 );
// CHECK( config2.description == "some text" ); CHECK( config2.description == "some text" );
} }
SECTION( "methods" ) { SECTION( "methods" ) {
parser.bind( &TestOpt::setValidIndex ) cli.bind( &TestOpt::setValidIndex )
.describe( "An index, which is an integer between 0 and 10, inclusive" ) .describe( "An index, which is an integer between 0 and 10, inclusive" )
.shortOpt( "i" ) .shortOpt( "i" )
.argName( "<index>" ); .argName( "<index>" );
@ -485,31 +479,31 @@ TEST_CASE( "cmdline", "" ) {
SECTION( "in range" ) { SECTION( "in range" ) {
const char* argv[] = { "test", "-i 3" }; const char* argv[] = { "test", "-i 3" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ); cli.parseInto( sizeof(argv)/sizeof(char*), argv, config );
REQUIRE( config.index == 3 ); REQUIRE( config.index == 3 );
} }
SECTION( "out of range" ) { SECTION( "out of range" ) {
const char* argv[] = { "test", "-i 42" }; const char* argv[] = { "test", "-i 42" };
REQUIRE_THROWS( parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ) ); REQUIRE_THROWS( cli.parseInto( sizeof(argv)/sizeof(char*), argv, config ) );
} }
} }
SECTION( "flags" ) { SECTION( "flags" ) {
parser.bind( &TestOpt::flag ) cli.bind( &TestOpt::flag )
.describe( "A flag" ) .describe( "A flag" )
.shortOpt( "f" ); .shortOpt( "f" );
SECTION( "set" ) { SECTION( "set" ) {
const char* argv[] = { "test", "-f" }; const char* argv[] = { "test", "-f" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ); cli.parseInto( sizeof(argv)/sizeof(char*), argv, config );
REQUIRE( config.flag ); REQUIRE( config.flag );
} }
SECTION( "not set" ) { SECTION( "not set" ) {
const char* argv[] = { "test" }; const char* argv[] = { "test" };
parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ); cli.parseInto( sizeof(argv)/sizeof(char*), argv, config );
REQUIRE( config.flag == false ); REQUIRE( config.flag == false );
} }
} }
@ -538,91 +532,97 @@ struct Config {
std::string fileName; std::string fileName;
std::string suiteName; std::string suiteName;
std::vector<std::string> warnings; std::vector<std::string> warnings;
std::vector<std::string> testsOrTags;
void abortAfterFirst() { abortAfter = 1; } void abortAfterFirst() { abortAfter = 1; }
void abortAfterX( int x ) { abortAfter = x; } void abortAfterX( int x ) { abortAfter = x; }
void addWarning( std::string const& _warning ) { warnings.push_back( _warning ); } void addWarning( std::string const& _warning ) { warnings.push_back( _warning ); }
void addTestOrTags( std::string const& _testSpec ) { testsOrTags.push_back( _testSpec ); }
}; };
TEST_CASE( "growing new Catch cli" ) { TEST_CASE( "growing new Catch cli" ) {
Clara::CommandLine<Config> parser; Clara::CommandLine<Config> cli;
parser.bind( &Config::showHelp ) cli.bind( &Config::showHelp )
.describe( "display usage information" ) .describe( "display usage information" )
.shortOpt( "?") .shortOpt( "?")
.shortOpt( "h") .shortOpt( "h")
.longOpt( "help" ); .longOpt( "help" );
parser.bind( &Config::listTests ) cli.bind( &Config::listTests )
.describe( "list all (or matching) test cases" ) .describe( "list all (or matching) test cases" )
.shortOpt( "l") .shortOpt( "l")
.longOpt( "list" ); .longOpt( "list" );
parser.bind( &Config::listTags ) cli.bind( &Config::listTags )
.describe( "list all (or matching) tags" ) .describe( "list all (or matching) tags" )
.shortOpt( "t") .shortOpt( "t")
.longOpt( "tags" ); .longOpt( "tags" );
parser.bind( &Config::showPassingTests ) cli.bind( &Config::showPassingTests )
.describe( "show passing test output" ) .describe( "show passing test output" )
.shortOpt( "p") .shortOpt( "p")
.longOpt( "passing" ); .longOpt( "passing" );
parser.bind( &Config::breakIntoDebugger ) cli.bind( &Config::breakIntoDebugger )
.describe( "break into debugger on failure" ) .describe( "break into debugger on failure" )
.shortOpt( "b") .shortOpt( "b")
.longOpt( "break" ); .longOpt( "break" );
parser.bind( &Config::noThrow ) cli.bind( &Config::noThrow )
.describe( "Skip exception tests" ) .describe( "Skip exception tests" )
.shortOpt( "e") .shortOpt( "e")
.longOpt( "nothrow" ); .longOpt( "nothrow" );
parser.bind( &Config::fileName ) cli.bind( &Config::fileName )
.describe( "output filename" ) .describe( "output filename" )
.shortOpt( "o") .shortOpt( "o")
.longOpt( "out" ) .longOpt( "out" )
.argName( "file name" ); .argName( "file name" );
parser.bind( &Config::suiteName ) cli.bind( &Config::suiteName )
.describe( "suite name" ) .describe( "suite name" )
.shortOpt( "n") .shortOpt( "n")
.longOpt( "name" ) .longOpt( "name" )
.argName( "name" ); .argName( "name" );
parser.bind( &Config::abortAfterFirst ) cli.bind( &Config::abortAfterFirst )
.describe( "abort at first failure" ) .describe( "abort at first failure" )
.shortOpt( "a") .shortOpt( "a")
.longOpt( "abort" ); .longOpt( "abort" );
parser.bind( &Config::abortAfterX ) cli.bind( &Config::abortAfterX )
.describe( "abort after x failures" ) .describe( "abort after x failures" )
.shortOpt( "x") .shortOpt( "x")
.longOpt( "abortx" ) .longOpt( "abortx" )
.argName( "number of failures" ); .argName( "number of failures" );
parser.bind( &Config::addWarning ) cli.bind( &Config::addWarning )
.describe( "enables warnings" ) .describe( "enables warnings" )
.shortOpt( "w") .shortOpt( "w")
.longOpt( "warn" ) .longOpt( "warn" )
.argName( "warning name" ); .argName( "warning name" );
std::cout << parser << std::endl; cli.bind( &Config::addTestOrTags )
.describe( "which test or tests to use" )
.argName( "test name, pattern or tags" );
std::cout << cli << std::endl;
Config config; Config config;
const char* argv[] = { "test", "-peb" }; const char* argv[] = { "test", "-peb" };
int argc = sizeof(argv)/sizeof(char*); int argc = sizeof(argv)/sizeof(char*);
parser.parseInto( argc, argv, config ); cli.parseInto( argc, argv, config );
CHECK( config.showPassingTests ); CHECK( config.showPassingTests );
CHECK( config.noThrow ); CHECK( config.noThrow );
CHECK( config.breakIntoDebugger ); CHECK( config.breakIntoDebugger );
// //
// REQUIRE_THROWS( parser.parseInto( sizeof(argv)/sizeof(char*), argv, config ) ); // REQUIRE_THROWS( cli.parseInto( sizeof(argv)/sizeof(char*), argv, config ) );
} }