jim 0.2.3 → 0.3.0.pre

data/lib/jim.rb

@@ -5,7 +5,7 @@ require 'version_sorter'
 require 'digest/md5'
 
 module Jim
-  VERSION = '0.2.3'
+  VERSION = '0.3.0.pre'
 
   class Error < RuntimeError; end
   class InstallError < Error; end

data/lib/jim/bundler.rb

@@ -3,99 +3,170 @@ module Jim
   # versions and then can bundle, compress, or copy those files into specific dirs
   # or files.
   #
-  # A Jimfile has a really simple format:
-  #
-  #     // comments look like JS comments
-  #     // you can set options by adding comments that look like JSON pairs
-  #     // bundle_path: /path/to/bundle.js
-  #
-  #     // A requirement is just a name and an optional version
-  #     // requirements are resolved and bundled in order of specification
-  #     jquery 1.4.2
-  #     jquery.color
-  #     sammy 0.5.0
+  # A Jimfile has a really simple format that's encoded as JSON. Options are
+  # specified as key value pairs and 'bundles' are specified under the "bundles"
+  # attribute. Each item in a bundle can be a simple string, or an array of
+  # [name, version].
   #
+  #        {
+  #          "bundle_dir": "test/tmp/",
+  #          "vendor_dir": "test/tmp/public/javascripts/vendor",
+  #          "bundles": {
+  #            "default": [
+  #              ["jquery", "1.4.1"],
+  #              "myproject",
+  #              "localfile"
+  #            ],
+  #            "base": [
+  #              "jquery"
+  #            ]
+  #          }
+  #        }
   #
+  # Pre jim version 0.3 had a different simpler but proprietary and (possibly confusing)
+  # Jimfile format. Bundler can still read that format and can actually convert
+  # it into the new JSON format for you. Future versions may remove this support.
   class Bundler
     class MissingFile < Jim::Error; end
+    class InvalidBundle < Jim::Error; end
 
-    attr_accessor :jimfile, :index, :requirements, :paths, :options
+    attr_accessor :jimfile, :index, :bundles, :paths, :options
+    attr_reader :jimfile, :bundle_dir
 
     # create a new bundler instance passing in the Jimfile as a `Pathname` or a
     # string. `index` is a Jim::Index
     def initialize(jimfile, index = nil, extra_options = {})
-      self.jimfile      = jimfile.is_a?(Pathname) ? jimfile.read : jimfile
       self.index        = index || Jim::Index.new
-      self.options      = {}
-      self.requirements = []
-      parse_jimfile
+      self.options      = {
+        :compressed_suffix => '.min'
+      }
+      self.bundles      = {}
+      self.jimfile      = jimfile
       self.options = options.merge(extra_options)
-      self.paths        = []
+      self.paths        = {}
       if options[:vendor_dir]
         logger.debug "adding vendor dir to index #{options[:vendor_dir]}"
         self.index.add(options[:vendor_dir])
       end
     end
 
-    # resove the requirements specified into Jimfile or raise a MissingFile error
+    # Set the Jimfile and parse it. If `file` is a `Pathname` read it as a string.
+    # If it's a string assume that its in the Jimfile format.
+    def jimfile=(file)
+      @jimfile = file.is_a?(Pathname) ? file.read : file
+      # look for old jimfile
+      if @jimfile =~ /^\/\//
+        logger.warn "You're Jimfile is in a deprecated format. Run `jim update_jimfile` to convert it."
+        parse_old_jimfile
+      else
+        parse_jimfile
+      end
+      @jimfile
+    end
+
+    # Set the `bundle_dir` where bundles will be written. If `bundle_dir` is set
+    # to nil, all bundles will be written to STDOUT
+    def bundle_dir=(new_dir)
+      if new_dir
+        new_dir = Pathname.new(new_dir)
+        new_dir.mkpath
+      end
+      @bundle_dir = new_dir
+    end
+
+    # Output the parse Jimfile requirements and options as a Jimfile-ready
+    # JSON-encoded string
+    def jimfile_to_json
+      h = {
+        "bundle_dir" => bundle_dir
+      }.merge(options)
+      h['bundles'] = {}
+      self.bundles.each do |bundle_name, requirements|
+        h['bundles']['bundle_name'] = []
+        requirements.each do |name, version|
+          h['bundles']['bundle_name'] << if version.nil? || version.strip == ''
+            name
+          else
+            [name, version]
+          end
+        end
+      end
+      Yajl::Encoder.encode(h, :pretty => true)
+    end
+
+    # Resolve the requirements specified in the Jimfile for each bundle to `paths`
+    # Raises MissingFile error
     def resolve!
