purplepkg 0.0.3

data/bin/install_ruby

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+if [ -z "$1" ]; then
+    echo "Usage: $0 ruby-<version>.tar.gz"
+    exit 1
+fi
+
+if [ ! -f "$1" ]; then
+    echo "File does not exist: $1"
+    exit 1
+fi
+
+if [ ! -f 'purple.gemspec' ]; then
+    echo "Please only run this script from purple source directory."
+    exit 1
+fi
+
+rm -f install_ruby.log
+export TARBALL=$1
+export PURPLE_TOPDIR=`pwd`
+
+function system() {
+    echo -n "$1" >&2
+    shift
+    $* >> $PURPLE_TOPDIR/install_ruby.log 2>&1
+    STATUS=$?
+    echo >&2
+    if [ 0 -ne $STATUS ]; then
+        echo "Error ocurred. Please check install_ruby.log."
+    fi
+}
+
+# Determine ruby topdir
+export RUBY_TOPDIR=/tmp/`tar tzf "$TARBALL" | head -1`
+
+# Extract source
+system "Extracting source..." tar -C /tmp xzf $TARBALL
+
+cd $RUBY_TOPDIR
+
+# Compile ruby
+system "Configuring..." ./configure
+system "Building..." make
+
+# Run purple to stage ruby package
+$RUBY_TOPDIR/miniruby -I lib -I "$RUBY_TOPDIR"/lib bin/purple -i $TARBALL
+
+# Clean /tmp
+rm -fr "$RUBY_TOPDIR"

data/bin/purple

@@ -0,0 +1,141 @@
+#!/usr/bin/ruby -w
+
+require 'uri'
+require 'uri/http'
+require 'getoptlong'
+
+require 'purple'
+
+def usage
+    puts <<-EOS
+Purple Packager, Copyright (c) 2004, Simon Conrad-Armes <curne@curnomatic.dk>
+Rights granted, under GNU GPL (version 2 or later), see file LICENSE
+
+Usage: #{File.basename $0} [options] <package>
+
+Options:
+    --make              Make a package from the staged install.
+    -m
+    --deploy            Deploy the built package. Implies --make.
+    -i
+    --skip-to=step      Skip to the given step [prepare].
+    --stop-at=step      Stop after given step is complete [build].
+    --manual            Print the manual page for Purple Package.
+
+    The arguments given to --skip-to and --stop-at must be one of 
+    'prepare', 'build', 'stage', or 'deps'.
+
+<package>
+    The package argument may be a url or path to a local file path. The file 
+    ending determines how it is handled:
+        .tar.gz         Source Tarball assumed. A purple spec is created 
+                        inferring the name and version from the filename.
+        .purple         Purple spec script. Contains references to source and
+                        build instructions.
+        .purple-src     Purple source package. Contains source files and build
+                        instructions.
+        .purple-bin     Purple binary package. 
+
+EOS
+    exit 1 
+end
+
+def filetype url
+    filename = File.basename(URI.parse(url).path)
+    return case filename
+    when /\.tar\.(gz|bz2)|\.tgz$/
+        :tarball
+    when /\.purple$/
+        :script
+    end
+end
+
+ALL_STEPS = { :prepare => 0, :build => 2, :stage => 4, :deps => 6 }
+
+
+usage if 0 == ARGV.size
+
+opts = GetoptLong.new
+opts.set_options(
+    [ '--help', GetoptLong::OPTIONAL_ARGUMENT],
+    [ '--make', '-m', GetoptLong::NO_ARGUMENT],
+    [ '--deploy', '-i', GetoptLong::NO_ARGUMENT],
+    [ '--skip-to', GetoptLong::REQUIRED_ARGUMENT],
+    [ '--stop-at', GetoptLong::REQUIRED_ARGUMENT],
+    [ '--manual', GetoptLong::REQUIRED_ARGUMENT]
+)
+
+OPTIONS = Hash.new
+opts.each_option { |name,arg| OPTIONS[name.gsub(/^--/, '')] = arg }
+p OPTIONS
+
+usage if OPTIONS.has_key? 'help'
+
+steps = [:prepare, :config, :build, :stage]
+
+if OPTIONS.has_key? 'make' or 'deps' == OPTIONS['stop-at']
+    steps << :deps
+end
+
+if OPTIONS.has_key? 'skip-to'
+    if 'make' == OPTIONS['skip-to']
+        first = steps.size
+    else
+        first = steps.index OPTIONS['skip-to'].intern 
+    end
+else
+    first = 0
+end
+
+if OPTIONS.has_key? 'stop-at'
+    last = steps.index OPTIONS['stop-at'].intern 
+else
+    last  = steps.size - 1
+end
+
+steps = steps[first..last]
+
+
+# Convert local paths to urls
+arg_ref = ARGV[0]
+arg_uri = URI.parse(arg_ref)
+if not arg_uri.scheme 
+    arg_uri.scheme = 'file'
+    arg_uri.path = File.join(Dir.pwd, arg_uri.path) if arg_uri.path !~ %r"^/"
+end
+arg_ref = arg_uri.to_s
+
+# Decide what to do with the argument
+puts "DEBUG main: #{filetype(arg_ref).inspect}"
+case filetype(arg_ref)
+when :tarball
+    @cabinet = Purple.cabinet_from_url arg_ref
+when :script
+    @cabinet = Purple::Script.open URI.parse(arg_ref).path
+else
+    raise "Unknown file type of argument '#{arg_ref}'"
+end
+p @cabinet
+
+error = catch :stop do
+    @cabinet.setup
+
+    @cabinet.run_steps steps
+
+    if OPTIONS.has_key? 'make' or OPTIONS.has_key? 'deploy'
+	Purple::Platform.detect
+        @cabinet.make
+    end
+
+    if OPTIONS.has_key? 'deploy'
+        puts "DEBUG: Doing deploy"
+        @cabinet.deploy
+    end
+
+    :normal_complete
+end
+
+if :normal_complete != error
+    STDERR.puts "An error condition was encountered and forced a stop."
+    STDERR.puts "Reason: #{error}" if error
+end

