captive-release 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87ceb43e08f3eacbf2ee69552a5b8011fe25798929ea0d476f9af8e882b48f2f
-  data.tar.gz: 27ced4d77d33181bea207d245704410d18e2c599e60b5d6df6b56f28fef992a1
+  metadata.gz: 03403604d3d533136b2f1901345f1a1192d698ec43ac8e54589e966e33d8a328
+  data.tar.gz: f822d4f46347d765a3c1beb5415b5e19d223f35f55a94592555d38fe4633ac4c
 SHA512:
-  metadata.gz: 5eefc83ed0eddfbb557763b3c4cdc2a9a2206d990b155a0d56c869ce4f4c65aae19e6140ac415580a4b1fd4c1990f93f62cd857f1df7b6995aec83ddd7d85e4e
-  data.tar.gz: 445fa1fffd733617434c9e4e7d6f535b3460ad446606e031b449afd5eaaddd67e6f603fdcada943335d6219739eae7110c9c1925201c694aa64db25fcd53b01f
+  metadata.gz: c7db3c9d1f2289de5eaf34d7057dd8abdc2e1d39c3d52eedcca661f3f8d494810b36e130320137bb9c58993e33ecef257407ee6cfd8ff5caceb036975c1a4a83
+  data.tar.gz: d4f457a4cc32c465ca677def528172deb6d0efb2e48bc95ae5911c9ca742a34c0d1a79abfa2c31551383c04531ec16569745e84e15786e97cd462fe4bb5b48ea

data/lib/captive_release/build_command.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Déclenche le workflow de build mobile (EAS ou Capacitor) sur la branche courante.
+  #
+  # Cette unité change quand le geste de build change, la CLI quand l'ensemble des commandes
+  # ou le parsing des options change. Le jeton arrive par un fournisseur et non par une
+  # valeur, pour n'être réclamé qu'au moment où il sert vraiment.
+  class BuildCommand
+    def initialize(terminal:, config:, token_provider:)
+      @terminal       = terminal
+      @config         = config
+      @token_provider = token_provider
+    end
+
+    def run(profile_arg)
+      refuser_sans_configuration
+      @terminal.say "\n#{@terminal.bold("captive-release build")}\n"
+      profil = profile_arg || demander_le_profil
+      BuildDispatchRun.new(terminal: @terminal)
+                      .call(profil: profil, workflow: workflow_file, jeton: jeton!)
+    end
+
+    private
+
+    def refuser_sans_configuration
+      return if @config.expo? || @config.capacitor?
+
+      @terminal.say @terminal.error("Aucune configuration de build dans #{CONFIG_FILE}.")
+      @terminal.say "Lancez #{@terminal.bold("captive-release init")} pour configurer le workflow de build.\n\n"
+      exit 1
+    end
+
+    def jeton!
+      jeton = @token_provider.call
+      return jeton if jeton
+
+      @terminal.say @terminal.error("GITHUB_TOKEN or `gh auth login` required to dispatch build workflows.")
+      exit 1
+    end
+
+    def demander_le_profil
+      Menu.new(terminal: @terminal).choose("Choose profile:",
+                                           { "staging" => "staging",
+                                             "production" => "production", })
+    end
+
+    def workflow_file
+      @config.expo? ? @config.expo.build_workflow : @config.capacitor.build_workflow
+    end
+  end
+end

data/lib/captive_release/build_config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  EXPO_DEFAULT_WORKFLOW      = "build.yml"
+  CAPACITOR_DEFAULT_WORKFLOW = "capacitor-build.yml"
+
+  # Le workflow de build à déclencher. Expo et Capacitor ne se distinguaient que par le nom
+  # du workflow par défaut : deux structures identiques pour une seule notion.
+  BuildConfig = Struct.new(:build_workflow, keyword_init: true) do
+    def self.from_hash(hash, default_workflow)
+      return nil unless hash
+
+      new(build_workflow: hash["build_workflow"] || default_workflow)
+    end
+
+    def to_h
+      { "build_workflow" => build_workflow }
+    end
+  end
+end

