shoes-package 4.0.0.pre3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e85a08b46b6fcdaa86a5b1609c14fb2e58c08677
+  data.tar.gz: b655bde5a2d94c020ed7a99a7eed8337cbb36d2f
+SHA512:
+  metadata.gz: d425a176814a1adfb819ed1296ad7d5f4308ce13b5928bdbbe933ad99a87c82714f179e37a2b2f5c22abcb43d052ef00d01e153d3f4ccdb54481b99351a4707c
+  data.tar.gz: 31d06640d06a1932e8826727d62720d499b9a1ae391a611818d98607d6aada43dc98b7fd4f4b6b7d903c2753bfeb7472b5a578b47d92a61afb0609e83a2e4ff1

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/shoes/package/configuration.rb

@@ -0,0 +1,156 @@
+require 'pathname'
+require 'yaml'
+require 'furoshiki/configuration'
+require 'furoshiki/validator'
+require 'furoshiki/warbler_extensions'
+require 'warbler/traits/shoes'
+
+class Shoes
+  module Package
+    # Configuration for Shoes packagers.
+    #
+    # @example
+    #   config_file = '/path/to/app.yaml'
+    #   config = Shoes::Package::Configuration.load(config_file)
+    #
+    module Configuration
+      extend ::Furoshiki::Util
+
+      JAR_APP_TEMPLATE_URL = 'https://s3.amazonaws.com/net.wasnotrice.shoes/wrappers/shoes-app-template-0.0.1.zip'
+
+      # Convenience method for loading config from a file. Note that you
+      # can pass four kinds of paths to the loader. Given the following
+      # file structure:
+      #  
+      #   ├── a
+      #   │   ├── app.yaml
+      #   │   └── shoes-app-a.rb
+      #   └── b
+      #   └── shoes-app-b.rb
+      #
+      # To package an app that has an `app.yaml`, like `shoes-app-a.rb`,
+      # you can call the loader with any of:
+      #
+      # - a/app.yaml
+      # - a
+      # - a/shoes-app-a.rb
+      #
+      # These will all find and use your configuration in `a/app.yaml`.
+      # To package an app that does not have an `app.yaml`, like
+      # `b/shoes-app-b.rb`, you must call the loader with the path of
+      # the script itself. Note that without an `app.yaml`, you will
+      # only bundle a single file, and your app will simply use the
+      # Shoes app icon.
+      #
+      # @overload load(path, base_config)
+      #   @param [String] path location of the app's 'app.yaml'
+      #   @param [Hash] base_config default values
+      # @overload load(path)
+      #   @param [String] path location of the directory that
+      #      contains the app's 'app.yaml'
+      #   @param [Hash] base_config default values
+      # @overload load(path)
+      #   @param [String] path location of the app
+      #   @param [Hash] base_config default values
+      def self.load(path, base_config = {})
+        pathname = Pathname.new(path)
+        app_yaml = Pathname.new('app.yaml')
+
+        if pathname.basename == app_yaml
+          file, dir = pathname, pathname.dirname
+        elsif pathname.directory?
+          file, dir = pathname.join(app_yaml), pathname
+        elsif pathname.file? && pathname.parent.children.include?(pathname.parent.join app_yaml)
+          file, dir = pathname.parent.join(app_yaml), pathname.parent
+        else
+          file, dir = config_for_single_file_app(pathname)
+        end
+
+        config = YAML.load(file.read)
+        config[:working_dir] = dir
+        config[:gems] = merge_gems(base_config, config)
+        create(config)
+      end
+
+      # @param [Hash] config user options
+      def self.create(config = {})
+        defaults = {
+          name: 'Shoes App',
+          version: '0.0.0',
+          release: 'Rookie',
+          run: nil,
+          ignore: 'pkg',
+          # TODO: Add actual paths. Keep these keys for compatibility with Shoes 3
+          icons: {
+            #osx: 'path/to/default/App.icns',
+            #gtk: 'path/to/default/app.png',
+            #win32: 'path/to/default/App.ico',
+          },
+          # TODO: Add actual paths. Keep these keys for compatibility with Shoes 3
+          dmg: {
+            #ds_store: 'path/to/default/.DS_Store',
+            #background: 'path/to/default/background.png'
+          },
+          working_dir: Dir.pwd,
+          gems: ['shoes-core'],
+          validator: Validator,
+          warbler_extensions: WarblerExtensions
+        }
+
+        symbolized_config = deep_symbolize_keys(config)
+        symbolized_config[:gems] = merge_gems(defaults, symbolized_config)
+        Furoshiki::Configuration.new defaults.merge(symbolized_config)
+      end
+
+      private
+      # If it exists, load default options. If not, let the filesystem raise an
+      # error.
+      def self.config_for_single_file_app(pathname)
+        default_options = {
+          run: pathname.basename.to_s,
+          name: pathname.basename(pathname.extname).to_s.gsub(/\W/, '-')
+        }.to_yaml
+        options = pathname.exist? ? default_options : pathname
+        dummy_file = Struct.new(:read)
+        [dummy_file.new(options), pathname.parent]
+      end
+
+      # We want to retain all of the gems, but simply merging the hash will
+      # replace the whole array, so we handle the gems separately. Note that
+      # keys may not have been symbolized yet
+      def self.merge_gems(base, additional)
+        base_gems = base.fetch(:gems) rescue base['gems']
+        additional_gems = additional.fetch(:gems) rescue additional['gems']
+        Array(base_gems).concat(Array(additional_gems)).uniq
+      end
+    end
+
+    class Validator < Furoshiki::Validator
+      def validate
+        unless config.run && config.working_dir.join(config.run).exist?
+          add_missing_file_error(config.run, "Run file")
+        end
+
+        if config.icons[:osx] && !config.working_dir.join(config.icons[:osx]).exist?
+          add_missing_file_error(config.icons[:osx], "OS X icon file")
+        end
+      end
+    end
+
+    class WarblerExtensions < Furoshiki::WarblerExtensions
+      def customize(warbler_config)
+        warbler_config.tap do |warbler|
+          warbler.pathmaps.application = ['shoes-app/%p']
+          warbler.extend ShoesWarblerConfig
+          warbler.run = @config.run.split(/\s/).first
+        end
+      end
+
+      private
+      # Adds Shoes-specific functionality to the Warbler Config
+      module ShoesWarblerConfig
+        attr_accessor :run
+      end
+    end
+  end
+end

