dpkg-tools 0.3.3

data/lib/dpkg-tools/package/rake.rb

@@ -0,0 +1,90 @@
+require 'rake'
+require 'rake/tasklib'
+
+module DpkgTools
+  module Package
+    class BuildTasks < Rake::TaskLib
+      def initialize
+        yield(self) if block_given?
+        
+        check_setup
+        define_base_tasks
+        define_tasks
+      end
+      
+      # Override this to check that people did the right thing in the block on init
+      def check_setup
+        
+      end
+      
+      # Override this to define subclass-specific building functionality
+      def define_tasks
+        
+      end
+      
+      # Override this method to properly return an instantiated Builder object
+      # You can use this yourself for the build steps, and it's used by :clean
+      # to invoke remove_build_products on your builder
+      def create_builder
+        
+      end
+      
+      # Override this method to properly return an instantiated Setup object.
+      # This is used by the setup helpers, like dpkg:setup:diff and dpkg:setup:regen
+      def create_setup
+        
+      end
+      
+      # Defines the base rake tasks and ensures that you only need to define the create_builder function and 
+      # build-arch, build-indep, binary-arch and binary-indep tasks as you need to
+      def define_base_tasks
+        # build
+        desc "Perform architecture-dependent build steps"
+        task "build-arch"
+        
+        desc "Perform architecture-independent build steps"
+        task "build-indep"
+        
+        desc "Perform all needed build steps"
+        task :build do
+          package_type = create_builder.architecture_independent? ? 'indep' : 'arch'
+          Rake::Task["build-#{package_type}"].invoke
+        end
+        
+        desc "Perform architecture dependent post-build install steps"
+        task "binary-arch"
+        
+        desc "Perform architecture independent post-build install steps"
+        task "binary-indep"
+        
+        desc "Perform all needed build steps"
+        task :binary do
+          package_type = create_builder.architecture_independent? ? 'indep' : 'arch'
+          Rake::Task["binary-#{package_type}"].invoke
+        end
+        
+        desc "Remove all build and install generated files"
+        task :clean do
+          create_builder.remove_build_products
+        end
+        
+        # dpkg-tools rake tasks
+        namespace :dpkg do
+          namespace :setup do
+            desc <<-EOD
+              Reset any files generated during initial setup to their pristine state.
+              Any of those files modified by you will be moved to <file_name>.bak first.
+              Identical files won't be touched.
+            EOD
+            task :reset do
+              setup = create_setup
+              setup.reset_maintainer_script_templates
+              setup.reset_control_files
+              setup.reset_package_resource_files
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/setup.rb

