furoshiki 0.0.2 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de386c74229b401a317c15d3c8ddb5e2b0af9ab4
+  data.tar.gz: 9c590ec9777006a102a182f6ee5586b5c2ce5c3b
+SHA512:
+  metadata.gz: 0e8b5ab686470eb569929192edae4584c911edc8deac8c545d15780034b562e2d9a01fc6e37fa8d6863df07a895cb624cf0bc01ffa491aa58d68ea7cebce973e
+  data.tar.gz: 96eda86a72af8d7888eabc82863b748eca4aa673f6a51c3865522b6d6afb8295509f9d795f37d07cdf5202b6f7bc8adef80920aebeb3569c41991ec84d5ee0b3

data/.gitignore

@@ -17,5 +17,8 @@ tmtags
 coverage
 rdoc
 pkg
+.rvmrc
+Gemfile.lock
 
 ## PROJECT::SPECIFIC
+spec/shoes/.furoshiki

data/.rspec

@@ -0,0 +1,2 @@
+-c
+--order random

data/Gemfile

@@ -1,3 +1,12 @@
 source "http://rubygems.org"
 
 gem "rake"
+gem "plist"
+gem "warbler"
+
+# Only for packaging Shoes apps (there is no GUI)
+gem "shoes"#, :github => "shoes/shoes4"
+
+group :test, :development do
+  gem "rspec", "~> 2.12"
+end

data/README.rdoc

@@ -1,50 +1,55 @@
 = furoshiki
 
-風呂敷 (Furoshiki) is a simple way to package your Ruby applications for distribution on Windows, Linux, and OSX. A 風呂敷 is "a type of traditional Japanese wrapping cloth that were frequently used to transport clothes, gifts, or other goods."
+風呂敷 (Furoshiki) is a simple way to package your Ruby applications for
+distribution on Windows, Linux, and OSX. A 風呂敷 is "a type of traditional
+Japanese wrapping cloth that were frequently used to transport clothes, gifts,
+or other goods."
 
-In our case, you can distribute your Ruby script with 風呂敷 by adding this to your Rakefile:
+== ALPHA WARNING
 
-  require 'furoshiki'
+This is all super alpha, and is subject to change at any time.
 
-  Furoshiki::RakeTask.new
+== Packaging Shoes apps
 
-If you'd like to set a different entry point, just configure your task:
+For the moment, we only really package Shoes apps. See ALPHA WARNING above ;)
 
-  Furoshiki::RakeTask.new do
-    entry "SomeClass#some_method"
-  end
+    path = 'path/to/your/shoes-app' # See Furoshiki::Shoes::Configuration
+    config = Furoshiki::Shoes::Configuration.load(path)
+    packager = Furoshiki::Shoes.new(:swt, :app, config)
+    packager.package
 
-and it'll do the right thing.
+Or use the shoes4 command line interface:
 
-== ALPHA WARNING
+    bin/shoes -p swt:app path/to/your/shoes-app
 
-This is all super alpha, and is subject to change at any time.
+Eventually, we will be able to package non-Shoes apps too.
 
 == Inspiration
 
