canopus 0.4.0 → 0.5.0

data/lib/canopus/editor.rb

@@ -4,23 +4,26 @@ require_relative "selection"
 
 module Canopus
   class Editor
-    PAIRS = {"(" => ")", "[" => "]", "{" => "}", '"' => '"', "'" => "'"}.freeze
+    DEFAULT_CLOSING_PAIRS = {"(" => ")", "[" => "]", "{" => "}", '"' => '"', "'" => "'"}.freeze
     attr_reader :buffer, :display_map, :selections, :scroll_x, :scroll_y
-    attr_accessor :tab_size, :use_tabs, :auto_pairs, :composition, :viewport_rows, :relative_line_numbers
+    attr_accessor :tab_size, :use_tabs, :auto_pairs, :closing_pairs, :composition, :viewport_rows, :relative_line_numbers
 
     def initialize(buffer = Buffer.new, wrap_width: nil, tab_size: 4)
       @buffer, @next_selection = buffer, 0
-      @tab_size, @use_tabs, @auto_pairs = tab_size, false, true
+      @tab_size, @use_tabs, @auto_pairs, @closing_pairs = tab_size, false, true, DEFAULT_CLOSING_PAIRS
       @display_map = DisplayMap.new(buffer, wrap_width: wrap_width, tab_size: tab_size)
       @scroll_x, @scroll_y, @viewport_rows = 0, 0, 30
       select(0)
       @subscription = buffer.on_edit do |patch|
         @display_map.block_map.blocks.values.each { |block| @display_map.remove_block(block.id) if block.kind == :git_diff }
+        previous = @selections
         @selections = @selections.map { |s| Selection.new(s.id, patch.map_offset(s.anchor), patch.map_offset(s.head), s.goal) }.freeze
+        notify_selection if @selections != previous
       end
     end
     def dispose
       @subscription.detach
+      @selection_listeners&.clear
       @display_map.dispose
       @language_document&.dispose
       clear_snippet
@@ -40,23 +43,30 @@ module Canopus
       self
     end
 
-    def set_selections(selections)
-      merged = []
-      selections.sort_by(&:start).each do |selection|
-        if merged.last && (selection.start < merged.last.end || (selection.start == merged.last.end && !snippet_active?))
-          previous = merged.pop
-          merged << Selection.new(previous.id, previous.start, [previous.end, selection.end].max, selection.goal)
-        else
-          merged << selection
-        end
+    def on_selection(&listener)
+      raise ArgumentError, "selection listener required" unless listener
+      (@selection_listeners ||= []) << listener
+      Zaniah::Subscription.new { @selection_listeners.delete(listener) }
+    end
+
+    def set_selections(selections, merge: true)
+      previous = @selections
+      unless merge
+        @selections = ordered_selections(selections).freeze
+        @buffer.selections = @selections
+        notify_selection if @selections != previous
+        return @selections
       end
-      @selections = merged.freeze
+      @selections = merged_selections(selections).freeze
       @buffer.selections = @selections
+      notify_selection if @selections != previous
+      @selections
     end
 
-    def insert_text(text, auto_indent: true)
+    def insert_text(text, auto_indent: true, pair: true)
       raise ArgumentError, "text must be UTF-8" unless text.is_a?(String) && text.valid_encoding?
-      texts = @selections.map do |selection|
+      closer = @closing_pairs[text] if pair && @auto_pairs
+      texts = merged_selections(@selections, touching: false).map do |selection|
         if text == "\n" && auto_indent
           indent = language_document.indent_for(selection.start, tab_size: @tab_size, use_tabs: @use_tabs)
           if language_document.definition == Language::PLAIN
@@ -64,30 +74,40 @@ module Canopus
             indent += @use_tabs ? "\t" : " " * @tab_size if before.rstrip.end_with?("{", "[", "(")
           end
           @buffer.line_ending + indent
-        elsif @auto_pairs && PAIRS.key?(text)
-          text + @buffer.rope.byteslice(selection.range).to_s + PAIRS[text]
+        elsif closer
+          text + @buffer.rope.byteslice(selection.range).to_s + closer
         else
           text
         end
       end
-      paired = @auto_pairs && PAIRS.key?(text)
-      replace_selections(texts, kind: :typing, group: true, cursor_back: paired ? PAIRS[text].bytesize : 0)
+      replace_selections(texts, kind: :typing, group: true, cursor_back: closer ? closer.bytesize : 0)
       reveal_cursor
     end
 
     def replace_selections(texts, kind: :edit, group: false, cursor_back: 0, before_selections: @selections)
