rpremote 0.5.0 → 0.7.0

data/lib/rpremote/mrbgems/lockfile.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Rpremote
+  class Mrbgems
+    module Lockfile
+      def read_lock(required: true)
+        contents = JSON.parse(File.read(lock_path))
+        validate_lock!(contents)
+        contents
+      rescue Errno::ENOENT
+        raise LockError, "mrbgems lock file does not exist: #{lock_path}" if required
+
+        nil
+      rescue JSON::ParserError => e
+        raise LockError, "invalid mrbgems lock file #{lock_path}: #{e.message}"
+      end
+
+      def require_names
+        lock_data = read_lock(required: false)
+        return [] unless lock_data
+
+        lock_data.fetch("gems").filter_map do |gem|
+          gem["require_name"] if gem.fetch("auto_require", true)
+        end.uniq
+      end
+
+      def prepend_requires(source)
+        names = require_names
+        return source if names.empty?
+
+        names.map { |name| "require #{name.inspect}\n" }.join.b + source.b
+      end
+
+      def locked_vm
+        read_lock.fetch("vm", nil)&.to_sym
+      end
+
+      private
+
+      def validate_lock!(contents)
+        validate_lock_header!(contents)
+        validate_lock_entries!(contents)
+      end
+
+      def validate_lock_header!(contents)
+        unless contents.is_a?(Hash) && contents["version"] == LOCK_VERSION
+          raise LockError,
+                "unsupported mrbgems lock format: #{lock_path}; " \
+                "run `rpremote mrbgems lock` to regenerate it"
+        end
+        excluded = contents.fetch("without", [])
+        unless contents["gems"].is_a?(Array) && contents["with"].is_a?(Array) && excluded.is_a?(Array) &&
+               valid_groups?(contents["with"]) && valid_groups?(excluded)
+          raise LockError, "invalid mrbgems lock file: #{lock_path}"
+        end
+        return if contents["vm"].nil? || VMS.map(&:to_s).include?(contents["vm"])
+
+        raise LockError, "invalid mrbgems VM in lock file: #{contents["vm"].inspect}"
+      end
+
+      def validate_lock_entries!(contents)
+        contents["gems"].each do |entry|
+          type = entry["type"] if entry.is_a?(Hash)
+          valid = entry.is_a?(Hash) && (type == "github" ? valid_github_lock?(entry) : valid_path_lock?(entry))
+          valid &&= valid_groups?(entry["groups"])
+          valid &&= entry_groups_selected?(entry, contents["with"], contents.fetch("without", []))
+          raise LockError, "invalid mrbgems lock entry: #{entry.inspect}" unless valid
+        end
+        keys = contents["gems"].map { |entry| [entry["type"], entry["source"]] }
+        raise LockError, "duplicate mrbgems lock entries: #{lock_path}" unless keys.uniq.length == keys.length
+      end
+
+      def valid_github_lock?(entry)
+        entry["source"].is_a?(String) && GITHUB_PATTERN.match?(entry["source"]) &&
+          entry["branch"].is_a?(String) && !entry["branch"].empty? &&
+          !entry["branch"].match?(/[\x00-\x1f\x7f]/) && entry["commit"].is_a?(String) &&
+          COMMIT_PATTERN.match?(entry["commit"]) &&
+          valid_require_name?(entry["require_name"]) &&
+          valid_auto_require?(entry)
+      end
+
+      def valid_path_lock?(entry)
+        entry["type"] == "path" && entry["source"].is_a?(String) && !entry["source"].empty? &&
+          !entry["source"].start_with?(File::SEPARATOR) && !entry["source"].match?(/[\x00-\x1f\x7f]/) &&
+          entry["sha256"].is_a?(String) && /\A[0-9a-f]{64}\z/.match?(entry["sha256"]) &&
+          valid_require_name?(entry["require_name"]) &&
+          valid_auto_require?(entry)
+      end
+
+      def valid_require_name?(name)
+        name.nil? || (name.is_a?(String) && !name.empty? && !name.match?(/[\x00-\x1f\x7f]/))
+      end
+
+      def valid_auto_require?(entry)
+        !entry.key?("auto_require") || entry["auto_require"] == true || entry["auto_require"] == false
+      end
+
+      def valid_groups?(groups)
+        groups.nil? || (groups.is_a?(Array) && groups.uniq.length == groups.length &&
+          groups.all? { |name| name.is_a?(String) && GROUP_PATTERN.match?(name) })
+      end
+
+      def entry_groups_selected?(entry, selected, excluded)
+        groups = Array(entry["groups"])
+        groups.empty? || (groups.intersect?(selected) && !groups.intersect?(excluded))
+      end
+
+      def validate_locked_paths!(entries)
+        entries.select { |entry| entry["type"] == "path" }.each do |entry|
+          directory = resolved_locked_path(entry)
+          raise LockError, "locked local mrbgem does not exist: #{directory}" unless mrbgem_directory?(directory)
+          next if digest_directory(directory) == entry.fetch("sha256")
+
+          raise LockError,
+                "locked local mrbgem has changed: #{directory}; " \
+                "run `rpremote mrbgems lock` to update #{lock_path}"
+        end
+      end
+
+      def mrbgem_directory?(directory)
+        File.file?(File.join(directory, "mrbgem.rake"))
+      end
+
+      def resolved_locked_path(entry)
+        File.expand_path(entry.fetch("source"), File.dirname(lock_path))
+      end
+    end
+
+    include Lockfile
+  end
+end

