rpremote 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b30b1f27c4bdbb212d69bc30f79342bf2caa6ae5c6787125a9627e53f15a714a
-  data.tar.gz: a7ab212fa48b5f58aa11357ffdf52c2f5c8dbf47c2b00c6d3b7279c38a1431d3
+  metadata.gz: 69cb11c8175c8864e4ae4a11108fb37e1ac08bab49b0b61ade2331f550b7d4b6
+  data.tar.gz: 7e32c77e20cda016f4b95ad5e60a5ccabf8a5d8aa1570ce8bcf3fd642b700b9d
 SHA512:
-  metadata.gz: 6086af03b4459d2c96102e7f884cd888276735ae77d30132189a4191c66892366a7deb51676613966751d343d79d5b53519242ac5171cee9d60044d81a4f7225
-  data.tar.gz: dc2851099a3a6a3c019a3cbb8936b4b111f9359d964208163d688d4afb4b4cf27135286949304954f7ea685a215f6373f27e23a3c20c3aa4fb5382e93bec6620
+  metadata.gz: f690408489ed84040dd492d4872747ec0a523d17bafc76603c885722c5aaca43a3a5f0d74584ca81f0ec5e7b4758bf0477a17f2877af045c81756894962fd5a8
+  data.tar.gz: bd1046210f3d48e00604328f72531455f236bd3e348b2bded6495b2681bf383367413ed2083b1469090d24ce10ab37ce85605454efa867e01c88a351807595aa

data/CHANGELOG.md

@@ -4,6 +4,12 @@ Notable changes to the `rpremote` RubyGem will be documented in this file. Repos
 
 ## Unreleased
 
+## 0.7.0 - 2026-10-04
+
+- Add Bundler-style `group` blocks and `gem ..., group:` to `Mrbgems`; `mrbgems lock|update --with/--without` now selects the locked firmware contents, with exclusions taking precedence, and build/runtime commands consume `Mrbgems.lock` without selecting groups again.
+- Make `Mrbgems.lock` version 2 a self-contained build input, add path checksum verification, and replace build/runtime `--mrbgems` and `--groups` options with `--lockfile`.
+- Keep active RP2040/RP2350 PWM slices clocked during scheduler sleep on PicoRuby 4.0.4, and restore clock gating after the final slice stops.
+
 ## 0.6.0 - 2026-09-20
 
 - Change the default PicoRuby version to `latest`, backed by the current `master` branch, while retaining `--language-version` for selecting a release tag.

data/README.ja.md

@@ -59,7 +59,9 @@ rpremote mrbgems lock
 rpremote build
 ```
 
-`Mrbgems.lock`はGitHubのコミットとローカルgemの内容ハッシュを固定します。`build`は既存のlockを再利用し、`rpremote mrbgems update`だけが新しいコミットを解決します。
+`Mrbgems.lock`は`build`で使うmrbgemを確定します。ビルドは`Mrbgems`を評価せず、GitHub branchも解決せずにlockを読みます。新しいコミットを解決するのは`rpremote mrbgems update`です。
+
+構成ごとのgemは`group :development do ... end`または`gem ..., group: :development`で整理できます。`rpremote mrbgems lock --with production --without test`はグループ外の共通gemとproduction gemをlockへ記録します。除外指定が優先され、`build`、`deploy`、`run`、`exec`はそのlockだけを使います。
 
 ファームウェアへ組み込む一方で、すべての`run`、`exec`、`deploy`に先行ロードしないgemには`auto_require: false`を指定できます。アプリケーション側から必要なgemを明示的に`require`してください。
 

data/README.md

@@ -59,7 +59,9 @@ rpremote mrbgems lock
 rpremote build
 ```
 
-`Mrbgems.lock` pins GitHub commits and hashes local gem contents. Existing locks are reused by `build`; `rpremote mrbgems update` deliberately resolves new commits.
+`Mrbgems.lock` pins the exact mrbgems used by `build`. Builds read the lock without evaluating `Mrbgems` or resolving GitHub branches; `rpremote mrbgems update` deliberately resolves new commits.
+
+Use `group :development do ... end` blocks or `gem ..., group: :development` to organize variant-specific gems. `rpremote mrbgems lock --with production --without test` writes common and production gems to the lock; exclusions take precedence, and `build`, `deploy`, `run`, and `exec` then use exactly that lock.
 
 Set `auto_require: false` for a gem that should remain embedded in firmware without being loaded before every `run`, `exec`, or `deploy`. Require that gem explicitly from the application when needed.
 

