canopus 0.1.0

data/lib/canopus/patch/reload.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Canopus::Patch::Reload
+  attr_reader :before, :after
+  def initialize(before, after) = (@before, @after = before, after)
+  def edits = []
+  def map_offset(offset, bias: :right)
+    position = offset.clamp(0, after.bytesize)
+    begin
+      after.point_at(position)
+      position
+    rescue RangeError
+      position -= 1
+      retry if position >= 0
+      raise
+    end
+  end
+end

data/lib/canopus/patch.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Canopus
+  class Patch
+    Edit = Data.define(:old_range, :new_range, :old_text, :new_text)
+    attr_reader :edits, :before, :after
+    def initialize(before, after, changes)
+      @before, @after = before, after
+      delta = 0
+      @edits = changes.sort_by { |range, _| range.begin }.map do |range, text|
+        ending = range.end + (range.exclude_end? ? 0 : 1)
+        old = range.begin...ending
+        start = range.begin + delta
+        delta += text.bytesize - (ending - range.begin)
+        Edit.new(old, start...(start + text.bytesize), before.byteslice(old).to_s.freeze, text.dup.freeze)
+      end.freeze
+    end
+    def map_offset(offset, bias: :right)
+      Denebola::Anchor.new(offset, bias: bias).transform(@edits.map { |e| [e.old_range, e.new_text] }).offset
+    end
+    def inverse = Patch.new(after, before, edits.map { |e| [e.new_range, e.old_text] })
+    def compose(other) = Composite.new([self, other])
+  end
+end
+
+require_relative "patch/composite"
+require_relative "patch/reload"

