pkgr 1.2.0 → 1.3.0

data/lib/pkgr/distributions/centos.rb

@@ -0,0 +1,12 @@
+require "pkgr/distributions/redhat"
+
+module Pkgr
+  module Distributions
+    # Contains the various components required to make a packaged app integrate well with a CentOS system.
+    class Centos < Redhat
+      def runner
+        @runner ||= Runner.new("upstart", "1.5")
+      end
+    end
+  end
+end

data/lib/pkgr/distributions/debian.rb

@@ -1,182 +1,58 @@
 require 'pkgr/buildpack'
 require 'pkgr/process'
-require 'yaml'
-require 'erb'
+require 'pkgr/distributions/base'
 
 module Pkgr
   module Distributions
-    class Debian
-
-      # Must be subclassed.
-      def codename
-        raise NotImplementedError, "codename must be set"
+    # Contains the various components required to make a packaged app integrate well with a Debian system.
+    class Debian < Base
+      # Only keep major digits
+      def release
+        @release[/^[0-9]+/]
       end
 
-      def osfamily
-        "debian"
+      def runner
+        @runner ||= Runner.new("sysv", "lsb-3.1")
       end
 
-      def slug
-        [osfamily, codename].join("-")
+      def package_test_command(package)
+        "dpkg -s '#{package}' > /dev/null 2>&1"
       end
 
-      def templates(app_name)
-        list = []
-
-        # directories
-        [
-          "usr/local/bin",
-          "opt/#{app_name}",
-          "etc/#{app_name}/conf.d",
-          "etc/default",
-          "etc/init",
-          "var/log/#{app_name}"
-        ].each{|dir| list.push Templates::DirTemplate.new(dir) }
-
-        # default
-        list.push Templates::FileTemplate.new("etc/default/#{app_name}", File.new(File.join(data_dir, "default.erb")))
-        # executable
-        list.push Templates::FileTemplate.new("usr/local/bin/#{app_name}", File.new(File.join(data_dir, "runner.erb")), mode: 0755)
-        # logrotate
-        list.push Templates::FileTemplate.new("etc/logrotate.d/#{app_name}", File.new(File.join(data_dir, "logrotate.erb")))
-
-        # NOTE: conf.d files are no longer installed here, since we don't want to overwrite any pre-existing config.
-        # They're now installed in the postinstall script.
-
-        list
-      end
-
-      def initializers_for(app_name, procfile_entries)
-        list = []
-        procfile_entries.select(&:daemon?).each do |process|
-          Pkgr.debug "Adding #{process.inspect} to initialization scripts"
-          # sysvinit
-          list.push [process, Templates::FileTemplate.new("sysv/#{app_name}", data_file("sysv/master.erb"))]
-          list.push [process, Templates::FileTemplate.new("sysv/#{app_name}-#{process.name}", data_file("sysv/process_master.erb"))]
-          list.push [process, Templates::FileTemplate.new("sysv/#{app_name}-#{process.name}-PROCESS_NUM", data_file("sysv/process.erb"))]
-          # upstart
-          list.push [process, Templates::FileTemplate.new("upstart/#{app_name}", data_file("upstart/init.d.sh.erb"))]
-          list.push [process, Templates::FileTemplate.new("upstart/#{app_name}.conf", data_file("upstart/master.conf.erb"))]
-          list.push [process, Templates::FileTemplate.new("upstart/#{app_name}-#{process.name}.conf", data_file("upstart/process_master.conf.erb"))]
-          list.push [process, Templates::FileTemplate.new("upstart/#{app_name}-#{process.name}-PROCESS_NUM.conf", data_file("upstart/process.conf.erb"))]
-        end
-        list
-      end
-
-      def check(config)
-        missing_packages = (build_dependencies(config.build_dependencies) || []).select do |package|
-          test_command = "dpkg -s '#{package}' > /dev/null 2>&1"
-          Pkgr.debug "sh(#{test_command})"
-          ! system(test_command)
-        end
-
-        unless missing_packages.empty?
-          package_install_command = "sudo apt-get update && sudo apt-get install --force-yes -y #{missing_packages.map{|package| "\"#{package}\""}.join(" ")}"
-          if config.auto
-            package_install = Mixlib::ShellOut.new(package_install_command)
-            package_install.logger = Pkgr.logger
-            package_install.run_command
-            package_install.error!
-          else
-            Pkgr.warn("Missing build dependencies detected. Run the following to fix: #{package_install_command}")
-          end
-        end
+      def package_install_command(packages)
+        "sudo apt-get update && sudo apt-get install --force-yes -y #{packages.map{|package| "\"#{package}\""}.join(" ")}"
       end
 
       def fpm_command(build_dir, config)