data/lib/shoes/package/jar.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+require 'furoshiki/jar'
+
+class Shoes
+  module Package
+    class Jar
+      extend Forwardable
+
+      def_delegators :@packager, :package, :default_dir, :filename
+
+      def initialize(config)
+        config.gems << 'shoes-swt'
+        @packager = Furoshiki::Jar.new(config)
+      end
+    end
+  end
+end

data/lib/shoes/package/jar_app.rb

@@ -0,0 +1,18 @@
+require 'forwardable'
+require 'furoshiki/jar_app'
+
+class Shoes
+  module Package
+    class JarApp
+      extend Forwardable
+
+      def_delegators :@packager, :package, :default_package_dir, :cache_dir,
+                                 :remote_template_url, :template_path
+
+      def initialize(config)
+        config.gems << 'shoes-swt'
+        @packager = Furoshiki::JarApp.new(config)
+      end
+    end
+  end
+end

data/lib/shoes/package/version.rb

@@ -0,0 +1,5 @@
+class Shoes
+  module Package
+    VERSION = "4.0.0.pre3"
+  end
+end

data/lib/warbler/traits/shoes.rb

@@ -0,0 +1,53 @@
+require 'warbler'
+require 'warbler/traits'
+require 'warbler/traits/furoshiki'
+
+module Warbler
+  module Traits
+    # Hack to control the executable
+    class NoGemspec
+      def update_archive(jar); end
+    end
+
+    # Disable this trait, since we are subclassing it (don't run twice)
+    class Furoshiki
+      def self.detect?; false; end
+    end
+
+    class Shoes < Furoshiki
+      def self.detect?
+        true
+      end
+
+      def self.requires?(trait)
+        # Actually, it would be better to dump the NoGemspec trait, but since
+        # we can't do that, we can at least make sure that this trait gets
+        # processed later by declaring that it requires NoGemspec.
+        [Traits::Jar, Traits::NoGemspec].include? trait
+      end
+
+      def after_configure
+        config.init_contents << StringIO.new("require 'shoes'\nShoes.configuration.backend = :swt\n")
+      end
+
+      def update_archive(jar)
+        super
+        add_main_rb(jar, apply_pathmaps(config, default_executable, :application))
+      end
+
+      # Uses the `@config.run` if it exists. Otherwise, looks in the
+      # application's `bin` directory for an executable with the same name as
+      # the jar. If this also fails, defaults to the first executable (alphabetically) in the
+      # applications `bin` directory.
+      #
+      # @return [String] filename of the executable to run
+      def default_executable
+        return @config.run if @config.run
+        exes = Dir['bin/*'].sort
+        exe = exes.grep(/#{config.jar_name}/).first || exes.first
+        raise "No executable script found" unless exe
+        exe
+      end
+    end
+  end
+end

data/shoes-package.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('lib/shoes/package/version')
+
+Gem::Specification.new do |s|
+  s.name        = "shoes-package"
+  s.version     = Shoes::Package::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Team Shoes"]
+  s.email       = ["shoes@librelist.com"]
+  s.homepage    = "https://github.com/shoes/shoes4"
+  s.summary     = %q{Application packaging for Shoes, the best little GUI toolkit for Ruby.}
+  s.description = %q{Application packaging for Shoes, the best little GUI toolkit for Ruby. Shoes makes building for Mac, Windows, and Linux super simple.}
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency "shoes-core", Shoes::Package::VERSION
+  s.add_dependency "furoshiki", "~> 0.3.0"
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,207 @@
+require_relative 'spec_helper'
+require 'shoes/package/configuration'
+
+describe Shoes::Package::Configuration do
+  context "defaults" do
+    subject { Shoes::Package::Configuration.create }
+
+    its(:name) { should eq('Shoes App') }
+    its(:shortname) { should eq('shoesapp') }
+    its(:ignore) { should eq(['pkg']) }
+    its(:gems) { should include('shoes-core') }
+    its(:version) { should eq('0.0.0') }
+    its(:release) { should eq('Rookie') }
+    its(:icons) { should be_an_instance_of(Hash) }
+    its(:dmg) { should be_an_instance_of(Hash) }
+    its(:run) { should be_nil }
+    its(:working_dir) { should eq(Pathname.new(Dir.pwd)) }
+    it { is_expected.not_to be_valid } # no :run
+
+    # TODO: Implement
+    describe "#icons" do
+      it 'osx is nil' do
+        expect(subject.icons[:osx]).to be_nil
+      end
+
+      it 'gtk is nil' do
+        expect(subject.icons[:gtk]).to be_nil
+      end
+
+      it 'win32 is nil' do
+        expect(subject.icons[:win32]).to be_nil
+      end
+    end
+
+    # TODO: Implement
+    describe "#dmg" do
+      it "ds_store is nil" do
+        expect(subject.dmg[:ds_store]).to be_nil
+      end
+
+      it "background is nil" do
+        expect(subject.dmg[:background]).to be_nil
+      end
+    end
+
+    describe "#to_hash" do
+      it "round-trips" do
+        expect(Shoes::Package::Configuration.create(subject.to_hash)).to eq(subject)
+      end
+    end
+  end
+
+  context "with options" do
+    include_context 'config'
+    subject { Shoes::Package::Configuration.load(@config_filename) }
+
+    its(:name) { should eq('Sugar Clouds') }
+    its(:shortname) { should eq('sweet-nebulae') }
+    its(:ignore) { should include('pkg') }
+    its(:run) { should eq('bin/hello_world') }
+    its(:gems) { should include('rspec') }
+    its(:gems) { should include('shoes-core') }
+    its(:version) { should eq('0.0.1') }
+    its(:release) { should eq('Mindfully') }
+    its(:icons) { should be_an_instance_of(Hash) }
+    its(:dmg) { should be_an_instance_of(Hash) }
+    its(:working_dir) { should eq(@config_filename.dirname) }
+    it { is_expected.to be_valid }
+
+    describe "#icons" do
+      it 'has osx' do
+        expect(subject.icons[:osx]).to eq('img/boots.icns')
+      end
+
+      it 'has gtk' do
+        expect(subject.icons[:gtk]).to eq('img/boots_512x512x32.png')
+      end
+
+      it 'has win32' do
+        expect(subject.icons[:win32]).to eq('img/boots.ico')
+      end
+    end
+
+    describe "#dmg" do
+      it "has ds_store" do
+        expect(subject.dmg[:ds_store]).to eq('path/to/custom/.DS_Store')
+      end
+
+      it "has background" do
+        expect(subject.dmg[:background]).to eq('path/to/custom/background.png')
+      end
+    end
+
+    it "incorporates custom features" do
+      expect(subject.custom).to eq('my custom feature')
+    end
+
+    it "round-trips" do
+      expect(Shoes::Package::Configuration.create(subject.to_hash)).to eq(subject)
+    end
+  end
+
+  context "with name, but without explicit shortname" do
+    let(:options) { {:name => "Sugar Clouds"} }
+    subject { Shoes::Package::Configuration.create options }
+
+    its(:name) { should eq("Sugar Clouds") }
+    its(:shortname) { should eq("sugarclouds") }
+  end
+
+  context "when the file to run doens't exist" do
+    let(:options) { {:run => "path/to/non-existent/file"} }
+    subject { Shoes::Package::Configuration.create options }
+
+    it { is_expected.not_to be_valid }
+  end
+
+  context "when osx icon is not specified" do
+    include_context 'config'
+    let(:valid_config) { Shoes::Package::Configuration.load(@config_filename) }
+    let(:options) { valid_config.to_hash.merge(:icons => {}) }
+    subject { Shoes::Package::Configuration.create(options) }
+
+    it "sets osx icon path to nil" do
+      expect(subject.icons[:osx]).to be_nil
+    end
+
+    it "is valid" do
+      expect(subject).to be_valid
+    end
+  end
+
+  context "when osx icon is specified, but doesn't exist" do
+    let(:options) { ({:icons => {:osx => "path/to/non-existent/file"}}) }
+    subject { Shoes::Package::Configuration.create options }
+
+    it "sets osx icon path" do
+      expect(subject.icons[:osx]).to eq("path/to/non-existent/file")
+    end
+
+    it { is_expected.not_to be_valid }
+  end
+
+  context "auto-loading" do
+    include_context 'config'
+
+    shared_examples "config with path" do
+      it "finds the config" do
+        Dir.chdir File.dirname(__FILE__) do
+          config = Shoes::Package::Configuration.load(path)
+          expect(config.shortname).to eq('sweet-nebulae')
+        end
+      end
+    end
+
+    context "with an 'app.yaml'" do
+      let(:path) { @config_filename }
+      it_behaves_like "config with path"
+    end
+
+    context "with a path to a directory containing an 'app.yaml'" do
+      let(:path) { @config_filename.parent }
+      it_behaves_like "config with path"
+    end
+
+    context "with a path to a file that is siblings with an 'app.yaml'" do
+      let(:path) { @config_filename.parent.join('sibling.rb') }
+      it_behaves_like "config with path"
+    end
+
+    context "with a path that exists, but no 'app.yaml'" do
+      let(:path) { @config_filename.parent.join('bin/hello_world') }
+      subject { Shoes::Package::Configuration.load(path) }
+
+      its(:name) { should eq('hello_world') }
+      its(:shortname) { should eq('hello_world') }
+    end
+
+    context "when the file doesn't exist" do
+      it "blows up" do
+        expect { Shoes::Package::Configuration.load('some/bogus/path') }.to raise_error
+      end
+    end
+
+    context "with additional gems" do
+      let(:path) { @config_filename }
+      let(:additional_config) { { gems: gems } }
+      let(:config) { config = Shoes::Package::Configuration.load(path, additional_config) }
+
+      context "one gem" do
+        let(:gems) { 'shoes-swt' }
+
+        it "adds one additional" do
+          expect(config.gems).to include('shoes-swt')
+        end
+      end
+
+      context "multiple gems" do
+        let(:gems) { ['shoes-swt', 'shoes-extras'] }
+
+        it "adds multiple additional gems" do
+          expect(config.gems & gems).to eq(gems)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,69 @@
+# Packaging caches files in $HOME/.furoshiki/cache by default.
+# For testing, we override $HOME using $FUROSHIKI_HOME
+FUROSHIKI_SPEC_DIR = Pathname.new(__FILE__).dirname.expand_path.to_s
+ENV['FUROSHIKI_HOME'] = FUROSHIKI_SPEC_DIR
+
+SHOES_PACKAGE_SPEC_ROOT= File.expand_path('..', __FILE__)
+
+$LOAD_PATH << File.expand_path(SHOES_PACKAGE_SPEC_ROOT)
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+$LOAD_PATH << File.expand_path('../../../shoes-core/lib', __FILE__)
+
+require 'pathname'
+require 'rspec/its'
+
+Dir["#{SHOES_PACKAGE_SPEC_ROOT}/support/**/*.rb"].each {|f| require f}
+
+module PackageHelpers
+  # need these values from a context block, so let doesn't work
+  def spec_dir
+    Pathname.new(__FILE__).join('..').cleanpath
+  end
+
+  def input_dir
+    spec_dir.join 'support', 'zip'
+  end
+end
+
+# Guards for running or not running specs. Specs in the guarded block only
+# run if the guard conditions are met.
+#
+module Guard
+  # Runs specs only if platform matches
+  #
+  # @example
+  # platform_is :windows do
+  #   it "does something only on windows" do
+  #     # specification
+  #   end
+  # end
+  def platform_is(platform)
+    yield if self.send "platform_is_#{platform.to_s}"
+  end
+
+  # Runs specs only if platform does not match
+  #
+  # @example
+  # platform_is_not :windows do
+  #   it "does something only on posix systems" do
+  #     # specification
+  #   end
+  # end
+  def platform_is_not(platform)
+    yield unless self.send "platform_is_#{platform.to_s}"
+  end
+
+  def platform_is_windows
+    return RbConfig::CONFIG['host_os'] =~ /windows|mswin/i
+  end
+
+  def platform_is_linux
+    return RbConfig::CONFIG['host_os'] =~ /linux/i
+  end
+
+  def platform_is_osx
+    return RbConfig::CONFIG['host_os'] =~ /darwin/i
+  end
+end
+
+include Guard

data/spec/support/shared_config.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+require 'pathname'
+
+shared_context 'config' do
+  before :all do
+    @config_filename = Pathname.new(__FILE__).join('../../test_app/app.yaml').cleanpath
+  end
+end
+
+shared_context 'package' do
+  before :all do
+    @app_dir = Pathname.new(__FILE__).join '../../test_app'
+    @output_dir = @app_dir.join 'pkg'
+  end
+end

data/spec/swt_app_spec.rb

@@ -0,0 +1,131 @@
+require_relative 'spec_helper'
+require 'shoes/package/configuration'
+require 'shoes/package/jar_app'
+
+include PackageHelpers
+
+describe Shoes::Package::JarApp do
+  include_context 'config'
+  include_context 'package'
+
+  let(:config) { Shoes::Package::Configuration.load @config_filename }
+  subject { Shoes::Package::JarApp.new config }
+
+  let(:launcher) { @output_file.join('Contents/MacOS/JavaAppLauncher') }
+  let(:icon)  { @output_file.join('Contents/Resources/boots.icns') }
+  let(:jar) { @output_file.join('Contents/Java/sweet-nebulae.jar') }
+
+  # $FUROSHIKI_HOME is set in spec_helper.rb for testing purposes,
+  # but should default to $HOME
+  context "when not setting $FUROSHIKI_HOME" do
+    before do
+      @old_furoshiki_home = ENV['FUROSHIKI_HOME']
+      ENV['FUROSHIKI_HOME'] = nil
+    end
+
+
+    its(:cache_dir) { should eq(Pathname.new(Dir.home).join('.furoshiki', 'cache')) }
+
+    after do
+      ENV['FUROSHIKI_HOME'] = @old_furoshiki_home
+    end
+  end
+
+  context "default" do
+    let(:cache_dir) { Pathname.new(SHOES_PACKAGE_SPEC_ROOT).join('.furoshiki', 'cache') }
+    its(:cache_dir) { should eq(cache_dir) }
+
+    it "sets package dir to {pwd}/pkg" do
+      Dir.chdir @app_dir do
+        expect(subject.default_package_dir).to eq(@app_dir.join 'pkg')
+      end
+    end
+
+    its(:template_path) { should eq(cache_dir.join('shoes-app-template.zip')) }
+    its(:remote_template_url) { should eq(Shoes::Package::Configuration::JAR_APP_TEMPLATE_URL) }
+  end
+
+  context "when creating a .app" do
+    before :all do
+      @output_dir.rmtree if @output_dir.exist?
+      @output_dir.mkpath
+      app_name = 'Sugar Clouds.app'
+      @output_file = @output_dir.join app_name
+      config   = Shoes::Package::Configuration.load @config_filename
+      @subject = Shoes::Package::JarApp.new config
+      @subject.package
+    end
+
+    subject { @subject }
+
+    its(:template_path) { should exist }
+
+    it "creates a .app" do
+      expect(@output_file).to exist
+    end
+
+    it "includes launcher" do
+      expect(launcher).to exist
+    end
+
+    # Windows can't test this
+    platform_is_not :windows do
+      it "makes launcher executable" do
+        expect(launcher).to be_executable
+      end
+    end
+
+    it "deletes generic icon" do
+      expect(icon.parent.join('GenericApp.icns')).not_to exist
+    end
+
+    it "injects icon" do
+      expect(icon).to exist
+    end
+
+    it "injects jar" do
+      expect(jar).to exist
+    end
+
+    it "removes any extraneous jars" do
+      jar_dir_contents = @output_file.join("Contents/Java").children
+      expect(jar_dir_contents.reject {|f| f == jar }).to be_empty
+    end
+
+    describe "Info.plist" do
+      require 'plist'
+      before :all do
+        @plist = Plist.parse_xml(@output_file.join 'Contents/Info.plist')
+      end
+
+      it "sets identifier" do
+        expect(@plist['CFBundleIdentifier']).to eq('com.hackety.shoes.sweet-nebulae')
+      end
+
+      it "sets display name" do
+        expect(@plist['CFBundleDisplayName']).to eq('Sugar Clouds')
+      end
+
+      it "sets bundle name" do
+        expect(@plist['CFBundleName']).to eq('Sugar Clouds')
+      end
+
+      it "sets icon" do
+        expect(@plist['CFBundleIconFile']).to eq('boots.icns')
+      end
+
+      it "sets version" do
+        expect(@plist['CFBundleVersion']).to eq('0.0.1')
+      end
+    end
+  end
+
+  describe "with an invalid configuration" do
+    let(:config) { Shoes::Package::Configuration.create }
+    subject { Shoes::Package::JarApp.new config }
+
+    it "fails to initialize" do
+      expect { subject }.to raise_error(Furoshiki::ConfigurationError)
+    end
+  end
+end

data/spec/swt_jar_spec.rb

@@ -0,0 +1,66 @@
+require_relative 'spec_helper'
+require 'shoes/package/configuration'
+require 'shoes/package/jar'
+
+include PackageHelpers
+
+describe Furoshiki::Jar do
+  include_context 'config'
+  include_context 'package'
+
+  context "when creating a .jar" do
+    before :all do
+      @output_dir.rmtree if @output_dir.exist?
+      @output_dir.mkpath
+      config = Shoes::Package::Configuration.load(@config_filename)
+      @subject = Shoes::Package::Jar.new(config)
+      @jar_path = @subject.package
+    end
+
+    let(:jar_name) { 'sweet-nebulae.jar' }
+    let(:output_file) { Pathname.new(@output_dir.join jar_name) }
+    subject { @subject }
+
+    it "creates a .jar" do
+      expect(output_file).to exist
+    end
+
+    it "returns path to .jar" do
+      expect(@jar_path).to eq(output_file.to_s)
+    end
+
+    it "creates .jar smaller than 60MB" do
+      expect(File.size(output_file)).to be < 60 * 1024 * 1024
+    end
+
+    context "inspecting contents" do
+      let (:jar) { Zip::File.new(output_file) }
+
+      it "includes shoes-core" do
+        shoes_core = jar.glob "gems/shoes-core*"
+        expect(shoes_core.length).to equal(1)
+      end
+
+      it "includes shoes-swt" do
+        shoes_swt = jar.glob "gems/shoes-swt*"
+        expect(shoes_swt.length).to equal(1)
+      end
+
+      it "excludes directories recursively" do
+        expect(jar.entries).not_to include("dir_to_ignore/file_to_ignore")
+      end
+    end
+
+    its(:default_dir) { should eq(@output_dir) }
+    its(:filename) { should eq(jar_name) }
+  end
+
+  describe "with an invalid configuration" do
+    let(:config) { Shoes::Package::Configuration.create}
+    subject { Shoes::Package::Jar.new(config) }
+
+    it "fails to initialize" do
+      expect { subject }.to raise_error(Furoshiki::ConfigurationError)
+    end
+  end
+end

data/spec/test_app/app.yaml

@@ -0,0 +1,17 @@
+name: Sugar Clouds
+shortname: sweet-nebulae
+ignore:
+  - pkg
+  - dir_to_ignore
+run: bin/hello_world
+gems: rspec
+version: 0.0.1
+release: Mindfully
+icons:
+  osx: img/boots.icns
+  gtk: img/boots_512x512x32.png
+  win32: img/boots.ico
+dmg:
+  ds_store: path/to/custom/.DS_Store
+  background: path/to/custom/background.png
+custom: my custom feature

data/spec/test_app/bin/hello_world

@@ -0,0 +1,3 @@
+Shoes.app do
+  banner "Hello world"
+end

data/spec/test_app/dir_to_ignore/file_to_ignore.txt

@@ -0,0 +1 @@
+should be ignored

data/spec/test_app/sibling.rb

@@ -0,0 +1 @@
+# Just a sibling of 'app.yaml'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: shoes-package
+version: !ruby/object:Gem::Version
+  version: 4.0.0.pre3
+platform: ruby
+authors:
+- Team Shoes
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.pre3
+  name: shoes-core
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.pre3
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  name: furoshiki
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: Application packaging for Shoes, the best little GUI toolkit for Ruby. Shoes makes building for Mac, Windows, and Linux super simple.
+email:
+- shoes@librelist.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/shoes/package/configuration.rb
+- lib/shoes/package/jar.rb
+- lib/shoes/package/jar_app.rb
+- lib/shoes/package/version.rb
+- lib/warbler/traits/shoes.rb
+- shoes-package.gemspec
+- spec/.furoshiki/cache/shoes-app-template.zip
+- spec/configuration_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_config.rb
+- spec/swt_app_spec.rb
+- spec/swt_jar_spec.rb
+- spec/test_app/app.yaml
+- spec/test_app/bin/hello_world
+- spec/test_app/dir_to_ignore/file_to_ignore.txt
+- spec/test_app/img/boots.icns
+- spec/test_app/img/boots.ico
+- spec/test_app/img/boots_512x512x32.png
+- spec/test_app/sibling.rb
+homepage: https://github.com/shoes/shoes4
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.2
+signing_key:
+specification_version: 4
+summary: Application packaging for Shoes, the best little GUI toolkit for Ruby.
+test_files:
+- spec/.furoshiki/cache/shoes-app-template.zip
+- spec/configuration_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_config.rb
+- spec/swt_app_spec.rb
+- spec/swt_jar_spec.rb
+- spec/test_app/app.yaml
+- spec/test_app/bin/hello_world
+- spec/test_app/dir_to_ignore/file_to_ignore.txt
+- spec/test_app/img/boots.icns
+- spec/test_app/img/boots.ico
+- spec/test_app/img/boots_512x512x32.png
+- spec/test_app/sibling.rb
+has_rdoc: