crate 0.1.1

data/lib/crate/digest.rb

@@ -0,0 +1,36 @@
+require 'digest/md5'
+require 'digest/sha1'
+
+module Crate
+  #
+  # A wrapper around a given digest value and the algorithm that creates it.
+  # Use it to verify a bytestream.
+  #
+  class Digest
+
+    attr_reader :engine
+    attr_reader :hex
+
+    class << self
+      def sha1( hex )
+        return Crate::Digest.new( hex, ::Digest::SHA1 )
+      end
+
+      def md5( hex )
+        return Crate::Digest.new( hex, ::Digest::MD5  )
+      end
+    end
+
+    def initialize( hex, klass )
+      @hex = hex
+      @engine = klass.new
+    end
+
+    # 
+    # verify that the given filename has a digest value
+    #
+    def valid?( filename )
+      engine.hexdigest( IO.read( filename ) ) == hex
+    end
+  end
+end

data/lib/crate/gem_integration.rb

@@ -0,0 +1,91 @@
+require 'crate/dependency'
+require 'rubygems/format'
+module Crate
+  class GemIntegration < Dependency
+    #
+    # Define all the tasks in the namespace of the +name+ of this task.
+    #
+    # The dependency chain is:
+    #
+    #   :integrate => :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_integration
+
+        task :done    => "#{name}:integrate"
+        task :default => "#{name}:done"
+      end
+
+      desc "Build and Integrate #{name} #{version}"
+      task name => "#{name}:default"
+    end
+
+    #
+    # Define how the gem integrates into the ruby installation
+    #
+    def define_integration
+      desc "Integrate #{name} into ruby's build tree"
+      task :integration => [ "#{name}:patch", "ruby:patch" ] do |t|
+        logger.info "Integrating #{name} into ruby's tree"
+        format = Gem::Format.from_file_by_path( local_source )
+
+        require_paths = format.spec.require_paths.dup
+        integration_info = {}
+
+        format.spec.extensions.each do |ext|
+          logger.info "integrating #{name} extension #{ext}"
+          ext_dirname = File.dirname( ext ) + File::SEPARATOR
+          dest_ext_dir = File.join( Crate.ruby.ext_dir, name )
+          integration_info[ ext_dirname ] = dest_ext_dir
+          require_paths.delete( File.dirname( ext ) )
+        end
+
+        require_paths.each do |rp|
+          logger.info "integrating #{name} '#{rp}' files "
+          integration_info[ rp + File::SEPARATOR ] = Crate.ruby.lib_dir
+        end
+
+        install_integration_files( integration_info )
+
+        setup_lines = IO.readlines( Crate.ruby.ext_setup_file )
+        if setup_lines.grep(/^#{name}/).empty? then
+          File.open( Crate.ruby.ext_setup_file, "a+" ) do |f|
+            logger.info "updating ext/Setup file to add #{name}"
+            f.puts name
+          end
+        end
+      end
+    end
+
+    #
+    # each of the key value pairs indicates a matching path (the key)  from the
+    # gemspec that should be installed into the designated destiation path (the
+    # value)
+    #
+    def install_integration_files( info )
+      format = Gem::Format.from_file_by_path( local_source )
+      info.each_pair do |from, to|
+        Dir.chdir( File.join( pkg_dir, from ) ) do
+          format.spec.files.each do |f|
+            if f.index( from ) == 0 then
+              src_file = f.sub( from, '' )
+              dest_file = File.join( to, src_file ) 
+              dest_dir = File.dirname( dest_file )
+              logger.debug "copy #{src_file} to #{dest_file}"
+              FileUtils.mkdir_p dest_dir unless File.directory?( dest_dir )
+              FileUtils.cp src_file, dest_file
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crate/main.rb

@@ -0,0 +1,173 @@
+require 'crate'
+
+require 'rubygems'
+require 'optparse'
+require 'find'
+require 'fileutils'
+
+module Crate
+  # The Crate::Main class contains all the functionality needed by the +crate+
+  # command line application.  Much of this code is derived from the Webby::Main
+  # class
+  class Main
+
+    # Directory where the Crate project will be created
+    attr_accessor :project
+
+    # Directory where the template Crate project is located
+    attr_accessor :data
+
+    # behavior options
+    attr_accessor :options
+
+    #
+    # Create a new instance of Crate and run with the command line _args_.
+    #
+    def self.run( args )
+      m = self.new
+      m.parse( args )
+      m.create_project
+    end
+
+    #
+    # default options
+    #
+    def default_options
+      o = OpenStruct.new
+      o.force = false
+      return o
+    end
+
+    #
+    # Create a new Crate object
+    #
+    def initialize
+      @log = Logging::Logger[self]
+      @options = self.default_options
+    end
+
+    #
+    # The option parser for Crate
+    #
+    def option_parser
+      OptionParser.new do |op|
+        op.banner << "  project"
+
+        op.on("-f", "--force", "force the overwriting of existing files") do
+          self.options.force = true
+        end
+        op.separator ""
+        op.separator "common options:"
+        op.on_tail( "-h", "--help", "show this message") do
+          puts op
+          exit 0
+        end
+
+        op.on_tail( "--version", "show version" ) do
+          puts "Crate #{::Crate::VERSION}"
+          exit 0
+        end
+      end
+    end
+
+    # 
+    # Parse the command line arguments
+    #
+    def parse( argv )
+      self.data = ::Crate.data_path
+      opts = option_parser
+      begin
+        opts.parse!( argv )
+        self.project = argv.shift
+
+        if project.nil?
+          puts opts
+          exit 1
+        end
+      rescue ::OptionParser::ParseError => pe
+        puts "#{opts.program_name}: #{pe}"
+        puts "Try `#{opts.program_name} --help` for more information"
+        exit 1
+      end
+    end
+
+    #
+    # Create a new Crate project
+    #
+    def create_project
+      unless options.force
+        abort "'#{project}' already exists" if File.exist?( project ) 
+      end
+
+      # copy over files from the master project data diretory in crate
+      files = project_files
+      files.keys.sort.each do |dir|
+        mkdir dir
+        files[dir].sort.each do |file|
+          cp file 
+        end
+      end
+    end
+
+    #
+    # Make a directory in the specified directory under the project directory
+    # and display a message on the screen indicating that the directory is being
+    # created.
+    #
+    def mkdir( dir )
+      dir = dir.empty? ? project : ::File.join( project, dir )
+      unless File.directory?( dir )
+        creating dir
+        FileUtils.mkdir_p dir
+      end
+    end
+
+    #
+    # Copy a file from the Crate prototype location to the project location.
+    # Display a message that the file is being created.
+    #
+    def cp( file )
+      src = ::File.join( data, file )
+      dest = ::File.join( project, file )
+      creating dest
+      FileUtils.cp( src, dest )
+    end
+
+    #
+    # log a creating message
+    #
+    def creating( msg )
+      @log.info "creating #{msg}"
+    end
+
+    #
+    # log a fatal message and abort
+    #
+    def abort( msg )
+      @log.fatal msg
+      exit 1
+    end
+
+    #
+    # Iterate over all the files in the Crate project template directory and
+    # store them in a hash
+    #
+    def project_files
+      keep       = %r/.rake$|Rakefile$|.patch$|.c$/
+      strip_path = %r/\A#{data}?/o
+      paths      = Hash.new { |h,k| h[k] = [] }
+      Find.find( data ) do |path|
+        next unless keep =~ path
+
+        if File.directory?( path ) then
+          paths[ path.sub( strip_path, '' ) ]
+          next
+        end
+        dir = ::File.dirname( path ).sub( strip_path, '' )
+        paths[dir] << path.sub( strip_path, '' )
+      end
+
+      return paths
+    end
+  end
+end

data/lib/crate/packing_list.rb

@@ -0,0 +1,16 @@
+module Crate
+
+  # encapsulate a packing list, a list of files and the prefix of those files
+  # that need to be stripped off for doing require
+  class PackingList
+
+    attr_reader :prefix
+    attr_reader :file_list
+
+    def initialize( file_list, prefix = Dir.pwd )
+      @prefix = prefix
+      @file_list = file_list.collect { |f| File.expand_path(f) }
+    end
+
+  end
+end

data/lib/crate/project.rb

@@ -0,0 +1,255 @@
+require 'rake'
+require 'rake/tasklib'
+require 'amalgalite'
+require 'amalgalite/requires'
+
+module Crate
+  #
+  # the Crate top level task, there should only be one of these in existence at
+  # a time.  This task is accessible via Crate.project, and is what is defined
+  # in the Rakefile in the project directory.
+  #
+  class Project < ::Rake::TaskLib
+    # Name of the project
+    attr_reader :name
+
+    # Top level directory of the project. 
+    attr_reader :project_root
+
+    # subdirectory of +project_root+ in which the recipe's are stored.
+    # default: 'recipes'
+    attr_accessor :recipe_dir
+
+    # subdirectory of +project_root+ where recipes' are built. default: 'build'
+    attr_accessor :build_dir
+
+    # subdirectory of +project_root+ representing a fake installation root.
+    # default 'fakeroot'
+    attr_accessor :install_dir
+
+    # the directory where the final products are stored
+    attr_accessor :dist_dir
+
+    # The list of extensions to compile
+    attr_reader :extensions
+
+    # The 'main' file
+    attr_accessor :main_file
+
+    # The 'main' class which is instantiated to start the application
+    attr_accessor :main_class
+
+    # The method on an instance of 'main_class' to invoke with ARGV, ENV
+    # arguments to start the crate based program.
+    attr_accessor :run_method
+
+    def initialize( name ) 
+      raise "Crate Project already initialized" if ::Crate.project
+      @name         = name
+      @project_root = File.expand_path( File.dirname( Rake.application.rakefile ) )
+      @recipe_dir   = File.join( @project_root, 'recipes' )
+      @build_dir    = File.join( @project_root, 'build' )
+      @install_dir  = File.join( @project_root, 'fakeroot' )
+      @dist_dir     = File.join( @project_root, 'dist' )
+      yield self if block_given?
+      ::Crate.project = self
+      define
+    end
+
+    def recipe_dir=( rd )
+      @recipe_dir = File.join( project_root, rd )
+    end
+
+    def build_dir=( bd )
+      @build_dir = File.join( project_root, bd)
+    end
+
+    def install_dir=( id )
+      @install_dir = File.join( project_root, id )
+    end
+
+    def dist_dir=( dd )
+      @dist_dir = File.join( project_root, dd )
+    end
+
+    def extensions=( list )
+      @extensions = list.select { |l| l.index("#").nil? }
+    end
+
+    # The list of application files to pack into the app.db
+    # This is an array of PackingList
+    def packing_lists
+      @packing_lists ||= []
+    end
+
+    def packing_lists=( list )
+      @packing_lists = [ list ].flatten
+    end
+
+    #
+    # Create a logger for the project
+    #
+    def logger
+      unless @logger 
+        @logger = Logging::Logger[name]
+        @logger.level = :debug
+        @logger.add_appenders
+
+        @logger.add_appenders( 
+            Logging::Appenders::File.new( File.join( project_root, "project.log" ), :layout => Logging::Layouts::Pattern.new( :pattern => "%d %5l: %m\n" )),
+            Logging::Appenders::Stdout.new( 'stdout', :level => :info,
+                                          :layout => Logging::Layouts::Pattern.new( :pattern      => "%d %5l: %m\n",
+                                                                                    :date_pattern => "%H:%M:%S") )
+        )
+      end
+      return @logger
+    end
+
+    #
+    # Load upthe compile params we may need to compile the project.  This method
+    # is usless until after the :ruby task has been completed
+    #
+    def compile_params 
+      unless @compile_params
+        @compile_params = {}
+        Dir.chdir( ::Crate.ruby.pkg_dir ) do
+          %w[ CC CFLAGS XCFLAGS LDFLAGS CPPFLAGS LIBS ].each do |p|
+            @compile_params[p] = %x( ./miniruby -I. -rrbconfig -e 'puts Config::CONFIG["#{p}"]' ).strip
+          end
+        end
+      end
+      return @compile_params
+    end
+
+    #
+    # Create the crate_boot.h file
+    #
+    def create_crate_boot_h
+      File.open( "crate_boot.h", "w+" ) do |h|
+        h.puts <<-CRATE_BOOT_H
+/**
+ * Automatcially generated.  Do not edit.  To change the contents of
+ * this file, update your project main_file, main_class and run_method
+ * options and rebuild.
+ */
+#define CRATE_MAIN_FILE  "#{Crate.project.main_file}"
+#define CRATE_MAIN_CLASS "#{Crate.project.main_class}"
+#define CRATE_RUN_METHOD "#{Crate.project.run_method}"
+CRATE_BOOT_H
+      end
+    end
+
+
+    # 
+    # Compile the crate_boot stub to an object file
+    #
+    def compile_crate_boot
+      create_crate_boot_h
+      compile_options = %w[ CFLAGS XCFLAGS CPPFLAGS ].collect { |c| compile_params[c] }.join(' ')
+      cmd = "#{compile_params['CC']} #{compile_options} -I#{Crate.ruby.pkg_dir} -o crate_boot.o -c crate_boot.c"
+      logger.debug cmd
+      sh cmd
+      ::CLEAN << "crate_boot.o"
+    end
+
+    #
+    # Run the link command to create the final executable
+    #
+    def link_project
+      link_options = %w[ CFLAGS XCFLAGS LDFLAGS ].collect { |c| compile_params[c] }.join(' ')
+      Dir.chdir( ::Crate.ruby.pkg_dir ) do
+        dot_a = FileList[ "**/*.a" ]
+        dot_o = [ "ext/extinit.o", File.join( project_root, "crate_boot.o" )]
+        libs = compile_params['LIBS']
+        cmd = "#{compile_params['CC']} #{link_options} #{dot_o.join(' ')} #{dot_a.join(' ')} -o #{File.join( dist_dir, name) }"
+        logger.debug cmd
+        sh cmd
+      end
+    end
+
+    #
+    # define the project task
+    #
+    def define
+      lib_db = File.join( dist_dir, "lib.db" )
+      app_db = File.join( dist_dir, "app.db" )
+      directory dist_dir
+      packer_cmd = "~/Projects/amalgalite/bin/amalgalite-pack"
+
+      task :pack_ruby => dist_dir do
+        prefix = File.join( ::Crate.ruby.pkg_dir, "lib" )
+        
+        logger.info "Packing ruby standard lib into #{lib_db}"
+        cmd = "#{packer_cmd} --drop-table --db #{lib_db} --compress --strip-prefix #{prefix} #{prefix}" 
+        logger.debug cmd
+        sh "#{cmd} > /dev/null"
+      end
+
+      task :pack_ruby_ext => dist_dir do
+        logger.info "Packing ruby extension libs into #{lib_db}"
+        File.open( ::Crate.ruby.ext_setup_file ) do |f|
+          f.each_line do |line|
+            next if line =~ /\Aoption/
+            next if line.strip.length == 0
+            next if line =~ /\A#/
+
+            prefix = File.join( ::Crate.ruby.ext_dir, line.strip, "lib" )
+            next unless File.directory?( prefix )
+
+            cmd = "#{packer_cmd} --merge --db #{lib_db} --compress --strip-prefix #{prefix} #{prefix}"
+            logger.debug cmd
+            sh "#{cmd} > /dev/null"
+          end
+        end
+      end
+
+      task :pack_amalgalite => dist_dir do
+        logger.info "Packing amalgalite into #{lib_db}"
+        cmd = "#{packer_cmd} --drop-table --db #{lib_db} --self"
+        logger.debug cmd
+        sh "#{cmd} > /dev/null"
+      end
+
+      task :pack_app => [ :pack_amalgalite, :pack_ruby, :pack_ruby_ext ] do
+        logger.info "Packing project packing lists lists into #{app_db}"
+        Crate.project.packing_lists.each_with_index do |pl,idx|
+          pc = ( idx == 0 ) ? "#{packer_cmd} --drop-table" : packer_cmd.dup
+          cmd = "#{pc} --db #{app_db} --merge --compress --strip-prefix #{pl.prefix} #{pl.file_list.join(' ')} "
+          logger.debug cmd
+          sh "#{cmd} > /dev/null"
+        end
+      end
+
+      file "crate_boot.o" => "crate_boot.c" do
+        compile_crate_boot
+      end
+
+      app_path = File.join( dist_dir, name )
+      file app_path => [ "crate_boot.o", dist_dir ] do
+        link_project
+      end
+
+      desc "Build #{name}"
+      #task :default => [ :ruby ] do 
+      task :default => [ app_path, :pack_app ] do
+        logger.info "Build #{name}"
+        compile_crate_boot
+        link_project
+      end
+      ::CLEAN << self.install_dir
+      ::CLEAN << "project.log"
+      ::CLEAN << self.dist_dir
+      load_rakefiles
+    end
+
+    #
+    # Load all .rake files that are in a recipe sub directory
+    #
+    def load_rakefiles
+      Dir["#{recipe_dir}/*/*.rake"].each do |recipe|
+        logger.debug "loading #{recipe}"
+        import recipe
+      end
+    end
+  end
+end