fpm 0.3.11 → 0.4.0pre1

data/lib/fpm/rubyfixes.rb

@@ -1,11 +0,0 @@
-# Ruby 1.8.7 added String#start_with? - monkeypatch the
-# String class if it isn't supported (<= ruby 1.8.6)
-if !String.instance_methods.include?("start_with?")
-  class String
-    public
-    def start_with?(str)
-      return self[0 .. (str.length-1)] == str
-    end
-  end
-end
-

data/lib/fpm/source.rb

@@ -1,155 +0,0 @@
-require "fpm/namespace"
-require "fpm/util"
-
-# Abstract class for a "thing to build a package from"
-class FPM::Source
-  # standard package metadata
-  %w(
-    name
-    version
-    iteration
-    architecture
-    maintainer
-    category
-    url
-    description
-  ).each do |attr|
-    attr = :"#{attr}"
-    define_method(attr) { self[attr] }
-    define_method(:"#{attr}=") { |v| self[attr] = v}
-  end
-
-  def dependencies
-    self[:dependencies] ||= []
-  end
-
-  attr_reader :paths
-  attr_accessor :root
-
-  def initialize(paths, root, params={})
-    @logger = Logger.new(STDERR)
-    @logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
-
-    @paths = paths
-    @root = root
-
-    self[:suffix] = params[:suffix]
-    self[:settings] = params[:settings]
-
-    get_source(params)
-    get_metadata
-
-    # override the inferred data with the passed-in data
-    params.each do |k,v|
-      self[k] = v if v != nil
-    end
-  end # def initialize
-
-  # this method should take the paths and root and infer as much
-  # about the package as it can.
-  def get_metadata
-    raise NoMethodError,
-      "Please subclass FPM::Source and define get_metadata"
-  end # def get_metadata
-
-  # This method should be overridden by package sources that need to do any
-  # kind of fetching.
-  def get_source(params)
-    # noop by default
-  end # def get_source
-
-  def make_tarball!(tar_path, builddir)
-    raise NoMethodError,
-      "Please subclass FPM::Source and define make_tarball!(tar_path)"
-  end
-
-  def metadata
-    @metadata ||= {}
-  end
-
-  def [](key)
-    metadata[key.to_sym]
-  end
-
-  def []=(key,val)
-    metadata[key.to_sym] = val
-  end
-
-  # MySourceClass.new('/tmp/build').package(FPM::Deb).assemble(params)
-  def package(pkg_cls)
-    pkg_cls.new(self)
-  end
-
-  private
-  def tar(output, paths, chdir=".")
-    dirs = []
-
-    # Include all directory entries at the top of the tarball
-    paths = [ paths ] if paths.is_a? String
-    paths.each do |path|
-      while path != "/" and path != "."
-        dirs << path if !dirs.include?(path)
-        path = File.dirname(path)
-      end
-    end # paths.each
-
-    # Want directories to be sorted thusly: [ "/usr", "/usr/bin" ]
-    # Why? tar and some package managers sometimes fail if the tar is created
-    # like: [ "/opt/fizz", "/opt" ]
-    # dpkg -i will fail if /opt doesn't exist, sorting it by length ensures
-    # /opt is created before /opt/fizz.
-    dirs.sort! { |a,b| a.size <=> b.size }
-    paths.sort! { |a,b| a.size <=> b.size }
-
-
-    # Solaris's tar is pretty neutered, so implement --exclude and such
-    # ourselves.
-    # TODO(sissel): May need to implement our own tar file generator
-    # so we can enforce file ownership. Again, solaris' tar doesn't support
-    # --owner, etc.
-    #paths = []
-    #dirs.each do |dir|
-      #Dir.glob(File.join(dir, "**", "*")).each do |path|
-        #next if excludesFile.fnmatch?(
-      #end
-    #end
-
-    excludes = self[:exclude].map { |e| ["--exclude", e] }.flatten
-
-    # TODO(sissel): To properly implement excludes as regexps, we
-    # will need to find files ourselves. That may be more work
-    # than it is worth. For now, rely on tar's --exclude.
-    dir_tar = [tar_cmd, "--owner=root", "--group=root" ] \
-              + excludes \
-              + ["-cf", output, "--no-recursion" ]
-
-    # Only if directories and paths do not have duplicates ...
-    dirs -= paths
-
-    if dirs.any?
-      ::Dir.chdir(chdir) do
-        safesystem *(dir_tar += dirs)
-      end
-    end
-
-    files_tar = [ tar_cmd ] \
-                + excludes \
-                + [ "--owner=root", "--group=root", "-rf", output ] \
-                + paths
-    ::Dir.chdir(chdir) do
-      safesystem(*files_tar)
-    end
-  end # def tar
-
-  def tar_cmd
-    # Rely on gnu tar for solaris and OSX.
-    case %x{uname -s}.chomp
-    when "SunOS"
-      return "gtar"
-    when "Darwin"
-      return "gnutar"
-    else
-      return "tar"
-    end
-  end # def tar_cmd
-end # class FPM::Source