-      texts = Array.new(@selections.length, texts) if texts.is_a?(String)
-      raise ArgumentError, "one text per selection required" unless texts.length == @selections.length
-      changes = @selections.zip(texts).map { |selection, text| [selection.range, text] }
+      selections = merged_selections(@selections, touching: false)
+      if texts.is_a?(Array)
+        unless [@selections.length, selections.length].include?(texts.length)
+          raise ArgumentError, "one text per selection required"
+        end
+        if selections.length != @selections.length
+          raise ArgumentError, "overlapping selections require the same text" unless texts.uniq.length == 1
+          texts = texts.first
+        end
+      end
+      texts = Array.new(selections.length, texts) if texts.is_a?(String)
+      raise ArgumentError, "one text per selection required" unless texts.length == selections.length
+      changes = selections.zip(texts).map { |selection, text| [selection.range, text] }
       @buffer.selections = before_selections
       delta = 0
-      after = @selections.zip(texts).map do |selection, text|
+      after = selections.zip(texts).map do |selection, text|
         ending = selection.start + delta + text.bytesize - cursor_back
         delta += text.bytesize - (selection.end - selection.start)
         Selection.new(selection.id, ending, ending, nil)
       end
+      after = merged_selections(after)
       @buffer.edit(changes, kind: kind, selections: after, before_selections: before_selections, group: group)
-      set_selections(after)
+      set_selections(after, merge: false)
     end
 
     def delete_backward
@@ -108,14 +128,14 @@ module Canopus
     def undo
       clear_snippet
       return false unless @buffer.undo
-      set_selections(@buffer.selections)
+      set_selections(@buffer.selections, merge: false)
       reveal_cursor
       true
     end
     def redo
       clear_snippet
       return false unless @buffer.redo
-      set_selections(@buffer.selections)
+      set_selections(@buffer.selections, merge: false)
       reveal_cursor
       true
     end
@@ -166,6 +186,18 @@ module Canopus
     end
 
     def select_all = select(0, @buffer.rope.bytesize)
+    def select_matches(pattern, **options)
+      matches = search(pattern, **options)
+      return matches if matches.empty?
+      selections = matches.map do |range|
+        selection = Selection.new(@next_selection, range.begin, range.end, nil)
+        @next_selection += 1
+        selection
+      end
+      set_selections(selections, merge: false)
+      reveal_cursor
+      matches
+    end
     def select_next_occurrence(all: false)
       needle = @buffer.rope.byteslice(primary.range).to_s
       if needle.empty?
@@ -186,13 +218,47 @@ module Canopus
     end
 
     def rectangle(first, last)
-      selections = (first.row..last.row).map do |row|
-        anchor = @display_map.to_buffer(DisplayPoint.new(row, first.column))
-        head = @display_map.to_buffer(DisplayPoint.new(row, last.column))
+      selections = BlockSelection.new(first, last).filter_map do |anchor, head|
+        next unless @display_map.row(anchor.row).kind == :text
+        selection = Selection.new(@next_selection, @display_map.to_buffer(anchor), @display_map.to_buffer(head), nil)
         @next_selection += 1
-        Selection.new(@next_selection, anchor, head, nil)
+        selection
       end
-      set_selections(selections)
+      return if selections.empty?
+      set_selections(selections, merge: false)
+    end
+    def add_cursor(direction)
+      raise ArgumentError, "cursor direction must be up or down" unless %i[up down].include?(direction)
+      edge = @selections.public_send(direction == :up ? :min_by : :max_by) { |selection| @display_map.to_display(selection.head).row }
+      point = @display_map.to_display(edge.head)
+      row = point.row + (direction == :up ? -1 : 1)
+      column = edge.goal || point.column
+      offset = nil
+      loop do
+        return unless row.between?(0, @display_map.row_count - 1)
+        unless @display_map.row(row).kind == :text
+          row += direction == :up ? -1 : 1
+          next
+        end
+        offset = @display_map.to_buffer(DisplayPoint.new(row, column))
+        break unless @selections.any? { |selection| selection.empty? && selection.head == offset }
+        row += direction == :up ? -1 : 1
+      end
+
+      selection = Selection.new(@next_selection, offset, offset, column)
+      @next_selection += 1
+      set_selections([*@selections, selection], merge: false)
+    end
+    def add_cursors_to_selected_lines(edge)
+      raise ArgumentError, "line edge must be start or end" unless %i[start end].include?(edge)
+      selections = selected_rows.map do |row|
+        start = @buffer.rope.line_start(row)
+        offset = edge == :start ? start : start + @buffer.line(row).bytesize
+        selection = Selection.new(@next_selection, offset, offset, nil)
+        @next_selection += 1
+        selection
+      end
+      set_selections(selections, merge: false)
     end
     def indent(outdent: false)
       change_lines(:indent) do |line|