data/lib/captive_release/build_config_prompt.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Demande au développeur s'il veut dispatcher le build d'un framework détecté, et sous quel
+  # workflow. Expo et Capacitor posent la même question à deux valeurs près.
+  #
+  # Cette unité change quand la question change, ConfigWriter quand la forme du fichier change.
+  class BuildConfigPrompt
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def call(framework, workflow_par_defaut)
+      @terminal.say "\n#{@terminal.bold("#{framework} project detected.")} " \
+                    "Configure build dispatch?\n"
+      @terminal.say "  #{@terminal.dim("1)")} Yes"
+      @terminal.say "  #{@terminal.dim("2)")} No"
+      return nil unless @terminal.ask_choice == 1
+
+      BuildConfig.new(build_workflow: workflow(workflow_par_defaut))
+    end
+
+    private
+
+    def workflow(workflow_par_defaut)
+      @terminal.say "\nWorkflow file name #{@terminal.dim("(default: #{workflow_par_defaut})")}:"
+      saisie = @terminal.ask
+      saisie.empty? ? workflow_par_defaut : saisie
+    end
+  end
+end

data/lib/captive_release/build_dispatch_run.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Déclenche le workflow de build sur la branche courante, après avoir dit ce qu'il va faire :
+  # le profil, le workflow et la branche sont les trois choses qu'on vérifie avant de lancer.
+  #
+  # Cette unité change quand ce qu'on déclenche change, BuildCommand quand la façon de
+  # constituer la demande change.
+  class BuildDispatchRun
+    def initialize(terminal:)
+      @terminal = terminal
+    end
+
+    def call(profil:, workflow:, jeton:)
+      branche = GitCommands.current_branch
+      annoncer(profil, workflow, branche)
+
+      url = GithubDispatch.dispatch(workflow_file: workflow, ref: branche,
+                                    inputs: { "profile" => profil },
+                                    remote_url: GitCommands.remote_url, token: jeton)
+
+      @terminal.done "Build dispatched!"
+      @terminal.say "     #{url}\n"
+    end
+
+    private
+
+    def annoncer(profil, workflow, branche)
+      @terminal.say "Profile:  #{@terminal.bold(profil)}"
+      @terminal.say "Workflow: #{@terminal.bold(workflow)}"
+      @terminal.say "Branch:   #{@terminal.bold(branche)}"
+      @terminal.say "\nDispatching...\n"
+    end
+  end
+end

data/lib/captive_release/changes_since.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  # Le lien vers les commits inclus depuis la dernière version taguée. Absent tant que ce
+  # tag n'existe pas ou que le remote ne mène pas à GitHub — la release continue sans lui.
+  #
+  # Cette unité change quand la façon de comparer deux versions change, ReleaseCommand quand
+  # le moment où on l'affiche change.
+  class ChangesSince
+    def self.url(version)
+      return nil unless GitCommands.tag?("v#{version}")
+
+      GithubRepo.from_remote(GitCommands.remote_url).compare_url("v#{version}", GitCommands.current_branch)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/captive_release/cli.rb

@@ -1,419 +1,64 @@
 # frozen_string_literal: true
 
 module CaptiveRelease
+  # Aiguille vers la commande demandée et lui câble ses collaborateurs. Elle ne porte aucun
+  # geste : chaque commande vit dans sa classe.
   class CLI
-    BUMP_TYPES = %w[patch minor major].freeze
-    SEMVER_RE = /\A\d+\.\d+\.\d+\z/
-
     def self.run(argv = ARGV)
       new(argv.dup).run
     end
 
     def initialize(argv)
-      @argv = argv
+      @options = Options.new(argv)
     end
 
     def run
-      command = @argv.shift
+      command = @options.next_argument
 
       case command
-      when "init"             then run_init
-      when "new"              then run_release
-      when "build"            then run_build
-      when "version", "--version", "-v" then puts "captive-release #{VERSION}"
-      when "help", "--help", "-h", nil  then print_help
-      else
-        puts error("Unknown command: #{command}")
-        print_help
-        exit 1
+      when "init"                       then run_init
+      when "new"                        then run_release
+      when "build"                      then run_build
+      when "version", "--version", "-v" then terminal.say "captive-release #{VERSION}"
+      when "help", "--help", "-h", nil  then aide.show
+      else refuser(command)
       end
     end
 
     private
 
-    # ── init ────────────────────────────────────────────────────────────────
-
     def run_init
-      files_arg = extract_option("--files")
-
-      if files_arg
-        run_init_non_interactive(files_arg)
-      else
-        run_init_interactive
-      end
-    end
-
-    def run_init_interactive
-      puts "\n#{bold("captive-release init")}\n\n"
-      puts "Scanning for version files...\n\n"
-
-      found = VersionDetector.scan
-
-      if found.empty?
-        puts warn("No version files found (package.json, VERSION).")
-        create_version_file_if_confirmed
-        return
-      end
-
-      found.each_with_index do |f, i|
-        version = safe_read(f)
-        puts "  #{dim("[#{i + 1}]")} #{f.path} #{dim("(#{version})")}"
-      end
-
-      selected = if found.size == 1
-        puts "\n#{ok("✅")}  1 fichier détecté — sélectionné automatiquement."
-        found
-      else
-        puts "\nAppuyez sur #{bold("Entrée")} pour tout sélectionner, ou entrez les numéros à #{bold("exclure")} (ex: 2,3) :"
-        print "> "
-        input = $stdin.gets&.chomp || ""
-        if input.strip.empty?
-          found
-        else
-          excluded = input.split(",").map { |n| n.strip.to_i - 1 }
-          found.reject.with_index { |_, i| excluded.include?(i) }
-        end
-      end
-
-      if selected.empty?
-        puts warn("Aucun fichier sélectionné.")
-        create_version_file_if_confirmed
-        return
-      end
-
-      write_config(selected)
-    end
-
-    def create_version_file_if_confirmed
-      puts "\nCreate a #{bold("VERSION")} file? [y/N] "
-      print "> "
-      answer = $stdin.gets&.chomp&.downcase || ""
-      exit 1 unless answer == "y"
-
-      initial = "0.1.0"
-      File.write("VERSION", "#{initial}\n")
-      puts "  #{ok("✅")}  VERSION créé avec #{bold(initial)}"
-
-      file = VersionFile.new("VERSION", "plain")
-      write_config([ file ])
-    end
-
-    def run_init_non_interactive(files_arg)
-      entries = files_arg.split(",").map(&:strip)
-      selected = entries.map do |entry|
-        path, type = entry.split(":")
-        type ||= detect_type(path)
-        VersionFile.new(path, type)
-      end
-      write_config(selected)
-    end
-
-    def write_config(files, expo: nil, capacitor: nil)
-      if files.empty?
-        puts error("No files selected.")
-        exit 1
-      end
-
-      detector = VersionDetector.new(".")
-      expo      ||= ask_expo_config      if detector.expo?
-      capacitor ||= ask_capacitor_config if detector.capacitor?
-
-      Config.write(files, expo: expo, capacitor: capacitor)
-      puts "\n#{ok("✅  captive-release.json written with #{files.size} version file(s).")}"
-      puts "   #{dim("Expo build workflow: #{expo.build_workflow}")}"           if expo
-      puts "   #{dim("Capacitor build workflow: #{capacitor.build_workflow}")}" if capacitor
-      puts
-    end
-
-    def ask_expo_config
-      puts "\n#{bold("Expo project detected.")} Configure EAS build dispatch?\n"
-      puts "  #{dim("1)")} Yes"
-      puts "  #{dim("2)")} No"
-      print "\n> "
-      choice = $stdin.gets&.chomp&.to_i || 0
-      return nil unless choice == 1
-
-      puts "\nWorkflow file name #{dim("(default: build.yml)")}:"
-      print "> "
-      workflow = $stdin.gets&.chomp || ""
-      workflow = "build.yml" if workflow.empty?
-
-      ExpoConfig.new(build_workflow: workflow)
-    end
-
-    def ask_capacitor_config
-      puts "\n#{bold("Capacitor project detected.")} Configure build dispatch?\n"
-      puts "  #{dim("1)")} Yes"
-      puts "  #{dim("2)")} No"
-      print "\n> "
-      choice = $stdin.gets&.chomp&.to_i || 0
-      return nil unless choice == 1
-
-      puts "\nWorkflow file name #{dim("(default: capacitor-build.yml)")}:"
-      print "> "
-      workflow = $stdin.gets&.chomp || ""
-      workflow = "capacitor-build.yml" if workflow.empty?
-
-      CapacitorConfig.new(build_workflow: workflow)
-    end
-
-    def parse_selection(input, found)
-      input.split(",").map { |n| found[n.strip.to_i - 1] }.compact
+      InitCommand.new(terminal: terminal).run(@options.value("--files"))
     end
 
