denebola 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 605dec1949038f3bf81ca5b49d875231c515fdc656933467f2d34d1b1411da7e
-  data.tar.gz: 856f7ba61ad06df9f280850a4912259d1a76556cf32e0e5e8b8c78e6cec264e5
+  metadata.gz: f055c7610d7665e51b0f089b0d408584ed42eef42cc4511c9a18d46887618366
+  data.tar.gz: ced4c1c876d1e11e55089c61ce07a13679d0c53ec61a1734a8d85cb77447fd48
 SHA512:
-  metadata.gz: 02af176392f474c79428f0837f7ea44ed7198a25a56a250d6119b80ddc9a9bf6f5e5eba7e020417c3c3b922ec65912b075050e6224993b73e78f4da1c8cf1d79
-  data.tar.gz: 2d69fa29d55fb1970b30da016df0cc4730985ec286aaaa2048c08f17472f38e3904d37cefaa75961b6f3e476e1e86e3bd45fa1223dbe7101a2802dd480a2e8ed
+  metadata.gz: 83906a37466f697707ec32ef73b4ef3baf60a33ac95b757a18b463139593a72b6d16fa68d033f6f5caba82720f170f192344f25f78836ac298d4b750772a277e
+  data.tar.gz: 923e8951c8cd9621b2c194be56a40b8d5fa548ecf7bd5cef17c0b4f2449b7e4ffeeee2cda26baef2f313ad0af79a8e37905bb97b668b5a550f426bb5e4a467c8

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## Unreleased
+
+## 0.2.2 — 2026-09-18
+
+- Add persistent batched edits and bounded line-window access to `LazyRope`; related snapshots share one backing-file close lifecycle.
+
+## 0.2.1 — 2026-09-16
+
+- Keep same-offset batch edit ordering deterministic across ropes and anchors.
+- Transform right-biased anchors after every insertion and replacement at their boundary.
+
 ## 0.2.0 — 2026-09-15
 
 - Add `LazyRope` for bounded-memory access to very large UTF-8 files.

data/README.md

@@ -86,7 +86,7 @@ text.materialize(0...1024)           # an ordinary editable Rope
 text.close
 ```
 
-`LazyRope` reads 1 MiB chunks by default and keeps eight chunks in an LRU cache. `byteslice`, line access, byte/codepoint positions, UTF-16 positions, and anchors follow `Rope` semantics. `edit`, `insert`, `delete`, and `replace` mutate the open view and store only replacement text in memory; call `materialize` when an immutable `Rope` snapshot is needed. A file changed, removed, or replaced after opening raises `Denebola::Error`. `to_s` and `materialize` without a range intentionally load the complete logical file.
+`LazyRope` reads 1 MiB chunks by default and keeps eight chunks in an LRU cache. `byteslice`, line access, byte/codepoint positions, UTF-16 positions, and anchors follow `Rope` semantics. `edit`, `insert`, `delete`, and `replace` mutate the open view; `apply_edits` returns a persistent view while storing only replacement text in memory. Views in that snapshot family share one backing-file lifetime, so closing any view closes the family. Call `materialize` for an independent `Rope` snapshot. A file changed, removed, or replaced after opening raises `Denebola::Error`. `to_s` and `materialize` without a range intentionally load the complete logical file.
 
 ## Text Rope
 
@@ -109,7 +109,7 @@ rope.apply_edits([[0...5, "Hi"], [6...11, "Ruby"]]).to_s
 
 Ranges passed to `replace`, `apply_edits`, and `byteslice` address bytes in UTF-8. Bounds and codepoint boundaries are checked. Inclusive, exclusive, beginless, and endless Ruby ranges are accepted; invalid encodings, split codepoints, and overlapping batch edits raise exceptions.
 
-`apply_edits` applies nonoverlapping edits against one original snapshot and sorts them into source order. Adjacent ranges are allowed. Input strings are copied or shared safely with Ruby's copy-on-write strings, so later mutation of the source cannot alter a rope.
+`apply_edits` applies nonoverlapping edits against one original snapshot, and `Anchor#transform` uses the same source order. Adjacent ranges are allowed; zero-length insertions at the same offset keep input order and precede a replacement beginning there. Input strings are copied or shared safely with Ruby's copy-on-write strings, so later mutation of the source cannot alter a rope.
 
 Chunks preserve extended grapheme clusters when building or joining text. A single unusually long grapheme may exceed the configured chunk size; explicit byte slices and edits may operate between codepoints inside a grapheme.
 