data/lib/rpremote/mrbgems.rb

@@ -9,12 +9,13 @@ module Rpremote
   class Mrbgems
     DEFAULT_PATH = "Mrbgems"
     DEFAULT_LOCK_PATH = "Mrbgems.lock"
-    LOCK_VERSION = 1
+    LOCK_VERSION = 2
     GITHUB_PATTERN = %r{\A[\w.-]+/[\w.-]+\z}
     COMMIT_PATTERN = /\A[0-9a-f]{40,64}\z/i
+    GROUP_PATTERN = /\A[a-zA-Z0-9][a-zA-Z0-9_-]*\z/
     VMS = %i[mruby mrubyc].freeze
 
-    Dependency = Data.define(:type, :source, :branch, :commit, :path, :require_name, :auto_require)
+    Dependency = Data.define(:type, :source, :branch, :commit, :path, :require_name, :auto_require, :groups)
     Overlay = Data.define(:path, :fingerprint)
 
     class Error < Rpremote::Error; end
@@ -25,10 +26,30 @@ module Rpremote
 
     def initialize(path: DEFAULT_PATH, lock_path: nil, cwd: Dir.pwd, resolver: nil)
       @path = File.expand_path(path, cwd)
-      @lock_path = File.expand_path(lock_path || DEFAULT_LOCK_PATH, File.dirname(@path))
+      @lock_path = if lock_path
+                     File.expand_path(lock_path, cwd)
+                   else
+                     File.expand_path(DEFAULT_LOCK_PATH, File.dirname(@path))
+                   end
       @resolver = resolver || method(:resolve_github)
     end
 
+    def self.parse_groups(value)
+      groups = value.to_s.split(",", -1).map(&:strip)
+      raise DefinitionError, "invalid mrbgem group: #{value.inspect}" if groups.empty?
+
+      normalize_groups(groups)
+    end
+
+    def self.normalize_groups(values)
+      Array(values).map do |name|
+        value = name.to_s
+        raise DefinitionError, "invalid mrbgem group: #{name.inspect}" unless GROUP_PATTERN.match?(value)
+
+        value.to_sym
+      end.uniq.freeze
+    end
+
     def exist?
       File.file?(path)
     end
@@ -37,6 +58,18 @@ module Rpremote
       @dependencies ||= load_definition
     end
 
