motion-sparkle-sandbox 2.0.0 → 2.1.1

data/lib/motion/project/appcast.rb

@@ -1,127 +1,310 @@
-module Motion::Project
-  class Sparkle
-
-    def create_release_notes
-      if File.exist?(release_notes_template_path)
-        File.open("#{release_notes_path}", "w") do |f|
-          template = File.read(release_notes_template_path)
-          f << ERB.new(template).result(binding)
-        end
-        App.info 'Create', "./#{release_notes_path}"
-      else
-        App.fail "Release notes template not found as expected at ./#{release_notes_template_path}"
-      end
-    end
+# frozen_string_literal: true
 
-    def create_appcast
-      create_release_folder
-      appcast_file = File.open("#{sparkle_release_path}/#{appcast.feed_filename}", 'w') do |f|
-        xml_string = ''
-        doc = REXML::Formatters::Pretty.new
-        doc.write(appcast_xml, xml_string)
-        f << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
-        f << xml_string
-        f << "\n"
-      end
-      if appcast_file
-        App.info "Create", "./#{sparkle_release_path}/#{appcast.feed_filename}"
-      else
-        App.info "Fail", "./#{sparkle_release_path}/#{appcast.feed_filename} not created"
-      end
-    end
+# rubocop:disable Metrics/ClassLength
+module Motion
+  module Project
+    class Sparkle
+      class Appcast
+        PARAMS = %i[
+          package_base_url
+          package_filename
+          notes_base_url
+          notes_filename
+          use_exported_private_key
+          base_url
+          releases_folder
+          feed_base_url
+          feed_filename
+        ].freeze
 
-    def appcast_xml
-      rss = REXML::Element.new 'rss'
-      rss.attributes['xmlns:atom'] = "http://www.w3.org/2005/Atom"
-      rss.attributes['xmlns:sparkle'] = "http://www.andymatuschak.org/xml-namespaces/sparkle"
-      rss.attributes['xmlns:version'] = "2.0"
-      rss.attributes['xmlns:dc'] = "http://purl.org/dc/elements/1.1/"
-      channel = rss.add_element 'channel'
-      channel.add_element('title').text = @config.name
-      channel.add_element('description').text = "#{@config.name} updates"
-      channel.add_element('link').text = @config.info_plist["SUFeedURL"]
-      channel.add_element('language').text = 'en'
-      channel.add_element('pubDate').text = Time.now.strftime("%a, %d %b %Y %H:%M:%S %z")
-      atom_link = channel.add_element('atom:link')
-      atom_link.attributes['href'] = @config.info_plist["SUFeedURL"]
-      atom_link.attributes['rel'] = 'self'
-      atom_link.attributes['type'] = "application/rss+xml"
-      item = channel.add_element 'item'
-      item.add_element('title').text = "#{@config.name} #{@config.short_version}"
-      item.add_element('pubDate').text = Time.now.strftime("%a, %d %b %Y %H:%M:%S %z")
-      guid = item.add_element('guid')
-      guid.text = "#{@config.name}-#{@config.short_version}"
-      guid.attributes['isPermaLink'] = false
-      item.add_element('sparkle:releaseNotesLink').text = "#{appcast.notes_url}"
-      enclosure = item.add_element('enclosure')
-      enclosure.attributes['url'] = "#{appcast.package_url}"
-      enclosure.attributes['length'] = "#{@package_size}"
-      enclosure.attributes['type'] = "application/octet-stream"
-      enclosure.attributes['sparkle:version'] = @config.version
-      enclosure.attributes['sparkle:shortVersionString'] = @config.short_version
-      enclosure.attributes['sparkle:dsaSignature'] = @package_signature
-      rss
-    end
+        CLI_OPTIONS = {
+          account: '--account',
+          private_eddsa_key: '-s',
+          download_url_prefix: '--download-url-prefix',
+          release_notes_url_prefix: '--release-notes-url-prefix',
+          full_release_notes_url: '--full-release-notes-url',
+          link: '--link',
+          versions: '--versions',
+          maximum_deltas: '--maximum-deltas',
+          delta_compression: '--delta-compression',
+          delta_compression_level: '--delta-compression-level',
+          channel: '--channel',
+          major_version: '--major-version',
+          ignore_skipped_upgrades_below_version: '--ignore-skipped-upgrades-below-version',
+          phased_rollout_interval: '--phased-rollout-interval',
+          critical_update_version: '--critical-update-version',
+          informational_update_versions: '--informational-update-versions',
+          output_path: '-o'
+        }.freeze
 