data/lib/purple/getter.rb

@@ -0,0 +1,34 @@
+require 'uri'
+
+module Purple
+    module Getter
+        def self.new url, destdir
+            puts "DEBUG Getter##new: url=#{url}"
+            @uri = URI.parse url
+            plugin = case @uri.scheme
+                when /http|ftp/
+                    'wget'
+                when 'file'
+                    'cp'
+                else
+                    raise StandardError.new("Unable to handle scheme #{@uri.scheme}")
+                end
+            require "purple/getter_#{plugin}"
+            (eval "Purple::Getter::Getter_#{plugin}").new @uri, destdir
+        end
+
+        class Generic
+            # -> anIO
+            def initialize uri, destdir
+                self.uri = uri
+                @status = 'Getting'
+                @destdir = destdir
+            end
+            attr_accessor :uri, :length, :content_type
+            attr_reader :thread
+
+            # def get -> nil
+            # def get_status -> anArray [status, %done]
+        end
+    end
+end

data/lib/purple/getter_cp.rb

@@ -0,0 +1,22 @@
+require 'open3'
+
+module Purple
+    module Getter
+        class Getter_cp < Generic
+            def get
+                if system "ln '#{@uri.path}' '#{@destdir}/'"
+                    @done = '100'
+                    @status = 'Done'
+                else
+                    @done = '100'
+                    @status = 'Error'
+                end
+            end
+
+            def get_status
+                [@status, @done]
+            end
+
+        end
+    end
+end

data/lib/purple/getter_wget.rb

