flintlock 0.1.0 → 0.2.0

data/CHANGES.md

@@ -1,3 +1,31 @@
+# Version 0.2.0
+
+- Added the ``package`` subcommand, which packages up a local directory into
+  a module archive.
+- Added the ``defaults`` subcommand, which prints out the default configuration
+  (from ``bin/defaults``) of the given module.
+- Added the ``new`` subcommand, which generates an empty template module 
+- Added the ``version`` subcommand, which prints the ``flintlock`` version
+- Added the ``--halt`` option to the ``deploy`` subcommand. This allows users
+  to halt deployment after a particular stage has run (e.g. ``--halt stage``)
+- Added a new optional deployment stage called ``detect``. This script should be
+  used to validate whether the module is appropriate for installation on the 
+  current host.
+- Fixed a bug that prevented scripts that required a TTY from working.
+- Fixed a bug with relative paths passed to the ``deploy`` command
+- Module scripts are now silently skipped if they don't exist or are empty
+  (rather than erroring out).
+- Fixed a bug where a ``/tmp`` filesystem mounted ``noexec`` would prevent 
+  scripts from running.
+- Can now deploy from local tarballs
+- Can now deploy from subversion repositories
+- Keyboard interrupts (``SIGQUIT``) are now caught and a nicer error is printed.
+- External commands (e.g. ``git``, ``svn``) are validated prior to being run.
+- Support a wider array of module URIs (e.g. ``svn+ssh://...``)
+- Archives with root directories are now supported as valid module archives 
+  (e.g. ``<archive_root>/<root_dir>/bin/*`` vs ``<archive_root>/bin/*`` layouts)
+- Archive detection now uses MIME hinting rather than filename hinting
+- Fixed a few issues with the RPM spec file
 
 # Version 0.1.0
 

data/README.md

@@ -44,6 +44,7 @@ files and directories to ``/some/empty/directory``. Let's see what happens:
 ```console
 $ flintlock deploy git://github.com/jcmcken/flintlock-redis.git /some/empty/directory
          run  fetching module
+         run  detecting compatibility
         info  deploying jcmcken/redis (0.0.1) to '/some/empty/directory'
       create  creating deploy directory
          run  installing and configuring dependencies
@@ -92,10 +93,12 @@ is usually acceptable. But all of the important files should really be located t
 
 ## Supported Formats
 
-Currently ``flintlock`` can install modules from a number of sources. In addition to
-local directories, ``flintlock`` supports the following protocols/formats:
+Currently ``flintlock`` can install modules from a number of sources:
 
-* ``git``
+* From a local directory
+* From a local tarball (``tar`` or ``tar.gz``)
+* Over ``git`` supported protocols (``git://..``)
+* Over ``svn`` supported protocols (``svn://...``)
 * ``tar`` or ``tar.gz`` over ``http``/``https``
 
 Attempting to install any other way will throw an error message similar to the following:
@@ -117,6 +120,7 @@ At its heart, a module has the following minimal layout:
 sample-app-1
 |-- bin
 |   |-- defaults
+|   |-- detect
 |   |-- modify
 |   |-- prepare
 |   |-- stage
@@ -130,8 +134,8 @@ generate this structure.
 
 The top-level directory (in this case, ``sample-app-1``) can be called anything. 
 
-The files under ``bin`` are executable scripts (using any language you care to use). All
-of these scripts must exist, but they need not do anything. More on these later.
+The files under ``bin`` are executable scripts (using any language you care to
+use). More on these later.
 
 The ``metadata.json`` file contains metadata about the module. This metadata looks as follows:
 
@@ -143,8 +147,9 @@ The ``metadata.json`` file contains metadata about the module. This metadata loo
 }
 ```
 
-All three keys (``author``, ``name``, ``version``) are required, but can be any value. These
-metadata are merely used to namespace the module.
+All three keys (``author``, ``name``, ``version``) are required, but can be any value
+(as long as they're not the empty string). These metadata are merely used to namespace 
+the module.
 
 ``flintlock`` developers can choose to include more files in their modules if needed.
 
@@ -157,6 +162,7 @@ These stages correspond directly to the scripts under ``bin/``.
 
 The most important stages, and their purpose, are as follows. (The stages occur in the order listed below)
 
+* ``detect``: Detect whether the module is compatible with the current host.
 * ``prepare``: Install or compile any required dependencies. This script takes no arguments.
 * ``stage``: Stage the application directories and files. This script takes a single argument,
   which is the directory where your app will be deployed. This directory need not exist, but if
@@ -205,4 +211,7 @@ command line.
 
 ### Examples
 
-An example ``flintlock`` module can be found @ http://github.com/jcmcken/flintlock-redis.git.
+Some example ``flintlock`` modules can be found @ the following locations:
+
+* http://github.com/jcmcken/flintlock-redis.git
+* http://github.com/jcmcken/flintlock-tomcat.git

data/lib/flintlock.rb

@@ -1,3 +1,4 @@
 require 'rubygems'
+require 'flintlock/util'
 require 'flintlock/metadata'
 require 'flintlock/module'

data/lib/flintlock/cli.rb

@@ -1,5 +1,6 @@
 require 'thor'
 require 'flintlock/module'
+require 'flintlock/version'
 
 module Flintlock
   class Cli < Thor
@@ -7,22 +8,38 @@ module Flintlock
 
     desc "deploy MODULE DIRECTORY", "Deploy a flintlock module MODULE to DIRECTORY"
     method_option :debug, :type => :boolean, :description => "enable debug output", :default => false
+    method_option :halt, :type => :string, :banner => 'STAGE', 
+                  :description => "Halt after STAGE", :enum => ['fetch', 'detect', 'prepare', 'stage', 'start', 'modify']
     def deploy(uri, app_dir)
+      app_dir = File.expand_path(app_dir)
       say_status "run", "fetching module", :magenta
       mod = get_module(uri, options)
-      say_status "info", "deploying #{mod.full_name} to '#{app_dir}'", :blue
-      say_status "create", "creating deploy directory"
-      mod.create_app_dir(app_dir) rescue abort("deploy directory is not empty")
+      return if options[:halt] == 'fetch'
 
       begin
+        say_status "run", "detecting compatibility", :magenta
+        mod.detect
+        return if options[:halt] == 'detect'
+
+        say_status "info", "deploying #{mod.full_name} to '#{app_dir}'", :blue
+        say_status "create", "creating deploy directory"
+        mod.create_app_dir(app_dir) rescue abort("deploy directory is not empty")
         say_status "run", "installing and configuring dependencies", :magenta
         mod.prepare
+        return if options[:halt] == 'prepare'
+
         say_status "create", "staging application files"
         mod.stage(app_dir)
+        return if options[:halt] == 'stage'
+
         say_status "run", "launching the application", :magenta
         mod.start(app_dir)
+        return if options[:halt] == 'start'
+
         say_status "run", "altering application runtime environment", :magenta
         mod.modify(app_dir)
+        return if options[:halt] == 'modify'
+
         say_status "info", "complete!", :blue
       rescue Errno::EACCES => e
         abort("#{e.message.gsub(/Permission denied/, 'permission denied')}")
@@ -39,24 +56,57 @@ module Flintlock
         inside("bin") do
           Module.script_names.each do |script|
             create_file script
+            chmod script, 0755, :verbose => false
           end
         end 
         create_file(Metadata.filename, Metadata.empty)
       end
     end
 
+    desc "package [DIRECTORY]", "Package up the given module directory"
+    method_option :debug, :type => :boolean, :description => "enable debug output", :default => false
+    def package(directory = Dir.pwd)
+      handle_exception { Module.package(directory, options.dup) }
+    end
+
+    desc "defaults MODULE", "Print the default configuration settings for MODULE"
+    def defaults(uri)
+      mod = get_module(uri)
+      mod.defaults.each do |k,v|
+        puts "#{k}=#{v}"
+      end
+    end
+
+    desc "version", "Print version information"
+    def version
+      puts Flintlock::VERSION
+    end
+
     private
 
     def get_module(uri, options={})
-      begin
+      handle_exception do
         Flintlock::Module.new(uri, options)
+      end
+    end
+
+    def handle_exception(&block)
+      begin
+        result = block.call
       rescue InvalidModule => e
         abort("invalid flintlock module '#{e}'")
       rescue UnsupportedModuleURI => e
         abort("don't know how to download '#{e}'!")
       rescue ModuleDownloadError => e
         abort("failed to download '#{e}'")
+      rescue DependencyError => e
+        abort("missing dependency: no such command '#{e}'")
+      rescue Interrupt
+        abort("interrupted by user")
+      rescue PackagingError
+        abort("packaging failed!")
       end
+      result
     end
 
     def error(message)

data/lib/flintlock/logger.rb

@@ -9,5 +9,10 @@ module Flintlock
     def unsilence!
       @logdev, @saved_logdev = @saved_logdev, nil if @saved_logdev
     end
+
+    def linewise(output, options={})
+      options[:level] ||= :debug
+      output.lines.each { |x| send(options[:level], x) }
+    end
   end
 end

data/lib/flintlock/metadata.rb

@@ -46,6 +46,10 @@ module Flintlock
       "#{author}/#{name} (#{version})"
     end
 
+    def package_name
+      "#{author}-#{name}-#{version}"
+    end
+
     def self.empty
       {"author" => "", "version" => "", "name" => ""}.to_json
     end

data/lib/flintlock/module.rb

@@ -1,6 +1,7 @@
 require 'flintlock/metadata'
 require 'flintlock/logger'
 require 'flintlock/util'
+require 'flintlock/runner'
 require 'open3'
 require 'fileutils'
 require 'logger'
@@ -15,6 +16,7 @@ module Flintlock
   class UnsupportedModuleURI < RuntimeError; end
   class ModuleDownloadError < RuntimeError; end
   class RunFailure < RuntimeError; end
+  class PackagingError < RuntimeError; end
 
   class Module
     attr_reader :uri, :metadata
@@ -22,33 +24,34 @@ module Flintlock
     def initialize(uri = nil, options={})
       # track temporary files and directories for deletion
       @tmpfiles = []
-     
+
       # destroy tmp files on exit 
       at_exit { handle_exit }
 
-      @debug = !!options[:debug]
       @uri = uri || Dir.pwd
-      @log = load_logger
-      @root_dir = download_from_uri(@uri)
-      @metadata = load_metadata
+      @log = Util.load_logger(!!options[:debug])
+      @runner = Runner.new(options)
+     
+      @root_dir = detect_root_dir(download_from_uri(@uri))
+      @metadata = load_metadata(@root_dir)
 
       load_scripts!
       validate
 
       @env = load_env(@defaults_script)
-
     end
 
     def download_from_uri(uri)
-      case URI.parse(uri).scheme
-      when nil # no scheme == local file
-        uri
+      case Util.get_uri_scheme(uri)
+      when nil, 'file' # no scheme == local file
+        handle_file(uri)
       when 'git'
         handle_git_uri(uri)
+      when 'svn'
+        handle_svn_uri(uri)
       when 'http', 'https'
-        raise UnsupportedModuleURI.new(uri) if ! Util.supported_archive?(uri)
         # over these protocols, we're getting an archive
-        handle_archive(handle_http_uri(uri))
+        handle_file(handle_http_uri(uri))
       else
         raise UnsupportedModuleURI, uri
       end
@@ -59,11 +62,22 @@ module Flintlock
     end
 
     def handle_git_uri(uri)
+      Util.depends_on 'git'
+
       root_dir = Dir.mktmpdir
       @tmpfiles << root_dir
-      command = Shellwords.join(['git', 'clone', uri, root_dir])
-      stdout, stderr, status = Open3.capture3(command)
-      raise ModuleDownloadError, uri if status.exitstatus != 0 
+      status = @runner.run(['git', 'clone', uri, root_dir])
+      raise ModuleDownloadError, uri if status != 0 
+      root_dir
+    end
+
+    def handle_svn_uri(uri)
+      Util.depends_on 'svn'
+
+      root_dir = Dir.mktmpdir
+      @tmpfiles << root_dir
+      status = @runner.run(['svn', 'checkout', uri, root_dir])
+      raise ModuleDownloadError, uri if status != 0 
       root_dir
     end
 
@@ -78,23 +92,32 @@ module Flintlock
         end
       end
       tmpfile
-    rescue OpenURI::HTTPError
+    rescue OpenURI::HTTPError, OpenSSL::SSL::SSLError
       raise ModuleDownloadError, uri
     end
 
-    def handle_archive(filename)
+    def handle_file(filename)
+      @log.debug("handling file '#{filename}'")
+      Util.depends_on 'tar'
+
       tmpdir = Dir.mktmpdir
       @tmpfiles << tmpdir
-      case filename
-      when /\.tar\.gz$/
+
+      mime = Util.mime_type(filename)
+      @log.debug("mime-type is '#{mime}'")
+
+      case mime 
+      when 'application/x-directory'
+        return filename
+      when 'application/x-gzip'
         command = ['tar', 'xfz', filename, '-C', tmpdir]
-      when /\.tar$/
+      when 'application/x-tar'
         command = ['tar', 'xf', filename, '-C', tmpdir]
       else
         raise UnsupportedModuleURI, filename
       end
-      _, _, status = Open3.capture3(Shellwords.join(command))
-      raise ModuleDownloadError if status.exitstatus != 0
+      status = @runner.run(command)
+      raise ModuleDownloadError, filename if status != 0
       tmpdir
     end
 
@@ -102,20 +125,29 @@ module Flintlock
       @metadata.full_name
     end
 
+    def package_name
+      @metadata.package_name
+    end
+
+    def self.stages
+      ['detect', 'prepare', 'stage', 'start', 'modify']
+    end
+
     def self.script_names
-      ['defaults', 'modify', 'prepare', 'stage', 'start', 'stop']
+      ['defaults', *Module.stages, 'stop']
     end
 
     def scripts
-      [@modify_script, @prepare_script, @stage_script, @start_script, @stop_script, @defaults_script]
+      [@modify_script, @prepare_script, @stage_script, @start_script, @stop_script, @defaults_script, @detect_script]
     end
 
-    def scripts_exist?
-      scripts.map { |x| File.file?(x) }.all?
+    def valid?
+      @metadata.valid?
     end
 
-    def valid?
-      @metadata.valid? && scripts_exist?
+    def detect
+      @log.info("running detect stage: #{@detect_script}")
+      run_script(@detect_script)
     end
 
     def prepare
@@ -149,7 +181,7 @@ module Flintlock
 
     def load_env(defaults_script)
       # hokey, but seems to work
-      env_data = %x{set -a && source #{defaults_script} && env}.split.map{ |x| x.split('=', 2) }
+      env_data = %x{set -a && source #{defaults_script} && env}.split("\n").map{ |x| x.split('=', 2) }
       env = Hash[env_data]
       @log.debug("defaults script is #{defaults_script}")
       @log.debug("defaults env is #{env.inspect}")
@@ -158,11 +190,34 @@ module Flintlock
       env
     end
 
+    def defaults
+      Hash[@env.to_a - ENV.to_a] 
+    end
+
     def create_app_dir(app_dir)
       FileUtils.mkdir_p(app_dir)
       raise if ! Util.empty_directory?(app_dir)
     end
 
+    def self.package(directory, options={})
+      Util.depends_on 'tar'
+
+      mod = Module.new(directory, options)
+      archive = mod.package_name + '.tar.gz'
+
+      if Util.path_split(directory).length > 1
+        change_to = File.dirname(directory)
+        archive_path = File.basename(directory)
+      else
+        change_to = '.'
+        archive_path = directory
+      end
+
+      status = Runner.new(options).run(['tar', 'cfz', archive, '-C', change_to, archive_path])
+      raise PackagingError.new(directory) if status != 0
+      archive
+    end
+
     private
 
     def load_scripts!
@@ -172,36 +227,42 @@ module Flintlock
     end
 
     def validate
+      @log.debug('validating module')
       raise InvalidModule.new(@uri) if ! valid?
     end
 
-    def load_logger
-      log = Logger.new(STDOUT)
-      log.silence! if ! @debug
-      log
-    end
-
-    def load_metadata
+    def load_metadata(root_dir)
+      @log.debug('loading module metadata')
       begin
-        Metadata.new(File.join(@root_dir, Metadata.filename)) 
+        Metadata.new(File.join(root_dir, Metadata.filename)) 
       rescue Errno::ENOENT
         raise InvalidModule, uri
       end
     end
 
-    def run(command)
-      handle_run(*Open3.capture3(@env, command))
+    def empty_script?(script)
+      File.read(script).strip.empty?
+    end
+
+    def skip_script?(script)
+     skip = ! File.file?(script) || empty_script?(script)
+     @log.debug("skipping '#{script}'") if skip
+     skip
     end
 
     def run_script(script, *args)
-      run(Shellwords.join([script, *args]))
+      return if skip_script?(script)
+      command = [*Util.detect_runtime(script), script, *args].compact
+      status = @runner.run(command, :env => @env)
+      raise RunFailure if status != 0
     end
 
-    def handle_run(stdout, stderr, status)
-      stdout.lines.each { |x| @log.info(x) }
-      if status.exitstatus != 0
-        stderr.lines.each { |x| @log.error(x) }
-        raise RunFailure
+    def detect_root_dir(directory)
+      contents = Dir[File.join(directory, '*')] 
+      if contents.length == 1 && File.directory?(contents[0])
+        contents[0]
+      else
+        directory
       end
     end
   end

data/lib/flintlock/runner.rb

@@ -0,0 +1,34 @@
+require 'open3'
+
+module Flintlock
+  class Runner
+    def initialize(options={})
+      @log = Util.load_logger(!!options[:debug])
+    end
+
+    def run(command, options={})
+      @log.debug("running command: '#{command.inspect}'")
+
+      options[:capture] = !!options[:capture]
+      options[:env] = options.fetch(:env, ENV)
+
+      rout, wout = IO.pipe
+      rerr, werr = IO.pipe
+      pid = Process.spawn(options[:env], Shellwords.join(command), :out => wout, :err => werr)
+
+      Process.wait(pid)
+      status = $?.exitstatus
+
+      # capture stdout/stderr
+      wout.close
+      werr.close
+      stdout = rout.read
+      stderr = rerr.read
+
+      @log.linewise(stdout, :level => :info)
+      @log.linewise(stderr)
+
+      return options[:capture] ? [stdout, stderr, status] : status 
+    end
+  end
+end

data/lib/flintlock/util.rb

@@ -1,27 +1,63 @@
+require 'flintlock/logger'
+
 module Flintlock
+  class DependencyError < RuntimeError; end
+
   class Util
     def self.empty_directory?(directory)
       Dir[File.join(directory, '*')].empty?
     end
   
-    def self.supported_archives
-      ['.tar.gz', '.tar']
-    end
-  
-    def self.supported_archive?(filename)
-      Util.supported_archives.include?(full_extname(filename))
-    end
-  
     def self.full_extname(filename)
       data = []
       current_filename = filename.dup
       while true
         ext = File.extname(current_filename)
-        break if ext.empty?
+        break if ext.empty? || ext =~ /^\.\d+$/
         current_filename = current_filename.gsub(/#{ext}$/, '')
         data << ext
       end
       data.reverse.join
     end
+
+    def self.which(command)
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exe = File.join(path, command)
+        return exe if File.executable?(exe)
+      end
+      nil
+    end
+
+    def self.get_uri_scheme(uri)
+      scheme = URI.parse(uri).scheme
+      return scheme.nil? ? nil : scheme.split('+', 0)[0] 
+    end
+
+    def self.load_logger(debug = false)
+      log = Logger.new(STDOUT)
+      log.silence! if ! debug
+      log
+    end
+
+    def self.detect_runtime(script, default="/bin/sh")
+      raw = File.open(script, &:readline)[/^\s*#!\s*(.+)/, 1] || default
+      raw.split
+    rescue EOFError
+      [default]
+    end
+
+    def self.path_split(path)
+      path.split(File::SEPARATOR).select { |x| ! x.empty? }
+    end
+
+    def self.depends_on(what)
+      raise DependencyError.new(what) if which(what).nil?
+    end
+
+    def self.mime_type(filename)
+      depends_on 'file'
+      stdout, stderr, status = Runner.new.run(['file', '--mime-type', filename], :capture => true) 
+      stdout.split(':')[1].strip
+    end
   end
 end

data/lib/flintlock/version.rb

@@ -1,3 +1,3 @@
 module Flintlock
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,89 +1,135 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: flintlock
-version: !ruby/object:Gem::Version
-  version: 0.1.0
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
-authors:
+authors: 
 - Jon McKenzie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-06-03 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: thor
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: json
-  requirement: !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: fakefs
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: A simple application deployer inspired by Heroku's buildpacks
 email: jcmcken@gmail.com
-executables:
+executables: 
 - flintlock
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - lib/flintlock.rb
 - lib/flintlock/module.rb
 - lib/flintlock/metadata.rb
 - lib/flintlock/util.rb
 - lib/flintlock/cli.rb
 - lib/flintlock/logger.rb
+- lib/flintlock/runner.rb
 - lib/flintlock/version.rb
 - LICENSE
 - README.md
 - CHANGES.md
 - bin/flintlock
+has_rdoc: true
 homepage: https://github.com/jcmcken/flintlock
-licenses:
+licenses: 
 - MIT
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 9
+      - 3
       version: 1.9.3
-required_rubygems_version: !ruby/object:Gem::Requirement
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A simple application deployer
 test_files: []
+