-The inspiriation for 風呂敷 came from Shoes[http://shoesrb.com]. One of Shoes' best features is packaging up scripts made with Shoes into their own executables. You could take any little script and make a .app, .exe, or .run file. However, this code was really complicated, and made Shoes hard to maintain. It was often the source of people's problems when trying to build Shoes of their own. So, while working on Shoes 4, I decided to see if anyone else was doing anything similar. I came across the .app for libgosu[http://code.google.com/p/gosu/wiki/RubyPackagingOnOsx], which was doing a similar thing. After emailing Julian, I decided that if this was useful for Shoes, and useful for libgosu, it'd probably be useful for other projects, too. So I've set out to figure out the Shoes packager, play with the libgosu versions, and come up with an easy way for you to bundle and distribute GUI programs written in Ruby.
+The inspiriation for 風呂敷 came from Shoes[http://shoesrb.com]. One of Shoes'
+best features is packaging up scripts made with Shoes into their own
+executables. You could take any little script and make a .app, .exe, or .run
+file. However, this code was really complicated, and made Shoes hard to
+maintain. It was often the source of people's problems when trying to build
+Shoes of their own. So, while working on Shoes 4, I decided to see if anyone
+else was doing anything similar. I came across the .app for
+libgosu[http://code.google.com/p/gosu/wiki/RubyPackagingOnOsx], which was doing
+a similar thing. After emailing Julian, I decided that if this was useful for
+Shoes, and useful for libgosu, it'd probably be useful for other projects, too.
+So I've set out to figure out the Shoes packager, play with the libgosu
+versions, and come up with an easy way for you to bundle and distribute GUI
+programs written in Ruby.
 
 == Helping out with 風呂敷
 
-風呂敷uses the following 'stack':
-
-* Ruby 1.9.2
-* Bundler
-* git flow
-
-I personally use rvm, so I also have a .rvmrc set up. It'll switch to the right Ruby when you cd into the directory, so you might see something about needing to create a gemset. If you use rvm, it's probably a good idea:
-
-  $ rvm gemset create furoshiki
-
-Since you've made a new gemset, you'll probably need to install bundler:
+It's easy! Just clone it down and do the usual bundler thing:
 
+  $ git clone https://github.com/shoes/furoshiki.git
+  $ cd furoshiki
   $ gem install bundler
+  $ bundle
 
-and then you should be good to go. Currently, we have no dependancies. I'm sure that'll change. :)
-
-=== A note about git flow
-
-git-flow[http://github.com/nvie/gitflow] is totally awesome, so I use it to manage my branches. I'm just using the default settings. What this means for you: you can use git-flow, but if you don't, master is just for stable stuff, develop is where all the action is happening. Patches and pull requests should be created off of develop.
+Easy-peasy.
 
 === Note on Patches/Pull Requests
  

data/Rakefile

@@ -1,4 +1,5 @@
 require 'bundler'
+require 'rake/clean'
 Bundler::GemHelper.install_tasks
 
 @types = %w[rb]
@@ -16,4 +17,5 @@ namespace :whitespace do
     end
   end
 end
- 
+
+CLEAN.include('spec/shoes/.furoshiki', 'spec/shoes/sample_app')

data/furoshiki.gemspec

@@ -16,5 +16,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  #s.add_dependency "gem", "version"
+  s.add_dependency "warbler"
+  s.add_dependency "plist"
 end

data/lib/furoshiki/exceptions.rb

@@ -0,0 +1,3 @@
+module Furoshiki
+  class DownloadError < StandardError; end
+end

data/lib/furoshiki/shoes/configuration.rb

@@ -0,0 +1,146 @@
+require 'pathname'
+require 'yaml'
+
+module Furoshiki
+  module Shoes
+    # Configuration for Shoes packagers.
+    #
+    # @example
+    #   config_file = '/path/to/app.yaml'
+    #   config = Shoes::Package::Configuration.load(config_file)
+    #
+    # 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
+      # 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)
+      #   @param [String] path location of the app's 'app.yaml'
+      # @overload load(path)
+      #   @param [String] path location of the directory that
+      #      contains the app's 'app.yaml'
+      # @overload load(path)
+      #   @param [String] path location of the app
+      def self.load(path = 'app.yaml')
+        pathname = Pathname.new(path)
+        app_yaml = Pathname.new('app.yaml')
+
+        dummy_file = Struct.new(:read)
+
+        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
+          # Can't find any 'app.yaml', so assume we just want to wrap
+          # this file. If it exists, load default options. If not, let
+          # the filesystem raise an error.
+          default_options = {
+            run: pathname.basename.to_s,
+            name: pathname.basename(pathname.extname).to_s.gsub(/\W/, '-')
+          }.to_yaml
+          options = pathname.exist? ? default_options : pathname
+          file = dummy_file.new(options)
+          dir = pathname.parent
+        end
+        new YAML.load(file.read), dir 
+      end
+
+      # @param [Hash] config user options
+      # @param [String] working_dir directory in which do packaging work
+      def initialize(config = {}, working_dir = Dir.pwd)
+        defaults = {
+          name: 'Shoes App',
+          version: '0.0.0',
+          release: 'Rookie',
+          run: nil,
+          ignore: 'pkg',
+          icons: {
+            #osx: 'path/to/default/App.icns',
+            #gtk: 'path/to/default/app.png',
+            #win32: 'path/to/default/App.ico',
+          },
+          dmg: {
+            ds_store: 'path/to/default/.DS_Store',
+            background: 'path/to/default/background.png'
+          }
+        }
+
+        # Overwrite defaults with supplied config
+        @config = config.inject(defaults) { |c, (k, v)| set_symbol_key c, k, v }
+
+        # Ensure that we always have what we need
+        @config[:shortname] ||= @config[:name].downcase.gsub(/\W+/, '')
+        [:ignore, :gems].each { |k| @config[k] = Array(@config[k]) }
+        @config[:gems] << 'shoes'
+
+        # Define reader for each key
+        metaclass = class << self; self; end
+        @config.keys.each do |k|
+          metaclass.send(:define_method, k) do
+            @config[k]
+          end
+        end
+
+        @working_dir = Pathname.new(working_dir)
+      end
+
+      # @return [Pathname] the current working directory
+      attr_reader :working_dir
+
+      def to_hash
+        @config
+      end
+
+      def ==(other)
+        super unless other.class == self.class && other.respond_to?(:to_hash)
+        @config == other.to_hash
+      end
+
+      private
+      # 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 set_symbol_key(config, k, v)
+        if v.kind_of? Hash
+          config[k.to_sym] = v.inject({}) { |hash, (k, v)| set_symbol_key(hash, k, v) }
+        else
+          config[k.to_sym] = v
+        end
+        config
+      end
+    end
+  end
+end

data/lib/furoshiki/shoes/swt_app.rb

@@ -0,0 +1,217 @@
+require 'furoshiki/exceptions'
+require 'furoshiki/shoes/configuration'
+require 'furoshiki/zip/directory'
+require 'furoshiki/shoes/swt_jar'
+require 'fileutils'
+require 'plist'
+require 'open-uri'
+require 'net/http'
+
+module Furoshiki
+  module Shoes
+    class SwtApp
+      include FileUtils
+
+      # @param [Shoes::Package::Configuration] config user configuration
+      def initialize(config)
+        @config = config
+        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
+
+      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)
+        raise Furoshiki::DownloadError, "Too many redirects" if redirect_limit == 0
+
+        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
+        "#{downloads_url}/#{template_basename}-#{latest_template_version}#{template_extension}"
+      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 = SwtJar.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::ZipFile.new(template_path).each do |entry|
+          # Fragile hack
+          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
+        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
+end

data/lib/furoshiki/shoes/swt_jar.rb

@@ -0,0 +1,62 @@
+require 'furoshiki/shoes/configuration'
+require 'warbler'
+require 'warbler/traits/shoes'
+
+module Furoshiki
+  module Shoes
+    class SwtJar
+      # @param [Furoshiki::Shoes::Configuration] config user configuration
+      def initialize(config = nil)
+        @shoes_config = config || Furoshiki::Shoes::Configuration.load
+        Dir.chdir working_dir do
+          @config = Warbler::Config.new do |config|
+            config.jar_name = @shoes_config.shortname
+            config.pathmaps.application = ['shoes-app/%p']
+            specs = @shoes_config.gems.map { |g| Gem::Specification.find_by_name(g) }
+            dependencies = specs.map { |s| s.runtime_dependencies }.flatten
+            (specs + dependencies).uniq.each { |g| config.gems << g }
+            ignore = @shoes_config.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/]
+          end
+          @config.extend ShoesWarblerConfig
+          @config.run = @shoes_config.run.split(/\s/).first
+        end
+      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
+        @shoes_config.working_dir
+      end
+
+      private
+      # Adds Shoes-specific functionality to the Warbler Config
+      module ShoesWarblerConfig
+        attr_accessor :run
+      end
+    end
+  end
+end

data/lib/furoshiki/shoes.rb

@@ -0,0 +1,15 @@
+require 'furoshiki/shoes/swt_jar'
+require 'furoshiki/shoes/swt_app'
+
+module Furoshiki
+  module Shoes
+    def self.new(backend, wrapper, config)
+      class_name = class_name_for(backend, wrapper)
+      self.const_get(class_name).new(config)
+    end
+
+    def self.class_name_for(backend, wrapper)
+      [backend, wrapper].map { |name| name.to_s.capitalize }.join
+    end
+  end
+end

data/lib/furoshiki/version.rb

@@ -1,4 +1,4 @@
 module Furoshiki
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end
 

data/lib/furoshiki/zip/directory.rb

@@ -0,0 +1,19 @@
+require 'furoshiki/zip/recursive'
+
+module Furoshiki
+  module Zip
+    class Directory
+      # @param [#to_s] input_dir the directory to zip
+      # @param [#to_s] output_file the location of the output archive
+      def initialize(input_dir, output_file)
+        @input_dir = Pathname.new(input_dir)
+        @zip = Recursive.new(output_file)
+      end
+
+      # Zip the whole input directory, including the root
+      def write
+        @zip.write [@input_dir.basename], @input_dir.parent, ''
+      end
+    end
+  end
+end

data/lib/furoshiki/zip/directory_contents.rb

@@ -0,0 +1,20 @@
+require 'furoshiki/zip/recursive'
+
+module Furoshiki
+  module Zip
+    class DirectoryContents
+      # @param [#to_s] input_dir the directory to zip
+      # @param [#to_s] output_file the location of the output archive
+      def initialize(input_dir, output_file)
+        @input_dir = Pathname.new(input_dir)
+        @zip = Recursive.new(output_file)
+      end
+
+      # Zip the contents of the input directory, without the root.
+      def write
+        entries = @input_dir.children(false)
+        @zip.write entries, @input_dir, ''
+      end
+    end
+  end
+end