-    def release_notes_template_path
-      sparkle_config_path + "release_notes.template.erb"
-    end
+        attr_accessor :base_url,
+                      :feed_base_url,
+                      :feed_filename,
+                      :notes_filename,
+                      :package_filename,
+                      :releases_folder,
+                      :use_exported_private_key,
+                      :cli_options
+        attr_writer   :notes_base_url,
+                      :package_base_url
 
-    def release_notes_content_path
-      sparkle_config_path + "release_notes.content.html"
-    end
+        def initialize(sparkle_object)
+          @sparkle = sparkle_object
+          @cli_options = {
+            account: 'ed25519' # Sparkle's default account
+          }
 
-    def release_notes_path
-      sparkle_release_path + appcast.notes_filename.to_s
-    end
+          @feed_base_url = nil
+          @feed_filename = 'releases.xml'
+          @notes_base_url = nil
+          @notes_filename = nil
+          @package_base_url = nil
+          @package_filename = nil
+          @base_url = nil
+          @releases_folder = nil
+          @use_exported_private_key = false
+        end
 
-    def release_notes_content
-      if File.exist?(release_notes_content_path)
-        File.read(release_notes_content_path)
-      else
-        App.fail "Missing #{release_notes_content_path}"
-      end
-    end
+        def process_option(key, value)
+          if CLI_OPTIONS.keys.include?(key)
+            cli_options[key] = value
+          elsif PARAMS.include?(key)
+            send("#{key}=", value)
+          else
+            return false
+          end
 
-    def release_notes_html
-      release_notes_content
-    end
+          true
+        end
 
+        def feed_url
+          "#{feed_base_url || base_url}#{feed_filename}"
+        end
 
-    class Appcast
-      attr_accessor :base_url,
-        :feed_base_url,
-        :feed_filename,
-        :notes_base_url, 
-        :notes_filename, 
-        :package_base_url,
-        :package_filename,
-        :archive_folder
-
-      def initialize
-        @feed_base_url = nil
-        @feed_filename = 'releases.xml'
-        @notes_base_url = nil
-        @notes_filename = 'release_notes.html'
-        @package_base_url = nil
-        @package_filename = nil
-        @base_url = nil
-        @archive_folder = nil
-      end
+        def notes_base_url
+          @notes_base_url || base_url
+        end
 
-      def feed_url
-        "#{feed_base_url || base_url}/#{feed_filename}"
-      end
+        def package_base_url
+          @package_base_url || base_url
+        end
 
-      def notes_url
-        "#{notes_base_url || base_url}/#{notes_filename}"
-      end
+        def prepare_args
+          args = []
 
-      def package_url
-        "#{package_base_url || base_url}/#{package_filename}"
-      end
+          account(args)
+          private_eddsa_key(args)
+          download_url_prefix(args)
+          release_notes_url_prefix(args)
+          full_release_notes_url(args)
+          link(args)
+          versions(args)
+          maximum_deltas(args)
+          delta_compression(args)
+          delta_compression_level(args)
+          channel(args)
+          major_version(args)
+          ignore_skipped_upgrades_below_version(args)
+          phased_rollout_interval(args)
+          critical_update_version(args)
+          informational_update_versions(args)
+          output_path(args)
 
-    end
+          args
+        end
+
+        private
+
+        # --account <account>     The account name in your keychain associated with
+        #                         your private EdDSA (ed25519) key to use for signing
+        #                         new updates. (default: ed25519)
+        def account(args)
+          return unless cli_options[:account].present?
+
+          args << "--account=#{cli_options[:account]}"
+        end
+
+        # -s <private-EdDSA-key>  The private EdDSA string (128 characters). If not
+        #                         specified, the private EdDSA key will be read from
+        #                         the Keychain instead.
+        def private_eddsa_key(args)
+          if cli_options[:private_eddsa_key].present?
+            args << "-s=#{cli_options[:private_eddsa_key]}"
+          elsif use_exported_private_key && File.exist?(private_key_path)
+            private_key = File.read(private_key_path)
+            args << "-s=#{private_key}"
+          end
+        end
+
+        # --download-url-prefix <url> A URL that will be used as prefix for the URL from
+        #                             where updates will be downloaded.
+        def download_url_prefix(args)
+          if cli_options[:download_url_prefix].present?
+            args << "--download-url-prefix=#{cli_options[:download_url_prefix]}"
+          elsif package_base_url.present?
+            args << "--download-url-prefix=#{package_base_url}"
+          end
+        end
+
+        # --release-notes-url-prefix <url> A URL that will be used as prefix for constructing
+        #                                  URLs for release notes.
+        def release_notes_url_prefix(args)
+          if cli_options[:release_notes_url_prefix].present?
+            args << "--release-notes-url-prefix=#{cli_options[:release_notes_url_prefix]}"
+          elsif notes_base_url.present?
+            args << "--release-notes-url-prefix=#{notes_base_url}"
+          end
+        end
+
+        # --full-release-notes-url <url>
+        #                         A URL that will be used for the full release notes.
+        def full_release_notes_url(args)
+          return unless cli_options[:full_release_notes_url].present?
+
+          args << "--full-release-notes-url=#{cli_options[:full_release_notes_url]}"
+        end
+
+        # --link <link>           A URL to the application's website which Sparkle may
+        #                         use for directing users to if they cannot download a
+        #                         new update from within the application. This will be
+        #                         used for new generated update items. By default, no
+        #                         product link is used.
+        def link(args)
+          return unless cli_options[:link].present?
 
