pkgr 0.2.0 → 0.3.0

data/README.md

@@ -2,7 +2,16 @@
 
 Plug this [Railtie](http://api.rubyonrails.org/classes/Rails/Railtie.html)
 into your Rails 3 app (ruby1.9 only), and you'll be ready to package your
-Rails app as a DEB package. RPM support could be added in the short future.
+Rails app as a DEB package. RPM support could/will be added in the short
+future.
+
+This gem originates from hours spent trying to figure out how to package a
+Ruby app for CentOS, and then Debian. It's definitely not trivial, because
+there are so many pieces to put together before getting something working.
+Hopefully this will save time for everyone :)
+
+Fair warning: there are probably a few things that could be done better, or in
+a more standard way. Feel free to open an issue and/or a pull-request.
 
 ## Why?
 
@@ -59,6 +68,8 @@ The default target installation directory for the other app files will be
   [`thin`](http://code.macournoyer.com/thin/) web server. Don't forget to add
   `thin` to your Gemfile!
 
+* Your Rails application must have a `config.ru` file.
+
 * Your application must be checked into a **Git** repository. Your name and
   email is taken from the git configuration, and the changelog is populated
   based on the git log between two versions.
@@ -252,7 +263,7 @@ Now you can send a first request:
 
 Obviously this app does nothing, so you'll get a 404. So go back to building your app, and then just type `rake pkgr:bump:patch` and `HOST=debian-build-machine rake pkgr:build:deb` to generate a new package !
 
-## Release it (debian)
+### Release it (debian)
 
 As of 0.2.0, you can now release the latest package on a server, and add it to
 your list of APT sources for easy installation. In the following we'll assume
@@ -368,6 +379,41 @@ Once you're ready to package your app, just run the following commands:
   app. Next step is probably to upload it to a local apt repository, and then
   a simple `apt-get install my-app` will install everything. Enjoy!
 
+## CLI usage
+
+Starting from version 0.3.0, pkgr now comes with an executable, which allows
+to package any app stored in a git repository with one command.
+
+For instance, here is how you would package the Redmine app:
+
+    pkgr --uri https://github.com/edavis10/redmine --ref master --bump 1.4.1 \
+      -c https://raw.github.com/crohr/pkgr/master/examples/redmine/configuration.yml \
+      -c https://raw.github.com/crohr/pkgr/master/examples/redmine/database.yml \
+      -c https://raw.github.com/crohr/pkgr/master/examples/redmine/pkgr.yml \
+      --host debian-build
+
+You .deb package will be available in `redmine/pkg/`. In this example, the given `pkgr.yml` configuration file automatically adds a dependency on `mysql-server`, which means that when you install the generated redmine package, it will be ready to be accessed on `0.0.0.0:8000`.
+
+Note that for simple projects, you may not need to specify any configuration
+file on the command line. See `pkgr -h` for the list of options available:
+
+    $ pkgr -h
+    * Description
+      pkgr 0.2.0 - Package Rails apps effortlessly.
+    * Usage
+      pkgr --uri GIT_REPOSITORY --config database.yml:http://path/to/database.yml --config ...
+
+    * Common options
+            --uri=                       Sets the Git repository URI (FILE, HTTP, SSH, GIT, etc.) [required]
+        -c, --config=                    Download a configuration file into the config/ folder of the app (HTTP or FILE URIs)
+        -b, --bump=                      Sets the app version [required]
+        -n, --name=                      Sets the app name [optional]
+            --ref=                       Sets the git reference to checkout [default=master]
+            --host=                      Sets the build machine hostname. If none, the process will stop just before building the package.
+
+    * Other
+        -h, --help                       Show this message
+            --version                    Show version
 
 ## Todo
 
@@ -378,6 +424,8 @@ Once you're ready to package your app, just run the following commands:
 
 * Better debian initd script.
 
+* Populate dependencies based on gems declared in the Gemfile.
+
 * Some tests.
 
 ## Authors

data/lib/pkgr/app.rb

@@ -1,5 +1,7 @@
 require 'rake'
 require 'erb'
+require 'pkgr/version'
+require 'yaml'
 
 module Pkgr
   class App
@@ -148,18 +150,24 @@ module Pkgr
     end
 
     # FIXME: this is ugly
-    def bump!(version_index = :patch)
-      indices = [:major, :minor, :patch]
-      index = indices.index(version_index) || raise(ArgumentError, "The given version index is not valid (#{version_index})")
-      version = @config.fetch('version') { '0.0.0' }
-      fragments = version.split(".")
-      fragments[index] = fragments[index].to_i+1
-      ((index+1)..2).each{|i|
-        fragments[i] = 0
-      }
-      new_version = fragments.join(".")
+    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]
 