@@ -0,0 +1,105 @@
+require 'open3'
+
+module Purple
+    module Getter
+        class Getter_wget < Generic
+            def initialize *args
+                super
+                @done = "0"
+            end
+
+            def get
+                @thread = Thread.new do
+                    filename = File.basename uri.path
+                    Open3.popen3 "wget --progress dot -O '#{@destdir}/#{filename}' #{@uri.to_s} 2>&1" do
+                        |pw, pr, pe|
+                        parse_input pw, pr, pe
+                    end
+                end
+            end
+
+            def get_status
+                [@status, @done]
+            end
+
+            # wget specific methods
+
+            def parse_input pw, pr, pe
+                #puts "DEBUG Getter_wget#parse_input: Start"
+
+                loop do
+                    # Start line
+                    2.times { pr.gets }
+
+                    # Host lookup
+                    #puts "DEBUG Getter_wget#parse_input: Host lookup"
+                    line = pr.gets
+                    #puts "->#{line}"
+                    if line =~ /failed:/
+                        @status = 'Host lookup failed'
+                        return
+                    end
+
+                    # Connecting
+                    #puts "DEBUG Getter_wget#parse_input: Connecting"
+                    line = pr.gets
+                    #puts "->#{line}"
+                    md = /^Connecting to (.*?)... (.*?)$/.match line
+                    #puts "DEBUG Getter_wget#parse_input: md[2]=#{md[2].inspect}"
+
+                    unless 'connected.' == md[2]
+                        @status = 'Connection failed'
+                        return
+                    end
+
+                    # Request
+                    #puts "DEBUG Getter_wget#parse_input: Sending request"
+                    line = pr.gets
+                    #puts "->#{line}"
+                    md = /HTTP request sent, awaiting response... (.*)/.match line
+                    case md[1]
+                    when '200 OK'
+                        # Okay. Continue
+                    when /^3\d{2}/
+                        # Redirection
+                        pr.gets # Location line
+                        redo
+                    else
+                        @status = md[1]
+                        return
+                    end
+
+                    break
+                end
+
+                # Content details
+                line = pr.gets
+                #puts "->#{line}"
+                md = /Length: (.*?) \[(.*?)\]/.match line
+                @length = md[1].gsub(',', '').to_i
+                @content_type = md[2]
+
+                # Empty line
+                pr.gets
+
+                # Data incoming
+                pr.each do |line|
+                    #puts "->#{line}"
+                         
+                    md = / *([0-9]+)K[ \.]+([0-9]+)% +([0-9\.,]+ KB\/s)/.match line
+                    #puts (md ? "DEBUG #{md.to_a.inspect}" : "DEBUG nil")
+                    if md
+                        @done = md[2]
+                        @rate = md[3]
+                        next
+                    end
+
+                    if "100" == @done
+                        @status = "Done"
+                    end
+                    pr.read
+                end
+            end
+        end
+    end
+end

data/lib/purple/makefile.rb

@@ -0,0 +1,59 @@
+
+module Purple
+
+    # Makefile aware predicate container. Initialize with path 
+    # to source directory.
+    class MakefileMaven
+        def initialize srcdir
+            @srcdir = srcdir
+        end
+
+        def has_makefile?
+            makefilename && true
+        end
+
+        def makefilename
+            return @makefilename if defined? @makefilename
+            @makefilename = ['GNUmakefile', 'makefile', 'Makefile'].find do |name|
+                puts "DEBUG MakefileMaven#makefilename: testing #{File.join(@srcdir, name)}"
+                FileTest.exist? File.join(@srcdir, name)
+            end
+        end
+
+        def uses_prefix?
+            return true if makefile_rules.grep(/^prefix/).size > 0
+            false
+        end
+
+        def uses_destdir?
+            return true if makefile_rules.grep(/DESTDIR/).size > 0
+            false
+        end
+
+        def makefile_rules
+            return @rules if defined? @rules
+            @rules = `make -pn -C #{@srcdir}`
+        end
+
+        def makefile_contents
+            return @contents if defined? @contents
+
+            @contents = ''
+            files = [makefilename];
+            while files.size > 0
+                filename = File.join(@srcdir, files.shift)
+                if FileTest.exist? filename
+                    puts "DEBUG MakefileMaven#makefile_contents: loop->if"
+                    text = File.open(filename) { |f| f.read }
+                    @contents << text
+                    text.grep(/^include /).each do |s|
+                        md = /^include (.*?)\n$/.match s
+                        files << md[1]
+                    end
+                end
+            end
+            puts "DEBUG MakefileMaven#makefile_contents: #{@contents.to_a.size} lines"
+            @contents
+        end
+    end
+end

