reflex-packager 0.2.0 → 0.3.0

data/lib/reflex/packager/platform.rb

@@ -1,5 +1,8 @@
 require 'erb'
 require 'fileutils'
+require 'open3'
+require 'shellwords'
+require 'tmpdir'
 
 
 module Reflex
@@ -14,8 +17,36 @@ module Reflex
     #
     class Platform
 
-      def initialize(config, verbose: false)
-        @config, @verbose = config, verbose
+      class << self
+
+        # Copies the app in +dir+ to +dest+, with the Ruby scripts in its data
+        # file in place of them, compiled by DataCompiler with the Ruby running
+        # this, and the other files as they are.
+        #
+        # Unless +compile+, the data file is left out, for the package to
+        # have it written by the Ruby in it.
+        #
+        def pack_app(dir, dest, compile: true)
+          files   = Dir.glob('**/*', base: dir).select {File.file? File.join(dir, _1)}.sort
+          scripts = DataCompiler.scripts dir
+
+          FileUtils.mkdir_p dest
+          DataCompiler.write dir, File.join(dest, DataLoader::DATA_FILE) if compile
+
+          (files - scripts).each do |name|
+            path = File.join dest, name
+            FileUtils.mkdir_p File.dirname(path)
+            FileUtils.cp File.join(dir, name), path
+          end
+        end
+
+      end# self
+
+      def initialize(
+        config, verbose: false, pack: false, notarize: [], generic: false, appstore: false)
+
+        @config, @verbose, @pack, @notarize = config, verbose, pack, notarize || []
+        @generic, @appstore                 = generic, appstore
       end
 
       attr_reader :config
@@ -28,6 +59,40 @@ module Reflex
         @verbose
       end
 
+      # Whether to put the files of the app together in a data file, which
+      # the package reads them from, as for a release.
+      #
+      def pack?()
+        @pack
+      end
+
+      # The steps of the notarization, having Apple check the app for the
+      # system to open it without warnings when downloaded, as for a release:
+      # :submit to send the app, and :export to export the app notarized,
+      # waiting for it.
+      #
+      def notarize()
+        @notarize
+      end
+
+      def notarize?()
+        !@notarize.empty?
+      end
+
+      # Whether to package the generic app, for no store in particular: when
+      # asked, or notarized, which only the generic one is, or when no store
+      # is asked for.
+      #
+      def generic?()
+        @generic || notarize? || !appstore?
+      end
+
+      # Whether to package the app for the Mac App Store.
+      #
+      def appstore?()
+        @appstore
+      end
+
       # Package the application as a distributable bundle.
       #
       # @param [Boolean] generate_only generate the project files but do
@@ -38,17 +103,218 @@ module Reflex
         build unless generate_only
       end
 
+      # Generates the files to build the app from, in build_dir.
+      #
+      def generate()
+        raise "#{self.class} must implement #{__method__}"
+      end
+
+      # Builds the app from the files generated, into dist_path.
+      #
+      def build()
+        raise "#{self.class} must implement #{__method__}"
+      end
+
+      # The directory of what the packager makes for the platform.
+      #
+      def platform_dir()
+        File.join config.dir, '.build', platform_name
+      end
+
+      # The directory the app is generated and built in.
+      #
+      def build_dir()
+        platform_dir
+      end
+
+      # The variant of the package, which the directory of the package is
+      # named after: generic, for no store in particular.
+      #
+      def variant()
+        'generic'
+      end
+
+      # The directory of the package of the variant, in dist/.
+      #
+      def dist_dir(variant = self.variant)
+        File.join config.dir, 'dist', variant
+      end
+
+      # The packaged app in dist_dir.
+      #
+      def dist_path()
+        File.join dist_dir, target
+      end
+
+      # The packages of the app for the stores, as {store => path}, each of
+      # which --<store> packages, in the dist directory of the store.
+      #
+      def store_package_paths()
+        {}
+      end
+
+      # The command to zip the packaged app into archive_path.
+      #
+      def archive_command()
+        raise "#{self.class} must implement #{__method__}"
+      end
+
+      # The zip of the packaged app to hand out, in dist_dir.
+      #
+      def archive_path()
+        File.join dist_dir, "#{target}-#{config.version}-#{archive_platform}.zip"
+      end
+
+      # The platform and the architecture the packaged app runs on, as the
+      # name of its zip tells them.
+      #
+      def archive_platform()
+        platform_name
+      end
+
+      # Returns the app name without characters unsafe for target, scheme or
+      # file names.
+      #
+      def target()
+        config.name.gsub(/[^A-Za-z0-9_\-]+/, '').then {_1.empty? ? 'App' : _1}
+      end
+
+      # The script the app starts with, in the app directory: the boot script
+      # of the profile, or the main script of the app.
+      #
+      def start_script()
+        profile.boot_main || config.main
+      end
+
       private
 