+          args << "--link=#{cli_options[:link]}"
+        end
+
+        # --versions <versions>   An optional comma delimited list of application
+        #                         versions (specified by CFBundleVersion) to generate
+        #                         new update items for. By default, new update items
+        #                         are inferred from the available archives and are only
+        #                         generated if they are in the latest 5 updates in the
+        #                         appcast.
+        def versions(args)
+          return unless cli_options[:versions].present?
+
+          args << "--versions=#{cli_options[:versions]}"
+        end
+
+        # --maximum-deltas <maximum-deltas>
+        #                         The maximum number of delta items to create for the
+        #                         latest update for each minimum required operating
+        #                         system. (default: 5)
+        def maximum_deltas(args)
+          return unless cli_options[:maximum_deltas].present?
+
+          args << "--maximum-deltas=#{cli_options[:maximum_deltas]}"
+        end
+
+        # --delta-compression <delta-compression>
+        #                         The compression method to use for generating delta
+        #                         updates. Supported methods for version 3 delta files
+        #                         are 'lzma', 'bzip2', 'zlib', 'lzfse', 'lz4', 'none',
+        #                         and 'default'. Note that version 2 delta files only
+        #                         support 'bzip2', 'none', and 'default' so other
+        #                         methods will be ignored if version 2 files are being
+        #                         generated. The 'default' compression for version 3
+        #                         delta files is currently lzma. (default: default)
+        def delta_compression(args)
+          return unless cli_options[:delta_compression].present?
+
+          args << "--delta-compression=#{cli_options[:delta_compression]}"
+        end
+
+        # --delta-compression-level <delta-compression-level>
+        #                         The compression level to use for generating delta
+        #                         updates. This only applies if the compression method
+        #                         used is bzip2 which accepts values from 1 - 9. A
+        #                         special value of 0 will use the default compression
+        #                         level. (default: 0)
+        def delta_compression_level(args)
+          return unless cli_options[:delta_compression_level].present?
+
+          args << "--delta-compression-level=#{cli_options[:delta_compression_level]}"
+        end
+
+        # --channel <channel-name>
+        #                         The Sparkle channel name that will be used for
+        #                         generating new updates. By default, no channel is
+        #                         used. Old applications need to be using Sparkle 2 to
+        #                         use this feature.
+        def channel(args)
+          return unless cli_options[:channel].present?
+
+          args << "--channel=#{cli_options[:channel]}"
+        end
+
+        # --major-version <major-version>
+        #                         The last major or minimum autoupdate sparkle:version
+        #                         that will be used for generating new updates. By
+        #                         default, no last major version is used.
+        def major_version(args)
+          return unless cli_options[:major_version].present?
+
+          args << "--major-version=#{cli_options[:major_version]}"
+        end
+
+        # --ignore-skipped-upgrades-below-version <below-version>
+        #                         Ignore skipped major upgrades below this specified
+        #                         version. Only applicable for major upgrades.
+        def ignore_skipped_upgrades_below_version(args)
+          return unless cli_options[:ignore_skipped_upgrades_below_version].present?
+
+          args << "--ignore-skipped-upgrades-below-version=#{cli_options[:ignore_skipped_upgrades_below_version]}"
+        end
+
+        # --phased-rollout-interval <phased-rollout-interval>
+        #                         The phased rollout interval in seconds that will be
+        #                         used for generating new updates. By default, no
+        #                         phased rollout interval is used.
+        def phased_rollout_interval(args)
+          return unless cli_options[:phased_rollout_interval].present?
+
+          args << "--phased-rollout-interval=#{cli_options[:phased_rollout_interval]}"
+        end
+
+        # --critical-update-version <critical-update-version>
+        #                         The last critical update sparkle:version that will be
+        #                         used for generating new updates. An empty string
+        #                         argument will treat this update as critical coming
+        #                         from any application version. By default, no last
+        #                         critical update version is used. Old applications
+        #                         need to be using Sparkle 2 to use this feature.
+        def critical_update_version(args)
+          return unless cli_options[:critical_update_version].present?
+
+          args << "--critical-update-version=#{cli_options[:critical_update_version]}"
+        end
+
+        # --informational-update-versions <informational-update-versions>
+        #                         A comma delimited list of application
+        #                         sparkle:version's that will see newly generated
+        #                         updates as being informational only. An empty string
+        #                         argument will treat this update as informational
+        #                         coming from any application version. Prefix a version
+        #                         string with '<' to indicate (eg "<2.5") to indicate
+        #                         older versions than the one specified should treat
+        #                         the update as informational only. By default, updates
+        #                         are not informational only. --link must also be
+        #                         provided. Old applications need to be using Sparkle 2
+        #                         to use this feature, and 2.1 or later to use the '<'
+        #                         upper bound feature.
+        def informational_update_versions(args)
+          return unless cli_options[:informational_update_versions].present?
+
+          args << "--informational-update-versions=#{cli_options[:informational_update_versions]}"
+        end
+
+        # -o <output-path>        Path to filename for the generated appcast (allowed
+        #                         when only one will be created).
+        def output_path(args)
+          return unless cli_options[:output_path].present?
+
+          args << "-o=#{cli_options[:output_path]}"
+        end
+      end
+    end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/motion/project/indent_string.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# https://makandracards.com/makandra/6087-ruby-indent-a-string
+String.class_eval do
+  def indent(count, char = ' ', skip_first_line: false)
+    gsub(/([^\n]*)(\n|$)/) do |_match|
+      last_iteration = (Regexp.last_match(1) == '' && Regexp.last_match(2) == '')
+      line = String.new
+      line << (char * count) unless last_iteration || skip_first_line
+      line << Regexp.last_match(1)
+      line << Regexp.last_match(2)
+
+      skip_first_line = false
+
+      line
+    end
+  end
+end

data/lib/motion/project/install.rb

@@ -1,75 +1,31 @@
-module Motion::Project
-  class Sparkle
+# frozen_string_literal: true
 
-    SPARKLE_ZIP_FILE = 'Sparkle.zip'
-
-    def sparkle_distrib
-      file_path = Pathname.new File.dirname(__FILE__)
-      distrib_path = "vendor/#{SPARKLE_ZIP_FILE}"
-      (file_path.parent.parent.parent + distrib_path).to_s
-      Pathname.new(sparkle_vendor_path + SPARKLE_ZIP_FILE)
-    end
-
-    def sparkle_vendor_path
-      file_path = Pathname.new File.dirname(__FILE__)
-      (file_path.parent.parent.parent + 'vendor/').to_s
-    end
-
-    def sparkle_path
-      Pathname.new(vendor_path + 'Sparkle')
-    end
-
-    def sparkle_framework_path
-      Pathname.new(vendor_path + 'Sparkle/Sparkle.framework')
-    end
-
-    def sparkle_xpc_path
-      Pathname.new(vendor_path + 'Sparkle/XPCServices')
-    end
-
-    def sparkle_zipball
-      Pathname.new(vendor_path + SPARKLE_ZIP_FILE)
-    end
-
-    def copy_zipball
-      `cp #{sparkle_distrib} #{sparkle_zipball}`
-    end
-
-    def unzip
-      `unzip #{sparkle_zipball.to_s} -d #{vendor_path.to_s}`
-      `rm #{sparkle_zipball}`
-    end
-
-    def installed?
-      File.directory?(sparkle_framework_path)
-    end
+module Motion
+  module Project
+    class Sparkle
+      def vendored_sparkle_path
+        vendor_path.join('Pods/Sparkle')
+      end
 
-    def install
-      FileUtils.rm_rf(sparkle_path) if File.directory?(sparkle_path) # force clean install
-      copy_zipball
-      unzip
-    end
+      def vendored_sparkle_framework_path
+        vendored_sparkle_path.join('Sparkle.framework')
+      end
 
-    def embed
-      @config.embedded_frameworks << sparkle_framework_path
-    end
+      def vendored_sparkle_xpc_path
+        vendored_sparkle_path.join('XPCServices')
+      end
 
