captive-release 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 62ba2157fbf2d4c10b034accf3e73b2de0d69018462070b8e2103db59b23ad5f
+  data.tar.gz: 9851621f86185f00f08194435d3c813bcd7db0782fe3f8475449284dad8b166c
+SHA512:
+  metadata.gz: 6290d340d5d2ae97b3f110ba8e03b27f295da458608110f6f5db710766856ccd691efb47d2a4f4505987a4a69035981618c2b21986d205a26ee56d1817b1a3ba
+  data.tar.gz: c5f6a79bd4ee364c862475939696187ef8dcc7e38ce908c053a8d7634a15381cb827b50d02b7864fb2512f952ca124354fbbeae25bee5f320df176fd36f575b3

data/bin/captive-release

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "captive_release"
+
+CaptiveRelease::CLI.run(ARGV)

data/lib/captive_release/cli.rb

@@ -0,0 +1,419 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  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
+    end
+
+    def run
+      command = @argv.shift
+
+      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
+      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
+    end
+
+    def detect_type(path)
+      File.basename(path) == "package.json" ? "package_json" : "plain"
+    end
+
+    # ── release ─────────────────────────────────────────────────────────────
+
+    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
+
+    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)
+    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"
+    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)
+    end
+
+    def github_token
+      return ENV["GITHUB_TOKEN"] unless ENV["GITHUB_TOKEN"].to_s.empty?
+
+      token = `gh auth token 2>/dev/null`.strip
+      token.empty? ? nil : token
+    end
+
+    def safe_read(file)
+      file.read_version
+    rescue
+      "?"
+    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 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/config.rb

@@ -0,0 +1,73 @@
+# 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
+
+  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?
+
+      @version_files = version_files
+      @expo          = expo
+      @capacitor     = capacitor
+    end
+
+    def expo?
+      !expo.nil?
+    end
+
+    def capacitor?
+      !capacitor.nil?
+    end
+
+    def current_version
+      version_files.first.read_version
+    end
+  end
+end

data/lib/captive_release/git_commands.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  class GitCommands
+    def self.dirty?
+      lines = `git diff --name-only && git diff --cached --name-only`.lines.map(&:strip).reject(&:empty?)
+      !lines.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
+      `git remote get-url origin 2>/dev/null`.strip
+    end
+
+    def self.add_and_commit(version, paths)
+      run! "git add #{paths.map { |p| shellescape(p) }.join(" ")}"
+      run! %(git commit -m "🔖 Set version v#{version}")
+    end
+
+    def self.tag(version)
+      run! "git tag v#{version}"
+    end
+
+    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}" }
+    end
+    private_class_method :shellescape
+  end
+end

data/lib/captive_release/github_dispatch.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require_relative "github_http"
+
+module CaptiveRelease
+  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
+    end
+
+    def initialize(workflow_file:, ref:, inputs:, remote_url:, token:)
+      @workflow_file = workflow_file
+      @ref           = ref
+      @inputs        = inputs
+      @remote_url    = remote_url
+      @token         = token
+    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
+
+      "https://github.com/#{owner}/#{repo}/actions"
+    end
+  end
+end

data/lib/captive_release/github_http.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+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)
+
+        location = response["location"] || response["Location"]
+        raise "GitHub redirect without Location header" unless location
+
+        uri = URI(location)
+      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
+
+      [match[1], match[2]]
+    end
+  end
+end

data/lib/captive_release/github_release.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require_relative "github_http"
+
+module CaptiveRelease
+  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
+    end
+
+    def initialize(version:, body:, remote_url:, token:)
+      @version    = version
+      @body       = body
+      @remote_url = remote_url
+      @token      = token
+    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"]
+    end
+  end
+end

data/lib/captive_release/version.rb

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

data/lib/captive_release/version_bumper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CaptiveRelease
+  class VersionBumper
+    SEMVER_RE = /\A\d+\.\d+\.\d+\z/
+
+    def self.bump(current, type)
+      new(current).bump(type)
+    end
+
+    def initialize(current)
+      raise ArgumentError, "Invalid semver: #{current}" unless current.match?(SEMVER_RE)
+
+      @major, @minor, @patch = current.split(".").map(&:to_i)
+    end
+
+    def bump(type)
+      case type.to_s
+      when "major" then "#{@major + 1}.0.0"
+      when "minor" then "#{@major}.#{@minor + 1}.0"
+      when "patch" then "#{@major}.#{@minor}.#{@patch + 1}"
+      else
+        raise ArgumentError, "Invalid version: #{type}" unless type.to_s.match?(SEMVER_RE)
+
+        type.to_s
+      end
+    end
+  end
+end

data/lib/captive_release/version_detector.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module CaptiveRelease
+  class VersionDetector
+    EXCLUDED_DIRS = %w[node_modules .git vendor tmp coverage dist .next .nuxt Pods].freeze
+
+    def self.scan(root = ".")
+      new(root).scan
+    end
+
+    def initialize(root)
+      @root = Pathname.new(root).expand_path
+    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
+    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
+      []
+    end
+
+    def find_ios_plist_files
+      Dir.glob(@root.join("ios", "**", "Info.plist")).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
+      []
+    end
+
+    def find_ruby_version_files
+      Dir.glob(@root.join("lib", "**", "version.rb")).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
+
+    def find_files(filename, type)
+      Dir.glob(@root.join("**", filename)).sort.reject { |p| excluded?(p) }.map do |path|
+        relative = Pathname.new(path).relative_path_from(@root).to_s
+        VersionFile.new(relative, type)
+      end
+    end
+
+    def excluded?(path)
+      EXCLUDED_DIRS.any? { |dir| path.include?("/#{dir}/") || path.include?("/#{dir}\\") }
+    end
+  end
+end

data/lib/captive_release/version_file.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CaptiveRelease
+  class VersionFile
+    TYPES = %w[package_json plain app_config_js ruby_version android_gradle ios_plist].freeze
+
+    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
+    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
+    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
+    end
+
+    def to_h
+      { "path" => path, "type" => type }
+    end
+
+    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 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"
+      ))
+    end
+  end
+end

data/lib/captive_release.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "captive_release/version"
+require_relative "captive_release/version_bumper"
+require_relative "captive_release/version_file"
+require_relative "captive_release/config"
+require_relative "captive_release/version_detector"
+require_relative "captive_release/git_commands"
+require_relative "captive_release/github_release"
+require_relative "captive_release/github_dispatch"
+require_relative "captive_release/cli"
+
+module CaptiveRelease
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: captive-release
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Captive Studio
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Gère les bumps de version (patch/minor/major/custom), met à jour package.json
+  et fichiers VERSION, crée le commit, le tag et la release GitHub.
+email:
+- dev@captive.fr
+executables:
+- captive-release
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/captive-release
+- lib/captive_release.rb
+- lib/captive_release/cli.rb
+- lib/captive_release/config.rb
+- lib/captive_release/git_commands.rb
+- lib/captive_release/github_dispatch.rb
+- lib/captive_release/github_http.rb
+- lib/captive_release/github_release.rb
+- lib/captive_release/version.rb
+- lib/captive_release/version_bumper.rb
+- lib/captive_release/version_detector.rb
+- lib/captive_release/version_file.rb
+homepage: https://github.com/captive-studio/captive-release
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: CLI de release semver pour projets Captive
+test_files: []