-    def detect_type(path)
-      File.basename(path) == "package.json" ? "package_json" : "plain"
-    end
-
-    # ── release ─────────────────────────────────────────────────────────────
-
+    # La confirmation est demandée même quand la version est donnée en argument : sans elle,
+    # une faute de frappe commitait, taguait et poussait sans aucun point d'arrêt. --yes reste
+    # le chemin explicite pour l'automatisation.
     def run_release
-      bump_arg = @argv.shift
-      config   = load_config
-
-      current  = config.current_version
-      puts "\n#{bold("captive-release")}\n\n"
-      puts "Current version: #{bold(current)}\n\n"
-
-      next_version =
-        if bump_arg
-          resolve_version(current, bump_arg)
-        else
-          ask_version(current)
-        end
-
-      confirm!(next_version) unless bump_arg
-
-      puts "\n#{bold("Updating version files...")}"
-      config.version_files.each do |f|
-        f.write_version(next_version)
-        puts "  #{ok("✅")}  #{f.path}"
-      end
-
-      puts "\n#{bold("Running git commands...")}"
-      last_tag = GitCommands.last_tag
-      GitCommands.add_and_commit(next_version, config.version_files.map(&:path))
-      puts "  #{ok("✅")}  git commit \"🔖 Set version v#{next_version}\""
-      GitCommands.tag(next_version)
-      puts "  #{ok("✅")}  git tag v#{next_version}"
-      GitCommands.push(next_version)
-      puts "  #{ok("✅")}  git push + tag"
-
-      puts "\n#{bold("Creating GitHub release...")}"
-      token = github_token
-      if token
-        commits = GitCommands.commits_since(last_tag)
-        url = GithubRelease.create(
-          version:    next_version,
-          body:       commits,
-          remote_url: GitCommands.remote_url,
-          token:      token
-        )
-        puts "  #{ok("✅")}  #{url}"
-      else
-        puts "  #{warn("⚠️   GITHUB_TOKEN not set — skipping GitHub release creation.")}"
-      end
-
-      puts "\n🎉  #{bold("Version v#{next_version} released successfully!")}\n\n"
-    end
+      sans_confirmation = @options.flag?("--yes")
 
-    def resolve_version(current, type)
-      unless type.match?(SEMVER_RE) || BUMP_TYPES.include?(type)
-        puts error("Invalid bump type: #{type}. Use patch|minor|major|x.y.z")
-        exit 1
-      end
-      VersionBumper.bump(current, type)
+      release_command.run(@options.next_argument, confirmation: !sans_confirmation)
     end
 
-    def ask_version(current)
-      candidates = {
-        "Patch"  => VersionBumper.bump(current, "patch"),
-        "Minor"  => VersionBumper.bump(current, "minor"),
-        "Major"  => VersionBumper.bump(current, "major"),
-        "Custom" => nil,
-      }
-
-      puts "Choose release type:\n"
-      candidates.each_with_index do |(label, version), i|
-        preview = version ? "→ #{bold(version)}" : "→ ?"
-        puts "  #{dim("#{i + 1})")} #{label}  #{preview}"
-      end
-
-      print "\n> "
-      choice = $stdin.gets&.chomp&.to_i || 0
-
-      labels  = candidates.keys
-      chosen  = labels[choice - 1]
-
-      if chosen.nil?
-        puts error("Invalid choice.")
-        exit 1
-      end
-
-      if chosen == "Custom"
-        print "Enter version (x.y.z): "
-        version = $stdin.gets&.chomp || ""
-        unless version.match?(SEMVER_RE)
-          puts error("Invalid semver: #{version}")
-          exit 1
-        end
-        version
-      else
-        candidates[chosen]
-      end
-    end
-
-    def confirm!(version)
-      puts "\nNew version: #{bold(version)}"
-      print "Confirm? [Y/n] "
-      answer = $stdin.gets&.chomp&.downcase || ""
-      exit 1 unless answer == "y" || answer == ""
-    end
-
-    # ── build ────────────────────────────────────────────────────────────────
-
     def run_build
