fpm 0.3.11 → 0.4.0pre1

data/lib/fpm/source/rpm.rb

@@ -1,28 +0,0 @@
-require "fpm/source"
-require "fpm/util"
-
-class FPM::Source::RPM < FPM::Source
-  def get_metadata
-    @rpm = @paths.first
-    self[:name] = %x{rpm -q --qf '%{name}' -p #{@rpm}}.chomp
-
-    self[:version] = %x{rpm -q --qf '%{version}' -p #{@rpm}}.chomp
-    self[:iteration] = %x{rpm -q --qf '%{release}' -p #{@rpm}}.chomp
-    self[:summary] = %x{rpm -q --qf '%{summary}' -p #{@rpm}}.chomp
-    #self[:description] = %x{rpm -q --qf '%{description}' -p #{@rpm}}
-    self[:dependencies] = %x{rpm -qRp #{@rpm}}.split("\n")\
-      .collect { |line| line.strip }
-
-    @paths = %x{rpm -qlp #{@rpm}}.split("\n")
-  end
-
-  def make_tarball!(tar_path, builddir)
-    tmpdir = "#{tar_path}.dir"
-    ::Dir.mkdir(tmpdir)
-    safesystem("rpm2cpio #{@rpm} | (cd #{tmpdir}; cpio -i --make-directories)")
-    tar(tar_path, ".", tmpdir)
-    @paths = ["."]
-    # TODO(sissel): Make a helper method.
-    safesystem(*["gzip", "-f", tar_path])
-  end
-end

data/lib/fpm/source/tar.rb

@@ -1,50 +0,0 @@
-require "fpm/rubyfixes"
-require "fpm/source"
-require "fpm/util"
-require "fileutils"
-
-class FPM::Source::Tar < FPM::Source
-  def get_metadata
-    self[:name] = @paths.first.split(".").first
-  end # def get_metadata
-
-  def make_tarball!(tar_path, builddir)
-    input_tarball = @paths.first
-
-    if input_tarball =~ /\.tar\.bz2$/
-      compression = :bipz2
-    elsif input_tarball =~ /\.tar\.gz$/
-      compression = :gzip
-    elsif input_tarball =~ /\.tar\.xz$/
-      compression = :lzma
-    else
-      compression = :none
-    end
-
-    # Unpack the tar file
-    installdir = "#{builddir}/tarbuild/#{self[:prefix]}"
-    FileUtils.mkdir_p(installdir)
-    flags = "-xf #{input_tarball} -C #{installdir}"
-    case compression
-      when :bzip2; flags += " -j"
-      when :gzip; flags += " -z"
-      when :lzma; flags += " --lzma"
-    end
-    #puts("tar #{flags}")
-    #sleep 5
-    safesystem("tar #{flags}")
-
-    if self[:prefix]
-      @paths = [self[:prefix]]
-    else
-      @paths = ["."]
-    end
-
-    ::Dir.chdir("#{builddir}/tarbuild") do
-      tar(tar_path, ".")
-    end
-
-    # TODO(sissel): Make a helper method.
-    safesystem(*["gzip", "-f", tar_path])
-  end # def make_tarball!
-end # class FPM::Source::Dir

data/lib/fpm/target/deb.rb

@@ -1,184 +0,0 @@
-require "erb"
-require "fpm/namespace"
-require "fpm/package"
-require "fpm/errors"
-require "fpm/util"
-
-class FPM::Target::Deb < FPM::Package
-
-  def self.flags(opts, settings)
-    settings.target[:deb] = "deb"
-
-    opts.on("--ignore-iteration-in-dependencies",
-            "For = dependencies, allow iterations on the specified version.  Default is to be specific.") do |x|
-      settings.target[:ignore_iteration] = true
-    end
-
-    opts.on("--pre-depends DEPENDENCY", "Add DEPENDENCY as Pre-Depends.") do |dep|
-      (settings.target[:pre_depends] ||= []) << dep
-    end
-
-    # Take care about the case when we want custom control file but still use fpm ...
-    opts.on("--custom-control FILEPATH",
-            "Custom version of the Debian control file.") do |control|
-      settings.target[:control] = File.expand_path(control)
-    end
-  end
-
-  def needs_md5sums
-    case %x{uname -s}.chomp
-    when "Darwin"
-      return false
-    else
-      return true
-    end
-  end # def needs_md5sums
-
-  def architecture
-    if @architecture.nil? or @architecture == "native"
-      # Default architecture should be 'native' which we'll need
-      # to ask the system about.
-      arch = %x{dpkg --print-architecture 2> /dev/null}.chomp
-      if $?.exitstatus != 0
-        arch = %x{uname -m}.chomp
-        @logger.warn("Can't find 'dpkg' tool (need it to get default " \
-                     "architecture!). Please specificy --architecture " \
-                     "specifically. (Defaulting now to #{arch})")
-      end
-      @architecture = arch
-    elsif @architecture == "x86_64"
-      # Debian calls x86_64 "amd64"
-      @architecture = "amd64"
-    end
-
-    return @architecture
-  end # def architecture
-
-  def specfile(builddir)
-    "#{builddir}/control"
-  end
-
-  def name
-    if @name =~ /[A-Z]/
-      @logger.warn("Debian tools (dpkg/apt) don't do well with packages " \
-        "that use capital letters in the name. In some cases it will " \
-        "automatically downcase them, in others it will not. It is confusing." \
-        "Best to not use any capital letters at all.")
-      @name = @name.downcase
-    end
-
-    if @name.include?("_")
-      @logger.info("Package name '#{@name}' includes underscores, converting" \
-                   " to dashes")
-      @name = @name.gsub(/[_]/, "-")
-    end
-
-    return @name
-  end
-
-  def build!(params)
-    control_files = [ "control" ]
-    if File.exists? "./md5sums"
-      control_files << "md5sums"
-    end
-
-    # Use custom Debian control file when given ...
-    if self.settings[:control]
-      %x{cp #{self.settings[:control]} ./control 2> /dev/null 2>&1}
-      @logger.warn("Unable to process custom Debian control file (exit " \
-                   "code: #{$?.exitstatus}). Falling back to default " \
-                   "template.") unless $?.exitstatus == 0
-    end
-
-    # place the postinst prerm files
-    self.scripts.each do |name, path|
-      case name
-        when "pre-install"
-          safesystem("cp #{path} ./preinst")
-          control_files << "preinst"
-        when "post-install"
-          safesystem("cp #{path} ./postinst")
-          control_files << "postinst"
-        when "pre-uninstall"
-          safesystem("cp #{path} ./prerm")
-          control_files << "prerm"
-        when "post-uninstall"
-          safesystem("cp #{path} ./postrm")
-          control_files << "postrm"
-        else raise "Unsupported script name '#{name}' (path: #{path})"
-      end # case name
-    end # self.scripts.each
-
-    if self.config_files.any?
-      File.open('conffiles', 'w'){ |f| f.puts(config_files.join("\n")) }
-      control_files << 'conffiles'
-    end
-
-    # Make the control
-    safesystem("tar -zcf control.tar.gz #{control_files.map{ |f| "./#{f}" }.join(" ")}")
-
-    # create debian-binary
-    File.open("debian-binary", "w") { |f| f.puts "2.0" }
-
-    # pack up the .deb
-    safesystem("ar -qc #{params[:output]} debian-binary control.tar.gz data.tar.gz")
-  end # def build
-
-  def default_output
-    if iteration
-      "#{name}_#{version}-#{iteration}_#{architecture}.#{type}"
-    else
-      "#{name}_#{version}_#{architecture}.#{type}"
-    end
-  end # def default_output
-
-  def fix_dependency(dep)
-    if dep =~ /[\(,\|]/
-      # Don't "fix" ones that could appear well formed already.
-    else
-      da = dep.split(/ +/)
-      if da.size > 1
-        # Convert strings 'foo >= bar' to 'foo (>= bar)'
-        dep = "#{da[0]} (#{da[1]} #{da[2]})"
-      end
-    end
-
-    name_re = /^[^ \(]+/
-    name = dep[name_re]
-    if name =~ /[A-Z]/
-      @logger.warn("Downcasing dependency '#{name}' because deb packages " \
-                   " don't work so good with uppercase names")
-      dep.gsub!(name_re) { |n| n.downcase }
-    end
-
-    if dep =~ /_/
-      @logger.warn("Replacing underscores with dashes in '#{dep}' because " \
-                   "debs don't like underscores")
-      dep.gsub!("_", "-")
-    end
-
-    # Convert gem ~> X.Y.Z to '>= X.Y.Z' and << X.Y+1.0
-    if dep =~ /\(~>/
-      name, version = dep.gsub(/[()~>]/, "").split(/ +/)[0..1]
-      nextversion = version.split(".").collect { |v| v.to_i }
-      l = nextversion.length
-      nextversion[l-2] += 1
-      nextversion[l-1] = 0
-      nextversion = nextversion.join(".")
-      return ["#{name} (>= #{version})", "#{name} (<< #{nextversion})"]
-    # ignore iterations for = dependencies if flag specified
-    elsif (m = dep.match(/(\S+)\s+\(= (.+)\)/)) && self.settings[:ignore_iteration]
-      name, version = m[1..2]
-      nextversion = version.split('.').collect { |v| v.to_i }
-      nextversion[-1] += 1
-      nextversion = nextversion.join(".")
-      return ["#{name} (>= #{version})", "#{name} (<< #{nextversion})"]
-    else
-      return dep
-    end
-  end # def fix_dependency
-
-  def pre_dependencies
-    self.settings[:pre_depends] || []
-  end # def pre_dependencies
-end # class FPM::Target::Deb

data/lib/fpm/target/rpm.rb

@@ -1,68 +0,0 @@
-require "fpm/package"
-require "fpm/util"
-
-class FPM::Target::Rpm < FPM::Package
-  def architecture
-    case @architecture
-      when nil
-        return %x{uname -m}.chomp   # default to current arch
-      when "native"
-        return %x{uname -m}.chomp   # 'native' is current arch
-      when "all"
-        # Translate fpm "all" arch to what it means in RPM.
-        return "noarch"
-      else
-        return @architecture
-    end
-  end # def architecture
-
-  def specfile(builddir)
-    "#{builddir}/#{name}.spec"
-  end
-
-  def url
-    if @url.nil? || @url.empty?
-      'http://nourlgiven.example.com'
-    else
-      @url
-    end
-  end
-
-  def iteration
-    if @iteration.nil? || @iteration.empty?
-      # Default iteration value of 1 makes sense.
-      return '1'
-    else
-      return @iteration
-    end
-  end # def iteration
-
-  def version
-    if @version.kind_of?(String) and @version.include?("-")
-      @logger.info("Package version '#{@version}' includes dashes, converting" \
-                   " to underscores")
-      @version = @version.gsub(/-/, "_")
-    end
-
-    return @version
-  end
-
-  def build!(params)
-    raise "No package name given. Can't assemble package" if !@name
-    # TODO(sissel): Abort if 'rpmbuild' tool not found.
-
-    %w(BUILD RPMS SRPMS SOURCES SPECS).each { |d| Dir.mkdir(d) }
-    args = ["rpmbuild", "-ba",
-           "--define", "buildroot #{Dir.pwd}/BUILD",
-           "--define", "_topdir #{Dir.pwd}",
-           "--define", "_sourcedir #{Dir.pwd}",
-           "--define", "_rpmdir #{Dir.pwd}/RPMS",
-           "#{name}.spec"]
-    safesystem(*args)
-
-    Dir["#{Dir.pwd}/RPMS/**/*.rpm"].each do |path|
-      # This should only output one rpm, should we verify this?
-      safesystem("mv", path, params[:output])
-    end
-  end # def build!
-end # class FPM::Target::RPM

data/lib/rpm/header.rb

@@ -1,89 +0,0 @@
-require File.join(File.dirname(__FILE__), "namespace")
-require File.join(File.dirname(__FILE__), "tag")
-
-class RPMFile::Header
-  attr_reader :tags
-  attr_reader :length
-
-  attr_accessor :magic  # 8-byte string magic
-  attr_accessor :index_count  # rpmlib calls this field 'il' unhelpfully
-  attr_accessor :data_length   # rpmlib calls this field 'dl' unhelpfully
-
-  HEADER_SIGNED_TYPE = 5
-  HEADER_MAGIC = "\x8e\xad\xe8\x01\x00\x00\x00\x00"
-
-  def initialize(rpm)
-    @rpm = rpm
-    @tags = []
-  end
-
-  def read
-    # TODO(sissel): update the comments here to reflect learnings about rpm
-    # internals
-    # At this point assume we've read and consumed the lead and signature.
-    #len = @rpm.signature.index_length + @rpm.signature
-    #
-    # header size is
-    #     ( @rpm.signature.index_length * size of a header entry )
-    #     + @rpm.signature.data_length
-    #
-    # header 'entries' are an
-    #   int32 (tag id), int32 (tag type), int32  (offset), uint32 (count)
-    #
-    # See rpm's header.c, the headerLoad method function for reference.
-
-    # Header always starts with HEADER_MAGIC + index_count(2bytes) +
-    # data_length(2bytes)
-    data = @rpm.file.read(16).unpack("a8NN")
-    # TODO(sissel): @index_count is really a count, rename?
-    @magic, @index_count, @data_length = data
-    validate
-
-    entry_size = 16 # tag id, type, offset, count == 16 bytes
-    @index_size = @index_count * entry_size
-    tag_data = @rpm.file.read(@index_size)
-    data = @rpm.file.read(@data_length)
-
-    #ap :data => data
-
-    (0 ... @index_count).each do |i|
-      offset = i * entry_size
-      entry_data = tag_data[i * entry_size, entry_size]
-      entry = entry_data.unpack("NNNN")
-      entry << data
-      tag = ::RPMFile::Tag.new(*entry)
-      @tags << tag
-
-      #ap tag.tag => {
-        #:type => tag.type,
-        #:offset => tag.offset,
-        #:count => tag.count,
-        #:value => (tag.value rescue "???"),
-      #}
-    end # each index
-    @length = @magic.size + @index_size + @data_length
-  end # def read
-
-  def write
-    raise "not implemented yet"
-    # Sort tags by type (integer value)
-    # emit all tags in order
-    # then emit all data segments in same order
-  end # def write
-
-  def validate
-    # TODO(sissel): raise real exceptions
-    if @magic != ::RPMFile::Header::HEADER_MAGIC
-      raise "Header magic did not match; got #{@magic.inspect}, " \
-            "expected #{::RPMFile::Header::HEADER_MAGIC.inspect}"
-    end
-
-    #if !(0..32).include?(@index_count)
-      #raise "Invalid 'index_count' value #{@index_count}, expected to be in range [0..32]"
-    #end
-
-    #if !(0..8192).include?(@data_length)
-      #raise "Invalid 'data_length' value #{@data_length}, expected to be in range [0..8192]"
-    #end
-  end # def validate
-end # class RPMFile::Header

data/lib/rpm/lead.rb

@@ -1,48 +0,0 @@
-require File.join(File.dirname(__FILE__), "namespace")
-
-class RPMFile::Lead
-  #struct rpmlead {
-  attr_accessor :magic #unsigned char magic[4];
-  attr_accessor :major #unsigned char major;
-  attr_accessor :minor #unsigned char minor;
-  attr_accessor :type  #short type;
-  attr_accessor :archnum #short archnum;
-  attr_accessor :name #char name[66];
-  attr_accessor :osnum #short osnum;
-  attr_accessor :signature_type #short signature_type;
-  attr_accessor :reserved #char reserved[16];
-  #}
-
-  attr_accessor :length
-
-  def initialize(rpm)
-    @rpm = rpm
-  end
-
-  def type
-    case @type
-    when 0
-      return :binary
-    when 1
-      return :source
-    else
-      raise "Unknown package 'type' value #{@type}"
-    end
-  end # def type
-
-  def read
-    # Use 'A' here instead of 'a' to trim nulls.
-    @length = 96
-    data = @rpm.file.read(@length).unpack("A4CCnnA66nnA16")
-    @magic, @major, @minor, @type, @archnum, @name, \
-      @osnum, @signature_type, @reserved = data
-
-    return nil
-  end # def read
-
-  def write(file)
-    data = [ @magic, @major, @minor, @type, @archnum, @name, \
-             @osnum, @signature_type, @reserved ].pack("a4CCnna66nna16")
-    file.write(data)
-  end # def write
-end # class RPMFile::Lead