furoshiki 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0a17813563822aee7e3ff59e3ed2fd2751ee933
-  data.tar.gz: eea188ad94a3bbfa03fbe232f8b6e8200dcaa85f
+  metadata.gz: 28682823686b0e99c68d8e89e8dda278cedcbd7f
+  data.tar.gz: 35eaf912683fd1e7f183d21cf55f998652f04348
 SHA512:
-  metadata.gz: 42e0d0a9be95baf3ff80bda2606708f8240d43726fff18dc6165841278e6b8e1aa6d1f675ccd813e5813be076c4aa3f5a8a9ee18a9141379f980002d4876b19b
-  data.tar.gz: f48f91a79590f621aaaed9ddef6dccb6e0999f9462453345087cd64b64fb3e3ad4206e05934a0caf33761173230567e5d63ebe51de4c95d367de19a45d667da5
+  metadata.gz: 98811a3dfc69cda04149f26361b3b31d7b8525bb79b7151db8bba034c88e4468e93ebff266f9472026741c27b2ca53b72179c015822bee0c16461b5060aa4cc0
+  data.tar.gz: dec72fe9319649dfb226b22946b3bb2678443b0e83a8f39411e02b346d4d805c639d22d69b9fc678eb7aa931d78b89606deb906c12f6058e9f759e550ce88c00

data/.gitignore

@@ -21,4 +21,4 @@ pkg
 Gemfile.lock
 
 ## PROJECT::SPECIFIC
-spec/shoes/.furoshiki
+spec/.furoshiki

data/.ruby-version

@@ -1 +1 @@
-jruby-1.7.16
+jruby-1.7.18

data/Gemfile

@@ -2,4 +2,3 @@ source "https://rubygems.org"
 
 gemspec
 
-gem 'shoes'

data/Rakefile

@@ -1,5 +1,6 @@
 require 'bundler'
 require 'rake/clean'
+require 'rspec/core/rake_task'
 Bundler::GemHelper.install_tasks
 
 @types = %w[rb]
@@ -19,3 +20,7 @@ namespace :whitespace do
 end
 
 CLEAN.include('spec/shoes/.furoshiki', 'spec/shoes/sample_app')
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/furoshiki.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'rubyzip', '>= 1.0.0'
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '>= 3.0.0'
   s.add_development_dependency 'rspec-its'
   s.add_development_dependency 'pry'
 end

data/lib/furoshiki/configuration.rb