@@ -0,0 +1,145 @@
+module DpkgTools
+  module Package
+    class Setup
+      class << self
+        include DpkgTools::Package::FSMethods
+        
+        # Should be overridden by subclasses to check whether the 
+        # directory at base_path needs to be bootstrapped in order
+        # for a DpkgTools::Package::Data subclass to be instantiated
+        def needs_bootstrapping?(base_path)
+          bootstrap_files.each do |filename|
+            return true unless File.file?(bootstrap_file_path(base_path, filename))
+          end
+          false
+        end
+        
+        # Should be overridden by subclasses to return the files
+        # that are expected to be present under base_path to
+        # support a DpkgTools::Package::Data subclass being instantiated
+        def bootstrap_files
+          ['deb.yml']
+        end
+        
+        # Shoule be overridden by subclasses and return the dir under 
+        # base_path where files required by the bootstrapping process
+        # should live (can be base_path)
+        def bootstrap_file_path(base_path, filename)
+          "#{base_path}/#{filename}"
+        end
+        
+        # Should be overridden by subclasses to bootstrap the 
+        # directory at base_path, to put it in a state that would 
+        # support a DpkgTools::Package::Data subclass being instantiated
+        def bootstrap(base_path)
+          bootstrap_files.each do |filename|
+            bootstrap_file(base_path, filename)
+          end
+        end
+        
+        def file_exists?(file_path)
+          File.file?(file_path)
+        end
+        
+        def move_original_aside(file_path)
+          FileUtils.mv(file_path, file_path + '.bak') 
+        end
+        
+        def copy_bootstrap_file_across(src_file, target_file)
+          FileUtils.cp(src_file, target_file)
+        end
+        
+        def bootstrap_file(base_path, filename, options = {})
+          target_file = bootstrap_file_path(base_path, filename)
+          src_file = File.join(data_class.resources_path, filename)
+          file_exists = File.file?(target_file)
+          if file_exists && options[:backup]
+            move_original_aside(target_file)
+            file_exists = false
+          end
+          copy_bootstrap_file_across(src_file, target_file) unless file_exists
+        end
+        
+        # Should be overridden by subclasses to return the specific 
+        # DpkgTools::Package::Data subclass they want to use
+        def data_class
+          DpkgTools::Package::Data
+        end
+        
+        def from_path(base_path)
+          self.bootstrap(base_path) if self.needs_bootstrapping?(base_path)
+          self.new(self.data_class.new(base_path), base_path)
+        end
+      end
+          
+      def initialize(data, options = {})
+        @data = data
+        @config = DpkgTools::Package::Config.new(data.name, data.version, config_options)
+      end
+      
+      def config_options
+        {}
+      end
+      
+      def control_file_classes
+        DpkgTools::Package::ControlFiles.classes
+      end
+      
+      def write_control_files
+        control_file_classes.each do |klass|
+          klass.new(@data, @config).write
+        end
+      end
+      
+      def maintainer_script_template_names
+        ['postinst.erb', 'postrm.erb', 'preinst.erb', 'prerm.erb']
+      end
+      
+      def copy_maintainer_script_templates
+        maintainer_script_template_names.each do |filename|
+          resource = File.join(@data.resources_path, filename)
+          FileUtils.cp(resource, File.join(@config.debian_path, filename)) if File.file?(resource)
+        end
+      end
+      
+      def prepare_package
+      end
+      
+      def create_structure
+        DpkgTools::Package.check_package_dir(@config)
+        
+        prepare_package
+        write_control_files
+        copy_maintainer_script_templates
+      end
+      
+      def reset_control_files
+        control_file_classes.each do |klass|
+          control_file = klass.new(@data, @config)
+          if control_file.needs_reset?
+            FileUtils.mv(control_file.file_path, control_file.file_path + '.bak') if File.exist?(control_file.file_path)
+            control_file.write 
+          end
+        end
+      end
+      
+      def reset_maintainer_script_templates
+        maintainer_script_template_names.each do |filename|
+          source = File.join(@data.resources_path, filename)
+          target = File.join(@config.debian_path, filename)
+          if File.file?(source) && !FileUtils.identical?(source, target)
+            FileUtils.mv(target, target + '.bak')
+            FileUtils.cp(source, target) 
+          end
+        end
+      end
+      
+      # This should be overridden to allow features such as the dpkg:setup:regen rake task to 
+      # reset the state of package-type specific files (i.e. files that get copied across by
+      # prepare_package).
+      def reset_package_resource_files
+        
+      end
+    end
+  end
+end

data/lib/dpkg-tools/version.rb

@@ -0,0 +1,23 @@
+module DpkgTools #:nodoc:
+  module VERSION
+    unless defined? MAJOR
+      MAJOR  = 0
+      MINOR  = 3
+      TINY   = 3
+      RELEASE_CANDIDATE = nil
+      
+      BUILD_TIME = "2008-06-06T12:49:00+01:00"
+      
+      STRING = [MAJOR, MINOR, TINY].join('.')
+      TAG = "REL_#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('_')}".upcase.gsub(/\.|-/, '_')
+      FULL_VERSION = "#{[MAJOR, MINOR, TINY, RELEASE_CANDIDATE].compact.join('.')} (build #{BUILD_TIME})"
+      
+    end
+  end
+  
+  NAME = "dpkg-tools"
+  GEM_NAME = NAME
+  URL  = "http://dpkg-tools.rubyforge.org/"
+  
+  DESCRIPTION = "#{NAME}-#{VERSION::FULL_VERSION} - Painless OS package building\n#{URL}"
+end

data/spec/dpkg-tools/command_line_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require File.dirname(__FILE__) + '/../../lib/dpkg-tools/command_line'
+
+describe DpkgTools::CommandLine, ".run" do
+  it "should test something..." do
+    
+  end
+end

