Words module

In keeping with the new nomenclature, we're calling the module "Words",
not "WordBreak".  The latter is Unicode jargon, the module provides word
iterators.  Words are the figure, word breaks are the ground.

2 files changed, 24 insertions, 24 deletions

diff --git a/src/Words.zig b/src/Words.zig
index 6a532f5..565a2fb 100644
--- a/src/Words.zig
+++ b/src/Words.zig
@@ -25,15 +25,15 @@ const WordBreakProperty = enum(u5) {
 s1: []u16 = undefined,
 s2: []u5 = undefined,
 
-const WordBreak = @This();
+const Words = @This();
 
-pub fn init(allocator: Allocator) Allocator.Error!WordBreak {
-    var wb: WordBreak = undefined;
+pub fn init(allocator: Allocator) Allocator.Error!Words {
+    var wb: Words = undefined;
     try wb.setup(allocator);
     return wb;
 }
 
-pub fn setup(wb: *WordBreak, allocator: Allocator) Allocator.Error!void {
+pub fn setup(wb: *Words, allocator: Allocator) Allocator.Error!void {
     wb.setupImpl(allocator) catch |err| {
         switch (err) {
             error.OutOfMemory => |e| return e,
@@ -42,7 +42,7 @@ pub fn setup(wb: *WordBreak, allocator: Allocator) Allocator.Error!void {
     };
 }
 
-pub fn deinit(wordbreak: *const WordBreak, allocator: mem.Allocator) void {
+pub fn deinit(wordbreak: *const Words, allocator: mem.Allocator) void {
     allocator.free(wordbreak.s1);
     allocator.free(wordbreak.s2);
 }
@@ -60,19 +60,19 @@ pub const Word = struct {
 };
 
 /// Returns the word break property type for `cp`.
-pub fn breakProperty(wordbreak: *const WordBreak, cp: u21) WordBreakProperty {
+pub fn breakProperty(wordbreak: *const Words, cp: u21) WordBreakProperty {
     return @enumFromInt(wordbreak.s2[wordbreak.s1[cp >> 8] + (cp & 0xff)]);
 }
 
 /// Convenience function for working with CodePoints
-fn breakProp(wb: *const WordBreak, point: CodePoint) WordBreakProperty {
+fn breakProp(wb: *const Words, point: CodePoint) WordBreakProperty {
     return @enumFromInt(wb.s2[wb.s1[point.code >> 8] + (point.code & 0xff)]);
 }
 
 /// Returns the Word at the given index.  Asserts that the index is less than
 /// `string.len`, and that the string is not empty. Always returns a word.
 /// The index does not have to be the start of a codepoint in the word.
-pub fn wordAtIndex(wordbreak: *const WordBreak, string: []const u8, index: usize) Word {
+pub fn wordAtIndex(wordbreak: *const Words, string: []const u8, index: usize) Word {
     assert(index < string.len and string.len > 0);
     var iter_back: ReverseIterator = initAtIndex(wordbreak, string, index);
     const first_back = iter_back.prev();
@@ -118,12 +118,12 @@ pub fn wordAtIndex(wordbreak: *const WordBreak, string: []const u8, index: usize
 }
 
 /// Returns an iterator over words in `slice`.
-pub fn iterator(wordbreak: *const WordBreak, slice: []const u8) Iterator {
+pub fn iterator(wordbreak: *const Words, slice: []const u8) Iterator {
     return Iterator.init(wordbreak, slice);
 }
 
 /// Returns a reverse iterator over the words in `slice`.
-pub fn reverseIterator(wordbreak: *const WordBreak, slice: []const u8) ReverseIterator {
+pub fn reverseIterator(wordbreak: *const Words, slice: []const u8) ReverseIterator {
     return ReverseIterator.init(wordbreak, slice);
 }
 
@@ -132,10 +132,10 @@ pub const Iterator = struct {
     this: ?CodePoint = null,
     that: ?CodePoint = null,
     cp_iter: CodepointIterator,
-    wb: *const WordBreak,
+    wb: *const Words,
 
     /// Assumes `str` is valid UTF-8.
-    pub fn init(wb: *const WordBreak, str: []const u8) Iterator {
+    pub fn init(wb: *const Words, str: []const u8) Iterator {
         var wb_iter: Iterator = .{ .cp_iter = .init(str), .wb = wb };
         wb_iter.advance();
         return wb_iter;
@@ -314,11 +314,11 @@ pub const ReverseIterator = struct {
     after: ?CodePoint = null,
     before: ?CodePoint = null,
     cp_iter: ReverseCodepointIterator,
-    wb: *const WordBreak,
+    wb: *const Words,
     flags: usize = 0,
 
     /// Assumes `str` is valid UTF-8.
-    pub fn init(wb: *const WordBreak, str: []const u8) ReverseIterator {
+    pub fn init(wb: *const Words, str: []const u8) ReverseIterator {
         var wb_iter: ReverseIterator = .{ .cp_iter = .init(str), .wb = wb };
         wb_iter.advance();
         return wb_iter;
@@ -511,7 +511,7 @@ pub const ReverseIterator = struct {
 //| Implementation Details
 
 /// Initialize a ReverseIterator at the provided index. Used in `wordAtIndex`.
-fn initAtIndex(wb: *const WordBreak, string: []const u8, index: usize) ReverseIterator {
+fn initAtIndex(wb: *const Words, string: []const u8, index: usize) ReverseIterator {
     var idx: u32 = @intCast(index);
     // Find the next lead byte:
     while (idx < string.len and 0x80 <= string[idx] and string[idx] <= 0xBf) : (idx += 1) {}
@@ -536,7 +536,7 @@ fn sneaky(iter: *const ReverseIterator) SneakIterator {
 
 const SneakIterator = struct {
     cp_iter: ReverseCodepointIterator,
-    wb: *const WordBreak,
+    wb: *const Words,
 
     fn peek(iter: *SneakIterator) ?CodePoint {
         const save_cp = iter.cp_iter;
@@ -570,7 +570,7 @@ const SneakIterator = struct {
     }
 };
 
-inline fn setupImpl(wb: *WordBreak, allocator: Allocator) !void {
+inline fn setupImpl(wb: *Words, allocator: Allocator) !void {
     const decompressor = compress.flate.inflate.decompressor;
     const in_bytes = @embedFile("wbp");
     var in_fbs = std.io.fixedBufferStream(in_bytes);
@@ -627,7 +627,7 @@ inline fn isExtensible(wbp: WordBreakProperty) bool {
 }
 
 test "Word Break Properties" {
-    const wb = try WordBreak.init(testing.allocator);
+    const wb = try Words.init(testing.allocator);
     defer wb.deinit(testing.allocator);
     try testing.expectEqual(.CR, wb.breakProperty('\r'));
     try testing.expectEqual(.LF, wb.breakProperty('\n'));
@@ -641,7 +641,7 @@ test "ext_pict" {
 }
 
 test wordAtIndex {
-    const wb = try WordBreak.init(testing.allocator);
+    const wb = try Words.init(testing.allocator);
     defer wb.deinit(testing.allocator);
     const t_string = "first second third";
     const second = wb.wordAtIndex(t_string, 8);
@@ -663,7 +663,7 @@ test wordAtIndex {
 const testr = "don't a:ka fin!";
 
 test "reversal" {
-    const wb = try WordBreak.init(testing.allocator);
+    const wb = try Words.init(testing.allocator);
     defer wb.deinit(testing.allocator);
     {
         var fwd = wb.iterator(testr);
@@ -696,7 +696,7 @@ test "reversal" {
 }
 
 fn testAllocations(allocator: Allocator) !void {
-    const wb = try WordBreak.init(allocator);
+    const wb = try Words.init(allocator);
     wb.deinit(allocator);
 }
 
diff --git a/src/unicode_tests.zig b/src/unicode_tests.zig
index 7139d4c..18f1814 100644
--- a/src/unicode_tests.zig
+++ b/src/unicode_tests.zig
@@ -211,7 +211,7 @@ test "Segmentation Word Iterator" {
     var buf_reader = std.io.bufferedReader(file.reader());
     var input_stream = buf_reader.reader();
 
-    const wb = try WordBreak.init(allocator);
+    const wb = try Words.init(allocator);
     defer wb.deinit(allocator);
 
     var buf: [4096]u8 = undefined;
@@ -392,5 +392,5 @@ const Graphemes = @import("Graphemes");
 const GraphemeIterator = @import("Graphemes").Iterator;
 const Normalize = @import("Normalize");
 
-const WordBreak = @import("WordBreak");
-const Word = WordBreak.Word;
+const Words = @import("Words");
+const Word = Words.Word;