@@ -0,0 +1,142 @@
+require 'pathname'
+require 'yaml'
+require 'furoshiki/validator'
+require 'furoshiki/warbler_extensions'
+require 'furoshiki/util'
+
+module Furoshiki
+  # Configuration for Furoshiki packagers.
+  #
+  # If your configuration uses hashes, the keys will always be
+  # symbols, even if you have created it with string keys. It's just
+  # easier that way.
+  #
+  # This is a value object. If you need to modify your configuration
+  # after initialization, dump it with #to_hash, make your changes,
+  # and instantiate a new object.
+  class Configuration
+    JAR_APP_TEMPLATE_URL = 'https://s3.amazonaws.com/net.wasnotrice.shoes/wrappers/shoes-app-template-0.0.1.zip'
+
+    include Util
+
+    # @param [Hash] config user options
+    # @param [String] working_dir directory in which to do packaging work
+    def initialize(config = {})
+      merge_config config
+      sanitize_config
+      define_readers
+    end
+
+    def shortname
+      @config[:shortname] || name.downcase.gsub(/\W+/, '')
+    end
+
+    def validator
+      @validator ||= validator_class.new(self)
+    end
+
+    def warbler_extensions
+      @warbler_extensions ||= warbler_extensions_class.new(self)
+    end
+
+    def to_hash
+      @config
+    end
+
+    def valid?
+      validator.valid?
+    end
+
+    def validate
+      return unless validator.respond_to? :reset_and_validate
+      validator.reset_and_validate
+    end
+
+    def error_message_list
+      validator.error_message_list
+    end
+
+    def ==(other)
+      super unless other.class == self.class && other.respond_to?(:to_hash)
+      @config == other.to_hash && working_dir == other.working_dir
+    end
+
+    def to_warbler_config
+      warbler_config = nil
+      Dir.chdir working_dir do
+        warbler_config = Warbler::Config.new do |config|
+          config.jar_name = self.shortname
+          specs = self.gems.map do |gem|
+            # This is rather a hack as  Gem::Specification.find_by_name(gem)
+            # seems to break Travis.
+            # See: https://github.com/shoes/shoes4/pull/989#issuecomment-68170746
+            Gem::Specification.find_all_by_name(gem).first
+          end
+          dependencies = specs.map { |s| s.runtime_dependencies }.flatten
+          (specs + dependencies).uniq.each { |g| config.gems << g }
+          ignore = self.ignore.map do |f|
+            path = f.to_s
+            children = Dir.glob("#{path}/**/*") if File.directory?(path)
+            [path, *children]
+          end.flatten
+          config.excludes.add FileList.new(ignore.flatten).pathmap(config.pathmaps.application.first)
+          config.gem_excludes += [/^samples/, /^examples/, /^test/, /^spec/]
+
+          warbler_extensions.customize(config) if warbler_extensions.respond_to? :customize
+        end
+      end
+      warbler_config
+    end
+
+    private
+    def warbler_extensions_class
+      @warbler_extensions_class ||= @config.fetch(:warbler_extensions)
+    end
+
+    def validator_class
+      @validator_class ||= @config.fetch(:validator)
+    end
+
+    # Overwrite defaults with supplied config
+    def merge_config(config)
+      defaults = {
+        name: 'Ruby App',
+        version: '0.0.0',
+        release: 'Rookie',
+        ignore: 'pkg',
+        # TODO: Establish these default icons and paths. These would be
+        # default icons for generic Ruby apps.
+        icons: {
+          #osx: 'path/to/default/App.icns',
+          #gtk: 'path/to/default/app.png',
+          #win32: 'path/to/default/App.ico',
+        },
+        template_urls: {
+          jar_app: JAR_APP_TEMPLATE_URL,
+        },
+        validator: Furoshiki::Validator,
+        warbler_extensions: Furoshiki::WarblerExtensions,
+        working_dir: Dir.pwd,
+      }
+
+      @config = merge_with_symbolized_keys(defaults, config)
+    end
+
+    # Ensure these keys have workable values
+    def sanitize_config
+      [:ignore, :gems].each { |k| @config[k] = Array(@config[k]) }
+      @config[:working_dir] = Pathname.new(@config[:working_dir])
+    end
+
+    # Define reader for each top-level config key (except those already defined
+    # explicitly)
+    def define_readers
+      metaclass = class << self; self; end
+      @config.keys.reject {|k| self.respond_to?(k) }.each do |k|
+        metaclass.send(:define_method, k) do
+          @config[k]
+        end
+      end
+    end
+  end
+end

data/lib/furoshiki/jar.rb

@@ -0,0 +1,41 @@
+require 'warbler'
+require 'warbler/traits/furoshiki'
+
+module Furoshiki
+  class Jar
+    # @param [Furoshiki::Shoes::Configuration] config user configuration
+    def initialize(config)
+      @furoshiki_config = config
+
+      unless config.valid?
+        raise Furoshiki::ConfigurationError, "Invalid configuration.\n#{config.error_message_list}"
+      end
+
+      @config = @furoshiki_config.to_warbler_config
+    end
+
+    def package(dir = default_dir)
+      Dir.chdir working_dir do
+        jar = Warbler::Jar.new
+        jar.apply @config
+        package_dir = dir.relative_path_from(working_dir)
+        package_dir.mkpath
+        path = package_dir.join(filename).to_s
+        jar.create path
+        File.expand_path path
+      end
+    end
+
+    def default_dir
+      working_dir.join 'pkg'
+    end
+
+    def filename
+      "#{@config.jar_name}.#{@config.jar_extension}"
+    end
+
+    def working_dir
+      @furoshiki_config.working_dir
+    end
+  end
+end

data/lib/furoshiki/jar_app.rb