-      self.requirements.each do |search|
-        name, version = search.strip.split(/\s+/)
-        path = self.index.find(name, version)
-        if !path
-          raise(MissingFile,
-          "Could not find #{name} #{version} in any of these paths #{index.directories.join(':')}")
+      self.bundles.each do |bundle_name, requirements|
+        self.paths[bundle_name] = []
+        requirements.each do |name, version|
+          path = self.index.find(name, version)
+          if !path
+            raise(MissingFile,
+            "Could not find #{name} #{version} in any of these paths #{index.directories.join(':')}")
+          end
+          self.paths[bundle_name] << [path, name, version]
         end
-        self.paths << [path, name, version]
       end
       paths
     end
 
-    # concatenate all the requirements into a single file and write to `to` or to the
-    # path specified in the :bundled_path option
-    def bundle!(to = nil)
+    # Concatenate all of the bundles to the dir set in `bundle_dir`
+    # or a specific bundle specified by bundle name. Setting `compress` to
+    # true will run the output of each bundle to the Google Closure Compiler.
+    # You can also use the YUI compressor by setting the option :compressor to 'yui'
+    # Raises an error if there is no bundled dir or specific bundle set
+    def bundle!(bundle_name = false, compress = false)
       resolve! if paths.empty?
-      to = options[:bundled_path] if to.nil? && options[:bundled_path]
-      io_for_path(to) do |io|
-        logger.info "Bundling to #{to}" if to
-        paths.each do |path, name, version|
-          io << path.read << "\n"
+      if bundle_name
+        files = self.paths[bundle_name]
+        if bundle_dir
+          path = path_for_bundle(bundle_name, compress)
+          concatenate(files, path, compress)
+          [path]
+        else
+          concatenate(files, "", compress)
         end
+      elsif bundle_dir
+        self.paths.collect do |bundle_name, files|
+          path = path_for_bundle(bundle_name, compress)
+          concatenate(files, path, compress)
+          path
+        end
+      else
+        raise(InvalidBundle,
+          "Must set either a :bundle_dir to write files to or a specific bundle to write to STDOUT")
       end
     end
 
-    # concatenate all the requirements into a single file then run through a JS
-    # then write to `to` or to the path specified in the :bundled_path option.
-    # You can also use the YUI compressor by setting the option :compressor to 'yui'
-    def compress!(to = nil)
-      to = options[:compressed_path] if to.nil? && options[:compressed_path]
-      io_for_path(to) do |io|
-        logger.info "Compressing to #{to}"
-        io << compress_js(bundle!(false))
-      end
+    # Alias to running `bundle!` with `compress` = `true`
+    def compress!(bundle_name = false)
+      bundle!(bundle_name, true)
     end
 
-    # copy each of the requirements into the dir specified with `dir` or the path
-    # specified with the :vendor_dir option
+    # Copy each of the requirements into the dir specified with `dir` or the path
+    # specified with the :vendor_dir option. Returns the dir it was vendored to.
     def vendor!(dir = nil, force = false)
       resolve! if paths.empty?
       dir ||= options[:vendor_dir]
       dir ||= 'vendor' # default
-      logger.info "Vendoring to #{dir}"
-      paths.each do |path, name, version|
+      logger.debug "Vendoring #{paths.length} files to #{dir}"
+      paths.collect {|n, p| p }.flatten.each do |path, name, version|
         if index.in_jimhome?(path)
           Jim::Installer.new(path, dir, :shallow => true, :force => force).install
         end
       end
+      dir
+    end
+
+    # Returns an array of `Pathname`s where each of the bundles will be written
+    def bundle_paths
+      self.bundles.collect {|name, reqs|  path_for_bundle(name) }
     end
 
-    # Run the uncompressed test through a JS compressor (closure-compiler) by
+    # Run the uncompressed js through a JS compressor (closure-compiler) by
     # default. Setting options[:compressor] == 'yui' will force the YUI JS Compressor
     def compress_js(uncompressed)
-      # if uncompressed.is_a?(File) && uncompressed.closed?
-      #   puts "uncompressed is a file"
-      #   uncompressed = File.read(uncompressed.path)
-      # end
       if options[:compressor] == 'yui'
         begin
           require "yui/compressor"
