fpm 0.1.4 → 0.1.5

data/bin/fpm

@@ -5,6 +5,8 @@ require "rubygems"
 require "optparse"
 require "ostruct"
 require "erb"
+
+$: << "#{File.dirname(__FILE__)}/../lib"
 require "fpm"
 
 def main(args)
@@ -49,29 +51,23 @@ def main(args)
     opts.on("-C DIRECTORY", "Change directory before searching for files") do |dir|
       settings.chdir = dir
     end
-  end # OptionParser
 
-  opts.parse!(args)
+    opts.on("-t PACKAGE_TYPE", "the type of package you want to create") do |type|
+      settings.package_type = type
+    end
 
-  if !settings.package_path
-    $stderr.puts "No package file given to manage. Give with -p PACKAGEFILE"
-    return 1
-  end
+    opts.on("-s SOURCE_TYPE", "what to build the package from") do |st|
+      settings.source_type = st
+    end
+  end # OptionParser
 
-  package = FPM::Deb.new
-  package.name = settings.package_name
-  package.version = settings.version
-  package.maintainer = settings.maintainer if settings.maintainer
-  package.architecture = (settings.architecture or %x{uname -m}.chomp)
-  package.dependencies = (settings.dependencies or [])
+  opts.parse!(args)
 
   p settings
-  package.assemble({
-    "output" => settings.package_path,
-    "root" => settings.chdir,
-    "paths" => args, # Remainder of args are paths.
-  })
+  FPM::Builder.new(settings, args).assemble!
+
+  return 0
 end # def main
 
-ret = main(ARGV) 
+ret = main(ARGV)
 exit(ret != nil ? ret : 0)

data/lib/fpm.rb

@@ -1,3 +1,11 @@
 require "fpm/namespace"
+require "fpm/builder"
+
 require "fpm/package"
-require "fpm/deb"
+require "fpm/target/deb"
+require "fpm/target/rpm"
+
+require "fpm/source"
+require "fpm/source/dir"
+require "fpm/source/gem"
+require "fpm/source/rpm"

data/lib/fpm/builder.rb