+    def selected_dependencies(with: [], without: [])
+      selected_groups = self.class.normalize_groups(with)
+      excluded_groups = self.class.normalize_groups(without)
+      dependencies
+      available = @definition.groups
+      validate_selected_groups!(selected_groups + excluded_groups, available)
+      dependencies.select do |dependency|
+        dependency.groups.empty? ||
+          (dependency.groups.intersect?(selected_groups) && !dependency.groups.intersect?(excluded_groups))
+      end
+    end
+
     def vm
       dependencies
       @definition.vm_name
@@ -47,50 +80,36 @@ module Rpremote
       dependencies
     end
 
-    def lock(update: false)
-      check
-      previous = update ? nil : read_lock(required: false)
-      entries = dependencies.map { |dependency| lock_entry(dependency, previous) }
-      contents = { "version" => LOCK_VERSION, "vm" => vm&.to_s, "gems" => entries }.compact
-      write_json(lock_path, contents)
-      contents
-    end
-
-    def read_lock(required: true)
-      contents = JSON.parse(File.read(lock_path))
+    def lock(update: false, with: [], without: [])
+      selected_groups = self.class.normalize_groups(with)
+      excluded_groups = self.class.normalize_groups(without)
+      previous = update ? nil : read_previous_lock
+      selected = selected_dependencies(with: selected_groups, without: excluded_groups)
+      selected.each { |dependency| validate_local!(dependency) if dependency.type == :path }
+      entries = selected.map do |dependency|
+        lock_entry(dependency, previous)
+      end
+      contents = {
+        "version" => LOCK_VERSION,
+        "vm" => vm&.to_s,
+        "with" => selected_groups.map(&:to_s),
+        "without" => excluded_groups.map(&:to_s),
+        "gems" => entries
+      }.compact
       validate_lock!(contents)
+      write_json(lock_path, contents)
       contents
-    rescue Errno::ENOENT
-      raise LockError, "mrbgems lock file does not exist: #{lock_path}" if required
-
-      nil
-    rescue JSON::ParserError => e
-      raise LockError, "invalid mrbgems lock file #{lock_path}: #{e.message}"
-    end
-
-    def require_names
-      lock_data = read_lock(required: false)
-      return [] unless lock_data
-
-      lock_data.fetch("gems").filter_map do |gem|
-        gem["require_name"] if gem.fetch("auto_require", true)
-      end.uniq
-    end
-
-    def prepend_requires(source)
-      names = require_names
-      return source if names.empty?
-
-      names.map { |name| "require #{name.inspect}\n" }.join.b + source.b
     end
 
-    def generate_overlay(base_config:, target:, directory:, update: false)
-      lock_data = lock(update: update)
+    def generate_overlay(base_config:, target:, directory:)
+      lock_data = read_lock
+      entries = lock_data.fetch("gems")
+      validate_locked_paths!(entries)
       fingerprint = build_fingerprint(base_config, lock_data)
       output_dir = File.join(File.expand_path(directory), fingerprint)
       output_path = File.join(output_dir, "build_config.rb")
       FileUtils.mkdir_p(output_dir)
-      write_file(output_path, overlay_source(base_config, target, lock_data.fetch("gems")))
+      write_file(output_path, overlay_source(base_config, target, entries))
       Overlay.new(path: output_path, fingerprint: fingerprint)
     end
 
@@ -128,7 +147,7 @@ module Rpremote
                   "branch" => dependency.branch, "commit" => validate_commit!(commit),
                   "require_name" => dependency.require_name }.compact
       else
