captive-release 0.3.2 → 0.4.4

data/lib/captive_release/config_loader.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Trouver la configuration du dépôt, ou la déduire par détection quand elle n'a jamais été
+  # écrite : un dépôt qui n'a qu'un fichier VERSION doit pouvoir releaser sans init préalable.
+  #
+  # Cette unité change quand les sources de configuration changent, les commandes quand leur
+  # geste change.
+  class ConfigLoader
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def call
+      return ConfigFile.load if File.exist?(CONFIG_FILE)
+
+      fichiers = VersionDetector.scan
+      refuser if fichiers.empty?
+
+      Config.new(fichiers)
+    end
+
+    private
+
+    def refuser
+      @terminal.say @terminal.error(
+        "Aucun fichier de version trouvé (package.json, lib/**/version.rb, VERSION).",
+      )
+      @terminal.say "Créez un fichier #{@terminal.bold("VERSION")} " \
+                    "ou lancez #{@terminal.bold("captive-release init")}.\n"
+      exit 1
+    end
+  end
+end

data/lib/captive_release/config_writer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Compose captive-release.json et l'écrit : les fichiers de version retenus, et les
+  # workflows de build si le dépôt en réclame.
+  #
+  # Cette unité change quand la forme de la configuration change, InitCommand quand la façon
+  # de réunir les fichiers change.
+  class ConfigWriter
+    def initialize(terminal:, frameworks: nil)
+      @terminal   = terminal
+      @frameworks = frameworks || FrameworkDetector.new(RepoFiles.new("."))
+    end
+
+    def call(fichiers)
+      refuser_le_vide if fichiers.empty?
+
+      expo      = demander("Expo", EXPO_DEFAULT_WORKFLOW) if @frameworks.expo?
+      capacitor = demander("Capacitor", CAPACITOR_DEFAULT_WORKFLOW) if @frameworks.capacitor?
+
+      ConfigFile.write(fichiers, expo: expo, capacitor: capacitor)
+      annoncer(fichiers, expo, capacitor)
+    end
+
+    private
+
+    def refuser_le_vide
+      @terminal.say @terminal.error("No files selected.")
+      exit 1
+    end
+
+    def annoncer(fichiers, expo, capacitor)
+      @terminal.say "\n#{@terminal.ok("✅  captive-release.json written with " \
+                                      "#{fichiers.size} version file(s).")}"
+      @terminal.say "   #{@terminal.dim("Expo build workflow: #{expo.build_workflow}")}" if expo
+      return unless capacitor
+
+      @terminal.say "   #{@terminal.dim("Capacitor build workflow: #{capacitor.build_workflow}")}"
+    end
+
+    def demander(framework, workflow_par_defaut)
+      BuildConfigPrompt.new(terminal: @terminal).call(framework, workflow_par_defaut)
+    end
+  end
+end

data/lib/captive_release/framework_detector.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Quel framework mobile ce dépôt utilise, donc quel workflow de build proposer.
+  #
+  # Cette unité change quand un framework s'ajoute, VersionDetector quand un format de
+  # fichier de version s'ajoute : deux raisons de changer différentes.
+  class FrameworkDetector
+    CAPACITOR_CONFIGS = %w[capacitor.config.ts capacitor.config.json capacitor.config.js].freeze
+
+    def initialize(files)
+      @files = files
+    end
+
+    # Les rescue existent pour qu'une arborescence hostile ne fasse pas échouer une release :
+    # la détection est une commodité, jamais une raison de s'arrêter.
+    def expo?
+      @files.glob("**", "app.config.js").any? ||
+        @files.glob("**", "app.json").any? { |chemin| File.read(chemin).include?('"expo"') }
+    rescue StandardError
+      false
+    end
+
+    def capacitor?
+      CAPACITOR_CONFIGS.any? { |nom| File.exist?(@files.path(nom)) }
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/captive_release/git_commands.rb

@@ -1,47 +1,38 @@
 # frozen_string_literal: true
 
 module CaptiveRelease
+  # Les commandes git d'une release. La façon de les lancer vit dans Shell.
   class GitCommands
     def self.dirty?
-      lines = `git diff --name-only && git diff --cached --name-only`.lines.map(&:strip).reject(&:empty?)
-      !lines.empty?
+      sortie = Shell.capture("git diff --name-only && git diff --cached --name-only")
+      !sortie.lines.map(&:strip).reject(&:empty?).empty?
     end
 
