String*
IxFileNames_local_part(String *path) {
StringIterator *top = Str_Tail(path);
int32_t code_point = StrIter_Prev(top);
// Trim trailing slash.
while (code_point == '/') {
code_point = StrIter_Prev(top);
}
StringIterator *tail = StrIter_Clone(top);
StrIter_Advance(tail, 1);
// Substring should start after last slash.
while (code_point != STR_OOB) {
if (code_point == '/') {
StrIter_Advance(top, 1);
break;
}
code_point = StrIter_Prev(top);
}
String *retval = StrIter_crop(top, tail);
DECREF(tail);
DECREF(top);
return retval;
}
static void
test_iterator_whitespace(TestBatchRunner *runner) {
int num_spaces;
String *ws_smiley = S_smiley_with_whitespace(&num_spaces);
{
StringIterator *iter = Str_Top(ws_smiley);
TEST_INT_EQ(runner, StrIter_Skip_Whitespace(iter), num_spaces,
"Skip_Whitespace");
TEST_INT_EQ(runner, StrIter_Skip_Whitespace(iter), 0,
"Skip_Whitespace without whitespace");
DECREF(iter);
}
{
StringIterator *iter = Str_Tail(ws_smiley);
TEST_INT_EQ(runner, StrIter_Skip_Whitespace_Back(iter), num_spaces,
"Skip_Whitespace_Back");
TEST_INT_EQ(runner, StrIter_Skip_Whitespace_Back(iter), 0,
"Skip_Whitespace_Back without whitespace");
DECREF(iter);
}
DECREF(ws_smiley);
}
Query*
QParser_Expand_Leaf_IMP(QueryParser *self, Query *query) {
QueryParserIVARS *const ivars = QParser_IVARS(self);
LeafQuery *leaf_query = (LeafQuery*)query;
Schema *schema = ivars->schema;
bool is_phrase = false;
bool ambiguous = false;
// Determine whether we can actually process the input.
if (!Query_is_a(query, LEAFQUERY)) { return NULL; }
String *full_text = LeafQuery_Get_Text(leaf_query);
if (!Str_Get_Size(full_text)) { return NULL; }
// If quoted, always generate PhraseQuery.
StringIterator *top = Str_Top(full_text);
StringIterator *tail = Str_Tail(full_text);
StrIter_Skip_Next_Whitespace(top);
StrIter_Skip_Prev_Whitespace(tail);
if (StrIter_Starts_With_Utf8(top, "\"", 1)) {
is_phrase = true;
StrIter_Advance(top, 1);
if (StrIter_Ends_With_Utf8(tail, "\"", 1)
&& !StrIter_Ends_With_Utf8(tail, "\\\"", 2)
) {
StrIter_Recede(tail, 1);
}
}
String *source_text = StrIter_substring(top, tail);
// Either use LeafQuery's field or default to Parser's list.
Vector *fields;
if (LeafQuery_Get_Field(leaf_query)) {
fields = Vec_new(1);
Vec_Push(fields, INCREF(LeafQuery_Get_Field(leaf_query)));
}
else {
fields = (Vector*)INCREF(ivars->fields);
}
CharBuf *unescape_buf = CB_new(Str_Get_Size(source_text));
Vector *queries = Vec_new(Vec_Get_Size(fields));
for (uint32_t i = 0, max = Vec_Get_Size(fields); i < max; i++) {
String *field = (String*)Vec_Fetch(fields, i);
Analyzer *analyzer = ivars->analyzer
? ivars->analyzer
: Schema_Fetch_Analyzer(schema, field);
if (!analyzer) {
Vec_Push(queries,
(Obj*)QParser_Make_Term_Query(self, field,
(Obj*)source_text));
}
else {
// Extract token texts.
String *split_source = S_unescape(self, source_text, unescape_buf);
Vector *maybe_texts = Analyzer_Split(analyzer, split_source);
uint32_t num_maybe_texts = Vec_Get_Size(maybe_texts);
Vector *token_texts = Vec_new(num_maybe_texts);
// Filter out zero-length token texts.
for (uint32_t j = 0; j < num_maybe_texts; j++) {
String *token_text = (String*)Vec_Fetch(maybe_texts, j);
if (Str_Get_Size(token_text)) {
Vec_Push(token_texts, INCREF(token_text));
}
}
if (Vec_Get_Size(token_texts) == 0) {
/* Query might include stop words. Who knows? */
ambiguous = true;
}
// Add either a TermQuery or a PhraseQuery.
if (is_phrase || Vec_Get_Size(token_texts) > 1) {
Vec_Push(queries, (Obj*)
QParser_Make_Phrase_Query(self, field, token_texts));
}
else if (Vec_Get_Size(token_texts) == 1) {
Vec_Push(queries,
(Obj*)QParser_Make_Term_Query(self, field, Vec_Fetch(token_texts, 0)));
}
DECREF(token_texts);
DECREF(maybe_texts);
DECREF(split_source);
}
}
Query *retval;
if (Vec_Get_Size(queries) == 0) {
retval = (Query*)NoMatchQuery_new();
if (ambiguous) {
NoMatchQuery_Set_Fails_To_Match((NoMatchQuery*)retval, false);
}
}
else if (Vec_Get_Size(queries) == 1) {
retval = (Query*)INCREF(Vec_Fetch(queries, 0));
}
else {
retval = QParser_Make_OR_Query(self, queries);
}
// Clean up.
DECREF(unescape_buf);
DECREF(queries);
DECREF(fields);
DECREF(source_text);
DECREF(tail);
DECREF(top);
return retval;
}
static void
test_iterator_substring(TestBatchRunner *runner) {
String *string = Str_newf("a%sb%sc%sd", smiley, smiley, smiley);
StringIterator *start = Str_Top(string);
StringIterator *end = Str_Tail(string);
{
String *substring = StrIter_crop(start, end);
TEST_TRUE(runner, Str_Equals(substring, (Obj*)string),
"StrIter_crop whole string");
DECREF(substring);
}
StrIter_Advance(start, 2);
StrIter_Recede(end, 2);
{
String *substring = StrIter_crop(start, end);
String *wanted = Str_newf("b%sc", smiley);
TEST_TRUE(runner, Str_Equals(substring, (Obj*)wanted),
"StrIter_crop");
TEST_TRUE(runner, StrIter_Starts_With(start, wanted),
"Starts_With returns true");
TEST_TRUE(runner, StrIter_Ends_With(end, wanted),
"Ends_With returns true");
DECREF(wanted);
DECREF(substring);
}
{
String *short_str = Str_newf("b%sx", smiley);
TEST_FALSE(runner, StrIter_Starts_With(start, short_str),
"Starts_With returns false");
TEST_FALSE(runner, StrIter_Ends_With(start, short_str),
"Ends_With returns false");
String *long_str = Str_newf("b%sxxxxxxxxxxxx%sc", smiley, smiley);
TEST_FALSE(runner, StrIter_Starts_With(start, long_str),
"Starts_With long string returns false");
TEST_FALSE(runner, StrIter_Ends_With(end, long_str),
"Ends_With long string returns false");
DECREF(short_str);
DECREF(long_str);
}
{
String *substring = StrIter_crop(end, NULL);
String *wanted = Str_newf("%sd", smiley);
TEST_TRUE(runner, Str_Equals(substring, (Obj*)wanted),
"StrIter_crop with NULL tail");
DECREF(wanted);
DECREF(substring);
}
{
String *substring = StrIter_crop(NULL, start);
String *wanted = Str_newf("a%s", smiley);
TEST_TRUE(runner, Str_Equals(substring, (Obj*)wanted),
"StrIter_crop with NULL top");
DECREF(wanted);
DECREF(substring);
}
DECREF(start);
DECREF(end);
DECREF(string);
}
static void
test_iterator(TestBatchRunner *runner) {
static const int32_t code_points[] = {
0x41,
0x7F,
0x80,
0x7FF,
0x800,
0xFFFF,
0x10000,
0x10FFFF
};
static size_t num_code_points
= sizeof(code_points) / sizeof(code_points[0]);
CharBuf *buf = CB_new(0);
for (size_t i = 0; i < num_code_points; ++i) {
CB_Cat_Char(buf, code_points[i]);
}
String *string = CB_To_String(buf);
{
StringIterator *iter = Str_Top(string);
TEST_TRUE(runner, StrIter_Equals(iter, (Obj*)iter),
"StringIterator equal to self");
TEST_FALSE(runner, StrIter_Equals(iter, (Obj*)CFISH_TRUE),
"StringIterator not equal non-iterators");
DECREF(iter);
}
{
StringIterator *top = Str_Top(string);
StringIterator *tail = Str_Tail(string);
TEST_INT_EQ(runner, StrIter_Compare_To(top, (Obj*)tail), -1,
"Compare_To top < tail");
TEST_INT_EQ(runner, StrIter_Compare_To(tail, (Obj*)top), 1,
"Compare_To tail > top");
TEST_INT_EQ(runner, StrIter_Compare_To(top, (Obj*)top), 0,
"Compare_To top == top");
StringIterator *clone = StrIter_Clone(top);
TEST_TRUE(runner, StrIter_Equals(clone, (Obj*)top), "Clone");
StrIter_Assign(clone, tail);
TEST_TRUE(runner, StrIter_Equals(clone, (Obj*)tail), "Assign");
String *other = Str_newf("Other string");
StringIterator *other_iter = Str_Top(other);
TEST_FALSE(runner, StrIter_Equals(other_iter, (Obj*)tail),
"Equals returns false for different strings");
StrIter_Assign(clone, other_iter);
TEST_TRUE(runner, StrIter_Equals(clone, (Obj*)other_iter),
"Assign iterator with different string");
DECREF(other);
DECREF(other_iter);
DECREF(clone);
DECREF(top);
DECREF(tail);
}
{
StringIterator *iter = Str_Top(string);
for (size_t i = 0; i < num_code_points; ++i) {
TEST_TRUE(runner, StrIter_Has_Next(iter), "Has_Next %d", i);
int32_t code_point = StrIter_Next(iter);
TEST_INT_EQ(runner, code_point, code_points[i], "Next %d", i);
}
TEST_TRUE(runner, !StrIter_Has_Next(iter),
"Has_Next at end of string");
TEST_INT_EQ(runner, StrIter_Next(iter), STR_OOB,
"Next at end of string");
StringIterator *tail = Str_Tail(string);
TEST_TRUE(runner, StrIter_Equals(iter, (Obj*)tail), "Equals tail");
DECREF(tail);
DECREF(iter);
}
{
StringIterator *iter = Str_Tail(string);
for (size_t i = num_code_points; i--;) {
TEST_TRUE(runner, StrIter_Has_Prev(iter), "Has_Prev %d", i);
int32_t code_point = StrIter_Prev(iter);
TEST_INT_EQ(runner, code_point, code_points[i], "Prev %d", i);
}
TEST_TRUE(runner, !StrIter_Has_Prev(iter),
"Has_Prev at end of string");
TEST_INT_EQ(runner, StrIter_Prev(iter), STR_OOB,
"Prev at start of string");
StringIterator *top = Str_Top(string);
TEST_TRUE(runner, StrIter_Equals(iter, (Obj*)top), "Equals top");
DECREF(top);
DECREF(iter);
}
{
StringIterator *iter = Str_Top(string);
StrIter_Next(iter);
TEST_INT_EQ(runner, StrIter_Advance(iter, 2), 2,
"Advance returns number of code points");
TEST_INT_EQ(runner, StrIter_Next(iter), code_points[3],
"Advance works");
TEST_INT_EQ(runner,
StrIter_Advance(iter, 1000000), num_code_points - 4,
"Advance past end of string");
StrIter_Prev(iter);
TEST_INT_EQ(runner, StrIter_Recede(iter, 2), 2,
"Recede returns number of code points");
TEST_INT_EQ(runner, StrIter_Prev(iter), code_points[num_code_points-4],
"Recede works");
TEST_INT_EQ(runner, StrIter_Recede(iter, 1000000), num_code_points - 4,
"Recede past start of string");
DECREF(iter);
}
DECREF(string);
DECREF(buf);
}