-      def render(template)
+      # The name of the platform, for the build directory, the templates and
+      # the zip of the app.
+      #
+      def platform_name()
+        raise "#{self.class} must implement #{__method__}"
+      end
+
+      # Left out when copying a library: a gem build leaves its binaries in
+      # lib/, while a package links the extensions in, and the Ruby of a
+      # windows package would even prefer a rays_ext.so on the load path to
+      # the one linked in.
+      #
+      BINARY_EXTS = %w[.so .dll .a .o .bundle]
+
+      # Copies the Ruby code of a library and what it reads at run time into
+      # +dest+: lib/ without the binaries, VERSION and res/.
+      #
+      def copy_library(root, dest)
+        copy_tree File.join(root, 'lib'), File.join(dest, 'lib')
+        %w[VERSION res].map {File.join root, _1}.select {File.exist? _1}.each do |path|
+          FileUtils.mkdir_p dest
+          FileUtils.cp_r path, dest
+        end
+      end
+
+      def copy_tree(src, dest)
+        Dir.glob('**/*', base: src).each do |path|
+          from = File.join src, path
+          next if File.directory?(from) || BINARY_EXTS.include?(File.extname path)
+          to = File.join dest, path
+          FileUtils.mkdir_p File.dirname(to)
+          FileUtils.cp from, to
+        end
+      end
+
+      # The files of the app, as they are, for any platform.
+      #
+      def app_dir()
+        File.join config.dir, '.build', 'app'
+      end
+
+      # Copies the files of the app to app_dir, and to +dir+ in the build
+      # directory, as they are, or packed with what reads its data file in
+      # the reflex library of the package, if the app is to be packed.
+      #
+      def copy_app_files(dir = 'app')
+        FileUtils.rm_rf app_dir
+        FileUtils.mkdir_p app_dir
+        config.app_files.each do |file|
+          dest = File.join app_dir, file
+          FileUtils.mkdir_p File.dirname(dest)
+          FileUtils.cp File.join(config.dir, file), dest
+        end
+        File.write File.join(app_dir, profile.boot_main), profile.boot if
+          profile.boot_main && profile.boot
+
+        dir = File.join build_dir, dir
+        FileUtils.rm_rf dir
+        FileUtils.mkdir_p dir
+        if pack?
+          raise Error, 'a packed app needs reflex in its libraries' unless
+            libraries.any? {_1.name == 'reflex'}
+          Platform.pack_app app_dir, dir, compile: compile_on_generate?
+          loader = File.join library_lib_dir('reflex'), 'reflex', 'packager'
+          FileUtils.mkdir_p loader
+          %w[data_file.rb data_loader.rb].each {FileUtils.cp File.join(__dir__, _1), loader}
+        else
+          FileUtils.cp_r File.join(app_dir, '.'), dir
+        end
+      end
+
+      # Whether the scripts of a packed app are compiled when generating, by
+      # the Ruby running this, which is the one the package runs them on.
+      #
+      def compile_on_generate?()
+        true
+      end
+
+      def write(path, content)
+        path = File.expand_path path, build_dir
+        FileUtils.mkdir_p File.dirname(path)
+        File.write path, content
+      end
+
+      # Renders the template with the packager's methods, and +vars+ as
+      # local variables.
+      #
+      def render(template, **vars)
         path = File.join TEMPLATES_DIR, platform_name, template