-        entry = { "type" => "path", "source" => dependency.source,
+        entry = { "type" => "path", "source" => locked_path(dependency.path),
                   "sha256" => digest_directory(dependency.path),
                   "require_name" => dependency.require_name || local_require_name(dependency.path) }.compact
       end
@@ -136,6 +155,7 @@ module Rpremote
         entry.delete("require_name")
         entry["auto_require"] = false
       end
+      entry["groups"] = dependency.groups.map(&:to_s) unless dependency.groups.empty?
       entry
     end
 
@@ -149,6 +169,26 @@ module Rpremote
       entry&.fetch("commit", nil)
     end
 
+    def read_previous_lock
+      contents = JSON.parse(File.read(lock_path))
+      raise LockError, "invalid mrbgems lock file: #{lock_path}" unless contents.is_a?(Hash)
+
+      version = contents["version"]
+      supported = [1, LOCK_VERSION].include?(version) && contents["gems"].is_a?(Array)
+      raise LockError, "unsupported mrbgems lock format: #{lock_path}" unless supported
+
+      if version == LOCK_VERSION
+        validate_lock!(contents)
+      elsif contents["gems"].any? { |entry| !entry.is_a?(Hash) }
+        raise LockError, "invalid mrbgems lock file: #{lock_path}"
+      end
+      contents
+    rescue Errno::ENOENT
+      nil
+    rescue JSON::ParserError => e
+      raise LockError, "invalid mrbgems lock file #{lock_path}: #{e.message}"
+    end
+
     def validate_commit!(commit)
       value = commit.to_s.downcase
       raise LockError, "invalid Git commit: #{commit.inspect}" unless COMMIT_PATTERN.match?(value)
@@ -190,41 +230,6 @@ module Rpremote
       relative.split(File::SEPARATOR).intersect?(%w[.git build tmp])
     end
 
-    def validate_lock!(contents)
-      unless contents.is_a?(Hash) && contents["version"] == LOCK_VERSION && contents["gems"].is_a?(Array)
-        raise LockError, "unsupported mrbgems lock format: #{lock_path}"
-      end
-      unless contents["vm"].nil? || VMS.map(&:to_s).include?(contents["vm"])
-        raise LockError, "invalid mrbgems VM in lock file: #{contents["vm"].inspect}"
-      end
-
-      contents["gems"].each do |entry|
-        type = entry["type"]
-        valid = type == "github" ? valid_github_lock?(entry) : valid_path_lock?(entry)
-        raise LockError, "invalid mrbgems lock entry: #{entry.inspect}" unless valid
-      end
-    end
-
-    def valid_github_lock?(entry)
-      GITHUB_PATTERN.match?(entry["source"].to_s) && !entry["branch"].to_s.empty? &&
-        COMMIT_PATTERN.match?(entry["commit"].to_s) && valid_require_name?(entry["require_name"]) &&
-        valid_auto_require?(entry)
-    end
-
-    def valid_path_lock?(entry)
-      entry["type"] == "path" && !entry["source"].to_s.empty? &&
-        /\A[0-9a-f]{64}\z/.match?(entry["sha256"].to_s) && valid_require_name?(entry["require_name"]) &&
-        valid_auto_require?(entry)
-    end
-
-    def valid_require_name?(name)
-      name.nil? || (name.is_a?(String) && !name.empty? && !name.match?(/[\x00-\x1f\x7f]/))
-    end
-
-    def valid_auto_require?(entry)
-      !entry.key?("auto_require") || entry["auto_require"] == true || entry["auto_require"] == false
-    end
-
     def local_require_name(directory)
       source = File.read(File.join(directory, "mrbgem.rake"))
       match = source.match(/^\s*spec\.require_name\s*=\s*["']([^"']+)["']\s*$/)
@@ -233,7 +238,7 @@ module Rpremote
 
     def build_fingerprint(base_config, lock_data)
       Digest::SHA256.hexdigest(
-        [File.binread(path), File.binread(base_config), JSON.generate(lock_data)].join("\0")
+        [File.binread(base_config), JSON.generate(lock_data)].join("\0")
       ).slice(0, 12)
     end
 
@@ -245,93 +250,28 @@ module Rpremote
         "load #{File.expand_path(base_config).inspect}",
         "conf = MRuby.targets.fetch(#{target.inspect})"
       ]
-      dependencies.zip(locked_entries).each do |dependency, locked|
-        lines << if dependency.type == :github
-                   "conf.gem github: #{dependency.source.inspect}, " \
-                     "branch: #{dependency.branch.inspect}, checksum_hash: #{locked.fetch("commit").inspect}"
+      locked_entries.each do |locked|
+        lines << if locked.fetch("type") == "github"
+                   "conf.gem github: #{locked.fetch("source").inspect}, " \
+                     "branch: #{locked.fetch("branch").inspect}, checksum_hash: #{locked.fetch("commit").inspect}"
                  else