data/lib/fpm/source/dir.rb

@@ -1,59 +0,0 @@
-require "fpm/source"
-require "fileutils"
-require "fpm/rubyfixes"
-require "fpm/util"
-
-class FPM::Source::Dir < FPM::Source
-  def get_metadata
-    self[:name] = File.basename(File.expand_path(root))
-  end
-
-  def make_tarball!(tar_path, builddir)
-    if self[:prefix]
-      # Trim leading '/' from prefix
-      self[:prefix] = self[:prefix][1..-1] if self[:prefix] =~ /^\//
-
-      # Prefix all files with a path if given.
-      @paths.each do |path|
-        # Trim @root (--chdir)
-        if @root != "." and path.start_with?(@root)
-          path = path[@root.size .. -1]
-        end
-
-        # Copy to self[:prefix] (aka --prefix)
-        if File.directory?(path)
-          # Turn 'path' into 'path/' so rsync copies it properly.
-          path = "#{path}/" if path[-1,1] != "/"
-          dest = "#{builddir}/tarbuild/#{self[:prefix]}/#{path}"
-        else
-          dest = "#{builddir}/tarbuild/#{self[:prefix]}/#{File.dirname(path)}"
-        end
-
-        ::FileUtils.mkdir_p(dest)
-        rsync = ["rsync", "-a", path, dest]
-        p rsync if $DEBUG
-        safesystem(*rsync)
-
-        # FileUtils.cp_r is pretty silly about how it copies files in some
-        # cases (funky permissions, etc)
-        # Use rsync instead..
-        #FileUtils.cp_r(path, dest)
-      end
-
-      # Prefix paths with 'prefix' if necessary.
-      if self[:prefix]
-        @paths = @paths.collect { |p| File.join("/", self[:prefix], p) }
-      end
-
-      ::Dir.chdir("#{builddir}/tarbuild") do
-        safesystem("ls #{builddir}/tarbuild") if $DEBUG
-        tar(tar_path, ".")
-      end
-    else
-      tar(tar_path, paths)
-    end
-
-    # TODO(sissel): Make a helper method.
-    safesystem(*["gzip", "-f", tar_path])
-  end # def make_tarball!
-end # class FPM::Source::Dir

data/lib/fpm/source/gem.rb