-        ERB.new(File.read(path), trim_mode: '-').result binding
+        b    = template_binding
+        vars.each {|name, value| b.local_variable_set name, value}
+        ERB.new(File.read(path), trim_mode: '-').result b
       end
 
-      def run(*cmd, chdir:, env: {})
-        puts "==> #{cmd.join ' '}"
-        return if system env, *cmd, chdir: chdir
-        raise Error, "command failed: #{cmd.join ' '}"
+      # A binding with the packager's methods and nothing else: a template
+      # sees every local variable of the method its binding is made in.
+      #
+      def template_binding()
+        binding
+      end
+
+      # Runs +cmd+, dropping what it prints if +quiet+ unless verbose, though
+      # not the errors it tells. The command is run as it is, not split by
+      # spaces even if it is only a path, as of the app named with spaces.
+      #
+      def run(*cmd, chdir: nil, env: {}, quiet: false)
+        puts "==> #{cmd.shelljoin}"
+        out = quiet && !verbose? ? {out: File::NULL} : {}
+        ok  = with_dir(chdir) {system env, [cmd.first, cmd.first], *cmd.drop(1), chdir: _1, **out}
+        return if ok
+        raise Error, "command failed: #{cmd.shelljoin}"
+      end
+
+      # Runs +cmd+, returning what it prints and whether it succeeded, for
+      # the caller to tell what failed.
+      #
+      def capture(*cmd, chdir: nil)
+        out, status = with_dir(chdir) {Open3.capture2e(*cmd, chdir: _1)}
+        [out, status.success?]
+      end
+
+      # Calls the block with +dir+ for a command to run in, or with no +dir+,
+      # a temporary directory removed after, not for the command to depend
+      # on where the packager is run from.
+      #
+      def with_dir(dir, &block)
+        dir ? block.call(dir) : Dir.mktmpdir(&block)
       end
 
       def check_tools(tools)
@@ -60,8 +326,21 @@ module Reflex
       end
 
       def executable?(name)
-        ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
-          .any? {|dir| File.executable? File.join(dir, name.to_s)}
+        !!find_executable(name)
+      end
+
+      # Windows finds 'g++' as 'g++.exe' through PATHEXT, which is separated
+      # by ';' whatever the platform.
+      #
+      def find_executable(name)
+        exts = ['', *ENV['PATHEXT'].to_s.split(';')]
+        ENV['PATH'].to_s.split(File::PATH_SEPARATOR).each do |dir|
+          exts.each do |ext|
+            path = File.join dir, "#{name}#{ext}"
+            return path if File.file?(path) && File.executable?(path)
+          end
+        end
+        nil
       end
 
     end# Platform

data/lib/reflex/packager/profile.rb

@@ -1,48 +1,64 @@
+require 'reflex/packager/library'
+
+
 module Reflex
 
 
   module Packager
 
 
-    # Describes the runtime a packaged app embeds: the umbrella pod that
-    # provides the native build, the extensions and libraries registered with
-    # CRuby, and the scaffold for the 'new' command.
+    # Describes the runtime a packaged app embeds: the gem it is made of, the
+    # libraries and extensions the gem depends on, and the scaffold for the
+    # 'new' command.
     #
     # The packager itself is runtime-agnostic; each gem (reflex, rubysketch,
     # ...) supplies its own profile and reuses this packager as the engine.
     #
     class Profile
 
-      # @param [String]               pod          umbrella pod name (e.g. 'Reflex')
-      # @param [String]               git          umbrella pod git repository
-      # @param [String]               version      umbrella pod version (for the tag)
-      # @param [Array<String>]        libraries    ruby lib bundles to add to load path
-      # @param [Array<String>]        extensions   native exts to register (Init_<name>)
+      # @param [Module]               extension    Extension of the gem (e.g. Reflex::Extension)
       # @param [Array<String>]        config_files config file names, preferred first
       # @param [Hash{String=>String}] templates    'new' scaffold files ({filename => content})
