canopus 0.4.0 → 0.5.0

data/lib/canopus/project/search.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-require "rbconfig"
-require_relative "search_worker"
-
-class Canopus::Project::Search
-  SearchWorker = Canopus::Project.const_get(:SearchWorker, false)
-  private_constant :SearchWorker
-
-  Match = Struct.new(:path, :line, :column, :byte_offset, :text, :match, keyword_init: true)
-  DEFAULT_MAX_SIZE = 10 * 1024 * 1024
-  Child = Struct.new(:pid, :input, :output, :queue, :writer, :reader, :waiter)
-  private_constant :Child
-
-  def initialize(project)
-    @project = project
-  end
-
-  # Results are ordered by relative path and byte offset, even with workers.
-  def call(pattern, workers: 4, max_size: DEFAULT_MAX_SIZE, extensions: nil, limit: nil,
-    case_sensitive: true, cancelled: nil, paths: nil, &block)
-    raise ArgumentError, "workers must be between 1 and 32" unless workers.is_a?(Integer) && workers.between?(1, 32)
-    raise ArgumentError, "limit must be positive" if limit && (!limit.is_a?(Integer) || !limit.positive?)
-    raise ArgumentError, "max_size must be nonnegative" if max_size && (!max_size.is_a?(Integer) || max_size.negative?)
-    max_size = [max_size || SearchWorker::MAX_FILE_BYTES, SearchWorker::MAX_FILE_BYTES].min
-    expression = pattern.is_a?(Regexp) ? pattern : Regexp.new(Regexp.escape(pattern), case_sensitive ? 0 : Regexp::IGNORECASE)
-    expression = Regexp.new(expression.source, expression.options, timeout: expression.timeout || 0.25)
-    files = []
-    (paths || @project.files(extensions: extensions, max_size: max_size)).each do |relative|
-      SearchWorker.check_cancelled(cancelled)
-      raise ArgumentError, "invalid search path" unless relative.is_a?(String) && relative.valid_encoding? && !relative.include?("\0")
-      @project.path(relative)
-      files << relative
-    end
-    files.sort!
-    return [] if files.empty?
-    results = []
-    receive = receiver(results)
-    if workers > 1 && files.length > 1
-      parallel(files, expression, [workers, files.length].min, max_size, limit, cancelled, &receive)
-    else
-      SearchWorker.scan(@project.root, files, expression, max_size, limit, cancelled: cancelled, &receive)
-    end
-    SearchWorker.check_cancelled(cancelled)
-    results.each(&block) if block
-    results
-  rescue SearchWorker::Cancelled
-    []
-  end
-
-  private
-
-  def receiver(results)
-    path = number = offset = raw = text = nil
-    lambda do |message|
-      case message[0]
-      when :line
-        _, path, number, offset, raw = message
-        text = raw.chomp.freeze
-      when :matches
-        message[1].each do |column, first, last|
-          results << Match.new(path: path, line: number, column: column,
-            byte_offset: offset + first, text: text, match: raw.byteslice(first, last - first))
-        end
-      when :error then raise IOError, "search worker: #{message[1]}"
-      when :done then nil
-      else raise IOError, "invalid search worker response"
-      end
-    end
-  end
-
-  def parallel(files, expression, count, max_size, limit, cancelled)
-    children, first = [], 0
-    count.times do |index|
-      SearchWorker.check_cancelled(cancelled)
-      length = files.length / count + (index < files.length % count ? 1 : 0)
-      config = [@project.root, files.slice(first, length), expression, max_size, limit, expression.timeout]
-      children << start_child(config)
-      first += length
-    end
-    remaining = limit
-    children.each do |child|
-      loop do
-        SearchWorker.check_cancelled(cancelled)
-        begin
-          message = child.queue.pop(true)
-        rescue ThreadError
-          sleep 0.005
-          next
-        end
-        raise message if message.is_a?(Exception)
-        break if message[0] == :done
-        if message[0] == :matches && remaining
-          message[1] = message[1].first(remaining)
-          remaining -= message[1].length
-        end
-        yield message
-        return if remaining == 0
-      end
-    end
-  ensure
-    children&.each { |child| stop_child(child) }
-  end
-
-  def start_child(config)
-    child_input, input = IO.pipe
-    output, child_output = IO.pipe
-    child = Child.new(nil, input, output, SizedQueue.new(2))
-        child.pid = Process.spawn({"RUBYOPT" => nil, "RUBYLIB" => nil}, RbConfig.ruby, "--disable-gems",
-          File.expand_path("search_worker/runner.rb", __dir__), in: child_input, out: child_output, err: File::NULL)
-    child.waiter = Process.detach(child.pid)
-    child_input.close
-    child_output.close
-    child.writer = Thread.new do
-      SearchWorker.write_frame(input, config)
-    rescue StandardError => error
-      enqueue(child, error)
-    ensure
-      input.close unless input.closed?
-    end
-    child.reader = Thread.new do
-      loop do
-        message = SearchWorker.read_frame(output)
-        break unless enqueue(child, message)
-        break if message[0] == :done
-      end
-    rescue StandardError => error
-      enqueue(child, error)
-    end
-    child
-  rescue Exception
-    stop_child(child) if child
-    [child_input, child_output, input, output].compact.each { |io| io.close unless io.closed? }
-    raise
-  end
-
-  def stop_child(child)
-    child.queue.close
-    if child.waiter && !child.waiter.join(0)
-      signal(child, "TERM")
-      unless child.waiter.join(0.2)
-        signal(child, "KILL")
-        child.waiter.join(0.5)
-      end
-    end
-    [child.input, child.output].compact.each { |io| io.close unless io.closed? }
-    [child.writer, child.reader].compact.each do |thread|
-      thread.kill unless thread.join(0.2)
-      thread.join(0.1)
-    end
-  end
-
-  def enqueue(child, message)
-    child.queue.push(message)
-  rescue ClosedQueueError
-    false
-  end
-
-  def signal(child, name)
-    Process.kill(name, child.pid)
-  rescue Errno::ESRCH, Errno::EINVAL
-    nil
-  end
-end

