autosparkle 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d68b72cb179b558388027771604619562da6a0293a8901b3aadf9c39fbd39df7
+  data.tar.gz: eaa1e667baba2cd385a63de1d5102ca950b37ecc154b5c8256e6087947d8e973
+SHA512:
+  metadata.gz: 787e99f1fd204d1a9234d22109fc92a2572d09381c8277ffd83e85423ee9fbc286547c700e449876ac6ea3a2b7bf4912901856a5ba4fbd5875e9431ff2e3c540
+  data.tar.gz: 23c2358c76555744a099b67441e032b422f6e5a068f62edda8fae42b74531296e053fe4302bc883ccfa3770911e038238054654d23fbfab7c09482d2aeb4b73c

data/README.md

@@ -0,0 +1,144 @@
+# autosparkle
+
+![autosparkle main image](resources/readme-main-image.jpg)
+
+autosparkle simplifies the process of **archiving**, **exporting**, **signing**, **packaging**, **notarizing**, and **uploading** your new version of the macOS app outside the App Store.
+
+With autosparkle, you no longer have to worry about these steps anymore.
+
+## Table of Contents
+- [Introduction](#introduction)
+- [Features](#features)
+- [Installation](#installation)
+- [Environment](#environment)
+- [Storage](#storage)
+- [Future Enhancements](#future-enhancements)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Introduction
+
+Pushing a new version of your macOS application outside the App Store can be time-consuming. This is because there are several steps required by Apple, in addition to the ones related to Sparkle.
+
+autosparkle is a Ruby command line tool that automates the delivery of your macOS applications outside the App Store. It is implemented around the [Sparkle](https://github.com/sparkle-project/Sparkle) framework.
+
+> **Note:**
+>
+> *This tool is designed for use in a Continuous Delivery (CD) workflow. Although it is possible to run it locally, doing so is not recommended due to the creation of a custom keychain and the mounting of a new DMG. However, if you are comfortable with these steps, you can run it locally without any issues.*
+
+## Features
+- Archive and export your signed application using the provided Developer Application ID certificate.
+- Package your app into a signed DMG.
+- Customize your DMG appearance by adding a custom background image and a symbolic link to drag the app to the Applications folder.
+- Notarize and staple your DMG.
+- Automatically sign the Sparkle framework.
+- Automatically handle your app versioning based on the specified bump method and the versions uploaded to the storage.
+- Generate or update the appcast.xml file used by Sparkle.
+- Upload the appcast.xml and your new version to the specified storage.
+- Use environment files, making it easy to create a specific one for use in CD *(e.g., env.autosparkle.production)*.
+
+## Installation
+
+#### Using Ruby Gems:
+1. Run the following command:
+    ```bash
+    gem install autosparkle
+    ```
+2. (optional) Add autosparkle to your shell configuration file (e.g. ~/.bashrc or  ~/.zshrc) by appending the following line:
+    ```bash
+    export PATH="<<YOUR_GEMS_DIR>>/autosparkle-x.x.x/bin:$PATH"
+    ```
+    Make sure to replace `<<YOUR_GEMS_DIR>>/autosparkle-x.x.x` with the actual path to the autosparkle gem on your system.
+
+3. (optional) Run the following command: `source ~/.bashrc` or `source ~/.zshrc`.
+
+
+#### Manual install:
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/hadiidbouk/autosparkle.git
+   ```
+2. Call the `autosparkle.rb` script from the repository, you need to specify your Xcode project path and your environment file. Here's how you can do it:
+    ```bash
+    ruby autosparkle.rb --project-path <<YOUR XCODE PROJECT>> --env <<YOUR ENV NAME>>
+    ```
+
+    You can also pass your workspace path using `--workspace-path` and specify the environment path using `--env-file`.
+
+
+## Environment
+autosparkle utilizes the [dotenv](https://github.com/bkeepers/dotenv) gem to manage environment variables.
+
+The purpose of using environment variable files is to facilitate the transition between the local environment on your personal machine and the production environment on your continuous delivery machine.
+
+When you specify the environment name using the `--env` command, autosparkle will search for autosparkle environment files *(e.g., .env.autosparkle.local, .env.autosparkle.production)* in your project directory.
+
+Remember to add your local environment file to the *.gitignore* file and remove any sensitive data from your production environment file. Instead, replace them with the environment variables provided by your continuous delivery system like this:
+```
+APP_SEPECIFIC_PASSWORD=$APP_SPECIFIC_PASSWORD
+```
+
+Below are the list of environment variables used by autosparkle:
+
+| Variable | Description | Required | Default value |
+|----------|-------------|----------|---------------|
+| SCHEME | The macOS app scheme | Yes | |
+| CONFIGURATION | The app configuration (Debug/Release..)| Yes | |
+| APPLE_ID | The Apple ID that will be used in the notarize step | Yes | |
+| APP_SPECIFIC_PASSWORD | The App specific password that will be used in the notarize step | Yes | |
+| DEVELOPER_ID_APPLICATION_BASE64 | The Developer ID Application base64 certificate | Yes | |
+| DEVELOPER_ID_APPLICATION_PASSWORD | The Developer ID Application base64 certificate password | Yes | |
+| DMG_BACKGROUND_IMAGE | The DMG background image path that should exist in the project folder | Yes | |
+| DMG_WINDOW_WIDTH | The DMG "Drag to Applications" window width | Yes | |
+| DMG_WINDOW_HEIGHT | The DMG "Drag to Applications" window height | Yes | |
+| DMG_ICON_SIZE | The icon size of the app and the Applications folder in the window | Yes | |
+| SPARKLE_PRIVATE_KEY | The Sparkle private key that will be generated on your machine after running the `lib/autosparkle/sparkle/generate_keys`, you can export the private key into a file and then copy it into this variable. `lib/autosparkle/sparkle/generate_keys -x ~/Desktop/my_key.txt` | Yes | |
+| SPARKLE_UPDATE_TITLE | The new version update title | Yes | |
+| SPARKLE_RELEASE_NOTES | The HTML release notes, it shouldn't contains any body or header just simple html tags | Yes | |
+| SPARKLE_BUMP_VERSION_METHOD | The version bump method for your marketing semantic version, `patch`, `minor`, `major` or `same`. | Yes | |
+| WEBSITE_URL | The website URL that will be added to the appcast.xml | Yes | |
+| STORAGE_TYPE | The storage type used to upload your app versions alongside the *appcast.yml* file, available values are: `aws-s3` | Yes | |
+| AWS_S3_ACCESS_KEY | The AWS S3 access Key | Yes (if `aws-s3` STORAGE_TYPE is specified) | |
+| AWS_S3_SECRET_ACCESS_KEY | The AWS S3 secret access key | Yes (if `aws-s3` STORAGE_TYPE is specified)| |
+| AWS_S3_REGION | The AWS S3 region | Yes (if `aws-s3` STORAGE_TYPE is specified) | |
+| AWS_S3_BUCKET_NAME | The AWS S3 bucket name | Yes (if `aws-s3` STORAGE_TYPE is specified) | |
+
+> **Note:**
+>
+> *Remember to add the SUFeedURL and the **SUPublicEDKey** to your app's Info.plist.*
+> **SUFeedURL** is the URL of your appcast.xml, which should be publicly accessible online.
+> **SUPublicEDKey** will be displayed in your terminal after running the `bin/generate_keys` command.
+
+You can refer to the [SparkleTestApp](https://github.com/hadiidbouk/sparkle-test-app) sample project for more information.
+
+## Storage
+In order to support multiple versions of your macOS application, autosparkle requires access to an online storage for uploading and reading the *appcast.xml* file and the application versions.
+
+The currently supported storage options are:
+
+- AWS S3
+
+## Future Enhancements
+Here are some future enhancements planned for autosparkle:
+
+- Support binary delta updates.
+- Support for additional storage options.
+- Introduce the ability to package the app without distributing it.
+- Support for the `pkg` format.
+- Distributing autosparkle using Homebrew.
+
+Stay tuned for these exciting updates!
+
+
+
+## Contributing
+Contributions to autosparkle are welcome! If you would like to contribute, please follow these guidelines:
+- Fork the repository.
+- Create a new branch for your feature or bug fix.
+- Make your changes and commit them with descriptive messages.
+- Push your changes to your forked repository.
+- Submit a pull request to the main repository on the `develop` branch.
+
+## License
+autosparkle is licensed under the [MIT License](LICENSE).

data/bin/autosparkle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/autosparkle/main'

data/lib/autosparkle/distribution.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require_relative 'helpers/build_directory_helpers'
+require_relative 'helpers/commands_helpers'
+require_relative 'helpers/puts_helpers'
+require_relative 'helpers/constants'
+require_relative 'helpers/appcast_helpers'
+require_relative 'environment/environment'
+
+# Distribution module to sign the update and upload it to the server
+module Distribution
+  def self.upload_update(pkg_path)
+    puts_title 'Uploading the update to the server'
+    ed_signature_fragment = sign_update(pkg_path)
+
+    appcast_xml = AppcastXML.generate_appcast_xml(ed_signature_fragment, Env.storage.deployed_appcast_xml)
+    upload_update_to_server(pkg_path, appcast_xml)
+
+    app_display_name = Env.variables.app_display_name
+    version = Env.variables.marketing_version
+    build_version = Env.variables.current_project_version
+    puts "#{app_display_name} version #{version} (#{build_version}) has been uploaded successfully. ✅ 🚀".green
+  end
+
+  def self.sign_update(pkg_path)
+    puts_if_verbose 'Signing the update...'
+    sign_update_path = File.join(__dir__, 'sparkle', 'sign_update')
+    sign_command = "echo \"#{Env.variables.sparkle_private_key}\" | "
+    sign_command += "#{sign_update_path} \"#{pkg_path}\" --ed-key-file -"
+    execute_command(sign_command, contains_sensitive_data: true)
+  end
+
+  def self.upload_update_to_server(pkg_path, appcast_xml)
+    puts_if_verbose 'Uploading the update to the server...'
+    appcast_file = BuildDirectory.new_file('appcast.xml')
+    appcast_file.write(appcast_xml)
+    appcast_file.close
+
+    Env.storage.upload(pkg_path, appcast_file.path)
+  end
+end

data/lib/autosparkle/environment/environment.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'dotenv'
+require 'nokogiri'
+require_relative '../helpers/appcast_helpers'
+require_relative '../helpers/puts_helpers'
+require_relative '../storages/aws_s3_storage'
+require_relative 'variables/default_environment_variables'
+
+# Environment module to load the environment variables
+# It contains the app state
+module Env
+  @variables = nil
+  @storage = nil
+  @verbose_enabled = false
+
+  class << self
+    attr_accessor :variables, :storage, :verbose_enabled
+
+    def initialize(options)
+      project_path = options[:project_path]
+      workspace_path = options[:workspace_path]
+      project_directory_path = File.dirname(workspace_path || project_path)
+
+      load_environment(project_directory_path, options)
+
+      @variables = DefaultEnvironmentVariables.new(project_directory_path)
+      @storage = retrieve_storage
+
+      retrieve_variables_from_xcode(project_path, workspace_path)
+      set_up_app_versions(project_path, workspace_path)
+
+      puts_if_verbose "Running the script with the #{options[:env]} environment...\n"
+    end
+  end
+
+  def self.load_environment(project_directory_path, options)
+    env_file_path = options[:env_file] || File.join(project_directory_path, ".env.autosparkle.#{options[:env]}")
+    raise "#{env_file_path} does not exist." unless File.exist?(env_file_path)
+
+    Dotenv.load(env_file_path)
+  end
+
+  def self.retrieve_storage
+    storage_type = ENV.fetch('STORAGE_TYPE', nil)
+    raise 'Storage type is not defined in the environment' if storage_type.nil? || storage_type.empty?
+
+    case storage_type
+    when 'aws-s3'
+      AwsS3Storage.new
+    else
+      raise "Storage type #{storage_type} is not supported"
+    end
+  end
+
+  def self.retrieve_variables_from_xcode(project_path, workspace_path)
+    puts_if_verbose 'Fetching the minimum macOS version from the Xcode project...'
+    ENV['MINIMUM_MACOS_VERSION'] = Xcodeproj.get_minimum_deployment_macos_version(project_path, workspace_path)
+
+    puts_if_verbose 'Fetching the app display name from the Xcode project...'
+    ENV['APP_DISPLAY_NAME'] = Xcodeproj.get_app_display_name(project_path, workspace_path)
+  end
+
+  def self.set_up_app_versions(project_path, workspace_path)
+    marketing_version, current_project_version = AppcastXML.retreive_versions(@storage.deployed_appcast_xml)
+
+    ENV['MARKETING_VERSION'] = marketing_version
+    ENV['CURRENT_PROJECT_VERSION'] = current_project_version
+
+    puts_if_verbose 'Updating the project versions from the environment variables...'
+    Xcodeproj.update_project_version(project_path, workspace_path)
+  end
+end

data/lib/autosparkle/environment/variables/aws_s3_environment_variables.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'base_environment_variables'
+
+# A class to load the AWS S3 environment variables
+class AwsS3EnvironmentVariables < BaseEnvironmentVariables
+  def initialize
+    super({
+      access_key: 'AWS_S3_ACCESS_KEY',
+      secret_access_key: 'AWS_S3_SECRET_ACCESS_KEY',
+      region: 'AWS_S3_REGION',
+      bucket_name: 'AWS_S3_BUCKET_NAME'
+    })
+  end
+end

data/lib/autosparkle/environment/variables/base_environment_variables.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../helpers/puts_helpers'
+
+# The base envrionment variables class
+class BaseEnvironmentVariables
+  def initialize(variables)
+    @variables = variables
+  end
+
+  def method_missing(method_name, *arguments, &block)
+    key = method_name.to_sym
+    if @variables.key?(key)
+      value = ENV.fetch(@variables[key], nil)
+      raise "#{@variables[key]} is not defined in the environment variables" if value.nil? || value.empty?
+
+      value
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @variables.key?(method_name.to_sym) || super
+  end
+end

data/lib/autosparkle/environment/variables/default_environment_variables.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../helpers/puts_helpers'
+require_relative '../../helpers/xcodeproj_helpers'
+require_relative 'base_environment_variables'
+
+# A class to load the default environment variables
+class DefaultEnvironmentVariables < BaseEnvironmentVariables
+  def initialize(project_directory_path)
+    super({
+      project_directory_path: 'PROJECT_DIRECTORY_PATH',
+      scheme: 'SCHEME',
+      configuration: 'CONFIGURATION',
+      marketing_version: 'MARKETING_VERSION',
+      current_project_version: 'CURRENT_PROJECT_VERSION',
+      minimum_macos_version: 'MINIMUM_MACOS_VERSION',
+      app_display_name: 'APP_DISPLAY_NAME',
+      apple_id: 'APPLE_ID',
+      app_specific_password: 'APP_SPECIFIC_PASSWORD',
+      developer_id_application_password: 'DEVELOPER_ID_APPLICATION_PASSWORD',
+      developer_id_application_base64: 'DEVELOPER_ID_APPLICATION_BASE64',
+      sparkle_private_key: 'SPARKLE_PRIVATE_KEY',
+      sparkle_update_title: 'SPARKLE_UPDATE_TITLE',
+      sparkle_release_notes: 'SPARKLE_RELEASE_NOTES',
+      sparkle_bump_version_method: 'SPARKLE_BUMP_VERSION_METHOD',
+      website_url: 'WEBSITE_URL',
+      dmg_background_image: 'DMG_BACKGROUND_IMAGE',
+      dmg_icon_size: 'DMG_ICON_SIZE',
+      dmg_window_width: 'DMG_WINDOW_WIDTH',
+      dmg_window_height: 'DMG_WINDOW_HEIGHT'
+    })
+
+    ENV['PROJECT_DIRECTORY_PATH'] = project_directory_path
+  end
+end

data/lib/autosparkle/helpers/appcast_helpers.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative '../environment/environment'
+require_relative 'puts_helpers'
+require_relative 'version_helpers'
+
+# AppcastXML module to generate the appcast XML file and items
+module AppcastXML
+  def self.generate_appcast_xml(ed_signature_fragment, deployed_appcast_xml)
+    if deployed_appcast_xml
+      append_item_to_existing_appcast(ed_signature_fragment, deployed_appcast_xml)
+    else
+      puts_if_verbose 'Creating a new appcast file...'
+      <<~XML
+        <?xml version="1.0" encoding="utf-8"?>
+        <rss version="2.0" xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle"  xmlns:dc="http://purl.org/dc/elements/1.1/">
+        	<channel>
+        		<title>Changelog</title>
+        		<description>Most recent changes with links to updates.</description>
+        		<language>en</language>
+        		#{generate_appcast_item(ed_signature_fragment)}
+        	</channel>
+        </rss>
+      XML
+    end
+  end
+
+  def self.append_item_to_existing_appcast(ed_signature_fragment, deployed_appcast_xml)
+    puts_if_verbose 'Appending the new item to the existing appcast file...'
+
+    doc = Nokogiri::XML(deployed_appcast_xml)
+
+    new_item_xml = generate_appcast_item(ed_signature_fragment)
+    new_item_doc = Nokogiri::XML(new_item_xml)
+    new_item = new_item_doc.root
+
+    channel = doc.at_xpath('//channel')
+    channel.add_child(new_item)
+
+    doc.to_xml
+  end
+
+  def self.generate_appcast_item(ed_signature_fragment)
+    date = Time.now.strftime('%a %b %d %H:%M:%S %Z %Y')
+    pkg_url = "#{Env.variables.marketing_version}/#{Env.variables.app_display_name}.dmg"
+    <<~XML
+      <item>
+      	<title>#{Env.variables.sparkle_update_title}</title>
+      	<link>#{Env.variables.website_url}</link>
+      	<sparkle:version>#{Env.variables.current_project_version}</sparkle:version>
+      	<sparkle:shortVersionString>#{Env.variables.marketing_version}</sparkle:shortVersionString>
+      	<description>
+      		<![CDATA[
+      		#{Env.variables.sparkle_release_notes}
+      		]]>
+      	</description>
+      	<pubDate>#{date}</pubDate>
+      	<enclosure url="#{pkg_url}" type="application/octet-stream" #{ed_signature_fragment} />
+      	<sparkle:minimumSystemVersion>#{Env.variables.minimum_macos_version}</sparkle:minimumSystemVersion>
+      </item>
+    XML
+  end
+
+  def self.retreive_versions(deployed_appcast_xml)
+    return ['1.0.0', '1'] unless deployed_appcast_xml
+
+    doc = Nokogiri::XML(deployed_appcast_xml)
+    [marketing_version(doc), current_project_version(doc)]
+  end
+
+  def self.marketing_version(doc)
+    method_name = Env.variables.sparkle_bump_version_method
+    raise "Unsupported bump method name '#{method_name}'" unless %w[minor patch major same].include?(method_name)
+
+    # bump the marketing version from @variables.sparkle_bump_version_method
+    short_version_strings = doc.xpath('//item/sparkle:shortVersionString', 'sparkle' => 'http://www.andymatuschak.org/xml-namespaces/sparkle')
+    latest_semantic_version = short_version_strings.map { |s| Gem::Version.new(s.text) }.max
+    method_name == 'same' ? latest_semantic_version.to_s : Version.bump(latest_semantic_version, method_name)
+  end
+
+  def self.current_project_version(doc)
+    # find the latest versions in the item tag for sparkle:version child
+    versions = doc.xpath('//item/sparkle:version', 'sparkle' => 'http://www.andymatuschak.org/xml-namespaces/sparkle')
+                  .map { |s| s.text.to_i }
+    latest_version = versions.max + 1
+    latest_version.to_s
+  end
+end

data/lib/autosparkle/helpers/build_directory_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'constants'
+require_relative 'puts_helpers'
+
+# This module is used to create a new path inside the build directory
+module BuildDirectory
+  @build_directory_path = File.expand_path(Constants::AUTOSPARKLE_BUILD_DIRECTORY_PATH)
+
+  def self.build_directory_path
+    @build_directory_path
+  end
+
+  def self.create_build_directory
+    if File.directory?(build_directory_path)
+      puts_if_verbose 'Cleaning up the build directory...'
+      FileUtils.rm_rf(build_directory_path)
+    end
+
+    puts_if_verbose "Creating the build directory at #{build_directory_path} ..."
+    FileUtils.mkdir_p(build_directory_path)
+  end
+
+  def self.new_path(name)
+    "#{build_directory_path}/#{name}"
+  end
+
+  def self.new_file(name)
+    File.open(new_path(name), 'w')
+  end
+
+  def self.new_directory(name)
+    path = new_path(name)
+    FileUtils.mkdir_p(path)
+    path
+  end
+end

data/lib/autosparkle/helpers/commands_helpers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'english'
+require_relative '../environment/environment'
+
+#
+# This method executes a command and returns the output
+# It raises an error if the command fails
+#
+def execute_command(command, contains_sensitive_data: false)
+  # if the command has --password, --secret then replace it with *****
+  presented_command = command.gsub(/(--password|--secret) \S+/, '\1 *****')
+
+  puts "\n#{presented_command}\n".cyan if Env.verbose_enabled && !contains_sensitive_data
+  stdout, stderr, status = Open3.capture3(command)
+
+  # if status is not success
+  unless status.success?
+    puts "\nCommand failed: #{command}\n".red
+    puts "\nError: #{stderr}\n".red
+    raise
+  end
+
+  puts "#{stdout}\n\n".magenta if Env.verbose_enabled && !contains_sensitive_data
+
+  stdout
+end

data/lib/autosparkle/helpers/constants.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Constants module to store the constants used in the application
+module Constants
+  NOTARIZE_KEYCHAIN_PROFILE = 'autosparkle.keychain.notarize.profile'
+  AUTOSPARKLE_BUILD_DIRECTORY_PATH = '~/Library/Developer/autosparkle/build'
+end

data/lib/autosparkle/helpers/dmg_helpers.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'build_directory_helpers'
+require_relative 'puts_helpers'
+require_relative '../environment/environment'
+
+# This module is used to create a DMG file and set up the appearance
+module DMG
+  def self.create(app_path)
+    volume_name = Env.variables.app_display_name
+    background_image_path = "#{Env.variables.project_directory_path}/#{Env.variables.dmg_background_image}"
+
+    dmg_path = create_blank_dmg(app_path, background_image_path, volume_name)
+    mount(dmg_path, volume_name)
+    copy_app_and_set_symbolic_link(app_path, volume_name)
+    copy_background_image(background_image_path, volume_name)
+    customize_dmg_appearence(volume_name)
+    unmount(volume_name)
+    create_read_only_dmg(dmg_path)
+  end
+
+  def self.create_blank_dmg(app_path, background_image_path, volume_name)
+    puts_if_verbose 'Creating a blank DMG...'
+    volume_size = volume_size(app_path, background_image_path)
+    uuid = `uuidgen`.strip
+    dmg_path = BuildDirectory.new_path("#{Env.variables.app_display_name}-#{uuid}.dmg")
+    execute_command("hdiutil create -size #{volume_size}m -fs HFS+ -volname '#{volume_name}' -ov '#{dmg_path}'")
+    dmg_path
+  end
+
+  def self.volume_size(app_path, background_image_path)
+    app_size_kb = `du -sk "#{app_path}"`.split("\t").first.to_i
+    background_size_kb = File.size(background_image_path) / 1024
+    buffer_size_kb = 20 * 1024
+    volume_size_kb = app_size_kb + background_size_kb + buffer_size_kb
+    (volume_size_kb / 1024.0).ceil
+  end
+
+  def self.mount(dmg_path, volume_name)
+    puts_if_verbose 'Mounting the DMG...'
+    execute_command("hdiutil attach '#{dmg_path}' -mountpoint '/Volumes/#{volume_name}'")
+  end
+
+  def self.copy_app_and_set_symbolic_link(app_path, volume_name)
+    puts_if_verbose 'Copying the app to the DMG and creating a symbolic link to the Applications folder...'
+    FileUtils.cp_r(app_path, "/Volumes/#{volume_name}")
+    execute_command("ln -s /Applications /Volumes/#{volume_name}/Applications")
+  end
+
+  def self.copy_background_image(background_image_path, volume_name)
+    puts_if_verbose 'Copying the background image to the DMG...'
+    FileUtils.mkdir_p("/Volumes/#{volume_name}/.background")
+    FileUtils.cp(background_image_path, "/Volumes/#{volume_name}/.background/")
+  end
+
+  def self.customize_dmg_appearence(volume_name)
+    puts_if_verbose 'Customizing the appearance of the DMG...'
+
+    app_x_position = Env.variables.dmg_window_width.to_i * 0.25
+    applications_x_position = Env.variables.dmg_window_width.to_i * 0.75
+    item_y_position = Env.variables.dmg_window_height.to_i / 2
+
+    apple_script = dmg_appearence_apple_script(volume_name, app_x_position, applications_x_position, item_y_position)
+    execute_command("osascript -e '#{apple_script}'")
+  end
+
+  def self.dmg_appearence_apple_script(volume_name, app_x_position, applications_x_position, item_y_position)
+    window_width = Env.variables.dmg_window_width.to_i
+    window_height = Env.variables.dmg_window_height.to_i
+    <<-APPLESCRIPT
+      tell application "Finder"
+        tell disk "#{volume_name}"
+          open
+            set current view of container window to icon view
+            set toolbar visible of container window to false
+            set statusbar visible of container window to false
+            set the bounds of container window to {0, 0, #{window_width}, #{window_height}}
+            set arrangement of icon view options of container window to not arranged
+            set icon size of icon view options of container window to #{Env.variables.dmg_icon_size}
+            set background picture of icon view options of container window to file ".background:#{Env.variables.dmg_background_image}"
+            set position of item "#{Env.variables.app_display_name}.app" of container window to {#{app_x_position}, #{item_y_position}}
+            set position of item "Applications" of container window to {#{applications_x_position}, #{item_y_position}}
+          close
+          open
+            update without registering applications
+            delay 5
+        end tell
+      end tell
+    APPLESCRIPT
+  end
+
+  def self.unmount(volume_name)
+    puts_if_verbose 'Unmounting the DMG...'
+    command = "hdiutil detach '/Volumes/#{volume_name}'"
+    begin
+      execute_command(command)
+    rescue StandardError
+      puts_if_verbose 'Retrying unmount after a brief wait...'
+      sleep 5
+      execute_command(command)
+    end
+  end
+
+  def self.create_read_only_dmg(dmg_path)
+    puts_if_verbose 'Converting the DMG to read-only...'
+    dmg_final_path = BuildDirectory.new_path("#{Env.variables.app_display_name}.dmg")
+    execute_command("hdiutil convert '#{dmg_path}' -format UDZO -o '#{dmg_final_path}'")
+    execute_command("rm -rf '#{dmg_path}'")
+    dmg_final_path
+  end
+end

data/lib/autosparkle/helpers/keychain_helpers.rb

@@ -0,0 +1,107 @@
+require 'securerandom'
+require 'open3'
+require 'base64'
+require_relative 'build_directory_helpers'
+require_relative 'constants'
+require_relative 'commands_helpers'
+require_relative 'puts_helpers'
+
+#
+# Execute the given block with a temporary keychain,
+# The block will receive the application certificate name and team id as arguments.
+# The temporary keychain will be deleted after the block has been executed.
+#
+def with_temporary_keychain
+  keychain_name = "temporary.autosparkle.keychain-#{SecureRandom.uuid}"
+  keychain_path = "~/Library/Keychains/#{keychain_name}-db"
+  password = SecureRandom.hex(16)
+
+  original_keychain_list = `security list-keychains`.strip.split("\n").map(&:strip)
+  default_keychain = execute_command('security default-keychain')
+  default_keychain_path = default_keychain.gsub(/"(.*)"/, '\1').strip
+
+  delete_temporary_keychain_if_needed(keychain_path)
+
+  begin
+    # Create a temporary keychain
+    create_temporary_keychain(keychain_path, password, original_keychain_list)
+    import_certificates_in_temporary_keychain(keychain_path)
+    execute_command("security set-key-partition-list -S apple-tool:,apple:,codesign: \\
+                  -s -k \"#{password}\" #{keychain_path}")
+
+    # Fetch the certificate names and team ids from the temporary keychain
+    application_cert_name, application_team_id = fetch_application_certificate_info(keychain_path)
+    store_notarization_credentials(keychain_path, application_team_id)
+
+    keychain_info = {
+      keychain_path: keychain_path,
+      application_cert_name: application_cert_name,
+      application_team_id: application_team_id
+    }
+    yield(keychain_info) if block_given?
+  ensure
+    puts_if_verbose 'Ensuring cleanup of temporary keychain...'
+    delete_temporary_keychain_if_needed(keychain_path)
+
+    # Reset the keychain to the default
+    execute_command("security list-keychains -s #{original_keychain_list.join(' ')}")
+    execute_command("security default-keychain -s \"#{default_keychain_path}\"")
+  end
+end
+
+private
+
+def create_temporary_keychain(keychain_path, password, original_keychain_list)
+  execute_command("security create-keychain -p \"#{password}\" #{keychain_path}")
+  execute_command("security unlock-keychain -p \"#{password}\" #{keychain_path}")
+  execute_command("security list-keychains -d user -s #{(original_keychain_list + [keychain_path]).join(' ')}")
+  execute_command("security default-keychain -s #{keychain_path}")
+end
+
+def store_notarization_credentials(keychain_path, application_team_id)
+  command = "xcrun notarytool store-credentials #{Constants::NOTARIZE_KEYCHAIN_PROFILE} \\
+						--keychain #{keychain_path} \\
+						--apple-id #{Env.variables.apple_id} \\
+						--team-id #{application_team_id} \\
+						--password #{Env.variables.app_specific_password}"
+  execute_command(command)
+end
+
+def import_certificates_in_temporary_keychain(keychain_path)
+  developer_id_application_p12 = Base64.decode64(Env.variables.developer_id_application_base64 || '')
+
+  # Create temporary files for the .p12 certificates
+  application_cert_file = BuildDirectory.new_file('application_cert.p12')
+
+  # Write the decoded .p12 data to the temporary files
+  application_cert_file.write(developer_id_application_p12)
+  application_cert_file.close
+
+  # Import the certificates into the temporary keychain
+  import_file_to_keychain(keychain_path, application_cert_file.path,
+                          Env.variables.developer_id_application_password)
+end
+
+def import_file_to_keychain(keychain_path, file_path, password)
+  command = "security import #{file_path} -k #{keychain_path} -P #{password}"
+  command += ' -T /usr/bin/codesign'
+  command += ' -T /usr/bin/security'
+  command += ' -T /usr/bin/productbuild'
+  command += ' -T /usr/bin/productsign'
+  execute_command(command)
+end
+
+def fetch_certificate_info(keychain_path, certificate_type)
+  command = "security find-certificate -c \"#{certificate_type}\" #{keychain_path} | grep \"labl\" | sed -E 's/^.*\"labl\"<blob>=\"(.*)\".*/\\1/'"
+  name = `#{command}`.strip
+  team_id = name[/\(([^)]+)\)$/, 1]
+  [name, team_id]
+end
+
+def fetch_application_certificate_info(keychain_path)
+  fetch_certificate_info(keychain_path, 'Developer ID Application')
+end
+
+def delete_temporary_keychain_if_needed(keychain_path)
+  execute_command("security delete-keychain #{keychain_path}") if File.exist?(File.expand_path(keychain_path.to_s))
+end

data/lib/autosparkle/helpers/puts_helpers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require_relative '../environment/environment'
+
+def puts_if_verbose(message)
+  puts message if Env.verbose_enabled
+end
+
+def puts_error(message)
+  if message.is_a?(Array)
+    puts message.map(&:red).join("\n")
+  else
+    puts message.red
+  end
+end
+
+def puts_title(message)
+  puts "\n🔷 #{message} ...\n".yellow
+end

data/lib/autosparkle/helpers/version_helpers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# This module is used to bump the version of the app
+# It receives the current version and the method to bump the version
+# It returns the new version
+module Version
+  def self.bump(current_version, method)
+    major, minor, patch = current_version.segments
+
+    case method
+    when 'major'
+      major += 1
+      # Reset minor and patch versions
+      minor = 0
+      patch = 0
+    when 'minor'
+      minor += 1
+      # Reset patch version
+      patch = 0
+    when 'patch'
+      patch += 1
+    else
+      raise ArgumentError, "Unknown bump method: #{method}"
+    end
+
+    "#{major}.#{minor}.#{patch}"
+  end
+end

data/lib/autosparkle/helpers/xcodeproj_helpers.rb

@@ -0,0 +1,75 @@
+require 'colorize'
+require 'xcodeproj'
+require 'plist'
+require 'optparse'
+require_relative '../environment/environment'
+require_relative 'puts_helpers'
+
+# Xcodeproj module to handle the fetch and manipulation of Xcode project
+module Xcodeproj
+  def self.get_app_display_name(project_path, workspace_path)
+    _, target = get_app_target(project_path, workspace_path)
+    build_settings = target.build_configurations.first.build_settings
+    display_name = build_settings['PRODUCT_NAME']
+    display_name = target.name if display_name == '$(TARGET_NAME)'
+    display_name
+  end
+
+  def self.get_minimum_deployment_macos_version(project_path, workspace)
+    _, target = get_app_target(project_path, workspace)
+    config = target.build_configurations.first
+    config.build_settings['MACOSX_DEPLOYMENT_TARGET']
+  end
+
+  def self.get_project_version(project_path, workspace_path)
+    _, target = get_app_target(project_path, workspace_path)
+    target.build_configurations.first.build_settings
+    [build_settings['MARKETING_VERSION'], build_settings['CURRENT_PROJECT_VERSION']]
+  end
+
+  def self.update_project_version(project_path, workspace_path)
+    project, target = get_app_target(project_path, workspace_path)
+    target.build_configurations.each do |config|
+      config.build_settings['MARKETING_VERSION'] = Env.variables.marketing_version
+      config.build_settings['CURRENT_PROJECT_VERSION'] = Env.variables.current_project_version
+    end
+    project.save
+
+    puts_if_verbose "Successfully updated the project version to #{Env.variables.marketing_version} and saved the project."
+  end
+
+  def self.get_app_target(project_path, workspace_path)
+    project = Xcodeproj::Project.open(project_path) if project_path
+    workspace = Xcodeproj::Workspace.new_from_xcworkspace(workspace_path) if workspace_path
+
+    target = project.targets.find { |t| t.name == Env.variables.scheme } if project
+
+    # If workspace is used, find the project containing the scheme
+    if workspace && !target
+      workspace.file_references.each do |file_reference|
+        project_path = File.join(File.dirname(workspace_path), file_reference.path)
+        project = Xcodeproj::Project.open(project_path)
+        target = project.targets.find { |t| t.name == Env.variables.scheme }
+        break if target
+      end
+    end
+
+    raise "Target not found for scheme #{Env.variables.scheme_name}".red unless target
+
+    [project, target]
+  end
+
+  def self.check_sparkle_configuration_existence(project_path, workspace_path)
+    project, target = get_app_target(project_path, workspace_path)
+    info_plist_file = project.files.find { |f| f.path.end_with?('Info.plist') }
+    raise 'Info.plist not found in the project' unless info_plist_file
+
+    info_plist_path = File.join(Env.variables.project_directory_path, "#{target.name}/#{info_plist_file.path}")
+    info_plist = Xcodeproj::Plist.read_from_path(info_plist_path)
+
+    raise 'Info.plist does not contain the needed Sparkle configuration: SUFeedURL'.red if info_plist['SUFeedURL'].nil?
+    return unless info_plist['SUPublicEDKey'].nil?
+
+    raise 'Info.plist does not contain the needed Sparkle configuration: SUPublicEDKey'.red
+  end
+end

data/lib/autosparkle/main.rb

@@ -0,0 +1,73 @@
+require 'optparse'
+require 'securerandom'
+require_relative 'packaging'
+require_relative 'distribution'
+require_relative 'helpers/build_directory_helpers'
+require_relative 'helpers/commands_helpers'
+require_relative 'helpers/keychain_helpers'
+require_relative 'helpers/xcodeproj_helpers'
+require_relative 'helpers/puts_helpers'
+require_relative 'environment/environment'
+
+def extract_options
+  options = {}
+
+  OptionParser.new do |opts|
+    opts.banner = 'Usage: automate-sparkle.rb [options]'
+
+    opts.on('--project-path PATH', 'Path to the Xcode project') do |path|
+      options[:project_path] = path
+    end
+
+    opts.on('--workspace-path PATH', 'Path to the Xcode workspace') do |path|
+      options[:workspace_path] = path
+    end
+
+    env_description = 'Environment to load (aka. local, production)'
+    env_description += ' it will look inside the Xcode project/workspace path'
+    env_description += ' for a file named `.autosparkle.env.<environment>`'
+
+    opts.on('--env ENVIRONMENT', env_description) do |env|
+      options[:env] = env
+    end
+
+    opts.on('--env-file PATH', 'Path to the environment file') do |path|
+      options[:env_file] = path
+    end
+
+    opts.on('-v', 'Enable verbose mode') do |verbose|
+      Env.verbose_enabled = verbose
+    end
+  end.parse!
+
+  # Check if both project path and environment are specified
+  unless (options[:workspace_path] || options[:project_path]) && (options[:env] || options[:env_file])
+    raise 'Xcode Project/Workspace path and Environment/Environment file are required.'
+  end
+
+  options
+end
+
+options = extract_options
+Env.initialize(options)
+
+Xcodeproj.check_sparkle_configuration_existence(options[:project_path], options[:workspace_path])
+
+BuildDirectory.create_build_directory
+
+puts "Automating the delivery of #{Env.variables.app_display_name} version #{Env.variables.marketing_version} (#{Env.variables.current_project_version})..."
+dmg_path = nil
+with_temporary_keychain do |keychain_info|
+  exported_app_path = Packaging.archive_and_sign(
+    keychain_info[:application_cert_name],
+    keychain_info[:application_team_id],
+    options
+  )
+  dmg_path = Packaging.create_and_sign_dmg(
+    exported_app_path,
+    keychain_info[:application_cert_name],
+    keychain_info[:keychain_path]
+  )
+end
+
+Distribution.upload_update(dmg_path)

data/lib/autosparkle/packaging.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/build_directory_helpers'
+require_relative 'helpers/constants'
+require_relative 'helpers/commands_helpers'
+require_relative 'helpers/dmg_helpers'
+require_relative 'helpers/puts_helpers'
+require_relative 'environment/environment'
+
+# Packaging module to archive and sign the app
+module Packaging
+  def self.archive_and_sign(
+    application_cert_name,
+    application_cert_team_id,
+    options
+  )
+
+    puts_title 'Archiving and signing the app'
+    app_archive_path = BuildDirectory.new_path("#{Env.variables.app_display_name}.xcarchive")
+    archive_command = 'xcodebuild clean analyze archive'
+    archive_command += " -scheme #{Env.variables.scheme}"
+    archive_command += " -archivePath '#{app_archive_path}'"
+    archive_command += " CODE_SIGN_IDENTITY='#{application_cert_name}'"
+    archive_command += " DEVELOPMENT_TEAM='#{application_cert_team_id}'"
+    archive_command += " -configuration #{Env.variables.configuration}"
+    archive_command += " OTHER_CODE_SIGN_FLAGS='--timestamp --options=runtime'"
+
+    archive_command += if options[:workspace_path]
+                         " -workspace #{options[:workspace_path]}"
+                       else
+                         " -project #{options[:project_path]}"
+                       end
+
+    execute_command(archive_command)
+
+    puts_title 'Exporting the app'
+    exported_app_path = export_app(app_archive_path, application_cert_name, application_cert_team_id)
+
+    puts_title 'Signing the Sparkle framework'
+    sign_sparkle_framework(
+      exported_app_path,
+      application_cert_name
+    )
+
+    exported_app_path
+  end
+
+  def self.export_app(app_archive_path, application_cert_name, team_id)
+    puts_if_verbose 'Exporting the app...'
+    export_options = {
+      signingStyle: 'automatic',
+      method: 'developer-id',
+      teamID: team_id,
+      signingCertificate: application_cert_name,
+      destination: 'export'
+    }
+
+    export_options_file = BuildDirectory.new_file('exportOptions.plist')
+    plist_content = export_options.to_plist
+    export_options_file.write(plist_content)
+    export_options_file.close
+
+    puts_if_verbose "exportOptions.plist:\n#{plist_content}"
+
+    # Create temporary directory for the exported app
+    export_app_dir_path = BuildDirectory.new_directory('exported_app')
+
+    # Construct the export command
+    export_command = "xcodebuild -exportArchive -archivePath \"#{app_archive_path}\""
+    export_command += " -exportPath \"#{export_app_dir_path}\""
+    export_command += " -exportOptionsPlist \"#{export_options_file.path}\""
+    execute_command(export_command)
+
+    "#{export_app_dir_path}/#{Env.variables.app_display_name}.app"
+  end
+
+  def self.create_and_sign_dmg(exported_app_path, application_cert_name, keychain_path)
+    puts_title "Creating #{Env.variables.app_display_name}.dmg"
+    puts_if_verbose 'Creating a DMG for the app...'
+    dmg_path = DMG.create(exported_app_path)
+
+    # Sign the DMG
+    puts_if_verbose 'Signing the DMG...'
+    execute_command("codesign --force --sign \"#{application_cert_name}\" --timestamp --options runtime \"#{dmg_path}\"")
+
+    # Notarize the DMG
+    puts_if_verbose 'Notarizing the DMG...'
+    execute_command("xcrun notarytool submit \"#{dmg_path}\" --keychain-profile \"#{Constants::NOTARIZE_KEYCHAIN_PROFILE}\" --keychain \"#{keychain_path}\" --wait")
+
+    # Staple the notarization ticket
+    puts_if_verbose 'Stapling the notarization ticket...'
+    execute_command("xcrun stapler staple \"#{dmg_path}\"")
+
+    dmg_path
+  end
+
+  def self.sign_sparkle_framework(exported_app_path, application_cert_name)
+    sparkle_auto_update_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework/AutoUpdate"
+    codesign('Signing Sparkle AutoUpdate...', application_cert_name, sparkle_auto_update_path)
+
+    sparkle_updater_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework/Updater.app"
+    codesign('Signing Sparkle Updater...', application_cert_name, sparkle_updater_path)
+
+    sparkle_installer_xpc_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework/XPCServices/Installer.xpc/Contents/MacOS/Installer"
+    codesign('Signing Sparkle Installer XPC Service...', application_cert_name, sparkle_installer_xpc_path)
+
+    sparkle_downloader_xpc_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework/XPCServices/Downloader.xpc/Contents/MacOS/Downloader"
+    codesign('Signing Sparkle Downloader XPC Service...', application_cert_name, sparkle_downloader_xpc_path)
+
+    sparkle_framework_path = "#{exported_app_path}/Contents/Frameworks/Sparkle.framework"
+    codesign('Signing Sparkle framework...', application_cert_name, sparkle_framework_path)
+  end
+
+  def self.codesign(title, application_cert_name, path)
+    puts_if_verbose title
+    execute_command("codesign -f -o runtime --timestamp -s \"#{application_cert_name}\" \"#{path}\"")
+  end
+end

data/lib/autosparkle/sparkle/old_dsa_scripts/sign_update

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+set -o pipefail
+if [ "$#" -ne 2 ]; then
+  echo "Usage: $0 update_archive_file dsa_priv.pem"
+  echo "This is an old DSA signing script for deprecated DSA keys."
+  echo "Do not use this for new applications."
+  exit 1
+fi
+openssl=/usr/bin/openssl
+version=`$openssl version`
+if [[ $version =~ "OpenSSL 0.9" ]]; then
+	# pre-10.13 system: Fall back to OpenSSL DSS1 digest because it does not like the -sha1 option
+	$openssl dgst -sha1 -binary < "$1" | $openssl dgst -dss1 -sign "$2" | $openssl enc -base64
+else
+	# 10.13 and later: Use LibreSSL SHA1 digest
+	$openssl dgst -sha1 -binary < "$1" | $openssl dgst -sha1 -sign "$2" | $openssl enc -base64
+fi

data/lib/autosparkle/storages/aws_s3_storage.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-s3'
+require_relative 'storage'
+require_relative '../environment/environment'
+require_relative '../environment/variables/aws_s3_environment_variables'
+require_relative '../helpers/puts_helpers'
+
+# AwsS3Storage class to upload the updated version of the app
+class AwsS3Storage
+  include Storage
+  def initialize
+    @variables = AwsS3EnvironmentVariables.new
+
+    credentials = Aws::Credentials.new(@variables.access_key, @variables.secret_access_key)
+    Aws.config.update({
+                        region: @variables.region,
+                        credentials: credentials
+                      })
+    s3 = Aws::S3::Resource.new
+    @bucket = s3.bucket(@variables.bucket_name)
+    super
+  end
+
+  def upload(pkg_path, appcast_path)
+    appcast_object = @bucket.object('appcast.xml')
+    appcast_object.upload_file(appcast_path)
+
+    puts_if_verbose "Uploaded the appcast file to the bucket #{@variables.bucket_name}"
+
+    version_object = @bucket.object(update_file_destination_path)
+    version_object.upload_file(pkg_path)
+
+    puts_if_verbose "Uploaded version #{Env.variables.marketing_version} to the bucket #{@variables.bucket_name}"
+  rescue StandardError => e
+    raise "Failed to upload file: #{e.message}"
+  end
+
+  def deployed_appcast_xml
+    appcast_object = @bucket.object('appcast.xml')
+    appcast_object.get.body.read
+  rescue StandardError
+    nil
+  end
+end

data/lib/autosparkle/storages/storage.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# This module is used as an interface for the storage classes
+# It contains the methods that the storage classes should implement
+# A storage can be for example Google Drive, Azure Blob Storage, AWS S3, etc.
+# The update_file_destination_path method will return the path where the file should be uploaded
+# The upload method is used to upload the package and the appcast file to the storage
+module Storage
+  def update_file_destination_path
+    "#{Env.variables.marketing_version}/#{Env.variables.app_display_name}.dmg"
+  end
+
+  def upload(pkg_path, appcast_path)
+    raise NotImplementedError, "This #{self.class} cannot respond to:"
+  end
+
+  def deployed_appcast_xml
+    raise NotImplementedError, "This #{self.class} cannot respond to:"
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: autosparkle
+version: !ruby/object:Gem::Version
+  version: 0.0.8
+platform: ruby
+authors:
+- Hadi Dbouk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.152.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.152.3
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.2
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.16.6
+- !ruby/object:Gem::Dependency
+  name: xcodeproj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.24.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.24.0
+description: Autosparkle is a command-line tool that automates the delivery of macOS
+  apps outside the App Store. It is designed to be used in CI/CD pipelines to automate
+  the process of archiving, signing, notarizing, and distributing macOS apps.
+email:
+- hadiidbouk@gmail.com
+executables:
+- autosparkle
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/autosparkle
+- lib/autosparkle/distribution.rb
+- lib/autosparkle/environment/environment.rb
+- lib/autosparkle/environment/variables/aws_s3_environment_variables.rb
+- lib/autosparkle/environment/variables/base_environment_variables.rb
+- lib/autosparkle/environment/variables/default_environment_variables.rb
+- lib/autosparkle/helpers/appcast_helpers.rb
+- lib/autosparkle/helpers/build_directory_helpers.rb
+- lib/autosparkle/helpers/commands_helpers.rb
+- lib/autosparkle/helpers/constants.rb
+- lib/autosparkle/helpers/dmg_helpers.rb
+- lib/autosparkle/helpers/keychain_helpers.rb
+- lib/autosparkle/helpers/puts_helpers.rb
+- lib/autosparkle/helpers/version_helpers.rb
+- lib/autosparkle/helpers/xcodeproj_helpers.rb
+- lib/autosparkle/main.rb
+- lib/autosparkle/packaging.rb
+- lib/autosparkle/sparkle/BinaryDelta
+- lib/autosparkle/sparkle/generate_appcast
+- lib/autosparkle/sparkle/generate_keys
+- lib/autosparkle/sparkle/old_dsa_scripts/sign_update
+- lib/autosparkle/sparkle/sign_update
+- lib/autosparkle/storages/aws_s3_storage.rb
+- lib/autosparkle/storages/storage.rb
+homepage: https://github.com/hadiidbouk/autosparkle
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/hadiidbouk/autosparkle
+  source_code_uri: https://github.com/hadiidbouk/autosparkle
+  changelog_uri: https://github.com/hadiidbouk/autosparkle/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: |+
+  ###################################### AUTOSPAKRLE ######################################
+
+  Thank you for installing AutoSparkle!
+
+  To use AutoSparkle in your terminal, you need to update your shell configuration files.
+  Add the following line to your shell configuration file (e.g., ~/.bashrc, ~/.zshrc):
+    export PATH="<<YOUR_GEMS_DIR>>/autosparkle-x.x.x/bin:$PATH"
+
+  After updating your shell configuration file, run the following command:
+    source ~/.bashrc or source ~/.zshrc
+
+  For more information, visit the AutoSparkle GitHub repository:
+    https://github.com/hadiidbouk/autosparkle
+
+  Enjoy using AutoSparkle!
+
+  #########################################################################################
+
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key: 
+specification_version: 4
+summary: Automate macOS app delivery outside the App Store
+test_files: []