-        %{
-          fpm -t deb -s dir  --verbose --force \
-          -C "#{build_dir}" \
-          -n "#{config.name}" \
-          --version "#{config.version}" \
-          --iteration "#{config.iteration}" \
-          --url "#{config.homepage}" \
-          --provides "#{config.name}" \
-          --deb-user "root" \
-          --deb-group "root" \
-          -a "#{config.architecture}" \
-          --description "#{config.description}" \
-          --maintainer "#{config.maintainer}" \
-          --template-scripts \
-          --before-install #{preinstall_file(config)} \
-          --after-install #{postinstall_file(config)} \
-          #{dependencies(config.dependencies).map{|d| "-d '#{d}'"}.join(" ")} \
-          .
-        }
-      end
-
-      def buildpacks(config)
-        custom_buildpack_uri = config.buildpack
-        if custom_buildpack_uri
-          uuid = Digest::SHA1.hexdigest(custom_buildpack_uri)
-          [Buildpack.new(custom_buildpack_uri, :custom, config.env)]
-        else
-          load_buildpack_list(config)
-        end
-      end
-
-      def default_buildpack_list
-        data_file(File.join("buildpacks", "#{osfamily}_#{codename}"))
-      end
-
-      def preinstall_file(config)
-        @preinstall_file ||= begin
-          source = File.join(data_dir, "hooks", "preinstall.sh")
-          file = Tempfile.new("preinstall")
-          file.write ERB.new(File.read(source)).result(config.sesame)
-          file.rewind
-          file
-        end
-
-        @preinstall_file.path
-      end
-
-      def postinstall_file(config)
-        @postinstall_file ||= begin
-          source = File.join(data_dir, "hooks", "postinstall.sh")
-          file = Tempfile.new("postinstall")
-          file.write ERB.new(File.read(source)).result(config.sesame)
-          file.rewind
-          file
-        end
-
-        @postinstall_file.path
-      end
-
-      def dependencies(other_dependencies = nil)
-        deps = YAML.load_file(File.join(data_dir, "dependencies.yml"))
-        (deps["default"] || []) | (deps[codename] || []) | (other_dependencies || [])
-      end
-
-      def build_dependencies(other_dependencies = nil)
-        deps = YAML.load_file(File.join(data_dir, "build_dependencies.yml"))
-        (deps["default"] || []) | (deps[codename] || []) | (other_dependencies || [])
-      end
-
-      def data_file(name)
-        File.new(File.join(data_dir, name))
-      end
-
-      def data_dir
-        File.join(Pkgr.data_dir, "distributions", "debian")
-      end
-
-      protected
-
-      def load_buildpack_list(config)
-        file = config.buildpack_list || default_buildpack_list
-        return [] if file.nil?
-
-        File.read(file).split("\n").map do |line|
-          url, *raw_env = line.split(",")
-          buildpack_env = (config.env || Env.new).merge(Env.new(raw_env))
-          Buildpack.new(url, :builtin, buildpack_env)
-        end
+        %{fpm #{fpm_args(build_dir, config).join(" ")} .}
+      end
+
+      def fpm_args(build_dir, config)
+        args = []
+        args << "-t deb"
+        args << "-s dir"
+        args << "--verbose"
+        args << "--force"
+        args << %{-C "#{build_dir}"}
+        args << %{-n "#{config.name}"}
+        args << %{--version "#{config.version}"}
+        args << %{--iteration "#{config.iteration}"}
+        args << %{--url "#{config.homepage}"}
+        args << %{--provides "#{config.name}"}
+        args << %{--deb-user "root"}
+        args << %{--deb-group "root"}
+        args << %{--license "#{config.license}"} unless config.license.nil?
+        args << %{-a "#{config.architecture}"}
+        args << %{--description "#{config.description}"}
+        args << %{--maintainer "#{config.maintainer}"}
+        args << %{--template-scripts}
+        args << %{--before-install #{preinstall_file(config)}}
+        args << %{--after-install #{postinstall_file(config)}}
+        dependencies(config.dependencies).each{|d| args << "-d '#{d}'"}
+        args
       end
     end
   end
 end
 
-%w{debian_squeeze debian_wheezy ubuntu_lucid ubuntu_precise}.each do |distro|
-  require "pkgr/distributions/#{distro}"
-end
+require 'pkgr/distributions/ubuntu'

data/lib/pkgr/distributions/redhat.rb

@@ -0,0 +1,51 @@
+require 'pkgr/buildpack'
+require 'pkgr/process'
+require 'pkgr/distributions/base'
+
+module Pkgr
+  module Distributions
+    # Contains the various components required to make a packaged app integrate well with a Debian system.
+    class Redhat < Base
+      # Only keep major adigits
+      def release
+        @release[/^[0-9]+/]
+      end
+
+      def runner
+        @runner ||= Runner.new("sysv", "lsb-3.1")
+      end
+
+      def package_test_command(package)
+        "rpm -qa '#{package}' | grep '#{package}' > /dev/null 2>&1"
+      end
+
+      def package_install_command(packages)
+        "sudo yum check-update && sudo yum install -y #{packages.map{|package| "\"#{package}\""}.join(" ")}"
+      end
+
+      def fpm_command(build_dir, config)
+        %{
+          fpm -t rpm -s dir --verbose --force \
+          -C "#{build_dir}" \
+          -n "#{config.name}" \
+          --version "#{config.version}" \
+          --iteration "#{config.iteration}" \
+          --url "#{config.homepage}" \
+          --provides "#{config.name}" \
+          --deb-user "root" \
+          --deb-group "root" \
+          -a "#{config.architecture}" \
+          --description "#{config.description}" \
+          --maintainer "#{config.maintainer}" \
+          --template-scripts \
+          --before-install #{preinstall_file(config)} \
+          --after-install #{postinstall_file(config)} \
+          #{dependencies(config.dependencies).map{|d| "-d '#{d}'"}.join(" ")} \
+          .
+        }
+      end
+    end
+  end
+end
+
+require 'pkgr/distributions/centos'

data/lib/pkgr/distributions/runner.rb

@@ -0,0 +1,39 @@
+module Pkgr
+  module Distributions
+    class Runner < Struct.new(:type, :version)
+      def sysv?
+        type == "sysv"
+      end
+
+      def upstart?
+        type == "upstart"
+      end
+
+      def templates(process, app_name)
+        send("templates_#{type}", process, app_name)
+      end
+
+      private
+      def templates_sysv(process, app_name)
+        [
+          Templates::FileTemplate.new("sysv/#{app_name}", data_file("master.erb")),
+          Templates::FileTemplate.new("sysv/#{app_name}-#{process.name}", data_file("process_master.erb")),
+          Templates::FileTemplate.new("sysv/#{app_name}-#{process.name}-PROCESS_NUM", data_file("process.erb")),
+        ]
+      end
+
+      def templates_upstart(process, app_name)
+        [
+          Templates::FileTemplate.new("upstart/#{app_name}", data_file("init.d.sh.erb")),
+          Templates::FileTemplate.new("upstart/#{app_name}.conf", data_file("master.conf.erb")),
+          Templates::FileTemplate.new("upstart/#{app_name}-#{process.name}.conf", data_file("process_master.conf.erb")),
+          Templates::FileTemplate.new("upstart/#{app_name}-#{process.name}-PROCESS_NUM.conf", data_file("process.conf.erb"))
+        ]
+      end
+
+      def data_file(name)
+        File.new(File.join(Pkgr.data_dir, "init", type, version, name))
+      end
+    end
+  end
+end

data/lib/pkgr/distributions/ubuntu.rb

@@ -0,0 +1,17 @@
+require "pkgr/distributions/debian"
+
+module Pkgr
+  module Distributions
+    # Contains the various components required to make a packaged app integrate well with a Ubuntu system.
+    class Ubuntu < Debian
+      # Keep everything
+      def release
+        @release
+      end
+
+      def runner
+        @runner ||= Runner.new("upstart", "1.5")
+      end
+    end
+  end
+end

data/lib/pkgr/version.rb

@@ -1,3 +1,3 @@
 module Pkgr
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pkgr
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-09 00:00:00.000000000 Z
+date: 2014-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -135,39 +135,17 @@ extra_rdoc_files:
 - LICENSE
 - README.md
 files:
-- lib/pkgr/app.rb
 - lib/pkgr/builder.rb
 - lib/pkgr/buildpack.rb
 - lib/pkgr/cli.rb
 - lib/pkgr/config.rb
-- lib/pkgr/data/bin/executable
-- lib/pkgr/data/config/pre_boot.rb
-- lib/pkgr/data/distributions/debian/build_dependencies.yml
-- lib/pkgr/data/distributions/debian/buildpacks/debian_squeeze
-- lib/pkgr/data/distributions/debian/buildpacks/debian_wheezy
-- lib/pkgr/data/distributions/debian/buildpacks/ubuntu_lucid
-- lib/pkgr/data/distributions/debian/buildpacks/ubuntu_precise
-- lib/pkgr/data/distributions/debian/cron.d
-- lib/pkgr/data/distributions/debian/default.erb
-- lib/pkgr/data/distributions/debian/dependencies.yml
-- lib/pkgr/data/distributions/debian/hooks/postinstall.sh
-- lib/pkgr/data/distributions/debian/hooks/preinstall.sh
-- lib/pkgr/data/distributions/debian/logrotate.erb
-- lib/pkgr/data/distributions/debian/runner.erb
-- lib/pkgr/data/distributions/debian/sysv/master.erb
-- lib/pkgr/data/distributions/debian/sysv/process.erb
-- lib/pkgr/data/distributions/debian/sysv/process_master.erb
-- lib/pkgr/data/distributions/debian/upstart/init.d.sh.erb
-- lib/pkgr/data/distributions/debian/upstart/master.conf.erb
-- lib/pkgr/data/distributions/debian/upstart/process.conf.erb
-- lib/pkgr/data/distributions/debian/upstart/process_master.conf.erb
-- lib/pkgr/data/pkgr.yml
 - lib/pkgr/dispatcher.rb
+- lib/pkgr/distributions/base.rb
+- lib/pkgr/distributions/centos.rb
 - lib/pkgr/distributions/debian.rb
-- lib/pkgr/distributions/debian_squeeze.rb
-- lib/pkgr/distributions/debian_wheezy.rb
-- lib/pkgr/distributions/ubuntu_lucid.rb
-- lib/pkgr/distributions/ubuntu_precise.rb
+- lib/pkgr/distributions/redhat.rb
+- lib/pkgr/distributions/runner.rb
+- lib/pkgr/distributions/ubuntu.rb
 - lib/pkgr/distributions.rb
 - lib/pkgr/env.rb
 - lib/pkgr/git.rb
@@ -176,6 +154,29 @@ files:
 - lib/pkgr/templates/file_template.rb
 - lib/pkgr/version.rb
 - lib/pkgr.rb
+- data/build_dependencies/centos.yml
+- data/build_dependencies/debian.yml
+- data/build_dependencies/ubuntu.yml
+- data/buildpacks/centos-6
+- data/buildpacks/debian-6
+- data/buildpacks/debian-7
+- data/buildpacks/ubuntu-10.04
+- data/buildpacks/ubuntu-12.04
+- data/cli/cli.sh.erb
+- data/dependencies/centos.yml
+- data/dependencies/debian.yml
+- data/dependencies/ubuntu.yml
+- data/environment/default.erb
+- data/hooks/postinstall.sh
+- data/hooks/preinstall.sh
+- data/init/sysv/lsb-3.1/master.erb
+- data/init/sysv/lsb-3.1/process.erb
+- data/init/sysv/lsb-3.1/process_master.erb
+- data/init/upstart/1.5/init.d.sh.erb
+- data/init/upstart/1.5/master.conf.erb
+- data/init/upstart/1.5/process.conf.erb
+- data/init/upstart/1.5/process_master.conf.erb
+- data/logrotate/logrotate.erb
 - LICENSE
 - README.md
 - bin/pkgr

data/lib/pkgr/app.rb

@@ -1,279 +0,0 @@
-require 'rake'
-require 'erb'
-require 'pkgr/version'
-require 'yaml'
-
-module Pkgr
-  class App
-    include RakeFileUtils
-    attr_reader :root
-    attr_reader :errors
-    attr_reader :config
-
-    # +root+: the root directory of the app.
-    # +config+ a Configuration object, hosting the parameters defined in `config/pkgr.yml`.
-    def initialize(root, config_path)
-      @root = root
-      load_config(config_path)
-      @errors = []
-    end
-
-    def load_config(path)
-      @config = YAML::load_file(path)
-      raise ArgumentError, "The given configuration file at '#{path}' is not a well-formed YAML file. Please fix it or remove it and run 'rake pkgr:setup'" unless @config.kind_of?(Hash)
-      @config['_path'] = path
-      normalize_name!
-    end
-    
-    def write_config
-      File.open(@config['_path'] || raise("Don't know where to save myself!"), "w+") {|f|
-        YAML.dump(@config.reject{|k,v| k == '_path'}, f)
-      }
-    end
-
-    # Returns true if the app is correctly configured. Else otherwise.
-    def valid?
-      @errors.clear
-      @errors.push("is not a valid git repository") unless File.exist?(File.join(@root, ".git", "HEAD"))
-      @errors.push("must have a name") unless @config.fetch('name')
-      @errors.push("must have a valid name ([a-zA-Z0-9_-])") unless @config.fetch('name').scan(/[^a-z0-9\_\-]/i)
-      @errors.push("must have a version") unless @config.fetch('version')
-      @errors.push("must have a valid target architecture") unless @config.fetch('architecture')
-      @errors.empty?
-    end
-
-    def generate_required_files
-      setup_debian
-      setup_binary
-    end
-
-    def git_ref
-      @config.fetch('git_ref') { 'HEAD' }
-    end
-
-    def prefix
-      @config.fetch('prefix') { "/opt/local" }
-    end
-
-    def author_name
-      @author_name ||= `git config --get user.name`.chomp
-    end
-
-    def author_email
-      @author_email ||= `git config --get user.email`.chomp
-    end
-
-    def name
-      @config['name']
-    end
-
-    def description
-      @config['description'] || ""
-    end
-
-    def debian_build_dependencies(installable_only = false)
-      deps = @config['debian_build_dependencies'] || []
-      if installable_only
-        deps = deps.reject{|d| d =~ /[\$\{\}]/}.map{|d| d.split(/\s/)[0]}
-      end
-      deps
-    end
-
-    def debian_runtime_dependencies(installable_only = false)
-      deps = @config['debian_runtime_dependencies'] || []
-      if installable_only
-        deps = deps.reject{|d| d =~ /[\$\{\}]/}.map{|d| d.split(/\s/)[0]}
-      end
-      deps
-    end
-
-    def architecture
-      @config['architecture'] || "all"
-    end
-
-    def homepage
-      @config['homepage'] || ""
-    end
-
-    def config_files
-      @config['config_files'] || []
-    end
-
-    def version
-      @config['version']
-    end
-    
-    def user
-      @config.fetch('user') { name }
-    end
-    
-    def group
-      @config.fetch('group') { name }
-    end
-
-    # prefix without the leading slash.
-    def pkg_prefix
-      prefix[1..-1]
-    end
-
-    def setup_debian
-      target = File.join(root, Pkgr::DEBIAN_DIR)
-      Pkgr.mkdir(target)
-
-      Dir[File.expand_path("../data/debian/*", __FILE__)].each do |file|
-        case File.extname(file)
-        when ".erb"
-          file_target = File.join(target, File.basename(file, ".erb"))
-          File.open(file_target, "w+") do |f|
-            f << ERB.new(File.read(file)).result(binding)
-          end
-        else
-          file_target = File.join(target, File.basename(file))
-          if File.exist?(file_target)
-            puts "File #{file_target} already exists. Skipped."
-          else
-            FileUtils.cp(file, file_target, :verbose => true)
-          end
-        end
-      end
-
-      puts "Correctly set up debian files."
-    end
-
-    # Creates an executable file for easy launch of the server/console/rake tasks once it is installed.
-    # E.g. /usr/bin/my-app console, /usr/bin/my-app server start -p 8080
-    def setup_binary
-      target = File.join(root, "bin", name)
-      Pkgr.mkdir(File.dirname(target))
-      FileUtils.cp(File.expand_path("../data/bin/executable", __FILE__), target, :verbose => true)
-      FileUtils.chmod 0755, target, :verbose => true
-      puts "Correctly set up executable file. Try running './bin/#{name} console'."
-    end
-
-    # FIXME: this is ugly
-    def bump!(version_index = :patch, new_version = nil)
-      unless version_index == :custom
-        indices = [:major, :minor, :patch]
-        index = indices.index(version_index) || raise(ArgumentError, "The given version index is not valid (#{version_index})")
-        fragments = version.split(".")
-        fragments[index] = fragments[index].to_i+1
-        ((index+1)..2).each{|i|
-          fragments[i] = 0
-        }
-        new_version = fragments.join(".")
-      else
-        raise ArgumentError, "new_version must not be nil when bumping with a :custom version" if new_version.nil?
-      end
-
-      changelog = File.read(debian_file("changelog"))
-      dist = (changelog.scan(/#{name} \(#{new_version}-(\d+)\)/).flatten[0].to_i)
-      dist += 1 if new_version == version
-      dist = 1 if dist == 0
-
-      last_commit = changelog.scan(/\s+\* ([a-z0-9]{7}) /).flatten[0]
-
-      cmd = "git log --oneline"
-      cmd << " #{last_commit}..#{git_ref}" unless last_commit.nil?
-      result = %x{#{cmd}}
-      ok = $?.exitstatus == 0
-      if !ok
-        raise "Command failed. Aborting."
-      else
-        content_changelog = [
-          "#{name} (#{new_version}-#{dist}) unstable; urgency=low",
-          "",
-          result.split("\n").reject{|l| l =~ / v#{version}/}.map{|l| "  * #{l}"}.join("\n"),
-          "",
-          " -- #{author_name} <#{author_email}>  #{Time.now.strftime("%a, %d %b %Y %H:%M:%S %z")}",
-          "",
-          changelog
-        ].join("\n")
-
-        File.open(debian_file("changelog"), "w+") do |f|
-          f << content_changelog
-        end
-
-        @config['version'] = new_version
-        write_config
-
-        puts "Committing changelog and version file..."
-        files_to_commit = [debian_file('changelog'), @config['_path']]
-        sh "git add #{files_to_commit.join(" ")} && git commit -m '[pkgr] v#{new_version}-#{dist}' #{files_to_commit.join(" ")}"
-      end
-    end
-
-    def build_debian_package(host)
-      puts "Building debian package on '#{host}'..."
-      Dir.chdir(root) do
-        Pkgr.mkdir("pkg")
-        archive = "#{name}-#{version}"
-        sh "scp #{File.expand_path("../data/config/pre_boot.rb", __FILE__)} #{host}:/tmp/"
-        cmd = %Q{
-          git archive #{git_ref} --prefix=#{archive}/ | ssh #{host} 'cat - > /tmp/#{archive}.tar &&
-            set -x && rm -rf /tmp/#{archive} &&
-            cd /tmp && tar xf #{archive}.tar && cd #{archive} &&
-            cat config/boot.rb >> /tmp/pre_boot.rb && cp -f /tmp/pre_boot.rb config/boot.rb &&
-            #{debian_steps.join(" &&\n")}'
-        }
-        sh cmd
-        # Fetch all package files, and put it in the `pkg` directory
-        sh "scp #{host}:/tmp/#{name}_#{version}* pkg/"
-      end
-    end
-
-    def debian_steps
-      target_vendor = "vendor/bundle/ruby/1.9.1"
-      [
-        # "sudo apt-get install #{debian_runtime_dependencies(true).join(" ")} -y",
-        "sudo apt-get install #{debian_build_dependencies(true).join(" ")} -y",
-        # Vendor bundler
-        "gem1.9.1 install bundler --no-ri --no-rdoc --version #{bundler_version} -i #{target_vendor}",
-        "GEM_HOME='#{target_vendor}' #{target_vendor}/bin/bundle install --deployment --without test development",
-        "rm -rf #{target_vendor}/{cache,doc}",
-        "dpkg-buildpackage -us -uc -d"
-      ]
-    end
-    
-    def release_debian_package(host, apt_directory = nil)
-      apt_directory ||= "/var/www/#{name}"
-      latest = Dir[File.join(root, "pkg", "*.deb")].find{|file| file =~ /#{version}/}
-      raise "No .deb available in pkg/" if latest.nil?
-      latest_name = File.basename(latest)
-      sh "scp #{latest} #{host}:/tmp/"
-      sh "ssh #{host} 'sudo mkdir -p #{apt_directory} && sudo chown $USER #{apt_directory} && mv /tmp/#{latest_name} #{apt_directory} && cd #{apt_directory} && ( which dpkg-scanpackages || sudo apt-get update && sudo apt-get install dpkg-dev -y ) && dpkg-scanpackages . | gzip -f9 > Packages.gz'"
-      puts "****"
-      puts "Now you just need to serve the '#{apt_directory}' directory over HTTP, and add a new source to your APT configuration on the production server:"
-      puts "$ cat /etc/apt/sources.list.d/#{name}.list"
-      puts "deb http://apt-server.ltd/#{name} /"
-      puts
-      puts "And then:"
-      puts "$ sudo apt-get update && sudo apt-get install #{name}"
-      puts "****"
-    end
-
-    private
-    def bundler_version
-      @config.fetch('bundler_version') { '1.3.5' }
-    end
-
-    def debian_file(filename)
-      file = File.join(root, Pkgr::DEBIAN_DIR, filename)
-      raise "The debian/changelog file does not exist. Please generate it first." unless File.exist?(file)
-      file
-    end
-
-    def normalize_name!
-      # debian packages can not contain capitalized letters nor underscores
-      if (raw_name = @config.fetch('name', '')) =~ /[A-Z_-]/
-        normalized_name = raw_name.
-                            gsub(/[A-Z]/) { |m| "_#{m.downcase}" }.  # underscore each word
-                            gsub(/[_-]+/, '-').                      # normalize underscores/dashes
-                            sub(/^-/, '')                            # strip leading dash
-        puts "Normalized application name to %s (original: %s)." % [
-          normalized_name.inspect, raw_name.inspect
-        ] unless normalized_name == raw_name
-        @config['name'] = normalized_name
-      end
-    end
-  end
-end