data/lib/canopus/performance_recorder.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "json"
+require "tempfile"
+require "time"
+
+module Canopus
+  # Installed only for an explicitly profiled window, never on the Window class.
+  class PerformanceRecorder
+    attr_reader :sampler
+
+    def initialize(window, trace_allocations: false, sampling: true, capacity: 600, sample_capacity: 2_000, interval: 0.01)
+      raise ArgumentError, "profile capacities must be positive integers" unless [capacity, sample_capacity].all? { |n| n.is_a?(Integer) && n.positive? }
+      raise ArgumentError, "sampling interval must be positive and finite" unless interval.positive? && interval.finite?
+      @window, @trace_allocations = window, trace_allocations
+      @sampling = sampling
+      @capacity, @sample_capacity, @interval = capacity, sample_capacity, interval
+      @frames, @stacks = [], []
+      @count = @sample_count = @total_allocations = 0
+      @max_frame_ms = 0.0
+      @mutex, @wake = Mutex.new, ConditionVariable.new
+    end
+
+    def start
+      raise ArgumentError, "a profile can only be started once" if @started
+      @started = true
+      if @trace_allocations
+        require "objspace"
+        ObjectSpace.trace_object_allocations_start
+        @tracing = true
+      end
+      @running = true
+      @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      profile = self
+      @window.singleton_class.prepend(Module.new do
+        define_method(:render) do |*args, **kwargs, &block|
+          profile.measure { super(*args, **kwargs, &block) }
+        end
+      end)
+      if @sampling
+        @sampler = Thread.new { sample_main_thread }
+        @sampler.name = "canopus-profile"
+      end
+      self
+    rescue Exception
+      stop
+      raise
+    end
+
+    def measure
+      return yield unless @running
+      allocated = GC.stat(:total_allocated_objects)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      completed = false
+      begin
+        result = yield
+        completed = true
+        result
+      ensure
+        elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1_000
+        allocations = GC.stat(:total_allocated_objects) - allocated
+        draws = @window.device.draw_calls if completed && @window.device.respond_to?(:draw_calls)
+        @last = {frame: @count + 1, frame_ms: elapsed, allocations: allocations, draw_calls: draws,
+          scale_factor: @window.scale_factor, completed: completed}
+        @frames[@count % @capacity] = @last
+        @count += 1
+        @total_allocations += allocations
+        @max_frame_ms = [@max_frame_ms, elapsed].max
+      end
+    end
+
+    def stop
+      @mutex.synchronize { @running = false; @wake.broadcast }
+      begin
+        @sampler&.join
+      ensure
+        @stopped_at ||= Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if @tracing
+          ObjectSpace.trace_object_allocations_stop
+          @tracing = false
+          @allocation_sites = allocation_sites
+        end
+      end
+      self
+    end
+
+    def statistics
+      times = @frames.map { |frame| frame[:frame_ms] }.sort
+      {frames: @count, retained_frames: @frames.length,
+       last_frame_ms: @last&.fetch(:frame_ms), last_allocations: @last&.fetch(:allocations), last_draw_calls: @last&.fetch(:draw_calls),
+       median_frame_ms: percentile(times, 0.5), p95_frame_ms: percentile(times, 0.95), max_frame_ms: @max_frame_ms,
+       mean_allocations: @count.zero? ? 0 : @total_allocations.fdiv(@count), sampling_samples: @sample_count}
+    end
+
+    def report
+      raise ArgumentError, "stop the profile before saving it" if @running
+      {schema_version: 1, kind: "profile", generated_at: Time.now.utc.iso8601,
+       context: self.class.context(@window), elapsed_seconds: @started_at ? @stopped_at - @started_at : 0,
+       measurement: {
+         frame: "Window#render: UI construction, layout, prepaint, paint, GPU submission and synchronous presentation; excludes input/tick/draw callbacks and asynchronous GPU completion",
+         allocations: "Process-wide GC total_allocated_objects delta during render, including other threads and sampling overhead; excludes frame-record bookkeeping",
+         percentiles: "Retained frame window only; max and mean allocations cover all observed frames",
+         timing: "Wall clock, including GC, scheduler waits and synchronous native calls; not GPU timestamps or idle CPU",
+         trace_allocations: @trace_allocations
+       }, statistics: statistics, frames: @frames.sort_by { |frame| frame[:frame] },
+       sampling: {enabled: @sampling, interval_seconds: @interval, max_depth: 32, total_samples: @sample_count, retained_samples: @stacks.length,
+         stacks: @stacks.tally.map { |stack, count| {count: count, stack: stack} }.sort_by { |entry| -entry[:count] }},
+       allocation_sites: @allocation_sites}
+    end
+
+    def write(path) = self.class.write_json(path, report)
+
+    private
+
+    def percentile(sorted, fraction)
+      return 0.0 if sorted.empty?
+      index = (sorted.length - 1) * fraction
+      sorted[index.floor] + (sorted[index.ceil] - sorted[index.floor]) * (index - index.floor)
+    end
+
+    def sample_main_thread
+      loop do
+        running = @mutex.synchronize do
+          @wake.wait(@mutex, @interval) if @running
+          @running
+        end
+        break unless running
+        # These are Ruby stack locations, not a native CPU profiler or object contents.
+        stack = (Thread.main.backtrace_locations(0, 32) || []).map { |location| "#{location.path}:#{location.lineno}:in '#{location.base_label}'" }
+        @stacks[@sample_count % @sample_capacity] = stack
+        @sample_count += 1
+      end
+    end
+
+    def allocation_sites
+      counts, examined = Hash.new(0), 0
+      ObjectSpace.each_object do |object|
+        examined += 1
+        break if examined > 100_000
+        file = ObjectSpace.allocation_sourcefile(object)
+        next unless file
+        site = [file, ObjectSpace.allocation_sourceline(object)]
+        counts[site] += 1 if counts.key?(site) || counts.length < 2_000
+      end
+      {scope: "Traced objects still alive at stop; not all allocated objects. Existing external traces can contribute. At most 100000 live objects examined, 2000 sites retained.",
+       examined_objects: [examined, 100_000].min, scan_limit_reached: examined > 100_000,
+       sites: counts.sort_by { |_, count| -count }.map { |(file, line), count| {file: file, line: line, live_objects: count} }}
+    end
+
+    def self.context(window = nil)
+      {ruby: RUBY_DESCRIPTION, engine: RUBY_ENGINE, ruby_version: RUBY_VERSION, platform: RUBY_PLATFORM,
+       canopus_version: Canopus::VERSION, zaniah_version: Zaniah::VERSION,
+       yjit: !!(defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?),
+       zjit: !!(defined?(RubyVM::ZJIT) && RubyVM::ZJIT.enabled?),
+       window: window&.class&.name, renderer: window&.device&.class&.name,
+       scale_factor: window&.scale_factor,
+       logical_size: window && {width: window.content_size.width, height: window.content_size.height}}
+    end
+
+    def self.validate_paths(paths, protected: [])
+      reports = paths.compact.map { |path| File.expand_path(path) }
+      raise ArgumentError, "diagnostic report paths must be distinct" unless reports.uniq.length == reports.length
+      protected = protected.compact.map { |path| File.expand_path(path) }
+      reports.each do |path|
+        raise ArgumentError, "report directory does not exist: #{File.dirname(path)}" unless File.directory?(File.dirname(path))
+        raise ArgumentError, "report path is a directory: #{path}" if File.directory?(path)
+        raise ArgumentError, "report path must not be a symlink: #{path}" if File.symlink?(path)
+        if protected.any? { |input| input == path || (File.exist?(path) && File.exist?(input) && File.identical?(path, input)) }
+          raise ArgumentError, "report path overlaps an input or output file: #{path}"
+        end
+      end
+      reports
+    end
+
+    def self.write_json(path, report)
+      target = validate_paths([path]).first
+      json = JSON.pretty_generate(report)
+      Tempfile.create([".canopus-report-", ".json"], File.dirname(target), mode: File::RDWR, perm: 0o600) do |file|
+        file.chmod(0o600)
+        file.write(json)
+        file.write("\n")
+        file.flush
+        file.fsync
+        file.close
+        File.rename(file.path, target)
+      end
+      target
+    end
+
+    def self.write_crash(path, exception, window: nil)
+      write_json(path, {schema_version: 1, kind: "crash", generated_at: Time.now.utc.iso8601,
+        context: context(window), exception: exception_details(exception),
+        privacy: "Local only. Message and backtrace can contain sensitive paths or text; review before sharing. No environment, buffer contents or object dumps are collected."})
+    end
+
+    def self.exception_details(exception, depth = 0)
+      result = {class: exception.class.name, message: clean_text(exception.message, 8_192),
+        backtrace: (exception.backtrace || []).first(100).map { |line| clean_text(line, 2_048) }}
+      result[:cause] = exception_details(exception.cause, depth + 1) if exception.cause && depth < 3 && exception.cause != exception
+      result
+    end
+    private_class_method :exception_details
+
+    def self.clean_text(value, limit) = value.to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).slice(0, limit)
+    private_class_method :clean_text
+  end
+end