@@ -111,40 +182,64 @@ module Jim
         end
         compressor = ::Closure::Compiler.new
       end
-      compressor.compress(uncompressed)
+      begin
+        compressor.compress(uncompressed)
+      rescue Exception => e
+        logger.error e.message
+      end
     end
 
     private
-    def io_for_path(to, &block)
-      case to
-      when IO
-        yield to
-        to.close
-        to
-      when Pathname
-        to.dirname.mkpath
-        io = to.open('w')
-        yield io
-        io.close
-        io
-      when String
-        to = Pathname.new(to)
-        io_for_path(to, &block)
-      else
-        io = ""
-        yield io
-        io
+    def concatenate(paths, io, compress)
+      if io.is_a?(Pathname)
+        io = io.open('w')
+        logger.debug "#{compress ? 'Compressing' : 'Bundling'} to #{io}"
       end
+      final_io, io = io, "" if compress
+      paths.each do |path, name, version|
+        io << path.read << "\n"
+      end
+      if compress
+        final_io << compress_js(io)
+        io = final_io
+      end
+      io.close if io.respond_to?(:close)
+      io
+    end
+
+    def path_for_bundle(bundle_name, compressed = false)
+      bundle_dir + "#{bundle_name}#{compressed ? options[:compressed_suffix] : ''}.js"
     end
 
     def parse_jimfile
+      json = Yajl::Parser.parse(jimfile)
+      json.each do |k, v|
+        set_option(k, v)
+      end
+    end
+
+    def parse_old_jimfile
+      bundle = []
       jimfile.each_line do |line|
         if /^\/\/\s?([^\:]+)\:\s(.*)$/.match line
-          self.options[$1.to_sym] = $2.strip
+          k, v = $1, $2.strip
+          if k == 'bundled_path'
+            k, v = 'bundle_dir', File.dirname(v)
+          end
+          set_option(k, v)
         elsif line !~ /^\// && line.strip != ''
-          self.requirements << line
+          bundle << line.split(/\s+/, 2).compact.collect {|s| s.strip }.reject {|s| s == '' }
         end
       end
+      self.bundles['default'] = bundle
+    end
+
+    def set_option(k, v)
+      if respond_to?("#{k}=")
+        self.send("#{k}=", v)
+      else
+        self.options[k.to_sym] = v
+      end
     end
 
     def logger

data/lib/jim/cli.rb

@@ -1,212 +1,250 @@
-require 'optparse'
-require 'readline'
+require 'thor'
 
 module Jim
+  # CLI handles the command line interface for the `jim` binary. It is a `Thor`
+  # application.
+  class CLI < ::Thor
+    include Thor::Actions
 
-  # CLI handles the command line interface for the `jim` binary.
-  # The layout is farily simple. Options are parsed using optparse.rb and
-  # the different public methods represent 1-1 the commands provided by the bin.
-  class CLI
+    attr_accessor :jimfile, :jimhome, :debug, :force
 
-    attr_accessor :jimfile, :jimhome, :force, :stdout
+    source_root File.dirname(__FILE__) + '/templates'
+
+    class_option "jimhome",
+        :type => :string,
+        :banner => "set the install path/JIMHOME dir (default ~/.jim)"
+
+    class_option "jimfile",
+        :type => :string,
+        :aliases => '-j',
+        :banner => "load specific Jimfile at path (default ./Jimfile)"
+
+    class_option "force",
+        :default => false,
+        :aliases => '-f',
+        :banner => "force file creation/overwrite"
+
+    class_option "debug",
+        :default => false,
+        :aliases => '-d',
+        :banner => "set log level to debug"
+
+    class_option "version",
+        :type => :boolean,
+        :aliases => '-v',
+        :banner => "print version and exit"
 
     # create a new instance with the args passed from the command line i.e. ARGV
-    def initialize(args)
-      @output = ""
+    def initialize(*)
+      super
+      if options[:version]
+        say "jim #{Jim::VERSION}", :red
+        exit
+      end
       # set the default jimhome
-      self.jimhome = Pathname.new(ENV['JIMHOME'] || '~/.jim').expand_path
+      self.jimhome = Pathname.new(options[:jimhome] || ENV['JIMHOME'] || '~/.jim').expand_path
       # parse the options