data/RELEASING.md

@@ -49,7 +49,7 @@ bundle exec rake release
 After the tag exists on GitHub, create a GitHub Release and attach the exact gem that passed validation. `--verify-tag` prevents GitHub CLI from silently creating a tag at another commit:
 
 ```sh
-gh release create v0.5.0 rpremote-0.5.0.gem --verify-tag --generate-notes
+gh release create v0.7.0 rpremote-0.7.0.gem --verify-tag --generate-notes
 ```
 
-Replace `0.5.0` in both places for later versions. Finally, install from RubyGems.org in a fresh environment and run `rpremote --version`.
+Replace `0.7.0` in both places for later versions. Finally, install from RubyGems.org in a fresh environment and run `rpremote --version`.

data/THIRD_PARTY_NOTICES.md

@@ -1,6 +1,6 @@
 # Third-Party Notices
 
-`rpremote` does not bundle R2P2 firmware. The `setup` command downloads a selected PicoRuby/R2P2 4.0.3 or 3.4.2 release from the PicoRuby project and verifies its published SHA-256 digest.
+`rpremote` does not bundle R2P2 firmware. The `setup` command downloads and prepares the selected PicoRuby/R2P2 source archive from the PicoRuby project.
 
 `setup` also downloads Raspberry Pi's `nuke_universal.uf2` from the official Pico SDK prebuilts release. It is used only by `rpremote bootsel --reset-flash-memory` to erase external flash memory.
 

data/lib/rpremote/build_command.rb

@@ -19,7 +19,7 @@ module Rpremote
         board: Target::DEFAULT_BOARD,
         cache_dir: defaults.fetch(:cache, Target::DEFAULT_CACHE_DIR),
         firmware: defaults[:firmware],
-        mrbgems: nil
+        mrbgems_lock: defaults[:mrbgems_lock]
       }.merge(defaults.except(:cache))
       OptionParser.new do |parser|
         parser.on("--language LANGUAGE") { |value| options[:language] = value }
@@ -27,8 +27,8 @@ module Rpremote
         parser.on("--board BOARD") { |value| options[:board] = value }
         parser.on("--firmware FILE") { |value| options[:firmware] = value }
         parser.on("--cache DIR") { |value| options[:cache_dir] = value }
-        parser.on("--mrbgems FILE") { |value| options[:mrbgems] = value }
-        parser.on("--no-mrbgems") { options[:mrbgems] = false }
+        parser.on("--lockfile FILE") { |value| options[:mrbgems_lock] = value }
+        parser.on("--no-mrbgems") { options[:mrbgems_lock] = false }
       end.parse!(args)
       raise ArgumentError, "build does not accept arguments" unless args.empty?
 

data/lib/rpremote/builder.rb

@@ -71,12 +71,12 @@ module Rpremote
     end
 
     def add_mrbgems_environment!(environment, options, source_dir, output)
-      definition = mrbgems_definition(options[:mrbgems])
-      return unless definition
+      lock_file = mrbgems_lock(options[:mrbgems_lock])
+      return unless lock_file
 
-      manager = mrbgems_class.new(path: definition, cwd: root)
+      manager = mrbgems_class.new(lock_path: lock_file, cwd: root)
       config_language = mrbgems_config_language(
-        manager.vm, options.fetch(:language), options.fetch(:language_version)
+        manager.locked_vm, options.fetch(:language), options.fetch(:language_version)
       )
       config_name = "r2p2-#{config_language}-#{options.fetch(:board)}"
       base_config = File.join(source_dir, "build_config", "#{config_name}.rb")
@@ -90,7 +90,6 @@ module Rpremote
       environment["RPREMOTE_CONFIG_NAME"] = config_name
       environment["RPREMOTE_MRUBY_CONFIG"] = overlay.path
       environment["RPREMOTE_MRBGEMS_FINGERPRINT"] = overlay.fingerprint
-      output.puts("using Mrbgems: #{manager.path}")
       output.puts("using Mrbgems.lock: #{manager.lock_path}")
     end
 
@@ -103,12 +102,19 @@ module Rpremote
       modern ? "picoruby" : "microruby"
     end
 
-    def mrbgems_definition(option)
+    def mrbgems_lock(option)
       return if option == false
 