@@ -0,0 +1,133 @@
+require 'fileutils'
+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.start_with? '/'
+        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=[])
+    @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,
+      :name => settings.package_name
+    )
+
+    @package = package_class_for(settings.package_type).new(@source)
+    @paths = paths
+
+    @output = settings.package_path
+  end # def initialize
+
+  def tar_path
+    @tar_path ||= "#{builddir}/data.tar"
+  end
+
+  # Assemble the package
+  def assemble!
+    output.gsub!(/VERSION/, "#{@source[:version]}-#{@source[:iteration]}")
+    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)
+
+      generate_md5sums
+      generate_specfile
+    end
+
+    ::Dir.chdir(builddir) do
+      @package.build!({
+        :tarball => tar_path,
+        :output => output
+      })
+    end
+
+    cleanup!
+  end # def assemble!
+
+private
+  def builddir
+    @builddir ||= File.expand_path(
+      "#{Dir.pwd}/build-#{@package.type}-#{File.basename(output)}"
+    )
+  end
+
+  def make_builddir!
+    FileUtils.rm_rf builddir
+    garbage << builddir
+    FileUtils.mkdir(builddir) if !File.directory?(builddir)
+  end
+
+  # TODO: [Jay] make this better.
+  def package_class_for(type)
+    type = FPM::Target::constants.find { |c| c.downcase == type }
+    if !type
+      raise ArgumentError, "unknown package type #{type.inspect}"
+    end
+
+    return FPM::Target.const_get(type)
+  end
+
+  # TODO: [Jay] make this better.
+  def source_class_for(type)
+    type = FPM::Source::constants.find { |c| c.downcase == type }
+    if !type
+      raise ArgumentError, "unknown package type #{type.inspect}"
+    end
+
+    return FPM::Source.const_get(type)
+  end
+
+  def cleanup!
+    return [] if garbage.empty?
+    FileUtils.rm_rf(garbage) && garbage.clear
+  end
+
+  def generate_specfile
+    File.open(@package.specfile(builddir), "w") do |f|
+      f.puts @package.render_spec
+    end
+  end
+
+  def generate_md5sums
+    md5sums = checksum(paths)
+    File.open("#{builddir}/md5sums", "w") { |f| f.puts md5sums }
+    md5sums
+  end
+
+  def checksum(paths)
+    md5sums = []
+    paths.each do |path|
+      md5sums += %x{find #{path} -type f -print0 | xargs -0 md5sum}.split("\n")
+    end
+  end # def checksum
+
+
+end

data/lib/fpm/namespace.rb

@@ -1 +1,13 @@
-module FPM; end
+module FPM
+  module Target; end # TODO(sissel): Make this the 'package' ?
+  DIRS = {
+    :templates => File.expand_path(
+      File.join(
+        File.dirname(__FILE__),
+        '..',
+        '..',
+        'templates'
+      )
+    )
+  }
+end

data/lib/fpm/package.rb

@@ -37,31 +37,56 @@ class FPM::Package
 
   # Array of dependencies.
   attr_accessor :dependencies
+
+  # a summary or description of the package
+  attr_accessor :summary
   
-  def initialize
-    @iteration = 1
-    @url = "http://nourlgiven.example.com/no/url/given"
-    @category = "default"
-    @license = "unknown"
-    @maintainer = "<#{ENV["USER"]}@#{Socket.gethostname}>"
-    @architecture = nil
-    @summary = "no summary given"
-
-    # Garbage is stuff you may want to clean up.
-    @garbage = []
+  def initialize(source)
+    @source = source
+
+    @name = source[:name] # || fail
+    @version = source[:version] # || fail
+
+    @dependencies = source[:dependencies] || []
+    @iteration = source[:iteration] || 1
+    @url = source[:url] || "http://nourlgiven.example.com/no/url/given"
+    @category = source[:category] || "default"
+    @license = source[:license] || "unknown"
+    @maintainer = source[:maintainer] || "<#{ENV["USER"]}@#{Socket.gethostname}>"
+    @architecture = source[:architecture] || %x{uname -m}.chomp
+    @summary = source[:summary] || "no summary given"
+  end
+
+  def generate_specfile(builddir, paths)
+    spec = template.result(binding)
+    File.open(specfile(builddir), "w") { |f| f.puts spec }
+  end
+
+  def generate_md5sums(builddir, paths)
+    md5sums = self.checksum(paths)
+    File.open("#{builddir}/md5sums", "w") { |f| f.puts md5sums }
+    md5sums
+  end
+
+  # TODO [Jay]: make this better...?
+  def type
+    self.class.name.split(':').last.downcase
   end
 
-  def tar(output, paths)
-    dirs = []
-    paths.each do |path|
-      while path != "/" and path != "."
-        dirs << path if !dirs.include?(path) 
-        path = File.dirname(path)
-      end
-    end # paths.each
-    dirs = dirs.sort { |a,b| a.length <=> b.length}
-    system(*["tar", "--owner=root", "--group=root", "-cf", output, "--no-recursion", *dirs])
-    system(*["tar", "--owner=root", "--group=root", "-rf", output, *paths])
+  def template
+    @template ||= begin
+      tpl = File.read(
+        "#{FPM::DIRS[:templates]}/#{type}.erb"
+      )
+      ERB.new(tpl, nil, "<>")
+    end
   end
 
+  def render_spec
+    template.result(binding)
+  end
+
+  def default_output
+    "#{name}-#{version}-#{iteration}.#{architecture}.#{type}"
+  end
 end

data/lib/fpm/source.rb

@@ -0,0 +1,88 @@
+require "fpm/namespace"
+
+# Abstract class for a "thing to build a package from"
+class FPM::Source
+  # standard package metadata
+  %w(
+    name
+    version
+    iteration
+    architecture
+    maintainer
+    category
+    url
+    summary
+  ).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_reader :root
+  def initialize(paths, root, params={})
+    @paths = paths
+    @root = root
+
+    get_source 
+    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
+    # noop by default
+  end # def get_source
+  def make_tarball!(tar_path)
+    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 = []
+    paths.each do |path|
+      while path != "/" and path != "."
+        dirs << path if !dirs.include?(path) 
+        path = File.dirname(path)
+      end
+    end # paths.each
+    system(*["tar", "-C", chdir, "--owner=root", "--group=root", 
+           "-cf", output, "--no-recursion", *dirs]) if dirs.any?
+    system(*["tar", "-C", chdir,
+           "--owner=root", "--group=root", "-rf", output, *paths])
+  end # def tar
+end

data/lib/fpm/source/dir.rb

@@ -0,0 +1,14 @@
+require "fpm/source"
+
+class FPM::Source::Dir < FPM::Source
+  def get_metadata
+    self[:name] = File.basename(File.expand_path(root))
+  end
+
+  def make_tarball!(tar_path)
+    tar(tar_path, paths)
+
+    # TODO(sissel): Make a helper method.
+    system(*["gzip", "-f", tar_path])
+  end
+end

data/lib/fpm/source/gem.rb

@@ -0,0 +1,86 @@
+require "fpm/namespace"
+require "fpm/source"
+require "rubygems/package"
+require "rubygems"
+require "fileutils"
+
+class FPM::Source::Gem < FPM::Source
+  def get_source
+    gem = @paths.first
+    looks_like_name_re = /^[A-Za-z0-9_-]+$/
+    if !File.exists?(gem) 
+      if gem =~ looks_like_name_re
+        # TODO(sissel): Use the Gem API
+        download(gem)
+      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 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})"
+    dep = ::Gem::Dependency.new gem_name, version
+    # How to handle prerelease? Some extra magic options?
+    #dep.prerelease = options[:prerelease]
+
+    specs_and_sources, errors =
+      ::Gem::SpecFetcher.fetcher.fetch_with_errors(dep, false, true, false)
+    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] = spec.send(field)
+        end
+
+        self[:name] = "rubygem-#{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'
+
+        self[:dependencies] = spec.runtime_dependencies.map do |dep|
+          reqs = dep.requirement.to_s.gsub(/,/, '')
+          "rubygem-#{dep.name} #{reqs}"
+        end
+      end # ::Gem::Package
+    end # File.open (the gem)
+  end # def get_metadata
+
+  def make_tarball!(tar_path)
+    tmpdir = "#{tar_path}.dir"
+    installdir = "#{tmpdir}/#{::Gem::dir}"
+    ::FileUtils.mkdir_p(installdir)
+    args = ["gem", "install", "--quiet", "--no-ri", "--no-rdoc",
+       "--install-dir", installdir, @paths.first]
+    system(*args)
+    tar(tar_path, ".", tmpdir)
+
+    # TODO(sissel): Make a helper method.
+    system(*["gzip", "-f", tar_path])
+  end
+
+end # class FPM::Source::Gem