-      self.jimfile = Pathname.new('Jimfile')
-      @args = parse_options(args)
-      ## try to run based on args
-    end
-
-    # method called by the bin directly after initialization.
-    def run(reraise = false)
-      command = @args.shift
-      if command && respond_to?(command)
-        self.send(command, *@args)
-      elsif command.nil? || command.strip == ''
-        cheat
-      else
-        @output << "No action found for #{command}. Run -h for help."
-      end
-      @output
-    rescue ArgumentError => e
-      @output << "#{e.message} for #{command}"
-      raise e if reraise
-    rescue Jim::FileExists => e
-      @output << "#{e.message} already exists, bailing. Use --force if you're sure"
-      raise e if reraise
-    rescue => e
-      @output << e.message + " (#{e.class})"
-      raise e if reraise
-    end
-
-    # list the possible commands to the logger
-    def commands
-      logger.info "Usage: jim [options] [command] [args]\n"
-      logger.info "Commands:"
-      logger.info template('commands')
-    end
-
-    # list the possible commands without detailed descriptions
-    def cheat
-      logger.info "Usage: jim [options] [command] [args]\n"
-      logger.info "Commands:"
-      logger.info [*template('commands')].grep(/^\w/).join
-      logger.info "run commands for details"
-    end
-    alias :help :cheat
-
-    # initialize the current dir with a new Jimfile
+      self.jimfile = Pathname.new(options[:jimfile] || 'Jimfile').expand_path
+      self.force = options[:force]
+      self.debug = options[:debug]
+      logger.level = Logger::DEBUG if debug
+    end
+
+    desc 'init [APPDIR]',
+      'Create an example Jimfile at path or the current directory if path is omitted'
     def init(dir = nil)
       dir = Pathname.new(dir || '')
       jimfile_path = dir + 'Jimfile'
-      if jimfile_path.readable? && !force
-        raise Jim::FileExists.new(jimfile_path)
-      else
-        File.open(jimfile_path, 'w') do |f|
-          f << template('jimfile')
-        end
-        logger.info "wrote Jimfile to #{jimfile_path}"
-      end
+      template('jimfile', jimfile_path)
     end
 
-    # install the file/project `url` into `jimhome`
+    desc 'install <URL> [NAME] [VERSION]',
+      "Install the file(s) at url into the JIMHOME directory."
+
+    long_desc <<-EOT
+      Install the file(s) at url into the JIMHOME directory. URL can be any path
+      or url that Downlow understands. This means:
+
+        jim install http://code.jquery.com/jquery-1.4.1.js\n
+        jim install ../sammy/\n
+        jim install gh://quirkey/sammy\n
+        jim install git://github.com/jquery/jquery.git\n
+    EOT
     def install(url, name = false, version = false)
       Jim::Installer.new(url, jimhome, :force => force, :name => name, :version => version).install
     end
 
-    # bundle the files specified in Jimfile into `to`
-    def bundle(to = nil)
-      to = STDOUT if stdout
-      io = bundler.bundle!(to)
-      logger.info "Wrote #{File.size(io.path) / 1024}kb" if io.respond_to? :path
+    desc 'bundle [BUNDLE_NAME]',
+      "Bundle the files specified in Jimfile"
+    long_desc <<-EOT
+      Concatenate all the bundles listed in a Jimfile and save them to the bundle dir
+      specified in the options or in the Jimfile.
+
+      If [BUNDLE_NAME] is specified, only bundles that specific bundle.
+
+      If no Jimfile is set in the options, assumes ./Jimfile.
+    EOT
+    method_option "bundle_dir",
+                  :type => :string,
+                  :banner => "override the bundle_dir set in the Jimfile"
+    method_option "stdout",
+                  :default => false,
+                  :aliases => '-o',
+                  :type => :boolean,
+                  :banner => "write the bundle to STDOUT"
+    def bundle(bundle_name = nil)
+      make_bundle(bundle_name, false)
     end
 