@@ -1,162 +0,0 @@
-require "fpm/namespace"
-require "fpm/source"
-require "rubygems/package"
-require "rubygems"
-require "fileutils"
-require "fpm/util"
-
-class FPM::Source::Gem < FPM::Source
-  def self.flags(opts, settings)
-    settings.source[:gem] = "gem"
-
-    opts.on("--bin-path DIRECTORY",
-            "The directory to install gem executables") do |path|
-      settings.source[:bin_path] = path
-    end
-    opts.on("--package-prefix PREFIX",
-            "Prefix for gem packages") do |package_prefix|
-      settings.source[:package_prefix] = package_prefix
-    end
-
-    opts.on("--gem PATH_TO_GEM",
-            "The path to the 'gem' tool (defaults to 'gem' and searches " \
-            "your $PATH)") do |path|
-      settings.source[:gem] = path
-    end
-  end # def flags
-
-  def get_source(params)
-    gem = @paths.first
-    looks_like_name_re = /^[A-Za-z0-9_-]+$/
-    if !File.exists?(gem)
-      if gem =~ looks_like_name_re
-        download(gem, params[:version])
-      else
-        raise "Path '#{gem}' is not a file and does not appear to be the name of a rubygem."
-      end
-    end
-  end # def get_source
-
-  def can_recurse_dependencies
-    true
-  end
-
-  def download(gem_name, version=nil)
-    # This code mostly mutated from rubygem's fetch_command.rb
-    # Code use permissible by rubygems's "GPL or these conditions below"
-    # http://rubygems.rubyforge.org/rubygems-update/LICENSE_txt.html
-
-    puts "Trying to download #{gem_name} (version=#{version || 'latest'})"
-    dep = ::Gem::Dependency.new gem_name, version
-    # How to handle prerelease? Some extra magic options?
-    #dep.prerelease = options[:prerelease]
-
-    if ::Gem::SpecFetcher.fetcher.respond_to?(:fetch_with_errors)
-      specs_and_sources, errors =
-        ::Gem::SpecFetcher.fetcher.fetch_with_errors(dep, true, true, false)
-    else
-      specs_and_sources =
-        ::Gem::SpecFetcher.fetcher.fetch(dep, true)
-      errors = "???"
-    end
-    spec, source_uri = specs_and_sources.sort_by { |s,| s.version }.last
-
-    if spec.nil? then
-      raise "Invalid gem? Name: #{gem_name}, Version: #{version}, Errors: #{errors}"
-    end
-
-    path = ::Gem::RemoteFetcher.fetcher.download spec, source_uri
-    FileUtils.mv path, spec.file_name
-    @paths = [spec.file_name]
-  end
-
-  def get_metadata
-    File.open(@paths.first, 'r') do |f|
-      ::Gem::Package.open(f, 'r') do |gem|
-        spec = gem.metadata
-        %w(
-          description
-          license
-          summary
-          version
-        ).each do |field|
-          self[field.to_sym] = spec.send(field) rescue "unknown"
-        end
-
-        if self[:settings][:package_prefix]
-          self[:package_prefix] = self[:settings][:package_prefix]
-        else
-          self[:package_prefix] = "rubygem"
-        end
-        self[:name] = "#{self[:package_prefix]}#{self[:suffix]}-#{spec.name}"
-        self[:maintainer] = spec.author
-        self[:url] = spec.homepage
-
-        # TODO [Jay]: this will be different for different
-        # package managers.  Need to decide how to handle this.
-        self[:category] = 'Languages/Development/Ruby'
-
-        # if the gemspec has extensions defined, then this should be a 'native' arch.
-        if !spec.extensions.empty?
-          self[:architecture] = "native"
-        else
-          self[:architecture] = "all"
-        end
-
-        # make sure we have a description
-        descriptions = [ self[:description], self[:summary], "#{spec.name} - no description given" ]
-        self[:description] = descriptions.detect { |d| !(d.nil? or d.strip.empty?) }
-
-        self[:dependencies] = []
-        spec.runtime_dependencies.map do |dep|
-          # rubygems 1.3.5 doesn't have 'Gem::Dependency#requirement'
-          if dep.respond_to?(:requirement)
-            reqs = dep.requirement.to_s.gsub(/,/, '')
-          else
-            reqs = dep.version_requirements
-          end
-
-          # Some reqs can be ">= a, < b" versions, let's handle that.
-          reqs.to_s.split(/, */).each do |req|
-            self[:dependencies] << "#{self[:package_prefix]}#{self[:suffix]}-#{dep.name} #{req}"
-          end
-        end # runtime_dependencies
-      end # ::Gem::Package
-    end # File.open (the gem)
-  end # def get_metadata
-
-  def make_tarball!(tar_path, builddir)
-    tmpdir = "#{tar_path}.dir"
-    gem = @paths.first
-    if self[:prefix]
-      installdir = "#{tmpdir}/#{self[:prefix]}"
-      # TODO(sissel): Overwriting @paths is bad mojo and confusing...
-      # Maybe we shouldn't?
-      @paths = [ self[:prefix] ]
-    else
-      installdir = File.join(tmpdir, ::Gem::dir)
-      @paths = [ ::Gem::dir ]
-    end
-
-    ::FileUtils.mkdir_p(installdir)
-    args = [self[:settings][:gem], "install", "--quiet", "--no-ri", "--no-rdoc",
-       "--install-dir", installdir, "--ignore-dependencies", "-E"]
-    if self[:settings][:bin_path]
-      tmp_bin_path = File.join(tmpdir, self[:settings][:bin_path])
-      args += ["--bindir", tmp_bin_path]
-      @paths << self[:settings][:bin_path]
-      FileUtils.mkdir_p(tmp_bin_path) # Fixes #27
-    end
-
-    args << gem
-    safesystem(*args)
-
-    # make paths relative  (/foo becomes ./foo)
-    tar(tar_path, @paths.collect {|p| ".#{p}"}, tmpdir)
-    FileUtils.rm_r(tmpdir)
-
-    # TODO(sissel): Make a helper method.
-    safesystem(*["gzip", "-f", tar_path])
-  end
-
-end # class FPM::Source::Gem

data/lib/fpm/source/python.rb

