furoshiki 0.2.0 → 0.3.0

data/lib/furoshiki/shoes/configuration.rb

@@ -1,184 +0,0 @@
-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
-        config = YAML.load(file.read)
-        config[:working_dir] = dir
-        new(config)
-      end
-
-      # @param [Hash] config user options
-      # @param [String] working_dir directory in which do packaging work
-      def initialize(config = {})
-        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'
-          },
-          working_dir: Dir.pwd
-        }
-
-        # 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
-        [:ignore, :gems].each { |k| @config[k] = Array(@config[k]) }
-        @config[:gems] << 'shoes'
-        @config[:working_dir] = Pathname.new(@config[:working_dir])
-
-        # Define reader for each key (#shortname defined below)
-        metaclass = class << self; self; end
-        @config.keys.reject {|k| k == :shortname}.each do |k|
-          metaclass.send(:define_method, k) do
-            @config[k]
-          end
-        end
-
-        @errors = []
-      end
-
-      def shortname
-        @config[:shortname] || @config[:name].downcase.gsub(/\W+/, '')
-      end
-
-      def to_hash
-        @config
-      end
-
-      def validate
-        unless @config[:run] && working_dir.join(@config[:run]).exist?
-          add_missing_file_error(@config[:run], "Run file")
-        end
-
-        if @config[:icons][:osx] && !working_dir.join(@config[:icons][:osx]).exist?
-          add_missing_file_error(@config[:icons][:osx], "OS X icon file")
-        end
-      end
-
-      def valid?
-        validate
-        return errors.empty?
-      end
-
-      def errors
-        @errors.dup
-      end
-
-      def error_message_list
-        @errors.map {|m| "  - #{m}"}.join("\n")
-      end
-
-      def ==(other)
-        super unless other.class == self.class && other.respond_to?(:to_hash)
-        @config == other.to_hash &&
-          working_dir == other.working_dir &&
-          errors == other.errors
-      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
-
-      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
-end

data/lib/furoshiki/shoes/swt_app.rb

@@ -1,230 +0,0 @@
-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
-
-      REMOTE_TEMPLATE_URL = 'https://s3.amazonaws.com/net.wasnotrice.shoes/wrappers/shoes-app-template-0.0.1.zip'
-
-      # @param [Shoes::Package::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
-
-      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
-        #"#{downloads_url}/#{template_basename}-#{latest_template_version}#{template_extension}"
-        REMOTE_TEMPLATE_URL
-      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::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
-end

data/lib/furoshiki/shoes/swt_jar.rb

@@ -1,67 +0,0 @@
-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
-
-        unless config.valid?
-          raise Furoshiki::ConfigurationError, "Invalid configuration.\n#{config.error_message_list}"
-        end
-
-        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

@@ -1,15 +0,0 @@
-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/warbler/traits/shoes.rb

@@ -1,51 +0,0 @@
-require 'furoshiki/shoes/configuration'
-
-module Warbler
-  module Traits
-    # Hack to control the executable
-    class NoGemspec
-      def update_archive(jar); end
-    end
-
-    class Shoes
-      include Trait
-      include PathmapHelper
-
-      def self.detect?
-        #File.exist? "app.yaml"
-        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)
-        # Not sure why Warbler doesn't do this automatically
-        jar.files.delete_if { |k, v| @config.excludes.include? k }
-        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