reflex-packager 0.2.0 → 0.3.0

data/lib/reflex/packager/windows.rb

@@ -0,0 +1,370 @@
+require 'rbconfig'
+require 'shellwords'
+require 'reflex/packager/platform'
+require 'reflex/packager/gems'
+
+
+module Reflex
+
+
+  module Packager
+
+
+    # Packages a Reflex application as a Windows executable with the Ruby
+    # runtime it runs on next to it.
+    #
+    # The executable links the Ruby DLL of RubyInstaller, and the native
+    # libraries (xot, rucy, rays, ...) statically from the archives and the
+    # ext objects a gem build leaves in the installed gems. Each extension is
+    # registered with ruby_init_ext, so requiring it initializes the copy
+    # linked in, as --with-static-linked-ext does.
+    #
+    class Windows < Platform
+
+      include Gems
+
+      TOOLCHAIN_HINT = 'install RubyInstaller with the MSYS2 DevKit (ridk install)'
+
+      # The dlls the executable loads go in this directory, which is a
+      # private assembly of the same name that the manifest embedded in the
+      # executable depends on. Having the ruby dll in lib/ (or bin/) also
+      # makes the parent directory the prefix, where Ruby looks for lib/ruby.
+      #
+      RUNTIME_DIR     = 'lib'
+      RUNTIME_VERSION = '1.0.0.0'
+
+      # Sizes of the icon of the executable, one image each in the ICO.
+      #
+      ICON_SIZES = [16, 32, 48, 256]
+
+      def package(generate_only: false)
+        raise Error, 'notarizing is only for macos'        if notarize?
+        raise Error, 'the Mac App Store is only for macos' if appstore?
+        super
+      end
+
+      def generate()
+        copy_libraries
+        copy_app_files 'lib/app'
+        write 'src/main.cpp',     render('main.cpp.erb')
+        write 'src/app.manifest', render('app.manifest.erb')
+        write 'src/app.rc',       render('app.rc.erb')
+        write 'lib/boot.rb',      render('boot.rb.erb')
+        generate_icon if config.icon
+      end
+
+      def generate_icon()
+        File.binwrite File.join(build_dir, 'src', 'app.ico'), Windows.ico(icon_pngs)
+      end
+
+      # [[size, png], ...] of the icon drawn at each size with Rays.
+      #
+      def icon_pngs()
+        require 'rays'
+        icon = Rays::Image.load File.join(config.dir, config.icon), smooth: true
+        ICON_SIZES.map do |size|
+          path = File.join build_dir, 'src', "icon_#{size}.png"
+          Rays::Image.new(size, size).paint {|p| p.image icon, 0, 0, size, size}.save path
+          [size, File.binread(path)]
+        end
+      end
+
+      # An ICO of the PNGs: ICONDIR, an ICONDIRENTRY per image, then the
+      # images. Windows takes PNG images in an ICO since Vista, and a size of
+      # 256 is written as 0.
+      #
+      def self.ico(pngs)
+        offset  = 6 + 16 * pngs.size
+        entries = pngs.map do |size, png|
+          entry   = [size % 256, size % 256, 0, 0, 1, 32, png.bytesize, offset].pack 'C4v2V2'
+          offset += png.bytesize
+          entry
+        end
+        [[0, 1, pngs.size].pack('v3'), *entries, *pngs.map {_1.last.b}].join
+      end
+
+      def build()
+        enable_toolchain
+        check_tools tools
+        # the strings of the app name are in utf-8
+        run 'windres', '--codepage=65001', 'app.rc', '-o', 'app.res.o',
+          chdir: File.join(build_dir, 'src')
+        run(*link_command, chdir: build_dir)
+        copy_dist
+      end
+
+      # The command to zip the packaged app into archive_path, with its
+      # folder, by the tar of Windows, which writes a zip by the extension.
+      # The tar of MSYS2 or git, which may come first on PATH, cannot.
+      #
+      def archive_command()
+        tar = File.join ENV['SystemRoot'] || 'C:/Windows', 'System32', 'tar.exe'
+        [tar, '-a', '-c', '-f', archive_path, '-C', dist_dir, File.basename(dist_path)]
+      end
+
+      # The architecture is the one of the ruby the executable is made with.
+      #
+      def archive_platform(rbconfig = RbConfig::CONFIG)
+        "windows-#{rbconfig['host_cpu'].match?(/arm|aarch64/) ? 'arm64' : 'x64'}"
+      end
+
+      def tools()
+        {compiler.first => TOOLCHAIN_HINT, 'windres' => TOOLCHAIN_HINT, 'objdump' => TOOLCHAIN_HINT}
+      end
+
+      # Directories under lib/ boot.rb puts on the load path, in the order of
+      # lib_names: the libraries, and the gems under gems/, apart from what
+      # else lib/ has, as ruby/ and app/.
+      #
+      def load_dirs()
+        gems = gem_names
+        lib_names.map {gems.include?(_1) ? File.join('gems', _1) : _1}
+      end
+
+      # Libraries built from native code: the ones whose gem has the static
+      # archive the extension was linked from.
+      #
+      def native_libraries()
+        libraries.select {File.file? static_archive(_1)}
+      end
+
+      def ext_objects()
+        libraries.select(&:extension).flat_map do |lib|
+          objs = Dir.glob(File.join lib.root, 'ext', lib.name, '*.o').sort
+          raise Error, "no objects of '#{lib.extension}' in '#{lib.root}' (was the gem built?)" if
+            objs.empty?
+          objs
+        end
+      end
+
+      # Static archives of the native libraries, the ones depending on the
+      # others first.
+      #
+      def static_archives()
+        native_libraries.reverse.map {static_archive _1}
+      end
+
+      # System libraries the extensions link, as the Makefiles their gem builds
+      # leave have them.
+      #
+      def system_libs()
+        native_libraries.flat_map do |lib|
+          makefile = File.join lib.root, 'ext', lib.name, 'Makefile'
+          File.file?(makefile) ? Windows.makefile_libs(File.read makefile) : []
+        end.uniq
+      end
+
+      # The names in the -l options of the LIBS of a Makefile mkmf writes.
+      #
+      def self.makefile_libs(makefile)
+        line = makefile.lines.find {_1.start_with? 'LIBS ='} or return []
+        line.split.filter_map {_1[/\A-l(.+)\z/, 1]}
+      end
+
+      # Paths of the DLLs of the toolchain the executable loads, directly or
+      # through another one: the import tables are followed from the
+      # executable as far as the DLLs beside the compiler go. The ones of
+      # Windows and the ruby dll end it, and any other is not to be found.
+      #
+      def toolchain_dlls(rbconfig = RbConfig::CONFIG)
+        @toolchain_dlls ||= begin
+          dir = toolchain_dir(rbconfig) or
+            raise Error, "compiler not found: #{TOOLCHAIN_HINT}"
+          found = {}
+          exe   = File.join build_dir, "#{target}.exe"
+          queue = dll_imports(exe).map {[_1, exe]}
+          until queue.empty?
+            dll, by = queue.shift
+            next if found.key? dll.downcase
+            path = File.join dir, dll
+            if File.file? path
+              found[dll.downcase] = path
+              queue.concat dll_imports(path).map {[_1, path]}
+            else
+              raise Error, "'#{dll}' needed by #{File.basename by} not found" unless
+                system_dll? dll, rbconfig
+              found[dll.downcase] = nil
+            end
+          end
+          found.values.compact
+        end
+      end
+
+      # DLLs the executable loads from lib/, listed in its manifest.
+      #
+      def runtime_dlls(rbconfig = RbConfig::CONFIG)
+        [rbconfig['LIBRUBY_SO'], *toolchain_dlls(rbconfig).map {File.basename _1}]
+      end
+
+      # The versions of the product and of the build, as the four numbers of
+      # the version resource and the assembly version.
+      #
+      def product_version()
+        Windows.four_numbers config.display_version
+      end
+
+      def file_version()
+        Windows.four_numbers config.build_version
+      end
+
+      # The first four numbers of +version+, filled up to four, which have to
+      # be in 0..65535.
+      #
+      def self.four_numbers(version)
+        numbers = version.split('.').first(4).map(&:to_i)
+        raise Error, "a number in the version '#{version}' is over 65535" if
+          numbers.any? {_1 > 65535}
+        (numbers + [0] * 4).first(4).join '.'
+      end
+
+      # The language id of a block of the version resource, for +lang+ of the
+      # localizations, as Windows has it.
+      #
+      def langid(lang)
+        return 0x0409 if lang == 'en' # U.S. English, the one of the values out of them
+        id = Windows.lcid(lang) & 0xffff
+        raise Error, "unknown language on windows: '#{lang}'" if
+          id == 0 || id == LOCALE_CUSTOM_UNSPECIFIED
+        id
+      end
+
+      LOCALE_CUSTOM_UNSPECIFIED = 0x1000
+
+      # The locale id Windows has for the locale +name+, or 0.
+      #
+      def self.lcid(name)
+        require 'fiddle'
+        @locale_name_to_lcid ||= Fiddle::Function.new(
+          Fiddle.dlopen('kernel32')['LocaleNameToLCID'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+        @locale_name_to_lcid.call "#{name}\0".encode('UTF-16LE'), 0
+      end
+
+      # +str+ as a string literal of a resource script, which doubles a quote
+      # rather than escaping it.
+      #
+      def rc_string(str)
+        %("#{str.gsub('\\', '\\\\\\\\').gsub('"', '""')}")
+      end
+
+      def compiler(rbconfig = RbConfig::CONFIG)
+        # may carry flags, e.g. 'g++ -std=gnu++11'
+        rbconfig['CXX'].shellsplit
+      end
+
+      # Compiles src/main.cpp and links it into the executable, run in the
+      # build directory.
+      #
+      def link_command(rbconfig = RbConfig::CONFIG)
+        [
+          *compiler(rbconfig), 'src/main.cpp', 'src/app.res.o', '-o', "#{target}.exe",
+          "-I#{rbconfig['rubyhdrdir']}", "-I#{rbconfig['rubyarchhdrdir']}",
+          *ext_objects,
+          '-Wl,--whole-archive', *static_archives, '-Wl,--no-whole-archive',
+          "-L#{rbconfig['libdir']}", *rbconfig['LIBRUBYARG_SHARED'].shellsplit,
+          *system_libs.map {"-l#{_1}"},
+          *('-mwindows' unless config.windows.console?)
+        ]
+      end
+
+      # Copies what the executable needs from the Ruby it was built with:
+      # the dlls into lib/, the standard library into lib/ruby.
+      #
+      def copy_runtime(dest, rbconfig = RbConfig::CONFIG)
+        runtime = File.join dest, RUNTIME_DIR
+        bindir  = rbconfig['bindir']
+        FileUtils.mkdir_p runtime
+        FileUtils.cp File.join(bindir, rbconfig['LIBRUBY_SO']), runtime
+
+        # the ruby dll finds these through the manifest in the directory, so
+        # the directory has to come along as it is
+        builtin = File.join bindir, 'ruby_builtin_dlls'
+        FileUtils.cp_r builtin, runtime if File.directory? builtin
+
+        toolchain_dlls(rbconfig).each {FileUtils.cp _1, runtime}
+        File.write File.join(runtime, "#{RUNTIME_DIR}.manifest"),
+          render('runtime.manifest.erb', dlls: runtime_dlls(rbconfig))
+
+        stdlib = File.join dest, 'lib', 'ruby'
+        FileUtils.mkdir_p stdlib
+        FileUtils.cp_r File.join(rbconfig['rubylibprefix'], rbconfig['ruby_version']), stdlib
+      end
+
+      private
+
+      def platform_name()
+        'windows'
+      end
+
+      # The ruby dll the executable links is the one the gems are built for.
+      #
+      def native_gems?()
+        true
+      end
+
+      def static_archive(lib)
+        File.join lib.root, 'lib', "lib#{lib.name}.a"
+      end
+
+      # The lib directory of the library +name+ in the package.
+      #
+      def library_lib_dir(name)
+        File.join build_dir, 'lib', name, 'lib'
+      end
+
+      def copy_libraries()
+        dir = File.join build_dir, 'lib'
+        FileUtils.rm_rf dir
+        libraries.each {copy_library _1.root, File.join(dir, _1.name)}
+        copy_gems {File.join dir, 'gems', _1, 'lib'}
+      end
+
+      def copy_dist()
+        dist = dist_path
+        FileUtils.rm_rf dist
+        FileUtils.mkdir_p dist
+        %W[#{target}.exe lib].each do |path|
+          FileUtils.cp_r File.join(build_dir, path), dist
+        end
+        copy_runtime dist
+        puts "Created #{dist}"
+      end
+
+      # Puts the MSYS2 toolchain of RubyInstaller on the PATH as gem install
+      # does, so that packaging works from any shell without 'ridk enable'.
+      #
+      def enable_toolchain()
+        require 'ruby_installer/runtime'
+        RubyInstaller::Runtime.enable_msys_apps
+      rescue LoadError
+      end
+
+      # The directory of the compiler, where MSYS2 keeps the DLLs of the
+      # toolchain and its packages, rather than PATH, where another toolchain,
+      # as the one of git, may come first with its own.
+      #
+      def toolchain_dir(rbconfig = RbConfig::CONFIG)
+        cxx      = rbconfig['CXX']&.shellsplit&.first
+        compiler = cxx && (File.absolute_path?(cxx) ? cxx : find_executable(cxx))
+        compiler && File.dirname(compiler)
+      end
+
+      def system_dll?(dll, rbconfig)
+        dll.casecmp?(rbconfig['LIBRUBY_SO']) ||
+          dll.match?(/\A(api|ext)-ms-/i) ||# api sets, which windows resolves
+          File.file?(File.join ENV['SystemRoot'].to_s, 'System32', dll)
+      end
+
+      def dll_imports(path)
+        out, status = Open3.capture2 'objdump', '-p', path
+        raise Error, "objdump failed: #{path}" unless status.success?
+        out.scan(/DLL Name: (\S+)/).flatten
+      end
+
+    end# Windows
+
+
+  end# Packager
+
+
+end# Reflex

data/lib/reflex/packager.rb

@@ -1,12 +1,29 @@
 require 'reflex/packager/extension'
 
+require 'reflex/packager/data_file'
+require 'reflex/packager/data_compiler'
+require 'reflex/packager/data_loader'
+
 require 'reflex/packager/profile'
 require 'reflex/packager/config'
 require 'reflex/packager/platform'
+require 'reflex/packager/gems'
+require 'reflex/packager/app_store_connect'
 require 'reflex/packager/macos'
+require 'reflex/packager/windows'
+require 'reflex/packager/stores/app_store'
+require 'reflex/packager/stores/itchio'
 require 'reflex/packager/cli'
 
 
 module Reflex::Packager
-  PLATFORMS = {macos: MacOS}
+
+  PLATFORMS = {macos: MacOS, windows: Windows}
+
+  # The platform the packager runs on, the only one it can build for.
+  #
+  def self.default_platform()
+    Gem.win_platform? ? :windows : :macos
+  end
+
 end

data/reflex-packager.gemspec

@@ -11,13 +11,13 @@ Gem::Specification.new do |s|
 
   ext   = Reflex::Packager::Extension
   name  = ext.name true
-  rdocs = glob.call *%w[README]
+  rdocs = glob.call(*%w[README])
 
   s.name        = name
   s.version     = ext.version
   s.license     = 'MIT'
-  s.summary     = 'Package Reflex applications as native app bundles.'
-  s.description = 'CLI tool to package Reflex applications as native macOS application bundles.'
+  s.summary     = 'Package Reflex applications as native apps.'
+  s.description = 'CLI tool to package Reflex applications as native macOS and Windows applications.'
   s.authors     = %w[xordog]
   s.email       = 'xordog@gmail.com'
   s.homepage    = "https://github.com/xord/reflex-packager"
@@ -25,10 +25,11 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_dependency 'xot',       '~> 0.4.0'
-  s.add_dependency 'rucy',      '~> 0.4.0'
-  s.add_dependency 'rays',      '~> 0.4.0'
-  s.add_dependency 'reflexion', '~> 0.6.0'
+  s.add_dependency 'fiddle'
+  s.add_dependency 'xot',       '~> 0.5.0'
+  s.add_dependency 'rucy',      '~> 0.5.0'
+  s.add_dependency 'rays',      '~> 0.5.0'
+  s.add_dependency 'reflexion', '~> 0.7.0'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/test/helper.rb

@@ -7,17 +7,53 @@ require 'reflex/extension'
 require 'reflex/packager'
 
 require 'test/unit'
+require 'tempfile'
 require 'tmpdir'
 
 include Xot::Test
 
 
+# Makes +dir+ a checkout of the cruby repository with what packaging for macOS
+# reads of it, so that the tests do not fetch the real one.
+#
+def fake_cruby(dir)
+  %w[CRuby/include/ruby.h CRuby/lib/ruby/4.0.0/set.rb src/CRuby.m].each do |path|
+    path = File.join dir, path
+    FileUtils.mkdir_p File.dirname(path)
+    FileUtils.touch path
+  end
+  dir
+end
+
+# Runs the block with the method +name+ of +obj+ returning +value+.
+#
+def stub(obj, name, value, &block)
+  # removed before defined again, which warns on overwriting
+  klass  = obj.singleton_class
+  hidden = klass.private_method_defined? name, false
+  saved  = klass.instance_method name if hidden || klass.method_defined?(name, false)
+  klass.remove_method name if saved
+  klass.define_method(name) {|*| value}
+  block.call
+ensure
+  klass.remove_method name
+  klass.define_method name, saved if saved
+  klass.send :private, name       if hidden
+end
+
+# Runs the block with the environment variables of +env+, nil to unset.
+#
+def with_env(env, &block)
+  saved = env.map {|key, _| [key, ENV[key]]}
+  env.each {|key, value| value ? ENV[key] = value : ENV.delete(key)}
+  block.call
+ensure
+  saved.each {|key, value| value ? ENV[key] = value : ENV.delete(key)}
+end
+
+
 TEST_PROFILE = Reflex::Packager::Profile.new(
-  pod:          'Reflex',
-  git:          'https://github.com/xord/reflex',
-  version:      Reflex::Extension.version,
-  libraries:    %w[Xot Rucy Rays Reflex],
-  extensions:   %w[rays_ext reflex_ext],
+  extension:    Reflex::Extension,
   config_files: %w[reflex.yml reflex.yaml],
   templates:    {'main.rb': <<~MAIN, 'reflex.yml': <<~CONFIG})
     require 'reflex'
@@ -28,3 +64,12 @@ TEST_PROFILE = Reflex::Packager::Profile.new(
   MAIN
     name: myapp
   CONFIG
+
+# The environment variables to sign with, to unset by with_env for the tests
+# not to take the ones of the developer.
+#
+ENV_TO_SIGN = [
+  *Reflex::Packager::MacOSConfig::CODESIGN_ENV_KEYS.values,
+  *Reflex::Packager::MacOS::CODESIGN_P12_ENV_KEYS.values,
+  *Reflex::Packager::AppStoreConnect::AUTH_ENV_KEYS.values
+].to_h {[_1, nil]}

data/test/test_packager_app_store_connect.rb

@@ -0,0 +1,108 @@
+require_relative 'helper'
+
+
+class TestPackagerAppStoreConnect < Test::Unit::TestCase
+
+  RP  = Reflex::Packager
+  ASC = RP::AppStoreConnect
+
+  # App Store Connect with a key of its own, answering the requests to the
+  # paths under the notary service by +answers+.
+  def asc(answers = {}, &block)
+    Dir.mktmpdir do |dir|
+      path = File.join dir, 'AuthKey.p8'
+      File.write path, OpenSSL::PKey::EC.generate('prime256v1').to_pem
+      asc = ASC.new issuer_id: 'ISSUER', key_id: 'KEY', key_path: path
+      asc.define_singleton_method(:get) do |path|
+        answers.fetch(path.delete_prefix '/notary/v2/').then {_1.is_a?(Proc) ? _1.call : _1}
+      end
+      asc.define_singleton_method(:sleep) {|*|}
+      asc.define_singleton_method(:puts)  {|*|}
+      block.call asc, path
+    end
+  end
+
+  def status(str)
+    {'data' => {'attributes' => {'status' => str}}}
+  end
+
+  def test_credentials()
+    keys = ASC::AUTH_ENV_KEYS
+    with_env ENV_TO_SIGN do
+      assert_nil ASC.credentials
+      assert_raise(RP::Error) {ASC.new}
+    end
+    creds = {issuer_id: 'ISSUER', key_id: 'KEY', key_path: '/a.p8'}
+    with_env ENV_TO_SIGN.merge(creds.to_h {[keys[_1], _2]}) do
+      assert_equal creds, ASC.credentials
+    end
+    with_env ENV_TO_SIGN.merge(keys[:key_id] => '', keys[:key_path] => '/a.p8') do
+      error = assert_raise(RP::Error) {ASC.credentials}
+      assert_include error.message, keys[:key_id]
+    end
+
+    # by the content of the .p8 file, as a secret of CI
+    creds = {issuer_id: 'ISSUER', key_id: 'KEY', key_p8: 'P8'}
+    with_env ENV_TO_SIGN.merge(creds.to_h {[keys[_1], _2]}) do
+      assert_equal creds, ASC.credentials
+    end
+    with_env ENV_TO_SIGN.merge(keys[:issuer_id] => 'ISSUER', keys[:key_id] => 'KEY') do
+      error = assert_raise(RP::Error) {ASC.credentials}
+      assert_include error.message, "#{keys[:key_p8]} or #{keys[:key_path]}"
+    end
+  end
+
+  def test_token()
+    asc do |asc, path|
+      header, payload, signature = asc.__send__(:token).split('.')
+      decode = -> str {(str + '=' * (-str.size % 4)).tr('-_', '+/').unpack1 'm0'}
+      assert_equal 'KEY',    JSON.parse(decode[header])['kid']
+      assert_equal 'ISSUER', JSON.parse(decode[payload])['iss']
+
+      # the raw r and s, which OpenSSL takes in DER
+      r, s = decode[signature].unpack('a32a32').map {OpenSSL::BN.new _1, 2}
+      der  = OpenSSL::ASN1::Sequence([OpenSSL::ASN1::Integer(r), OpenSSL::ASN1::Integer(s)]).to_der
+      assert OpenSSL::PKey.read(File.read path).verify('SHA256', der, "#{header}.#{payload}")
+
+      # by the content of the .p8 file
+      p8 = File.read path
+      header, payload, signature = ASC.new(issuer_id: 'ISSUER', key_id: 'KEY', key_p8: p8)
+        .__send__(:token).split('.')
+      r, s = decode[signature].unpack('a32a32').map {OpenSSL::BN.new _1, 2}
+      der  = OpenSSL::ASN1::Sequence([OpenSSL::ASN1::Integer(r), OpenSSL::ASN1::Integer(s)]).to_der
+      assert OpenSSL::PKey.read(p8).verify('SHA256', der, "#{header}.#{payload}")
+    end
+  end
+
+  def test_wait_until_notarized()
+    statuses = [status('In Progress'), status('Accepted')]
+    asc 'submissions/abc' => -> {statuses.shift} do |asc, _|
+      assert_nothing_raised {asc.wait_until_notarized 'ABC'} # in lower case
+      assert_empty statuses
+    end
+
+    asc 'submissions/abc' => status('In Progress') do |asc, _|
+      error = assert_raise(RP::Error) {asc.wait_until_notarized 'abc', timeout: -1}
+      assert_include error.message, 'timed out'
+    end
+
+    asc 'submissions/abc' => {} do |asc, _|
+      error = assert_raise(RP::Error) {asc.wait_until_notarized 'abc'}
+      assert_include error.message, 'unknown status of the notarization: nil'
+    end
+
+    log     = {'issues' => [{'path' => 'a.app/b', 'message' => 'not signed'}]}
+    answers = {
+      'submissions/abc'      => status('Invalid'),
+      'submissions/abc/logs' => {'data' => {'attributes' => {'developerLogUrl' => 'https://log'}}}
+    }
+    asc answers do |asc, _|
+      stub Net::HTTP, :get, log.to_json do
+        error = assert_raise(RP::Error) {asc.wait_until_notarized 'abc'}
+        assert_include error.message, 'Invalid'
+        assert_include error.message, 'a.app/b: not signed'
+      end
+    end
+  end
+
+end# TestPackagerAppStoreConnect

data/test/test_packager_cli.rb

@@ -63,10 +63,27 @@ class TestPackagerCLI < Test::Unit::TestCase
   def test_package()
     tmpdir do
       capture {cli.create ['myapp']}
-      cli.package ['--generate-only', 'myapp']
-      %w[project.yml Podfile src/main.mm app/main.rb].each do |f|
-        assert File.exist?("myapp/build/macos/#{f}"), "missing #{f}"
+      Dir.mktmpdir do |cruby|
+        saved, ENV['CRUBY_PATH'] = ENV['CRUBY_PATH'], fake_cruby(cruby)
+        cli.package ['--generate-only', '--platform', 'macos', 'myapp']
+      ensure
+        ENV['CRUBY_PATH'] = saved
       end
+      %w[project.yml src/main.mm app/main.rb].each do |f|
+        assert File.exist?("myapp/.build/macos/project/#{f}"), "missing #{f}"
+      end
+    end
+
+    tmpdir do
+      capture {cli.create ['myapp']}
+      cli.package ['--generate-only', '--platform', 'windows', 'myapp']
+      %w[src/main.cpp src/app.manifest lib/boot.rb lib/app/main.rb lib/reflex/lib/reflex.rb].each do |f|
+        assert File.exist?("myapp/.build/windows/#{f}"), "missing #{f}"
+      end
+
+      cli.package ['--generate-only', '--platform', 'windows', '--pack', 'myapp']
+      assert_include Dir.children('myapp/.build/windows/lib/app'), 'data.bin'
+      assert_not_include Dir.children('myapp/.build/windows/lib/app'), 'main.rb'
     end
 
     tmpdir do
@@ -74,7 +91,25 @@ class TestPackagerCLI < Test::Unit::TestCase
       assert_raise(RP::Error) do
         cli.package ['--generate-only', '--platform', 'unknown', 'myapp']
       end
+      error = assert_raise(RP::Error) do
+        cli.package ['--notarize-submit', '--notarize-export', 'myapp']
+      end
+      assert_include error.message, 'only one of'
+
+      error = assert_raise(RP::Error) do
+        cli.package ['--notarize-wait', 'ID', '--appstore', 'myapp']
+      end
+      assert_include error.message, '--notarize-wait'
+      error = assert_raise(RP::Error) do
+        cli.package ['--platform', 'windows', '--appstore', 'myapp']
+      end
+      assert_include error.message, 'only for macos'
     end
   end
 
+  def test_default_platform()
+    stub(Gem, :win_platform?, true)  {assert_equal :windows, RP.default_platform}
+    stub(Gem, :win_platform?, false) {assert_equal :macos,   RP.default_platform}
+  end
+
 end# TestPackagerCLI