@@ -353,6 +419,31 @@ module Canopus
     end
 
     private
+    def notify_selection
+      @selection_listeners&.dup&.each do |listener|
+        listener.call(@selections)
+      rescue StandardError => error
+        begin
+          warn "Canopus selection notification failed: #{error.message}"
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    def merged_selections(selections, touching: !snippet_active?)
+      ordered_selections(selections).each_with_object([]) do |selection, merged|
+        if merged.last && (selection.start < merged.last.end || (touching && selection.start == merged.last.end))
+          previous = merged.pop
+          merged << Selection.new(previous.id, previous.start, [previous.end, selection.end].max, selection.goal)
+        else
+          merged << selection
+        end
+      end
+    end
+    def ordered_selections(selections)
+      selections.each_with_index.sort_by { |selection, index| [selection.start, index] }.map!(&:first)
+    end
     def horizontal(offset, direction)
       if @buffer.rope.respond_to?(:lazy?)
         rope = @buffer.rope

data/lib/canopus/git/state.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Git
+    class State
+      CACHE_LIMIT = 20
+      Snapshot = Data.define(:head, :branch, :index_stamp, :entries) do
+        def identity = [head, branch, index_stamp].freeze
+      end
+
+      attr_reader :snapshot
+
+      def initialize(repository)
+        @repository = repository
+        @repository_lock = Mutex.new
+        @diff_cache = {}
+      end
+
+      def capture
+        synchronize do |repository|
+          3.times do
+            before = repository_identity
+            entries = repository.status.to_h do |entry|
+              [entry.path.dup.freeze, entry.code.dup.freeze]
+            end.freeze
+            after = repository_identity
+            return Snapshot.new(*after, entries) if before == after
+          end
+          raise Thuban::RefLockError, "Git HEAD or index changed while reading status"
+        end
+      end
+
+      def identity
+        synchronize do |repository|
+          [freeze_string(repository.head), freeze_string(repository.branch), index_stamp(repository)].freeze
+        end
+      end
+
+      def install(snapshot)
+        raise ArgumentError, "invalid Git snapshot" unless snapshot.is_a?(Snapshot)
+
+        @snapshot = snapshot
+      end
+
+      def invalidate
+        @snapshot = nil
+        @diff_cache.clear
+      end
+
+      def cached_diff(key) = @diff_cache[key]
+
+      def store_diff(key, diff)
+        @diff_cache.clear if @diff_cache.length >= CACHE_LIMIT && !@diff_cache.key?(key)
+        @diff_cache[key] = diff
+      end
+
+      def synchronize(snapshot: nil, index_lock: false, &block)
+        @repository_lock.synchronize do
+          operation = lambda do
+            if snapshot && snapshot.identity != repository_identity
+              raise Thuban::RefLockError, "Git HEAD or index changed since it was displayed"
+            end
+
+            block.call(@repository)
+          end
+          index_lock ? with_index_lock(&operation) : operation.call
+        end
+      end
+
+      private
+
+      def freeze_string(value) = value&.dup&.freeze
+
+      def index_stamp(repository)
+        path = File.join(repository.git_dir, "index")
+        return unless File.file?(path)
+
+        stat = File.stat(path)
+        [stat.mtime.to_i, stat.mtime.nsec, stat.size, stat.ino].freeze
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      end
+
+      def repository_identity
+        [freeze_string(@repository.head), freeze_string(@repository.branch), index_stamp(@repository)].freeze
+      end
+
+      def with_index_lock
+        path = File.join(@repository.git_dir, "index.lock")
+        lock = File.open(path, File::WRONLY | File::CREAT | File::EXCL | File::BINARY, 0o644)
+        yield
+      rescue Errno::EEXIST
+        raise Thuban::RefLockError, "Git index is locked: #{path}"
+      ensure
+        lock&.close
+        File.unlink(path) if lock && File.exist?(path)
+      end
+    end
+  end
+end

