captive-release 0.4.3 → 0.4.4

data/lib/captive_release/release_command.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Le geste de release : bumper les fichiers de version, commiter, taguer, pousser, publier.
+  #
+  # Cette unité change quand le geste change, la CLI quand l'ensemble des commandes ou le
+  # parsing des options change.
+  class ReleaseCommand
+    def initialize(terminal:, config:, token_provider:)
+      @terminal       = terminal
+      @config         = config
+      @token_provider = token_provider
+    end
+
+    def run(bump_arg, confirmation:)
+      ReleasePreconditions.new(terminal: @terminal).verifier!
+      courante = @config.current_version
+      @terminal.say "\n#{@terminal.bold("captive-release")}\n"
+      @terminal.say "Current version: #{@terminal.bold(courante)}\n"
+
+      prochaine = VersionChoice.new(terminal: @terminal).call(courante, bump_arg)
+      confirmer!(prochaine) if confirmation
+
+      VersionFilesWriting.new(terminal: @terminal).call(prochaine, @config.version_files)
+      GitRelease.new(terminal: @terminal).call(prochaine, @config.version_files.map(&:path))
+      publication.call(prochaine)
+      @terminal.say "\n🎉  #{@terminal.bold("Version v#{prochaine} released successfully!")}\n"
+    end
+
+    private
+
+    def confirmer!(version)
+      @terminal.say "\nNew version: #{@terminal.bold(version)}"
+      reponse = @terminal.ask("Confirm? [Y/n] ").downcase
+      exit 1 unless reponse == "y" || reponse.empty?
+    end
+
+    def publication
+      ReleasePublication.new(terminal: @terminal, token_provider: @token_provider)
+    end
+  end
+end

data/lib/captive_release/release_preconditions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Ce qui doit être vrai avant qu'une release parte.
+  #
+  # Le commit de version part avec --only, mais un arbre sale reste un mauvais point de
+  # départ : le tag désignerait un état que personne n'a relu.
+  #
+  # Cette unité change quand les conditions changent, ReleaseCommand quand la suite des
+  # étapes change.
+  class ReleasePreconditions
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def verifier!
+      return unless GitCommands.dirty?
+
+      @terminal.say @terminal.error("L'arbre de travail n'est pas propre.")
+      @terminal.say "Commitez ou remisez vos modifications avant de releaser.\n"
+      exit 1
+    end
+  end
+end

data/lib/captive_release/release_publication.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Publie la release sur GitHub, ou dit pourquoi elle ne l'est pas. Le jeton arrive par un
+  # fournisseur et non par une valeur, pour n'être réclamé qu'au moment où il sert.
+  #
+  # Cette unité change quand les règles de publication changent, ReleaseCommand quand les
+  # étapes du geste changent.
+  class ReleasePublication
+    def initialize(terminal:, token_provider:)
+      @terminal       = terminal
+      @token_provider = token_provider
+    end
+
+    def call(version)
+      @terminal.say "\n#{@terminal.bold("Creating GitHub release...")}"
+      jeton = @token_provider.call
+      return sans_jeton unless jeton
+
+      url = GithubRelease.create(version: version, remote_url: GitCommands.remote_url, token: jeton)
+      @terminal.done url
+    end
+
+    private
+
+    def sans_jeton
+      @terminal.say "  #{@terminal.warn("⚠️   GITHUB_TOKEN not set - skipping GitHub release creation.")}"
+    end
+  end
+end

data/lib/captive_release/repo_files.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module CaptiveRelease
+  # Où chercher dans un dépôt, et où ne pas chercher.
+  #
+  # Cette unité change quand la liste des dossiers à ignorer change. Sans elle, chaque
+  # détection réimplémentait l'exclusion, et en oublier une faisait remonter un
+  # node_modules/**/app.json comme s'il était celui du projet.
+  class RepoFiles
+    EXCLUDED_DIRS = %w[node_modules .git vendor tmp coverage dist .next .nuxt Pods].freeze
+
+    def initialize(root)
+      @root = Pathname.new(root).expand_path
+    end
+
+    def path(*segments) = @root.join(*segments)
+
+    def glob(*segments)
+      Dir.glob(path(*segments).to_s).sort.reject { |chemin| excluded?(chemin) }
+    end
+
+    def relative(chemin) = Pathname.new(chemin).relative_path_from(@root).to_s
+
+    private
+
+    def excluded?(chemin)
+      relatif = relative(chemin)
+      EXCLUDED_DIRS.any? do |dossier|
+        relatif.start_with?("#{dossier}/") || relatif.include?("/#{dossier}/")
+      end
+    end
+  end
+end

