aboutsummaryrefslogtreecommitdiffstats
path: root/src/catch2/internal/catch_textflow.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/catch2/internal/catch_textflow.cpp')
-rw-r--r--src/catch2/internal/catch_textflow.cpp379
1 files changed, 379 insertions, 0 deletions
diff --git a/src/catch2/internal/catch_textflow.cpp b/src/catch2/internal/catch_textflow.cpp
new file mode 100644
index 0000000..1c21d20
--- /dev/null
+++ b/src/catch2/internal/catch_textflow.cpp
@@ -0,0 +1,379 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#include <catch2/internal/catch_textflow.hpp>
+
+#include <algorithm>
+#include <cstring>
+#include <ostream>
+
+namespace {
+ bool isWhitespace( char c ) {
+ return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+ }
+
+ bool isBreakableBefore( char c ) {
+ static const char chars[] = "[({<|";
+ return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+ }
+
+ bool isBreakableAfter( char c ) {
+ static const char chars[] = "])}>.,:;*+-=&/\\";
+ return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+ }
+
+} // namespace
+
+namespace Catch {
+ namespace TextFlow {
+ void AnsiSkippingString::preprocessString() {
+ for ( auto it = m_string.begin(); it != m_string.end(); ) {
+ // try to read through an ansi sequence
+ while ( it != m_string.end() && *it == '\033' &&
+ it + 1 != m_string.end() && *( it + 1 ) == '[' ) {
+ auto cursor = it + 2;
+ while ( cursor != m_string.end() &&
+ ( isdigit( *cursor ) || *cursor == ';' ) ) {
+ ++cursor;
+ }
+ if ( cursor == m_string.end() || *cursor != 'm' ) {
+ break;
+ }
+ // 'm' -> 0xff
+ *cursor = AnsiSkippingString::sentinel;
+ // if we've read an ansi sequence, set the iterator and
+ // return to the top of the loop
+ it = cursor + 1;
+ }
+ if ( it != m_string.end() ) {
+ ++m_size;
+ ++it;
+ }
+ }
+ }
+
+ AnsiSkippingString::AnsiSkippingString( std::string const& text ):
+ m_string( text ) {
+ preprocessString();
+ }
+
+ AnsiSkippingString::AnsiSkippingString( std::string&& text ):
+ m_string( CATCH_MOVE( text ) ) {
+ preprocessString();
+ }
+
+ AnsiSkippingString::const_iterator AnsiSkippingString::begin() const {
+ return const_iterator( m_string );
+ }
+
+ AnsiSkippingString::const_iterator AnsiSkippingString::end() const {
+ return const_iterator( m_string, const_iterator::EndTag{} );
+ }
+
+ std::string AnsiSkippingString::substring( const_iterator begin,
+ const_iterator end ) const {
+ // There's one caveat here to an otherwise simple substring: when
+ // making a begin iterator we might have skipped ansi sequences at
+ // the start. If `begin` here is a begin iterator, skipped over
+ // initial ansi sequences, we'll use the true beginning of the
+ // string. Lastly: We need to transform any chars we replaced with
+ // 0xff back to 'm'
+ auto str = std::string( begin == this->begin() ? m_string.begin()
+ : begin.m_it,
+ end.m_it );
+ std::transform( str.begin(), str.end(), str.begin(), []( char c ) {
+ return c == AnsiSkippingString::sentinel ? 'm' : c;
+ } );
+ return str;
+ }
+
+ void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() {
+ // check if we've landed on an ansi sequence, and if so read through
+ // it
+ while ( m_it != m_string->end() && *m_it == '\033' &&
+ m_it + 1 != m_string->end() && *( m_it + 1 ) == '[' ) {
+ auto cursor = m_it + 2;
+ while ( cursor != m_string->end() &&
+ ( isdigit( *cursor ) || *cursor == ';' ) ) {
+ ++cursor;
+ }
+ if ( cursor == m_string->end() ||
+ *cursor != AnsiSkippingString::sentinel ) {
+ break;
+ }
+ // if we've read an ansi sequence, set the iterator and
+ // return to the top of the loop
+ m_it = cursor + 1;
+ }
+ }
+
+ void AnsiSkippingString::const_iterator::advance() {
+ assert( m_it != m_string->end() );
+ m_it++;
+ tryParseAnsiEscapes();
+ }
+
+ void AnsiSkippingString::const_iterator::unadvance() {
+ assert( m_it != m_string->begin() );
+ m_it--;
+ // if *m_it is 0xff, scan back to the \033 and then m_it-- once more
+ // (and repeat check)
+ while ( *m_it == AnsiSkippingString::sentinel ) {
+ while ( *m_it != '\033' ) {
+ assert( m_it != m_string->begin() );
+ m_it--;
+ }
+ // if this happens, we must have been a begin iterator that had
+ // skipped over ansi sequences at the start of a string
+ assert( m_it != m_string->begin() );
+ assert( *m_it == '\033' );
+ m_it--;
+ }
+ }
+
+ static bool isBoundary( AnsiSkippingString const& line,
+ AnsiSkippingString::const_iterator it ) {
+ return it == line.end() ||
+ ( isWhitespace( *it ) &&
+ !isWhitespace( *it.oneBefore() ) ) ||
+ isBreakableBefore( *it ) ||
+ isBreakableAfter( *it.oneBefore() );
+ }
+
+ void Column::const_iterator::calcLength() {
+ m_addHyphen = false;
+ m_parsedTo = m_lineStart;
+ AnsiSkippingString const& current_line = m_column.m_string;
+
+ if ( m_parsedTo == current_line.end() ) {
+ m_lineEnd = m_parsedTo;
+ return;
+ }
+
+ assert( m_lineStart != current_line.end() );
+ if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
+
+ const auto maxLineLength = m_column.m_width - indentSize();
+ std::size_t lineLength = 0;
+ while ( m_parsedTo != current_line.end() &&
+ lineLength < maxLineLength && *m_parsedTo != '\n' ) {
+ ++m_parsedTo;
+ ++lineLength;
+ }
+
+ // If we encountered a newline before the column is filled,
+ // then we linebreak at the newline and consider this line
+ // finished.
+ if ( lineLength < maxLineLength ) {
+ m_lineEnd = m_parsedTo;
+ } else {
+ // Look for a natural linebreak boundary in the column
+ // (We look from the end, so that the first found boundary is
+ // the right one)
+ m_lineEnd = m_parsedTo;
+ while ( lineLength > 0 &&
+ !isBoundary( current_line, m_lineEnd ) ) {
+ --lineLength;
+ --m_lineEnd;
+ }
+ while ( lineLength > 0 &&
+ isWhitespace( *m_lineEnd.oneBefore() ) ) {
+ --lineLength;
+ --m_lineEnd;
+ }
+
+ // If we found one, then that is where we linebreak, otherwise
+ // we have to split text with a hyphen
+ if ( lineLength == 0 ) {
+ m_addHyphen = true;
+ m_lineEnd = m_parsedTo.oneBefore();
+ }
+ }
+ }
+
+ size_t Column::const_iterator::indentSize() const {
+ auto initial = m_lineStart == m_column.m_string.begin()
+ ? m_column.m_initialIndent
+ : std::string::npos;
+ return initial == std::string::npos ? m_column.m_indent : initial;
+ }
+
+ std::string Column::const_iterator::addIndentAndSuffix(
+ AnsiSkippingString::const_iterator start,
+ AnsiSkippingString::const_iterator end ) const {
+ std::string ret;
+ const auto desired_indent = indentSize();
+ // ret.reserve( desired_indent + (end - start) + m_addHyphen );
+ ret.append( desired_indent, ' ' );
+ // ret.append( start, end );
+ ret += m_column.m_string.substring( start, end );
+ if ( m_addHyphen ) { ret.push_back( '-' ); }
+
+ return ret;
+ }
+
+ Column::const_iterator::const_iterator( Column const& column ):
+ m_column( column ),
+ m_lineStart( column.m_string.begin() ),
+ m_lineEnd( column.m_string.begin() ),
+ m_parsedTo( column.m_string.begin() ) {
+ assert( m_column.m_width > m_column.m_indent );
+ assert( m_column.m_initialIndent == std::string::npos ||
+ m_column.m_width > m_column.m_initialIndent );
+ calcLength();
+ if ( m_lineStart == m_lineEnd ) {
+ m_lineStart = m_column.m_string.end();
+ }
+ }
+
+ std::string Column::const_iterator::operator*() const {
+ assert( m_lineStart <= m_parsedTo );
+ return addIndentAndSuffix( m_lineStart, m_lineEnd );
+ }
+
+ Column::const_iterator& Column::const_iterator::operator++() {
+ m_lineStart = m_lineEnd;
+ AnsiSkippingString const& current_line = m_column.m_string;
+ if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
+ m_lineStart++;
+ } else {
+ while ( m_lineStart != current_line.end() &&
+ isWhitespace( *m_lineStart ) ) {
+ ++m_lineStart;
+ }
+ }
+
+ if ( m_lineStart != current_line.end() ) { calcLength(); }
+ return *this;
+ }
+
+ Column::const_iterator Column::const_iterator::operator++( int ) {
+ const_iterator prev( *this );
+ operator++();
+ return prev;
+ }
+
+ std::ostream& operator<<( std::ostream& os, Column const& col ) {
+ bool first = true;
+ for ( auto line : col ) {
+ if ( first ) {
+ first = false;
+ } else {
+ os << '\n';
+ }
+ os << line;
+ }
+ return os;
+ }
+
+ Column Spacer( size_t spaceWidth ) {
+ Column ret{ "" };
+ ret.width( spaceWidth );
+ return ret;
+ }
+
+ Columns::iterator::iterator( Columns const& columns, EndTag ):
+ m_columns( columns.m_columns ), m_activeIterators( 0 ) {
+
+ m_iterators.reserve( m_columns.size() );
+ for ( auto const& col : m_columns ) {
+ m_iterators.push_back( col.end() );
+ }
+ }
+
+ Columns::iterator::iterator( Columns const& columns ):
+ m_columns( columns.m_columns ),
+ m_activeIterators( m_columns.size() ) {
+
+ m_iterators.reserve( m_columns.size() );
+ for ( auto const& col : m_columns ) {
+ m_iterators.push_back( col.begin() );
+ }
+ }
+
+ std::string Columns::iterator::operator*() const {
+ std::string row, padding;
+
+ for ( size_t i = 0; i < m_columns.size(); ++i ) {
+ const auto width = m_columns[i].width();
+ if ( m_iterators[i] != m_columns[i].end() ) {
+ std::string col = *m_iterators[i];
+ row += padding;
+ row += col;
+
+ padding.clear();
+ if ( col.size() < width ) {
+ padding.append( width - col.size(), ' ' );
+ }
+ } else {
+ padding.append( width, ' ' );
+ }
+ }
+ return row;
+ }
+
+ Columns::iterator& Columns::iterator::operator++() {
+ for ( size_t i = 0; i < m_columns.size(); ++i ) {
+ if ( m_iterators[i] != m_columns[i].end() ) {
+ ++m_iterators[i];
+ }
+ }
+ return *this;
+ }
+
+ Columns::iterator Columns::iterator::operator++( int ) {
+ iterator prev( *this );
+ operator++();
+ return prev;
+ }
+
+ std::ostream& operator<<( std::ostream& os, Columns const& cols ) {
+ bool first = true;
+ for ( auto line : cols ) {
+ if ( first ) {
+ first = false;
+ } else {
+ os << '\n';
+ }
+ os << line;
+ }
+ return os;
+ }
+
+ Columns operator+( Column const& lhs, Column const& rhs ) {
+ Columns cols;
+ cols += lhs;
+ cols += rhs;
+ return cols;
+ }
+ Columns operator+( Column&& lhs, Column&& rhs ) {
+ Columns cols;
+ cols += CATCH_MOVE( lhs );
+ cols += CATCH_MOVE( rhs );
+ return cols;
+ }
+
+ Columns& operator+=( Columns& lhs, Column const& rhs ) {
+ lhs.m_columns.push_back( rhs );
+ return lhs;
+ }
+ Columns& operator+=( Columns& lhs, Column&& rhs ) {
+ lhs.m_columns.push_back( CATCH_MOVE( rhs ) );
+ return lhs;
+ }
+ Columns operator+( Columns const& lhs, Column const& rhs ) {
+ auto combined( lhs );
+ combined += rhs;
+ return combined;
+ }
+ Columns operator+( Columns&& lhs, Column&& rhs ) {
+ lhs += CATCH_MOVE( rhs );
+ return CATCH_MOVE( lhs );
+ }
+
+ } // namespace TextFlow
+} // namespace Catch