-      profile_arg = extract_option("--profile")
-
-      config = load_config
-
-      unless config.expo? || config.capacitor?
-        puts error("Aucune configuration de build dans #{CONFIG_FILE}.")
-        puts "Lancez #{bold("captive-release init")} pour configurer le workflow de build.\n\n"
-        exit 1
-      end
-
-      puts "\n#{bold("captive-release build")}\n\n"
-
-      profile = profile_arg || ask_profile
-
-      token = github_token
-      unless token
-        puts error("GITHUB_TOKEN or `gh auth login` required to dispatch build workflows.")
-        exit 1
-      end
-
-      ref = current_branch
-      workflow_file = config.expo? ? config.expo.build_workflow : config.capacitor.build_workflow
-
-      puts "Profile:  #{bold(profile)}"
-      puts "Workflow: #{bold(workflow_file)}"
-      puts "Branch:   #{bold(ref)}"
-      puts "\nDispatching...\n"
-
-      url = GithubDispatch.dispatch(
-        workflow_file: workflow_file,
-        ref:           ref,
-        inputs:        { "profile" => profile },
-        remote_url:    GitCommands.remote_url,
-        token:         token
-      )
-
-      puts "#{ok("✅")}  Build dispatched!"
-      puts "     #{url}\n\n"
-    end
-
-    def ask_profile
-      puts "Choose profile:\n"
-      puts "  #{dim("1)")} staging"
-      puts "  #{dim("2)")} production"
-      print "\n> "
-      choice = $stdin.gets&.chomp&.to_i || 0
-
-      case choice
-      when 1 then "staging"
-      when 2 then "production"
-      else
-        puts error("Invalid choice.")
-        exit 1
-      end
-    end
-
-    def current_branch
-      branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
-      branch.empty? ? "main" : branch
-    end
-
-    # ── helpers ─────────────────────────────────────────────────────────────
-
-    def load_config
-      return Config.load if File.exist?(CONFIG_FILE)
-
-      files = VersionDetector.scan
-      if files.empty?
-        puts error("Aucun fichier de version trouvé (package.json, lib/**/version.rb, VERSION).")
-        puts "Créez un fichier #{bold("VERSION")} ou lancez #{bold("captive-release init")}.\n\n"
-        exit 1
-      end
-
-      Config.new(files)
+      BuildCommand.new(**collaborateurs).run(@options.value("--profile"))
     end
 
