reflex-packager 0.1.2

data/test/helper.rb

@@ -0,0 +1,28 @@
+%w[../xot ../rucy ../rays ../reflex .]
+  .map  {|s| File.expand_path "../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'xot/test'
+require 'reflex/extension'
+require 'reflex/packager'
+
+require 'test/unit'
+require 'tmpdir'
+
+include Xot::Test
+
+
+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],
+  config_files: %w[reflex.yml reflex.yaml],
+  template:     <<~RUBY)
+    require 'reflex'
+
+    Reflex.start do
+      Reflex::Window.new(title: '{{name}}', frame: [100, 100, 400, 300]).show
+    end
+  RUBY

data/test/test_packager_cli.rb

@@ -0,0 +1,80 @@
+require_relative 'helper'
+
+require 'stringio'
+require 'fileutils'
+
+
+class TestPackagerCLI < Test::Unit::TestCase
+
+  RP  = Reflex::Packager
+  CLI = RP::CLI
+
+  def capture(&block)
+    old              = [$stdout, $stderr]
+    out, err         = StringIO.new, StringIO.new
+    $stdout, $stderr = out, err
+    block.call
+    return out.string, err.string
+  ensure
+    $stdout, $stderr = old
+  end
+
+  def tmpdir(&block)
+    Dir.mktmpdir {|dir| Dir.chdir(dir) {block.call dir}}
+  end
+
+  def cli()
+    CLI.new TEST_PROFILE
+  end
+
+  def test_run()
+    out, = capture {cli.run []}
+    assert_include out, 'Usage: reflex'
+
+    out, = capture {cli.run ['--version']}
+    assert_equal Reflex::Extension.version, out.strip
+
+    assert_raise(SystemExit) {capture {cli.run ['unknown']}}
+  end
+
+  def test_new()
+    tmpdir do
+      capture {cli.create ['myapp']}
+      assert File.file?('myapp/main.rb')
+      assert File.file?('myapp/reflex.yml')
+
+      main = File.read('myapp/main.rb')
+      assert_include main, "require 'reflex'"
+      assert_include main, 'Reflex.start'
+
+      config = RP::Config.load TEST_PROFILE, 'myapp'
+      assert_equal 'myapp',   config.name
+      assert_equal 'main.rb', config.main
+    end
+
+    tmpdir do
+      FileUtils.mkdir 'myapp'
+      assert_raise(RP::Error) {cli.create ['myapp']}
+    end
+
+    assert_raise(RP::Error) {cli.create []}
+  end
+
+  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}"
+      end
+    end
+
+    tmpdir do
+      capture {cli.create ['myapp']}
+      assert_raise(RP::Error) do
+        cli.package ['--generate-only', '--platform', 'unknown', 'myapp']
+      end
+    end
+  end
+
+end# TestPackagerCLI

data/test/test_packager_config.rb