-      candidate = File.expand_path(option || Mrbgems::DEFAULT_PATH, root)
+      candidate = File.expand_path(option || Mrbgems::DEFAULT_LOCK_PATH, root)
       return candidate if File.file?(candidate)
-      raise Error, "mrbgems definition does not exist: #{candidate}" if option
+      raise Error, "mrbgems lock file does not exist: #{candidate}" if option
+
+      definition = File.join(root, Mrbgems::DEFAULT_PATH)
+      if File.file?(definition)
+        raise Error,
+              "Mrbgems.lock does not exist: #{candidate}; " \
+              "run `rpremote mrbgems lock` before building"
+      end
 
       nil
     end

data/lib/rpremote/cli/filesystem_commands.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Rpremote
+  class CLI
+    module FilesystemCommands
+      private
+
+      def fs(args)
+        subcommand = args.shift
+        recursive = subcommand == "cp" && (args.delete("--recursive") || args.delete("-r"))
+        options = parse_connection_options(args)
+        case subcommand
+        when "cp"
+          copy(args, options, recursive: recursive)
+        when "push"
+          copy(args, options, recursive: true, command: "push")
+        when "cat"
+          cat(args, options)
+        when "ls", "rm", "mkdir"
+          filesystem_shell_command(subcommand, args, options)
+        else
+          raise ArgumentError, "unknown fs command: #{subcommand || "(none)"}"
+        end
+      rescue Shell::TimeoutError => e
+        raise Shell::TimeoutError, "filesystem connection failed: #{e.message}"
+      end
+
+      def copy(args, options, recursive: false, command: "cp")
+        usage = command == "push" ? "rpremote fs push LOCAL_DIR :/REMOTE_DIR" : "rpremote fs cp SOURCE DESTINATION"
+        raise ArgumentError, "usage: #{usage} [options]" unless args.length == 2
+
+        source, destination = args
+        source_remote = RemotePath.remote?(source)
+        destination_remote = RemotePath.remote?(destination)
+        raise ArgumentError, "exactly one cp path must be remote (prefix remote paths with :)" if source_remote == destination_remote
+        return RecursiveCopy.new(output: stdout, serial: serial, device: device).call(source, destination, options) if recursive
+
+        ensure_filesystem_connection!(options)
+        if source_remote
+          data = with_modem(options) { |modem| modem.download(RemotePath.unwrap(source)) }
+          File.binwrite(local_destination(destination, source), data)
+          stdout.puts("downloaded #{data.bytesize} bytes: #{source} -> #{destination}")
+        else
+          data = File.binread(source)
+          with_modem(options) { |modem| modem.upload(RemotePath.unwrap(destination), data) }
+          stdout.puts("uploaded #{data.bytesize} bytes: #{source} -> #{destination}")
+        end
+      rescue Errno::ENOENT => e
+        raise ArgumentError, e.message
+      end
+
+      def cat(args, options)
+        raise ArgumentError, "usage: rpremote fs cat :/REMOTE/PATH [options]" unless args.length == 1
+        raise ArgumentError, "cat path must be remote (prefix it with :)" unless RemotePath.remote?(args.first)
+
+        stdout.write(with_modem(options) { |modem| modem.download(RemotePath.unwrap(args.first)) })
+      end
+
+      def filesystem_shell_command(command, args, options)
+        usage = "usage: rpremote fs #{command} :/REMOTE/PATH [options]"
+        raise ArgumentError, usage unless args.length == 1
+
+        path = RemotePath.validate(args.first)
+        stdout.puts("deleting remote path permanently: #{path}") if command == "rm"
+        output = with_shell(options) do |shell|
+          shell.execute("#{command} #{Shell.quote_argument(path)}")
+        end
+        ensure_filesystem_success!(command, output)
+        stdout.write(output)
+      end
+
+      def ensure_filesystem_success!(command, output)
+        failed = command == "ls" ? output.start_with?("ls:") : !output.empty?
+        raise Shell::CommandError, output.strip if failed
+      end
+
+      def ensure_filesystem_connection!(options)
+        output = with_shell(options) { |shell| shell.execute("ls '/'") }
+        ensure_filesystem_success!("ls", output)
+      end
+
+      def with_modem(options)
+        port_path = device.main_port(options[:port])
+        serial.open(port_path, baud: options[:baud]) do |port|
+          yield PicoModem.new(port, timeout: options[:timeout])
+        end
+      end
+
+      def with_shell(options)
+        port_path = device.main_port(options[:port])
+        serial.open(port_path, baud: options[:baud]) do |port|
+          shell = Shell.new(port, timeout: options[:timeout])
+          shell.synchronize!
+          yield shell
+        end
+      end
+
+      def local_destination(destination, source)
+        return destination unless File.directory?(destination)
+
+        File.join(destination, File.basename(RemotePath.unwrap(source)))
+      end
+    end
+  end
+end