-    # compress the files specified in Jimfile into `to`
-    def compress(to = nil)
-      to = STDOUT if stdout
-      io = bundler.compress!(to)
-      logger.info "Wrote #{File.size(io.path) / 1024}kb" if io.respond_to? :path
+    desc "compress [BUNDLE_NAME]",
+      "Bundle all the files listed in a Jimfile, run through the google closure " +
+      "compiler and save them to [COMPRESSED_PATH]."
+    long_desc <<-EOT
+      Concatenate all the bundles listed in a Jimfile, run them through the google
+      closure compiler and save them to the bundle dirspecified in the options or
+      in the Jimfile.
+
+      If a [BUNDLE_NAME] is specified, only bundle and compress that bundle.
+
+      If no Jimfile is set in the options, assumes ./Jimfile.
+    EOT
+    method_option "bundle_dir",
+                  :type => :string,
+                  :banner => "override the bundle_dir set in the Jimfile"
+    method_option "stdout",
+                  :default => false,
+                  :aliases => '-o',
+                  :type => :boolean,
+                  :banner => "write the bundle to STDOUT"
+    def compress(bundle_name = nil)
+      make_bundle(bundle_name, true)
     end
 
-    # copy/vendor all the files specified in Jimfile to `dir`
+    desc "vendor [VENDOR_DIR]",
+      "Copy all the files listed in Jimfile to the vendor_dir"
     def vendor(dir = nil)
-      bundler.vendor!(dir, force)
+      dir = bundler.vendor!(dir, force)
+      say("Vendored files to #{dir}", :green)
+    rescue Jim::Error => e
+      say e.message, :red
     end
 
-    # list the only the _installed_ projects and versions.
-    # Match names against `search` if supplied.
+    desc "list [SEARCH]",
+      "List all the installed packages and their versions, optionally limiting by [SEARCH]"
     def list(search = nil)
-      logger.info "Getting list of installed files in\n#{installed_index.directories.join(':')}"
-      logger.info "Searching for '#{search}'" if search
+      say "Getting list of installed files in"
+      say("#{installed_index.directories.join(':')}", :yellow)
+      say("Searching for '#{search}'", :yellow) if search
       list = installed_index.list(search)
-      logger.info "Installed:"
+      say "Installed:"
       print_version_list(list)
     end
-    alias :installed :list
+    map "installed" => "list"
 
-    # list all available projects and versions including those in the local path, or
-    # paths specified in a Jimfile.
-    # Match names against `search` if supplied.
+    desc "available [SEARCH]",
+      "List all available projects and versions " +
+      "including those in the local path, or paths specified in a Jimfile"
     def available(search = nil)
-      logger.info "Getting list of all available files in\n#{index.directories.join("\n")}"
-      logger.info "Searching for '#{search}'" if search
+      say "Getting list of all available files in\n#{index.directories.join("\n")}"
+      say "Searching for '#{search}'" if search
       list = index.list(search)
-      logger.info "Available:"
+      say "Available:"
       print_version_list(list)
     end
 
-    # Iterates over matching files and prompts for removal
+    desc "remove <NAME> [VERSION]",
+      "Iterate through the install files and prompt for the removal of those " +
+      "matching the supplied NAME and VERSION"
     def remove(name, version = nil)
-      logger.info "Looking for files matching #{name} #{version}"
+      say "Looking for files matching #{name} #{version}"
       files = installed_index.find_all(name, version)
       if files.length > 0
-        logger.info "Found #{files.length} matching files"
+        say "Found #{files.length} matching files"
         removed = 0
         files.each do |filename|
-          response = Readline.readline("Remove #{filename}? (y/n)\n")
-          if response.strip =~ /y/i
-            logger.info "Removing #{filename}"
+          do_remove = yes?("Remove #{filename}?", :red)
+          if do_remove
+            say "Removing #{filename}"
             filename.delete
             removed += 1
           else
-            logger.info "Skipping #{filename}"
+            say "Skipping #{filename}", :yellow
           end
         end
-        logger.info "Removed #{removed} files."
+        say "Removed #{removed} files."
       else
-        logger.info "No installed files matched."
+        say "No installed files matched."
       end
     end
-    alias :uninstall :remove
+    map "uninstall" => "remove"
 
-    # list the files and their resolved paths specified in the Jimfile
+    desc "resolve",
+      "Resolve all the paths listed in a Jimfile and print them to STDOUT. " +
+      "If no Jimfile is set in the options, assumes ./Jimfile."
     def resolve
       resolved = bundler.resolve!
-      logger.info "Files:"
-      resolved.each do |r|
-        logger.info r.join(" | ")
+      say "Files:"
+      resolved.each do |bundle_name, requirements|
+        say bundle_name, :green
+        say "-----------------------", :green
+        requirements.each do |path, name, version|
+          say [name, version, path].join(" | ") + "\n"
+        end
       end
       resolved
+    rescue Jim::Error => e
+      say e.message, :red
     end
 