@@ -0,0 +1,225 @@
+require 'furoshiki/exceptions'
+require 'furoshiki/zip/directory'
+require 'furoshiki/jar'
+require 'fileutils'
+require 'plist'
+require 'open-uri'
+require 'net/http'
+
+module Furoshiki
+  class JarApp
+    include FileUtils
+
+    # @param [Furoshiki::Shoes::Configuration] config user configuration
+    def initialize(config)
+      @config = config
+
+      unless config.valid?
+        raise Furoshiki::ConfigurationError, "Invalid configuration.\n#{config.error_message_list}"
+      end
+
+      home = ENV['FUROSHIKI_HOME'] || Dir.home
+      @cache_dir = Pathname.new(home).join('.furoshiki', 'cache')
+      @default_package_dir = working_dir.join('pkg')
+      @package_dir = default_package_dir
+      @default_template_path = cache_dir.join(template_filename)
+      @template_path = default_template_path
+      @tmp = @package_dir.join('tmp')
+    end
+
+    # @return [Pathname] default package directory: ./pkg
+    attr_reader :default_package_dir
+
+    # @return [Pathname] package directory
+    attr_accessor :package_dir
+
+    # @return [Pathname] default path to .app template
+    attr_reader :default_template_path
+
+    # @return [Pathname] path to .app template
+    attr_accessor :template_path
+
+    # @return [Pathname] cache directory
+    attr_reader :cache_dir
+
+    attr_reader :config
+
+    attr_reader :tmp
+
+    def package
+      remove_tmp
+      create_tmp
+      cache_template
+      extract_template
+      inject_icon
+      inject_config
+      jar_path = ensure_jar_exists
+      inject_jar jar_path
+      move_to_package_dir tmp_app_path
+      tweak_permissions
+    rescue => e
+      raise e
+    ensure
+      remove_tmp
+    end
+
+    private
+    def create_tmp
+      tmp.mkpath
+    end
+
+    def remove_tmp
+      tmp.rmtree if tmp.exist?
+    end
+
+    def cache_template
+      cache_dir.mkpath unless cache_dir.exist?
+      download_template unless template_path.size?
+    end
+
+    def template_basename
+      'shoes-app-template'
+    end
+
+    def template_extension
+      '.zip'
+    end
+
+    def template_filename
+      "#{template_basename}#{template_extension}"
+    end
+
+    def latest_template_version
+      '0.0.1'
+    end
+
+    def download_template
+      download remote_template_url, template_path
+    end
+
+    def download(remote_url, local_path)
+      download_following_redirects remote_url, local_path
+    end
+
+    def download_following_redirects(remote_url, local_path, redirect_limit = 5)
+      if redirect_limit == 0
+        raise Furoshiki::DownloadError,
+              "Too many redirects trying to reach #{remote_url}"
+      end
+
+      uri = URI(remote_url)
+      Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        request = Net::HTTP::Get.new(uri.request_uri)
+        http.request request do |response|
+          case response
+          when Net::HTTPSuccess then
+            warn "Downloading #{remote_url} to #{local_path}"
+            open(local_path, 'wb') do |file|
+              response.read_body do |chunk|
+                file.write chunk
+              end
+            end
+          when Net::HTTPRedirection then
+            location = response['location']
+            warn "Redirected to #{location}"
+            download_following_redirects(location, local_path, redirect_limit - 1)
+          else
+            raise Furoshiki::DownloadError, "Couldn't download app template at #{remote_url}. #{response.value}"
+          end
+        end
+      end
+    end
+
+    def downloads_url
+      "http://shoesrb.com/downloads"
+    end
+
+    def remote_template_url
+      config.template_urls.fetch(:jar_app)
+    end
+
+    def move_to_package_dir(path)
+      dest = package_dir.join(path.basename)
+      dest.rmtree if dest.exist?
+      mv path.to_s, dest
+    end
+
+    def ensure_jar_exists
+      jar = Jar.new(@config)
+      path = tmp.join(jar.filename)
+      jar.package(tmp) unless File.exist?(path)
+      path
+    end
+
+    # Injects JAR into APP. The JAR should be the only item in the
+    # Contents/Java directory. If this directory contains more than one
+    # JAR, the "first" one gets run, which may not be what we want.
+    #
+    # @param [Pathname, String] jar_path the location of the JAR to inject
+    def inject_jar(jar_path)
+      jar_dir = tmp_app_path.join('Contents/Java')
+      jar_dir.rmtree
+      jar_dir.mkdir
+      cp Pathname.new(jar_path), jar_dir
+    end
+
+    def extract_template
+      raise IOError, "Couldn't find app template at #{template_path}." unless template_path.size?
+      extracted_app = nil
+
+      ::Zip::File.open(template_path) do |zip_file|
+        zip_file.each do |entry|
+          extracted_app = template_path.join(entry.name) if Pathname.new(entry.name).extname == '.app'
+          p = tmp.join(entry.name)
+          p.dirname.mkpath
+          entry.extract(p)
+        end
+      end
+      mv tmp.join(extracted_app.basename.to_s), tmp_app_path
+    end
+
+    def inject_config
+      plist = tmp_app_path.join 'Contents/Info.plist'
+      template = Plist.parse_xml(plist)
+      template['CFBundleIdentifier'] = "com.hackety.shoes.#{config.shortname}"
+      template['CFBundleDisplayName'] = config.name
+      template['CFBundleName'] = config.name
+      template['CFBundleVersion'] = config.version
+      template['CFBundleIconFile'] = Pathname.new(config.icons[:osx]).basename.to_s if config.icons[:osx]
+      File.open(plist, 'w') { |f| f.write template.to_plist }
+    end
+
+    def inject_icon
+      if config.icons[:osx]
+        icon_path = working_dir.join(config.icons[:osx])
+        raise IOError, "Couldn't find app icon at #{icon_path}" unless icon_path.exist?
+        resources_dir = tmp_app_path.join('Contents/Resources')
+        cp icon_path, resources_dir.join(icon_path.basename)
+      end
+    end
+
+    def tweak_permissions
+      executable_path.chmod 0755
+    end
+
+    def app_name
+      "#{config.name}.app"
+    end
+
+    def tmp_app_path
+      tmp.join app_name
+    end
+
+    def app_path
+      package_dir.join app_name
+    end
+
+    def executable_path
+      app_path.join('Contents/MacOS/JavaAppLauncher')
+    end
+
+    def working_dir
+      config.working_dir
+    end
+  end
+end