-    def install_and_embed
-      install unless installed?
-      embed
-    end
+      def installed?
+        File.directory?(vendored_sparkle_framework_path)
+      end
 
-    def verify_installation
-      if installed?
-        App.info "Sparkle", "Framework installed in #{sparkle_framework_path.to_s}"
-      else
-        App.fail "Sparkle framework not correctly copied to #{sparkle_framework_path.to_s}
-Run `rake sparkle:install` manually or, if the problem persists,
-please explain your setup and problem as an issue on GitHub at:
-https://github.com/digitalmoksha/motion-sparkle-sandbox/issues
-"
+      def verify_installation
+        if installed?
+          App.info 'Sparkle', "Framework installed in #{vendored_sparkle_framework_path}"
+        else
+          App.fail "Sparkle Cocoapod not correctly installed to #{vendored_sparkle_path}. Run `rake pod:install`."
+        end
       end
     end
-
   end
 end

data/lib/motion/project/package.rb

@@ -1,44 +1,60 @@
-module Motion::Project
-  class Sparkle
-
-    def package
-      return unless setup_ok?
-      create_release_folder
-      @config.build_mode = :release
-      return unless create_zip_file
-      App.info "Release", version_string
-      App.info "Version", @config.short_version
-      App.info "Build", @config.version || 'unspecified in Rakefile'
-      App.info "Size", @package_size.to_s
-      sign_package
-      create_appcast
-      create_release_notes
-      `open #{sparkle_release_path}`
-    end
+# frozen_string_literal: true
 
-    def create_zip_file
-      unless File.exist?(app_bundle_path)
-        App.fail "You need to build your app with the Release target to use Sparkle"
-      end
-      if File.exist?("#{sparkle_release_path}/#{zip_file}")
-        App.fail "Release already exists at ./#{sparkle_release_path}/#{zip_file} (remove it manually with `rake sparkle:clean`)"
+module Motion
+  module Project
+    class Sparkle
+      def package
+        return unless setup_ok?
+
+        create_release_folder
+        @config.build_mode = :release
+        return unless create_zip_file
+
+        App.info 'Release', version_string
+        App.info 'Version', @config.short_version
+        App.info 'Build', @config.version || 'unspecified in Rakefile'
+        App.info 'Size', @package_size.to_s
+
+        sign_package
+        create_release_notes
+
+        `open #{sparkle_release_path}`
       end
-      FileUtils.cd(app_release_path) do
-        `zip -r --symlinks "#{zip_file}" "#{app_file}"`
+
+      def create_zip_file
+        App.fail 'You need to build your app with the Release target to use Sparkle' unless File.exist?(app_bundle_path)
+
+        App.info 'Create', "./#{sparkle_release_path}/#{zip_file}"
+
+        if File.exist?("#{sparkle_release_path}/#{zip_file}")
+          App.fail "Release already exists at ./#{sparkle_release_path}/#{zip_file} (remove it manually with `rake sparkle:clean`)"
+        end
+
+        FileUtils.cd(app_release_path) do
+          `zip -r --symlinks "#{zip_file}" "#{app_file}"`
+        end
+
+        FileUtils.mv "#{app_release_path}/#{zip_file}", "./#{sparkle_release_path}/"
+
+        @package_file = zip_file
+        @package_size = File.size "./#{sparkle_release_path}/#{zip_file}"
       end
-      FileUtils.mv "#{app_release_path}/#{zip_file}", "./#{sparkle_release_path}/"
-      App.info "Create", "./#{sparkle_release_path}/#{zip_file}"
-      @package_file = zip_file
-      @package_size = File.size "./#{sparkle_release_path}/#{zip_file}"
-    end
 
-    def sign_package
-      package = "./#{sparkle_release_path}/#{zip_file}"
-      @package_signature = `#{openssl} dgst -sha1 -binary < "#{package}" | #{openssl} dgst -dss1 -sign "#{private_key_path}" | #{openssl} enc -base64`
-      @package_signature = @package_signature.strip
-      App.info "Signature", "\"#{@package_signature}\""
-    end
+      def sign_package
+        package = "./#{sparkle_release_path}/#{zip_file}"
+        sign_update_app = "#{vendored_sparkle_path}/bin/sign_update"
+        args = []
+
+        if appcast.use_exported_private_key && File.exist?(private_key_path)
+          # -s <private-key>        The private EdDSA (ed25519) key
+          private_key = File.read(private_key_path)
+          args << "-s=#{private_key}"
+        end
 
+        results, _status = Open3.capture2e(sign_update_app, *args, package)
 
+        App.info 'Signature', results
+      end
+    end
   end
 end