data/lib/fpm/source/rpm.rb

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

data/lib/fpm/target/deb.rb

@@ -0,0 +1,31 @@
+require "erb"
+require "fpm/namespace"
+require "fpm/package"
+
+class FPM::Target::Deb < FPM::Package
+  # Debian calls x86_64 "amd64"
+  def architecture
+    if @architecture == "x86_64"
+      "amd64"
+    else
+      @architecture
+    end
+  end
+
+  def specfile(builddir)
+    "#{builddir}/control"
+  end
+
+  def build!(params)
+    # Make the control
+    system("tar -zcf control.tar.gz control md5sums")
+
+    # create debian-binary
+    File.open("debian-binary", "w") { |f| f.puts "2.0" }
+
+    # pack up the .deb
+    system("ar -qc #{params[:output]} debian-binary control.tar.gz data.tar.gz")
+
+  end # def build
+end # class FPM::Deb
+

data/lib/fpm/target/rpm.rb

@@ -0,0 +1,19 @@
+require "fpm/package"
+
+class FPM::Target::Rpm < FPM::Package
+  def specfile(builddir)
+    "#{builddir}/#{name}.spec"
+  end
+
+  def build!(params)
+    raise "No package name given. Can't assemble package" if !@name
+    Dir.mkdir("BUILD")
+    args = ["rpmbuild", "-ba", 
+           "--define", "buildroot #{Dir.pwd}/BUILD",
+           "--define", "_topdir #{Dir.pwd}",
+           "--define", "_sourcedir #{Dir.pwd}",
+           "--define", "_rpmdir #{params[:output]}",
+           "#{name}.spec"]
+    system(*args)
+  end
+end

data/templates/deb.erb

@@ -1,13 +1,13 @@
-Package: <%= @name %>
-Version: <%= @version %>-<%= @iteration %>
-Architecture: <%= @architecture %>
-Maintainer: <%= @maintainer or "<unknown>" %>
-<% if @dependencies.size > 0 %>
-Depends: <%= @dependencies.join(", ") %>
+Package: <%= name %>
+Version: <%= version %>-<%= iteration %>
+Architecture: <%= architecture %>
+Maintainer: <%= maintainer or "<unknown>" %>
+<% if dependencies.size > 0 %>
+Depends: <%= dependencies.join(", ") %>
 <% end %>
 Standards-Version: 3.9.1
-Section: <%= @category or "unknown" %> 
+Section: <%= category or "unknown" %> 
 Priority: extra
-Homepage: <%= @url or "http://nourlgiven.example.com/" %>
-Description: <%= @summary or "no summary given" %>
-  <%= @summary or "no description given"%>
+Homepage: <%= url or "http://nourlgiven.example.com/" %>
+Description: <%= summary or "no summary given" %>
+  <%= summary or "no description given"%>