-                   "conf.gem #{dependency.path.inspect}"
+                   "conf.gem #{resolved_locked_path(locked).inspect}"
                  end
       end
       "#{lines.join("\n")}\n"
     end
 
-    def write_json(filename, contents)
-      write_file(filename, "#{JSON.pretty_generate(contents)}\n")
-    end
-
-    def write_file(filename, contents)
-      return if File.file?(filename) && File.binread(filename) == contents
-
-      FileUtils.mkdir_p(File.dirname(filename))
-      temporary = "#{filename}.tmp-#{Process.pid}"
-      File.binwrite(temporary, contents)
-      File.rename(temporary, filename)
-    ensure
-      FileUtils.rm_f(temporary) if temporary
+    def locked_path(directory)
+      Pathname.new(directory).relative_path_from(Pathname.new(File.dirname(lock_path))).to_s
     end
 
-    class Definition
-      attr_reader :dependencies, :vm_name
-
-      def initialize(filename)
-        @directory = File.dirname(filename)
-        @dependencies = []
-      end
-
-      def vm(name)
-        value = name.to_sym
-        raise DefinitionError, "unsupported mrbgems VM: #{name.inspect}" unless VMS.include?(value)
-        raise DefinitionError, "mrbgems VM specified more than once" if vm_name
-
-        @vm_name = value
-      end
-
-      def gem(github: nil, path: nil, branch: "main", commit: nil, require: nil, auto_require: true)
-        sources = [github, path].compact
-        raise DefinitionError, "gem requires exactly one of github or path" unless sources.length == 1
-        unless require.nil? || (require.is_a?(String) && !require.empty? && !require.match?(/[\x00-\x1f\x7f]/))
-          raise DefinitionError, "invalid mrbgem require name: #{require.inspect}"
-        end
-
-        valid_auto_require = [true, false].include?(auto_require)
-        raise DefinitionError, "mrbgem auto_require must be true or false: #{auto_require.inspect}" unless valid_auto_require
-
-        dependency = if github
-                       github_dependency(github, branch, commit, require, auto_require)
-                     else
-                       path_dependency(path, branch, commit, require, auto_require)
-                     end
-        key = [dependency.type, dependency.source]
-        raise DefinitionError, "duplicate mrbgem: #{dependency.source}" if dependencies.any? do |item|
-          [item.type, item.source] == key
-        end
-
-        dependencies << dependency
-      end
-
-      private
-
-      attr_reader :directory
-
-      def github_dependency(source, branch, commit, require_name, auto_require)
-        raise DefinitionError, "invalid GitHub mrbgem: #{source.inspect}" unless GITHUB_PATTERN.match?(source.to_s)
-        raise DefinitionError, "GitHub mrbgem branch must not be empty" if branch.to_s.empty?
-        raise DefinitionError, "invalid Git commit: #{commit.inspect}" if commit && !COMMIT_PATTERN.match?(commit.to_s)
-
-        Dependency.new(type: :github, source: source, branch: branch,
-                       commit: commit&.downcase, path: nil, require_name: require_name,
-                       auto_require: auto_require)
-      end
-
-      def path_dependency(source, branch, commit, require_name, auto_require)
-        raise DefinitionError, "local mrbgem path must not be empty" if source.to_s.empty?
-        raise DefinitionError, "local mrbgem does not accept branch or commit" if branch != "main" || commit
-
-        Dependency.new(type: :path, source: source, branch: nil, commit: nil,
-                       path: File.expand_path(source, directory), require_name: require_name,
-                       auto_require: auto_require)
-      end
+    def validate_selected_groups!(selected, available)
+      unknown = selected - available
+      raise DefinitionError, "unknown mrbgem group: #{unknown.join(", ")}" unless unknown.empty?
     end
   end
 end