data/lib/canopus/plugins/api.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Canopus
+  module Plugins
+    class API
+      def initialize(workspace, permissions)
+        @workspace, @permissions = workspace, permissions
+      end
+      def permit!(permission)
+        raise Canopus::Plugins::PermissionDenied, "plugin requires #{permission}" unless @permissions.include?(permission)
+      end
+      def text
+        permit!("read_buffer")
+        @workspace.editor.buffer.text.dup.freeze
+      end
+      def replace(range, text)
+        permit!("edit_buffer")
+        @workspace.editor.buffer.edit([[range, text]], kind: :plugin)
+      end
+      def files
+        permit!("read_project")
+        @workspace.files.dup.freeze
+      end
+      def notify(message) = @workspace.message = message.to_s
+      def run(command)
+        permit!("process")
+        raise ArgumentError, "command must be a nonempty argument array" unless command.is_a?(Array) && !command.empty?
+        Open3.capture3(*command, chdir: @workspace.root)
+      end
+      def http_get(url)
+        permit!("network")
+        require "net/http"
+        uri = URI(url)
+        raise ArgumentError, "HTTP or HTTPS URL required" unless %w[http https].include?(uri.scheme)
+        body = +""
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 5) do |http|
+          http.request_get(uri.request_uri) do |response|
+            response.read_body do |chunk|
+              raise Canopus::Error, "plugin HTTP response exceeds 1 MiB" if body.bytesize + chunk.bytesize > 1 << 20
+              body << chunk
+            end
+          end
+        end
+        body
+      end
+    end
+  end
+end

