rpremote 0.1.0

data/lib/rpremote/shell.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "io/wait"
+
+module Rpremote
+  class Shell
+    DEFAULT_TIMEOUT = 10.0
+    PROMPT_START = "\e[?25l\e[1G$> \e[0K".b
+    PROMPT_END = "\e[?25h".b
+    ECHO_START = "\e[?25l\e[1G$> ".b
+    ERASE_LINE = "\e[0K".b
+    CURSOR_POSITION_QUERY = "\e[6n".b
+    CURSOR_POSITION_RESPONSE = "\e[1;1R".b
+
+    class Error < Rpremote::Error; end
+    class TimeoutError < Error; end
+    class ProtocolError < Error; end
+    class CommandError < Error; end
+
+    def self.quote_argument(argument)
+      argument = String(argument)
+      raise ArgumentError, "shell argument contains a control character" if argument.match?(/[\x00-\x1f\x7f]/)
+      return "'#{argument}'" unless argument.include?("'")
+      return %("#{argument}") unless argument.include?('"')
+
+      raise ArgumentError, "shell argument cannot contain both quote characters"
+    end
+
+    attr_reader :io, :timeout
+
+    def initialize(io, timeout: DEFAULT_TIMEOUT)
+      raise ArgumentError, "timeout must be positive" unless timeout.positive?
+
+      @io = io
+      @timeout = timeout
+    end
+
+    def synchronize!
+      drain_input
+      write_all("\r".b)
+      read_until_prompt
+      nil
+    end
+
+    def execute(command)
+      command = validate_command(command)
+      send_command(command)
+      response = read_until_prompt(after: ECHO_START + command.b + ERASE_LINE)
+      extract_output(response, command)
+    rescue TimeoutError
+      interrupt
+      raise
+    end
+
+    def send_command(command)
+      command = validate_command(command)
+      write_all("#{command}\r".b)
+      nil
+    end
+
+    private
+
+    def validate_command(command)
+      command = String(command)
+      raise ArgumentError, "shell command must not be empty" if command.empty?
+      raise ArgumentError, "shell command contains a control character" if command.match?(/[\x00-\x1f\x7f]/)
+
+      command
+    end
+
+    def read_until_prompt(wait: timeout, after: nil)
+      deadline = monotonic_time + wait
+      buffer = +"".b
+      loop do
+        boundary = after ? buffer.index(after) : 0
+        prompt_at = buffer.index(PROMPT_START, boundary + (after&.bytesize || 0)) if boundary
+        return buffer if prompt_at && buffer.index(PROMPT_END, prompt_at + PROMPT_START.bytesize)
+
+        buffer << read_available(deadline)
+        answer_terminal_queries(buffer)
+      end
+    end
+
+    def extract_output(response, command)
+      echo = ECHO_START + command.b + ERASE_LINE
+      echo_at = response.rindex(echo)
+      raise ProtocolError, "R2P2 Shell did not echo the command" unless echo_at
+
+      prompt_at = response.index(PROMPT_START, echo_at + echo.bytesize)
+      raise ProtocolError, "R2P2 Shell prompt was not found after the command" unless prompt_at
+
+      output_at = response.index("\n", echo_at + echo.bytesize)
+      raise ProtocolError, "R2P2 Shell response has no command boundary" unless output_at
+
+      response.byteslice((output_at + 1)...prompt_at) || +"".b
+    end
+
+    def drain_input
+      deadline = monotonic_time + 0.1
+      buffer = +"".b
+      loop do
+        remaining = deadline - monotonic_time
+        break unless remaining.positive? && selectable_io.wait_readable(remaining)
+
+        buffer << io.read_nonblock(4096)
+      rescue IO::WaitReadable
+        next
+      rescue EOFError
+        raise IOError, "serial connection closed"
+      end
+      answer_terminal_queries(buffer)
+    end
+
+    def read_available(deadline)
+      remaining = deadline - monotonic_time
+      raise TimeoutError, "timed out waiting for the R2P2 Shell after #{timeout} seconds" unless remaining.positive?
+      unless selectable_io.wait_readable(remaining)
+        raise TimeoutError, "timed out waiting for the R2P2 Shell after #{timeout} seconds"
+      end
+
+      data = io.read_nonblock(4096)
+      raise IOError, "serial connection closed" if data.nil? || data.empty?
+
+      data
+    rescue IO::WaitReadable
+      retry
+    rescue EOFError
+      raise IOError, "serial connection closed"
+    end
+
+    def interrupt
+      write_all("\x03".b)
+      read_until_prompt(wait: [timeout, 1.0].min)
+    rescue IOError, SystemCallError, Error
+      nil
+    end
+
+    def answer_terminal_queries(buffer)
+      write_all(CURSOR_POSITION_RESPONSE) while buffer.sub!(CURSOR_POSITION_QUERY, "")
+    end
+
+    def write_all(data)
+      offset = 0
+      while offset < data.bytesize
+        written = io.write(data.byteslice(offset..))
+        raise IOError, "serial connection closed while writing" unless written&.positive?
+
+        offset += written
+      end
+      io.flush if io.respond_to?(:flush)
+    end
+
+    def selectable_io
+      io.respond_to?(:to_io) ? io.to_io : io
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/rpremote/target.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rpremote
+  class Target
+    DEFAULT_LANGUAGE = "picoruby"
+    DEFAULT_LANGUAGE_VERSION = "4.0.3"
+    DEFAULT_BOARD = "pico2"
+    DEFAULT_CACHE_DIR = "firmware"
+    IDENTIFIER_PATTERN = /\A[a-zA-Z0-9][a-zA-Z0-9._-]*\z/
+
+    attr_reader :language, :language_version, :board, :cache_dir
+
+    def initialize(
+      language: DEFAULT_LANGUAGE,
+      language_version: DEFAULT_LANGUAGE_VERSION,
+      board: DEFAULT_BOARD,
+      cache_dir: DEFAULT_CACHE_DIR,
+      firmware: nil
+    )
+      @language = validate_identifier(:language, language)
+      @language_version = validate_identifier(:language_version, language_version)
+      @board = validate_identifier(:board, board)
+      @cache_dir = String(cache_dir).gsub("{version}", @language_version)
+      @firmware = firmware
+      raise ArgumentError, "cache must not be empty" if @cache_dir.empty?
+    end
+
+    def source_dir(root: Dir.pwd)
+      File.expand_path(File.join(cache_dir, "#{language}-#{language_version}"), root)
+    end
+
+    def firmware_path(root: nil)
+      path = @firmware || File.join(cache_dir, "#{language}-#{language_version}-#{board}.uf2")
+      root ? File.expand_path(path, root) : path
+    end
+
+    private
+
+    def validate_identifier(name, value)
+      value = String(value)
+      return value if IDENTIFIER_PATTERN.match?(value)
+
+      raise ArgumentError, "invalid #{name}: #{value.inspect}"
+    end
+  end
+end