data/lib/rpremote/cli.rb

@@ -3,6 +3,7 @@
 require "optparse"
 require_relative "build_command"
 require_relative "bootsel_command"
+require_relative "cli/filesystem_commands"
 require_relative "config_show"
 require_relative "dfu_command"
 require_relative "deploy_command"
@@ -12,9 +13,10 @@ require_relative "mrbgems_command"
 require_relative "recursive_copy"
 require_relative "setup_command"
 
-# rubocop:disable Metrics/ClassLength
 module Rpremote
   class CLI
+    include FilesystemCommands
+
     def self.start(argv = ARGV, config: Config, **options)
       new(**options).run(argv, config: config)
     rescue OptionParser::ParseError, ArgumentError, SystemCallError, Rpremote::Error => e
@@ -136,44 +138,24 @@ module Rpremote
       ConfigShow.run(args, defaults: config_options, output: stdout)
     end
 
-    def fs(args)
-      subcommand = args.shift
-      recursive = subcommand == "cp" && (args.delete("--recursive") || args.delete("-r"))
-      options = parse_connection_options(args)
-      case subcommand
-      when "cp"
-        copy(args, options, recursive: recursive)
-      when "push"
-        copy(args, options, recursive: true, command: "push")
-      when "cat"
-        cat(args, options)
-      when "ls", "rm", "mkdir"
-        filesystem_shell_command(subcommand, args, options)
-      else
-        raise ArgumentError, "unknown fs command: #{subcommand || "(none)"}"
-      end
-    rescue Shell::TimeoutError => e
-      raise Shell::TimeoutError, "filesystem connection failed: #{e.message}"
-    end
-
     def run_file(args)
       reset_on_timeout = !args.delete("--reset-on-timeout").nil?
-      options = parse_connection_options(args)
+      options = parse_connection_options(args, mrbgems_lock: true)
       raise ArgumentError, "usage: rpremote run FILE [options]" unless args.length == 1
 
       source = args.first
       source = File.join(source, "main.rb") if File.directory?(source)
-      data = prepend_mrbgem_requires(File.binread(source))
+      data = prepend_mrbgem_requires(File.binread(source), options[:mrbgems_lock])
       execute_temporary(data, options, output: stdout, reset_on_timeout: reset_on_timeout)
     rescue Errno::ENOENT => e
       raise ArgumentError, e.message
     end
 
     def execute_code(args)
-      options = parse_connection_options(args)
+      options = parse_connection_options(args, mrbgems_lock: true)
       raise ArgumentError, "usage: rpremote exec CODE [options]" unless args.length == 1
 
-      execute_temporary(prepend_mrbgem_requires(args.first), options, output: stdout)
+      execute_temporary(prepend_mrbgem_requires(args.first, options[:mrbgems_lock]), options, output: stdout)
     end
 
     def execute_temporary(data, options, output: nil, reset_on_timeout: false)
@@ -197,8 +179,13 @@ module Rpremote
             "#{timeout_error.message}; automatic reset failed: #{e.message}"
     end
 
-    def prepend_mrbgem_requires(data)
-      Mrbgems.new(cwd: Dir.pwd).prepend_requires(data)
+    def prepend_mrbgem_requires(data, lock_file)
+      return data if lock_file == false
+
+      path = lock_file || Mrbgems::DEFAULT_LOCK_PATH
+      raise ArgumentError, "mrbgems lock file does not exist: #{path}" if lock_file && !File.file?(path)
+
+      Mrbgems.new(cwd: Dir.pwd, lock_path: path).prepend_requires(data)
     end
 
     def interactive(args, repl: false)
@@ -227,18 +214,23 @@ module Rpremote
       stdout.puts("reset R2P2: #{port_path}")
     end
 