data/lib/canopus/plugins/isolated_runtime.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "rbconfig"
+
+# Separate-process execution isolates crashes and accidental global state.
+# It is NOT an OS sandbox: Ruby plugins remain trusted executable code.
+module Canopus
+  module Plugins
+    class IsolatedRuntime
+      WORKER = <<~'RUBY'
+    require "json"
+    require "stringio"
+    require "open3"
+    protocol = STDOUT
+    $stdout = StringIO.new
+    class PluginAPI
+      attr_reader :edits, :messages
+      def initialize(context, permissions)
+        @context, @permissions, @edits, @messages = context, permissions, [], []
+      end
+      def permit!(name)
+        raise "plugin requires #{name}" unless @permissions.include?(name)
+      end
+      def text
+        permit!("read_buffer")
+        @context.fetch("text")
+      end
+      def files
+        permit!("read_project")
+        @context.fetch("files")
+      end
+      def replace(range, text)
+        permit!("edit_buffer")
+        @edits << [range.begin, range.end + (range.exclude_end? ? 0 : 1), text]
+      end
+      def notify(message) = @messages << message.to_s
+      def run(command)
+        permit!("process")
+        raise "command must be an argument array" unless command.is_a?(Array) && !command.empty?
+        Open3.capture3(*command, chdir: @context.fetch("root"))
+      end
+      def http_get(url)
+        permit!("network")
+        require "net/http"
+        uri = URI(url)
+        raise "HTTP or HTTPS URL required" unless %w[http https].include?(uri.scheme)
+        body = +""
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 5) do |http|
+          http.request_get(uri.request_uri) do |response|
+            response.read_body do |chunk|
+              raise "plugin HTTP response exceeds 1 MiB" if body.bytesize + chunk.bytesize > 1 << 20
+              body << chunk
+            end
+          end
+        end
+        body
+      end
+    end
+    class PluginDefinition
+      attr_reader :actions, :panels, :languages, :servers
+      def initialize
+        @actions, @panels, @languages, @servers = {}, {}, {}, {}
+      end
+      def register_action(name, description: name, &block) = @actions[name] = [description, block]
+      def register_panel(name, side: :right, &block) = @panels[name] = [side, block]
+      def register_language(name, **options) = @languages[name] = options
+      def configure_lsp(language, command) = @servers[language] = command
+    end
+    begin
+      bootstrap = JSON.parse(STDIN.gets || raise("missing plugin source"))
+      definition = PluginDefinition.new
+      definition.instance_eval(bootstrap.fetch("source"), bootstrap.fetch("path"), 1)
+      protocol.puts(JSON.generate(actions: definition.actions.transform_values(&:first), panels: definition.panels.transform_values(&:first), languages: definition.languages, servers: definition.servers))
+      protocol.flush
+      STDIN.each_line do |line|
+        begin
+          request = JSON.parse(line)
+          api = PluginAPI.new(request.fetch("context"), bootstrap.fetch("permissions"))
+          table = request["kind"] == "panel" ? definition.panels : definition.actions
+          result = table.fetch(request.fetch("name"))[1].call(api)
+          protocol.puts(JSON.generate(result: result.is_a?(String) ? result : nil, edits: api.edits, messages: api.messages))
+        rescue StandardError, ScriptError => error
+          protocol.puts(JSON.generate(error: "#{error.class}: #{error.message}"))
+        end
+        protocol.flush
+        $stdout.truncate(0)
+        $stdout.rewind
+      end
+    rescue StandardError, ScriptError => error
+      protocol.puts(JSON.generate(error: "#{error.class}: #{error.message}"))
+      protocol.flush
+    end
+  RUBY
+
+      def initialize(workspace, source, path, permissions, timeout: 2)
+        @workspace, @permissions, @timeout = workspace, permissions, timeout
+        @input, @output, @process = Open3.popen2(RbConfig.ruby, "-e", WORKER)
+        @input.sync = true
+        @output.binmode
+        @pending, @lock = +"".b, Mutex.new
+        @input.puts(JSON.generate(source: source, path: path, permissions: permissions))
+        manifest = response
+        manifest.fetch("actions").each do |name, description|
+          workspace.register_action(name, description: description) { invoke(:action, name) }
+        end
+        manifest.fetch("panels").each do |name, side|
+          workspace.register_panel(name, side: side.to_sym) { Zaniah::Text.new(invoke(:panel, name).to_s) }
+        end
+        manifest.fetch("languages").each { |name, options| workspace.register_language(name, **options.transform_keys(&:to_sym)) }
+        workspace.settings.merge!("language_servers" => manifest.fetch("servers"))
+      rescue StandardError
+        close
+        raise
+      end
+      def invoke(kind, name)
+        @lock.synchronize do
+          buffer = @workspace.editor.buffer
+          version = buffer.version
+          context = {root: @workspace.root}
+          context[:text] = buffer.text if @permissions.include?("read_buffer")
+          context[:files] = @workspace.files if @permissions.include?("read_project")
+          @input.puts(JSON.generate(kind: kind, name: name, context: context))
+          result = response
+          edits = result.fetch("edits")
+          unless edits.empty?
+            raise Canopus::Plugins::PermissionDenied, "plugin requires edit_buffer" unless @permissions.include?("edit_buffer")
+            raise Canopus::Error, "buffer changed while plugin was running" unless buffer.version == version
+            buffer.edit(edits.map { |first, last, text| [first...last, text] }, kind: :plugin)
+          end
+          @workspace.message = result.fetch("messages").last.to_s unless result.fetch("messages").empty?
+          result["result"]
+        end
+      rescue IOError, Errno::EPIPE, EOFError => error
+        raise Canopus::Error, "plugin process ended: #{error.message}"
+      end
+      def close
+        @input&.close unless @input&.closed?
+        if @process && !@process.join(0.2)
+          Process.kill("KILL", @process.pid) rescue Errno::ESRCH
+          @process.join
+        end
+        @output&.close unless @output&.closed?
+      end
+  private
+      def response
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + @timeout
+        loop do
+          if (ending = @pending.index("\n"))
+            result = JSON.parse(@pending.slice!(0, ending + 1))
+            raise Canopus::Error, result["error"] if result["error"]
+            return result
+          end
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          if remaining <= 0 || !IO.select([@output], nil, nil, remaining)
+            close
+            raise Canopus::Error, "plugin exceeded #{@timeout} second response limit"
+          end
+          chunk = @output.read_nonblock(65_536)
+          @pending << chunk
+          raise Canopus::Error, "plugin response exceeds 1MB" if @pending.bytesize > 1 << 20
+        end
+      end
+    end
+  end
+end