data/lib/denebola/anchor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "edit"
+
 module Denebola
   # A position transformed explicitly by edits against its current snapshot.
   class Anchor
@@ -15,15 +17,22 @@ module Denebola
       delta = 0
       previous = 0
       transformed = nil
-      edits.sort_by { |range, _| range.begin }.each do |range, text|
+      normalized = edits.map do |range, text|
+        raise TypeError, "expected a Range of byte offsets" unless range.is_a?(Range)
         start = range.begin
         finish = range.end + (range.exclude_end? ? 0 : 1)
-        raise ArgumentError, "invalid or overlapping edits" unless start.is_a?(Integer) && start >= previous && finish >= start
+        raise ArgumentError, "invalid edit" unless start.is_a?(Integer) && finish.is_a?(Integer) && start >= 0 && finish >= start
+        [start, finish, Edit.normalize_text(text)]
+      end
+      Edit.sort(normalized).each do |start, finish, text|
+        raise ArgumentError, "invalid or overlapping edits" if start < previous
         previous = finish
         if offset < start
           transformed ||= offset + delta
         elsif offset <= finish
-          transformed ||= start + delta + (bias == :right ? text.bytesize : 0)
+          position = start + delta
+          transformed = position + text.bytesize if bias == :right
+          transformed ||= position
         end
         delta += text.bytesize - (finish - start)
       end

data/lib/denebola/edit.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Denebola
+  module Edit
+    def self.sort(edits)
+      edits.each_with_index.sort_by { |edit, index| [edit[0], edit[1], index] }.map!(&:first)
+    end
+
+    def self.normalize_text(text)
+      raise TypeError, "text must be a String" unless text.is_a?(String)
+      string = text.encoding == Encoding::UTF_8 ? text : text.encode(Encoding::UTF_8)
+      raise ArgumentError, "text must be valid UTF-8" unless string.valid_encoding?
+      string
+    end
+  end
+  private_constant :Edit
+end

data/lib/denebola/lazy_rope.rb

@@ -10,6 +10,20 @@ module Denebola
     TextPiece = Struct.new(:rope, keyword_init: true) do
       def bytesize = rope.bytesize
     end
+    class FileOwner
+      def initialize(file)
+        @file = file
+        @lock = Mutex.new
+      end
+
+      def closed? = @file.closed?
+
+      def close
+        @lock.synchronize { @file.close unless @file.closed? }
+        nil
+      end
+    end
+    private_constant :FileOwner
 
     attr_reader :chunk_size, :cached_bytes
 
@@ -25,6 +39,7 @@ module Denebola
       flags = File::RDONLY | File::BINARY
       flags |= File::SHARE_DELETE if defined?(File::SHARE_DELETE)
       @file = File.open(path, flags)
+      @file_owner = FileOwner.new(@file)
       @path = File.expand_path(path)
       @chunk_size = chunk_size
       @cache_chunks = cache_chunks
@@ -45,7 +60,7 @@ module Denebola
     end
 
     def lazy? = true
-    def closed? = @file.closed?
+    def closed? = @file_owner.closed?
 
     def bytesize
       ensure_unchanged!
@@ -94,6 +109,26 @@ module Denebola
       read_bytes(start, ending - start).force_encoding(Encoding::UTF_8).sub(/(?:\r\n|[\r\n\u2028\u2029])\z/, "")
     end
 
