rpremote 0.6.0 → 0.7.0

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/version.rb

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

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);
++  }
+ }

data/sig/rpremote.rbs

@@ -208,7 +208,7 @@ module Rpremote
       ?board: String,
       ?cache_dir: String,
       ?firmware: String?,
-      ?mrbgems: String | false | nil,
+      ?mrbgems_lock: String | false | nil,
       ?output: IO,
       ?error: IO
     ) -> void
@@ -237,6 +237,7 @@ module Rpremote
       attr_reader path: String?
       attr_reader require_name: String?
       attr_reader auto_require: bool
+      attr_reader groups: Array[Symbol]
     end
 
     class Overlay < Data
@@ -247,6 +248,9 @@ module Rpremote
     attr_reader path: String
     attr_reader lock_path: String
 
+    def self.parse_groups: (String value) -> Array[Symbol]
+    def self.normalize_groups: (untyped values) -> Array[Symbol]
+
     def initialize: (
       ?path: String,
       ?lock_path: String?,
@@ -255,15 +259,18 @@ module Rpremote
     ) -> void
     def exist?: () -> bool
     def dependencies: () -> Array[Dependency]
+    def selected_dependencies: (?with: Array[String | Symbol], ?without: Array[String | Symbol]) -> Array[Dependency]
     def vm: () -> Symbol?
     def check: () -> Array[Dependency]
-    def lock: (?update: bool) -> Hash[String, untyped]
+    def lock: (?update: bool, ?with: Array[String | Symbol], ?without: Array[String | Symbol]) -> Hash[String, untyped]
     def read_lock: (?required: bool) -> Hash[String, untyped]?
+    def require_names: () -> Array[String]
+    def prepend_requires: (String source) -> String
+    def locked_vm: () -> Symbol?
     def generate_overlay: (
       base_config: String,
       target: String,
-      directory: String,
-      ?update: bool
+      directory: String
     ) -> Overlay
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rpremote
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - ogom
@@ -31,6 +31,7 @@ files:
 - lib/rpremote/builder.rb
 - lib/rpremote/checksum.rb
 - lib/rpremote/cli.rb
+- lib/rpremote/cli/filesystem_commands.rb
 - lib/rpremote/config.rb
 - lib/rpremote/config_show.rb
 - lib/rpremote/deploy_command.rb
@@ -40,9 +41,17 @@ files:
 - lib/rpremote/flash_command.rb
 - lib/rpremote/flasher.rb
 - lib/rpremote/help.rb
+- lib/rpremote/help/dfu_commands.rb
+- lib/rpremote/help/filesystem_commands.rb
+- lib/rpremote/help/project_commands.rb
+- lib/rpremote/help/remote_commands.rb
+- lib/rpremote/help/root_text.rb
 - lib/rpremote/language.rb
 - lib/rpremote/language_source.rb
 - lib/rpremote/mrbgems.rb
+- lib/rpremote/mrbgems/definition.rb
+- lib/rpremote/mrbgems/file_writer.rb
+- lib/rpremote/mrbgems/lockfile.rb
 - lib/rpremote/mrbgems_command.rb
 - lib/rpremote/nuke_firmware.rb
 - lib/rpremote/picomodem.rb
@@ -61,6 +70,7 @@ files:
 - patches/picoruby-3.4.5-ruby-exception-status.patch
 - patches/picoruby-4.0.3-pwm-sleep-clock.patch
 - patches/picoruby-4.0.3-ruby-exception-status.patch
+- patches/picoruby-4.0.4-pwm-sleep-clock.patch
 - sig/rpremote.rbs
 - tasks/firmware_build.rb
 - tasks/release.rake