data/lib/purple/matches.rb

@@ -0,0 +1,20 @@
+
+module Purple
+
+    module Matches
+        EXTENSIONS = '(\.tar\.gz|\.tar\.bz2|\.tgz|\.zip)'
+        REGEXPS = [
+            /^(.+)-((\d+)(\.\d+)*(-?\w+)?)#{EXTENSIONS}$/,
+            /^(.+)\.([^\.]+?)#{EXTENSIONS}$/,
+        ];
+        
+        def self.match_filename filename
+            md = nil
+            REGEXPS.find { |r| md = r.match filename }
+            #puts "DEBUG Matches#match_filename: filename=#{filename.inspect} md=#{md.to_a.inspect}"
+            raise 'filename does not match pattern' if not (md and not md.to_a[0..1].include? nil)
+
+            { :name => md[1], :version => md[2] } 
+        end
+    end
+end

data/lib/purple/osx.rb

@@ -0,0 +1,117 @@
+
+module Purple
+
+PACKAGE_DESCRIPTION_TEMPLATE = proc do |pkg| <<EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IFPkgDescriptionTitle</key>
+	<string>#{pkg.name}</string>
+	<key>IFPkgDescriptionVersion</key>
+	<string>#{pkg.version}</string>
+</dict>
+</plist>
+EOS
+end
+
+
+PACKAGE_INFO_TEMPLATE = proc do |pkg| <<EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <!--
+    <key></key>
+    <string></string>
+    ***
+    -->
+    <key>CFBundleGetInfoString</key>
+    <string>#{pkg.info_string}</string>
+    <key>CFBundleIdentifier</key>
+    <string>#{pkg.identifier}</string>
+    <key>CFBundleName</key>
+    <string>#{pkg.name}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>#{pkg.version}</string>
+    <key>IFMajorVersion</key>
+    <integer>#{pkg.major}</integer>
+    <key>IFMinorVersion</key>
+    <integer>#{pkg.minor}</integer>
+    <key>IFPkgFlagAllowBackRev</key>
+    <false/>
+    <key>IFPkgFlagAuthorizationAction</key>
+    <string>AdminAuthorization</string>
+    <key>IFPkgFlagDefaultLocation</key>
+    <string>/</string>
+    <key>IFPkgFlagInstallFat</key>
+    <false/>
+    <key>IFPkgFlagIsRequired</key>
+    <false/>
+    <key>IFPkgFlagOverwritePermissions</key>
+    <true/>
+    <key>IFPkgFlagRelocatable</key>
+    <false/>
+    <key>IFPkgFlagRestartAction</key>
+    <string>NoRestart</string>
+    <key>IFPkgFlagRootVolumeOnly</key>
+    <true/>
+    <key>IFPkgFlagUpdateInstalledLanguages</key>
+    <false/>
+    <key>IFPkgFlagUseUserMask</key>
+    <false/>
+    <key>IFPkgFormatVersion</key>
+    <real>0.10000000149011612</real>
+</dict>
+</plist>
+EOS
+end
+
+    class PackageInfo
+        def info_string; long_name; end
+    end
+
+    class PurpleCabinet
+        def osx_stage
+            assert_dir "#{@cabinet_dir}"
+            assert_dir "#{@cabinet_dir}/OsxStage"
+            assert_dir File.join(@cabinet_dir, 'OsxStage')
+        end
+
+        def make
+            packages.each do |pkg|
+                system "rm -r '#{osx_stage}'"
+                File.open "#{osx_stage}/Description.plist", "w" do |f|
+                    f.puts pkg.description
+                end
+
+                Dir.mkdir "#{osx_stage}/Resources"
+                File.open "#{osx_stage}/Resources/Welcome.txt", "w" do |f|
+                    f.print <<-EOS
+Hello, World!
+                    EOS
+                end
+
+                File.open "#{osx_stage}/Info.plist", "w" do |f|
+                    f.print PACKAGE_INFO_TEMPLATE.call(pkg)
+                end
+
+                File.open "#{osx_stage}/Description.plist", "w" do |f|
+                    f.print PACKAGE_DESCRIPTION_TEMPLATE.call(pkg)
+                end
+
+                system "/Developer/Applications/Utilities/PackageMaker.app/Contents/MacOS/PackageMaker " + 
+                    "-build -p '#{packagedir}/#{pkg.name}.pkg' -f '#{pkg.stage_root}' -r '#{osx_stage}/Resources' " +
+                    "-d '#{osx_stage}/Description.plist' -i '#{osx_stage}/Info.plist'"
+            end
+        end
+
+
+        def deploy
+            packages.each do |pkg|
+                system "open '#{File.join packagedir, pkg.name}.pkg'"
+            end
+        end
+    end
+
+end