+    def line_end(row)
+      start = line_start(row)
+      index_until_line(row + 1)
+      ending = row + 1 < packed_line_count ? unpack_line_start(row + 1) : bytesize
+      tail = read_bytes([ending - 3, start].max, [ending - start, 3].min)
+      ending - (tail.end_with?("\r\n") ? 2 : tail.end_with?("\xE2\x80\xA8".b, "\xE2\x80\xA9".b) ? 3 : tail.end_with?("\r", "\n") ? 1 : 0)
+    end
+
+    def line_window(row, from: 0, max_bytes: 16_384)
+      raise TypeError, "from must be an Integer" unless from.is_a?(Integer)
+      raise ArgumentError, "max_bytes must be a nonnegative integer" unless max_bytes.is_a?(Integer) && max_bytes >= 0
+
+      start, ending = line_start(row), line_end(row)
+      offset = (start + from).clamp(start, ending)
+      offset -= 1 while offset > start && offset < ending && (read_bytes(offset, 1).getbyte(0) & 0xC0) == 0x80
+      value = read_bytes(offset, [max_bytes, ending - offset].min)
+      value = value.byteslice(0, complete_utf8_length(value)) unless value.empty?
+      [value.force_encoding(Encoding::UTF_8), offset - start]
+    end
+
     def byteslice(offset, length = nil)
       start, finish = slice_bounds(offset, length)
       Rope.new(read_bytes(start, finish - start).force_encoding(Encoding::UTF_8))
@@ -149,6 +184,34 @@ module Denebola
     def delete(range) = edit(range, "")
     def replace(range, text) = edit(range, text)
 
+    # Ranges address the original snapshot. The returned view has independent
+    # overlays, indexes, and cache. Snapshots share one backing-file lifetime:
+    # closing any snapshot closes the complete family.
+    def apply_edits(edits)
+      normalized = Edit.sort(edits.map do |range, text|
+        start, finish = byte_bounds(range)
+        validate_offset(start)
+        validate_offset(finish)
+        [start, finish, normalize_text(text)]
+      end)
+      previous = 0
+      normalized.each do |start, finish, _text|
+        raise ArgumentError, "overlapping edits" if start < previous
+        previous = finish
+      end
+      return self if normalized.empty?
+
+      updated = []
+      consumed = 0
+      normalized.each do |start, finish, text|
+        updated.concat(pieces_for(consumed, start))
+        updated << TextPiece.new(rope: Rope.new(text)).freeze unless text.empty?
+        consumed = finish
+      end
+      updated.concat(pieces_for(consumed, bytesize))
+      snapshot_with(coalesce(updated))
+    end
+
     def point_at(byte_offset)
       validate_offset(byte_offset)
       index_to([byte_offset + 1, bytesize].min)
@@ -236,8 +299,7 @@ module Denebola
     end
 
     def close
-      @file.close unless @file.closed?
-      nil
+      @file_owner.close
     end
 
     private
@@ -314,6 +376,17 @@ module Denebola
       @piece_ends = @pieces.map { |piece| total += piece.bytesize }
     end
 
+    def snapshot_with(pieces)
+      ensure_unchanged!
+      snapshot = dup
+      snapshot.instance_variable_set(:@cache, {})
+      snapshot.instance_variable_set(:@cached_bytes, 0)
+      snapshot.instance_variable_set(:@pieces, pieces.freeze)
+      snapshot.__send__(:rebuild_piece_ends)
+      snapshot.__send__(:reset_index)
+      snapshot
+    end
+
     def read_bytes(offset, count)
       ensure_unchanged!
       return "".b if count.zero?
@@ -562,7 +635,7 @@ module Denebola
     end
 
     def ensure_unchanged!
-      raise IOError, "closed file" if @file.closed?
+      raise IOError, "closed file" if closed?
       unchanged = file_stamp(@file.stat) == @stamp && file_stamp(File.stat(@path)) == @path_stamp
       raise Error, "file changed on disk; reopen it" unless unchanged
     rescue Errno::ENOENT

data/lib/denebola/rope.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "edit"
+
 module Denebola
   class Rope
     DEFAULT_CHUNK_SIZE = 1024