@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*-
+require_relative 'helper'
+
+
+class TestPackagerConfig < Test::Unit::TestCase
+
+  RP          = Reflex::Packager
+  Config      = RP::Config
+  MacOSConfig = RP::MacOSConfig
+
+  MAIN = File.basename(__FILE__)
+
+  def config(dir: __dir__, main: nil, parent: nil, stderr: nil, **hash)
+    main ||= MAIN
+    Config.new TEST_PROFILE, dir, {main: main, **hash}, stderr: stderr
+  end
+
+  def load_config(dir, path = nil)
+    Config.load TEST_PROFILE, dir, path
+  end
+
+  def stderr()
+    [].tap {|array|
+      def array.puts(s) = self << s
+    }
+  end
+
+  def touch(path, data = '')
+    FileUtils.mkdir_p File.dirname path
+    File.write path, data
+  end
+
+  def tmpdir(
+    yaml_path: 'reflex.yaml',
+    yaml:      '',
+    main_path: 'main.rb',
+    main:      '',
+    &block)
+
+    Dir.mktmpdir do |dir|
+      Dir.chdir dir do
+        File.write yaml_path, yaml if yaml_path && yaml
+        File.write main_path, main if main_path && main
+        block.call dir
+      end
+    end
+  end
+
+  def test_load()
+    tmpdir                      {|dir| assert_equal 'main.rb',  load_config(dir).main}
+    tmpdir(yaml: nil)           {|dir| assert_equal 'main.rb',  load_config(dir).main}
+    tmpdir(yaml: 'a: b: c')     {|dir| assert_raise(RP::Error) {load_config dir}}
+    tmpdir                      {|dir| assert_raise(RP::Error) {load_config "#{dir}/nodir"}}
+
+    tmpdir(yaml_path: '1.yaml') {|dir| assert_equal 'main.rb',  load_config(dir, '1.yaml').main}
+    tmpdir                      {|dir| assert_raise(RP::Error) {load_config dir, '2.yaml'}}
+    tmpdir(yaml_path: '3.yml')  {|dir| assert_raise(RP::Error) {load_config dir, '3.yaml'}}
+    tmpdir(yaml_path: '4.yaml') {|dir| assert_raise(RP::Error) {load_config dir, '4.yml'}}
+
+    tmpdir(yaml: 'name: 5')     {|dir| assert_equal '5',        load_config(dir).name}
+
+    tmpdir(yaml_path: 'reflex.yml', yaml: 'main: 6.rb', main_path: '6.rb') {|dir|
+      File.write      'reflex.yaml',      'main: 7.rb'
+      assert_equal '6.rb', load_config(dir).main
+    }
+  end
+
+  def test_load_full_config()
+    tmpdir yaml: <<~YAML, main_path: 'app.rb' do |dir|
+      name:      My App
+      bundle_id: com.example.myapp
+      version:   1.2.3
+      main:      app.rb
+      icon:      icon.png
+      files:     ['*.rb', data]
+      pods:
+        reflex: {git: https://example.com/reflex, tag: v1}
+      macos:
+        deployment_target: '12.0'
+        archs: [arm64, x86_64]
+        codesign: {identity: Developer ID, team_id: ABCDE12345}
+    YAML
+      touch 'icon.png'
+      touch '1.rb'
+      touch 'data/2.json'
+      c = load_config dir
+      assert_equal 'My App',                                       c.name
+      assert_equal 'com.example.myapp',                            c.bundle_id
+      assert_equal '1.2.3',                                        c.version
+      assert_equal 'app.rb',                                       c.main
+      assert_equal 'icon.png',                                     c.icon
+      assert_equal %w[*.rb data],                                  c.files
+      assert_equal %w[1.rb app.rb data],                           c.app_files
+      assert_equal({git: 'https://example.com/reflex', tag: 'v1'}, c.pods[:reflex])
+      assert_equal '12.0',                                         c.macos.deployment_target
+      assert_equal %w[arm64 x86_64],                               c.macos.archs
+      assert_equal 'Developer ID',                                 c.macos.codesign_identity
+      assert_equal 'ABCDE12345',                                   c.macos.codesign_team_id
+    end
+  end
+
+  def test_name()
+    assert_equal 'test', config()         .name
+    assert_equal '1',    config(name: 1)  .name
+    assert_equal 'test', config(name: nil).name
+  end
+
+  def test_bundle_id()
+    assert_equal 'org.xord.reflex.test',   config()                  .bundle_id
+    assert_equal 'a.b',                    config(bundle_id: 'a.b')  .bundle_id
+    assert_equal 'org.xord.reflex.name-1', config( name:    'Name-1').bundle_id
+    assert_equal 'org.xord.reflex.name-2', config('name' => 'Name-2').bundle_id
+    assert_raise(RP::Error)               {config bundle_id: ''}
+    assert_raise(RP::Error)               {config bundle_id: 'a'}
+    assert_raise(RP::Error)               {config bundle_id: 'a.'}
+    assert_raise(RP::Error)               {config name: 'アプリ'}
+  end
+
+  def test_version()
+    assert_equal '0.1.0',    config()              .version
+    assert_equal '1',        config(version: '1')  .version
+    assert_equal '2.3',      config(version: '2.3').version
+    assert_equal '0.1.0',    config(version: nil)  .version
+    assert_raise(RP::Error) {config version: '4.'}
+  end
+
+  def test_main()
+    assert_equal 'test_packager_config.rb', config()                 .main
+    assert_equal 'helper.rb',               config(main: 'helper.rb').main
+    assert_raise(RP::Error)                {config main: 'nofile.rb'}
+  end
+
+  def test_icon()
+    assert_nil                config()                 .icon
+    assert_equal 'helper.rb', config(icon: 'helper.rb').icon
+    assert_raise(RP::Error)  {config icon: 'nofile.png'}
+  end
+
+  def test_files()
+    assert_nil                  config()                  .files
+    assert_equal %w[helper.rb], config(files: 'helper.rb').files
+    assert_equal %w[a b],       config(files: %w[a b])    .files
+  end
+
+  def test_pods()
+    assert_equal({cruby: {}, reflex: {}}, config()                            .pods)
+    assert_equal({tag:    '6'},           config(pods: {cruby: {tag:    '6'}}).pods[:cruby])
+    assert_equal({branch: '7'},           config(pods: {cruby: {branch: '7'}}).pods[:cruby])
+    assert_equal({git:    '8'},           config(pods: {cruby: {git:    '8'}}).pods[:cruby])
+    assert_equal({path:   '9'},           config(pods: {cruby: {path:   '9'}}).pods[:cruby])
+  end
+
+  def test_app_files()
+    tmpdir                      do |dir|
+      touch 'x.rb'
+      assert_equal %w[main.rb],      load_config(dir).app_files
+    end
+
+    tmpdir yaml: "files: ['*']" do |dir|
+      touch 'x.rb'
+      assert_equal %w[main.rb x.rb], load_config(dir).app_files
+    end
+
+    tmpdir yaml: "files: ['*']" do |dir|
+      %w[build dist].each {Dir.mkdir _1}
+      touch 'build/1.rb'
+      touch 'dist/2.rb'
+      assert_equal %w[main.rb],      load_config(dir).app_files
+    end
+
+    tmpdir yaml_path: 'a.yaml', yaml: <<~YAML, main_path: 'b.rb' do |dir|
+      main: b.rb
+      files: '*'
+    YAML
+      %w[c.json d.png].each {touch _1}
+      assert_equal(
+        %w[a.yaml b.rb c.json d.png],
+        load_config(dir, 'a.yaml').app_files.map {File.basename _1})
+    end
+  end
+
+  def test_macos_deployment_target()
+    assert_equal '11.0',     config()                               .macos.deployment_target
+    assert_equal '11.0',     config(macos: {})                      .macos.deployment_target
+    assert_equal '1',        config(macos: {deployment_target: 1})  .macos.deployment_target
+    assert_equal '11.0',     config(macos: {deployment_target: nil}).macos.deployment_target
+    assert_raise(RP::Error) {config(macos: {deployment_target: {}})}
+  end
+
+  def test_macos_archs()
+    assert_equal ['arm64'],  config()                      .macos.archs
+    assert_equal ['arm64'],  config(macos: {})             .macos.archs
+    assert_equal ['1'],      config(macos: {archs: 1})     .macos.archs
+    assert_equal ['2', '3'], config(macos: {archs: [2, 3]}).macos.archs
+    assert_equal ['arm64'],  config(macos: {archs: nil})   .macos.archs
+    assert_raise(RP::Error) {config(macos: {archs: []})}
+    assert_raise(RP::Error) {config(macos: {archs: {}})}
+  end
+
+  def test_macos_codesign_identity()
+    assert_equal '-',        config()                                  .macos.codesign_identity
+    assert_equal '-',        config(macos: {})                         .macos.codesign_identity
+    assert_equal '-',        config(macos: {codesign: {}})             .macos.codesign_identity
+    assert_equal '-',        config(macos: {codesign: nil})            .macos.codesign_identity
+    assert_equal '1',        config(macos: {codesign: {identity: 1}})  .macos.codesign_identity
+    assert_equal '-',        config(macos: {codesign: {identity: nil}}).macos.codesign_identity
+    assert_raise(RP::Error) {config(macos: {codesign: 2})}
+    assert_raise(RP::Error) {config(macos: {codesign: {identity: {}}})}
+  end
+
+  def test_macos_codesign_team_id()
+    assert_nil               config()                                 .macos.codesign_team_id
+    assert_nil               config(macos: {})                        .macos.codesign_team_id
+    assert_nil               config(macos: {codesign: {}})            .macos.codesign_team_id
+    assert_nil               config(macos: {codesign: nil})           .macos.codesign_team_id
+    assert_equal '1',        config(macos: {codesign: {team_id: 1}})  .macos.codesign_team_id
+    assert_nil               config(macos: {codesign: {team_id: nil}}).macos.codesign_team_id
+    assert_raise(RP::Error) {config(macos: {codesign: 2})}
+    assert_raise(RP::Error) {config(macos: {codesign: {team_id: {}}})}
+  end
+
+  def test_warn_unknown_key()
+    e = stderr
+
+    config stderr: e,                                k1: 1
+    assert_equal "unknown key '/k1'",                e.shift
+
+    config stderr: e,                                macos: {k2: 2}
+    assert_equal "unknown key '/macos/k2'",          e.shift
+
+    config stderr: e,                                macos: {codesign: {k3: 3}}
+    assert_equal "unknown key '/macos/codesign/k3'", e.shift
+  end
+
+  def test_invalid_value_type()
+    assert_raise(RP::Error) {config macos: 'arm64'}
+    assert_raise(RP::Error) {config pods:  ['cruby']}
+  end
+
+end# TestPackagerConfig

data/test/test_packager_macos.rb

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+require_relative 'helper'
+
+
+class TestPackagerMacOS < Test::Unit::TestCase
+
+  RP    = Reflex::Packager
+  MacOS = RP::MacOS
+
+  def packager(yaml = nil, files: ['main.rb'], env: {}, &block)
+    Dir.mktmpdir do |dir|
+      files.each do |f|
+        path = File.join dir, f
+        FileUtils.mkdir_p File.dirname(path)
+        FileUtils.touch path
+      end
+      File.write File.join(dir, 'reflex.yml'), yaml if yaml
+      with_env({'REFLEX_PODS_PATH' => nil}.merge(env)) do
+        config = RP::Config.load TEST_PROFILE, dir
+        block.call MacOS.new(config), dir
+      end
+    end
+  end
+
+  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
+
+  def read(dir, path)
+    File.read File.join(dir, 'build', 'macos', path)
+  end
+
+  # --- generate ----------------------------------------------------------
+
+  def test_generate_creates_files()
+    packager do |pkg, dir|
+      pkg.generate
+      %w[project.yml Podfile src/main.mm app/main.rb].each do |f|
+        assert File.exist?(File.join dir, 'build/macos', f), "missing #{f}"
+      end
+    end
+  end
+
+  def test_app_dir_includes_files_and_excludes_build()
+    packager "files: [data]", files: %w[main.rb data/x.png] do |pkg, dir|
+      pkg.generate
+      pkg.generate # regenerating must not nest a previous build/ into app/
+      app = File.join dir, 'build/macos/app'
+      assert  File.exist?(File.join app, 'data/x.png')
+      assert !File.exist?(File.join app, 'build')
+    end
+  end
+
+  def test_project_yml()
+    packager "name: My App\nbundle_id: com.example.myapp" do |pkg, dir|
+      pkg.generate
+      str  = read dir, 'project.yml'
+      yml  = YAML.safe_load str
+      base = yml.dig 'settings', 'base'
+      assert_equal 'MyApp',                 yml['name']
+      assert_equal 'com.example.myapp',     base['PRODUCT_BUNDLE_IDENTIFIER']
+      assert_equal '0.1.0',                 base['MARKETING_VERSION']
+      assert_equal 'arm64',                 base['ARCHS']
+      assert_equal '-',                     base['CODE_SIGN_IDENTITY']
+      assert_equal '11.0', yml.dig('options', 'deploymentTarget', 'macOS')
+      assert_not_include str, 'CFBundleIconFile'
+      assert_not_include str, 'DEVELOPMENT_TEAM'
+    end
+  end
+
+  def test_project_yml_with_icon_and_team()
+    yaml = <<~YML
+      icon: icon.png
+      macos:
+        codesign: {team_id: ABCDE12345}
+    YML
+    packager yaml, files: %w[main.rb icon.png] do |pkg, dir|
+      # render only: a full generate would shell out to sips / iconutil
+      str = pkg.__send__ :render, 'project.yml.erb'
+      assert_include str, 'CFBundleIconFile: AppIcon'
+      assert_include str, 'path: AppIcon.icns'
+      assert_include str, 'DEVELOPMENT_TEAM: ABCDE12345'
+    end
+  end
+
+  # --- build (checked before shelling out to xcodegen / pod / xcodebuild) -
+
+  def test_check_tools_reports_missing()
+    packager do |pkg, _|
+      with_env 'PATH' => '' do
+        error = assert_raise(RP::Error) {pkg.__send__ :check_tools, MacOS::TOOLS}
+        assert_include error.message, 'xcodegen'
+        assert_include error.message, 'brew install xcodegen'
+      end
+    end
+  end
+
+  # Runs the block with a packager whose CRuby / Reflex pods resolve to
+  # local directories under +repos+ (via REFLEX_PODS_PATH).
+  def with_pods(repos, &block)
+    packager(nil, env: {'REFLEX_PODS_PATH' => repos}) {|pkg, _| block.call pkg}
+  end
+
+  def test_check_dev_pods_missing_dir()
+    Dir.mktmpdir do |repos|
+      with_pods repos do |pkg|             # neither repos/cruby nor repos/reflex exists
+        error = assert_raise(RP::Error) {pkg.__send__ :check_dev_pods}
+        assert_include error.message, 'pod directory not found'
+      end
+    end
+  end
+
+  def test_check_dev_pods_cruby_not_built()
+    Dir.mktmpdir do |repos|
+      FileUtils.mkdir_p File.join(repos, 'cruby')   # exists but has no CRuby/include
+      with_pods repos do |pkg|
+        error = assert_raise(RP::Error) {pkg.__send__ :check_dev_pods}
+        assert_include error.message, 'no CRuby binary'
+        assert_include error.message, 'download_or_build'
+      end
+    end
+  end
+
+  def test_check_dev_pods_reflex_not_set_up()
+    Dir.mktmpdir do |repos|
+      FileUtils.mkdir_p File.join(repos, 'cruby', 'CRuby', 'include')  # CRuby is OK
+      FileUtils.mkdir_p File.join(repos, 'reflex')                     # exists but has no xot
+      with_pods repos do |pkg|
+        error = assert_raise(RP::Error) {pkg.__send__ :check_dev_pods}
+        assert_include error.message, 'not set up for CocoaPods'
+        assert_include error.message, 'pod.rake setup'
+      end
+    end
+  end
+
+  def test_copy_app_without_build_product_raises()
+    packager do |pkg, _|
+      # nothing was built, so the .app is not under DerivedData
+      error = assert_raise(RP::Error) {pkg.__send__ :copy_app}
+      assert_include error.message, 'application not found'
+    end
+  end
+
+  # --- target ------------------------------------------------------------
+
+  def test_target_strips_unsafe_chars()
+    # a non-ascii name needs an explicit bundle_id (one cannot be derived),
+    # so set it here to keep the focus on target-name normalization
+    packager("name: My App!")                            {|pkg, _| assert_equal 'MyApp', pkg.target}
+    packager("name: アプリ\nbundle_id: com.example.app") {|pkg, _| assert_equal 'App',   pkg.target}
+  end
+
+  # --- extensions / libraries (registered with CRuby in main.mm) ---------
+
+  def test_main_mm_registers_runtime_and_starts()
+    packager "main: app.rb", files: %w[app.rb] do |pkg, dir|
+      pkg.generate
+      str = read dir, 'src/main.mm'
+      assert_include str, '@"app.rb"'                  # the entry script
+      assert_include str, 'Init_reflex_ext'            # native ext registered
+      assert_include str, 'Init_rays_ext'
+      assert_include str, '@"Reflex"'                  # library bundle added
+      assert_include str, 'changeCurrentDirectoryPath' # cwd set to app dir
+      assert_include str, '@"app"'                     # the bundled app dir
+      assert_include str, '[CRuby start:main]'
+    end
+  end
+
+  # --- pod_refs / dev_pod_paths (rendered into the Podfile) --------------
+
+  def test_podfile_defaults_to_git_pods()
+    packager do |pkg, dir|
+      pkg.generate
+      str = read dir, 'Podfile'
+      assert_include str, "pod 'CRuby', git: 'https://github.com/xord/cruby'"
+      assert_include str,
+        "pod 'Reflex', git: 'https://github.com/xord/reflex', " +
+        "tag: 'v#{Reflex::Extension.version}'"
+      assert_not_include str, 'PODS_ROOT'
+    end
+  end
+
+  def test_podfile_with_pods_path_env()
+    packager nil, env: {'REFLEX_PODS_PATH' => '/repos'} do |pkg, dir|
+      pkg.generate
+      str = read dir, 'Podfile'
+      assert_include str, "pod 'CRuby', path: '/repos/cruby'"
+      assert_include str, "pod 'Reflex', path: '/repos/reflex'"
+      # development pods need the ${PODS_ROOT} rewrite block
+      assert_include str, "s.gsub! '${PODS_ROOT}/CRuby', '/repos/cruby'"
+      assert_include str, "s.gsub! '${PODS_ROOT}/Reflex', '/repos/reflex'"
+    end
+  end
+
+  def test_podfile_with_pods_config()
+    yaml = <<~YML
+      pods:
+        cruby: {git: https://example.com/cruby, branch: dev}
+    YML
+    packager yaml do |pkg, dir|
+      pkg.generate
+      line = read(dir, 'Podfile').lines.grep(/pod 'CRuby'/).first
+      assert_match %r{git: 'https://example.com/cruby'}, line
+      assert_match %r{branch: 'dev'},                    line
+    end
+  end
+
+  # --- icon_commands -----------------------------------------------------
+
+  def test_icon_commands()
+    packager do |pkg, _|
+      cmds = pkg.icon_commands 'icon.png', 'AppIcon.iconset'
+      assert_equal 10, cmds.size
+      assert_include cmds,
+        %w[sips -z 16 16 icon.png --out AppIcon.iconset/icon_16x16.png]
+      assert_include cmds,
+        %w[sips -z 1024 1024 icon.png --out AppIcon.iconset/icon_512x512@2x.png]
+    end
+  end
+
+end# TestPackagerMacOS