data/lib/captive_release/shell.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Comment on parle au shell : échapper ce qu'on lui passe, lire ce qu'il rend, et échouer
+  # bruyamment quand la commande échoue.
+  #
+  # Cette unité change quand la façon de lancer une commande change, GitCommands quand les
+  # commandes d'une release changent.
+  module Shell
+    def self.run!(commande)
+      system(commande) || raise("Command failed: #{commande}")
+    end
+
+    def self.capture(commande) = `#{commande}`.strip
+
+    # Rubocop veut Shellwords, mais son échappement diffère du nôtre sur des chemins que git
+    # accepte : la liste blanche dit exactement ce qui passe sans protection.
+    def self.escape(chaine) = chaine.gsub(%r{[^a-zA-Z0-9._\-/]}) { |caractere| "\\#{caractere}" }
+  end
+end

data/lib/captive_release/terminal.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Tout ce qui touche au terminal : la couleur et la saisie.
+  #
+  # Cette unité change quand l'habillage change, les commandes quand leur geste change. Les
+  # deux flux sont injectés, ce qui rend chaque commande testable sans toucher à $stdin.
+  class Terminal
+    def initialize(input: $stdin, output: $stdout)
+      @input  = input
+      @output = output
+    end
+
+    def say(message = "") = @output.puts(message)
+
+    def prompt(message) = @output.print(message)
+
+    def ask(message = "> ")
+      prompt(message)
+      @input.gets&.chomp || ""
+    end
+
+    # Un choix hors menu vaut 0, qui ne correspond à aucune entrée : l'appelant décide quoi
+    # en faire plutôt que de voir une exception.
+    def ask_choice(message = "\n> ") = ask(message).to_i
+
+    # La ligne d'une étape réussie : six unités la réécrivaient, et leurs deux espaces
+    # finissaient par ne plus être les mêmes.
+    def done(etape) = say("  #{ok("✅")}  #{etape}")
+
+    def bold(str)  = "\e[1m#{str}\e[0m"
+    def dim(str)   = "\e[2m#{str}\e[0m"
+    def ok(str)    = "\e[32m#{str}\e[0m"
+    def warn(str)  = "\e[33m#{str}\e[0m"
+    def error(str) = "\e[31m#{str}\e[0m"
+  end
+end

data/lib/captive_release/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CaptiveRelease
-  VERSION = "0.4.3"
+  VERSION = "0.4.4"
 end

data/lib/captive_release/version_choice.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Comment on désigne la prochaine version : un mot-clé de bump, un semver écrit à la main,
+  # ou un menu quand rien n'est donné.
+  #
+  # Cette unité change quand les façons de nommer une version changent, ReleaseCommand quand
+  # le geste de release change.
+  class VersionChoice
+    BUMP_TYPES = %w[patch minor major].freeze
+    SEMVER_RE  = /\A\d+\.\d+\.\d+\z/
+    CUSTOM     = "Custom"
+
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def call(current, bump_arg)
+      bump_arg ? resolve(current, bump_arg) : ask(current)
+    end
+
+    private
+
+    def resolve(current, type)
+      return VersionBumper.bump(current, type) if type.match?(SEMVER_RE) || BUMP_TYPES.include?(type)
+
+      refuse("Invalid bump type: #{type}. Use patch|minor|major|x.y.z")
+    end
+
+    def ask(current)
+      choisi = Menu.new(terminal: @terminal).choose("Choose release type:", candidates_for(current))
+      choisi == CUSTOM ? type_it : choisi
+    end
+
+    # La valeur rendue est la version elle-même, sauf pour Custom qui n'en a pas encore une.
+    def candidates_for(current)
+      candidats = BUMP_TYPES.to_h do |type|
+        version = VersionBumper.bump(current, type)
+        [ "#{type.capitalize}  → #{@terminal.bold(version)}", version ]
+      end
+      candidats.merge("#{CUSTOM}  → ?" => CUSTOM)
+    end
+
+    def type_it
+      version = @terminal.ask("Enter version (x.y.z): ")
+      return version if version.match?(SEMVER_RE)
+
+      refuse("Invalid semver: #{version}")
+    end
+
+    def refuse(message)
+      @terminal.say @terminal.error(message)
+      exit 1
+    end
+  end
+end