data/lib/canopus/project/search_worker/cancelled.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-class Canopus::Project::SearchWorker::Cancelled < StandardError; end

data/lib/canopus/project/search_worker/runner.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  Project = Class.new
-end
-
-require_relative "../search_worker"
-
-Canopus::Project.const_get(:SearchWorker, false).run

data/lib/canopus/project/search_worker.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../regexp_compat"
-require_relative "../match_data_compat"
-
-    # This protocol only connects this file to its own Ruby parent. Marshal is
-    # never accepted from a file, network peer, plugin, or external executable.
-module Canopus::Project::SearchWorker
-  MAX_FILE_BYTES = 64 << 20
-  MAX_FRAME_BYTES = MAX_FILE_BYTES + (64 << 10)
-  READ_BYTES = 64 << 10
-  MATCH_BATCH = 128
-
-  def self.check_cancelled(callback)
-    raise Cancelled if callback&.call
-  end
-
-  def self.write_frame(io, value)
-    bytes = Marshal.dump(value)
-    raise IOError, "search frame exceeds safety limit" if bytes.bytesize > MAX_FRAME_BYTES
-    io.write([bytes.bytesize].pack("N"))
-    io.write(bytes)
-    io.flush
-  end
-
-  def self.read_frame(io)
-    header = io.read(4)
-    raise EOFError, "search worker ended before completion" unless header && header.bytesize == 4
-    size = header.unpack1("N")
-    raise IOError, "invalid search frame size" unless size.between?(1, MAX_FRAME_BYTES)
-    bytes = io.read(size)
-    raise EOFError, "truncated search frame" unless bytes && bytes.bytesize == size
-    Marshal.load(bytes)
-  rescue TypeError, ArgumentError => error
-    raise IOError, "invalid search frame: #{error.message}"
-  end
-
-  def self.scan(root, paths, expression, max_size, limit, cancelled: nil)
-    total = 0
-    paths.each do |relative|
-      check_cancelled(cancelled)
-      absolute = File.expand_path(relative, root)
-      raise ArgumentError, "path outside project" unless absolute.start_with?(root + File::SEPARATOR)
-      source = read_source(absolute, max_size, cancelled)
-      next unless source
-      offset = 0
-      source.each_line.with_index(1) do |line, number|
-        check_cancelled(cancelled)
-        matches, sent_line = [], false
-        Canopus.with_regexp_timeout(expression) do
-          line.to_enum(:scan, expression).each do
-            match = Regexp.last_match
-            check_cancelled(cancelled)
-            unless sent_line
-              yield [:line, relative, number, offset, line]
-              sent_line = true
-            end
-            first = match.respond_to?(:bytebegin) ? match.bytebegin(0) : match.pre_match.bytesize
-            matches << [match.begin(0) + 1, first, first + match[0].bytesize]
-            total += 1
-            if matches.length == MATCH_BATCH || (limit && total >= limit)
-              yield [:matches, matches]
-              matches = []
-            end
-            return if limit && total >= limit
-          end
-        end
-        yield [:matches, matches] unless matches.empty?
-        offset += line.bytesize
-      end
-    end
-  end
-
-  def self.read_source(path, max_size, cancelled)
-    flags = File::RDONLY
-    # Windows defines NONBLOCK as 1, which aliases WRONLY in File.open.
-    flags |= File::NONBLOCK unless RUBY_PLATFORM.match?(/mswin|mingw/)
-    File.open(path, flags) do |file|
-      file.binmode
-      return unless file.stat.file? && file.size <= max_size
-      source = +"".b
-      while (chunk = file.read(READ_BYTES))
-        check_cancelled(cancelled)
-        source << chunk
-        return if source.bytesize > max_size || chunk.include?("\0")
-      end
-      source.force_encoding(Encoding::UTF_8)
-      source if source.valid_encoding?
-    end
-  rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR, Errno::ELOOP
-    nil
-  end
-
-  def self.run
-    STDIN.binmode
-    STDOUT.binmode
-    root, paths, expression, max_size, limit, timeout = read_frame(STDIN)
-    expression = Regexp.new(expression.source, expression.options, timeout: timeout)
-    scan(root, paths, expression, max_size, limit) { |message| write_frame(STDOUT, message) }
-    write_frame(STDOUT, [:done])
-  rescue StandardError => error
-    write_frame(STDOUT, [:error, "#{error.class}: #{error.message}".byteslice(0, 4096)])
-    write_frame(STDOUT, [:done])
-  end
-end
-
-require_relative "search_worker/cancelled"
-Canopus::Project.send(:private_constant, :SearchWorker)