-    def github_token
-      return ENV["GITHUB_TOKEN"] unless ENV["GITHUB_TOKEN"].to_s.empty?
+    def release_command = ReleaseCommand.new(**collaborateurs)
 
-      token = `gh auth token 2>/dev/null`.strip
-      token.empty? ? nil : token
+    def collaborateurs
+      { terminal: terminal, config: ConfigLoader.new(terminal: terminal).call,
+        token_provider: GithubToken.method(:call), }
     end
 
-    def safe_read(file)
-      file.read_version
-    rescue
-      "?"
+    def refuser(command)
+      terminal.say terminal.error("Unknown command: #{command}")
+      aide.show
+      exit 1
     end
 
-    def extract_option(flag)
-      idx = @argv.index { |a| a.start_with?("#{flag}=") || a == flag }
-      return nil if idx.nil?
-
-      arg = @argv.delete_at(idx)
-      if arg.include?("=")
-        arg.split("=", 2).last
-      else
-        @argv.delete_at(idx)
-      end
-    end
-
-    def print_help
-      puts <<~HELP
-
-        #{bold("captive-release")} — Semver release tool
-
-        #{bold("Usage:")}
-          captive-release init [--files path[:type],...]
-          captive-release new [patch|minor|major|x.y.z]
-          captive-release version
-
-        #{bold("Commands:")}
-          init    Detect version files and write captive-release.json
-          new     Bump version, commit, tag, push, create GitHub release
-          build   Dispatch an EAS build workflow (staging/production) via GitHub Actions
-
-        #{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
-
-        #{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 build
-          captive-release build --profile staging
-          captive-release build --profile production
-
-        #{bold("GitHub release:")}
-          Set GITHUB_TOKEN env var or authenticate with `gh auth login`
-
-      HELP
-    end
+    def terminal = @terminal ||= Terminal.new
 
-    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"
+    def aide = Help.new(terminal: terminal)
   end
 end

data/lib/captive_release/config.rb

@@ -1,55 +1,13 @@
 # frozen_string_literal: true
 
-require "json"
-
 module CaptiveRelease
   CONFIG_FILE = "captive-release.json"
 
-  ExpoConfig = Struct.new(:build_workflow, keyword_init: true) do
-    def self.from_hash(h)
-      return nil unless h
-
-      new(build_workflow: h["build_workflow"] || "build.yml")
-    end
-
-    def to_h
-      { "build_workflow" => build_workflow }
-    end
-  end
-
-  CapacitorConfig = Struct.new(:build_workflow, keyword_init: true) do
-    def self.from_hash(h)
-      return nil unless h
-
-      new(build_workflow: h["build_workflow"] || "capacitor-build.yml")
-    end
-
-    def to_h
-      { "build_workflow" => build_workflow }
-    end
-  end
-
+  # Ce qu'un dépôt déclare pour ses releases : les fichiers qui portent la version, et les
+  # workflows de build s'il en a. Sa forme sur le disque vit dans ConfigFile.
   class Config
     attr_reader :version_files, :expo, :capacitor
 
-    def self.load(path = CONFIG_FILE)
-      raise "#{CONFIG_FILE} not found. Run `captive-release init` first." unless File.exist?(path)
-
-      data = JSON.parse(File.read(path))
-      new(
-        data["version_files"].map { |f| VersionFile.new(f["path"], f["type"]) },
-        ExpoConfig.from_hash(data["expo"]),
-        CapacitorConfig.from_hash(data["capacitor"])
-      )
-    end
-
-    def self.write(version_files, path = CONFIG_FILE, expo: nil, capacitor: nil)
-      data = { "version_files" => version_files.map(&:to_h) }
-      data["expo"]      = expo.to_h      if expo
-      data["capacitor"] = capacitor.to_h if capacitor
-      File.write(path, "#{JSON.pretty_generate(data)}\n")
-    end
-
     def initialize(version_files, expo = nil, capacitor = nil)
       raise ArgumentError, "version_files cannot be empty" if version_files.empty?