-    def parse_connection_options(args, default_timeout: PicoModem::DEFAULT_TIMEOUT)
+    def parse_connection_options(args, default_timeout: PicoModem::DEFAULT_TIMEOUT, mrbgems_lock: false)
       options = {
         port: config_options[:port],
         baud: config_options.fetch(:baud, Serial::BAUD_RATE),
         timeout: config_options.fetch(:timeout, default_timeout),
         language: config_options.fetch(:language, Target::DEFAULT_LANGUAGE)
       }
+      options[:mrbgems_lock] = config_options[:mrbgems_lock] if mrbgems_lock
       parser = OptionParser.new do |opts|
         opts.on("--port PORT") { |value| options[:port] = value }
         opts.on("--baud RATE", Integer) { |value| options[:baud] = value }
         opts.on("--timeout SECONDS", Float) { |value| options[:timeout] = value }
         opts.on("--language LANGUAGE") { |value| options[:language] = value }
+        if mrbgems_lock
+          opts.on("--lockfile FILE") { |value| options[:mrbgems_lock] = value }
+          opts.on("--no-mrbgems") { options[:mrbgems_lock] = false }
+        end
       end
       parser.parse!(args)
       raise ArgumentError, "--baud must be positive" unless options[:baud].positive?
@@ -246,82 +238,5 @@ module Rpremote
 
       options
     end
-
-    def copy(args, options, recursive: false, command: "cp")
-      usage = command == "push" ? "rpremote fs push LOCAL_DIR :/REMOTE_DIR" : "rpremote fs cp SOURCE DESTINATION"
-      raise ArgumentError, "usage: #{usage} [options]" unless args.length == 2
-
-      source, destination = args
-      source_remote = RemotePath.remote?(source)
-      destination_remote = RemotePath.remote?(destination)
-      raise ArgumentError, "exactly one cp path must be remote (prefix remote paths with :)" if source_remote == destination_remote
-      return RecursiveCopy.new(output: stdout, serial: serial, device: device).call(source, destination, options) if recursive
-
-      ensure_filesystem_connection!(options)
-      if source_remote
-        data = with_modem(options) { |modem| modem.download(RemotePath.unwrap(source)) }
-        File.binwrite(local_destination(destination, source), data)
-        stdout.puts("downloaded #{data.bytesize} bytes: #{source} -> #{destination}")
-      else
-        data = File.binread(source)
-        with_modem(options) { |modem| modem.upload(RemotePath.unwrap(destination), data) }
-        stdout.puts("uploaded #{data.bytesize} bytes: #{source} -> #{destination}")
-      end
-    rescue Errno::ENOENT => e
-      raise ArgumentError, e.message
-    end
-
-    def cat(args, options)
-      raise ArgumentError, "usage: rpremote fs cat :/REMOTE/PATH [options]" unless args.length == 1
-      raise ArgumentError, "cat path must be remote (prefix it with :)" unless RemotePath.remote?(args.first)
-
-      stdout.write(with_modem(options) { |modem| modem.download(RemotePath.unwrap(args.first)) })
-    end
-
-    def filesystem_shell_command(command, args, options)
-      usage = "usage: rpremote fs #{command} :/REMOTE/PATH [options]"
-      raise ArgumentError, usage unless args.length == 1
-
-      path = RemotePath.validate(args.first)
-      stdout.puts("deleting remote path permanently: #{path}") if command == "rm"
-      output = with_shell(options) do |shell|
-        shell.execute("#{command} #{Shell.quote_argument(path)}")
-      end
-      ensure_filesystem_success!(command, output)
-      stdout.write(output)
-    end
-
-    def ensure_filesystem_success!(command, output)
-      failed = command == "ls" ? output.start_with?("ls:") : !output.empty?
-      raise Shell::CommandError, output.strip if failed
-    end
-
-    def ensure_filesystem_connection!(options)
-      output = with_shell(options) { |shell| shell.execute("ls '/'") }
-      ensure_filesystem_success!("ls", output)
-    end
-
-    def with_modem(options)
-      port_path = device.main_port(options[:port])
-      serial.open(port_path, baud: options[:baud]) do |port|
-        yield PicoModem.new(port, timeout: options[:timeout])
-      end
-    end
-
-    def with_shell(options)
-      port_path = device.main_port(options[:port])
-      serial.open(port_path, baud: options[:baud]) do |port|
-        shell = Shell.new(port, timeout: options[:timeout])
-        shell.synchronize!
-        yield shell
-      end
-    end
-
-    def local_destination(destination, source)
-      return destination unless File.directory?(destination)
-
-      File.join(destination, File.basename(RemotePath.unwrap(source)))
-    end
   end
 end