-      # @param [String, nil]          command      CLI command name (default: pod_key)
+      # @param [String, nil]          command      CLI command name (default: the name in lower case)
       # @param [String, nil]          boot         boot script overrides config main (default: nil)
       #
-      def initialize(
-        pod:, git:, version:, libraries:, extensions:, config_files:, templates:,
-        command: nil, boot: nil)
-
-        @pod          = pod
-        @git          = git
-        @version      = version
-        @libraries    = libraries
-        @extensions   = extensions
+      def initialize(extension:, config_files:, templates:, command: nil, boot: nil)
+        @extension    = extension
         @config_files = config_files
         @templates    = templates
         @command      = command
         @boot         = boot
       end
 
-      attr_reader :pod, :git, :version, :libraries, :extensions, :config_files,
-        :templates, :boot
+      attr_reader :extension, :config_files, :templates, :boot
+
+      # The name of the gem (e.g. 'Reflex').
+      #
+      def name()
+        extension.name
+      end
+
+      def version()
+        extension.version
+      end
+
+      # The libraries the gem depends on, and the gem itself, each after the
+      # ones it depends on.
+      #
+      # @return [Array<Library>] libraries
+      #
+      def libraries()
+        @libraries ||= Library.collect extension.root_dir
+      end
+
+      # Native extensions to register (Init_<name>).
+      #
+      def extensions()
+        libraries.filter_map(&:extension)
+      end
 
       def command()
-        @command || pod_key
+        @command || name.downcase
       end
 
       def main()
@@ -53,12 +69,8 @@ module Reflex
         @boot ? '__reflex_main__.rb' : nil
       end
 
-      def pod_key()
-        pod.downcase.to_sym
-      end
-
       def bundle_id_prefix()
-        "org.xord.#{pod_key}"
+        "org.xord.#{name.downcase}"
       end
 
     end# Profile

data/lib/reflex/packager/profiles/reflex.rb

@@ -0,0 +1,43 @@
+require 'reflex/extension'
+require 'reflex/packager/profile'
+
+
+module Reflex
+
+
+  module Packager
+
+
+    # The profile to package an app of Reflex with.
+    #
+    REFLEX = Profile.new(
+      extension:    Reflex::Extension,
+      config_files: %w[reflex.yml reflex.yaml],
+      templates:    {'main.rb': <<~MAIN, 'reflex.yml': <<~CONFIG})
+        require 'reflex'
+
+        view = Reflex::View.new
+        def view.on_draw(e)
+          e.painter.font nil, 48
+          e.painter.text 'hello, world!', 100, 100
+        end
+
+        win = Reflex::Window.new
+        win.title = '{{name}}'
+        win.frame = [100, 100, 400, 300]
+        win.add view
+        win.show
+
+        Reflex.start
+      MAIN
+        name: {{name}}
+        version: 1.0.0
+        #bundle_id: org.xord.reflex.example.{{name_id}}
+        #icon: icon.png
+      CONFIG
+
+
+  end# Packager
+
+
+end# Reflex

data/lib/reflex/packager/rake.rb