-    def self.last_tag
-      tag = `git describe --tags --abbrev=0 2>/dev/null`.strip
-      tag.empty? ? nil : tag
-    end
-
-    def self.commits_since(tag)
-      range = tag ? "#{tag}..HEAD" : "HEAD"
-      `git log #{range} --pretty=format:"- %s (%h)" --no-merges`.strip
-    end
+    def self.remote_url = Shell.capture("git remote get-url origin 2>/dev/null")
 
-    def self.remote_url
-      `git remote get-url origin 2>/dev/null`.strip
+    def self.current_branch
+      branche = Shell.capture("git rev-parse --abbrev-ref HEAD 2>/dev/null")
+      branche.empty? ? "main" : branche
     end
 
+    # --only borne le commit aux fichiers de version : sans lui, ce qui traînait dans l'index
+    # part dans la release, taggé et poussé, sans que rien ne le signale.
     def self.add_and_commit(version, paths)
-      run! "git add #{paths.map { |p| shellescape(p) }.join(" ")}"
-      run! %(git commit -m "🔖 Set version v#{version}")
+      echappes = paths.map { |chemin| Shell.escape(chemin) }.join(" ")
+      Shell.run! "git add #{echappes}"
+      Shell.run! %(git commit --only #{echappes} -m "🔖 Set version v#{version}")
     end
 
     def self.tag(version)
-      run! "git tag v#{version}"
+      Shell.run! "git tag v#{version}"
     end
 
+    # Le tag part avant HEAD : au moment où le webhook du push sur main arrive, le tag existe
+    # déjà. Dans l'autre sens, demander « ce sha porte-t-il un tag v* ? » répond non presque
+    # toujours, et la même release se construit deux fois.
     def self.push(version)
-      run! "git push origin HEAD"
-      run! "git push origin v#{version}"
-    end
-
-    def self.run!(cmd)
-      system(cmd) || raise("Git command failed: #{cmd}")
-    end
-
-    def self.shellescape(str)
-      str.gsub(/[^a-zA-Z0-9._\-\/]/) { |c| "\\#{c}" }
+      Shell.run! "git push origin v#{version}"
+      Shell.run! "git push origin HEAD"
     end
-    private_class_method :shellescape
   end
 end

data/lib/captive_release/git_release.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # La séquence git d'une release : commiter les fichiers de version, taguer, pousser.
+  #
+  # Cette unité change quand la séquence change, ReleaseCommand quand ce qui l'entoure
+  # change. Chaque étape est annoncée au fur et à mesure : une release qui s'arrête doit
+  # laisser voir jusqu'où elle est allée.
+  class GitRelease
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def call(version, paths)
+      @terminal.say "\n#{@terminal.bold("Running git commands...")}"
+      GitCommands.add_and_commit(version, paths)
+      @terminal.done %(git commit "🔖 Set version v#{version}")
+      GitCommands.tag(version)
+      @terminal.done "git tag v#{version}"
+      GitCommands.push(version)
+      @terminal.done "git push + tag"
+    end
+  end
+end

data/lib/captive_release/github_api.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require_relative "github_http"
+require_relative "github_repo"
+
+module CaptiveRelease
+  # L'API GitHub d'un dépôt : à quelle adresse poster, et ce qui compte comme un échec. Les
+  # commandes lui parlent par délégation plutôt que d'en hériter le transport, ce qui leur
+  # laisse la seule composition de leur payload.
+  #
+  # Cette unité change quand l'adressage ou la politique d'erreur changent, GithubHttp quand
+  # le transport change.
+  class GithubApi
+    HOTE = "https://api.github.com"
+
+    attr_reader :depot
+
+    def initialize(remote_url:, token:, http: nil)
+      @depot = GithubRepo.from_remote(remote_url)
+      @http  = http || GithubHttp.new(token: token)
+    end
+
+    def post(chemin, corps, attendu:)
+      reponse = @http.post(URI("#{HOTE}/#{depot.path(chemin)}"), JSON.generate(corps))
+      refuser(reponse) unless reponse.code == attendu
+
+      reponse.body.to_s.empty? ? nil : JSON.parse(reponse.body)
+    end
+
+    private
+
+    # Le corps d'une erreur GitHub est du JSON qui nomme la cause, sauf quand il n'en est pas :
+    # un 500 rend parfois du texte brut, qu'il vaut mieux montrer que d'avaler.
+    def refuser(reponse)
+      data = begin
+        JSON.parse(reponse.body)
+      rescue StandardError
+        {}
+      end
+      raise "GitHub API error (#{reponse.code}): #{data["message"] || reponse.body}"
+    end
+  end
+end

data/lib/captive_release/github_dispatch.rb

@@ -1,40 +1,25 @@
 # frozen_string_literal: true
 
-require "json"
-require "uri"
-require_relative "github_http"
+require_relative "github_api"
 
 module CaptiveRelease
+  # Déclenche un workflow GitHub Actions. Elle compose ce qu'elle demande ; l'API, son
+  # authentification et ses échecs vivent dans GithubApi.
   class GithubDispatch
-    GITHUB_API = "https://api.github.com"
-
-    include GithubHttp
-
-    def self.dispatch(workflow_file:, ref:, inputs:, remote_url:, token:)
-      new(workflow_file: workflow_file, ref: ref, inputs: inputs, remote_url: remote_url, token: token).dispatch
+    def self.dispatch(workflow_file:, ref:, inputs:, remote_url:, token:, api: nil)
+      api ||= GithubApi.new(remote_url: remote_url, token: token)
+      new(api).dispatch(workflow_file: workflow_file, ref: ref, inputs: inputs)
     end
 
-    def initialize(workflow_file:, ref:, inputs:, remote_url:, token:)
-      @workflow_file = workflow_file
-      @ref           = ref
-      @inputs        = inputs
-      @remote_url    = remote_url
-      @token         = token
+    def initialize(api)
+      @api = api
     end
 
-    def dispatch
-      owner, repo = parse_remote(@remote_url)
-      uri = URI("#{GITHUB_API}/repos/#{owner}/#{repo}/actions/workflows/#{@workflow_file}/dispatches")
-
-      payload = JSON.generate({ "ref" => @ref, "inputs" => @inputs })
-      response = github_post(uri, @token, payload)
-
-      unless response.code == "204"
-        data = JSON.parse(response.body) rescue {}
-        raise "GitHub API error (#{response.code}): #{data["message"] || response.body}"
-      end
+    def dispatch(workflow_file:, ref:, inputs:)
+      @api.post("actions/workflows/#{workflow_file}/dispatches",
+                { "ref" => ref, "inputs" => inputs }, attendu: "204")
 
-      "https://github.com/#{owner}/#{repo}/actions"
+      @api.depot.actions_url
     end
   end
 end

data/lib/captive_release/github_http.rb

@@ -4,39 +4,48 @@ require "net/http"
 require "uri"
 
 module CaptiveRelease
-  module GithubHttp
-    MAX_REDIRECTS = 3
-
-    def github_post(uri, token, body)
-      MAX_REDIRECTS.times do
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-
-        request = Net::HTTP::Post.new(uri.path)
-        request["Authorization"]       = "token #{token}"
-        request["Content-Type"]        = "application/json"
-        request["Accept"]              = "application/vnd.github+json"
-        request["X-GitHub-Api-Version"] = "2022-11-28"
-        request.body = body
-
-        response = http.request(request)
-
-        return response unless %w[301 302 307 308].include?(response.code)
+  # Le transport : poster sur l'API GitHub, authentifié, en suivant les redirections qu'elle
+  # sert quand un dépôt a été renommé. Elle ne sait rien de ce qui est posté ni de ce qui
+  # compte comme un échec, qui appartiennent à GithubApi.
+  class GithubHttp
+    MAX_REDIRECTIONS = 3
+    REDIRECTIONS     = %w[301 302 307 308].freeze
+    EN_TETES         = {
+      "Content-Type"         => "application/json",
+      "Accept"               => "application/vnd.github+json",
+      "X-GitHub-Api-Version" => "2022-11-28",
+    }.freeze
+
+    def initialize(token:)
+      @token = token
+    end
 
-        location = response["location"] || response["Location"]
-        raise "GitHub redirect without Location header" unless location
+    def post(uri, corps)
+      MAX_REDIRECTIONS.times do
+        reponse = envoyer(uri, corps)
+        return reponse unless REDIRECTIONS.include?(reponse.code)
 
-        uri = URI(location)
+        uri = URI(ailleurs!(reponse))
       end
 
       raise "Too many redirects from GitHub API"
     end
 
-    def parse_remote(url)
-      match = url.match(%r{github\.com[:/]([^/]+)/(.+?)(?:\.git)?\z})
-      raise "Cannot parse GitHub repo from remote URL: #{url}" unless match
+    private
+
+    def envoyer(uri, corps)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      requete = Net::HTTP::Post.new(uri.path)
+      EN_TETES.each { |nom, valeur| requete[nom] = valeur }
+      requete["Authorization"] = "token #{@token}"
+      requete.body = corps
+      http.request(requete)
+    end
 
-      [ match[1], match[2] ]
+    def ailleurs!(reponse)
+      reponse["location"] || reponse["Location"] ||
+        raise("GitHub redirect without Location header")
     end
   end
 end

data/lib/captive_release/github_release.rb

@@ -1,44 +1,28 @@
 # frozen_string_literal: true
 
-require "json"
-require "uri"
-require_relative "github_http"
+require_relative "github_api"
 
 module CaptiveRelease
+  # Crée la release GitHub d'une version. Elle compose ce qu'elle demande ; l'API, son
+  # authentification et ses échecs vivent dans GithubApi.
   class GithubRelease
-    GITHUB_API = "https://api.github.com"
-
-    include GithubHttp
-
-    def self.create(version:, body:, remote_url:, token:)
-      new(version: version, body: body, remote_url: remote_url, token: token).create
+    def self.create(version:, remote_url:, token:, api: nil)
+      api ||= GithubApi.new(remote_url: remote_url, token: token)
+      new(api).create(version)
     end
 
-    def initialize(version:, body:, remote_url:, token:)
-      @version    = version
-      @body       = body
-      @remote_url = remote_url
-      @token      = token
+    def initialize(api)
+      @api = api
     end
 
-    def create
-      owner, repo = parse_remote(@remote_url)
-      uri = URI("#{GITHUB_API}/repos/#{owner}/#{repo}/releases")
-
-      payload = JSON.generate({
-        "tag_name"   => "v#{@version}",
-        "name"       => "v#{@version}",
-        "body"       => @body.empty? ? "_No commits since last release._" : @body,
-        "draft"      => false,
-        "prerelease" => false,
-      })
-
-      response = github_post(uri, @token, payload)
-      data     = JSON.parse(response.body)
-
-      raise "GitHub API error (#{response.code}): #{data["message"]}" unless response.code == "201"
-
-      data["html_url"]
+    # GitHub compose le corps : commits catégorisés, contributeurs, lien Full Changelog. Le
+    # composer ici obligeait à lister les commits, et sans tag précédent cette liste était
+    # l'historique entier du dépôt.
+    def create(version)
+      @api.post("releases",
+                { "tag_name" => "v#{version}", "name" => "v#{version}",
+                  "generate_release_notes" => true, "draft" => false, "prerelease" => false, },
+                attendu: "201")["html_url"]
     end
   end
 end

data/lib/captive_release/github_repo.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Quel dépôt GitHub un remote git désigne. Les deux formes de remote, SSH et HTTPS, mènent
+  # au même couple propriétaire et dépôt.
+  #
+  # Cette unité change quand les formes de remote changent, GithubApi quand l'API change.
+  class GithubRepo
+    REMOTE = %r{github\.com[:/]([^/]+)/(.+?)(?:\.git)?\z}
+
+    attr_reader :owner, :repo
+
+    def self.from_remote(url)
+      match = url.match(REMOTE)
+      raise "Cannot parse GitHub repo from remote URL: #{url}" unless match
+
+      new(match[1], match[2])
+    end
+
+    def initialize(owner, repo)
+      @owner = owner
+      @repo  = repo
+    end
+
+    def path(suite) = "repos/#{owner}/#{repo}/#{suite}"
+
+    def actions_url = "https://github.com/#{owner}/#{repo}/actions"
+  end
+end

data/lib/captive_release/github_token.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # D'où vient le jeton GitHub : la variable d'environnement d'abord, la CLI `gh` ensuite.
+  #
+  # Cette unité change quand les sources d'authentification changent. La lecture reste
+  # paresseuse chez les appelants, qui la reçoivent en fournisseur : interroger `gh` coûte un
+  # appel système, inutile tant qu'on n'a pas vérifié le reste.
+  module GithubToken
+    def self.call
+      depuis_env = ENV["GITHUB_TOKEN"].to_s
+      return depuis_env unless depuis_env.empty?
+
+      depuis_gh = `gh auth token 2>/dev/null`.strip
+      depuis_gh.empty? ? nil : depuis_gh
+    end
+  end
+end

data/lib/captive_release/help.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Ce que la CLI documente d'elle-même. Cette unité change quand la documentation de
+  # l'interface change, la CLI quand son aiguillage change.
+  class Help
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def show
+      @terminal.say <<~HELP
+
+        #{@terminal.bold("captive-release")} : Semver release tool
+
+        #{@terminal.bold("Usage:")}
+          captive-release init [--files path[:type],...]
+          captive-release new [patch|minor|major|x.y.z] [--yes]
+          captive-release version
+
+        #{@terminal.bold("Commands:")}
+          init    Detect version files and write captive-release.json
+          new     Bump version, commit, tag, push, create GitHub release
+                  Refuse de tourner sur un arbre de travail sale.
+                  Demande toujours confirmation, sauf avec --yes.
+          build   Dispatch an EAS build workflow (staging/production) via GitHub Actions
+
+        #{@terminal.bold("Options for init:")}
+          --files   Non-interactive: comma-separated list of files with optional type
+                    Type is auto-detected (package_json or plain) when omitted
+                    Example: --files=package.json,ios/VERSION:plain
+
+        #{@terminal.bold("Examples:")}
+          captive-release init
+          captive-release init --files=package.json,apps/mobile/package.json
+          captive-release new
+          captive-release new patch
+          captive-release new 2.0.0
+          captive-release new patch --yes
+          captive-release build
+          captive-release build --profile staging
+          captive-release build --profile production
+
+        #{@terminal.bold("GitHub release:")}
+          Set GITHUB_TOKEN env var or authenticate with `gh auth login`
+
+      HELP
+    end
+  end
+end

data/lib/captive_release/init_command.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Détecte les fichiers de version d'un dépôt et écrit captive-release.json.
+  #
+  # Cette unité change quand la façon de constituer la configuration change, la CLI quand
+  # l'ensemble des commandes ou le parsing des options change.
+  class InitCommand
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def run(files_arg)
+      files_arg ? sans_interaction(files_arg) : avec_interaction
+    end
+
+    private
+
+    def sans_interaction(files_arg)
+      writer.call(VersionFilesArgument.parse(files_arg))
+    end
+
+    def avec_interaction
+      @terminal.say "\n#{@terminal.bold("captive-release init")}\n"
+      @terminal.say "Scanning for version files...\n"
+
+      trouves = VersionDetector.scan
+      return creer_un_version("No version files found (package.json, VERSION).") if trouves.empty?
+
+      retenus = selection.call(trouves)
+      return creer_un_version("Aucun fichier sélectionné.") if retenus.empty?
+
+      writer.call(retenus)
+    end
+
+    def creer_un_version(motif)
+      writer.call(VersionFileBootstrap.new(terminal: @terminal).call(motif))
+    end
+
+    def writer = @writer ||= ConfigWriter.new(terminal: @terminal)
+
+    def selection = @selection ||= VersionFileSelection.new(terminal: @terminal)
+  end
+end

data/lib/captive_release/menu.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Une liste numérotée, un choix, et le refus de ce qui n'est pas dans la liste.
+  #
+  # Un rang négatif est refusé comme un rang trop grand : sans cette garde, une saisie non
+  # numérique vaut 0, donc l'indice -1, et Ruby rendait silencieusement la dernière entrée.
+  class Menu
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    # entries : un Hash {libellé affiché => valeur rendue}, dans l'ordre d'affichage.
+    def choose(title, entries)
+      @terminal.say "#{title}\n"
+      entries.each_key.with_index do |libelle, rang|
+        @terminal.say "  #{@terminal.dim("#{rang + 1})")} #{libelle}"
+      end
+
+      rang = @terminal.ask_choice - 1
+      refuse if rang.negative? || rang >= entries.size
+
+      entries.values[rang]
+    end
+
+    private
+
+    def refuse
+      @terminal.say @terminal.error("Invalid choice.")
+      exit 1
+    end
+  end
+end

data/lib/captive_release/options.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # La ligne de commande et ce qu'on en lit : la commande, les drapeaux, les options à
+  # valeur, sous leurs deux formes « --opt valeur » et « --opt=valeur ».
+  #
+  # Cette unité change quand la syntaxe des options change, la CLI quand l'ensemble des
+  # commandes change. Elle consomme ce qu'elle lit, pour qu'un argument positionnel lu
+  # ensuite ne récupère pas une option.
+  class Options
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def next_argument = @argv.shift
+
+    def flag?(name) = !@argv.delete(name).nil?
+
+    def value(name)
+      rang = @argv.index { |argument| argument.start_with?("#{name}=") || argument == name }
+      return nil if rang.nil?
+
+      argument = @argv.delete_at(rang)
+      argument.include?("=") ? argument.split("=", 2).last : @argv.delete_at(rang)
+    end
+  end
+end