data/spec/dpkg-tools/package/builder_spec.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DpkgTools::Package::Builder, "instances" do
+  before(:each) do
+    DpkgTools::Package::Config.stubs(:root_path).returns('/a/path/to/')
+    @config = DpkgTools::Package::Config.new('rails-app', '1.0.8', {})
+    DpkgTools::Package::Config.expects(:new).with('rails-app', '1.0.8', {}).returns(@config)
+    
+    @stub_data = stub("stub DpkgTools::Package::Rails::Data", :name => 'rails-app', :version => '1.0.8',
+                 :full_name => 'rails-app-1.0.8', :debian_revision => "1", :debian_arch => "all",
+                 :mongrel_ports => ['8000', '8001', '8002'])
+    stub_data_binding = @stub_data.send(:binding)
+    @stub_data.stubs(:binding).returns(stub_data_binding)
+    
+    @builder = DpkgTools::Package::Builder.new(@stub_data)
+  end
+  
+  it "should provide access to @data" do
+    @builder.data.should == @stub_data
+  end
+  
+  it "should be able to provide access to its DpkgTools::Package::Config entry" do
+    @builder.config.should == @config
+  end
+  
+  it "should be able to create an intermediate tmp build directory" do
+    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app-1.0.8/dpkg-tools-tmp')
+    
+    @builder.create_intermediate_buildroot
+  end
+  
+  it "should be able to create the debian/tmp buildroot dir" do
+    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app-1.0.8/debian/tmp')
+    
+    @builder.create_buildroot
+  end
+  
+  it "should be able to create the buildroot/DEBIAN dir" do
+    Dir.expects(:mkdir).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN')
+    File.expects(:directory?).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN').returns(false)
+    
+    @builder.create_DEBIAN_dir
+  end
+  
+  it "should be able to create the DEBIAN/* package metadata files" do
+    @builder.expects(:sh).with('dpkg-gencontrol')
+    
+    @builder.create_control_files
+  end
+  
+  it "should be able to generate the path to the built .deb package" do
+    @builder.built_deb_path.should == "/a/path/to/rails-app_1.0.8-1_all.deb"
+  end
+  
+  it "should be able to create the .deb package" do
+    @builder.stubs(:built_deb_path).returns('/a/path/to/rails-app_1.0.8-1_all.deb')
+    
+    @builder.expects(:sh).with('dpkg-deb --build "/a/path/to/rails-app-1.0.8/debian/tmp" "/a/path/to/rails-app_1.0.8-1_all.deb"')
+    @builder.create_deb
+  end
+  
+  it "should be able to report which maintainer scripts need to be generated" do
+    Dir.expects(:entries).with('/a/path/to/rails-app-1.0.8/debian').returns(['.', '..', 'postinst.erb', 'preinst.erb', 'postinst'])
+    @builder.maintainer_script_targets.should == ['postinst', 'preinst']
+  end
+  
+  it "should be able to render an erb template using data as the binding" do
+    @builder.render_template("<%= mongrel_ports.inspect %>").
+      should == '["8000", "8001", "8002"]'
+  end
+  
+  it "should be able to generate a maintainer script" do
+    File.expects(:read).with('/a/path/to/rails-app-1.0.8/debian/postinst.erb').returns('template')
+    mock_file = mock('File')
+    mock_file.expects(:write).with('rendered template')
+    File.expects(:open).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN/postinst', 'w').yields(mock_file)
+    File.expects(:chmod).with(0755, '/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN/postinst')
+    
+    @builder.expects(:render_template).with('template').returns('rendered template')
+    
+    @builder.generate_maintainer_script('postinst')
+  end
+  
+  it "should be able to generate all the maintainer scripts" do
+    @builder.expects(:maintainer_script_targets).returns(['postinst', 'preinst'])
+    @builder.expects(:generate_maintainer_script).with('postinst')
+    @builder.expects(:generate_maintainer_script).with('preinst')
+    
+    @builder.generate_maintainer_scripts
+  end 
+  
+  it "should be able to report that it's an architecture independent package when it is" do
+    @stub_data.stubs(:architecture_independent?).returns(true)
+    @builder.architecture_independent?.should be_true
+  end
+  
+  it "should be able to report that it's an architecture dependent package when it is" do
+    @stub_data.stubs(:architecture_independent?).returns(false)
+    @builder.architecture_independent?.should be_false
+  end
+end
+
+describe DpkgTools::Package::Builder, "#build_package" do
+  it "should perform the equivalent steps to configure/make" do
+    stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
+                 :full_name => 'rails-app-1.0.8')
+    builder = DpkgTools::Package::Builder.new(stub_data)
+    builder.expects(:create_buildroot)
+    builder.expects(:create_install_dirs)
+    builder.expects(:build_package_files)
+    
+    builder.build_package
+  end
+end
+
+describe DpkgTools::Package::Builder, "#binary_package" do
+  it "should perform the steps needed to make a .deb and .dsc" do
+    stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
+                 :full_name => 'rails-app-1.0.8')
+    builder = DpkgTools::Package::Builder.new(stub_data)
+    builder.expects(:create_buildroot)
+    builder.expects(:create_install_dirs)
+    builder.expects(:install_package_files)
+    builder.expects(:generate_maintainer_scripts)
+    builder.expects(:create_DEBIAN_dir)
+    builder.expects(:create_control_files)
+    builder.expects(:create_deb)
+    
+    builder.binary_package
+  end
+end
+
+describe DpkgTools::Package::Builder, "#remove_build_products" do
+  before(:each) do
+    DpkgTools::Package::Config.stubs(:root_path).returns("a/path/to")
+    
+    @stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
+                 :full_name => 'rails-app-1.0.8')
+    
+    @builder = DpkgTools::Package::Builder.new(@stub_data)
+  end
+  
+  it "should only try to remove build products when debian/tmp exists" do
+    File.expects(:exists?).with('a/path/to/rails-app-1.0.8/debian/tmp').returns(false)
+    File.expects(:exists?).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp').returns(false)
+    FileUtils.expects(:remove_dir).never
+    
+    @builder.remove_build_products
+  end
+  
+  it "should remove all the build products" do
+    File.expects(:exists?).with('a/path/to/rails-app-1.0.8/debian/tmp').returns(true)
+    FileUtils.expects(:remove_dir).with('a/path/to/rails-app-1.0.8/debian/tmp')
+    File.expects(:exists?).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp').returns(true)
+    FileUtils.expects(:remove_dir).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp')
+    
+    @builder.remove_build_products
+  end
+end