data/lib/purple/pkg_actions.rb

@@ -0,0 +1,95 @@
+
+module Purple
+    module PackageActions
+
+        attr_accessor :cabinet
+
+        def self.package_method name
+            prg = <<-EOS
+                def #{name}
+                    if defined? @method_#{name}_package and @method_#{name}_package
+                        return @method_#{name}_package.call(self)
+                    else
+                        m = self.method "default_#{name}"
+                        return(m.call) if m
+                    end
+                end
+                def #{name}= prc
+                    @method_#{name}_package = prc
+                end
+            EOS
+            #puts prg
+            module_eval prg
+        end
+
+        def srcdir
+            return @srcdir if defined? @srcdir
+            dirs = Dir.new(cabinet.srcdir).reject { |s| s =~ /^\.{1,2}$/ }
+            if 1 == dirs.size
+                @srcdir = "#{cabinet.srcdir}/#{dirs[0]}"
+            else
+                @srcdir = Dir.new(cabinet.srcdir).find { |s| s =~ Regexp.new('^' + Regexp.escape(name)) }
+            end
+            throw :stop, "Unable to determine source directory for package #{name}" if not @srcdir
+            puts "Choosing #{@srcdir} as source code folder"
+            @srcdir
+        end
+
+        def stage_root
+            File.join cabinet.stage_root, long_name
+        end
+
+        package_method :prepare
+        package_method :config
+        package_method :build
+        package_method :stage
+        package_method :make
+
+        def default_prepare
+            puts "DEBUG PackageActions#default_prepare"
+            files.each do |f|
+                unpack = case f
+                    when /gz$/; '-z'
+                    when /bz2$/; '-j'
+                    else ''
+                end
+                if not Purple.sys "tar x #{unpack} -C '#{cabinet.srcdir}' -f #{cabinet.filesdir}/#{f}"
+                    throw :stop
+                end
+            end
+
+        end
+
+        def default_config
+           throw :stop unless system "cd #{srcdir}; ./configure --prefix=/usr"
+        end
+
+        def default_build
+           throw :stop unless system "make -C '#{srcdir}'"
+        end
+
+        def default_stage
+            system "rm -fr '#{stage_root}/*'"
+
+            require 'purple/makefile'
+
+            puts "DEBUG PackageActions#default_stage: srcdir=#{srcdir}"
+            mkm = MakefileMaven.new srcdir
+            if mkm.uses_prefix?
+                if mkm.uses_destdir?
+                    make_args = "DESTDIR='#{stage_root}'"
+                else
+                    make_args = "prefix='#{stage_root}/usr'"
+                end
+            else
+                if mkm.uses_destdir?
+                    make_args = "DESTDIR='#{stage_root}'"
+                else
+                    raise 'Unable to find a way to stage! Package neither defines prefix or DESTDIR'
+                end
+            end
+               
+            throw :stop if not system "make -C '#{srcdir}' #{make_args} install"
+        end
+    end
+end

data/lib/purple/platform.rb