data/lib/rpremote/terminal.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Rpremote
+  class Terminal
+    EXIT_BYTE = 0x1D
+    BUFFER_SIZE = 4096
+
+    attr_reader :serial_io, :input, :output
+
+    def initialize(serial_io, input: $stdin, output: $stdout, selector: nil)
+      @serial_io = serial_io
+      @input = input
+      @output = output
+      @selector = selector || ->(readers) { IO.select(readers) }
+    end
+
+    def run(exit_sequence: nil)
+      with_raw_input { relay }
+    ensure
+      leave_interactive_mode(exit_sequence)
+    end
+
+    private
+
+    def with_raw_input(&)
+      if input.respond_to?(:tty?) && input.tty? && input.respond_to?(:raw)
+        input.raw(&)
+      else
+        yield
+      end
+    end
+
+    def relay
+      readers = [selectable_serial, input]
+      loop do
+        ready = @selector.call(readers)
+        break unless ready
+
+        return if ready.first.any? { |stream| !relay_stream(stream) }
+      end
+    rescue EOFError, Errno::EIO
+      nil
+    end
+
+    def relay_stream(stream)
+      if stream.equal?(selectable_serial)
+        data = serial_io.read_nonblock(BUFFER_SIZE)
+        return false if data.nil? || data.empty?
+
+        output.write(data)
+        output.flush if output.respond_to?(:flush)
+        true
+      else
+        relay_input?
+      end
+    rescue IO::WaitReadable
+      true
+    end
+
+    def relay_input?
+      data = input.read_nonblock(BUFFER_SIZE)
+      return false if data.nil? || data.empty?
+
+      exit_at = data.index(EXIT_BYTE.chr)
+      if exit_at&.positive?
+        serial_io.write(data.byteslice(0...exit_at))
+        serial_io.flush if serial_io.respond_to?(:flush)
+      end
+      return false if exit_at
+
+      serial_io.write(data)
+      serial_io.flush if serial_io.respond_to?(:flush)
+      true
+    end
+
+    def selectable_serial
+      @selectable_serial ||= serial_io.respond_to?(:to_io) ? serial_io.to_io : serial_io
+    end
+
+    def leave_interactive_mode(sequence)
+      return unless sequence
+
+      serial_io.write(sequence)
+      serial_io.flush if serial_io.respond_to?(:flush)
+    rescue IOError, SystemCallError
+      nil
+    end
+  end
+end

data/lib/rpremote/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rpremote
+  VERSION = "0.1.0"
+end

data/lib/rpremote.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "rpremote/version"
+
+module Rpremote
+  class Error < StandardError; end
+end
+
+require_relative "rpremote/checksum"
+require_relative "rpremote/config"
+require_relative "rpremote/target"
+require_relative "rpremote/language"
+require_relative "rpremote/remote_path"
+require_relative "rpremote/picomodem"
+require_relative "rpremote/device"
+require_relative "rpremote/dfu_compiler"
+require_relative "rpremote/serial"
+require_relative "rpremote/terminal"
+require_relative "rpremote/shell"
+require_relative "rpremote/runner"
+require_relative "rpremote/resetter"
+require_relative "rpremote/language_source"
+require_relative "rpremote/mrbgems"
+require_relative "rpremote/mrbgems_command"
+require_relative "rpremote/flasher"
+require_relative "rpremote/builder"
+require_relative "rpremote/dfu_command"
+require_relative "rpremote/setup_command"
+require_relative "rpremote/build_command"
+require_relative "rpremote/flash_command"