data/spec/dpkg-tools/package/config_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DpkgTools::Package::Config do
+  it "should be able to set and return the root dir in which all package making is happening" do
+    DpkgTools::Package::Config.root_path = "a/path"
+    DpkgTools::Package::Config.root_path.should == "a/path"
+  end
+end
+
+describe DpkgTools::Package::Config, ".new" do
+  it "should require a name, version pair of arguments" do
+    DpkgTools::Package::Config.new('gem_name', '1.0.8').
+      should be_an_instance_of(DpkgTools::Package::Config)
+  end
+  
+  it "should throw an error if the argument is not present" do
+    lambda { DpkgTools::Package::Config.new() }.should raise_error
+  end
+  
+  it "should allow base_path to be specified as well as name and version" do
+    DpkgTools::Package::Config.new('gem_name', '1.0.8', {:base_path => '/a/path/to'}).
+      should be_an_instance_of(DpkgTools::Package::Config)
+  end
+end
+
+describe DpkgTools::Package::Config, "instances" do
+  before(:each) do
+    DpkgTools::Package::Config.root_path = "a/path"
+    @config = DpkgTools::Package::Config.new('gemname', '1.0.8', {:suffix => "rubygem"})
+  end
+  
+  it "should be able to set and return the path to the base package dir" do
+    @config.base_path.should == "a/path/gemname-rubygem-1.0.8"
+  end
+  
+  it "should be able to return the path to the debian dir in the package" do
+    @config.debian_path.should == "a/path/gemname-rubygem-1.0.8/debian"
+  end
+  
+  it "should be able to return the path to the .gem with #base_path" do
+    @config.gem_path.should == "a/path/gemname-rubygem-1.0.8/gemname-1.0.8.gem"
+  end
+  
+  it "should be able to return the root_path set on the class" do
+    DpkgTools::Package::Config.root_path = 'a/root/path'
+    @config.root_path.should == 'a/root/path'
+  end
+  
+  it "should be able to return the file name of the gem" do
+    @config.gem_filename.should == 'gemname-1.0.8.gem'
+  end
+  
+  it "should be able to return the name of the dpkg package dir" do
+    @config.package_dir_name.should == 'gemname-rubygem-1.0.8'
+  end
+  
+  it "should be able to return the name of the dpkg package name of the gem" do
+    @config.package_name.should == 'gemname-rubygem'
+  end
+  
+  it "should be able to return the path to where the .orig.tar.gz file should be" do
+    @config.orig_tarball_path.should == "a/path/gemname-rubygem-1.0.8.orig.tar.gz"
+  end
+  
+  it "should be able to return the path to where the package buildroot should be" do
+    @config.intermediate_buildroot.should == "a/path/gemname-rubygem-1.0.8/dpkg-tools-tmp"
+  end
+  
+  it "should be able to return the path to where the package intermediate buildroot should be" do
+    @config.buildroot.should == "a/path/gemname-rubygem-1.0.8/debian/tmp"
+  end
+  
+  it "should be able to return the path to where the bin dir in the buildroot should be" do
+    @config.bin_install_path.should == "a/path/gemname-rubygem-1.0.8/debian/tmp/usr/bin"
+  end
+  
+  it "should be able to return the path to where the gem install dir in the package buildroot should be" do
+    @config.gem_install_path.should == "a/path/gemname-rubygem-1.0.8/debian/tmp/usr/lib/ruby/gems/1.8"
+  end
+  
+  it "should be able to return the path to where the etc dir in the package buildroot should be" do
+    @config.etc_install_path.should == "a/path/gemname-rubygem-1.0.8/debian/tmp/etc"
+  end
+  
+  it "should be able to return the path to the DEBIAN control dir of the buildroot" do
+    @config.buildroot_DEBIAN_path.should == "a/path/gemname-rubygem-1.0.8/debian/tmp/DEBIAN"
+  end
+  
+  it "should provide access to the filename the built .deb will have" do
+    @config.deb_filename("1", "i386").should == "gemname-rubygem_1.0.8-1_i386.deb"
+  end
+  
+  it "should provide access to the version" do
+    @config.version.should == "1.0.8"
+  end
+  
+  it "should provide access to the debianized version (with package release suffix)" do
+    @config.deb_version("1").should == "1.0.8-1"
+  end
+end
+
+describe DpkgTools::Package::Config, "instances with suffix specified directly" do
+  before(:each) do
+    DpkgTools::Package::Config.root_path = "a/path"
+  end
+  
+  it "should be able to cope with 'rubygem' suffix" do
+    config = DpkgTools::Package::Config.new('package-name', '1.0.8', :suffix => "rubygem")
+    config.package_name.should == 'package-name-rubygem'
+  end
+  
+  it "should be able to cope with non-'rubygem' suffix" do
+    config = DpkgTools::Package::Config.new('package-name', '1.0.8', :suffix => "fnordling")
+    config.package_name.should == 'package-name-fnordling'
+  end
+end
+
+describe DpkgTools::Package::Config, "instances for gem names with debian oddities" do
+  before(:each) do
+    DpkgTools::Package::Config.root_path = "a/path"
+  end
+  
+  it "should be able to cope with gem names with underscores in them" do
+    config = DpkgTools::Package::Config.new('gem_name', '1.0.8', :suffix => "rubygem")
+    config.package_name.should == 'gem-name-rubygem'
+  end
+  
+  it "should be able to cope with gem names with capitalisation in them" do
+    config = DpkgTools::Package::Config.new('BlueCloth', '1.0.8', :suffix => "rubygem")
+    config.package_name.should == 'bluecloth-rubygem'
+  end
+end
+
+describe DpkgTools::Package::Config, "instances with base_path specified directly" do
+  before(:each) do
+    @config = DpkgTools::Package::Config.new('package-name', '1.0.8', :base_path => '/a/path/to/package-name')
+  end
+  
+  it "should be able to set and return the path to the base package dir" do
+    @config.base_path.should == "/a/path/to/package-name"
+  end
+  
+  it "should be able to return the name of the dpkg package dir" do
+    @config.package_dir_name.should == 'package-name'
+  end
+  
+  it "should be able to return the correct root_path" do
+    @config.root_path.should == '/a/path/to'
+  end
+end