@@ -0,0 +1,15 @@
+
+module Purple
+    module Platform
+        def self.detect
+            case true
+            when FileTest.exist?('/etc/debian_version')
+                system_brand = :debian
+            when (FileTest.directory?('/System/Library/') and FileTest.file?('/mach_kernel'))
+                system_brand = :osx
+            end
+
+            require "purple/#{system_brand}"
+        end
+    end
+end

data/lib/purple/script.rb

@@ -0,0 +1,172 @@
+require 'singleton'
+require 'uri'
+require 'purple'
+
+
+PURPLE_SCRIPT_TEMPLATE = proc do |cabinet| <<EOS
+# Autogenerated Purple Packaging script.
+# Cabinet name: '#{cabinet.name}'
+
+name #{cabinet.name.inspect}
+long_name #{cabinet.long_name.inspect}
+
+#{ cabinet.urls.collect { |k,v| "url #{v.inspect}\n" } }
+
+#{
+   cabinet.packages.collect { |pkg| PURPLE_PACKAGE_TEMPLATE.call pkg }
+}
+EOS
+end
+
+PURPLE_PACKAGE_TEMPLATE = proc do |pkg| <<EOS
+package(#{pkg.name.inspect}) { |p|
+#{pkg.files.collect{ |s| "    p.file #{s.inspect}" }.join("\n") }
+    p.long_name #{pkg.long_name.inspect}
+    p.identifier #{pkg.identifier.inspect}
+    p.version #{pkg.version.inspect}
+    p.major #{pkg.major}
+    p.minor #{pkg.minor}
+
+    # Uncomment and modify for special configuration
+    #p.config proc { |pkg|
+    #    throw :stop unless system "cd \#{pkg.srcdir}; ./configure --prefix=/usr"
+    #}
+
+}
+EOS
+end
+
+module Purple
+    class Script
+        def self.open filename
+            parse File.open(filename).read
+        end
+
+        def self.parse string
+            script = self.new
+            script.instance_eval string
+            puts "DEBUG Purple::Script##parse: cabinet=#{script.cabinet}"
+            script.cabinet
+        end
+
+        def initialize
+            @cabinet = PurpleCabinet.new
+            @package_scripts = Array.new
+        end
+        attr_reader :cabinet
+
+        def name name
+            @cabinet.name = name
+        end
+
+        def long_name name
+            @cabinet.long_name = name
+        end
+
+        def url url
+            @cabinet.add_url url
+        end
+
+        def package name=nil
+            puts "> #package(#{name.inspect})"
+            package = PackageScript.new @cabinet
+            @package_scripts << package
+            package.name name
+            yield package if block_given?
+        end
+
+        def infer
+            if not @cabinet.long_name
+                @cabinet.long_name = @cabinet.packages[0].long_name
+            end
+            if not @cabinet.name
+                @cabinet.name = @cabinet.packages[0].name
+            end
+        end
+
+        def infer_all
+            @package_scripts.each { |pkg|
+                puts "DEBUG PurpleScript#infer_all"
+                pkg.infer
+            }
+            puts "DEBUG PurpleScript#infer_all: b4end"
+            infer
+        end
+
+        def self.write cabinet, filename
+            File.open filename, 'w' do |f|
+                f.write dump(cabinet)
+            end
+        end
+        def self.dump cabinet
+            PURPLE_SCRIPT_TEMPLATE.call cabinet
+        end
+
+        class PackageScript
+            def self.callthrough (*ss)
+                ss.each do |s|
+                    module_eval <<-EOS
+                        def #{s} value
+                            @package.#{s} = value
+                        end
+                    EOS
+                end
+            end
+
+            def initialize cabinet
+                @package = cabinet.create_package
+                @cabinet = cabinet
+                puts "DEBUG PackageScript#initialize: @package=#{@package}"
+            end
+
+            callthrough :long_name, :name, :identifier, :version, :major, :minor
+            callthrough :prepare, :config, :build, :stage, :make
+
+            def pkg
+                @package
+            end
+
+            def file filename
+                pkg.files << filename
+            end
+
+            def infer
+                puts "DEBUG #infer"
+                puts "DEBUG PackageScript#infer: pkg=#{pkg}"
+                # Take a guess at the filename
+                if 0 == pkg.files.size
+                    files = @cabinet.files
+                    puts "DEBUG #infer: cabinet_files=#{files.inspect}"
+                    if 0 == files.size
+                        warn 'Cabinet files section is empty. Did you not specify any urls?'
+                    else
+                        if pkg.long_name
+                            # See if any filenames match the long name
+                            rs =  files.grep Regexp.new(Regexp.escape(pkg.long_name))
+                            file rs[0] if 1 == rs.size
+                        else
+                            # Else just guess that the first file is the right one
+                            file files[0]
+                        end
+                    end
+                end
+
+                #puts "DEBUG #infer: pkg.files=#{pkg.files.inspect}"
+                #puts "DEBUG #infer: long_name=#{pkg.long_name}"
+                # Take a guess at properties long_name, name, version, major, and minor
+                md = Matches.match_filename pkg.files[0]
+                puts "DEBUG #infer: filename match result  #{md.inspect}"
+
+                pkg.long_name = "#{md[:name]}-#{md[:version]}" if not pkg.long_name
+                pkg.name = md[:name] if not pkg.name
+                pkg.version = md[:version] if not pkg.version
+
+                md = /^([0-9]+)\.([0-9]+).*/.match pkg.version
+                pkg.major = md[1] if md and not pkg.major
+                pkg.minor = md[2] if md and not pkg.minor
+                
+            end
+        end
+
+    end
+end