data/lib/canopus/plugins/local_runtime.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Plugins
+    class LocalRuntime
+      def initialize(workspace, source, path, permissions)
+        @workspace, @api = workspace, Canopus::Plugins::API.new(workspace, permissions)
+        instance_eval(source, path, 1)
+      end
+      def register_action(name, description: name, &block)
+        raise ArgumentError, "action callback required" unless block
+        @workspace.register_action(name, description: description) { block.call(@api) }
+      end
+      def register_panel(name, side: :right, &block)
+        raise ArgumentError, "panel callback required" unless block
+        @workspace.register_panel(name, side: side) { block.call(@api) }
+      end
+      def register_language(name, **options) = @workspace.register_language(name, **options)
+      def configure_lsp(language, command)
+        @workspace.settings.merge!("language_servers" => {language => command})
+      end
+      def close; end
+    end
+  end
+end

data/lib/canopus/plugins/permission_denied.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Plugins
+    class PermissionDenied < Error; end
+  end
+end

data/lib/canopus/plugins/registry.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Plugins
+    class Registry
+      PERMISSIONS = %w[read_buffer edit_buffer read_project process network].freeze
+
+      def initialize(workspace)
+        @workspace, @loaded = workspace, []
+      end
+
+      def load(path, trusted: false, permissions: [], isolated: true, timeout: 2)
+        raise PermissionDenied, "plugins execute Ruby code; explicitly mark this plugin trusted" unless trusted
+        permissions = permissions.map(&:to_s)
+        raise PermissionDenied, "unknown plugin permission" unless (permissions - PERMISSIONS).empty?
+        source = File.read(path, 256 * 1024 + 1, encoding: "UTF-8")
+        raise Error, "plugin source exceeds 256KB" if source.bytesize > 256 * 1024
+        plugin = if isolated
+          IsolatedRuntime.new(@workspace, source, path, permissions, timeout: timeout)
+        else
+          LocalRuntime.new(@workspace, source, path, permissions)
+        end
+        @loaded << plugin
+        plugin
+      end
+
+      def close = @loaded.each(&:close)
+    end
+  end
+end