data/lib/canopus/language/background_analysis.rb

@@ -8,6 +8,8 @@ module Canopus
       LINE_LIMIT = 16 << 10
       ROW_LIMIT = 256
       CACHE_ROWS = 512
+      SELECTION_LIMIT = 256
+      SELECTION_RANGE_LIMIT = 10_000
       Snapshot = Data.define(:rope, :version, :id, :name, :lexer, :first, :last, :syntax)
       attr_reader :analysis_error
 
@@ -83,10 +85,38 @@ module Canopus
       def diagnostics = (request(syntax: true); @syntax ? @syntax[:diagnostics] : EMPTY)
       def fold_ranges = (request(syntax: true); @syntax ? @syntax[:folds] : EMPTY)
       def bracket_at(offset) = (request(syntax: true); @syntax && @syntax[:brackets][offset])
+      def brackets(rows = nil)
+        request(syntax: true)
+        values = @syntax ? @syntax[:bracket_pairs] : EMPTY
+        rows ? values.select { |pair| pair.close_row >= rows.begin && pair.open_row < rows.end } : values
+      end
+      def structure_regions = (request(syntax: true); @syntax ? @syntax[:structure_regions] : EMPTY)
+      def selection_ranges(offsets)
+        unless offsets.is_a?(Array) && offsets.length.between?(1, SELECTION_LIMIT)
+          raise ArgumentError, "selection offsets must contain 1..#{SELECTION_LIMIT} entries"
+        end
+        positions = offsets.each_with_index.map do |offset, index|
+          point = @buffer.rope.point_at(offset)
+          [index, point.row, point.column, offset].freeze
+        end.freeze
+        unless @selection_positions&.map(&:last) == offsets
+          @job&.cancel
+          @job = nil
+          @selection_positions, @selection_results = positions, {}
+          @generation += 1
+          @failed = false
+          @analysis_error = nil
+          @dirty = missing_work?
+        end
+        return unless @selection_results.length == positions.length
+
+        positions.map { |index,| @selection_results.fetch(index) }.freeze
+      end
 
       def invalidate(patch)
         @job&.cancel
         @job = @syntax = nil
+        @selection_positions = @selection_results = nil
         @syntax_rows.clear
         if patch.is_a?(Patch::Reload)
           @tokens.clear
@@ -112,6 +142,12 @@ module Canopus
           result = job.future.await(timeout: 0)
           if @submitted_version == @buffer.version && @submitted_generation == @generation
             result[:tokens].each { |row, tokens| @tokens[row] = tokens; @stale.delete(row) }
+            if @selection_results
+              result[:selections].each { |index, ranges| @selection_results[index] = ranges }
+              if @selection_results.values.sum(&:length) > SELECTION_RANGE_LIMIT
+                raise Error, "too many background selection ranges"
+              end
+            end
             while @tokens.length > CACHE_ROWS
               @tokens.delete(@tokens.each_key.find { |row| !@rows.include?(row) })
             end
@@ -128,15 +164,17 @@ module Canopus
           @scheduler ||= Scheduler.acquire
           # A folded viewport can contain distant source rows. Fill one missing
           # contiguous run at a time without paint changing/cancelling its job.
-          missing = @rows.select { |row| row_needed?(row) }
-          missing = @rows if missing.empty?
+          rows = work_rows
+          missing = rows.select { |row| row_needed?(row) }
+          missing = rows if missing.empty?
           first = last = missing.first
           missing.drop(1).each do |row|
             break unless row == last + 1
             last = row
           end
           snapshot = Snapshot.new(@buffer.rope, @buffer.version, @id,
-            @document.definition.name, @document.definition.lexer, first, last, !!(@want_syntax && !syntax_complete?))
+            @document.definition.name, @document.definition.lexer, first, last,
+            {syntax: !!(@want_syntax && !syntax_complete?), selections: @selection_positions}.freeze)
           if (@job = @scheduler.submit(snapshot, prior_syntax: @syntax))
             @submitted_version, @submitted_generation = @buffer.version, @generation
           end
@@ -162,6 +200,7 @@ module Canopus
         @provisional.clear
         @syntax_rows.clear
         @syntax = nil