+
+require_relative "mrbgems/file_writer"
+require_relative "mrbgems/lockfile"
+require_relative "mrbgems/definition"

data/lib/rpremote/mrbgems_command.rb

@@ -10,12 +10,21 @@ module Rpremote
     def self.run(args, output: $stdout, mrbgems: Mrbgems)
       command = args.shift
       options = { path: DEFAULT_PATH, lock_path: nil }
+      with = nil
+      without = nil
       OptionParser.new do |opts|
         opts.on("--file FILE") { |value| options[:path] = value }
         opts.on("--lockfile FILE") { |value| options[:lock_path] = value }
+        opts.on("--with GROUPS") { |value| with = Mrbgems.parse_groups(value) }
+        opts.on("--without GROUPS") { |value| without = Mrbgems.parse_groups(value) }
       end.parse!(args)
       raise ArgumentError, "mrbgems does not accept arguments" unless args.empty?
 
+      unless %w[lock update].include?(command)
+        raise ArgumentError, "--with is only available for mrbgems lock and update" if with
+        raise ArgumentError, "--without is only available for mrbgems lock and update" if without
+      end
+
       manager = mrbgems.new(**options)
       case command
       when "check"
@@ -24,7 +33,7 @@ module Rpremote
       when "list"
         list(manager, output)
       when "lock", "update"
-        result = manager.lock(update: command == "update")
+        result = manager.lock(update: command == "update", with: with || [], without: without || [])
         output.puts("locked #{result.fetch("gems").length} mrbgems: #{manager.lock_path}")
       else
         raise ArgumentError, "unknown mrbgems command: #{command || "(none)"}"
@@ -36,13 +45,19 @@ module Rpremote
       lock = manager.read_lock(required: false)
       entries = lock&.fetch("gems", []) || []
       dependencies.each do |dependency|
-        entry = entries.find do |item|
-          item["type"] == dependency.type.to_s && item["source"] == dependency.source
-        end
+        entry = entries.find { |item| matching_entry?(manager, dependency, item) }
         suffix = entry && (entry["commit"] || entry["sha256"])
         output.puts([dependency.type, dependency.source, suffix&.slice(0, 12)].compact.join(" "))
       end
     end
     private_class_method :list
+
+    def self.matching_entry?(manager, dependency, entry)
+      return false unless entry["type"] == dependency.type.to_s
+      return entry["source"] == dependency.source if dependency.type == :github
+
+      File.expand_path(entry["source"], File.dirname(manager.lock_path)) == dependency.path
+    end
+    private_class_method :matching_entry?
   end
 end

data/lib/rpremote/picoruby_compiler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rpremote
+  class PicoRubyCompiler
+    class Error < StandardError; end
+
+    CANDIDATES = %w[
+      build/mrbc/default/bin/mrbc
+      build/host/bin/mrbc
+    ].freeze
+
+    def self.ensure_legacy_path!(root)
+      root = File.expand_path(root)
+      legacy_path = File.join(root, "bin/mrbc")
+      return legacy_path if File.executable?(legacy_path)
+
+      compiler = CANDIDATES.map { |path| File.join(root, path) }.find { |path| File.executable?(path) }
+      raise Error, "PicoRuby mrbc was not built under #{root}" unless compiler
+
+      FileUtils.mkdir_p(File.dirname(legacy_path))
+      relative = File.join("..", compiler.delete_prefix("#{root}/"))
+      FileUtils.ln_sf(relative, legacy_path)
+      legacy_path
+    end
+  end
+end

data/lib/rpremote/picoruby_source_patch.rb

@@ -3,7 +3,6 @@
 module Rpremote
   class PicoRubySourcePatch
     JOB_PATH = "mrbgems/picoruby-shell/mrblib/job.rb"
-    BOOTSEL_PATH = "mrbgems/picoruby-machine/include/machine.h"
     PWM_PATH = "mrbgems/picoruby-pwm/ports/rp2040/pwm.c"
     PATCH_ALIASES = { "3.4.2" => "3.4.5" }.freeze
 