data/lib/canopus/plugins.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Plugins; end
+end
+
+require_relative "plugins/permission_denied"
+require_relative "plugins/api"
+require_relative "plugins/local_runtime"
+require_relative "plugins/isolated_runtime"
+require_relative "plugins/registry"

data/lib/canopus/project/ignore_matcher.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+class Canopus::Project::IgnoreMatcher
+  Rule = Struct.new(:base, :expression, :negated, :directory, keyword_init: true)
+
+  def initialize(rules = [])
+    @rules = rules.freeze
+  end
+
+  def add(source, base: "")
+    rules = source.lines.filter_map do |line|
+      line = line.delete_suffix("\n").delete_suffix("\r")
+      # Only unescaped trailing spaces are insignificant.
+      line = line.sub(/(?<!\\)(?:\\\\)*\K +\z/, "")
+      next if line.empty? || line.start_with?("#")
+      negated = line.start_with?("!")
+      line = line[1..] if negated
+      directory = line.end_with?("/")
+      line = line.delete_suffix("/") if directory
+      anchored = line.start_with?("/") || line.include?("/")
+      line = line.delete_prefix("/")
+      next if line.empty?
+      expression = Regexp.new((anchored ? "\\A" : "(?:\\A|/)") + glob(line) + "\\z")
+      Rule.new(base: base.delete_suffix("/"), expression: expression, negated: negated, directory: directory)
+    rescue RegexpError
+      nil
+    end
+    self.class.new(@rules + rules)
+  end
+
+  # Ancestors must be checked by the walker: excluded parents cannot be
+  # resurrected by a child's negation, exactly as Git's pruning requires.
+  def ignored?(path, directory: false)
+    ignored = false
+    @rules.each do |rule|
+      next if rule.directory && !directory
+      next unless rule.base.empty? || path.start_with?(rule.base + "/")
+      local = rule.base.empty? ? path : path[(rule.base.length + 1)..]
+      ignored = !rule.negated if rule.expression.match?(local)
+    end
+    ignored
+  end
+
+  private
+
+  def glob(pattern)
+    result = +""
+    index = 0
+    while index < pattern.length
+      char = pattern[index]
+      case char
+      when "\\"
+        index += 1
+        result << Regexp.escape(pattern[index] || "\\")
+      when "*"
+        finish = index
+        finish += 1 while pattern[finish + 1] == "*"
+        if finish > index && (index.zero? || pattern[index - 1] == "/") && (finish == pattern.length - 1 || pattern[finish + 1] == "/")
+          if pattern[finish + 1] == "/"
+            result << "(?:[^/]+/)*"
+            finish += 1
+          else
+            result << ".*"
+          end
+        else
+          result << "[^/]*"
+        end
+        index = finish
+      when "?"
+        result << "[^/]"
+      when "["
+        cursor = index + 1
+        cursor += 1 if ["!", "^"].include?(pattern[cursor])
+        cursor += 1 if pattern[cursor] == "]"
+        finish = nil
+        while cursor < pattern.length
+          if pattern[cursor, 2] == "[:" && (ending = pattern.index(":]", cursor + 2))
+            cursor = ending + 2
+            next
+          end
+          if pattern[cursor] == "]"
+            finish = cursor
+            break
+          end
+          cursor += pattern[cursor] == "\\" ? 2 : 1
+        end
+        if finish
+          content = pattern[(index + 1)...finish].sub(/\A!/, "^")
+          content = content.gsub(/(?<!\\)(.)-(.)/) { Regexp.last_match(1).ord > Regexp.last_match(2).ord ? Regexp.last_match(1) : Regexp.last_match(0) }
+          result << "(?!/)[#{content}]"
+          index = finish
+        else
+          result << "\\["
+        end
+      else
+        result << Regexp.escape(char)
+      end
+      index += 1
+    end
+    result
+  rescue RegexpError
+    Regexp.escape(pattern)
+  end
+end