data/lib/canopus/terminal/cell.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Canopus
-  module Terminal
-    Cell = Struct.new(:text, :width, :foreground, :background, :attributes, :hyperlink, keyword_init: true)
-  end
-end

data/lib/canopus/terminal/grid.rb

@@ -1,321 +0,0 @@
-# frozen_string_literal: true
-
-require "denebola"
-require "zaniah"
-
-module Canopus
-  module Terminal
-    class Grid
-      attr_reader :columns, :rows, :cells, :scrollback, :cursor_x, :cursor_y, :scroll_top, :scroll_bottom
-      attr_accessor :foreground, :background, :attributes, :hyperlink, :autowrap, :insert_mode, :origin_mode, :cursor_visible
-
-      def initialize(columns: 80, rows: 24, scrollback: 10_000)
-        validate_dimensions(columns, rows)
-        @columns, @rows = columns, rows
-        @scrollback = Scrollback.new(scrollback)
-        reset
-      end
-
-      def reset
-        @foreground = @background = @hyperlink = nil
-        @attributes = {}.freeze
-        @autowrap = @cursor_visible = true
-        @insert_mode = @origin_mode = false
-        @cursor_x = @cursor_y = 0
-        @wrap_pending = false
-        @alternate = nil
-        @scroll_top, @scroll_bottom = 0, rows - 1
-        @cells = Array.new(rows) { blank_row }
-        @tabs = (8...columns).step(8).to_a
-        save_cursor
-      end
-
-      def [](row, column = nil) = column ? cells[row]&.[](column) : cells[row]
-      def alternate? = !@alternate.nil?
-      def lines = cells.map { |row| row.map(&:text).join.rstrip }
-      def text = lines.join("\n")
-
-      def put(char)
-        width = self.class.width(char)
-        previous_x = @wrap_pending ? cursor_x : cursor_x - 1
-        if previous_x >= 0 && !char.ascii_only?
-          previous_x -= 1 if cells[cursor_y][previous_x].width.zero? && previous_x.positive?
-          previous = cells[cursor_y][previous_x]
-          joined = previous.text + char
-          if joined.match?(/\A\X\z/)
-            width = [self.class.width(joined), columns].min
-            if previous_x + width > columns && autowrap
-              cells[cursor_y][previous_x] = blank
-              carriage_return
-              linefeed
-              return put(joined)
-            end
-            width = [width, columns - previous_x].min
-            clear_wide(cursor_y, previous_x + 1) if width == 2 && previous.width < 2
-            cells[cursor_y][previous_x + 1] = blank if width < previous.width
-            previous.text, previous.width = joined, width
-            cells[cursor_y][previous_x + 1] = previous.dup.tap { |cell| cell.text = ""; cell.width = 0 } if width == 2
-            @cursor_x = [previous_x + width, columns - 1].min
-            @wrap_pending = previous_x + width >= columns && autowrap
-            return
-          end
-        end
-        return if width.zero?
-        width = 1 if width > columns
-        if @wrap_pending || (width == 2 && cursor_x == columns - 1)
-          if autowrap
-            @cursor_x = 0
-            linefeed
-          elsif width == 2
-            return
-          end
-          @wrap_pending = false
-        end
-        insert_characters(width) if insert_mode
-        clear_wide(cursor_y, cursor_x)
-        clear_wide(cursor_y, cursor_x + 1) if width == 2
-        cells[cursor_y][cursor_x] = Cell.new(text: char, width: width, foreground: foreground,
-          background: background, attributes: attributes, hyperlink: hyperlink)
-        cells[cursor_y][cursor_x + 1] = Cell.new(text: "", width: 0, foreground: foreground,
-          background: background, attributes: attributes, hyperlink: hyperlink) if width == 2
-        if cursor_x + width >= columns
-          @cursor_x = columns - 1
-          @wrap_pending = autowrap
-        else
-          @cursor_x += width
-        end
-      end
-
-      def self.width(char)
-        return 1 if char.bytesize == 1 && char.ord.between?(32, 126)
-        Zaniah::Unicode.width(char)
-      end
-
-      def move(x: cursor_x, y: cursor_y, relative: false)
-        if relative
-          x += cursor_x
-          y += cursor_y
-        end
-        top, bottom = origin_mode ? [scroll_top, scroll_bottom] : [0, rows - 1]
-        @cursor_x = x.clamp(0, columns - 1)
-        @cursor_y = y.clamp(top, bottom)
-        @wrap_pending = false
-      end
-
-      def position(row, column)
-        move(x: column - 1, y: row - 1 + (origin_mode ? scroll_top : 0))
-      end
-
-      def carriage_return = move(x: 0)
-      def backspace = move(x: cursor_x - 1)
-
-      def linefeed
-        @wrap_pending = false
-        if cursor_y == scroll_bottom
-          scroll_up
-        elsif cursor_y < rows - 1
-          @cursor_y += 1
-        end
-      end
-
-      def reverse_index
-        @wrap_pending = false
-        cursor_y == scroll_top ? scroll_down : @cursor_y = [0, cursor_y - 1].max
-      end
-
-      def tab(count = 1, backward: false)
-        count.times do
-          stop = backward ? @tabs.reverse.find { |column| column < cursor_x } : @tabs.find { |column| column > cursor_x }
-          move(x: stop || (backward ? 0 : columns - 1))
-        end
-      end
-
-      def tab_set = @tabs = (@tabs + [cursor_x]).uniq.sort
-      def tab_clear(all: false) = all ? @tabs.clear : @tabs.delete(cursor_x)
-
-      def margins(top = 1, bottom = rows)
-        return unless top >= 1 && top < bottom && bottom <= rows
-        @scroll_top, @scroll_bottom = top - 1, bottom - 1
-        position(1, 1)
-      end
-
-      def scroll_up(count = 1)
-        [count, scroll_bottom - scroll_top + 1].min.times do
-          removed = cells.delete_at(scroll_top)
-          scrollback.push(removed) if scroll_top.zero? && scroll_bottom == rows - 1 && !alternate?
-          cells.insert(scroll_bottom, blank_row)
-        end
-      end
-
-      def scroll_down(count = 1)
-        [count, scroll_bottom - scroll_top + 1].min.times do
-          cells.delete_at(scroll_bottom)
-          cells.insert(scroll_top, blank_row)
-        end
-      end
-
-      def erase_display(mode = 0)
-        case mode
-        when 0
-          erase_line(0)
-          ((cursor_y + 1)...rows).each { |row| cells[row] = blank_row }
-        when 1
-          (0...cursor_y).each { |row| cells[row] = blank_row }
-          erase_line(1)
-        when 2 then @cells = Array.new(rows) { blank_row }
-        when 3 then scrollback.clear
-        end
-      end
-
-      def erase_line(mode = 0)
-        first, last = case mode
-        when 0 then [cursor_x, columns - 1]
-        when 1 then [0, cursor_x]
-        when 2 then [0, columns - 1]
-        else return
-        end
-        (first..last).each { |column| clear_wide(cursor_y, column); cells[cursor_y][column] = blank }
-      end
-
-      def erase_characters(count = 1)
-        (cursor_x...[cursor_x + count, columns].min).each { |column| clear_wide(cursor_y, column); cells[cursor_y][column] = blank }
-      end
-
-      def insert_characters(count = 1)
-        clear_wide(cursor_y, cursor_x) if cells[cursor_y][cursor_x].width.zero?
-        cells[cursor_y].insert(cursor_x, *Array.new([count, columns - cursor_x].min) { blank })
-        cells[cursor_y] = cells[cursor_y].first(columns)
-        normalize_row(cursor_y)
-      end
-
-      def delete_characters(count = 1)
-        clear_wide(cursor_y, cursor_x)
-        count = [count, columns - cursor_x].min
-        cells[cursor_y].slice!(cursor_x, count)
-        cells[cursor_y].concat(Array.new(count) { blank })
-        normalize_row(cursor_y)
-      end
-
-      def insert_lines(count = 1)
-        return unless cursor_y.between?(scroll_top, scroll_bottom)
-        [count, scroll_bottom - cursor_y + 1].min.times { cells.delete_at(scroll_bottom); cells.insert(cursor_y, blank_row) }
-      end
-
-      def delete_lines(count = 1)
-        return unless cursor_y.between?(scroll_top, scroll_bottom)
-        [count, scroll_bottom - cursor_y + 1].min.times { cells.delete_at(cursor_y); cells.insert(scroll_bottom, blank_row) }
-      end
-
-      def save_cursor
-        @saved = [cursor_x, cursor_y, foreground, background, attributes, hyperlink, origin_mode, @wrap_pending]
-      end
-
-      def restore_cursor
-        return unless @saved
-        @cursor_x, @cursor_y, @foreground, @background, @attributes, @hyperlink, @origin_mode, @wrap_pending = @saved
-        @cursor_x = cursor_x.clamp(0, columns - 1)
-        @cursor_y = cursor_y.clamp(0, rows - 1)
-      end
-
-      def alternate(enable, save: true)
-        if enable && !alternate?
-          save_cursor if save
-          @alternate = cells
-          @cells = Array.new(rows) { blank_row }
-          @cursor_x = @cursor_y = 0
-          @scroll_top, @scroll_bottom = 0, rows - 1
-          @wrap_pending = false
-        elsif !enable && alternate?
-          @cells, @alternate = @alternate, nil
-          @scroll_top, @scroll_bottom = 0, rows - 1
-          restore_cursor if save
-        end
-      end
-
-      def resize(columns:, rows:)
-        validate_dimensions(columns, rows)
-        previous_columns = @columns
-        @columns, @rows = columns, rows
-        [cells, @alternate].compact.each do |screen|
-          while screen.length > rows
-            removed = screen.shift
-            scrollback.push(removed) unless alternate?
-            @cursor_y -= 1 if screen.equal?(cells)
-          end
-          screen << blank_row while screen.length < rows
-          screen.each do |row|
-            row.slice!(columns, row.length) if row.length > columns
-            row << blank while row.length < columns
-          end
-        end
-        cells.each_index { |index| normalize_row(index) }
-        @tabs = (@tabs.select { |column| column < columns } + (previous_columns...columns).select { |column| column.positive? && (column % 8).zero? }).uniq.sort
-        @scroll_top, @scroll_bottom = 0, rows - 1
-        move
-      end
-
-      # Coordinates are [column, row]; finish is exclusive, including scrollback
-      # when history: true. This is suitable for selection/copy without a renderer.
-      def selection(start, finish, history: false)
-        source = history ? scrollback.to_a + cells : cells
-        start, finish = finish, start if ([start[1], start[0]] <=> [finish[1], finish[0]]) == 1
-        (start[1]..finish[1]).map do |row|
-          next "" unless source[row]
-          first = row == start[1] ? start[0] : 0
-          last = row == finish[1] ? finish[0] : columns
-          source[row][first...last].to_a.map(&:text).join.rstrip
-        end.join("\n")
-      end
-
-      def links(row)
-        line = cells.fetch(row).map(&:text).join
-        explicit = []
-        cells[row].each_with_index do |cell, column|
-          next unless cell.hyperlink
-          if explicit.last && explicit.last[:url] == cell.hyperlink && explicit.last[:end_column] == column
-            explicit.last[:end_column] = column + 1
-          else
-            explicit << {url: cell.hyperlink, column: column, end_column: column + 1}
-          end
-        end
-        line.to_enum(:scan, %r{https?://[^\s<>"']+}).each do
-          found = Regexp.last_match
-          column = line[0...found.begin(0)].each_char.sum { |char| self.class.width(char) }
-          explicit << {url: found[0], column: column, end_column: column + found[0].length}
-        end
-        explicit.uniq
-      end
-
-      def file_paths(row, cwd: Dir.pwd)
-        line = cells.fetch(row).map(&:text).join
-        line.scan(%r{(?:\A|[\s("'])([^\s:"'()]+):(\d+)(?::(\d+))?}).filter_map do |name, number, column|
-          absolute = File.expand_path(name, cwd)
-          {path: absolute, line: number.to_i, column: column ? column.to_i : 1} if File.file?(absolute)
-        end
-      end
-
-      private
-
-      def validate_dimensions(columns, rows)
-        raise ArgumentError, "terminal dimensions must be positive integers" unless columns.is_a?(Integer) && rows.is_a?(Integer) && columns.positive? && rows.positive?
-      end
-
-      def blank = Cell.new(text: " ", width: 1, foreground: foreground, background: background, attributes: {}.freeze)
-      def blank_row = Array.new(columns) { blank }
-
-      def clear_wide(row, column)
-        return unless column.between?(0, columns - 1)
-        cell = cells[row][column]
-        cells[row][column - 1] = blank if cell.width.zero? && column.positive?
-        cells[row][column + 1] = blank if cell.width == 2 && column + 1 < columns
-      end
-
-      def normalize_row(row)
-        cells[row].each_with_index do |cell, column|
-          cells[row][column] = blank if (cell.width == 2 && (column == columns - 1 || cells[row][column + 1].width != 0)) ||
-            (cell.width.zero? && (column.zero? || cells[row][column - 1].width != 2))
-        end
-      end
-    end
-  end
-end