data/templates/rpm.erb

@@ -0,0 +1,41 @@
+Name: <%= @name %>
+Version: <%= @version %>
+Release: <%= @iteration %>
+Summary: <%= @summary %>
+
+Group: <%= @category %>
+<%#
+TODO: [Jay] rpms require a license
+let's detect it intelligently
+%>
+License: <%= @license %> 
+Source0:  %{_sourcedir}/data.tar.gz
+BuildRoot: %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX)
+
+<% if @dependencies && !@dependencies.empty? %>
+Requires: <%= @dependencies.join(", ") %>
+<% end %>
+
+%description
+<%= @summary %>
+
+%prep
+echo "PREP"
+pwd
+tar -zvxf %SOURCE0
+
+%build
+#noop
+
+%install
+#noop
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+
+%files
+%defattr(-,root,root,-)
+<%= @source.paths.join("\n") %>
+
+%changelog

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fpm
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 1
-  - 4
-  version: 0.1.4
+  - 5
+  version: 0.1.5
 platform: ruby
 authors: 
 - Jordan Sissel
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-04 00:00:00 -08:00
+date: 2011-01-07 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,12 +42,19 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/fpm/deb.rb
+- lib/fpm/builder.rb
 - lib/fpm/namespace.rb
+- lib/fpm/source.rb
+- lib/fpm/source/dir.rb
+- lib/fpm/source/rpm.rb
+- lib/fpm/source/gem.rb
+- lib/fpm/target/deb.rb
+- lib/fpm/target/rpm.rb
 - lib/fpm/package.rb
 - lib/fpm.rb
 - bin/fpm
 - bin/fpm-npm
+- templates/rpm.erb
 - templates/deb.erb
 has_rdoc: true
 homepage: https://github.com/jordansissel/fpm

data/lib/fpm/deb.rb

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby
-#
-
-require "erb"
-require "fpm/namespace"
-require "fpm/package"
-
-class FPM::Deb < FPM::Package
-
-  # Assemble the package.
-  # params:
-  #  "root" => "/some/path"   # the 'root' of your package directory
-  #  "paths" => [ "/some/path" ...]  # paths to icnlude in this package
-  #  "output" => "foo.deb"  # what to output to.
-  #
-  # The 'output' file path will have 'VERSION' and 'ARCH' replaced with
-  # the appropriate values if if you want the filename generated.
-  def assemble(params)
-    raise "No package name given. Can't assemble package" if !@name
-
-    root = params["root"]
-    paths = params["paths"]
-    output = params["output"]
-    type = "deb" 
-
-    p self.inspect
-
-    # Debian calls x86_64 "amd64"
-    @architecture = "amd64" if @architecture == "x86_64"
-
-    output.gsub!(/VERSION/, "#{@version}-#{@iteration}")
-    output.gsub!(/ARCH/, @architecture)
-
-    builddir = "#{Dir.pwd}/build-#{type}-#{File.basename(output)}"
-    @garbage << builddir
-
-    Dir.mkdir(builddir) if !File.directory?(builddir)
-
-    Dir.chdir(root || ".") do 
-      self.tar("#{builddir}/data.tar", paths)
-      # TODO(sissel): Make a helper method.
-      system(*["gzip", "-f", "#{builddir}/data.tar"])
-
-      # Generate md5sums
-      md5sums = self.checksum(paths)
-      File.open("#{builddir}/md5sums", "w") { |f| f.puts md5sums.join("\n") }
-
-      # Generate 'control' file
-      template = File.new("#{File.dirname(__FILE__)}/../../templates/deb.erb").read()
-      control = ERB.new(template, nil, "<>").result(binding)
-      File.open("#{builddir}/control", "w") { |f| f.puts control }
-    end
-
-    # create control.tar.gz
-    Dir.chdir(builddir) do
-      # Make the control
-      system("tar -zcf control.tar.gz control md5sums")
-     
-      # create debian-binary
-      File.open("debian-binary", "w") { |f| f.puts "2.0" }
-
-      # pack up the .deb
-      system("ar -qc #{output} debian-binary control.tar.gz data.tar.gz")
-    end
-  end  # def assemble
-
-  def checksum(paths)
-    md5sums = []
-    paths.each do |path|
-      md5sums += %x{find #{path} -type f -print0 | xargs -0 md5sum}.split("\n")
-    end
-  end # def checksum
-end # class FPM::Deb
-