+        @selection_positions = @selection_results = nil
         @analysis_error = nil
       end
 
@@ -205,10 +244,16 @@ module Canopus
         last = [last, end_row].min
         job.check!
         source = rope.byteslice(from, to - from).to_s.freeze
+        selection_request = snapshot.syntax.is_a?(Hash) ? snapshot.syntax : {}
+        syntax = selection_request.fetch(:syntax, snapshot.syntax == true)
+        selections = Array(selection_request[:selections]).filter_map do |index, row, column, _offset|
+          [index, row, column] if row.between?(rope.point_at(from).row, end_row)
+        end
         {"id" => snapshot.id, "version" => snapshot.version, "name" => snapshot.name,
           "lexer" => snapshot.lexer, "source" => source, "base" => from,
           "base_line" => rope.point_at(from).row, "first" => first, "last" => last,
-          "syntax" => snapshot.syntax, "complete" => complete, "context" => context}.freeze
+          "syntax" => syntax, "selections" => selections.freeze,
+          "complete" => complete, "context" => context}.freeze
       end
 
       def self.decode(response, prior_syntax: nil)
@@ -220,17 +265,39 @@ module Canopus
           outline = raw.fetch("outline").map do |name, kind, first, last, start, finish, depth|
             Language::Symbol.new(name.freeze, kind.to_sym, (first...last).freeze, (start...finish).freeze, depth)
           end.freeze
-          brackets = {}
-          raw.fetch("brackets").each do |first, last|
-            range = (first...last).freeze
-            brackets[first] = brackets[last - 1] = range
+          bracket_pairs = raw.fetch("brackets").map do |open_first, open_last, open_row, close_first, close_last, close_row, depth|
+            Language::Bracket.new((open_first...open_last).freeze, (close_first...close_last).freeze,
+              open_row, close_row, depth).freeze
+          end.freeze
+          brackets = bracket_pairs.each_with_object({}) do |pair, result|
+            range = (pair.open_range.begin...pair.close_range.end).freeze
+            result[pair.open_range.begin] = result[pair.close_range.begin] = range
           end
           {outline: outline, diagnostics: raw.fetch("diagnostics").map { |first, last, message| {range: (first...last).freeze, message: message.freeze, severity: 1}.freeze }.freeze,
             folds: raw.fetch("folds").map { |first, last| (first...last).freeze }.freeze,
-            brackets: brackets.freeze, complete: response.fetch("complete")}.freeze
+            brackets: brackets.freeze, bracket_pairs: bracket_pairs,
+            structure_regions: raw.fetch("structure_regions").map { |first, last, kind| {start_line: first, end_line: last, kind: kind.to_sym}.freeze }.freeze,
+            complete: response.fetch("complete")}.freeze
         end
         syntax = merge_syntax(prior_syntax, syntax) if prior_syntax && syntax && !syntax[:complete]
-        {tokens: tokens, syntax: syntax}.freeze
+        values = response.fetch("selections", [])
+        unless values.is_a?(Array) && values.length <= SELECTION_LIMIT
+          raise Error, "invalid background selection ranges"
+        end
+        seen, total = {}, 0
+        selections = values.to_h do |index, ranges|
+          total += ranges.length if ranges.is_a?(Array)
+          unless index.is_a?(Integer) && index.between?(0, SELECTION_LIMIT - 1) && !seen.key?(index) &&
+              ranges.is_a?(Array) && total <= SELECTION_RANGE_LIMIT && ranges.all? do |range|
+                range.is_a?(Array) && range.length == 2 && range.all? { |value| value.is_a?(Integer) && value >= 0 } &&
+                  range[0] <= range[1]
+              end
+            raise Error, "invalid background selection ranges"
+          end
+          seen[index] = true
+          [index, ranges.map { |first, last| (first...last).freeze }.freeze]
+        end.freeze
+        {tokens: tokens, syntax: syntax, selections: selections}.freeze
       end
 
       # Decoding and bounded merging happen on a preparation thread, never in
@@ -238,17 +305,29 @@ module Canopus
       def self.merge_syntax(previous, current)
         return previous if previous[:complete]
         outlines = (previous[:outline] + current[:outline]).uniq { |item| [item.name, item.kind, item.range, item.selection] }
