dpkg-tools 0.3.3

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

@@ -0,0 +1,112 @@
+require 'rubygems'
+require 'rake'
+
+module DpkgTools
+  module Package
+    class Builder
+      include DpkgTools::Package::FSMethods
+      
+      attr_reader :data, :config
+      
+      def initialize(data)
+        @data = data
+        @config = DpkgTools::Package::Config.new(@data.name, @data.version, config_options)
+      end
+      
+      def config_options
+        {}
+      end
+      
+      def architecture_independent?
+        @data.architecture_independent?
+      end
+      
+      def create_intermediate_buildroot
+        create_dir_if_needed(config.intermediate_buildroot)
+      end
+      
+      def create_buildroot
+        create_dir_if_needed(config.buildroot)
+      end
+      
+      def create_install_dirs
+      end
+      
+      def build_package_files
+      end
+      
+      def install_package_files
+      end
+      
+      def render_template(template)
+        conf_file = ERB.new(template, nil, '-').result(data.binding)
+      end
+      
+      def maintainer_script_targets
+        names = Dir.entries(config.debian_path).select do |name| 
+          ['postinst.erb', 'preinst.erb', 'postrm.erb', 'prerm.erb'].include?(name)
+        end
+        names.collect { |name| name[/^(.+)\.erb$/, 1] }
+      end
+      
+      def generate_maintainer_script(script_name)
+        template = File.read(File.join(config.debian_path, "#{script_name}.erb"))
+        target_path = File.join(config.buildroot_DEBIAN_path, script_name)
+        File.open(target_path, 'w') do |f|
+          f.write(render_template(template))
+        end
+        File.chmod(0755, target_path)
+      end
+      
+      def generate_maintainer_scripts
+        maintainer_script_targets.each do |target|
+          generate_maintainer_script(target)
+        end
+      end
+      
+      def create_DEBIAN_dir
+        Dir.mkdir(config.buildroot_DEBIAN_path) unless File.directory?(config.buildroot_DEBIAN_path)
+      end
+      
+      # create DEBIAN/* package metadata by running dpkg-gencontrol
+      # Note: this assumes that command is run from package base dir
+      def create_control_files
+        sh "dpkg-gencontrol"
+      end
+      
+      def deb_filename
+        config.deb_filename(data.debian_revision, data.debian_arch)
+      end
+      
+      def built_deb_path
+        File.join(config.root_path, deb_filename)
+      end
+      
+      # create the .deb binary package by running dpkg-deb --build with the appropriate options
+      def create_deb
+        sh "dpkg-deb --build \"#{config.buildroot}\" \"#{built_deb_path}\""
+      end
+      
+      def build_package
+        create_buildroot
+        create_install_dirs
+        build_package_files
+      end
+      
+      def binary_package
+        create_buildroot
+        create_install_dirs
+        install_package_files
+        create_DEBIAN_dir
+        generate_maintainer_scripts
+        create_control_files
+        create_deb
+      end
+      
+      def remove_build_products
+        FileUtils.remove_dir(config.buildroot) if File.exists?(config.buildroot)
+        FileUtils.remove_dir(config.intermediate_buildroot) if File.exists?(config.intermediate_buildroot)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module DpkgTools
+  module Package
+    class << self
+      def config(name_version_pair)
+        @config ||= {}
+        @config[name_version_pair] ||= DpkgTools::Package::Config.new(*name_version_pair)
+        yield(@config[name_version_pair]) if block_given?
+        @config[name_version_pair]
+      end
+    end
+    
+    class Config
+      class << self
+        attr_accessor :root_path
+      end
+      
+      attr_reader :name, :version
+      
+      def initialize(name, version, options = {})
+        @name = name
+        @version = version
+        @options = options
+      end
+      
+      def full_name
+        @name + "-" + @version
+      end
+      
+      def package_name
+        @name.downcase.tr("_", "-") + (@options[:suffix].nil? ? '' : "-#{@options[:suffix]}")
+      end
+      
+      def package_dir_name
+        File.basename(base_path)
+      end
+      
+      def base_path
+        return @options[:base_path] if @options.has_key?(:base_path)
+        File.join(root_path, "#{package_name}-#{version}")
+      end
+      
+      def root_path
+        return File.dirname(@options[:base_path]) if @options.has_key?(:base_path)
+        self.class.root_path
+      end
+      
+      def debian_path
+        File.join(base_path, 'debian')
+      end
+      
+      def gem_filename
+        full_name + '.gem'
+      end
+      
+      def gem_path
+        File.join(base_path, gem_filename)
+      end
+      
+      def orig_tarball_path
+        base_path + ".orig.tar.gz"
+      end
+      
+      def buildroot
+        File.join(debian_path, 'tmp')
+      end
+      
+      def intermediate_buildroot
+        File.join(base_path, 'dpkg-tools-tmp')
+      end
+      
+      def bin_install_path
+        File.join(buildroot, 'usr/bin')
+      end
+      
+      def gem_install_path
+        File.join(buildroot, 'usr/lib/ruby/gems/1.8')
+      end
+      
+      def etc_install_path
+        File.join(buildroot, 'etc')
+      end
+      
+      def buildroot_DEBIAN_path
+        File.join(buildroot, 'DEBIAN')
+      end
+      
+      def deb_filename(deb_revision, deb_arch)
+        "#{package_name}_#{deb_version(deb_revision)}_#{deb_arch}.deb"
+      end
+      
+      def deb_version(deb_revision)
+        "#{version}-#{deb_revision}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'dpkg-tools/package/control_files/base'
+require 'dpkg-tools/package/control_files/control'
+require 'dpkg-tools/package/control_files/copyright'
+require 'dpkg-tools/package/control_files/changelog'
+require 'dpkg-tools/package/control_files/rules'
+require 'dpkg-tools/package/control_files/rakefile'
+
+module DpkgTools
+  module Package
+    module ControlFiles
+      class << self
+        def classes
+          [
+            DpkgTools::Package::ControlFiles::Changelog,
+            DpkgTools::Package::ControlFiles::Control,
+            DpkgTools::Package::ControlFiles::Copyright,
+            DpkgTools::Package::ControlFiles::Rakefile,
+            DpkgTools::Package::ControlFiles::Rules
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/control_files/base.rb

@@ -0,0 +1,75 @@
+module DpkgTools
+  module Package
+    module ControlFiles
+      class Base
+        class << self
+          def check_target_dir(target_dir_path)
+            Dir.mkdir(target_dir_path) unless File.exists?(target_dir_path)
+          end
+          
+          def write(file_path, contents)
+            check_target_dir(File.dirname(file_path))
+            File.open(file_path, 'w') do |f|
+              f.write(contents)
+            end
+          end
+          
+          def write_executable(file_path, contents)
+            self.write(file_path, contents)
+            File.chmod(0755, file_path)
+          end
+          
+          def filename
+            'base'
+          end
+          
+          def formatter_class
+            BaseFormatter
+          end
+        end
+        
+        attr_reader :data, :config, :formatter
+        
+        def initialize(data, config)
+          @data = data
+          @config = config
+          @formatter = self.class.formatter_class.new(self)
+        end
+        
+        def executable?
+          false
+        end
+        
+        def filename
+          self.class.filename
+        end
+        
+        def file_path
+          File.join(@config.debian_path, filename)
+        end
+        
+        def to_s
+          formatter.build
+        end
+        
+        def write
+          write_method = executable? ? :write_executable : :write
+          self.class.send(write_method, file_path, self.to_s)
+        end
+        
+        def needs_reset?
+          return true unless File.exist?(file_path)
+          File.read(file_path) != self.to_s
+        end
+      end
+      
+      class BaseFormatter
+        attr_reader :metadata, :output
+        
+        def initialize(metadata)
+          @metadata = metadata
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/control_files/changelog.rb

@@ -0,0 +1,23 @@
+module DpkgTools
+  module Package
+    module ControlFiles
+      class Changelog < DpkgTools::Package::ControlFiles::Base
+        class << self
+          def filename
+            'changelog'
+          end
+          
+          def formatter_class
+            ChangelogFormatter
+          end
+        end
+      end
+      
+      class ChangelogFormatter < DpkgTools::Package::ControlFiles::BaseFormatter
+        def build
+          metadata.changelog
+        end
+      end
+    end
+  end
+end

data/lib/dpkg-tools/package/control_files/control.rb

@@ -0,0 +1,148 @@
+module DpkgTools
+  module Package
+    module ControlFiles
+      class Control < DpkgTools::Package::ControlFiles::Base
+        class << self
+          def filename
+            'control'
+          end
+          
+          def formatter_class
+            ControlFormatter
+          end
+        end
+        
+        # Source: package-name
+        def source
+          config.package_name
+        end
+        
+        # Maintainer: name/email address
+        def maintainer
+          ["Matt Patterson", "matt@reprocessed.org"]
+        end
+          
+        # Section: hardwired to 'libs' for now
+        def section
+          'libs'
+        end
+        
+        # Priority: hardwired to 'optional' for now
+        def priority
+          'optional'
+        end
+        
+        # Build-Depends: build-time package deps
+        def build_depends
+          data.build_dependencies
+        end
+        
+        # Standards-Version: the version we currently implement
+        def standards_version
+          DpkgTools::Package.standards_version
+        end
+        
+        # Package: package name for binary .deb
+        def package
+          config.package_name
+        end
+        
+        # Architecture: Binary package's architecture
+        def architecture
+          data.debian_arch
+        end
+        
+        # Essential: Hardwired to 'no' because nothing but Debian/Ubuntu base packages are essential
+        def essential
+          "no"
+        end
+        
+        # Depends: install- and run-time package deps
+        def depends
+          data.dependencies
+        end
+        
+        # Description: We only return the summary for now
+        def description
+          data.summary
+        end
+      end
+      
+      class ControlFormatter < DpkgTools::Package::ControlFiles::BaseFormatter
+        def source_field_names
+          [:source, :maintainer, :uploaders, :section, :priority, 
+           :build_depends, :build_depends_indep, :build_conflicts, 
+           :build_conflicts_indep, :standards_version]
+        end
+        
+        def binary_field_names
+          [:package, :architecture, :section, :priority, :essential, 
+           :depends, :recommends, :suggests, :enhances, :pre_depends, 
+           :description]
+        end
+        
+        def field_names_map
+          {:source => "Source", :maintainer => "Maintainer", :uploaders => "Uploaders", 
+           :section => "Section", :priority => "Priority", :build_depends => "Build-Depends", 
+           :build_depends_indep => "Build-Depends-Indep", :build_conflicts => "Build-Conflicts", 
+           :build_conflicts_indep => "Build-Conflicts-Indep", :standards_version => "Standards-Version", 
+           :package => "Package", :architecture => "Architecture", :essential => "Essential", 
+           :depends => "Depends", :recommends => "Recommends", :suggests => "Suggests", 
+           :enhances => "Enhances", :pre_depends => "Pre-Depends", :description => "Description"}
+        end
+        
+        # Dynamically define methods to handle dependency lines (they're all the same bar the name...)
+        [:build_depends, :build_depends_indep, :build_conflicts, :build_conflicts_indep, 
+         :depends, :recommends, :suggests, :enhances, :pre_depends].each do |field_name|
+           define_method(field_name) {depends_line(field_name)}
+        end
+        
+        # generate the Maintainer line
+        def maintainer
+          "Maintainer: #{metadata.maintainer[0]} <#{metadata.maintainer[1]}>"
+        end
+        
+        def build
+          @output = []
+          # Source 'paragraph'
+          source_field_names.each {|field_name| process_field(field_name)}
+          
+          # line break to make new debian/control 'paragraph'
+          output << "" 
+          
+          # Binary 'paragraph'
+          binary_field_names.each {|field_name| process_field(field_name)}
+          
+          # required final newline
+          output << ""
+          output.join("\n")
+        end
+        
+        private
+        
+        def process_field(field_name)
+          if metadata.respond_to?(field_name)
+            if self.respond_to?(field_name)
+              output << self.send(field_name)
+            else
+              output << "#{field_names_map[field_name]}: #{metadata.send(field_name)}"
+            end
+          end
+        end
+        
+        def deps_string(dependencies)
+          deps = []
+          dependencies.each do |dependency|
+            reqs = dependency.has_key?(:requirements) ? dependency[:requirements].collect {|req| "(#{req})"} : []
+            deps << ([dependency[:name]] + reqs).join(" ")
+          end
+          deps.join(", ")
+        end
+        
+        def depends_line(field_name)
+          "#{field_names_map[field_name]}: #{deps_string(metadata.send(field_name))}"
+        end
+      end
+    end
+  end
+end