crate 0.1.1

data/data/recipes/openssl/openssl.rake

@@ -0,0 +1,20 @@
+#
+# Crate recipe for openssl
+#
+Crate::Dependency.new("openssl", "0.9.8i") do |t|
+  t.depends_on( "zlib" )
+  t.upstream_source  = "http://www.openssl.org/source/openssl-0.9.8i.tar.gz"
+  t.upstream_sha1    = "b2e029cfb68bf32eae997d60317a40945db5a65f"
+
+  t.build_commands = [
+    "./config --prefix=#{File.join( '/', 'usr' )} zlib no-threads no-shared",
+    "make"
+  ]
+
+  t.install_commands = [
+    "make install_sw INSTALL_PREFIX=#{t.install_dir}" ,
+    "make clean"
+  ]
+
+end
+

data/data/recipes/ruby/ext-extmk.rb.patch

@@ -0,0 +1,33 @@
+  * Make sure selected .a files in the current build directory are appended to
+    the build path.
+  * run ranlib on all .a files so they actually link correctly
+
+--- ext/extmk.rb
++++ ext/extmk.rb
+@@ -500,6 +500,7 @@ void Init_ext _((void))\n{\n#$extinit}
+   end
+ 
+   $extobjs = "ext/#{extinit.o} #{$extobjs}"
++  $extobjs = "#{$extobjs} libz.a libcrypto.a libssl.a"
+   if RUBY_PLATFORM =~ /m68k-human|beos/
+     $extflags.delete("-L/usr/local/lib")
+   end
+@@ -513,9 +514,17 @@ void Init_ext _((void))\n{\n#$extinit}
+   ].map {|n, v|
+     "#{n}=#{v}" if v and !(v = v.strip).empty?
+   }.compact
+-  puts conf
+   $stdout.flush
+   $mflags.concat(conf)
++  unless enable_config("shared", $enable_shared )
++    $extobjs.split.each do |eo|
++      if eo =~/^ext/ and eo =~ /\.a$/ then
++        local_f = eo[4..-1]    
++        puts "ranlib #{local_f}"
++        %x[ ranlib #{local_f} ]
++      end
++    end
++  end
+ else
+   FileUtils.rm_f(extinit.to_a)
+ end

data/data/recipes/ruby/ruby.rake

@@ -0,0 +1,30 @@
+#
+# Crate recipe for ruby version 1.2.3
+#
+Crate::Ruby.new( "ruby", "1.8.6-p287") do |t|
+  t.depends_on( "openssl" )
+  t.depends_on( "zlib" )
+
+  t.integrates( "amalgalite" )
+  t.integrates( "arrayfields" )
+  t.integrates( "configuration" )
+
+  t.upstream_source  = "ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.6-p287.tar.gz"
+  t.upstream_md5     = "f6cd51001534ced5375339707a757556"
+
+  ENV["CPPFLAGS"]= "-I#{File.join( t.install_dir, 'usr', 'include')}"
+  ENV["LDFLAGS"] = "-L#{File.join( t.install_dir, 'usr', 'lib' )}"
+
+  def t.build
+    # put the .a files from the fakeroot/usr/lib directory into the package
+    # directory so the compilation can use them
+    %w[ libz.a libcrypto.a libssl.a ].each do |f| 
+      FileUtils.cp File.join( install_dir, "usr", "lib", f ), pkg_dir
+    end 
+    sh "./configure --disable-shared --prefix=#{File.join( '/', 'usr' )}"
+    sh "make"
+  end
+
+  t.install_commands << "make install DESTDIR=#{t.install_dir}"
+
+end

data/data/recipes/rubygems/rubygems.rake

@@ -0,0 +1,19 @@
+#
+# Crate recipe for rubygems version 1.3.1
+#
+Crate::Dependency.new( "rubygems", "1.3.1") do |t|
+  t.upstream_source = "http://rubyforge.org/frs/download.php/45905/rubygems-1.3.1.tgz"
+  t.upstream_sha1   = "a21ae466146bffb28ece05cddbdced0b908ca74f"
+
+  # TODO: figure out proper integration of rubygems, or just wait until 1.9
+  #namespace t.name do
+  #  desc "Integrate with ruby"
+  #  task :integration => [ "ruby:patch", "#{t.name}:patch" ] do
+  #    t.logger.info "Integrating #{t.name} into ruby's tree"
+  #    Dir.chdir( File.join( t.pkg_dir, "lib" ) ) do |d|
+  #      FileUtils.cp_r ".", Crate.ruby.lib_dir
+  #    end
+  #  end
+  #end
+end
+

data/data/recipes/zlib/zlib.rake

@@ -0,0 +1,16 @@
+#
+# Crate recipe for zlib version 1.2.3
+#
+Crate::Dependency.new( "zlib", "1.2.3") do |t|
+  t.upstream_source = "http://www.zlib.net/zlib-1.2.3.tar.gz"
+  t.upstream_md5    = "debc62758716a169df9f62e6ab2bc634"
+
+  t.build_commands << "./configure --prefix=#{File.join( '/', 'usr' )}"
+
+  t.install_commands = [
+    "make install prefix=#{File.join( t.install_dir, 'usr' )}",
+    "make distclean"
+  ]
+
+end
+

data/gemspec.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'crate/version'
+require 'tasks/config'
+
+Crate::GEM_SPEC = Gem::Specification.new do |spec|
+  proj = Configuration.for('project')
+  spec.name         = proj.name
+  spec.version      = Crate::VERSION
+  
+  spec.author       = proj.author
+  spec.email        = proj.email
+  spec.homepage     = proj.homepage
+  spec.summary      = proj.summary
+  spec.description  = proj.description
+  spec.platform     = Gem::Platform::RUBY
+
+  
+  pkg = Configuration.for('packaging')
+  spec.files        = pkg.files.all
+  spec.executables  = pkg.files.bin.collect { |b| File.basename(b) }
+
+  # add dependencies here
+  spec.add_dependency("rake", ">= 0.8.1")
+  spec.add_dependency("configuration", "~> 0.0.5")
+  spec.add_dependency("progressbar")
+  spec.add_dependency("archive-tar-minitar")
+  spec.add_dependency("amalgalite", "~> 0.5.0")
+  
+   
+  
+  if rdoc = Configuration.for_if_exist?('rdoc') then
+    spec.has_rdoc         = true
+    spec.extra_rdoc_files = pkg.files.rdoc
+    spec.rdoc_options     = rdoc.options + [ "--main" , rdoc.main_page ]
+  else
+    spec.has_rdoc         = false
+  end 
+
+  if test = Configuration.for_if_exist?('testing') then
+    spec.test_files       = test.files
+  end 
+
+  if rf = Configuration.for_if_exist?('rubyforge') then
+    spec.rubyforge_project  = rf.project
+  end 
+
+end

data/lib/crate.rb

@@ -0,0 +1,85 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'rubygems'
+require 'logging'
+require 'date'
+
+# Configure Crate to log to STDOUT at the 'info' level
+Logging::Logger['Crate'].level = :info
+Logging::Logger['Crate'].add_appenders( Logging::Appender.stdout )
+Logging::Appender.stdout.layout = Logging::Layouts::Pattern.new( 
+    :pattern      => "[%d] %5l: %m\n",   # [date] LEVEL: message
+    :date_pattern => "%H:%M:%S"          # date == HH::MM::SS
+)
+
+module Crate
+
+  # The root directory of the project is considered to be the parent directory
+  # of the 'lib' directory.
+  #   
+  # returns:: [String] The full expanded path of the parent directory of 'lib'
+  #           going up the path from the current file.  Trailing
+  #           File::SEPARATOR is guaranteed.
+  #   
+  def self.root_dir
+    unless @root_dir
+      path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
+      lib_index  = path_parts.rindex("lib")
+      @root_dir = path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
+    end 
+    return @root_dir
+  end 
+
+  # returns:: [String] The full expanded path of the +config+ directory
+  #           below _root_dir_.  All parameters passed in are joined onto the
+  #           result.  Trailing File::SEPARATOR is guaranteed if _args_ are
+  #           *not* present.
+  #   
+  def self.config_path(*args)
+    self.sub_path("config", *args)
+  end 
+
+  # returns:: [String] The full expanded path of the +data+ directory below
+  #           _root_dir_.  All parameters passed in are joined onto the 
+  #           result. Trailing File::SEPARATOR is guaranteed if 
+  #           _*args_ are *not* present.
+  #   
+  def self.data_path(*args)
+    self.sub_path("data", *args)
+  end 
+
+  # returns:: [String] The full expanded path of the +lib+ directory below
+  #           _root_dir_.  All parameters passed in are joined onto the 
+  #           result. Trailing File::SEPARATOR is guaranteed if 
+  #           _*args_ are *not* present.
+  #   
+  def self.lib_path(*args)
+    self.sub_path("lib", *args)
+  end 
+
+  def self.sub_path(sub,*args)
+    sp = ::File.join(root_dir, sub) + File::SEPARATOR
+    sp = ::File.join(sp, *args) if args
+  end
+
+  def self.project
+    @project
+  end
+  
+  def self.project=( p )
+    @project = p
+  end
+
+  def self.ruby
+    @ruby
+  end
+  def self.ruby=( r )
+    @ruby = r
+  end
+
+end
+%w[ version packing_list utils dependency gem_integration ruby project ].each { |r| require "crate/#{r}" }
+

data/lib/crate/dependency.rb

@@ -0,0 +1,306 @@
+require 'rake'
+require 'rake/tasklib'
+require 'rake/clean'
+require 'crate/utils'
+require 'crate/digest'
+
+module Crate
+  # Create a build task that will download, checksum and build and install an
+  # upstream source
+  #
+  # This task will create the following targets:
+  #
+  class Dependency < ::Rake::TaskLib
+    include ::Crate::Utils
+    # Name of the task, this is also the Rake namespace underwhich all other
+    # tasks will follow
+    attr_accessor :name
+
+    # Version of the upstream version
+    attr_accessor :version
+
+    # Upstream location 
+    attr_accessor :upstream_source
+
+    # array of shell commands for building 
+    attr_accessor :build_commands
+
+    # array of shell commands for installing
+    attr_accessor :install_commands
+
+    #
+    # Create a Crate Dependency with the given name and version
+    #
+    def initialize( name = nil, version = nil )
+      @name = name
+      @version = version
+      @install_commands = []
+      @build_commands = []
+      yield self if block_given?
+      @upstream_source = URI.parse( @upstream_source )
+      define unless name.nil? or version.nil?
+    end
+
+    # 
+    # The build directory for this particular task
+    #
+    def build_dir
+      @build_dir ||= File.join(Crate.project.build_dir, name )
+    end
+
+    #
+    # The recipe directory for this particular task
+    #
+    def recipe_dir
+      @recipe_dir ||= File.join( Crate.project.recipe_dir, name )
+    end
+
+    #
+    # The fake root directory to install into
+    # 
+    def install_dir
+      Crate.project.install_dir
+    end
+
+    #
+    # handle to the top level logger
+    #
+    def logger
+      Crate.project.logger
+    end
+
+    #
+    # The directory this task unpacks into
+    #
+    def pkg_dir
+      @pkg_dir ||= File.join( self.build_dir, "#{name + ( version ? "-#{version}" : "" ) }" )
+    end
+
+    #
+    # override the directory that the local source unpacks into if it is not
+    # +name-version+
+    #
+    def pkg_dir=( pd )
+      @pkg_dir = File.join( self.build_dir, pd )
+    end
+
+    #
+    # The local on disk copy of the upstream source
+    #
+    def local_source
+      @local_source ||= File.join( build_dir, File.basename( upstream_source.path ) )
+    end
+
+    #
+    # record the upstream sha1 checksum
+    #
+    def upstream_sha1=( checksum )
+      @digest = Crate::Digest.sha1( checksum )
+    end
+    def upstream_sha1
+      if @digest then
+        return @digest.hex
+      else
+        return nil
+      end
+    end
+
+    #
+    # record the upstream md5 checksum
+    #
+    def upstream_md5=( checksum )
+      @digest = Crate::Digest.md5( checksum )
+    end
+    def usptream_md5
+      if @digest then
+        return @digest.hex
+      else
+        return nil
+      end
+    end
+
+    #
+    # Define all the tasks in the namespace of the +name+ of this task.
+    #
+    # The dependency chain is:
+    #
+    #   :install => :build => :patch => :unpack => :verify => :download
+    #
+    #
+    def define
+      logger.debug "Defining tasks for #{name} #{version}"
+
+      namespace "#{name}" do
+        define_download
+        define_verify
+        define_unpack
+        define_patch
+        define_build
+        define_install
+
+        task :done    => "#{name}:install"
+        task :default => "#{name}:done"
+      end
+
+      desc "Build and Install #{name} #{version}"
+      task name => "#{name}:default"
+    end
+
+    def define_download
+      file local_source do |t|
+        logger.info "Downloading #{upstream_source} to #{t.name}"
+        download( upstream_source, t.name )
+      end
+
+      desc "Download #{File.basename( local_source )}"
+      task :download => local_source
+    end
+
+    def define_verify
+      desc "Verify source against its checksum"
+      task :verify => "#{name}:download" do 
+        if @digenst then 
+          if @digest.valid?( local_source ) then
+              logger.info "#{local_source} validates against #{@digest.hex}"
+          else
+            raise "#{local_source} does not have checksum #{@digest.hex}" 
+          end
+        end
+      end
+    end
+
+    def define_unpack
+      #-- unpack
+      desc "Unpack #{name} into #{build_dir}"
+      task :unpack => "#{name}:verify" do 
+        logger.info "Unpacking"
+        unpack( local_source, build_dir )
+        FileUtils.rm_f dotfile( 'patch' )
+      end
+      ::CLEAN << pkg_dir
+    end
+
+    def define_patch
+      desc "Apply patches to #{name}"
+      task :patch => dotfile( 'patch' )  do
+        logger.info "#{name} #{version} is patched"
+      end
+      file dotfile( 'patch' ) => "#{name}:unpack" do
+        logger.info "Patching #{name} #{version}"
+        patch_files.each do |pfile|
+          logger.info "applying patch #{File.basename( pfile ) }"
+          apply_patch( pfile, pkg_dir )
+        end
+        dotfile!( 'patch' )
+      end
+
+      ::CLEAN << dotfile( 'patch' )
+    end
+
+    def define_build
+      desc "Build #{name} #{version}"
+      task :build => dotfile( 'build' ) do
+        logger.info "#{name} #{version} built"
+      end
+
+      file dotfile( 'build' ) => "#{name}:patch" do
+        logger.info "Bulding #{name} #{version}"
+        Dir.chdir( pkg_dir ) do
+          build
+        end
+        dotfile!( 'build' )
+      end
+      ::CLEAN << dotfile( 'build' )
+    end
+
+    def define_install
+      desc "Install #{name} into #{Crate.project.install_dir}"
+      task :install => dotfile('install')  do
+        logger.info "#{name} #{version} is installed"
+      end
+
+      file dotfile( 'install' ) => "#{name}:build" do 
+        logger.info "Installing #{name} #{version}"
+        Dir.chdir( pkg_dir ) do
+          install
+        end
+        dotfile!( 'install' )
+      end
+      ::CLEAN << dotfile( 'install' )
+
+    end
+
+
+    #
+    # Execute all the build commands
+    #
+    def build
+      cd_and_sh( pkg_dir, build_commands )
+    end
+
+    #
+    # Execute all the install commands
+    #
+    def install
+      cd_and_sh( pkg_dir, install_commands )
+    end
+
+    #
+    # Change to a directory and execute a sequence of commands
+    #
+    def cd_and_sh( dir, cmds )
+      Dir.chdir( dir ) do
+        cmds.each do |cmd|
+          sh cmd
+        end
+      end
+    end
+
+    #
+    # Execute a shell command, sending the command name to the logger at info
+    # level and all the output to the logger at the debug level
+    #
+    def sh( cmd )
+      logger.info( cmd )
+
+      io = IO.popen( "#{cmd} 2>&1" )
+      io.each_line do |l|
+        logger.debug( l.strip )
+      end
+    end
+
+    #
+    # return the full path to a named dotfile
+    #
+    def dotfile( name )
+      File.join( build_dir, ".#{name}" )
+    end
+
+    #
+    # make the given dotfile
+    #
+    def dotfile!( name )
+      File.open( dotfile( name ), "w" ) do |f|
+        h = { 'name' => self.name, 'version' => self.version, "#{name}_timestsamp" => Time.now }
+        f.puts h.to_yaml
+      end
+    end
+
+    #
+    # allow this task to say it depends on something else.  This is a build
+    # dependency 
+    #
+    def depends_on( other_dependency )
+      namespace name do
+        task :build => "#{other_dependency}:done"
+      end
+    end
+
+    # 
+    # patch the upacked source with files that are in the recipe directory
+    #
+    def patch_files
+      Dir[File.join( recipe_dir, "*.patch" )].sort
+    end
+  end
+end