-# rubocop:enable Metrics/ClassLength

data/lib/rpremote/config.rb

@@ -16,17 +16,17 @@ module Rpremote
       baud: Integer,
       timeout: Numeric,
       language: String,
-      mrbgems: [String, FalseClass].freeze
+      mrbgems_lock: [String, FalseClass].freeze
     }.freeze
     COMMAND_OPTIONS = {
       "setup" => %i[cache language language_version],
-      "build" => %i[cache language language_version board firmware mrbgems],
+      "build" => %i[cache language language_version board firmware mrbgems_lock],
       "bootsel" => %i[mount port baud timeout],
-      "deploy" => %i[cache language language_version board firmware mrbgems mount port baud timeout],
+      "deploy" => %i[cache language language_version board firmware mrbgems_lock mount port baud timeout],
       "dfu" => %i[cache language language_version port baud timeout],
       "flash" => %i[cache language language_version board firmware mount port timeout],
-      "run" => %i[port baud timeout language],
-      "exec" => %i[port baud timeout language],
+      "run" => %i[port baud timeout language mrbgems_lock],
+      "exec" => %i[port baud timeout language mrbgems_lock],
       "reset" => %i[port baud timeout],
       "monitor" => %i[port baud timeout],
       "repl" => %i[port baud timeout],
@@ -106,6 +106,7 @@ module Rpremote
         expected = OPTION_TYPES[key]
         raise Error, "unknown config option: #{key}" unless expected
         raise Error, "config option #{key} must be a #{type_name(expected)}" unless valid_value?(value, expected)
+
         next unless %i[baud timeout].include?(key)
         next if value.positive?
 

data/lib/rpremote/config_show.rb

@@ -38,7 +38,7 @@ module Rpremote
         board: defaults.fetch(:board, Target::DEFAULT_BOARD),
         cache: defaults.fetch(:cache, Target::DEFAULT_CACHE_DIR),
         firmware: defaults[:firmware],
-        mrbgems: defaults[:mrbgems],
+        mrbgems_lock: defaults[:mrbgems_lock],
         mount: defaults[:mount],
         port: defaults[:port],
         baud: defaults.fetch(:baud, Serial::BAUD_RATE),
@@ -53,8 +53,8 @@ module Rpremote
         opts.on("--board BOARD") { |value| options[:board] = value }
         opts.on("--cache DIR") { |value| options[:cache] = value }
         opts.on("--firmware FILE") { |value| options[:firmware] = value }
-        opts.on("--mrbgems FILE") { |value| options[:mrbgems] = value }
-        opts.on("--no-mrbgems") { options[:mrbgems] = false }
+        opts.on("--lockfile FILE") { |value| options[:mrbgems_lock] = value }
+        opts.on("--no-mrbgems") { options[:mrbgems_lock] = false }
         opts.on("--mount DIR") { |value| options[:mount] = value }
         opts.on("--port PORT") { |value| options[:port] = value }
         opts.on("--baud RATE", Integer) { |value| options[:baud] = value }
@@ -70,19 +70,27 @@ module Rpremote
         cache_dir: options[:cache],
         firmware: options[:firmware]
       )
+      print_target_options(target)
+      print_runtime_options(options)
+    end
+
+    def print_target_options(target)
       output.puts("language=#{target.language}")
       output.puts("language_version=#{target.language_version}")
       output.puts("board=#{target.board}")
       output.puts("cache=#{target.cache_dir}")
       output.puts("firmware=#{target.firmware_path}")
-      output.puts("mrbgems=#{mrbgems_value(options[:mrbgems])}")
+    end
+
+    def print_runtime_options(options)
+      output.puts("mrbgems_lock=#{mrbgems_lock_value(options[:mrbgems_lock])}")
       output.puts("mount=#{options[:mount] || "auto"}")
       output.puts("port=#{options[:port] || "auto"}")
       output.puts("baud=#{options[:baud]}")
       output.puts("timeout=#{options[:timeout]}")
     end
 
-    def mrbgems_value(value)
+    def mrbgems_lock_value(value)
       return "false" if value == false
 
       value || "auto"