@@ -21,8 +20,6 @@ module Rpremote
       patch_version = PATCH_ALIASES.fetch(version, version)
       patches(patch_version).each do |patch, prerequisite|
         next unless File.file?(patch) && File.file?(File.join(source, prerequisite))
-        next if prerequisite == BOOTSEL_PATH && File.read(File.join(source, prerequisite)).include?("Machine_bootsel")
-
         next if git_apply?(source, patch, "--reverse", "--check")
 
         raise Error, "cannot apply rpremote patch to PicoRuby #{version}" unless git_apply?(source, patch, "--check")
@@ -36,7 +33,6 @@ module Rpremote
     def patches(patch_version)
       definitions = {
         "ruby-exception-status" => JOB_PATH,
-        "bootsel" => BOOTSEL_PATH,
         "pwm-sleep-clock" => PWM_PATH
       }
       definitions.map do |name, prerequisite|

data/lib/rpremote/target.rb

@@ -3,7 +3,7 @@
 module Rpremote
   class Target
     DEFAULT_LANGUAGE = "picoruby"
-    DEFAULT_LANGUAGE_VERSION = "4.0.3"
+    DEFAULT_LANGUAGE_VERSION = "latest"
     DEFAULT_BOARD = "pico2"
     DEFAULT_CACHE_DIR = "firmware"
     IDENTIFIER_PATTERN = /\A[a-zA-Z0-9][a-zA-Z0-9._-]*\z/

data/lib/rpremote/terminal.rb

@@ -75,8 +75,6 @@ module Rpremote
       true
     end
 
-    # input.raw disables the terminal's usual LF-to-CRLF output conversion.
-    # Preserve device CRLF while making a bare LF start at the left margin.
     def normalize_line_endings(data)
       normalized = +"".b
       data.each_byte do |byte|

data/lib/rpremote/version.rb

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

data/lib/rpremote.rb

@@ -21,6 +21,7 @@ require_relative "rpremote/runner"
 require_relative "rpremote/resetter"
 require_relative "rpremote/recursive_copy"
 require_relative "rpremote/picoruby_source_patch"
+require_relative "rpremote/picoruby_compiler"
 require_relative "rpremote/language_source"
 require_relative "rpremote/nuke_firmware"
 require_relative "rpremote/mrbgems"

data/patches/picoruby-4.0.4-pwm-sleep-clock.patch

@@ -0,0 +1,27 @@
+diff --git a/mrbgems/picoruby-pwm/ports/rp2040/pwm.c b/mrbgems/picoruby-pwm/ports/rp2040/pwm.c
+--- a/mrbgems/picoruby-pwm/ports/rp2040/pwm.c
++++ b/mrbgems/picoruby-pwm/ports/rp2040/pwm.c
+@@ -1,3 +1,4 @@
+ #include "pico/stdlib.h"
+ #include "hardware/clocks.h"
+ #include "hardware/pwm.h"
++#include "hardware/structs/clocks.h"
+@@ -61,4 +62,18 @@
+ {
+   uint slice_num = pwm_gpio_to_slice_num(pin);
++  /* The scheduler uses WFI when no task is runnable, and the HAL normally
++   * gates clk_sys_pwm while a core sleeps. Ungate it before starting a slice
++   * so autonomous PWM output continues between scheduler ticks. */
++  if (enabled) {
++    hw_set_bits(&clocks_hw->sleep_en0,
++                CLOCKS_SLEEP_EN0_CLK_SYS_PWM_BITS);
++  }
+   pwm_set_enabled(slice_num, enabled);
++  /* Preserve the clock for every active slice. Once the final slice stops,
++   * restore the HAL's low-power policy instead of keeping PWM clocked merely
++   * because a PWM object was initialized earlier. */
++  if (!enabled && pwm_hw->en == 0) {
++    hw_clear_bits(&clocks_hw->sleep_en0,
++                  CLOCKS_SLEEP_EN0_CLK_SYS_PWM_BITS);
++  }
+ }