Skip to content
Kward Search API index

Module: Kward::ScratchpadRunner

Defined in:
lib/kward/prompt_interface/editor/scratchpad_runner.rb

Overview

Executes editor buffers and returns captured runner output.

Defined Under Namespace

Classes: Result

Constant Summary collapse

OUTPUT_READ_SIZE = 
16 * 1024
MAX_OUTPUT_BYTES = 
1_000_000
POLL_INTERVAL = 
0.05
DEFAULT_BINARIES = 
{
  ruby: -> { RbConfig.ruby },
  node: "node",
  python: -> { windows_host? ? "python" : "python3" },
  shell: -> { File.executable?("/bin/sh") ? "/bin/sh" : "sh" },
  lua: "lua",
  julia: "julia",
  elixir: "elixir",
  crystal: "crystal",
  swift: "swift",
  go: "go"
}.freeze
RUNNER_ARGUMENTS = 
{
  crystal: ["run"],
  go: ["run"]
}.freeze

Class Method Summary collapse

Class Method Details

.append_output(chunks, chunk, output_size) ⇒ Object 



164
165
166
167
168
169
170
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 164

def append_output(chunks, chunk, output_size)
  return output_size if output_size >= MAX_OUTPUT_BYTES

  remaining = MAX_OUTPUT_BYTES - output_size
  chunks << chunk.byteslice(0, remaining)
  output_size + [chunk.bytesize, remaining].min
end

.capture_process(command, cancelled: nil, chdir: nil) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 113

def capture_process(command, cancelled: nil, chdir: nil)
  options = chdir ? { chdir: chdir } : {}
  input, output, wait_thread = Open3.popen2e(*command, **options)
  input.close
  chunks = []
  output_size = 0
  was_cancelled = false

  loop do
    if !was_cancelled && cancelled&.call
      terminate_process(wait_thread.pid)
      was_cancelled = true
    end

    output_size = read_available_output(output, chunks, output_size)
    break if wait_thread.join(0)

    sleep POLL_INTERVAL
  end

  output_size = read_remaining_output(output, chunks, output_size)
  [chunks.join, wait_thread.value, was_cancelled, output_size >= MAX_OUTPUT_BYTES]
ensure
  if wait_thread&.alive?
    terminate_process(wait_thread.pid)
    wait_thread.join
  end
  input&.close unless input&.closed?
  output&.close unless output&.closed?
end

.capture_source(content, extension:, source_path:, cwd:, command:, cancelled: nil) ⇒ Object 



71
72
73
74
75
76
77
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 71

def capture_source(content, extension:, source_path:, cwd:, command:, cancelled: nil)
  Tempfile.create(["kward-scratchpad", extension], dir: temporary_directory(cwd, source_path)) do |file|
    file.write(content.to_s)
    file.flush
    capture_process([*command, file.path], cancelled: cancelled, chdir: cwd)
  end
end

.configured_binary(runner, runner_config, cwd) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 79

def configured_binary(runner, runner_config, cwd)
  settings = runner_config.is_a?(Hash) ? (runner_config[runner.to_s] || runner_config[runner]) : nil
  configured = settings.is_a?(Hash) ? (settings["binary"] || settings[:binary]) : settings
  binary = configured.nil? ? default_binary(runner) : configured
  unless binary.is_a?(String) && !binary.strip.empty?
    raise ArgumentError, "Editor runner #{runner.inspect} binary must be a non-empty string"
  end

  binary = binary.strip
  path_like?(binary) ? File.expand_path(binary, cwd) : binary
end

.default_binary(runner) ⇒ Object 



91
92
93
94
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 91

def default_binary(runner)
  value = DEFAULT_BINARIES[runner]
  value.respond_to?(:call) ? value.call : value
end

.monotonic_now ⇒ Object 



178
179
180
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 178

def monotonic_now
  Process.clock_gettime(Process::CLOCK_MONOTONIC)
end

.path_like?(value) ⇒ Boolean

Returns:

  • (Boolean) 


105
106
107
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 105

def path_like?(value)
  value.include?("/") || value.include?("\\") || value.start_with?("~")
end

.read_available_output(output, chunks, output_size) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 144

def read_available_output(output, chunks, output_size)
  ready = IO.select([output], nil, nil, 0)
  return output_size unless ready

  loop do
    output_size = append_output(chunks, output.read_nonblock(OUTPUT_READ_SIZE), output_size)
  rescue IO::WaitReadable, EOFError
    break
  end
  output_size
end

.read_remaining_output(output, chunks, output_size) ⇒ Object 



156
157
158
159
160
161
162
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 156

def read_remaining_output(output, chunks, output_size)
  loop do
    output_size = append_output(chunks, output.read_nonblock(OUTPUT_READ_SIZE), output_size)
  end
rescue IO::WaitReadable, IOError, EOFError
  output_size
end

.run(language, content, cancelled: nil, cwd: Dir.pwd, source_path: nil, runner_config: {}) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 35

def run(language, content, cancelled: nil, cwd: Dir.pwd, source_path: nil, runner_config: {})
  language = ScratchpadLanguages.normalize(language)
  runner = ScratchpadLanguages.runner(language)
  raise ArgumentError, "Scratchpad language #{language.inspect} is not runnable" unless runner

  cwd = File.expand_path(cwd.to_s.empty? ? Dir.pwd : cwd)
  binary = configured_binary(runner, runner_config, cwd)
  arguments = RUNNER_ARGUMENTS.fetch(runner, [])
  default_display_path = ScratchpadLanguages.display_path(language)
  display_path = source_path.to_s.empty? ? default_display_path : File.basename(source_path.to_s)
  extension = File.extname(display_path)
  extension = File.extname(default_display_path) if extension.empty?
  started_at = monotonic_now
  output, status, was_cancelled, truncated = capture_source(
    content,
    extension: extension,
    source_path: source_path,
    cwd: cwd,
    command: [binary, *arguments],
    cancelled: cancelled
  )
  Result.new(
    language: language,
    output: output,
    exit_status: was_cancelled ? 130 : status.exitstatus,
    duration: monotonic_now - started_at,
    command: [binary, *arguments, "<#{display_path}>"],
    cancelled: was_cancelled,
    truncated: truncated
  )
rescue Errno::ENOENT
  raise ArgumentError, "Editor runner #{runner.inspect} binary #{binary.inspect} was not found"
rescue Errno::EACCES
  raise ArgumentError, "Editor runner #{runner.inspect} binary #{binary.inspect} is not executable"
end

.temporary_directory(cwd, source_path) ⇒ Object 



96
97
98
99
100
101
102
103
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 96

def temporary_directory(cwd, source_path)
  return cwd if source_path.to_s.empty?

  directory = File.dirname(File.expand_path(source_path, cwd))
  return directory if Dir.exist?(directory) && File.writable?(directory)

  cwd
end

.terminate_process(pid) ⇒ Object 



172
173
174
175
176
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 172

def terminate_process(pid)
  Process.kill("TERM", pid)
rescue Errno::ESRCH
  nil
end

.windows_host? ⇒ Boolean

Returns:

  • (Boolean) 


109
110
111
 
# File 'lib/kward/prompt_interface/editor/scratchpad_runner.rb', line 109

def windows_host?
  RbConfig::CONFIG["host_os"].to_s.match?(/mswin|mingw|cygwin/i)
end