@@ -0,0 +1,115 @@
+require 'rbconfig'
+require 'xot/rake'
+require 'reflex/packager'
+require 'reflex/packager/profiles/reflex'
+
+
+module Reflex
+
+
+  module Packager
+
+
+    module Rake
+
+      def package_application()
+        config       = Config.load REFLEX, '.'
+        platform     = PLATFORMS[Packager.default_platform].new config, pack: true
+        app_path     = platform.dist_path
+        archive_path = platform.archive_path
+        tag          = "v#{config.version}"
+        srcs         = [
+          *config.app_files,
+          *REFLEX.config_files,
+          'VERSION',
+          'Gemfile.lock'
+        ].select {File.file? _1}
+
+        relative       = -> path {path.delete_prefix "#{config.dir}/"}
+        reflex_package = -> *args do
+          reflex = File.expand_path '../../../bin/reflex', __dir__
+          sh RbConfig.ruby, reflex, 'package', '--pack', *args, '.'
+        end
+
+        desc "package the application into #{relative[app_path]}"
+        alias_task :package => app_path
+
+        desc "archive the application into #{relative[archive_path]}"
+        alias_task :archive => archive_path
+
+        namespace :package do
+          platform.store_package_paths.each do |store, path|
+            desc "package the application for #{store} into #{relative[path]}"
+            alias_task store => path
+          end
+        end
+
+        desc "release the application archived or packaged on GitHub, by the tag #{tag}"
+        task :release do
+          ref = ENV['GITHUB_REF_NAME']
+          raise "#{ref} is not the tag of the version, #{tag}" if ref && ref != tag
+          paths = [archive_path, *platform.store_package_paths.values].select {File.file? _1}
+          raise 'nothing to release, archive or package the application first' if paths.empty?
+          release_on_github(*paths, tag: tag, notes: release_notes(tag))
+        end
+
+        namespace :upload do
+          desc "upload #{relative[archive_path]} to itch.io"
+          task :itchio => archive_path do
+            project = config.upload.itchio_project ||
+              raise("no upload.itchio.project in #{REFLEX.config_files.first}")
+            Stores::Itchio.new(project).upload archive_path,
+              channel: Packager.default_platform.to_s, version: config.version
+          end
+
+          platform.store_package_paths[:appstore]&.then do |pkg_path|
+            desc "upload #{relative[pkg_path]} to App Store Connect"
+            task :appstore => pkg_path do
+              Stores::AppStore.new.upload pkg_path, platform: Packager.default_platform.to_s
+            end
+          end
+        end
+
+        task :clean do
+          rm_rf File.dirname(platform.dist_dir)
+        end
+
+        task :clobber => :clean do
+          rm_rf File.dirname(platform.platform_dir)
+        end
+
+        file app_path => srcs do
+          reflex_package.call
+        end
+
+        file archive_path => app_path do
+          sh(*platform.archive_command)
+        end
+
+        platform.store_package_paths.each do |store, path|
+          file path => srcs do
+            reflex_package.call "--#{store}"
+          end
+        end
+      end
+
+      private
+
+      def release_notes(tag)
+        commit = git('-C', Reflex::Extension.root_dir, 'rev-parse', 'HEAD', err: File::NULL).strip
+        [
+          Xot::ChangeLog.new.changes(tag),
+          ("Built with xord/all@#{commit}." unless commit.empty?)
+        ].compact.join("\n\n")
+      end
+
+    end# Rake
+
+
+  end# Packager
+
+
+end# Reflex
+
+
+include Reflex::Packager::Rake

data/lib/reflex/packager/stores/app_store.rb

@@ -0,0 +1,60 @@
+require 'shellwords'
+
+
+module Reflex
+
+
+  module Packager
+
+
+    # The stores to hand out the app at.
+    #
+    module Stores
+
+
+      # The App Store, which the app is uploaded to by altool of Xcode, as an
+      # installer package, by the API key of App Store Connect in the
+      # environment variables, as notarizing on CI is.
+      #
+      class AppStore
+
+        def initialize(app_store_connect = AppStoreConnect.new)
+          @app_store_connect = app_store_connect
+        end
+
+        # Uploads +path+, the installer package of the app for +platform+, as
+        # macos, which App Store Connect tells the app and the version of by
+        # its Info.plist.
+        #
+        def upload(path, platform:)
+          raise Error, "nothing to upload: '#{path}'" unless File.file? path
+
+          asc = @app_store_connect
+          asc.with_key_path do |key_path|
+            cmd = [
+              'xcrun', 'altool', '--upload-package', path,
+              '--platform',     platform,
+              '--api-key',      asc.credentials[:key_id],
+              '--api-issuer',   asc.credentials[:issuer_id],
+              '--p8-file-path', key_path
+            ]
+            puts "==> #{cmd.shelljoin}"
+            case system(*cmd)
+            when nil
+              raise Error, 'xcrun not found, install Xcode'
+            when false
+              raise Error, "failed to upload: #{cmd.shelljoin}"
+            end
+          end
+        end
+
+      end# AppStore
+
+
+    end# Stores
+
+
+  end# Packager
+
+
+end# Reflex