fpm 0.3.11 → 0.4.0pre1

data/lib/fpm/builder.rb

@@ -1,220 +0,0 @@
-require "fileutils"
-require "fpm/util"
-require "pathname"
-
-class FPM::Builder
-  # where is the package's root?
-  def root
-    @root ||= (@source.root || '.')
-  end
-
-  # where the package goes
-  def output
-    @output ||= begin
-      o = @package.default_output
-      if o[0,1] == "/"
-        o
-      else
-        File.join(@working_dir, o)
-      end
-    end
-  end
-
-  # things to clean up afterwards
-  def garbage
-    @garbage ||= []
-  end
-
-  attr_reader :paths
-  attr_reader :package
-  attr_reader :source
-
-  def initialize(settings, paths=[])
-    @logger = Logger.new(STDERR)
-    @logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
-
-    @working_dir = Dir.pwd
-    root = settings.chdir || '.'
-    paths = ['.'] if paths.empty?
-    @source  = source_class_for(settings.source_type || 'dir').new(
-      paths, root,
-      :version => settings.version,
-      :iteration => settings.iteration,
-      :epoch => settings.epoch,
-      :name => settings.package_name,
-      :prefix => settings.prefix,
-      :suffix => settings.suffix,
-      :exclude => settings.exclude,
-      :maintainer => settings.maintainer,
-      :provides => [],
-      :replaces => [],
-      :conflicts => [],
-      :description => settings.description,
-      :url => settings.url,
-      :settings => settings.source
-    )
-
-    @edit = !!settings.edit
-
-    @paths = paths
-    @package = package_class_for(settings.package_type).new(@source,
-			:settings => settings.target
-		)
-    # Append dependencies given from settings (-d flag for fpm)
-    @package.dependencies += settings.dependencies if settings.dependencies
-    # Append provides given from settings (--provides flag for fpm)
-    @package.provides += settings.provides if settings.provides
-    @package.replaces += settings.replaces if settings.replaces
-    @package.conflicts += settings.conflicts if settings.conflicts
-    @package.architecture = settings.architecture if settings.architecture
-    @package.category = settings.category if settings.category
-    @package.scripts = settings.scripts
-    @package.config_files = settings.config_files
-
-    @output = settings.package_path
-    @recurse_dependencies = settings.recurse_dependencies
-  end # def initialize
-
-  def tar_path
-    @tar_path ||= "#{builddir}/data.tar"
-  end
-
-  # Assemble the package
-  def assemble!
-    version_a = [ @source[:version], @package.iteration ].compact
-    if @package.epoch
-      output.gsub!(/VERSION/, "#{@package.epoch}:" + version_a.join('-'))
-    else
-      output.gsub!(/VERSION/, version_a.join('-'))
-    end
-    output.gsub!(/ARCH/, @package.architecture)
-
-    File.delete(output) if File.exists?(output) && !File.directory?(output)
-
-    make_builddir!
-
-    ::Dir.chdir root do
-      @source.make_tarball!(tar_path, builddir)
-
-      # Hack to unpack before generating the spec, etc.
-      # Need to formalize this feature.
-      # Perhaps something like @package.prepare
-      if @package.respond_to?(:unpack_data_to)
-        data_tarball = File.join(builddir, "data.tar.gz")
-        Dir.chdir(builddir) do
-          FileUtils.mkdir_p(@package.unpack_data_to)
-          safesystem("gzip -d #{data_tarball}")
-          Dir.chdir(@package.unpack_data_to) do
-            @source.root = Dir.pwd
-            safesystem("tar -xf #{data_tarball.gsub(/\.gz$/, "")}")
-          end
-        end
-      end
-
-      generate_md5sums if @package.needs_md5sums
-      generate_specfile
-      edit_specfile if @edit
-    end
-
-    ::Dir.chdir(builddir) do
-      @package.build!({
-        :tarball => tar_path,
-        :output => output
-      })
-    end
-
-    garbage << @source.garbage if @source.respond_to?(:garbage)
-
-    cleanup!
-  end # def assemble!
-
-  private
-  def builddir
-    @builddir ||= File.expand_path(
-      "#{Dir.pwd}/build-#{@package.type}-#{File.basename(output)}"
-    )
-  end
-
-  private
-  def make_builddir!
-    FileUtils.rm_rf builddir
-    garbage << builddir
-    FileUtils.mkdir(builddir) if !File.directory?(builddir)
-  end
-
-  # TODO: [Jay] make this better.
-  private
-  def package_class_for(type)
-    realtype = FPM::Target.constants.find { |c| c.downcase.to_s == type }
-    if !realtype
-      valid_types = FPM::Target.constants.collect { |c| c.downcase }
-      @logger.fatal("No such package target type #{type.inspect}; " \
-                    "Valid types: #{valid_types.join(", ")}")
-      raise ArgumentError, "unknown package type #{type.inspect}"
-    end
-
-    return FPM::Target.const_get(realtype)
-  end
-
-  # TODO: [Jay] make this better.
-  private
-  def source_class_for(type)
-    realtype = FPM::Source::constants.find { |c| c.downcase.to_s == type }
-    if !realtype
-      valid_types = FPM::Source.constants.collect { |c| c.downcase }
-      @logger.fatal("No such package source type #{type.inspect}; " \
-                    "Valid types: #{valid_types.join(", ")}")
-      raise ArgumentError, "unknown package type #{type.inspect}"
-    end
-
-    return FPM::Source.const_get(realtype)
-  end
-
-  private
-  def cleanup!
-    return [] if garbage.empty?
-    FileUtils.rm_rf(garbage) && garbage.clear
-  end
-
-  private
-  def generate_specfile
-    @package.generate_specfile(builddir)
-  end
-
-  private
-  def edit_specfile
-    # TODO(sissel): support editing multiple files for targets like
-    # puppet which generate multiple manifests.
-    editor = ENV['FPM_EDITOR'] || ENV['EDITOR'] || 'vi'
-    safesystem("#{editor} '#{package.specfile(builddir)}'")
-    unless File.size? package.specfile(builddir)
-      puts "Empty specfile.  Aborting."
-      exit 1
-    end
-  end
-
-  private
-  def generate_md5sums
-    md5sums = checksum(paths)
-    File.open("#{builddir}/md5sums", "w") { |f| f.puts md5sums }
-    md5sums
-  end
-
-  private
-  def checksum(paths)
-    paths.collect do |path|
-      if File.directory? path
-       # This should work for both cases where we use -C or not ...
-        %x{ find #{path} -type f -print0 | xargs -0 md5sum }.split("\n").collect do |i|
-          # Remove leading path and "./" from the md5sum output if present ...
-          i = i.split(/\s+/)
-          "%s  %s" % [i[0], i[1].sub(/#{path}\//, '').sub(/\.\//, '')]
-        end
-      elsif File.exists? path
-        %x{md5sum "#{path}"}
-      else
-        next
-      end
-    end.flatten
-  end # def checksum
-end

data/lib/fpm/flags.rb

@@ -1,20 +0,0 @@
-require "fpm/namespace"
-
-class FPM::Flags
-  def initialize(opts, flag_prefix, help_prefix)
-    @opts = opts
-    @flag_prefix = flag_prefix
-    @help_prefix = help_prefix
-  end # def initialize
-
-  def on(*args, &block)
-    fixed_args = args.collect do |arg|
-      if arg =~ /^--/
-        "--#{@flag_prefix}-#{arg.gsub(/^--/, "")}"
-      else
-        "(#{@help_prefix}) #{arg}"
-      end
-    end
-    @opts.on(*fixed_args, &block)
-  end # def on
-end # class FPM::Flags

data/lib/fpm/program.rb

@@ -1,273 +0,0 @@
-require "rubygems"
-require "erb" # TODO(sissel): Move to the class that needs it.
-require "fpm/namespace"
-require "optparse"
-require "ostruct"
-
-require "fpm"
-require "fpm/flags"
-
-class FPM::Program
-  def initialize
-    @settings = OpenStruct.new
-    @settings.dependencies = []
-    @settings.exclude = []  # Paths to exclude in packaging
-    @settings.provides = []
-    @settings.replaces = []
-    @settings.conflicts = []
-    @settings.source = {}   # source settings
-    @settings.target = {}   # target settings
-    @settings.config_files ||= []
-    @settings.inputs_path = nil # file path to read a list of paths from
-    @settings.paths = [] # Paths to include in the package
-
-    # Maintainer scripts - https://github.com/jordansissel/fpm/issues/18
-    @settings.scripts ||= {}
-
-    @help = nil
-  end # def initialize
-
-  def run(args)
-    $: << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-    extracted_args = options(args)
-
-    ok = true
-    if @settings.package_type.nil?
-      $stderr.puts "Missing package target type (no -t flag?)"
-      ok = false
-    end
-
-    if @settings.source_type.nil?
-      $stderr.puts "Missing package source type (no -s flag?)"
-      ok = false
-    end
-
-    paths = process_paths(extracted_args)
-    ok = false if paths == :errors
-
-    if !ok
-      $stderr.puts "There were errors; see above."
-      $stderr.puts
-      $stderr.puts @help
-      return 1
-    end
-
-    builder = FPM::Builder.new(@settings, paths)
-    builder.assemble!
-    puts "Created #{builder.output}"
-    return 0
-  end # def run
-
-  def process_paths(args)
-    paths_iolike = args
-    read_from_stdin = args.length == 1 && args.first == '-'
-
-    ok = true
-    if @settings.inputs_path 
-      if read_from_stdin
-        $stderr.puts "Error: setting --inputs conflicts with passing '-' as the only argument"
-        ok = false
-      end
-      unless File.file?(@settings.inputs_path)
-        $stderr.puts "Error: '#{@settings.inputs_path}' does not exist"
-        ok = false
-      end
-    end
-
-    return :errors if !ok
-
-    if read_from_stdin
-      paths_iolike = $stdin
-    end
-    if @settings.inputs_path
-      paths_iolike = File.open(@settings.inputs_path, 'r')
-    end
-
-    paths = []
-    paths_iolike.each do |entry|
-      paths << entry.strip
-    end
-    paths_iolike.close if paths_iolike.respond_to?(:close)
-    paths
-  end # def process_paths
-
-  def options(args)
-    opts = OptionParser.new
-    default_options(opts)
-
-    # Add extra flags from plugins
-    FPM::Source::Gem.flags(FPM::Flags.new(opts, "gem", "gem source only"), @settings)
-    FPM::Source::Python.flags(FPM::Flags.new(opts, "python", "python source only"),
-                              @settings)
-    FPM::Target::Deb.flags(FPM::Flags.new(opts, "deb", "deb target only"), @settings)
-
-    # Process fpmrc first
-    fpmrc(opts)
-
-    # Proces normal flags now.
-    remaining = opts.parse(args)
-
-    # need to print help in a different scope
-    @help = opts.help
-
-    return remaining
-  end # def options
-
-  def fpmrc(options)
-    # Skip if we have no HOME environment variable.
-    return if !ENV.include?("HOME")
-    rcpath = File.expand_path("~/.fpmrc")
-    return if !File.exists?(rcpath)
-
-    # fpmrc exists, read it as flags, one per line.
-    File.new(rcpath, "r").each do |line|
-      flag = line.chomp
-      begin
-        options.parse([flag])
-      rescue => e
-        $stderr.puts "Error parsing fpmrc (#{rcpath})"
-        raise e
-      end # begin
-    end # File.new
-  end # def fpmrc
-
-  def default_options(opts)
-    # TODO(sissel): Maybe this should be '-o OUTPUT' ?
-    opts.on("-p PACKAGEFILE", "--package PACKAGEFILE",
-            "The package file to manage") do |path|
-      if path =~ /^\//
-        @settings.package_path = path
-      else
-        @settings.package_path = "#{Dir.pwd}/#{path}"
-      end
-    end # --package
-
-    opts.on("-n PACKAGENAME", "--name PACKAGENAME",
-            "What name to give to the package") do |name|
-      @settings.package_name = name
-    end # --name
-
-    opts.on("-v VERSION", "--version VERSION",
-            "version to give the package") do |version|
-      @settings.version = version
-    end # --version
-
-    opts.on("--iteration ITERATION",
-            "(optional) Set the iteration value for this package ('release' for RPM).") do |iteration|
-      @settings.iteration = iteration
-    end # --iteration
-
-    opts.on("--epoch EPOCH",
-            "(optional) Set epoch value for this package.") do |epoch|
-      @settings.epoch = epoch
-    end # --epoch
-
-    opts.on("-d DEPENDENCY", "--depends DEPENDENCY") do |dep|
-      @settings.dependencies << dep
-    end # --depends
-
-    opts.on("--category SECTION_OR_GROUP") do |thing|
-      @settings.category = thing
-    end # --category
-
-    opts.on("--provides PROVIDES") do |thing|
-      @settings.provides << thing
-    end # --provides
-
-    opts.on("--conflicts CONFLICTS") do |thing|
-      @settings.conflicts << thing
-    end # --conflicts
-
-    opts.on("--replaces REPLACES") do |thing|
-      @settings.replaces << thing
-    end # --replaces
-
-    opts.on("--config-files PATH",
-            "(optional) Treat path as a configuration file. Uses conffiles in deb or %config in rpm. (/etc/package.conf)") do |thing|
-      @settings.config_files << thing
-    end
-
-    opts.on("-a ARCHITECTURE", "--architecture ARCHITECTURE") do |arch|
-      @settings.architecture = arch
-    end # --architecture
-
-    opts.on("-m MAINTAINER", "--maintainer MAINTAINER") do |maintainer|
-      @settings.maintainer = maintainer
-    end # --maintainer
-
-    opts.on("-C DIRECTORY", "Change directory before searching for files") do |dir|
-      @settings.chdir = dir
-    end # -C
-
-    opts.on("-t PACKAGE_TYPE", "the type of package you want to create") do |type|
-      @settings.package_type = type
-    end # -t
-
-    opts.on("-s SOURCE_TYPE", "what to build the package from") do |st|
-      @settings.source_type = st
-    end # -s
-
-    opts.on("-S PACKAGE_SUFFIX", "which suffix to append to package and dependencies") do |sfx|
-      @settings.suffix = sfx
-    end # -S
-
-    opts.on("--prefix PREFIX",
-            "A path to prefix files with when building the target package. This may not be necessary for all source types. For example, the 'gem' type will prefix with your gem directory (gem env | grep -A1 PATHS:)") do |prefix|
-      @settings.prefix = prefix
-    end # --prefix
-
-    opts.on("-e", "--edit", "Edit the specfile before building") do
-      @settings.edit = true
-    end # --edit
-
-    opts.on("-x PATTERN", "--exclude PATTERN",
-            "Exclude paths matching pattern (according to tar --exclude)") do |pattern|
-      @settings.exclude << pattern
-    end # -x / --exclude
-
-    opts.on("--post-install SCRIPTPATH",
-            "Add a post-install action. This script will be included in the" \
-            " resulting package") do |path|
-      @settings.scripts["post-install"] = File.expand_path(path)
-    end # --post-install
-
-    opts.on("--pre-install SCRIPTPATH",
-            "Add a pre-install action. This script will be included in the" \
-            " resulting package") do |path|
-      @settings.scripts["pre-install"] = File.expand_path(path)
-    end # --pre-install
-
-    opts.on("--pre-uninstall SCRIPTPATH",
-            "Add a pre-uninstall action. This script will be included in the" \
-            " resulting package") do |path|
-      @settings.scripts["pre-uninstall"] = File.expand_path(path)
-    end # --pre-uninstall
-
-    opts.on("--post-uninstall SCRIPTPATH",
-            "Add a post-uninstall action. This script will be included in the" \
-            " resulting package") do |path|
-      @settings.scripts["post-uninstall"] = File.expand_path(path)
-    end # --post-uninstall
-
-    opts.on("--description DESCRIPTION",
-            "Add a description for this package.") do |description|
-      @settings.description = description
-    end # --description
-
-    opts.on("--url URL",
-            "Add a url for this package.") do |url|
-      @settings.url = url
-    end # --url
-
-    opts.on("--inputs FILEPATH",
-            "The path to a file containing a newline-separated list of " \
-            "files and dirs to package.") do |path|
-      settings.source[:inputs] = path
-    end
-
-    opts.separator "Pass - as the only argument to have the list of " \
-                   "files and dirs read from STDIN " \
-                   "(e.g. fpm -s dir -t deb - < FILELIST)"
-
-  end # def default_options
-end # class FPM::Program