@@ -171,7 +179,7 @@ module Pkgr
         raise "Command failed. Aborting."
       else
         content_changelog = [
-          "#{name} (#{new_version}-1) unstable; urgency=low",
+          "#{name} (#{new_version}-#{dist}) unstable; urgency=low",
           "",
           result.split("\n").reject{|l| l =~ / v#{version}/}.map{|l| "  * #{l}"}.join("\n"),
           "",
@@ -189,7 +197,7 @@ module Pkgr
 
         puts "Committing changelog and version file..."
         files_to_commit = [debian_file('changelog'), @config['_path']]
-        sh "git add #{files_to_commit.join(" ")} && git commit -m 'v#{new_version}' #{files_to_commit.join(" ")}"
+        sh "git add #{files_to_commit.join(" ")} && git commit -m '[pkgr] v#{new_version}-#{dist}' #{files_to_commit.join(" ")}"
       end
     end
 
@@ -215,7 +223,7 @@ module Pkgr
     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_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}",
@@ -248,8 +256,8 @@ module Pkgr
     end
 
     def debian_file(filename)
-      file = File.join(Pkgr::DEBIAN_DIR, filename)
-      return nil unless File.exist?(file)
+      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
   end

data/lib/pkgr/cli.rb

@@ -0,0 +1,164 @@
+require 'open-uri'
+require 'fileutils'
+require 'pkgr'
+require 'uri'
+
+module Pkgr
+  class CLI
+    include Rake::DSL
+
+    class Error < StandardError; end
+
+    attr_reader :errors
+    attr_reader :uri
+    attr_reader :dir
+    attr_reader :config_files
+    attr_reader :version
+    attr_reader :name
+    attr_reader :app
+    attr_reader :host
+    attr_reader :ref
+
+    def initialize(opts = {})
+      @errors = []
+      @uri, @config_files, @version, @name, @host, @ref = opts.values_at(
+        :uri, :config_files, :version, :name, :host, :ref
+      )
+      @app = nil
+    end
+
+    def run
+      raise Error, "Can't run pkgr: #{errors.join(", ")}" unless valid?
+      clone_repository
+      Dir.chdir(dir) do
+        checkout
+        copy_remote_config_files
+        copy_example_config_files
+        setup
+        bundle
+        configure_app
+        generate
+        bump
+        build
+      end
+    end
+
+    def valid?
+      @errors.clear
+      @errors.push("You must pass a repository URI through --uri") if uri.nil?
+      @errors.push("You must pass a version number through --bump") if version.nil?
+      @errors.empty?
+    end
+
+    def build
+      if host.nil?
+        puts "Can't build the package. You must pass the --host option for this."
+      else
+        @app.build_debian_package(host)
+      end
+    end
+
+    def bump
+      @app.bump!(:custom, version)
+    end
+
+    def bundle
+      sh "bundle install"
+      sh "git add -f Gemfile.lock"
+      sh "if git status --porcelain | grep Gemfile.lock; then git commit -m '[pkgr] Update Gemfile.lock.'; fi"
+    end
+
+    def checkout
+      sh "if git branch | grep '#{pkgr_branch}'; then git checkout #{pkgr_branch}; else git checkout -b #{pkgr_branch} #{ref}; fi"
+    end
+
+    def clone_repository
+      parsed_uri = URI.parse(uri)
+      case parsed_uri.scheme
+      when nil, "file"
+        @dir = parsed_uri.path
+      else
+        @dir = File.basename(uri, ".git")
+        sh "git clone #{uri}"
+      end
+      @dir = File.expand_path @dir
+    end
+
+    def configure_app
+      @app = Pkgr::App.new(dir, "config/pkgr.yml")
+      @app.config['git_ref'] = pkgr_branch
+      @app.config['config_files'].push(*Dir["config/*.yml"].map{|f| File.basename(f)}).uniq!
+      if name.nil?
+        @app.config['name'] = File.basename(dir) if @app.name.nil?
+      else
+        @app.config['name'] = name
+      end
+      raise Error, "The app is not correctly configured: #{@app.errors.join(", ")}" unless @app.valid?
+      @app.write_config
+    end
+
+    # Download the given config files
+    def copy_remote_config_files
+      (config_files || []).each do |file|
+        filename, file_uri = file.split("::")
+        if file_uri.nil?
+          file_uri = filename
+          filename = File.basename(file_uri)
+        end
+
+        file_uri = File.expand_path(file_uri) if URI.parse(file_uri).scheme.nil?
+        target = "config/#{filename}"
+        puts "Copying #{file_uri} into #{target}..."
+        File.open(target, "w+") { |f| f << open(file_uri).read }
+      end
+    end
+
+    def copy_example_config_files
+      [".example", ".dist"].each do |pattern|
+        Dir["config/*.yml#{pattern}"].each do |file|
+          target = File.basename(file, pattern)
+          unless File.exist?("config/#{target}")
+            FileUtils.cp(file, "config/#{target}")
+          end
+        end
+      end
+    end
+
+    def generate
+      @app.generate_required_files
+      sh "git add debian/"
+      sh "if git status --porcelain | grep debian/; then git commit -m '[pkgr] Add debian files.'; fi"
+      sh "git add bin/"
+      sh "if git status --porcelain | grep bin/; then git commit -m '[pkgr] Add executable file.'; fi"
+    end
+
+    def pkgr_branch
+      "pkgr-#{ref}"
+    end
+
+    def setup
+      Pkgr.setup(dir)
+
+      gemfile = File.read("Gemfile")
+      unless gemfile =~ /$gem 'pkgr'/
+        File.open("Gemfile", "a") do |f|
+          f.puts
+          f.puts "gem 'pkgr'"
+        end
+      end
+
+      unless gemfile =~ /$gem 'thin'/
+        File.open("Gemfile", "a") do |f|
+          f.puts
+          f.puts "gem 'pkgr'"
+        end
+      end
+
+      sh "git add Gemfile"
+      sh" if git status --porcelain | grep Gemfile; then git commit -m '[pkgr] Update Gemfile.'; fi"
+      sh "git add -f config/*.yml"
+      sh" if git status --porcelain | grep config/*.yml; then git commit -m '[pkgr] Update configuration files.'; fi"
+    end
+  end
+
+end

data/lib/pkgr/pkgr.rake

@@ -23,10 +23,10 @@ namespace :pkgr do
     end
 
     namespace :bump do
-      %w{patch minor major}.each do |version|
-        desc "Increments the #{version} version by one"
+      %w{patch minor major custom}.each do |version|
+        desc "Increments the #{version} version. If using :custom, then you can pass a specific VERSION environment variable."
         task version.to_sym do
-          APP.bump!(version.to_sym)
+          APP.bump!(version.to_sym, ENV.fetch('VERSION'))
         end
       end
     end

data/lib/pkgr/version.rb

@@ -1,3 +1,3 @@
 module Pkgr
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pkgr
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -16,17 +16,17 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0.8'
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -53,6 +53,7 @@ extra_rdoc_files:
 - README.md
 files:
 - lib/pkgr/app.rb
+- lib/pkgr/cli.rb
 - lib/pkgr/data/bin/executable
 - lib/pkgr/data/config/pre_boot.rb
 - lib/pkgr/data/debian/changelog