@@ -1,137 +0,0 @@
-require "fpm/namespace"
-require "fpm/source"
-require "fpm/util"
-require "rubygems/package"
-require "rubygems"
-require "fileutils"
-require "tmpdir"
-require "json"
-
-class FPM::Source::Python < FPM::Source
-  def self.flags(opts, settings)
-    settings.source[:python] = "python"
-    settings.source[:easy_install] = "easy_install"
-    settings.source[:pypi] ="http://pypi.python.org/simple"
-
-    opts.on("--bin PYTHON_BINARY_LOCATION",
-            "The path to the python you want to run. Default is 'python'") do |path|
-      settings.source[:python] = path
-    end
-
-    opts.on("--easyinstall EASY_INSTALL_PATH",
-            "The path to your easy_install tool. Default is 'easy_install'") do |path|
-      settings.source[:easy_install] = path
-    end
-
-    opts.on("--pypi PYPI_SERVER",
-            "PyPi Server uri for retrieving packages. Default is 'http://pypi.python.org/simple'") do |pypi|
-      settings.source[:pypi] = pypi
-    end
-
-    opts.on("--package-prefix PREFIX",
-            "Prefix for python packages") do |package_prefix|
-      settings.source[:package_prefix] = package_prefix
-    end
-  end # def flags
-
-  def get_source(params)
-    package = @paths.first
-    if ["setup.py", "."].include?(package)
-      # Assume we're building from an existing python package.
-      # Source already acquired, nothing to do!
-      return
-    end
-
-    if !File.exists?(package)
-      download(package, params[:version])
-    else
-      @paths = [ File.expand_path(package) ]
-    end
-  end # def get_source
-
-  def download(package, version=nil)
-    puts "Trying to download #{package} (using: #{self[:settings][:easy_install]})"
-    @tmpdir = ::Dir.mktmpdir("python-build", ::Dir.pwd)
-
-    if version.nil?
-      want_pkg = "#{package}"
-    else
-      want_pkg = "#{package}==#{version}"
-    end
-
-    safesystem(self[:settings][:easy_install], "-i", self[:settings][:pypi],
-               "--editable", "-U", "--build-directory", @tmpdir, want_pkg)
-
-    # easy_install will put stuff in @tmpdir/packagename/, flatten that.
-    #  That is, we want @tmpdir/setup.py, and start with
-    #  @tmpdir/somepackage/setup.py
-    dirs = ::Dir.glob(File.join(@tmpdir, "*"))
-    if dirs.length != 1
-      raise "Unexpected directory layout after easy_install. Maybe file a bug? The directory is #{@tmpdir}"
-    end
-    @paths = dirs
-  end # def download
-
-  def get_metadata
-    setup_py = @paths.first
-    if File.directory?(setup_py)
-      setup_py = File.join(setup_py, "setup.py")
-      @paths = [setup_py]
-    end
-
-    if !File.exists?(setup_py)
-      raise "Unable to find python package; tried #{setup_py}"
-    end
-
-    pylib = File.expand_path(File.dirname(__FILE__))
-    setup_cmd = "env PYTHONPATH=#{pylib} #{self[:settings][:python]} #{setup_py} --command-packages=pyfpm get_metadata"
-    output = ::Dir.chdir(File.dirname(setup_py)) { `#{setup_cmd}` }
-    puts output
-    metadata = JSON.parse(output[/\{.*\}/msx])
-    #p metadata
-
-    if self[:settings][:package_prefix]
-      self[:package_prefix] = self[:settings][:package_prefix]
-    else
-      self[:package_prefix] = "python"
-    end
-
-    self[:architecture] = metadata["architecture"]
-    self[:description] = metadata["description"]
-    self[:license] = metadata["license"]
-    self[:version] = metadata["version"]
-    self[:name] = "#{self[:package_prefix]}#{self[:suffix]}-#{metadata["name"]}"
-    self[:url] = metadata["url"]
-
-    self[:dependencies] = metadata["dependencies"].collect do |dep|
-      name, cmp, version = dep.split
-      "#{self[:package_prefix]}#{self[:suffix]}-#{name} #{cmp} #{version}"
-    end
-  end # def get_metadata
-
-  def make_tarball!(tar_path, builddir)
-    setup_py = @paths.first
-    dir = File.dirname(setup_py)
-
-    # Some setup.py's assume $PWD == current directory of setup.py, so let's
-    # chdir first.
-    ::Dir.chdir(dir) do
-      safesystem(self[:settings][:python], "setup.py", "bdist")
-    end
-
-    dist_tar = ::Dir.glob(File.join(dir, "dist", "*.tar.gz")).first
-    puts "Found dist tar: #{dist_tar}"
-    puts "Copying to #{tar_path}"
-
-    @paths = [ "." ]
-
-    safesystem("cp", dist_tar, "#{tar_path}.gz")
-  end # def make_tarball!
-
-  def garbage
-    trash = []
-    trash << @tmpdir if @tmpdir
-    return trash
-  end # def garbage
-
-end # class FPM::Source::Gem