data/lib/purple.rb

@@ -0,0 +1,221 @@
+require 'singleton'
+require 'fileutils'
+
+module Purple
+    autoload :PackageActions, 'purple/pkg_actions'
+    autoload :Getter, 'purple/getter'
+    autoload :Script, 'purple/script'
+    autoload :Matches, 'purple/matches'
+    autoload :Platform, 'purple/platform'
+    PURPLE_FOLDER = "#{ENV['HOME']}/purple"
+
+
+    class PurpleCabinet
+        def initialize
+            @packages = Array.new
+            @urls = Hash.new
+            @files = Array.new
+        end
+        attr_accessor :name, :long_name
+        attr_reader :urls, :files, :packages, :cabinet_dir
+
+        # -> aString # Get source dir
+        def filesdir
+            assert_dir File.join(@cabinet_dir, 'Files')
+        end
+
+        def srcdir
+            assert_dir File.join(@cabinet_dir, 'Source')
+        end
+
+        def stage_root
+            assert_dir File.join(@cabinet_dir, 'StageRoot')
+        end
+
+        def packagedir
+            assert_dir File.join(@cabinet_dir, 'Package')
+        end
+
+        def fetch_all
+            urls.each do |url|
+                Getter.get url, filesdir
+            end
+        end
+
+        def add_url url
+            filename = File.basename URI.parse(url).path
+            @urls[filename] = url
+            @files << filename
+        end
+
+        def setup
+            raise 'cabinet long_name not properly set' if not long_name
+            @cabinet_dir = File.join(PURPLE_FOLDER, long_name)
+            assert_dir @cabinet_dir
+        end
+
+        def fetch filename
+            if not FileTest.exist? "#{filesdir}/#{filename}"
+                g = Getter.new urls[filename], filesdir 
+                g.get
+                status = 'Getting'
+                loop do
+                    status, done = *(g.get_status)
+                    printf "\015\033[MFetching %-40s %3d%%  %s", filename,  done, status
+                    $defout.flush
+                    sleep 1
+                    break if 'Getting' != status
+                end
+                puts
+                throw :stop, "There was an error while fetching file #{filename}" unless 'Done' == status 
+            end
+        end
+
+        def prepare
+            @packages.each do |p|
+                p.files.each { |f| fetch f }
+                p.prepare
+            end
+        end
+
+        def config
+            @packages.each { |p|
+                return false if not p.config
+            }
+        end
+        
+        def build
+            @packages.each { |p|
+                return false if not p.build
+            }
+        end
+        
+        def stage
+            @packages.each { |p|
+                return false if not p.stage
+            }
+        end
+
+        def deps
+            true
+        end
+
+        def run_steps steps=[:prepare, :build, :deps, :make]
+            steps.each do |step|
+                self.method(step).call
+            end
+        end
+
+        ## ##
+
+        def create_package
+            p = PackageInfo.new
+            class <<p
+                include PackageActions
+            end
+            p.cabinet = self
+            @packages << p
+            @packages.last
+        end
+        
+        ## ##
+
+        def assert_dir path
+            unless FileTest.exist? path
+                puts ">- Creating folder #{path}"
+                Dir.mkdir path 
+            end
+            (FileTest.directory? path) ? path : nil
+        end
+        
+    end
+
+    class PackageInfo
+        def initialize
+            @files = []
+        end
+        attr_accessor :long_name, :name, :version, :major, :minor, :identifier, :description
+        attr_reader :files
+    end
+
+    class PurpleFile
+        def self.parse str
+            pkg = PackageInfo.new
+            receiver_stack = ['main']
+            str.split(/(\r\n|\r|\n)+/).each do |line|
+                r = self.method("__#{receiver_stack.last}").call line.strip, pkg
+                case r
+                when -1
+                    receiver_stack.pop
+                when nil
+                else
+                    receiver_stack.push r
+                end
+            end
+            pkg
+        end
+
+        def self.__main line, pkg
+            case line
+            when /^package/
+                pkg.name = line.gsub(/^package\s+/, '')
+                return 'package'
+            end
+        end
+
+        PROPS = 'longname|version|major|minor|identifier|description|url'
+        def self.__package line, pkg
+            if (md = Regexp.new("^(#{PROPS})\s+(.*)$").match line)
+                pkg.method("#{md[1]}=").call md[2]
+            else
+                self.infer_properties pkg if line == 'infer'
+            end
+            nil
+        end
+
+        def self.infer_properties pkg
+            if pkg.url
+                if pkg.url =~ /prdownloads.sourceforge.net/
+                    md = Regexp.new 'http://prdownloads.sourceforge.net/([^/])/(.*?)tar.(gz|bz2)?download'
+                    pkg.long_name = md[2]
+                end
+            end
+
+            pkg.long_name = File.basename Dir.pwd if not pkg.long_name
+
+            md = /([a-z\-]+)-([0-9\-\.]+.*)/.match pkg.long_name
+            pkg.version = md[2] if not pkg.version
+
+            md = /^([0-9]+)\.([0-9]+)/.match pkg.version
+            pkg.major = md[1] if not pkg.major
+            pkg.minor = md[2] if not pkg.minor
+
+        end
+    end
+
+    def self.cabinet_from_url url
+
+        cabinet = Purple::Script.parse(<<-EOS
+            url #{url.inspect}
+            package # {|pkg| pkg.infer }
+            infer_all
+        EOS
+        )
+        cabinet.setup
+        Purple::Script.write cabinet, File.join(cabinet.cabinet_dir, cabinet.name + '.purple')
+        cabinet
+    end
+
+    def self.sys cmd
+        system cmd
+    end
+
+end
+
+module Kernel
+    alias_method :_system_, :system
+    def system(*args)
+        puts "> #{args.join " "}"
+        _system_(*args)
+    end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: purplepkg
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+date: 2004-11-12
+summary: A simple pre-packing tool with meta-package plugin support.
+require_paths: 
+  - lib
+author: Simon Conrad-Armes
+email: curne@curnomatic.dk
+homepage: purplepkg.rubyforge.org
+rubyforge_project: purple
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib/purple
+  - lib/purple.rb
+  - lib/purple/matches.rb
+  - lib/purple/getter_cp.rb
+  - lib/purple/getter_wget.rb
+  - lib/purple/osx.rb
+  - lib/purple/pkg_actions.rb
+  - lib/purple/script.rb
+  - lib/purple/makefile.rb
+  - lib/purple/getter.rb
+  - lib/purple/platform.rb
+  - bin/purple
+  - bin/install_ruby
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: 
+  - purple
+extensions: []
+requirements: []
+dependencies: []