-        brackets = (previous[:brackets].values + current[:brackets].values).uniq.first(8192)
+        bracket_pairs = (previous.fetch(:bracket_pairs, []) + current.fetch(:bracket_pairs, []))
+          .uniq { |pair| [pair.open_range, pair.close_range] }.first(8192)
+        brackets = bracket_pairs.each_with_object({}) do |pair, result|
+          range = (pair.open_range.begin...pair.close_range.end).freeze
+          result[pair.open_range.begin] = result[pair.close_range.begin] = range
+        end
+        structure_regions = (previous.fetch(:structure_regions, []) + current.fetch(:structure_regions, []))
+          .uniq { |region| [region[:start_line], region[:end_line], region[:kind]] }.first(10_000)
         {outline: outlines.sort_by { |item| item.selection.begin }.first(10_000).freeze,
           diagnostics: (previous[:diagnostics] + current[:diagnostics]).uniq.first(1000).freeze,
           folds: (previous[:folds] + current[:folds]).uniq.sort_by(&:begin).first(10_000).freeze,
-          brackets: brackets.each_with_object({}) { |range, result| result[range.begin] = result[range.end - 1] = range }.freeze,
+          brackets: brackets.freeze, bracket_pairs: bracket_pairs.freeze,
+          structure_regions: structure_regions.freeze,
           complete: false}.freeze
       end
 
       private
-      def row_needed?(row) = !@tokens.key?(row) || (@want_syntax && !syntax_complete? && !@syntax_rows.key?(row))
-      def missing_work? = @rows.any? { |row| row_needed?(row) }
+      def row_needed?(row)
+        !@tokens.key?(row) || (@want_syntax && !syntax_complete? && !@syntax_rows.key?(row)) ||
+          @selection_positions&.any? { |index, selection_row,| selection_row == row && !@selection_results.key?(index) }
+      end
+      def work_rows = [*@rows, *@selection_positions&.map { |_, row,| row }].compact.uniq.sort
+      def missing_work? = work_rows.any? { |row| row_needed?(row) }
 
       def retain_unchanged_rows(patch)
         return if patch.edits.empty?

data/lib/canopus/language/document.rb

@@ -29,14 +29,15 @@ module Canopus
         highlighter.tokens_for(row)
       end
       # Explicit synchronous escape hatch. Asynchronous UI paths never call this.
-      def highlighter(strategy: nil, window_context: nil)
+      def highlighter(strategy: nil, window_context: nil, max_seconds: nil)
         return @highlighter if @highlighter
-        require "antares"
+        require "antares" unless defined?(Antares::Highlighter)
         large = @buffer.rope.bytesize > 1 << 20
         @highlighter = Antares::Highlighter.new(lexer: Rouge::Lexer.find(@definition.lexer).new,
           lines: ->(row) { @buffer.rope.byteslice(@buffer.rope.line_start(row), (row + 1 < @buffer.line_count ? @buffer.rope.line_start(row + 1) : @buffer.rope.bytesize) - @buffer.rope.line_start(row)).to_s },
           line_count: -> { @buffer.line_count }, strategy: strategy || (large ? :window : :auto),
-          window_context: window_context || (@buffer.rope.bytesize > 10 << 20 ? 0 : 500))
+          window_context: window_context || (@buffer.rope.bytesize > 10 << 20 ? 0 : 500),
+          max_seconds: max_seconds || 0.25)
       end
       def invalidate(patch)
         @background&.invalidate(patch)
@@ -88,7 +89,11 @@ module Canopus
       end
       def fold_ranges
         return @background.fold_ranges if @background
-        outline.filter_map { |symbol| symbol.range if @buffer.rope.point_at(symbol.range.end).row > @buffer.rope.point_at(symbol.range.begin).row }
+        structure_regions.map do |region|
+          first = @buffer.rope.line_start(region[:start_line]) + @buffer.line(region[:start_line]).bytesize
+          last = @buffer.rope.line_start(region[:end_line]) + @buffer.line(region[:end_line]).bytesize
+          (first...last).freeze
+        end
       end
       def indent_for(offset, tab_size: 4, use_tabs: false)
         row = @buffer.rope.point_at(offset).row
@@ -101,42 +106,73 @@ module Canopus
         return @background.bracket_at(offset) if @background
         bracket_ranges[offset]
       end
