chore(release): 0.6.26

This reverts commit d338c136db.

Thanks to using relinking with @rpath, paths are shorting leaving enough
room in all *.eln files to be signed.

.golangci.yml

@@ -75,6 +75,9 @@ issues:
     - source: "`json:"
       linters:
         - lll
+    - source: "`yaml:"
+      linters:
+        - lll
 
 run:
   skip-dirs:

CHANGELOG.md

@@ -2,6 +2,200 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.6.26](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.25...v0.6.26) (2021-11-27)
+
+
+### Features
+
+* **build:** re-link eln files by default again ([4ae288c](https://github.com/jimeh/build-emacs-for-macos/commit/4ae288cae34c5e1d291dad7b6b654fe37c4a221f))
+* **native-comp:** no longer require gcc homebrew formula ([3bd78d1](https://github.com/jimeh/build-emacs-for-macos/commit/3bd78d130a5419a6530a7d30e271569e501870fb)), closes [#53](https://github.com/jimeh/build-emacs-for-macos/issues/53)
+
+
+### Bug Fixes
+
+* **embed:** relink shared libraries with [@rpath](https://github.com/rpath) instead of [@executable](https://github.com/executable)_path ([fb5362c](https://github.com/jimeh/build-emacs-for-macos/commit/fb5362ce183ce43e52afcc0fc721cf2145f9c85b))
+
+### [0.6.25](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.24...v0.6.25) (2021-11-25)
+
+### [0.6.24](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.23...v0.6.24) (2021-11-24)
+
+
+### Bug Fixes
+
+* **embedding:** embedding GCC fails when paths do not require sanitizing ([8a467b0](https://github.com/jimeh/build-emacs-for-macos/commit/8a467b0d43140f6956d53c27e2319ae1b572868c))
+
+### [0.6.23](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.22...v0.6.23) (2021-11-10)
+
+
+### Bug Fixes
+
+* **build:** do not re-link eln files by default ([d338c13](https://github.com/jimeh/build-emacs-for-macos/commit/d338c136db8acc4378154cf66ed7db5462787602)), closes [#60](https://github.com/jimeh/build-emacs-for-macos/issues/60)
+
+### [0.6.22](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.21...v0.6.22) (2021-11-10)
+
+
+### Features
+
+* **patch:** add support for posix-spawn patch from emacs-plus ([4030ceb](https://github.com/jimeh/build-emacs-for-macos/commit/4030ceb9cab6749af3c28161ac97caec90a8aed0))
+
+### [0.6.21](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.20...v0.6.21) (2021-10-27)
+
+### [0.6.20](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.19...v0.6.20) (2021-10-23)
+
+
+### Bug Fixes
+
+* **notarization:** explicitly only copy *.c and *.h C source files ([591c39e](https://github.com/jimeh/build-emacs-for-macos/commit/591c39e629c9556adcf296cd5c15dd0b17c4d986))
+
+### [0.6.19](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.18...v0.6.19) (2021-10-23)
+
+
+### Bug Fixes
+
+* **patch:** resolve emacs-29 symlink patches to their real URL ([bcbd017](https://github.com/jimeh/build-emacs-for-macos/commit/bcbd01778d416b99205c51f348a543489889f66d))
+
+### [0.6.18](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.17...v0.6.18) (2021-10-23)
+
+
+### Features
+
+* **docs:** embed C source files and set source-directory accordingly ([67b8c5f](https://github.com/jimeh/build-emacs-for-macos/commit/67b8c5f3974e178e31519846d46af82d9770ad6e))
+
+
+### Bug Fixes
+
+* **patches:** correctly use emacs 28.x and 29.x patches ([4dad581](https://github.com/jimeh/build-emacs-for-macos/commit/4dad5812fa2b67adc7262a778829013995a904bc))
+
+### [0.6.17](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.16...v0.6.17) (2021-10-10)
+
+
+### Features
+
+* **release:** tweak GitHub release description ([a956dc1](https://github.com/jimeh/build-emacs-for-macos/commit/a956dc1b42b2648e2663f5b48c72d7428fe75f19))
+
+### [0.6.16](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.15...v0.6.16) (2021-10-10)
+
+
+### Features
+
+* **build:** handle macOS Big Sur and later version number ([2e2f9bc](https://github.com/jimeh/build-emacs-for-macos/commit/2e2f9bc98acdc972a22add3d1015bd80cad20b41))
+* **cask:** make cask template helpers more flexible ([d63cd54](https://github.com/jimeh/build-emacs-for-macos/commit/d63cd545aab3a35e0cbbbcabd862525acbc414b8))
+* **plan:** allow build plan to be output as YAML or JSON ([1bbfe5d](https://github.com/jimeh/build-emacs-for-macos/commit/1bbfe5d3ea810215b417e5b80d2902f03d68f366))
+* **release:** add description to GitHub Releases ([7118ed8](https://github.com/jimeh/build-emacs-for-macos/commit/7118ed856053de06ddcdfba2a2d6fa40f58c17ab))
+* **release:** force-replace existing asset files by default ([e7a991e](https://github.com/jimeh/build-emacs-for-macos/commit/e7a991ef92a5c546106a8badaf9c60247a1397b5))
+
+
+### Bug Fixes
+
+* **release:** publish arguments are not handled as asset files to upload ([b4c5184](https://github.com/jimeh/build-emacs-for-macos/commit/b4c5184cefe43fdc54b1ad5c8a1970f104137644))
+
+### [0.6.15](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.14...v0.6.15) (2021-08-05)
+
+
+### Bug Fixes
+
+* **build:** another --relink-eln-files flag fix ([3622df5](https://github.com/jimeh/build-emacs-for-macos/commit/3622df550c72fc9da70235005239b278b5822cf6))
+
+### [0.6.14](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.13...v0.6.14) (2021-08-05)
+
+
+### Bug Fixes
+
+* **build:** silly typo ([1fc7faa](https://github.com/jimeh/build-emacs-for-macos/commit/1fc7faac1f040466fa4474a873d2290273780ee2))
+
+### [0.6.13](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.12...v0.6.13) (2021-08-04)
+
+
+### Bug Fixes
+
+* **native_comp:** add option to enable/disable relinking *.eln files ([ac943c4](https://github.com/jimeh/build-emacs-for-macos/commit/ac943c430c58e0761ac44e8d25d4d55a461d01a2))
+
+### [0.6.12](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.11...v0.6.12) (2021-08-02)
+
+
+### Bug Fixes
+
+* **sign:** resolve signing issue caused by re-linking shared lib in *.eln files ([e6b1e5a](https://github.com/jimeh/build-emacs-for-macos/commit/e6b1e5a554fd0f776bd01c17cfb1ebbbdf7a7831))
+
+### [0.6.11](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.10...v0.6.11) (2021-07-17)
+
+
+### Bug Fixes
+
+* **native-comp:** fix re-linking and signing issue with *.eln files ([b03343f](https://github.com/jimeh/build-emacs-for-macos/commit/b03343f506aa3ceabdfa03f8a2916b2db4873f3f))
+
+### [0.6.10](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.9...v0.6.10) (2021-07-16)
+
+
+### Bug Fixes
+
+* **native-comp:** *.eln files were not being found during shared lib embedding ([9d32509](https://github.com/jimeh/build-emacs-for-macos/commit/9d32509c615076618957cc47c82f6e9d8f972fe7))
+
+### [0.6.9](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.8...v0.6.9) (2021-07-04)
+
+
+### Features
+
+* **release:** add bulk edit command to quickly change multiple GitHub releases ([cb63806](https://github.com/jimeh/build-emacs-for-macos/commit/cb638062625d9bc3eee12515067fb09e05a08414))
+
+
+### Bug Fixes
+
+* **plan:** correctly parse --test-release-type flag ([fd0ec4d](https://github.com/jimeh/build-emacs-for-macos/commit/fd0ec4d772dd3da93afc234fb3024220b2099c88))
+
+### [0.6.8](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.7...v0.6.8) (2021-07-02)
+
+
+### Features
+
+* **builds:** add support for stable builds ([f4d6e3a](https://github.com/jimeh/build-emacs-for-macos/commit/f4d6e3a56d2c15b0c86af18e8d16bebbeb92a8ab))
+
+### [0.6.7](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.6...v0.6.7) (2021-07-02)
+
+
+### Features
+
+* **bundle:** move bundled shared libraries to Contents/Frameworks ([5c722e3](https://github.com/jimeh/build-emacs-for-macos/commit/5c722e36c571aa7bf558b7f210c011f12d8d8a1c))
+
+### [0.6.6](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.5...v0.6.6) (2021-07-01)
+
+### [0.6.5](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.4...v0.6.5) (2021-07-01)
+
+
+### Bug Fixes
+
+* **native_comp:** improve handling of *.eln files in .app bundle ([9019e73](https://github.com/jimeh/build-emacs-for-macos/commit/9019e73d606f0379f988f46d6008770f8f3f7a51))
+
+### [0.6.4](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.3...v0.6.4) (2021-06-30)
+
+### [0.6.3](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.2...v0.6.3) (2021-06-29)
+
+
+### Bug Fixes
+
+* **patches:** correctly set ref when loading a build plan YAML ([99aa76b](https://github.com/jimeh/build-emacs-for-macos/commit/99aa76b3985195c310a20bafa19a8c7a4c8558fd))
+
+### [0.6.2](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.1...v0.6.2) (2021-06-29)
+
+
+### Bug Fixes
+
+* **native_comp:** patch Emacs.pdmp for customized native-lisp paths ([23b8236](https://github.com/jimeh/build-emacs-for-macos/commit/23b8236e0a66fb09810e8422bedf02f7192a53e4))
+
+### [0.6.1](https://github.com/jimeh/build-emacs-for-macos/compare/v0.6.0...v0.6.1) (2021-06-28)
+
+
+### Bug Fixes
+
+* **cask:** add missing --force flag to cask update command ([6af597b](https://github.com/jimeh/build-emacs-for-macos/commit/6af597b4271341f9796c3d9c356de9918e0f6f85))
+
+## [0.6.0](https://github.com/jimeh/build-emacs-for-macos/compare/v0.5.2...v0.6.0) (2021-06-28)
+
+
+### Features
+
+* **cask:** add cask update command to manage cask formula ([adbcfc6](https://github.com/jimeh/build-emacs-for-macos/commit/adbcfc6fc433fcc99b10dc5ccb51ba458333fa9c))
+
 ### [0.5.2](https://github.com/jimeh/build-emacs-for-macos/compare/v0.5.1...v0.5.2) (2021-06-27)
 
 

README.md

@@ -17,21 +17,10 @@ Use this script at your own risk.
   built from the `master` branch. This script allows you to choose any branch,
   tag, or git ref you want.
 
-## Status
+## Binary Builds
 
-As of writing (2021-04-25) it works for me on my machine. Your luck may vary.
+Nightly and stable binary builds produced with this build script are available
-
+from [jimeh/emacs-builds](https://github.com/jimeh/emacs-builds).
-I have successfully built:
-
-- `emacs-27.1` release git tag
-- `master` branch (Emacs 28.x)
-- `feature/native-comp` branch (Emacs 28.x)
-
-For reference, my machine is:
-
-- 13-inch MacBook Pro (2020), 10th-gen 2.3 GHz Quad-Core Intel Core i7 (4c/8t)
-- macOS Big Sur 11.2.3 (20D91)
-- Xcode 12.4 (12D4e)
 
 ## Limitations
 
@@ -41,9 +30,9 @@ The build produced does have some limitations:
   application will be that of the machine it was built on.
 - The minimum required macOS version of the built application will be the same
   as that of the machine it was built on.
-- The application is not signed, so running it on machines other than the one
+- The application is not signed automatically, but the CLI tool used to sign the
-  that built the application will yield warnings. If you want to make a signed
+  nightly builds is available. Run `go run ./cmd/emacs-builder package --help`
-  Emacs.app, google is you friend for finding signing instructions.
+  for details. More detailed instructions will come soon.
 
 ## Requirements
 
@@ -61,6 +50,26 @@ The build produced does have some limitations:
   brew install ruby
   ```
 
+## Status
+
+As of writing (2021-11-27) it works for me on my machine and for the nightly
+builds in [jimeh/emacs-builds](https://github.com/jimeh/emacs-builds). Your luck
+may vary.
+
+I have successfully built:
+
+- `emacs-28` release branch
+- `master` branch (Emacs 29.x)
+
+For reference, my machine is:
+
+- 13-inch MacBook Pro (2020), 10th-gen 2.3 GHz Quad-Core Intel Core i7 (4c/8t)
+- macOS Monterey 12.0.1 (21A559)
+- Xcode 13.1 (13A1030d)
+
+Nightly builds are built with GitHub Actions on GitHub-hosted runners, using
+`macos-10.15`.
+
 ## Usage
 
 ```
@@ -76,8 +85,10 @@ Options:
         --[no-]native-comp           Enable/disable native-comp (default: enabled if supported)
         --[no-]native-march          Enable/disable -march=native CFLAG(default: disabled)
         --[no-]native-full-aot       Enable/disable NATIVE_FULL_AOT / Ahead of Time compilation (default: disabled)
+        --[no-]relink-eln-files      Enable/disable re-linking shared libraries in bundled *.eln files (default: enabled)
         --[no-]rsvg                  Enable/disable SVG image support via librsvg (default: enabled)
         --no-titlebar                Apply no-titlebar patch (default: disabled)
+        --posix-spawn                Apply posix-spawn patch (default: disabled)
         --no-frame-refocus           Apply no-frame-refocus patch (default: disabled)
         --[no-]github-auth           Make authenticated GitHub API requests if GITHUB_TOKEN environment variable is set.(default: enabled)
         --work-dir DIR               Specify a working directory where tarballs, sources, and builds will be stored and worked with
@@ -85,7 +96,8 @@ Options:
         --build-name NAME            Override generated build name
         --dist-include x,y,z         List of extra files to copy from Emacs source into build folder/archive (default: COPYING)
         --[no-]archive               Enable/disable creating *.tbz archive (default: enabled)
-        --[no-]archive-keep          Enable/disable keeping source folder for archive (default: disabled)
+        --[no-]archive-keep-build-dir
+                                     Enable/disable keeping source folder for archive (default: disabled)
         --plan FILE                  Follow given plan file, instead of using given git ref/sha
 ```
 

build-emacs-for-macos

@@ -11,6 +11,7 @@ require 'net/http'
 require 'optparse'
 require 'pathname'
 require 'time'
+require 'tmpdir'
 require 'uri'
 require 'yaml'
 
@@ -25,7 +26,7 @@ module Output
     if newline
       warn "==> #{msg}"
     else
-      STDERR.print "==> #{msg}"
+      $stderr.print "==> #{msg}"
     end
   end
 
@@ -34,6 +35,19 @@ module Output
   end
 end
 
+module System
+  include Output
+
+  def run_cmd(*args)
+    out("CMD: #{args.join(' ')}")
+    cmd(*args)
+  end
+
+  def cmd(*args)
+    system(*args) || err("Exit code: #{$CHILD_STATUS.exitstatus}")
+  end
+end
+
 class OS
   def self.version
     @version ||= OSVersion.new
@@ -52,7 +66,7 @@ class OSVersion
   end
 
   def to_s
-    @to_s ||= "#{major}.#{minor}"
+    @to_s ||= major >= 11 ? major.to_s : "#{major}.#{minor}"
   end
 
   def major
@@ -70,6 +84,7 @@ end
 
 class Build
   include Output
+  include System
 
   EMACS_MIRROR_REPO = 'emacs-mirror/emacs'
   DOWNLOAD_URL = 'https://github.com/emacs-mirror/emacs/tarball/%s'
@@ -104,9 +119,10 @@ class Build
     build_dir, app = create_build_dir(app)
 
     handle_native_lisp(app)
-    add_cli_helper(app)
 
-    LibEmbedder.new(app, brew_dir, extra_libs).embed
+    CLIHelperEmbedder.new(app).embed
+    CSourcesEmbedder.new(app, @source_dir).embed
+    LibEmbedder.new(app, brew_dir, extra_libs, options[:relink_eln]).embed
     GccLibEmbedder.new(app, gcc_info).embed if options[:native_comp]
 
     archive_build(build_dir) if options[:archive]
@@ -117,9 +133,10 @@ class Build
   def load_plan(filename)
     plan = YAML.safe_load(File.read(filename), [:Time])
 
+    @ref = plan.dig('source', 'ref')
     @meta = {
       sha: plan.dig('source', 'commit', 'sha'),
-      ref: plan.dig('source', 'ref'),
+      ref: @ref,
       date: plan.dig('source', 'commit', 'date')
     }
 
@@ -131,10 +148,6 @@ class Build
       @archive_filename = plan.dig('output', 'archive')
     end
 
-    if plan.dig('output', 'disk_image') || !plan.dig('output', 'archive')
-      options[:archive] = false
-    end
-
     @build_name = plan.dig('build', 'name') if plan.dig('build', 'name')
   end
 
@@ -155,11 +168,22 @@ class Build
   end
 
   def extra_libs
-    @extra_libs ||= [
+    return @extra_libs if @extra_libs
+
+    libs = [
       File.join(brew_dir, 'opt/expat/lib/libexpat.1.dylib'),
       File.join(brew_dir, 'opt/libiconv/lib/libiconv.2.dylib'),
       File.join(brew_dir, 'opt/zlib/lib/libz.1.dylib')
     ]
+
+    if options[:native_comp]
+      libgcc_s = File.join(
+        brew_dir, 'lib', 'gcc', gcc_info.major_version, 'libgcc_s.1.dylib'
+      )
+      libs << libgcc_s if File.exist?(libgcc_s)
+    end
+
+    @extra_libs = libs
   end
 
   def download_tarball(sha)
@@ -189,7 +213,7 @@ class Build
     end
 
     out "CMD: #{log_args.join(' ')}"
-    system(*args) || err("Exit code: #{$CHILD_STATUS.exitstatus}")
+    cmd(*args)
 
     target
   end
@@ -276,8 +300,6 @@ class Build
         verify_native_comp
         gcc_info.verify_libgccjit
 
-        apply_native_comp_env_setup_patch(source)
-
         ENV['CFLAGS'] = [
           "-I#{File.join(gcc_info.root_dir, 'include')}",
           "-I#{File.join(gcc_info.libgccjit_root_dir, 'include')}",
@@ -292,6 +314,8 @@ class Build
           "-L#{gcc_info.libgccjit_lib_dir}",
           "-I#{File.join(gcc_info.root_dir, 'include')}",
           "-I#{File.join(gcc_info.libgccjit_root_dir, 'include')}",
+          # Ensure library re-linking and code signing will work after building.
+          '-Wl,-headerpad_max_install_names',
           ENV['LDFLAGS']
         ].compact.join(' ')
 
@@ -390,13 +414,13 @@ class Build
     info "Copying \"#{app_name}\" to: #{target_dir}"
 
     FileUtils.mkdir_p(target_dir)
-    FileUtils.cp_r(app, target_dir)
+    cmd('cp', '-a', app, target_dir)
 
     options[:dist_include]&.each do |filename|
       src = File.join(source_dir, filename)
       if File.exist?(src)
         info "Copying \"#{filename}\" to: #{target_dir}"
-        FileUtils.cp_r(src, target_dir)
+        cmd('cp', '-pRL', src, target_dir)
       else
         info "Warning: #{filename} does not exist in #{source_dir}"
       end
@@ -411,20 +435,17 @@ class Build
     contents_dir = File.join(app, 'Contents')
 
     FileUtils.cd(contents_dir) do
-      # Skip creation of symlinks if *.eln files are located under
-      # Resources/native-lisp. Emacs is capable of finding lisp sources and
-      # *.eln cache files without symlinks.
-      return if Dir['Resources/native-lisp/**/*.eln'].any?
-
-      info 'Creating symlinks within Emacs.app needed for native-comp'
-
-      FileUtils.ln_s('Resources/lisp', 'lisp') unless File.exist?('lisp')
-
       source = Dir['MacOS/libexec/emacs/**/eln-cache',
                    'MacOS/lib/emacs/**/native-lisp'].first
 
-      if source.nil?
+      # Skip creation of symlinks if *.eln files are not located in a location
-        err 'Failed to find native-lisp cache directory for symlink creation.'
+      # known to be used by builds which need symlinks and other tweaks.
+      return if source.nil?
+
+      info 'Creating symlinks within Emacs.app needed for native-comp'
+
+      if !File.exist?('lisp') && File.exist?('Resources/lisp')
+        run_cmd('ln', '-s', 'Resources/lisp', 'lisp')
       end
 
       # Check for folder name containing two dots (.), as this causes Apple's
@@ -434,10 +455,9 @@ class Build
       # The workaround for now is to rename the folder replacing the dots with
       # hyphens (-), and create the native-lisp symlink pointing to the new
       # location.
-      if source.match(%r{/.+\..+\..+/})
+      eln_dir = File.dirname(Dir[File.join(source, '**', '*.eln')].first)
-        # Dig deeper into native-lisp directory
-        eln_dir = File.dirname(Dir[File.join(source, '**', '*.eln')].first)
 
+      if eln_dir.match(%r{/.+\..+\..+/})
         base = File.basename(eln_dir)
         parent = File.dirname(eln_dir)
 
@@ -447,13 +467,20 @@ class Build
             new_name = File.join(parent, base.gsub(/\.(.+)\./, '-\\1-'))
 
             info "Renaming: #{old_name} --> #{new_name}"
-            FileUtils.mv(old_name, new_name)
+            cmd('mv', old_name, new_name)
           end
 
           base = File.basename(parent)
           parent = File.dirname(parent)
         end
 
+        eln_parts = eln_dir.match(
+          %r{/(\d+\.\d+\.\d+)/native-lisp/(\d+\.\d+\.\d+-\w+)(?:/.+)?$}i
+        )
+        if eln_parts
+          patch_dump_native_lisp_paths(app, eln_parts[1], eln_parts[2])
+        end
+
         # Find native-lisp directory again after it has been renamed.
         source = Dir['MacOS/libexec/emacs/**/eln-cache',
                      'MacOS/lib/emacs/**/native-lisp'].first
@@ -464,20 +491,31 @@ class Build
       end
 
       target = File.basename(source)
-      FileUtils.ln_s(source, target) unless File.exist?(target)
+      run_cmd('ln', '-s', source, target) unless File.exist?(target)
     end
   end
 
-  def add_cli_helper(app)
+  def patch_dump_native_lisp_paths(app, emacs_version, eln_version)
-    source = File.join(__dir__, 'helper', 'emacs-cli.bash')
+    sanitized_emacs_version = emacs_version.gsub('.', '-')
-    target = File.join(app, 'Contents', 'MacOS', 'bin', 'emacs')
+    sanitized_eln_version = eln_version.gsub('.', '-')
-    dir = File.dirname(target)
 
-    info "Adding \"emacs\" CLI helper to #{dir}"
+    contents_dir = File.join(app, 'Contents')
+    FileUtils.cd(contents_dir) do
+      filename = Dir['MacOS/Emacs.pdmp', 'MacOS/libexec/Emacs.pdmp'].first
+      err "no Emacs.pdmp file found in #{app}" unless filename
+      info 'patching Emacs.pdmp to point at new native-lisp paths'
 
-    FileUtils.mkdir_p(dir)
+      content = File.read(filename, mode: 'rb').gsub(
-    FileUtils.cp(source, target)
+        "lib/emacs/#{emacs_version}/native-lisp/#{eln_version}/",
-    FileUtils.chmod('+w', target)
+        "lib/emacs/#{sanitized_emacs_version}/" \
+        "native-lisp/#{sanitized_eln_version}/"
+      ).gsub(
+        "../native-lisp/#{eln_version}/",
+        "../native-lisp/#{sanitized_eln_version}/"
+      )
+
+      File.open(filename, 'w') { |f| f.write(content) }
+    end
   end
 
   def build_name
@@ -511,10 +549,10 @@ class Build
     if !File.exist?(archive_filename)
       info "Creating #{filename} archive in \"#{target_dir}\"..."
       FileUtils.cd(parent_dir) do
-        system('tar', '-cjf', archive_filename, build)
+        cmd('tar', '-cjf', archive_filename, build)
 
         if options[:archive_keep] == false
-          info "Removeing \"#{build}\" directory from #{parent_dir}"
+          info "Removing \"#{build}\" directory from #{parent_dir}"
           FileUtils.rm_rf(build_dir)
         end
       end
@@ -576,26 +614,6 @@ class Build
     response.body
   end
 
-  def run_cmd(*args)
-    out "CMD: #{args.join(' ')}"
-    system(*args) || err("Exit code: #{$CHILD_STATUS.exitstatus}")
-  end
-
-  def apply_native_comp_env_setup_patch(source)
-    term = 'native-compile-setup-environment-variables'
-    file = 'lisp/emacs-lisp/comp.el'
-    return if `grep '#{term}' '#{file}'`.strip.size.positive?
-
-    template = File.read(
-      File.join(__dir__, 'patches/native-comp-env-setup.diff.erb')
-    )
-    patch = ERB.new(template).result(gcc_info.get_binding)
-    patch_file = File.join(source, 'macos_patches/native-comp-env-setup.diff')
-
-    File.write(patch_file, patch)
-    apply_patch({ file: patch_file }, source)
-  end
-
   def effective_version
     @effective_version ||= begin
       case ref
@@ -603,8 +621,10 @@ class Build
         'emacs-26'
       when /^emacs-27.*/
         'emacs-27'
-      else
+      when /^emacs-28.*/
         'emacs-28'
+      else
+        'emacs-29'
       end
     end
   end
@@ -612,14 +632,14 @@ class Build
   def patches(opts = {})
     p = []
 
-    if %w[emacs-26 emacs-27 emacs-28].include?(effective_version)
+    if %w[emacs-26 emacs-27 emacs-28 emacs-29].include?(effective_version)
       p << {
         url: 'https://github.com/d12frosted/homebrew-emacs-plus/raw/master/' \
              "patches/#{effective_version}/fix-window-role.patch"
       }
     end
 
-    if %w[emacs-27 emacs-28].include?(effective_version)
+    if %w[emacs-27 emacs-28 emacs-29].include?(effective_version)
       p << {
         url: 'https://github.com/d12frosted/homebrew-emacs-plus/raw/master/' \
              "patches/#{effective_version}/system-appearance.patch"
@@ -640,6 +660,15 @@ class Build
       end
     end
 
+    if %w[emacs-28 emacs-29].include?(effective_version)
+      if options[:posix_spawn]
+        p << {
+          url: 'https://github.com/d12frosted/homebrew-emacs-plus/raw/master/' \
+               "patches/#{effective_version}/posix-spawn.patch"
+        }
+      end
+    end
+
     if effective_version == 'emacs-27'
       p << {
         url: 'https://github.com/d12frosted/homebrew-emacs-plus/raw/master/' \
@@ -677,7 +706,14 @@ class Build
       info "Downloading patch: #{patch[:url]}"
       run_cmd('curl', '-L#', patch[:url], '-o', patch_file)
 
-      apply_patch({ file: patch_file }, target)
+      real_patch_url = detect_github_symlink_patch(patch[:url], patch_file)
+      if real_patch_url
+        FileUtils.rm(patch_file)
+        apply_patch({ url: real_patch_url }, target)
+      else
+        apply_patch({ file: patch_file }, target)
+      end
+
     elsif patch[:replace]
       err 'Patch replace input error' unless patch[:replace].size == 3
 
@@ -695,10 +731,35 @@ class Build
       f.close
     end
   end
+
+  # When downloading raw files from GitHub, if the target file is a symlink, it
+  # will return the actual target path of the symlink instead of the content of
+  # the target file. Hence we have to check if the patch file we have downloaded
+  # contains one and only one line, and if so, assume it's a symlink.
+  def detect_github_symlink_patch(original_url, patch_file)
+    lines = []
+
+    # read first two lines
+    File.open(patch_file) do |f|
+      lines << f.gets
+      lines << f.gets
+    end
+
+    # if the file contains more than one line of text, it's not a symlink.
+    return unless lines[1].nil?
+
+    symlink_target = lines[0].strip
+    # Assume patch file content is something along the lines of
+    # "../emacs-28/fix-window-role.patch", hence we resolve it relative to the
+    # original url.
+    info "patch is symlink to #{symlink_target}"
+    URI.join(original_url, symlink_target).to_s
+  end
 end
 
 class AbstractEmbedder
   include Output
+  include System
 
   attr_reader :app
 
@@ -708,30 +769,96 @@ class AbstractEmbedder
     @app = app
   end
 
-  private
-
   def invocation_dir
-    File.join(app, 'Contents', 'MacOS')
+    @invocation_dir ||= File.join(app, 'Contents', 'MacOS')
   end
 
   def bin
-    File.join(invocation_dir, 'Emacs')
+    @bin ||= File.join(invocation_dir, 'Emacs')
+  end
+
+  def bin_dir
+    @bin_dir ||= File.join(invocation_dir, 'bin')
   end
 
   def lib_dir
-    File.join(invocation_dir, 'lib')
+    @lib_dir ||= frameworks_dir
+  end
+
+  def frameworks_dir
+    @frameworks_dir ||= File.join(app, 'Contents', 'Frameworks')
+  end
+
+  def resources_dir
+    @resources_dir ||= File.join(app, 'Contents', 'Resources')
+  end
+end
+
+class CLIHelperEmbedder < AbstractEmbedder
+  def embed
+    source = File.join(__dir__, 'helper', 'emacs-cli.bash')
+    target = File.join(bin_dir, 'emacs')
+    dir = File.dirname(target)
+
+    info 'Adding "emacs" CLI helper to Emacs.app'
+
+    FileUtils.mkdir_p(dir)
+    run_cmd('cp', '-pRL', source, target)
+    run_cmd('chmod', '+w', target)
+  end
+end
+
+class CSourcesEmbedder < AbstractEmbedder
+  PATH_PATCH = <<~ELISP
+    ;; Allow Emacs to find bundled C sources.
+    (setq source-directory (expand-file-name ".."))
+  ELISP
+
+  attr_reader :source_dir
+
+  def initialize(app, source_dir)
+    super(app)
+
+    @source_dir = source_dir
+  end
+
+  def embed
+    info 'Embedding C source files into Emacs.app for documentation purposes'
+
+    src_dir = File.join(source_dir, 'src')
+    Dir[File.join(src_dir, '**', '*.{c,h}')].each do |f|
+      rel = f[src_dir.size + 1..-1]
+      target = File.join(resources_dir, 'src', rel)
+      FileUtils.mkdir_p(File.dirname(target))
+      cmd('cp', '-pRL', f, target)
+    end
+
+    return if File.exist?(site_start_el_file) &&
+              File.read(site_start_el_file).include?(PATH_PATCH)
+
+    File.open(site_start_el_file, 'a') do |f|
+      f.puts("\n#{PATH_PATCH}")
+    end
+  end
+
+  private
+
+  def site_start_el_file
+    @site_start_el_file ||= File.join(resources_dir, 'lisp', 'site-start.el')
   end
 end
 
 class LibEmbedder < AbstractEmbedder
   attr_reader :lib_source
   attr_reader :extra_libs
+  attr_reader :relink_eln_files
 
-  def initialize(app, lib_source, extra_libs = [])
+  def initialize(app, lib_source, extra_libs = [], relink_eln_files = true)
     super(app)
 
     @lib_source = lib_source
     @extra_libs = extra_libs
+    @relink_eln_files = relink_eln_files
   end
 
   def embed
@@ -741,15 +868,20 @@ class LibEmbedder < AbstractEmbedder
     binary ||= bin
 
     FileUtils.cd(File.dirname(app)) do
+      rel_path = Pathname.new(lib_dir).relative_path_from(
+        Pathname.new(File.dirname(binary))
+      ).to_s
+      rpath = File.join('@executable_path', rel_path)
+
+      set_rpath(binary, rpath)
       copy_libs(binary)
       copy_extra_libs(extra_libs, binary) if extra_libs.any?
-      if eln_files.any?
+
+      if relink_eln_files && eln_files.any?
         info "Embedding libraries for #{eln_files.size} *.eln files " \
              'within Emacs.app'
-        rel_path = Pathname.new(lib_dir).relative_path_from(
+
-          Pathname.new(File.dirname(binary))
+        eln_files.each { |f| copy_libs(f) }
-        ).to_s
-        eln_files.each { |f| copy_libs(f, rel_path) }
       end
     end
   end
@@ -757,36 +889,22 @@ class LibEmbedder < AbstractEmbedder
   private
 
   def eln_files
-    @eln_files ||= Dir[
+    @eln_files ||= Dir[File.join(app, 'Contents', '**', '*.eln')]
-      File.join(
-        app, 'Contents', 'Resources', 'native-lisp', '**', '*.eln'
-      ),
-      File.join(
-        app, 'Contents', 'MacOS', 'lib', 'emacs', '**',
-        'native-lisp', '**', '*.eln'
-      ),
-      File.join(
-        app, 'Contents', 'MacOS', 'libexec', 'emacs', '**',
-        'eln-cache', '**', '*.eln'
-      )
-    ]
   end
 
-  def copy_libs(exe, rel_path = nil)
+  def set_rpath(exe, rpath)
-    exe_file = File.basename(exe)
+    return if rpath.nil? || rpath == ''
-    rel_path ||= Pathname.new(lib_dir).relative_path_from(
-      Pathname.new(File.dirname(exe))
-    ).to_s
 
-    rpath = File.join('@executable_path', rel_path)
     rpaths = `otool -l "#{exe}" | grep -A 2 'cmd LC_RPATH' | grep 'path'`
+    return if rpaths.include?(rpath)
 
-    unless rpaths.include?(rpath)
+    while_writable(exe) do
-      while_writable(exe) do
+      cmd('install_name_tool', '-add_rpath', rpath, exe)
-        system('install_name_tool', '-add_rpath',
-               File.join('@executable_path', rel_path), exe)
-      end
     end
+  end
+
+  def copy_libs(exe)
+    exe_file = File.basename(exe)
 
     `otool -L "#{exe}"`.split("\n")[1..-1].each do |line|
       match = line.match(%r{^\s+(.+/(lib[^/ ]+))\s})
@@ -794,41 +912,37 @@ class LibEmbedder < AbstractEmbedder
 
       while_writable(exe) do
         if match[2] == exe_file
-          system('install_name_tool', '-id',
+          cmd('install_name_tool', '-id',
-                 File.join('@executable_path', rel_path, match[2].to_s), exe)
+              File.join('@rpath', match[2].to_s), exe)
         else
-          system('install_name_tool', '-change', match[1],
+          cmd('install_name_tool', '-change', match[1],
-                 File.join('@executable_path', rel_path, match[2].to_s), exe)
+              File.join('@rpath', match[2].to_s), exe)
         end
       end
 
       next if match[2] == exe_file || File.exist?(File.join(lib_dir, match[2]))
 
       FileUtils.mkdir_p(lib_dir)
-      FileUtils.cp(match[1], lib_dir)
+      cmd('cp', '-pRL', match[1], lib_dir)
-      copy_libs(File.join(lib_dir, match[2].to_s), rel_path)
+      copy_libs(File.join(lib_dir, match[2].to_s))
     end
   end
 
-  def copy_extra_libs(extra_libs, exe, rel_path = nil)
+  def copy_extra_libs(extra_libs, exe)
-    rel_path ||= Pathname.new(lib_dir).relative_path_from(
-      Pathname.new(File.dirname(exe))
-    ).to_s
-
     extra_libs.each do |lib|
       lib_file = File.basename(lib)
       target = "#{lib_dir}/#{lib_file}"
       unless File.exist?(target)
         FileUtils.mkdir_p(lib_dir)
-        FileUtils.cp(lib, lib_dir)
+        cmd('cp', '-pRL', lib, lib_dir)
       end
 
       while_writable(target) do
-        system('install_name_tool', '-id',
+        cmd('install_name_tool', '-id',
-               File.join('@executable_path', rel_path, lib_file), target)
+            File.join('@rpath', lib_file), target)
       end
 
-      copy_libs(target, rel_path)
+      copy_libs(target)
     end
   end
 
@@ -837,7 +951,7 @@ class LibEmbedder < AbstractEmbedder
     File.chmod(0o775, file)
     yield
   ensure
-    File.chmod(mode, file)
+    File.chmod(mode, file) if File.exist?(file)
   end
 end
 
@@ -862,28 +976,65 @@ class GccLibEmbedder < AbstractEmbedder
     end
 
     FileUtils.mkdir_p(File.dirname(target_dir))
-    FileUtils.cp_r(source_dir, target_dir)
+    run_cmd('cp', '-pRL', source_dir, target_dir)
     FileUtils.rm(Dir[File.join(target_dir, '**', '.DS_Store')], force: true)
-    FileUtils.chmod_R('u+w', target_dir)
+    run_cmd('chmod', '-R', 'u+w', target_dir)
-    FileUtils.mv(source_darwin_dir, target_darwin_dir)
+    if source_darwin_dir != target_darwin_dir
+      run_cmd('mv', source_darwin_dir, target_darwin_dir)
+    end
+
+    env_setup = ERB.new(NATIVE_COMP_ENV_VAR_TPL).result(gcc_info.get_binding)
+    return if File.exist?(site_start_el_file) &&
+              File.read(site_start_el_file).include?(env_setup)
+
+    File.open(site_start_el_file, 'a') do |f|
+      f.puts("\n#{env_setup}")
+    end
   end
 
   private
 
+  NATIVE_COMP_ENV_VAR_TPL = <<~ELISP
+    ;; Set LIBRARY_PATH to point at bundled GCC and Xcode Command Line Tools to
+    ;; ensure native-comp works.
+    (when (and (eq system-type 'darwin)
+               (string-match-p "\\.app\\/Contents\\/MacOS\\/?$"
+                               invocation-directory))
+      (let* ((library-path-env (getenv "LIBRARY_PATH"))
+             (devtools-dir
+              "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib")
+             (gcc-dir (expand-file-name
+                       "<%= app_bundle_relative_lib_dir %>"
+                       invocation-directory))
+             (darwin-dir (expand-file-name
+                          "<%= app_bundle_relative_darwin_lib_dir %>"
+                          invocation-directory))
+             (lib-paths (list)))
+
+        (if library-path-env
+            (push library-path-env lib-paths))
+        (if (file-directory-p devtools-dir)
+            (push devtools-dir lib-paths))
+        (push darwin-dir lib-paths)
+        (push gcc-dir lib-paths)
+
+        (setenv "LIBRARY_PATH" (mapconcat 'identity lib-paths ":"))))
+  ELISP
+
   def embedded?
     Dir[File.join(target_dir, 'libgcc*')].any?
   end
 
   def target_dir
-    File.join(invocation_dir, gcc_info.relative_lib_dir)
+    File.join(lib_dir, gcc_info.relative_lib_dir)
   end
 
   def source_darwin_dir
-    File.join(invocation_dir, gcc_info.relative_darwin_lib_dir)
+    File.join(lib_dir, gcc_info.relative_darwin_lib_dir)
   end
 
   def target_darwin_dir
-    File.join(invocation_dir, gcc_info.sanitized_relative_darwin_lib_dir)
+    File.join(lib_dir, gcc_info.sanitized_relative_darwin_lib_dir)
   end
 
   def source_dir
@@ -893,6 +1044,10 @@ class GccLibEmbedder < AbstractEmbedder
   def relative_dir(path, root)
     Pathname.new(path).relative_path_from(Pathname.new(root)).to_s
   end
+
+  def site_start_el_file
+    @site_start_el_file ||= File.join(resources_dir, 'lisp', 'site-start.el')
+  end
 end
 
 class GccInfo
@@ -914,7 +1069,7 @@ class GccInfo
   end
 
   def relative_lib_dir
-    @relative_lib_dir ||= relative_dir(lib_dir, root_dir)
+    @relative_lib_dir ||= relative_dir(lib_dir, File.join(root_dir, 'lib'))
   end
 
   def darwin_lib_dir
@@ -929,7 +1084,9 @@ class GccInfo
   end
 
   def relative_darwin_lib_dir
-    @relative_darwin_lib_dir ||= relative_dir(darwin_lib_dir, root_dir)
+    @relative_darwin_lib_dir ||= relative_dir(
+      darwin_lib_dir, File.join(root_dir, 'lib')
+    )
   end
 
   # Sanitize folder name with full "MAJOR.MINOR.PATCH" version number to just
@@ -939,7 +1096,21 @@ class GccInfo
   def sanitized_relative_darwin_lib_dir
     @sanitized_relative_darwin_lib_dir ||= File.join(
       File.dirname(relative_darwin_lib_dir),
-      File.basename(relative_darwin_lib_dir).split('.').first
+      File.basename(relative_darwin_lib_dir).gsub('.', '_')
+    )
+  end
+
+  def app_bundle_relative_lib_dir
+    @app_bundle_relative_lib_dir ||= relative_dir(
+      File.join(embedder.lib_dir, relative_lib_dir),
+      embedder.invocation_dir
+    )
+  end
+
+  def app_bundle_relative_darwin_lib_dir
+    @app_bundle_relative_darwin_lib_dir ||= relative_dir(
+      File.join(embedder.lib_dir, sanitized_relative_darwin_lib_dir),
+      embedder.invocation_dir
     )
   end
 
@@ -986,6 +1157,10 @@ class GccInfo
 
   private
 
+  def embedder
+    @embedder ||= AbstractEmbedder.new(Dir.mktmpdir(['Emacs', '.app']))
+  end
+
   def relative_dir(path, root)
     Pathname.new(path).relative_path_from(Pathname.new(root)).to_s
   end
@@ -995,6 +1170,7 @@ if __FILE__ == $PROGRAM_NAME
   cli_options = {
     work_dir: File.expand_path(__dir__),
     native_full_aot: false,
+    relink_eln: true,
     native_march: false,
     parallel: Etc.nprocessors,
     rsvg: true,
@@ -1052,6 +1228,12 @@ if __FILE__ == $PROGRAM_NAME
         cli_options[:native_full_aot] = v
       end
 
+      opts.on('--[no-]relink-eln-files',
+              'Enable/disable re-linking shared libraries in bundled *.eln ' \
+              'files (default: enabled)') do |v|
+        cli_options[:relink_eln] = v
+      end
+
       opts.on('--[no-]rsvg',
               'Enable/disable SVG image support via librsvg ' \
               '(default: enabled)') do |v|
@@ -1062,6 +1244,10 @@ if __FILE__ == $PROGRAM_NAME
         cli_options[:no_titlebar] = true
       end
 
+      opts.on('--posix-spawn', 'Apply posix-spawn patch (default: disabled)') do
+        cli_options[:posix_spawn] = true
+      end
+
       opts.on('--no-frame-refocus',
               'Apply no-frame-refocus patch (default: disabled)') do
         cli_options[:no_frame_refocus] = true

go.mod

@@ -13,6 +13,7 @@ require (
 	github.com/hashicorp/go-hclog v0.16.1
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/hashicorp/go-retryablehttp v0.7.0 // indirect
+	github.com/hexops/gotextdiff v1.0.3
 	github.com/jimeh/undent v1.1.0
 	github.com/mattn/go-isatty v0.0.13 // indirect
 	github.com/mitchellh/gon v0.2.3

go.sum

@@ -136,6 +136,8 @@ github.com/hashicorp/go-retryablehttp v0.7.0/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/hcl/v2 v2.0.0/go.mod h1:oVVDG71tEinNGYCxinCYadcmKU9bglqW9pV3txagJ90=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jimeh/undent v1.1.0 h1:Cge7P4Ws6buy0SVuHBluY/aOKdFuJUMzoJswfAHZ4zE=

patches/native-comp-env-setup.diff.erb

@@ -1,57 +0,0 @@
-diff --git a/lisp/emacs-lisp/comp.el b/lisp/emacs-lisp/comp.el
-index 8c638312b0..87af889ef4 100644
---- a/lisp/emacs-lisp/comp.el
-+++ b/lisp/emacs-lisp/comp.el
-@@ -4215,6 +4215,52 @@ native-compile-async
-   (let ((load (not (not load))))
-     (native--compile-async files recursively load selector)))
- 
-+;;;###autoload
-+(defun native-compile-setup-environment-variables (&rest _args)
-+  "Ensure LIBRARY_PATH is set correctly when libgccjit is bundled."
-+  (when (and (eq system-type 'darwin)
-+             (string-match-p "\.app\/Contents\/MacOS\/?$"
-+                             invocation-directory))
-+    (let* ((library-path-env (getenv "LIBRARY_PATH"))
-+           (devtools-dir
-+            "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib")
-+           (gcc-dir (expand-file-name
-+                     "<%= relative_lib_dir %>"
-+                     invocation-directory))
-+           (darwin-dir (expand-file-name
-+                        "<%= sanitized_relative_darwin_lib_dir %>"
-+                        invocation-directory))
-+           (lib-paths (list)))
-+
-+      (if library-path-env
-+          (push library-path-env lib-paths))
-+      (if (file-directory-p devtools-dir)
-+          (push devtools-dir lib-paths))
-+      (push darwin-dir lib-paths)
-+      (push gcc-dir lib-paths)
-+
-+      (setenv "LIBRARY_PATH" (mapconcat 'identity lib-paths ":"))))
-+
-+  ;; Remove advice, as it only needs to run once.
-+  (advice-remove 'native-compile
-+                 'native-compile-setup-environment-variables)
-+  (advice-remove 'comp--native-compile
-+                 'native-compile-setup-environment-variables)
-+  (advice-remove 'native-compile-async
-+                 'native-compile-setup-environment-variables)
-+  (advice-remove 'native--compile-async
-+                 'native-compile-setup-environment-variables))
-+
-+;; Ensure environment setup runs before any native compilation.
-+(advice-add 'native-compile :before
-+            'native-compile-setup-environment-variables)
-+(advice-add 'comp--native-compile :before
-+            'native-compile-setup-environment-variables)
-+(advice-add 'native-compile-async :before
-+            'native-compile-setup-environment-variables)
-+(advice-add 'native--compile-async :before
-+            'native-compile-setup-environment-variables)
-+
- (provide 'comp)
- 
- ;; LocalWords: limplified limplified limplification limplify Limple LIMPLE libgccjit elc eln

pkg/cask/live_check.go

@@ -0,0 +1,13 @@
+package cask
+
+type LiveCheck struct {
+	Cask    string           `json:"cask"`
+	Version LiveCheckVersion `json:"version"`
+}
+
+type LiveCheckVersion struct {
+	Current           string `json:"current"`
+	Latest            string `json:"latest"`
+	Outdated          bool   `json:"outdated"`
+	NewerThanUpstream bool   `json:"newer_than_upstream"`
+}

pkg/cask/release_info.go

@@ -0,0 +1,66 @@
+package cask
+
+import (
+	"sort"
+	"strings"
+)
+
+type ReleaseInfo struct {
+	Name    string
+	Version string
+	Assets  map[string]*ReleaseAsset
+}
+
+func (s *ReleaseInfo) Asset(needles ...string) *ReleaseAsset {
+	if len(needles) == 1 {
+		if a, ok := s.Assets[needles[0]]; ok {
+			return a
+		}
+	}
+
+	// Dirty and inefficient way to ensure assets are searched in a predictable
+	// order.
+	var assets []*ReleaseAsset
+	for _, a := range s.Assets {
+		assets = append(assets, a)
+	}
+	sort.SliceStable(assets, func(i, j int) bool {
+		return assets[i].Filename < assets[j].Filename
+	})
+
+	for _, a := range assets {
+		for _, needle := range needles {
+			if !strings.Contains(a.Filename, needle) {
+				continue
+			}
+		}
+
+		return a
+	}
+
+	return nil
+}
+
+func (s *ReleaseInfo) DownloadURL(needles ...string) string {
+	a := s.Asset(needles...)
+	if a == nil {
+		return ""
+	}
+
+	return a.DownloadURL
+}
+
+func (s *ReleaseInfo) SHA256(needles ...string) string {
+	a := s.Asset(needles...)
+	if a == nil {
+		return ""
+	}
+
+	return a.SHA256
+}
+
+type ReleaseAsset struct {
+	Filename    string
+	DownloadURL string
+	SHA256      string
+}

pkg/cask/update.go

@@ -0,0 +1,493 @@
+package cask
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/template"
+	"time"
+
+	"github.com/google/go-github/v35/github"
+	"github.com/hashicorp/go-hclog"
+	"github.com/hexops/gotextdiff"
+	"github.com/hexops/gotextdiff/myers"
+	"github.com/hexops/gotextdiff/span"
+	"github.com/jimeh/build-emacs-for-macos/pkg/gh"
+	"github.com/jimeh/build-emacs-for-macos/pkg/release"
+	"github.com/jimeh/build-emacs-for-macos/pkg/repository"
+)
+
+// Error vars
+var (
+	Err                = errors.New("cask")
+	ErrReleaseNotFound = fmt.Errorf("%w: release not found", Err)
+
+	ErrFailedSHA256Parse = fmt.Errorf(
+		"%w: failed to parse SHA256 from asset", Err,
+	)
+	ErrFailedSHA256Download = fmt.Errorf(
+		"%w: failed to download SHA256 asset", Err,
+	)
+	ErrNoTapOrOutput = fmt.Errorf(
+		"%w: no tap repository or output directory specified", Err,
+	)
+)
+
+type UpdateOptions struct {
+	// BuildsRepo is the GitHub repository containing binary releases.
+	BuildsRepo *repository.Repository
+
+	// TapRepo is the GitHub repository to update the casks in.
+	TapRepo *repository.Repository
+
+	// Ref is the git ref to apply cask updates on top of. Default branch will
+	// be used if empty.
+	Ref string
+
+	// OutputDir specifies a directory to write cask files to. When set, tap
+	// repository is ignored and no changes will be committed directly against
+	// any specified tap repository.
+	OutputDir string
+
+	// Force update will ignore the outdated live check flag, and process all
+	// casks regardless. But it will only update the cask in question if the
+	// resulting output cask is different.
+	Force bool
+
+	// TemplatesDir is the directory where cask templates are located.
+	TemplatesDir string
+
+	LiveChecks []*LiveCheck
+
+	GithubToken string
+}
+
+type Updater struct {
+	BuildsRepo   *repository.Repository
+	TapRepo      *repository.Repository
+	Ref          string
+	OutputDir    string
+	TemplatesDir string
+
+	logger hclog.Logger
+	gh     *github.Client
+}
+
+func Update(ctx context.Context, opts *UpdateOptions) error {
+	updater := &Updater{
+		BuildsRepo:   opts.BuildsRepo,
+		TapRepo:      opts.TapRepo,
+		Ref:          opts.Ref,
+		OutputDir:    opts.OutputDir,
+		TemplatesDir: opts.TemplatesDir,
+		logger:       hclog.FromContext(ctx).Named("cask"),
+		gh:           gh.New(ctx, opts.GithubToken),
+	}
+
+	for _, chk := range opts.LiveChecks {
+		err := updater.Update(ctx, chk, opts.Force)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *Updater) Update(
+	ctx context.Context,
+	chk *LiveCheck,
+	force bool,
+) error {
+	if s.TapRepo == nil && s.OutputDir == "" {
+		return ErrNoTapOrOutput
+	}
+
+	if !force && !chk.Version.Outdated {
+		s.logger.Info("skipping", "cask", chk.Cask, "reason", "up to date")
+
+		return nil
+	}
+
+	newCaskContent, err := s.renderCask(ctx, chk)
+	if err != nil {
+		return err
+	}
+
+	caskFile := chk.Cask + ".rb"
+
+	if s.OutputDir != "" {
+		_, err = s.putFile(
+			ctx, chk, filepath.Join(s.OutputDir, caskFile), newCaskContent,
+		)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	}
+
+	_, err = s.putRepoFile(
+		ctx, s.TapRepo, s.Ref, chk,
+		filepath.Join("Casks", caskFile), newCaskContent,
+	)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Updater) putFile(
+	ctx context.Context,
+	chk *LiveCheck,
+	filename string,
+	content []byte,
+) (bool, error) {
+	parent := filepath.Dir(filename)
+	s.logger.Info("processing cask update",
+		"output-directory", parent, "cask", chk.Cask, "file", filename,
+	)
+
+	err := os.MkdirAll(parent, 0o755)
+	if err != nil {
+		return false, err
+	}
+
+	existingContent, err := os.ReadFile(filename)
+	if err != nil && !os.IsNotExist(err) {
+		return false, err
+	}
+
+	infoMsg := "creating cask"
+
+	if !os.IsNotExist(err) {
+		infoMsg = "updating cask"
+		if bytes.Equal(existingContent, content) {
+			s.logger.Info(
+				"skip update: no change to cask content",
+				"cask", chk.Cask, "file", filename,
+			)
+
+			s.logger.Debug(
+				"cask content",
+				"file", filename, "content", string(content),
+			)
+
+			return false, nil
+		}
+	}
+
+	existing := string(existingContent)
+	edits := myers.ComputeEdits(
+		span.URIFromPath(filename), existing, string(content),
+	)
+	diff := fmt.Sprint(gotextdiff.ToUnified(
+		filename, filename, existing, edits,
+	))
+
+	s.logger.Info(
+		infoMsg,
+		"cask", chk.Cask, "version", chk.Version.Latest, "file", filename,
+		"diff", diff,
+	)
+
+	s.logger.Debug(
+		"cask content",
+		"file", filename, "content", string(content),
+	)
+
+	err = os.WriteFile(filename, content, 0o644) //nolint:gosec
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+func (s *Updater) putRepoFile(
+	ctx context.Context,
+	repo *repository.Repository,
+	ref string,
+	chk *LiveCheck,
+	filename string,
+	content []byte,
+) (bool, error) {
+	s.logger.Info("processing cask update",
+		"tap-repo", repo.Source, "cask", chk.Cask, "file", filename,
+	)
+	repoContent, _, resp, err := s.gh.Repositories.GetContents(
+		ctx, repo.Owner(), repo.Name(), filename,
+		&github.RepositoryContentGetOptions{Ref: ref},
+	)
+	if err != nil && resp.StatusCode != http.StatusNotFound {
+		return false, err
+	}
+
+	if resp.StatusCode == http.StatusNotFound {
+		err := s.createRepoFile(ctx, repo, chk, filename, content)
+		if err != nil {
+			return false, err
+		}
+	} else {
+		_, err := s.updateRepoFile(
+			ctx, repo, repoContent, chk, filename, content,
+		)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	return true, nil
+}
+
+func (s *Updater) createRepoFile(
+	ctx context.Context,
+	repo *repository.Repository,
+	chk *LiveCheck,
+	filename string,
+	content []byte,
+) error {
+	commitMsg := fmt.Sprintf(
+		"feat(cask): create %s with version %s",
+		chk.Cask, chk.Version.Latest,
+	)
+
+	edits := myers.ComputeEdits(
+		span.URIFromPath(filename), "", string(content),
+	)
+	diff := fmt.Sprint(gotextdiff.ToUnified(filename, filename, "", edits))
+
+	s.logger.Info(
+		"creating cask",
+		"cask", chk.Cask, "version", chk.Version.Latest, "file", filename,
+		"diff", diff,
+	)
+	s.logger.Debug(
+		"cask content",
+		"file", filename, "content", string(content),
+	)
+	contResp, _, err := s.gh.Repositories.CreateFile(
+		ctx, repo.Owner(), repo.Name(), filename,
+		&github.RepositoryContentFileOptions{
+			Message: &commitMsg,
+			Content: content,
+		},
+	)
+	if err != nil {
+		return err
+	}
+
+	s.logger.Info(
+		"new commit created",
+		"commit", contResp.GetSHA(), "message", contResp.GetMessage(),
+		"url", contResp.Commit.GetHTMLURL(),
+	)
+
+	return nil
+}
+
+func (s *Updater) updateRepoFile(
+	ctx context.Context,
+	repo *repository.Repository,
+	repoContent *github.RepositoryContent,
+	chk *LiveCheck,
+	filename string,
+	content []byte,
+) (bool, error) {
+	existingContent, err := repoContent.GetContent()
+	if err != nil {
+		return false, err
+	}
+
+	if existingContent == string(content) {
+		s.logger.Info(
+			"skip update: no change to cask content",
+			"cask", chk.Cask, "file", filename,
+		)
+
+		return false, nil
+	}
+
+	sha := repoContent.GetSHA()
+
+	commitMsg := fmt.Sprintf(
+		"feat(cask): update %s to version %s",
+		chk.Cask, chk.Version.Latest,
+	)
+
+	edits := myers.ComputeEdits(
+		span.URIFromPath(filename), existingContent, string(content),
+	)
+	diff := fmt.Sprint(gotextdiff.ToUnified(
+		filename, filename, existingContent, edits,
+	))
+
+	s.logger.Info(
+		"updating cask",
+		"cask", chk.Cask, "version", chk.Version.Latest, "file", filename,
+		"diff", diff,
+	)
+	s.logger.Debug(
+		"cask content",
+		"file", filename, "content", string(content),
+	)
+
+	contResp, _, err := s.gh.Repositories.CreateFile(
+		ctx, repo.Owner(), repo.Name(), filename,
+		&github.RepositoryContentFileOptions{
+			Message: &commitMsg,
+			Content: content,
+			SHA:     &sha,
+		},
+	)
+	if err != nil {
+		return false, err
+	}
+
+	s.logger.Info(
+		"new commit created",
+		"commit", contResp.GetSHA(), "message", contResp.GetMessage(),
+		"url", contResp.Commit.GetHTMLURL(),
+	)
+
+	return true, nil
+}
+
+func (s *Updater) renderCask(
+	ctx context.Context,
+	chk *LiveCheck,
+) ([]byte, error) {
+	releaseName, err := release.VersionToName(chk.Version.Latest)
+	if err != nil {
+		return nil, err
+	}
+
+	s.logger.Info("fetching release details",
+		"release", releaseName, "repo", s.BuildsRepo.URL(),
+	)
+	release, resp, err := s.gh.Repositories.GetReleaseByTag(
+		ctx, s.BuildsRepo.Owner(), s.BuildsRepo.Name(), releaseName,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if release == nil || resp.StatusCode == http.StatusNotFound {
+		return nil, fmt.Errorf("%w: %s", ErrReleaseNotFound, releaseName)
+	}
+
+	info := &ReleaseInfo{
+		Name:    release.GetName(),
+		Version: chk.Version.Latest,
+		Assets:  map[string]*ReleaseAsset{},
+	}
+
+	s.logger.Info("processing release assets")
+	for _, asset := range release.Assets {
+		filename := asset.GetName()
+		s.logger.Debug("processing asset", "filename", filename)
+
+		if strings.HasSuffix(filename, ".sha256") {
+			filename = strings.TrimSuffix(filename, ".sha256")
+		}
+
+		if _, ok := info.Assets[filename]; !ok {
+			info.Assets[filename] = &ReleaseAsset{
+				Filename: filename,
+			}
+		}
+
+		if strings.HasSuffix(asset.GetName(), ".sha256") {
+			s.logger.Debug("downloading *.sha256 asset to extract SHA256 value")
+			r, err2 := s.downloadAssetContent(ctx, asset)
+			if err2 != nil {
+				return nil, err2
+			}
+			defer r.Close()
+
+			content := make([]byte, 64)
+			n, err2 := io.ReadAtLeast(r, content, 64)
+			if err2 != nil {
+				return nil, err2
+			}
+			if n < 64 {
+				return nil, fmt.Errorf(
+					"%w: %s", ErrFailedSHA256Parse, asset.GetName(),
+				)
+			}
+
+			sha := string(content)[0:64]
+			if sha == "" {
+				return nil, fmt.Errorf(
+					"%w: %s", ErrFailedSHA256Parse, asset.GetName(),
+				)
+			}
+
+			info.Assets[filename].SHA256 = sha
+		} else {
+			info.Assets[filename].DownloadURL = asset.GetBrowserDownloadURL()
+		}
+	}
+
+	templateFile := filepath.Join(s.TemplatesDir, chk.Cask+".rb.tpl")
+	tplContent, err := os.ReadFile(templateFile)
+	if err != nil {
+		return nil, err
+	}
+
+	tpl, err := template.New(chk.Cask).Parse(string(tplContent))
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	err = tpl.Execute(&buf, info)
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func (s *Updater) downloadAssetContent(
+	ctx context.Context,
+	asset *github.ReleaseAsset,
+) (io.ReadCloser, error) {
+	httpClient := &http.Client{Timeout: 60 * time.Second}
+
+	r, downloadURL, err := s.gh.Repositories.DownloadReleaseAsset(
+		ctx, s.BuildsRepo.Owner(), s.BuildsRepo.Name(),
+		asset.GetID(), httpClient,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if r == nil && downloadURL != "" {
+		req, err := http.NewRequestWithContext(ctx, "GET", downloadURL, nil)
+		if err != nil {
+			return nil, err
+		}
+
+		//nolint:bodyclose
+		resp, err := httpClient.Do(req)
+		if err != nil {
+			return nil, err
+		}
+		r = resp.Body
+	}
+
+	if r == nil {
+		return nil, fmt.Errorf(
+			"%s: %s", ErrFailedSHA256Download, asset.GetName(),
+		)
+	}
+
+	return r, nil
+}

pkg/cli/cask.go

@@ -0,0 +1,158 @@
+package cli
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+
+	"github.com/jimeh/build-emacs-for-macos/pkg/cask"
+	"github.com/jimeh/build-emacs-for-macos/pkg/repository"
+	cli2 "github.com/urfave/cli/v2"
+)
+
+type caskOptions struct {
+	BuildsRepo  *repository.Repository
+	GithubToken string
+}
+
+func caskCmd() *cli2.Command {
+	tokenDefaultText := ""
+	if len(os.Getenv("GITHUB_TOKEN")) > 0 {
+		tokenDefaultText = "***"
+	}
+
+	return &cli2.Command{
+		Name:  "cask",
+		Usage: "manage Homebrew Casks",
+		Flags: []cli2.Flag{
+			&cli2.StringFlag{
+				Name:    "builds-repository",
+				Aliases: []string{"builds-repo", "b"},
+				Usage:   "owner/name of GitHub repo for containing builds",
+				EnvVars: []string{"EMACS_BUILDS_REPOSITORY"},
+				Value:   "jimeh/emacs-builds",
+			},
+			&cli2.StringFlag{
+				Name:        "github-token",
+				Usage:       "GitHub API Token",
+				EnvVars:     []string{"GITHUB_TOKEN"},
+				DefaultText: tokenDefaultText,
+				Required:    true,
+			},
+		},
+		Subcommands: []*cli2.Command{
+			caskUpdateCmd(),
+		},
+	}
+}
+
+func caskActionWrapper(
+	f func(*cli2.Context, *Options, *caskOptions) error,
+) func(*cli2.Context) error {
+	return actionWrapper(func(c *cli2.Context, opts *Options) error {
+		rOpts := &caskOptions{
+			GithubToken: c.String("github-token"),
+		}
+
+		if r := c.String("builds-repository"); r != "" {
+			var err error
+			rOpts.BuildsRepo, err = repository.NewGitHub(r)
+			if err != nil {
+				return err
+			}
+		}
+
+		return f(c, opts, rOpts)
+	})
+}
+
+func caskUpdateCmd() *cli2.Command {
+	return &cli2.Command{
+		Name:      "update",
+		Usage:     "update casks based on brew livecheck result in JSON format",
+		ArgsUsage: "<livecheck.json>",
+		Flags: []cli2.Flag{
+			&cli2.StringFlag{
+				Name: "ref",
+				Usage: "git ref to create/update casks on top of in the " +
+					"tap repository",
+				EnvVars: []string{"GITHUB_REF"},
+			},
+			&cli2.StringFlag{
+				Name:    "output",
+				Aliases: []string{"o"},
+				Usage:   "directory to write cask files to",
+			},
+			&cli2.StringFlag{
+				Name:    "tap-repository",
+				Aliases: []string{"tap"},
+				Usage: "owner/name of GitHub repo for Homebrew Tap to " +
+					"commit changes to if --output is not set",
+				EnvVars: []string{"GITHUB_REPOSITORY"},
+			},
+			&cli2.StringFlag{
+				Name:     "templates-dir",
+				Aliases:  []string{"t"},
+				Usage:    "path to directory of cask templates",
+				EnvVars:  []string{"CASK_TEMPLATE_DIR"},
+				Required: true,
+			},
+			&cli2.BoolFlag{
+				Name:    "force",
+				Aliases: []string{"f"},
+				Usage: "force update file even if livecheck has it marked " +
+					"as not outdated (does not force update if cask " +
+					"content is unchanged)",
+				Value: false,
+			},
+		},
+		Action: caskActionWrapper(caskUpdateAction),
+	}
+}
+
+func caskUpdateAction(
+	c *cli2.Context,
+	_ *Options,
+	cOpts *caskOptions,
+) error {
+	updateOpts := &cask.UpdateOptions{
+		BuildsRepo:   cOpts.BuildsRepo,
+		GithubToken:  cOpts.GithubToken,
+		Ref:          c.String("ref"),
+		OutputDir:    c.String("output"),
+		Force:        c.Bool("force"),
+		TemplatesDir: c.String("templates-dir"),
+	}
+
+	if r := c.String("tap-repository"); r != "" {
+		var err error
+		updateOpts.TapRepo, err = repository.NewGitHub(r)
+		if err != nil {
+			return err
+		}
+	}
+
+	arg := c.Args().First()
+	if arg == "" {
+		return errors.New("no livecheck argument given")
+	}
+
+	if arg == "-" {
+		err := json.NewDecoder(c.App.Reader).Decode(&updateOpts.LiveChecks)
+		if err != nil {
+			return err
+		}
+	} else {
+		f, err := os.Open(arg)
+		if err != nil {
+			return err
+		}
+
+		err = json.NewDecoder(f).Decode(&updateOpts.LiveChecks)
+		if err != nil {
+			return err
+		}
+	}
+
+	return cask.Update(c.Context, updateOpts)
+}

pkg/cli/cli.go

@@ -46,9 +46,11 @@ func New(version, commit, date string) *CLI {
 			Commands: []*cli2.Command{
 				planCmd(),
 				signCmd(),
+				signFilesCmd(),
 				notarizeCmd(),
 				packageCmd(),
 				releaseCmd(),
+				caskCmd(),
 				{
 					Name:    "version",
 					Usage:   "print the version",

pkg/cli/notarize.go

@@ -52,7 +52,7 @@ func notarizeCmd() *cli2.Command {
 	}
 }
 
-func notarizeAction(c *cli2.Context, opts *Options) error {
+func notarizeAction(c *cli2.Context, _ *Options) error {
 	options := &notarize.Options{
 		File:     c.Args().Get(0),
 		BundleID: c.String("bundle-id"),

pkg/cli/plan.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 
@@ -37,6 +38,12 @@ func planCmd() *cli2.Command {
 				Name:  "sha",
 				Usage: "override commit SHA of specified git branch/tag",
 			},
+			&cli2.StringFlag{
+				Name:    "format",
+				Aliases: []string{"f"},
+				Usage:   "output format of build plan (yaml or json)",
+				Value:   "yaml",
+			},
 			&cli2.StringFlag{
 				Name: "output",
 				Usage: "output filename to write plan to instead of printing " +
@@ -89,7 +96,7 @@ func planAction(c *cli2.Context, opts *Options) error {
 		GithubToken:   c.String("github-token"),
 	}
 
-	if c.String("test-build-type") == "draft" {
+	if c.String("test-release-type") == "draft" {
 		planOpts.TestBuildType = plan.Draft
 	}
 
@@ -102,7 +109,18 @@ func planAction(c *cli2.Context, opts *Options) error {
 		return err
 	}
 
-	planYAML, err := p.YAML()
+	format := c.String("format")
+	var plan string
+	switch format {
+	case "yaml", "yml":
+		format = "yaml"
+		plan, err = p.YAML()
+	case "json":
+		format = "json"
+		plan, err = p.JSON()
+	default:
+		err = fmt.Errorf("--format must be yaml or json")
+	}
 	if err != nil {
 		return err
 	}
@@ -111,7 +129,7 @@ func planAction(c *cli2.Context, opts *Options) error {
 	out = os.Stdout
 	if f := c.String("output"); f != "" {
 		logger.Info("writing plan", "file", f)
-		logger.Debug("content", "yaml", planYAML)
+		logger.Debug("content", format, plan)
 		out, err = os.Create(f)
 		if err != nil {
 			return err
@@ -119,7 +137,7 @@ func planAction(c *cli2.Context, opts *Options) error {
 		defer out.Close()
 	}
 
-	_, err = out.WriteString(planYAML)
+	_, err = out.WriteString(plan)
 	if err != nil {
 		return err
 	}

pkg/cli/release.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -42,7 +43,7 @@ func releaseCmd() *cli2.Command {
 				Usage: "owner/name of GitHub repo to check for release, " +
 					"ignored if a plan is provided",
 				EnvVars: []string{"GITHUB_REPOSITORY"},
-				Value:   "jimeh/emacs-builds",
+				Value:   "",
 			},
 			&cli2.StringFlag{
 				Name:    "name",
@@ -60,6 +61,7 @@ func releaseCmd() *cli2.Command {
 		Subcommands: []*cli2.Command{
 			releaseCheckCmd(),
 			releasePublishCmd(),
+			releaseBulkCmd(),
 		},
 	}
 }
@@ -106,7 +108,7 @@ func releaseCheckCmd() *cli2.Command {
 
 func releaseCheckAction(
 	c *cli2.Context,
-	opts *Options,
+	_ *Options,
 	rOpts *releaseOptions,
 ) error {
 	rlsOpts := &release.CheckOptions{
@@ -151,6 +153,12 @@ func releasePublishCmd() *cli2.Command {
 					"specified",
 				Value: "",
 			},
+			&cli2.BoolFlag{
+				Name: "asset-size-check",
+				Usage: "Do not replace existing asset files if local and " +
+					"remote file sizes match.",
+				Value: false,
+			},
 		},
 		Action: releaseActionWrapper(releasePublishAction),
 	}
@@ -158,16 +166,17 @@ func releasePublishCmd() *cli2.Command {
 
 func releasePublishAction(
 	c *cli2.Context,
-	opts *Options,
+	_ *Options,
 	rOpts *releaseOptions,
 ) error {
 	rlsOpts := &release.PublishOptions{
-		Repository:   rOpts.Repository,
+		Repository:     rOpts.Repository,
-		CommitRef:    c.String("release-sha"),
+		CommitRef:      c.String("release-sha"),
-		ReleaseName:  rOpts.Name,
+		ReleaseName:    rOpts.Name,
-		ReleaseTitle: c.String("title"),
+		ReleaseTitle:   c.String("title"),
-		AssetFiles:   c.Args().Slice(),
+		AssetFiles:     c.Args().Slice(),
-		GithubToken:  rOpts.GithubToken,
+		AssetSizeCheck: c.Bool("asset-size-check"),
+		GithubToken:    rOpts.GithubToken,
 	}
 
 	rlsType := c.String("type")
@@ -182,7 +191,13 @@ func releasePublishAction(
 		return fmt.Errorf("invalid --type \"%s\"", rlsType)
 	}
 
+	if c.Args().Len() > 0 {
+		rlsOpts.AssetFiles = c.Args().Slice()
+	}
+
 	if rOpts.Plan != nil {
+		rlsOpts.Source = rOpts.Plan.Source
+
 		if rOpts.Plan.Release != nil {
 			rlsOpts.ReleaseName = rOpts.Plan.Release.Name
 			rlsOpts.ReleaseTitle = rOpts.Plan.Release.Title
@@ -194,7 +209,8 @@ func releasePublishAction(
 			}
 		}
 
-		if rOpts.Plan.Output != nil {
+		// Set asset files based on plan if no file arguments were given.
+		if len(rlsOpts.AssetFiles) == 0 && rOpts.Plan.Output != nil {
 			rlsOpts.AssetFiles = []string{
 				filepath.Join(
 					rOpts.Plan.Output.Directory,
@@ -206,3 +222,56 @@ func releasePublishAction(
 
 	return release.Publish(c.Context, rlsOpts)
 }
+
+func releaseBulkCmd() *cli2.Command {
+	return &cli2.Command{
+		Name:      "bulk",
+		Usage:     "bulk modify GitHub releases",
+		ArgsUsage: "",
+		Flags: []cli2.Flag{
+			&cli2.StringFlag{
+				Name:  "name",
+				Usage: "regexp pattern matching release names to modify",
+			},
+			&cli2.StringFlag{
+				Name: "prerelease",
+				Usage: "change prerelease flag, must be \"true\" or " +
+					"\"false\", otherwise prerelease value is not changed",
+			},
+			&cli2.BoolFlag{
+				Name:  "dry-run",
+				Usage: "do not perform any changes",
+			},
+		},
+		Action: releaseActionWrapper(releaseBulkAction),
+	}
+}
+
+func releaseBulkAction(
+	c *cli2.Context,
+	_ *Options,
+	rOpts *releaseOptions,
+) error {
+	bulkOpts := &release.BulkOptions{
+		Repository:  rOpts.Repository,
+		NamePattern: c.String("name"),
+		DryRun:      c.Bool("dry-run"),
+		GithubToken: rOpts.GithubToken,
+	}
+
+	switch c.String("prerelease") {
+	case "true":
+		v := true
+		bulkOpts.Prerelease = &v
+	case "false":
+		v := false
+		bulkOpts.Prerelease = &v
+	case "":
+	default:
+		return errors.New(
+			"--prerelease by me \"true\" or \"false\" when specified",
+		)
+	}
+
+	return release.Bulk(c.Context, bulkOpts)
+}

pkg/cli/sign.go

@@ -112,3 +112,49 @@ func signAction(c *cli2.Context, opts *Options) error {
 
 	return sign.Emacs(c.Context, app, signOpts)
 }
+
+func signFilesCmd() *cli2.Command {
+	signCmd := signCmd()
+
+	var flags []cli2.Flag
+	for _, f := range signCmd.Flags {
+		n := f.Names()
+		if len(n) > 0 && n[0] == "plan" {
+			continue
+		}
+
+		flags = append(flags, f)
+	}
+
+	return &cli2.Command{
+		Name:      "sign-files",
+		Usage:     "sign files with codesign",
+		ArgsUsage: "<file> [<file>...]",
+		Hidden:    true,
+		Flags:     flags,
+		Action:    actionWrapper(signFilesAction),
+	}
+}
+
+func signFilesAction(c *cli2.Context, opts *Options) error {
+	signOpts := &sign.Options{
+		Identity:    c.String("sign"),
+		Options:     c.StringSlice("options"),
+		Deep:        c.Bool("deep"),
+		Timestamp:   c.Bool("timestamp"),
+		Force:       c.Bool("force"),
+		Verbose:     c.Bool("verbose"),
+		CodeSignCmd: c.String("codesign"),
+	}
+
+	if v := c.StringSlice("entitlements"); len(v) > 0 {
+		e := sign.Entitlements(v)
+		signOpts.Entitlements = &e
+	}
+
+	if !opts.quiet {
+		signOpts.Output = os.Stdout
+	}
+
+	return sign.Files(c.Context, c.Args().Slice(), signOpts)
+}

pkg/commit/commit.go

@@ -8,11 +8,11 @@ import (
 )
 
 type Commit struct {
-	SHA       string     `yaml:"sha"`
+	SHA       string     `yaml:"sha" json:"sha"`
-	Date      *time.Time `yaml:"date"`
+	Date      *time.Time `yaml:"date" json:"date"`
-	Author    string     `yaml:"author"`
+	Author    string     `yaml:"author" json:"author"`
-	Committer string     `yaml:"committer"`
+	Committer string     `yaml:"committer" json:"committer"`
-	Message   string     `yaml:"message"`
+	Message   string     `yaml:"message" json:"message"`
 }
 
 func New(rc *github.RepositoryCommit) *Commit {

pkg/osinfo/osinfo.go

@@ -2,13 +2,14 @@ package osinfo
 
 import (
 	"os/exec"
+	"strconv"
 	"strings"
 )
 
 type OSInfo struct {
-	Name    string `yaml:"name"`
+	Name    string `yaml:"name" json:"name"`
-	Version string `yaml:"version"`
+	Version string `yaml:"version" json:"version"`
-	Arch    string `yaml:"arch"`
+	Arch    string `yaml:"arch" json:"arch"`
 }
 
 func New() (*OSInfo, error) {
@@ -29,8 +30,17 @@ func New() (*OSInfo, error) {
 	}, nil
 }
 
-func (s *OSInfo) MajorMinor() string {
+// DistinctVersion returns macOS version down to a distinct "major"
+// version. For macOS 10.x, this will include the first two numeric parts of the
+// version (10.15), while for 11.x and later, the first numeric part is enough
+// (11).
+func (s *OSInfo) DistinctVersion() string {
 	parts := strings.Split(s.Version, ".")
+
+	if n, _ := strconv.Atoi(parts[0]); n >= 11 {
+		return parts[0]
+	}
+
 	max := len(parts)
 	if max > 2 {
 		max = 2

pkg/plan/create.go

@@ -11,7 +11,9 @@ import (
 	"github.com/jimeh/build-emacs-for-macos/pkg/commit"
 	"github.com/jimeh/build-emacs-for-macos/pkg/gh"
 	"github.com/jimeh/build-emacs-for-macos/pkg/osinfo"
+	"github.com/jimeh/build-emacs-for-macos/pkg/release"
 	"github.com/jimeh/build-emacs-for-macos/pkg/repository"
+	"github.com/jimeh/build-emacs-for-macos/pkg/source"
 )
 
 var nonAlphaNum = regexp.MustCompile(`[^\w_-]+`)
@@ -64,16 +66,18 @@ func Create(ctx context.Context, opts *Options) (*Plan, error) {
 		return nil, err
 	}
 
-	releaseName := fmt.Sprintf(
+	version := fmt.Sprintf(
-		"Emacs.%s.%s.%s",
+		"%s.%s.%s",
 		commitInfo.DateString(),
 		commitInfo.ShortSHA(),
 		sanitizeString(opts.Ref),
 	)
+
+	releaseName := fmt.Sprintf("Emacs.%s", version)
 	buildName := fmt.Sprintf(
-		"%s.%s.%s",
+		"Emacs.%s.%s.%s",
-		releaseName,
+		version,
-		sanitizeString(osInfo.Name+"-"+osInfo.MajorMinor()),
+		sanitizeString(osInfo.Name+"-"+osInfo.DistinctVersion()),
 		sanitizeString(osInfo.Arch),
 	)
 	diskImage := buildName + ".dmg"
@@ -82,17 +86,18 @@ func Create(ctx context.Context, opts *Options) (*Plan, error) {
 		Build: &Build{
 			Name: buildName,
 		},
-		Source: &Source{
+		Source: &source.Source{
 			Ref:        opts.Ref,
 			Repository: repo,
 			Commit:     commitInfo,
-			Tarball: &Tarball{
+			Tarball: &source.Tarball{
 				URL: repo.TarballURL(commitInfo.SHA),
 			},
 		},
 		OS: osInfo,
 		Release: &Release{
-			Name: releaseName,
+			Name:       releaseName,
+			Prerelease: true,
 		},
 		Output: &Output{
 			Directory: opts.OutputDir,
@@ -100,16 +105,28 @@ func Create(ctx context.Context, opts *Options) (*Plan, error) {
 		},
 	}
 
+	// If given git ref is a stable release tag (emacs-23.2b, emacs-27.2, etc.)
+	// we modify release properties accordingly.
+	if v, err := release.GitRefToStableVersion(opts.Ref); err == nil {
+		plan.Release.Prerelease = false
+		plan.Release.Name, err = release.VersionToName(v)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	if opts.TestBuild != "" {
 		testName := sanitizeString(opts.TestBuild)
 
 		plan.Build.Name += ".test." + testName
 		plan.Release.Title = "Test Builds"
 		plan.Release.Name = "test-builds"
+
+		plan.Release.Prerelease = true
+		plan.Release.Draft = false
 		if opts.TestBuildType == Draft {
+			plan.Release.Prerelease = false
 			plan.Release.Draft = true
-		} else {
-			plan.Release.Prerelease = true
 		}
 
 		index := strings.LastIndex(diskImage, ".")

pkg/plan/plan.go

@@ -2,21 +2,21 @@ package plan
 
 import (
 	"bytes"
+	"encoding/json"
 	"io"
 	"os"
 
-	"github.com/jimeh/build-emacs-for-macos/pkg/commit"
 	"github.com/jimeh/build-emacs-for-macos/pkg/osinfo"
-	"github.com/jimeh/build-emacs-for-macos/pkg/repository"
+	"github.com/jimeh/build-emacs-for-macos/pkg/source"
 	"gopkg.in/yaml.v3"
 )
 
 type Plan struct {
-	Build   *Build         `yaml:"build,omitempty"`
+	Build   *Build         `yaml:"build,omitempty" json:"build,omitempty"`
-	Source  *Source        `yaml:"source,omitempty"`
+	Source  *source.Source `yaml:"source,omitempty" json:"source,omitempty"`
-	OS      *osinfo.OSInfo `yaml:"os,omitempty"`
+	OS      *osinfo.OSInfo `yaml:"os,omitempty" json:"os,omitempty"`
-	Release *Release       `yaml:"release,omitempty"`
+	Release *Release       `yaml:"release,omitempty" json:"release,omitempty"`
-	Output  *Output        `yaml:"output,omitempty"`
+	Output  *Output        `yaml:"output,omitempty" json:"output,omitempty"`
 }
 
 // Load attempts to loads a plan YAML from given filename.
@@ -54,29 +54,37 @@ func (s *Plan) YAML() (string, error) {
 	return buf.String(), nil
 }
 
+// WriteJSON writes plan in JSON format to given io.Writer.
+func (s *Plan) WriteJSON(w io.Writer) error {
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+
+	return enc.Encode(s)
+}
+
+// JSON returns plan in JSON format.
+func (s *Plan) JSON() (string, error) {
+	var buf bytes.Buffer
+	err := s.WriteJSON(&buf)
+	if err != nil {
+		return "", err
+	}
+
+	return buf.String(), nil
+}
+
 type Build struct {
-	Name string `yaml:"name,omitempty"`
+	Name string `yaml:"name,omitempty" json:"name,omitempty"`
-}
-
-type Source struct {
-	Ref        string                 `yaml:"ref,omitempty"`
-	Repository *repository.Repository `yaml:"repository,omitempty"`
-	Commit     *commit.Commit         `yaml:"commit,omitempty"`
-	Tarball    *Tarball               `yaml:"tarball,omitempty"`
-}
-
-type Tarball struct {
-	URL string `yaml:"url,omitempty"`
 }
 
 type Release struct {
-	Name       string `yaml:"name"`
+	Name       string `yaml:"name" json:"name"`
-	Title      string `yaml:"title,omitempty"`
+	Title      string `yaml:"title,omitempty" json:"title,omitempty"`
-	Draft      bool   `yaml:"draft,omitempty"`
+	Draft      bool   `yaml:"draft,omitempty" json:"draft,omitempty"`
-	Prerelease bool   `yaml:"prerelease,omitempty"`
+	Prerelease bool   `yaml:"prerelease,omitempty" json:"prerelease,omitempty"`
 }
 
 type Output struct {
-	Directory string `yaml:"directory,omitempty"`
+	Directory string `yaml:"directory,omitempty" json:"directory,omitempty"`
-	DiskImage string `yaml:"disk_image,omitempty"`
+	DiskImage string `yaml:"disk_image,omitempty" json:"disk_image,omitempty"`
 }

pkg/release/bulk.go

@@ -0,0 +1,84 @@
+package release
+
+import (
+	"context"
+	"regexp"
+
+	"github.com/google/go-github/v35/github"
+	"github.com/hashicorp/go-hclog"
+	"github.com/jimeh/build-emacs-for-macos/pkg/gh"
+	"github.com/jimeh/build-emacs-for-macos/pkg/repository"
+)
+
+type BulkOptions struct {
+	Repository  *repository.Repository
+	NamePattern string
+	Prerelease  *bool
+	DryRun      bool
+	GithubToken string
+}
+
+func Bulk(ctx context.Context, opts *BulkOptions) error {
+	logger := hclog.FromContext(ctx).Named("release")
+	gh := gh.New(ctx, opts.GithubToken)
+
+	nameMatcher, err := regexp.Compile(opts.NamePattern)
+	if err != nil {
+		return err
+	}
+
+	nextPage := 1
+	lastPage := 1
+
+	for nextPage <= lastPage {
+		releases, resp, err := gh.Repositories.ListReleases(
+			ctx, opts.Repository.Owner(), opts.Repository.Name(),
+			&github.ListOptions{
+				Page:    nextPage,
+				PerPage: 100,
+			},
+		)
+		if err != nil {
+			return err
+		}
+
+		nextPage = resp.NextPage
+		lastPage = resp.LastPage
+
+		for _, r := range releases {
+			if !nameMatcher.MatchString(r.GetName()) {
+				continue
+			}
+
+			logger.Info("match found", "release", r.GetName())
+
+			var changes []interface{}
+			if opts.Prerelease != nil && r.GetPrerelease() != *opts.Prerelease {
+				changes = append(changes, "prerelease", *opts.Prerelease)
+				r.Prerelease = opts.Prerelease
+			}
+
+			if len(changes) > 0 {
+				changes = append(
+					[]interface{}{"release", r.GetName()}, changes...,
+				)
+				logger.Info("modifying", changes...)
+				if !opts.DryRun {
+					_, _, err = gh.Repositories.EditRelease(
+						ctx, opts.Repository.Owner(), opts.Repository.Name(),
+						r.GetID(), r,
+					)
+					if err != nil {
+						return err
+					}
+				}
+			}
+		}
+
+		if nextPage == 0 || lastPage == 0 {
+			break
+		}
+	}
+
+	return nil
+}

pkg/release/publish.go

@@ -11,6 +11,7 @@ import (
 	"github.com/hashicorp/go-hclog"
 	"github.com/jimeh/build-emacs-for-macos/pkg/gh"
 	"github.com/jimeh/build-emacs-for-macos/pkg/repository"
+	"github.com/jimeh/build-emacs-for-macos/pkg/source"
 )
 
 type releaseType int
@@ -40,15 +41,26 @@ type PublishOptions struct {
 	// draft)
 	ReleaseType releaseType
 
+	// Source contains the source used to build the asset files. When set a
+	// release body/description text will be generated based on source commit
+	// details.
+	Source *source.Source
+
 	// AssetFiles is a list of files which must all exist in the release for
 	// the check to pass.
 	AssetFiles []string
 
+	// AssetSizeCheck causes a file size check for any existing asset files on a
+	// release which have the same filename as a asset we want to upload. If the
+	// size of the local and remote files are the same, the existing asset file
+	// is left in place. When this is false, given asset files will always be
+	// uploaded, replacing any asset files with the same filename.
+	AssetSizeCheck bool
+
 	// GitHubToken is the OAuth token used to talk to the GitHub API.
 	GithubToken string
 }
 
-//nolint:funlen,gocyclo
 // Publish creates and publishes a GitHub release.
 func Publish(ctx context.Context, opts *PublishOptions) error {
 	logger := hclog.FromContext(ctx).Named("release")
@@ -68,6 +80,16 @@ func Publish(ctx context.Context, opts *PublishOptions) error {
 	prerelease := opts.ReleaseType == Prerelease
 	draft := opts.ReleaseType == Draft
 
+	body := ""
+	if opts.Source != nil {
+		body, err = releaseBody(opts)
+		if err != nil {
+			return err
+		}
+		logger.Debug("rendered release body", "content", body)
+	}
+
+	created := false
 	logger.Info("checking release", "tag", tagName)
 	release, resp, err := gh.Repositories.GetReleaseByTag(
 		ctx, opts.Repository.Owner(), opts.Repository.Name(), tagName,
@@ -77,6 +99,7 @@ func Publish(ctx context.Context, opts *PublishOptions) error {
 			return err
 		}
 
+		created = true
 		logger.Info("creating release", "tag", tagName, "name", name)
 
 		release, _, err = gh.Repositories.CreateRelease(
@@ -87,6 +110,7 @@ func Publish(ctx context.Context, opts *PublishOptions) error {
 				TargetCommitish: &opts.CommitRef,
 				Prerelease:      boolPtr(false),
 				Draft:           boolPtr(true),
+				Body:            &body,
 			},
 		)
 		if err != nil {
@@ -94,62 +118,9 @@ func Publish(ctx context.Context, opts *PublishOptions) error {
 		}
 	}
 
-	for _, fileName := range files {
+	err = uploadReleaseAssets(ctx, gh, release, files, opts)
-		fileIO, err2 := os.Open(fileName)
+	if err != nil {
-		if err2 != nil {
+		return err
-			return err2
-		}
-		defer fileIO.Close()
-
-		fileInfo, err2 := fileIO.Stat()
-		if err2 != nil {
-			return err2
-		}
-
-		fileBaseName := filepath.Base(fileName)
-		assetExists := false
-
-		for _, a := range release.Assets {
-			if a.GetName() != fileBaseName {
-				continue
-			}
-
-			if a.GetSize() == int(fileInfo.Size()) {
-				logger.Info("asset exists with correct size",
-					"file", fileBaseName,
-					"local_size", byteCountIEC(fileInfo.Size()),
-					"remote_size", byteCountIEC(int64(a.GetSize())),
-				)
-				assetExists = true
-			} else {
-				_, err = gh.Repositories.DeleteReleaseAsset(
-					ctx, opts.Repository.Owner(), opts.Repository.Name(),
-					a.GetID(),
-				)
-				if err != nil {
-					return err
-				}
-				logger.Info(
-					"deleted asset with wrong size", "file", fileBaseName,
-				)
-			}
-		}
-
-		if !assetExists {
-			logger.Info("uploading asset",
-				"file", fileBaseName,
-				"size", byteCountIEC(fileInfo.Size()),
-			)
-			_, _, err2 = gh.Repositories.UploadReleaseAsset(
-				ctx, opts.Repository.Owner(), opts.Repository.Name(),
-				release.GetID(),
-				&github.UploadOptions{Name: fileBaseName},
-				fileIO,
-			)
-			if err2 != nil {
-				return err2
-			}
-		}
 	}
 
 	changed := false
@@ -158,6 +129,11 @@ func Publish(ctx context.Context, opts *PublishOptions) error {
 		changed = true
 	}
 
+	if body != "" && release.GetBody() != body {
+		release.Body = &body
+		changed = true
+	}
+
 	if release.GetDraft() != draft {
 		release.Draft = &draft
 		changed = true
@@ -169,6 +145,7 @@ func Publish(ctx context.Context, opts *PublishOptions) error {
 	}
 
 	if changed {
+		logger.Info("updating release attributes", "url", release.GetHTMLURL())
 		release, _, err = gh.Repositories.EditRelease(
 			ctx, opts.Repository.Owner(), opts.Repository.Name(),
 			release.GetID(), release,
@@ -178,13 +155,89 @@ func Publish(ctx context.Context, opts *PublishOptions) error {
 		}
 	}
 
-	logger.Info("release created", "url", release.GetHTMLURL())
+	if created {
+		logger.Info("release created", "url", release.GetHTMLURL())
+	} else {
+		logger.Info("release updated", "url", release.GetHTMLURL())
+	}
+
+	return nil
+}
+
+func uploadReleaseAssets(
+	ctx context.Context,
+	gh *github.Client,
+	release *github.RepositoryRelease,
+	fileNames []string,
+	opts *PublishOptions,
+) error {
+	logger := hclog.FromContext(ctx).Named("release")
+
+	for _, fileName := range fileNames {
+		logger.Debug("processing asset", "file", filepath.Base(fileName))
+
+		fileIO, err := os.Open(fileName)
+		if err != nil {
+			return err
+		}
+		defer fileIO.Close()
+
+		fileInfo, err := fileIO.Stat()
+		if err != nil {
+			return err
+		}
+
+		fileBaseName := filepath.Base(fileName)
+		assetExists := false
+
+		for _, a := range release.Assets {
+			if a.GetName() != fileBaseName {
+				continue
+			}
+
+			if opts.AssetSizeCheck && a.GetSize() == int(fileInfo.Size()) {
+				logger.Info("asset exists with correct size",
+					"file", fileBaseName,
+					"local_size", byteCountIEC(fileInfo.Size()),
+					"remote_size", byteCountIEC(int64(a.GetSize())),
+				)
+				assetExists = true
+			} else {
+				logger.Info(
+					"deleting existing asset", "file", fileBaseName,
+				)
+				_, err = gh.Repositories.DeleteReleaseAsset(
+					ctx, opts.Repository.Owner(), opts.Repository.Name(),
+					a.GetID(),
+				)
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		if !assetExists {
+			logger.Info("uploading asset",
+				"file", fileBaseName,
+				"size", byteCountIEC(fileInfo.Size()),
+			)
+			_, _, err = gh.Repositories.UploadReleaseAsset(
+				ctx, opts.Repository.Owner(), opts.Repository.Name(),
+				release.GetID(),
+				&github.UploadOptions{Name: fileBaseName},
+				fileIO,
+			)
+			if err != nil {
+				return err
+			}
+		}
+	}
 
 	return nil
 }
 
 func publishFileList(files []string) ([]string, error) {
-	var output []string
+	results := map[string]struct{}{}
 	for _, file := range files {
 		var err error
 		file, err = filepath.Abs(file)
@@ -200,11 +253,10 @@ func publishFileList(files []string) ([]string, error) {
 			return nil, fmt.Errorf("\"%s\" is not a file", file)
 		}
 
-		output = append(output, file)
+		results[file] = struct{}{}
 		sumFile := file + ".sha256"
 
 		_, err = os.Stat(sumFile)
-		fmt.Printf("err: %+v\n", err)
 		if err != nil {
 			if os.IsNotExist(err) {
 				continue
@@ -212,7 +264,12 @@ func publishFileList(files []string) ([]string, error) {
 
 			return nil, err
 		}
-		output = append(output, sumFile)
+		results[sumFile] = struct{}{}
+	}
+
+	var output []string
+	for f := range results {
+		output = append(output, f)
 	}
 
 	return output, nil

pkg/release/release_body.go

@@ -0,0 +1,78 @@
+package release
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"text/template"
+)
+
+var tplFuncs = template.FuncMap{
+	"indent": func(n int, s string) string {
+		pad := strings.Repeat(" ", n)
+
+		return pad + strings.ReplaceAll(s, "\n", "\n"+pad)
+	},
+}
+
+var bodyTpl = template.Must(template.New("body").Funcs(tplFuncs).Parse(`
+{{- $t := "` + "`" + `" -}}
+### Build Details
+
+{{ with .SourceURL -}}
+- Source: {{ . }}
+{{- end }}
+{{- if .CommitURL }}
+- Commit: {{ .CommitURL }}
+  {{- if .CommitSHA }} ({{ $t }}{{ .CommitSHA }}{{ $t }}){{ end }}
+{{- end }}
+{{- with .TarballURL }}
+- Tarball: {{ . }}
+{{- end }}
+{{- with .BuildLogURL }}
+- Build Log: {{ . }} (available for 90 days)
+{{- end }}`,
+))
+
+type bodyData struct {
+	SourceURL   string
+	CommitSHA   string
+	CommitURL   string
+	BuildLogURL string
+	TarballURL  string
+}
+
+func releaseBody(opts *PublishOptions) (string, error) {
+	src := opts.Source
+
+	if src.Repository == nil || src.Commit == nil {
+		return "", nil
+	}
+
+	data := &bodyData{
+		SourceURL:  src.Repository.TreeURL(src.Ref),
+		CommitSHA:  src.Commit.SHA,
+		CommitURL:  src.Repository.CommitURL(src.Commit.SHA),
+		TarballURL: src.Repository.TarballURL(src.Commit.SHA),
+	}
+
+	// If available, use the exact value from the build plan.
+	if src.Tarball != nil {
+		data.TarballURL = src.Tarball.URL
+	}
+
+	// If running within GitHub Actions, provide link to build log.
+	if opts.Repository != nil {
+		if id := os.Getenv("GITHUB_RUN_ID"); id != "" {
+			data.BuildLogURL = opts.Repository.ActionRunURL(id)
+		}
+	}
+
+	var buf bytes.Buffer
+	err := bodyTpl.Execute(&buf, data)
+	if err != nil {
+		return "", err
+	}
+
+	return buf.String(), nil
+}

pkg/release/version.go

@@ -0,0 +1,42 @@
+package release
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+)
+
+// Errors
+var (
+	Err             = errors.New("release")
+	ErrInvalidName  = fmt.Errorf("%w: invalid name", Err)
+	ErrEmptyVersion = fmt.Errorf("%w: empty version", Err)
+	ErrNotStableRef = fmt.Errorf(
+		"%w: git ref is not stable tagged release", Err,
+	)
+)
+
+var (
+	stableVersion = regexp.MustCompile(`^\d+\.\d+(?:[a-z]+)?$`)
+	stableGetRef  = regexp.MustCompile(`^emacs-(\d+\.\d+(?:[a-z]+)?)$`)
+)
+
+func VersionToName(version string) (string, error) {
+	if version == "" {
+		return "", ErrEmptyVersion
+	}
+
+	if stableVersion.MatchString(version) {
+		return "Emacs-" + version, nil
+	}
+
+	return "Emacs." + version, nil
+}
+
+func GitRefToStableVersion(ref string) (string, error) {
+	if m := stableGetRef.FindStringSubmatch(ref); len(m) > 1 {
+		return m[1], nil
+	}
+
+	return "", fmt.Errorf("%w: \"%s\"", ErrNotStableRef, ref)
+}

pkg/release/version_test.go

@@ -0,0 +1,138 @@
+package release
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestVersionToName(t *testing.T) {
+	type args struct {
+		version string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr string
+	}{
+		{
+			name: "empty",
+			args: args{
+				version: "",
+			},
+			wantErr: "release: empty version",
+		},
+		{
+			name: "nightly",
+			args: args{
+				version: "2021-07-01.1b88404.master",
+			},
+			want: "Emacs.2021-07-01.1b88404.master",
+		},
+		{
+			name: "stable",
+			args: args{
+				version: "27.2",
+			},
+			want: "Emacs-27.2",
+		},
+		{
+			name: "stable with letter",
+			args: args{
+				version: "23.3b",
+			},
+			want: "Emacs-23.3b",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := VersionToName(tt.args.version)
+
+			assert.Equal(t, tt.want, got)
+
+			if tt.wantErr != "" {
+				assert.EqualError(t, err, tt.wantErr)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestGitRefToStableVersion(t *testing.T) {
+	type args struct {
+		version string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr string
+	}{
+		{
+			name: "empty",
+			args: args{
+				version: "",
+			},
+			wantErr: "release: git ref is not stable tagged release: \"\"",
+		},
+		{
+			name: "master",
+			args: args{
+				version: "master",
+			},
+			wantErr: "release: git ref is not stable tagged release: " +
+				"\"master\"",
+		},
+		{
+			name: "feature",
+			args: args{
+				version: "feature/native-comp",
+			},
+			wantErr: "release: git ref is not stable tagged release: " +
+				"\"feature/native-comp\"",
+		},
+		{
+			name: "stable",
+			args: args{
+				version: "emacs-27.2",
+			},
+			want: "27.2",
+		},
+		{
+			name: "stable with letter",
+			args: args{
+				version: "emacs-23.3b",
+			},
+			want: "23.3b",
+		},
+		{
+			name: "future stable",
+			args: args{
+				version: "emacs-239.33",
+			},
+			want: "239.33",
+		},
+		{
+			name: "future stable with letter",
+			args: args{
+				version: "emacs-239.33c",
+			},
+			want: "239.33c",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := GitRefToStableVersion(tt.args.version)
+
+			assert.Equal(t, tt.want, got)
+
+			if tt.wantErr != "" {
+				assert.EqualError(t, err, tt.wantErr)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}

pkg/repository/repository.go

@@ -22,8 +22,8 @@ const GitHub Type = "github"
 // Repository represents basic information about a repository with helper
 // methods to get various pieces of information from it.
 type Repository struct {
-	Type   Type   `yaml:"type,omitempty"`
+	Type   Type   `yaml:"type,omitempty" json:"type,omitempty"`
-	Source string `yaml:"source,omitempty"`
+	Source string `yaml:"source,omitempty" json:"source,omitempty"`
 }
 
 func NewGitHub(ownerAndName string) (*Repository, error) {
@@ -89,3 +89,42 @@ func (s *Repository) TarballURL(ref string) string {
 		return ""
 	}
 }
+
+func (s *Repository) CommitURL(ref string) string {
+	if ref == "" {
+		return ""
+	}
+
+	switch s.Type {
+	case GitHub:
+		return GitHubBaseURL + s.Source + "/commit/" + ref
+	default:
+		return ""
+	}
+}
+
+func (s *Repository) TreeURL(ref string) string {
+	if ref == "" {
+		return ""
+	}
+
+	switch s.Type {
+	case GitHub:
+		return GitHubBaseURL + s.Source + "/tree/" + ref
+	default:
+		return ""
+	}
+}
+
+func (s *Repository) ActionRunURL(runID string) string {
+	if runID == "" {
+		return ""
+	}
+
+	switch s.Type {
+	case GitHub:
+		return GitHubBaseURL + s.Source + "/actions/runs/" + runID
+	default:
+		return ""
+	}
+}

pkg/sign/emacs.go

@@ -117,42 +117,24 @@ func signCLIHelper(ctx context.Context, appBundle string, opts *Options) error {
 }
 
 // elnFiles finds all native-compilation *.eln files within a Emacs.app bundle,
-// based on expected paths they might be stored in.
+// excluding any *.eln which should be automatically located by codesign when
+// signing the Emacs.app bundle itself with the --deep flag. Essentially this
+// only returns *.eln files which must be individually signed before signing the
+// app bundle itself.
 func elnFiles(emacsApp string) ([]string, error) {
-	dirs := []string{
-		// Current *.eln location.
-		filepath.Join(emacsApp, "Contents", "Resources", "native-lisp"),
-		// Legacy *.eln location.
-		filepath.Join(emacsApp, "Contents", "MacOS", "lib", "emacs"),
-	}
-
 	var files []string
-	walkDirFunc := func(path string, _d fs.DirEntry, _err error) error {
+	walkDirFunc := func(path string, d fs.DirEntry, _err error) error {
-		if strings.HasSuffix(path, ".eln") {
+		if d.Type().IsRegular() && strings.HasSuffix(path, ".eln") &&
+			!strings.Contains(path, ".app/Contents/Frameworks/") {
 			files = append(files, path)
 		}
 
 		return nil
 	}
 
-	for _, dir := range dirs {
+	err := filepath.WalkDir(filepath.Join(emacsApp, "Contents"), walkDirFunc)
-		fi, err := os.Stat(dir)
+	if err != nil {
-		if err != nil {
+		return nil, err
-			if os.IsNotExist(err) {
-				continue
-			}
-
-			return nil, err
-		}
-
-		if !fi.IsDir() {
-			continue
-		}
-
-		err = filepath.WalkDir(dir, walkDirFunc)
-		if err != nil {
-			return nil, err
-		}
 	}
 
 	return files, nil

pkg/sign/entitlements.go

@@ -14,6 +14,7 @@ var DefaultEmacsEntitlements = []string{
 	"com.apple.security.cs.allow-jit",
 	"com.apple.security.network.client",
 	"com.apple.security.cs.disable-library-validation",
+	"com.apple.security.cs.allow-dyld-environment-variables",
 	"com.apple.security.automation.apple-events",
 }
 

pkg/sign/entitlements_test.go

@@ -50,6 +50,7 @@ var entitlementsTestCases = []struct {
 			"com.apple.security.cs.allow-jit",
 			"com.apple.security.network.client",
 			"com.apple.security.cs.disable-library-validation",
+			"com.apple.security.cs.allow-dyld-environment-variables",
 			"com.apple.security.automation.apple-events",
 		},
 		//nolint:lll
@@ -64,6 +65,8 @@ var entitlementsTestCases = []struct {
                 <true/>
                 <key>com.apple.security.cs.disable-library-validation</key>
                 <true/>
+                <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+                <true/>
                 <key>com.apple.security.automation.apple-events</key>
                 <true/>
               </dict>
@@ -78,6 +81,7 @@ func TestDefaultEmacsEntitlements(t *testing.T) {
 			"com.apple.security.cs.allow-jit",
 			"com.apple.security.network.client",
 			"com.apple.security.cs.disable-library-validation",
+			"com.apple.security.cs.allow-dyld-environment-variables",
 			"com.apple.security.automation.apple-events",
 		},
 		DefaultEmacsEntitlements,

pkg/source/source.go

@@ -0,0 +1,17 @@
+package source
+
+import (
+	"github.com/jimeh/build-emacs-for-macos/pkg/commit"
+	"github.com/jimeh/build-emacs-for-macos/pkg/repository"
+)
+
+type Source struct {
+	Ref        string                 `yaml:"ref,omitempty" json:"ref,omitempty"`
+	Repository *repository.Repository `yaml:"repository,omitempty" json:"repository,omitempty"`
+	Commit     *commit.Commit         `yaml:"commit,omitempty" json:"commit,omitempty"`
+	Tarball    *Tarball               `yaml:"tarball,omitempty" json:"tarball,omitempty"`
+}
+
+type Tarball struct {
+	URL string `yaml:"url,omitempty" json:"url,omitempty"`
+}