data/lib/captive_release/version_detector.rb

@@ -1,84 +1,53 @@
 # frozen_string_literal: true
 
-require "pathname"
-
 module CaptiveRelease
+  # Quels fichiers d'un dépôt portent une version, et sous quel format.
   class VersionDetector
-    EXCLUDED_DIRS = %w[node_modules .git vendor tmp coverage dist .next .nuxt Pods].freeze
+    RUBY_VERSION_PATTERN = /VERSION\s*=\s*["'].+?["']/
+    GRADLE_PATH          = %w[android app build.gradle].freeze
 
     def self.scan(root = ".")
       new(root).scan
     end
 
     def initialize(root)
-      @root = Pathname.new(root).expand_path
+      @files = RepoFiles.new(root)
     end
 
     def scan
-      find_files("package.json", "package_json") +
-        find_files("app.config.js", "app_config_js") +
-        find_ruby_version_files +
-        find_files("VERSION", "plain") +
-        find_android_gradle_files +
-        find_ios_plist_files
-    end
-
-    def expo?
-      find_files("app.config.js", "app_config_js").any? ||
-        find_files("app.json", "plain").any? { |f| File.read(File.join(@root, f.path)).include?('"expo"') }
-    rescue
-      false
-    end
-
-    def capacitor?
-      %w[capacitor.config.ts capacitor.config.json capacitor.config.js].any? do |f|
-        File.exist?(@root.join(f))
-      end
-    rescue
-      false
+      by_name("package.json", "package_json") +
+        by_name("app.config.js", "app_config_js") +
+        by_content(%w[lib ** version.rb], "ruby_version", RUBY_VERSION_PATTERN) +
+        by_name("VERSION", "plain") +
+        android_gradle +
+        by_content(%w[ios ** Info.plist], "ios_plist", /CFBundleShortVersionString/)
     end
 
     private
 
-    def find_android_gradle_files
-      path = @root.join("android", "app", "build.gradle")
-      return [] unless File.exist?(path) && File.read(path).match?(/versionName\s+['"]/)
-
-      [ VersionFile.new("android/app/build.gradle", "android_gradle") ]
-    rescue
-      []
+    def by_name(filename, type)
+      @files.glob("**", filename).map { |chemin| version_file(chemin, type) }
     end
 
-    def find_ios_plist_files
-      Dir.glob(@root.join("ios", "**", "Info.plist").to_s).sort.reject { |p| excluded?(p) }.select do |path|
-        File.read(path).include?("CFBundleShortVersionString")
-      end.map do |path|
-        relative = Pathname.new(path).relative_path_from(@root).to_s
-        VersionFile.new(relative, "ios_plist")
-      end
-    rescue
+    def by_content(segments, type, pattern)
+      @files.glob(*segments)
+            .select { |chemin| File.read(chemin).match?(pattern) }
+            .map { |chemin| version_file(chemin, type) }
+    rescue StandardError
       []
     end
 
-    def find_ruby_version_files
-      Dir.glob(@root.join("lib", "**", "version.rb").to_s).sort.reject { |p| excluded?(p) }.select do |path|
-        File.read(path).match?(/VERSION\s*=\s*["'].+?["']/)
-      end.map do |path|
-        relative = Pathname.new(path).relative_path_from(@root).to_s
-        VersionFile.new(relative, "ruby_version")
-      end
-    end
+    # Le build.gradle est à un chemin fixe : le chercher par glob remonterait ceux des
+    # modules Android embarqués, qui ne portent pas la version de l'app.
+    def android_gradle
+      chemin = @files.path(*GRADLE_PATH)
+      return [] unless File.exist?(chemin) && File.read(chemin).match?(/versionName\s+['"]/)
 
-    def find_files(filename, type)
-      Dir.glob(@root.join("**", filename).to_s).sort.reject { |p| excluded?(p) }.map do |path|
-        relative = Pathname.new(path).relative_path_from(@root).to_s
-        VersionFile.new(relative, type)
-      end
+      [ VersionFile.new(GRADLE_PATH.join("/"), "android_gradle") ]
+    rescue StandardError
+      []
     end
 
-    def excluded?(path)
-      relative = Pathname.new(path).relative_path_from(@root).to_s
-      EXCLUDED_DIRS.any? { |dir| relative.start_with?("#{dir}/") || relative.include?("/#{dir}/") }
-    end
+    def version_file(chemin, type) = VersionFile.new(@files.relative(chemin), type)
   end
 end

data/lib/captive_release/version_file.rb

@@ -1,44 +1,30 @@
 # frozen_string_literal: true
 
-require "json"
-
 module CaptiveRelease
+  # Un fichier qui porte une version : son chemin, son type, et les garde-fous qui disent
+  # au développeur ce qui manque. La façon dont la version s'exprime dans le texte vit dans
+  # VersionFormat, qui ne connaît pas le disque.
   class VersionFile
-    TYPES = %w[package_json plain app_config_js ruby_version android_gradle ios_plist].freeze
+    TYPES = VersionFormat.types
 
     attr_reader :path, :type
 
     def initialize(path, type)
       raise ArgumentError, "Unknown type #{type}. Must be one of: #{TYPES.join(", ")}" unless TYPES.include?(type)
 
-      @path = path
-      @type = type
+      @path   = path
+      @type   = type
+      @format = VersionFormat.for(type)
     end
 
     def read_version
-      raise "File not found: #{path}" unless File.exist?(path)
-
-      case type
-      when "package_json"    then JSON.parse(File.read(path))["version"]
-      when "plain"           then File.read(path).strip
-      when "app_config_js"   then read_app_config_js
-      when "ruby_version"    then read_ruby_version
-      when "android_gradle"  then read_android_gradle
-      when "ios_plist"       then read_ios_plist
-      end
+      @format.read(lire!) ||
+        raise("Cannot read version from #{path} : expected pattern: #{@format.expected}")
     end
 
     def write_version(new_version)
-      raise "File not found: #{path}" unless File.exist?(path)
-
-      case type
-      when "package_json"    then write_package_json(new_version)
-      when "plain"           then File.write(path, "#{new_version}\n")
-      when "app_config_js"   then write_app_config_js(new_version)
-      when "ruby_version"    then write_ruby_version(new_version)
-      when "android_gradle"  then write_android_gradle(new_version)
-      when "ios_plist"       then write_ios_plist(new_version)
-      end
+      contenu = lire!
+      File.write(path, @format.write(contenu, read_version, new_version))
     end
 
     def to_h
@@ -47,61 +33,10 @@ module CaptiveRelease
 
     private
 
-    def write_package_json(new_version)
-      content = File.read(path)
-      old_version = JSON.parse(content)["version"]
-      File.write(path, content.gsub(/"version": "#{Regexp.escape(old_version)}"/, %("version": "#{new_version}")))
-    end
-
-    def read_ruby_version
-      File.read(path).match(/VERSION\s*=\s*["'](.+?)["']/)[1]
-    rescue
-      raise "Cannot read version from #{path} — expected pattern: VERSION = \"x.y.z\""
-    end
-
-    def write_ruby_version(new_version)
-      content     = File.read(path)
-      old_version = read_ruby_version
-      File.write(path, content.gsub(/VERSION\s*=\s*["']#{Regexp.escape(old_version)}["']/) do |match|
-        match.include?('"') ? %(VERSION = "#{new_version}") : %(VERSION = '#{new_version}')
-      end)
-    end
-
-    def read_app_config_js
-      File.read(path).match(/version:\s*['"](.+?)['"]/)[1]
-    rescue
-      raise "Cannot read version from #{path} — expected pattern: version: 'x.y.z'"
-    end
-
-    def write_app_config_js(new_version)
-      content    = File.read(path)
-      old_version = read_app_config_js
-      File.write(path, content.gsub(/version:\s*['"]#{Regexp.escape(old_version)}['"]/, "version: '#{new_version}'"))
-    end
-
-    def read_android_gradle
-      File.read(path).match(/versionName\s+['"](.+?)['"]/)&.[](1) ||
-        raise("Cannot read version from #{path} — expected pattern: versionName 'x.y.z'")
-    end
-
-    def write_android_gradle(new_version)
-      content = File.read(path)
-      old_version = read_android_gradle
-      File.write(path, content.gsub(/versionName\s+['"]#{Regexp.escape(old_version)}['"]/, "versionName '#{new_version}'"))
-    end
-
-    def read_ios_plist
-      File.read(path).match(/<key>CFBundleShortVersionString<\/key>\s*<string>(.+?)<\/string>/)&.[](1) ||
-        raise("Cannot read version from #{path} — expected CFBundleShortVersionString key")
-    end
+    def lire!
+      raise "File not found: #{path}" unless File.exist?(path)
 
-    def write_ios_plist(new_version)
-      content = File.read(path)
-      old_version = read_ios_plist
-      File.write(path, content.gsub(
-        /(<key>CFBundleShortVersionString<\/key>\s*<string>)#{Regexp.escape(old_version)}(<\/string>)/,
-        "\\1#{new_version}\\2"
-      ))
+      File.read(path)
     end
   end
 end

data/lib/captive_release/version_file_bootstrap.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Le dépôt ne porte aucun fichier de version : proposer d'en créer un, et le créer.
+  #
+  # Cette unité change quand ce que reçoit un dépôt nu change, InitCommand quand la façon de
+  # réunir les fichiers change.
+  class VersionFileBootstrap
+    VERSION_INITIALE = "0.1.0"
+
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def call(motif)
+      @terminal.say @terminal.warn(motif)
+      @terminal.say "\nCreate a #{@terminal.bold("VERSION")} file? [y/N] "
+      exit 1 unless @terminal.ask.downcase == "y"
+
+      File.write("VERSION", "#{VERSION_INITIALE}\n")
+      @terminal.done "VERSION créé avec #{@terminal.bold(VERSION_INITIALE)}"
+      [ VersionFile.new("VERSION", "plain") ]
+    end
+  end
+end

data/lib/captive_release/version_file_selection.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Parmi les fichiers de version détectés, lesquels retenir.
+  #
+  # La saisie nomme ce qu'on ne veut **pas** : sur un dépôt qui porte dix fichiers de
+  # version, exclure est plus court que tout énumérer. Cette unité change quand la façon de
+  # choisir change, InitCommand quand ce qu'on fait du choix change.
+  class VersionFileSelection
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def call(found)
+      list(found)
+      found.size == 1 ? seul(found) : exclude(found, demander)
+    end
+
+    private
+
+    def list(found)
+      found.each_with_index do |fichier, rang|
+        @terminal.say "  #{@terminal.dim("[#{rang + 1}]")} #{fichier.path} " \
+                      "#{@terminal.dim("(#{readable_version(fichier)})")}"
+      end
+    end
+
+    def demander
+      @terminal.say "\nAppuyez sur #{@terminal.bold("Entrée")} pour tout sélectionner, " \
+                    "ou entrez les numéros à #{@terminal.bold("exclure")} (ex: 2,3) :"
+      @terminal.ask
+    end
+
+    def seul(found)
+      @terminal.say ""
+      @terminal.done "1 fichier détecté : sélectionné automatiquement."
+      found
+    end
+
+    def exclude(found, saisie)
+      return found if saisie.strip.empty?
+
+      rangs = saisie.split(",").map { |numero| numero.strip.to_i - 1 }
+      found.reject.with_index { |_, rang| rangs.include?(rang) }
+    end
+
+    def readable_version(fichier)
+      fichier.read_version
+    rescue StandardError
+      "?"
+    end
+  end
+end

data/lib/captive_release/version_files_argument.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Lit la valeur de `--files` : une liste de chemins séparés par des virgules, chacun pouvant
+  # nommer son type après un deux-points.
+  #
+  # Cette unité change quand la forme de l'argument change, InitCommand quand ce qu'on fait
+  # des fichiers change.
+  module VersionFilesArgument
+    def self.parse(valeur)
+      valeur.split(",").map(&:strip).map do |entree|
+        chemin, type = entree.split(":")
+        VersionFile.new(chemin, type || type_deduit(chemin))
+      end
+    end
+
+    def self.type_deduit(chemin)
+      File.basename(chemin) == "package.json" ? "package_json" : "plain"
+    end
+  end
+end

data/lib/captive_release/version_files_writing.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Poser la nouvelle version dans chaque fichier qui la porte, et le dire au fur et à mesure :
+  # une release qui s'arrête doit laisser voir jusqu'où elle est allée.
+  #
+  # Cette unité change quand la façon d'écrire change, ReleaseCommand quand la suite des
+  # étapes change.
+  class VersionFilesWriting
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def call(version, fichiers)
+      @terminal.say "\n#{@terminal.bold("Updating version files...")}"
+      fichiers.each do |fichier|
+        fichier.write_version(version)
+        @terminal.done fichier.path
+      end
+    end
+  end
+end