+      def brackets(rows = nil)
+        rows = bracket_rows(rows) if rows
+        return @background.brackets(rows) if @background
+        values = structure_brackets
+        rows ? values.select { |pair| pair.close_row >= rows.begin && pair.open_row < rows.end } : values.dup
+      end
+      def structure_regions
+        return @background.structure_regions if @background
+        highlighter.structure.fold_regions.map do |region|
+          {start_line: region.start_line, end_line: region.end_line, kind: region.kind}.freeze
+        end.freeze
+      end
+      def selection_ranges(offsets)
+        return @background.selection_ranges(offsets) if @background
+        offsets.map do |offset|
+          point = @buffer.rope.point_at(offset)
+          ranges = highlighter.structure.selection_ranges(point.row, point.column).map do |region|
+            first = @buffer.rope.offset_at(Denebola::Point.new(region.start_line, region.start_column || 0))
+            last = @buffer.rope.offset_at(Denebola::Point.new(region.end_line,
+              region.end_column || @buffer.line(region.end_line).length))
+            (first...last).freeze
+          end.uniq.sort_by { |range| [range.size, -range.begin] }
+          ranges.each_with_object([]) do |range, nested|
+            nested << range if !nested.last || (range.begin <= nested.last.begin && nested.last.end <= range.end)
+          end.freeze
+        end.freeze
+      end
 
       private
+      def bracket_rows(rows)
+        unless rows.is_a?(Range) && rows.begin.is_a?(Integer) && rows.end.is_a?(Integer) && rows.begin >= 0
+          raise ArgumentError, "bracket rows must be a nonnegative integer range"
+        end
+        last = rows.exclude_end? ? rows.end : rows.end + 1
+        raise RangeError, "bracket rows outside document" if last < rows.begin || last > @buffer.line_count
+        rows.begin...last
+      end
+
       def bracket_ranges
-        return @brackets if @brackets_version == @buffer.version
-        pairs = {"(" => ")", "[" => "]", "{" => "}"}
-        tokens = if @definition.name == "ruby"
-          require "prism"
-          Prism.lex(@buffer.text).value.filter_map do |token, _state|
-            next unless %w[PARENTHESIS_LEFT PARENTHESIS_RIGHT BRACKET_LEFT BRACKET_RIGHT BRACE_LEFT BRACE_RIGHT].include?(token.type.to_s)
-            [token.location.start_offset, token.value]
-          end
-        else
-          require "rouge"
-          collected, byte = [], 0
-          Rouge::Lexer.find(@definition.lexer).new.lex(@buffer.text).each do |token, value|
-            unless token.qualname.start_with?("Literal.String", "Comment")
-              value.b.scan(/[()\[\]{}]/n) { |character| collected << [byte + Regexp.last_match.begin(0), character] }
-            end
-            byte += value.bytesize
-          end
-          collected
+        return @bracket_ranges if @bracket_ranges_version == @buffer.version
+
+        @bracket_ranges = structure_brackets.each_with_object({}) do |pair, ranges|
+          range = (pair.open_range.begin...pair.close_range.end).freeze
+          ranges[pair.open_range.begin] = ranges[pair.close_range.begin] = range
         end
-        stack, @brackets = [], {}
-        tokens.each do |position, character|
-          if pairs.key?(character)
-            stack << [position, character]
-          elsif stack.last && pairs[stack.last[1]] == character
-            opening = stack.pop[0]
-            range = (opening...position + character.bytesize).freeze
-            @brackets[opening] = @brackets[position] = range
-          else
-            stack.clear
+        @bracket_ranges_version = @buffer.version
+        @bracket_ranges
+      end
+
+      def structure_brackets
+        return @structure_brackets if @structure_brackets_version == @buffer.version
+
+        boundaries = {}
+        byte_offset = lambda do |row, column|
+          positions = boundaries[row] ||= @buffer.line(row).each_char.each_with_object([0]) do |character, values|
+            values << values.last + character.bytesize
           end
+          @buffer.rope.line_start(row) + positions.fetch(column)
         end
-        @brackets_version = @buffer.version
-        @brackets
+        @structure_brackets = highlighter.structure.brackets.map do |pair|
+          opening = byte_offset.call(pair.open_line, pair.open_column)
+          closing = byte_offset.call(pair.close_line, pair.close_column)
+          Bracket.new((opening...opening + 1).freeze, (closing...closing + 1).freeze,
+            pair.open_line, pair.close_line, pair.depth).freeze
+        end.freeze
+        @structure_brackets_version = @buffer.version
+        @structure_brackets
       end
     end
   end