@@ -22,7 +24,7 @@ module Denebola
     def initialize(text = "", chunk_size: DEFAULT_CHUNK_SIZE, branching: Tree::DEFAULT_BRANCHING, tree: nil)
       raise ArgumentError, "chunk_size must be an integer >= 4" unless chunk_size.is_a?(Integer) && chunk_size >= 4
       @chunk_size = chunk_size
-      @tree = tree || Tree.new(chunks(normalize_text(text)), summary: TextSummary, branching: branching)
+      @tree = tree || Tree.new(chunks(Edit.normalize_text(text)), summary: TextSummary, branching: branching)
       freeze
     end
 
@@ -51,7 +53,7 @@ module Denebola
 
     def replace(range, text)
       start, finish = byte_bounds(range)
-      replacement = normalize_text(text)
+      replacement = Edit.normalize_text(text)
       first_index, first, prefix = locate_byte_offset(start)
       last_index, last, suffix = locate_byte_offset(finish)
       if first_index.positive? && start == prefix.bytesize
@@ -76,7 +78,7 @@ module Denebola
 
     # Ranges refer to the original snapshot. Adjacent edits are allowed; overlaps are rejected.
     def apply_edits(edits)
-      normalized = edits.map { |range, text| [*byte_bounds(range), normalize_text(text)] }.sort_by { |start, finish, _| [start, finish] }
+      normalized = Edit.sort(edits.map { |range, text| [*byte_bounds(range), Edit.normalize_text(text)] })
       previous = 0
       normalized.each do |start, finish, _|
         raise ArgumentError, "overlapping edits" if start < previous
@@ -234,13 +236,6 @@ module Denebola
       left.slice(0, left.size - 1).append(boundary).append(right.slice(1, right.size - 1))
     end
 
-    def normalize_text(text)
-      raise TypeError, "text must be a String" unless text.is_a?(String)
-      string = text.encoding == Encoding::UTF_8 ? text : text.encode(Encoding::UTF_8)
-      raise ArgumentError, "text must be valid UTF-8" unless string.valid_encoding?
-      string
-    end
-
     def chunks(text)
       return [] if text.empty?
       return [Chunk.new(text)] if text.bytesize <= chunk_size

data/lib/denebola/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Denebola
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/lib/denebola.rb

@@ -7,6 +7,7 @@ require_relative "denebola/cursor"
 require_relative "denebola/text_summary"
 require_relative "denebola/point"
 require_relative "denebola/dimensions"
+require_relative "denebola/edit"
 require_relative "denebola/rope"
 require_relative "denebola/anchor"
 require_relative "denebola/lazy_rope"

data/sig/denebola.rbs

@@ -162,7 +162,9 @@ module Denebola
     def utf16_length: () -> Integer
     def line_count: (?exact: bool) -> Integer
     def line_start: (Integer) -> Integer
+    def line_end: (Integer) -> Integer
     def line: (Integer) -> String
+    def line_window: (Integer, ?from: Integer, ?max_bytes: Integer) -> [String, Integer]
     def byteslice: (Integer | Range[Integer?], ?Integer?) -> Rope
     def each_chunk: () { (String) -> void } -> self
                   | () -> Enumerator[String, self]
@@ -172,6 +174,7 @@ module Denebola
     def insert: (Integer, String) -> self
     def delete: (Range[Integer?]) -> self
     def replace: (Range[Integer?], String) -> self
+    def apply_edits: (Array[[Range[Integer?], String]]) -> LazyRope
     def point_at: (Integer) -> Point
     def offset_at: (Point) -> Integer
     def utf16_offset_at: (Integer) -> Integer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: denebola
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Yudai Takada
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-15 00:00:00.000000000 Z
+date: 2026-09-18 00:00:00.000000000 Z
 dependencies: []
 description: Immutable text ropes plus bounded-memory, file-backed editing with line
   and UTF-16 indexing.
@@ -25,6 +25,7 @@ files:
 - lib/denebola/anchor.rb
 - lib/denebola/cursor.rb
 - lib/denebola/dimensions.rb
+- lib/denebola/edit.rb
 - lib/denebola/error.rb
 - lib/denebola/lazy_rope.rb
 - lib/denebola/point.rb