-    # vendor to dir, then bundle and compress the Jimfile contents
+    desc "pack [DIR]",
+      "Runs in order, vendor, bundle, compress. This command " +
+      "simplifies the common workflow of vendoring and re-bundling " +
+      "before committing or deploying changes to a project"
     def pack(dir = nil)
-      logger.info "packing the Jimfile for this project"
-      vendor(dir)
-      bundle
-      compress
+      say "Packing the Jimfile for this project"
+      invoke :vendor, [dir]
+      invoke :bundle
+      invoke :compress
     end
 
-    private
-    def parse_options(runtime_args)
-      OptionParser.new("", 24, '  ') do |opts|
-        opts.banner = "Usage: jim [options] [command] [args]"
-
-        opts.separator ""
-        opts.separator "jim options:"
-
-        opts.on("--jimhome path/to/home", "set the install path/JIMHOME dir (default ~/.jim)") {|h|
-          self.jimhome = Pathname.new(h)
-        }
-
-        opts.on("-j", "--jimfile path/to/jimfile", "load specific Jimfile at path (default ./Jimfile)") { |j|
-          self.jimfile = Pathname.new(j)
-        }
-
-        opts.on("-f", "--force", "force file creation/overwrite") {|f|
-          self.force = true
-        }
-
-        opts.on("-d", "--debug", "set log level to debug") {|d|
-          logger.level = Logger::DEBUG
-        }
-
-        opts.on("-o", "--stdout", "write output of commands (like bundle and compress to STDOUT)") {|o|
-          logger.level = Logger::ERROR
-          self.stdout = true
-        }
-
-        opts.on("-v", "--version", "print version") {|d|
-          puts "jim #{Jim::VERSION}"
-          exit
-        }
+    desc "watch [DIR]",
+      "Watches your Jimfile and JS files and triggers `bundle` if something " +
+      "changes. Handy for development."
+    def watch(dir = nil)
+      require 'fssm'
+      run_update = lambda {|type, path|
+        unless bundler.bundle_paths.any? {|p| path.include?(p) }
+          say("--> #{path} #{type}")
+          system "jim bundle"
+        end
+      }
+      say "Now watching JS files..."
+      run_update["started", 'Jimfile']
+      FSSM.monitor(Dir.pwd, [File.join('**','*.js'), 'Jimfile']) do
+        update do |base, relative|
+          run_update["changed", relative]
+        end
 
+        create do |base, relative|
+          run_update["created", relative]
+        end
 
-        opts.on_tail("-h", "--help", "Show this message. Run jim commands for list of commands.") do
-          puts opts.help
-          exit
+        delete do |base, relative|
+          run_update["deleted", relative]
         end
+      end
+    end
 
-      end.parse! runtime_args
-    rescue OptionParser::MissingArgument => e
-      logger.warn "#{e}, run -h for options"
-      exit
+    desc "update_jimfile [APP_DIR]",
+      "Converts a Jimfile from the old pre 0.3 format to the JSON format."
+    def update_jimfile(dir = nil)
+      dir = Pathname.new(dir || '')
+      bundler
+      copy_file(dir + 'Jimfile', dir + 'Jimfile.old')
+      create_file(dir + 'Jimfile', bundler.jimfile_to_json)
     end
 
+    private
     def index
       @index ||= Jim::Index.new(install_dir, Dir.pwd)
     end
@@ -223,18 +261,29 @@ module Jim
       jimhome + 'lib'
     end
 
-    def template(path)
-      (Pathname.new(__FILE__).dirname + 'templates' + path).read
-    end
-
     def logger
       Jim.logger
     end
 
     def print_version_list(list)
       list.each do |file, versions|
-        logger.info "#{file} (#{VersionSorter.rsort(versions.collect {|v| v[0] }).join(', ')})"
+        say "#{file} (#{VersionSorter.rsort(versions.collect {|v| v[0] }).join(', ')}\n"
+      end
+    end
+
+    def make_bundle(bundle_name, compress = false)
+      bundler.bundle_dir = options[:bundle_dir] if options[:bundle_dir]
+      bundler.bundle_dir = nil if options[:stdout]
+      result = bundler.bundle!(bundle_name, compress)
+      if options[:stdout]
+        puts result
+      else
+        result.each do |path|
+          say("Wrote #{path} #{File.size(path.to_s) / 1024}kb", :green)
+        end
       end
+    rescue Jim::Error => e
+      say e.message, :red
     end
 
   end