data/lib/furoshiki/util.rb

@@ -0,0 +1,27 @@
+module Furoshiki
+  module Util
+    # Ensure symbol keys, even in nested hashes
+    #
+    # @param [Hash] config the hash to set (key: value) on
+    # @param [#to_sym] k the key
+    # @param [Object] v the value
+    # @return [Hash] an updated hash
+    def deep_set_symbol_key(hash, key, value)
+      if value.kind_of? Hash
+        hash[key.to_sym] = value.inject({}) { |inner_hash, (inner_key, inner_value)| deep_set_symbol_key(inner_hash, inner_key, inner_value) }
+      else
+        hash[key.to_sym] = value
+      end
+      hash
+    end
+
+    def deep_symbolize_keys(hash)
+      merge_with_symbolized_keys({}, hash)
+    end
+
+    # Assumes that defaults already has symbolized keys
+    def merge_with_symbolized_keys(defaults, hash)
+      hash.inject(defaults) { |symbolized, (k, v)| deep_set_symbol_key(symbolized, k, v) }
+    end
+  end
+end

data/lib/furoshiki/validator.rb

@@ -0,0 +1,42 @@
+module Furoshiki
+  class Validator
+    def initialize(config)
+      @config = config
+      @errors = []
+    end
+
+    attr_reader :config
+
+    def valid?
+      reset_and_validate
+      return errors.empty?
+    end
+
+    def reset_and_validate
+      @errors.clear
+      validate if respond_to? :validate
+    end
+
+    def errors
+      @errors.dup
+    end
+
+    def error_message_list
+      @errors.map {|m| "  - #{m}"}.join("\n")
+    end
+
+    def working_dir
+      @config.working_dir
+    end
+
+    private
+    def add_error(message)
+      @errors << message
+    end
+
+    def add_missing_file_error(value, description)
+      message = "#{description} configured as '#{value}', but couldn't find file at #{working_dir.join(value.to_s)}"
+      add_error(message)
+    end
+  end
+end

data/lib/furoshiki/version.rb

@@ -1,4 +1,4 @@
 module Furoshiki
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end
 

data/lib/furoshiki/warbler_extensions.rb

@@ -0,0 +1,12 @@
+module Furoshiki
+  class WarblerExtensions
+    def initialize(config)
+      @config = config
+    end
+
+    # Override to customize config
+    def customize(warbler_config)
+      warbler_config
+    end
+  end
+end

data/lib/furoshiki.rb

@@ -1,3 +1,4 @@
-puts "OMG, nothing here!"
-puts ""
-puts "You probably want to `require 'furoshiki/shoes'`"
+require 'furoshiki/configuration'
+require 'furoshiki/exceptions'
+require 'furoshiki/jar'
+require 'furoshiki/jar_app'

data/lib/warbler/traits/furoshiki.rb

@@ -0,0 +1,31 @@
+require 'warbler'
+require 'warbler/traits'
+
+module Warbler
+  module Traits
+    # Hack to stop bundler injecting itself
+    class Bundler
+      def self.detect?
+        false
+      end
+    end
+
+    class Furoshiki
+      include ::Warbler::Trait
+      include PathmapHelper
+
+      def self.detect?
+        true
+      end
+
+      def self.requires?(trait)
+        [Traits::Jar].include? trait
+      end
+
+      def update_archive(jar)
+        # Not sure why Warbler doesn't do this automatically
+        jar.files.delete_if { |k, v| @config.excludes.include? k }
+      end
+    end
+  end
+end