chrysalis 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007 Jared Hanson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,5 @@
+= Chrysalis
+
+Chrysalis is a simple dependency manager built on Ruby and Rake.  Chrysalis can
+simplify your development environment by making it possible to build entire
+applications, including dependencies, in a single command.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+PKG_NAME    = 'chrysalis'
+PKG_VERSION = '0.1.0'
+
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*'
+]
+
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.files = PKG_FILES
+  s.add_dependency('rake', '>= 0.7.3')
+  s.add_dependency('gratr', '>= 0.4.3')
+  
+  s.author = "Jared Hanson"
+  s.email = "jaredhanson@gmail.com"
+  s.homepage = "http://chrysalis.rubyforge.org/"
+  s.rubyforge_project = "chrysalis"
+
+  s.summary = "Simple dependency management with Ruby and Rake."
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/chrysalis.rb')
+  rdoc.rdoc_files.include('lib/chrysalis/**/*.rb')
+end
+
+desc "Preview the rdoc HTML files in web browser"
+task :preview_rdoc do
+  sh "heel -r doc" + (RUBY_PLATFORM.match(/mswin/) ? " 2>&1" : "")
+end
+task :preview_rdoc => :rdoc
+
+desc "Publish the rdoc HTML files to RubyForge"
+task :publish_rdoc do
+  sh "scp -r doc/* jaredhanson@rubyforge.org:/var/www/gforge-projects/chrysalis/api"
+end
+task :publish_rdoc => :rdoc
+
+Rake::TestTask.new do |test|
+  test.libs << "test"
+  test.test_files = FileList['test/test_suite.rb']
+end

data/lib/chrysalis/ar/tar.rb

@@ -0,0 +1,56 @@
+require 'chrysalis/archive'
+require 'chrysalis/core_ext/string'
+
+
+module Chrysalis
+module Ar
+
+  # Implements support for extracting tar archives.
+  #
+  # Archives of this type are identified by the file extension <em>tar</em>.
+  class TarArchive < Archive
+    
+    EXTENSION = ".tar".freeze
+    
+    def self.extracts?(path)
+      path.end? EXTENSION
+    end
+    
+    def initialize(path, params = {})
+      super
+      @extract_to = params[:extract_to]
+      @extracts_into = params[:extracts_into]
+      @noop = params[:noop]
+    end
+    
+    def extract(to = '.')
+      dir = Pathname.new(to)
+      dir = dir + @extract_to if @extract_to
+      
+      unless @noop
+        FileUtils.mkpath dir
+        
+        bin = (RUBY_PLATFORM.match(/mswin/) ? "bsdtar" : "tar")
+      
+        puts "Extracting #{@path} ..."
+        sh "#{bin} #{self.flags} #{@path} -C #{dir.cleanpath}"
+      end
+      
+      ex_path = Pathname.new(dir).join(self.extracts_into)
+      ex_path.cleanpath.to_s
+    end
+    
+    protected
+      def flags
+        "xvf"
+      end
+    
+      def extracts_into
+        return @extracts_into if @extracts_into
+        Pathname.new(@path).basename(EXTENSION)
+      end
+    
+  end
+
+end 
+end

data/lib/chrysalis/ar/tar_bz2.rb

@@ -0,0 +1,32 @@
+require 'chrysalis/ar/tar'
+
+
+module Chrysalis
+module Ar
+
+  # Implements support for extracting tar archives compressed with bzip2
+  # compression.
+  #
+  # Archives of this type are identified by the file extension <em>.tar.bz2</em>.
+  class TarBz2Archive < TarArchive
+    
+    EXTENSION = ".tar.bz2".freeze
+    
+    def self.extracts?(path)
+      path.end? EXTENSION
+    end
+    
+    protected
+      def flags
+        "xjvf"
+      end
+      
+      def extracts_into
+        return @extracts_into if @extracts_into
+        Pathname.new(@path).basename(EXTENSION)
+      end
+    
+  end
+
+end 
+end

data/lib/chrysalis/ar/tar_gz.rb

@@ -0,0 +1,51 @@
+require 'chrysalis/ar/tar'
+
+
+module Chrysalis
+module Ar
+
+  # Implements support for extracting tar archives compressed with gzip
+  # compression.
+  #
+  # Archives of this type are identified by the file extension <em>.tar.gz</em>.
+  class TarGzArchive < TarArchive
+    
+    EXTENSION = ".tar.gz".freeze
+    
+    def self.extracts?(path)
+      path.end? EXTENSION
+    end
+    
+    protected
+      def flags
+        "xzvf"
+      end
+      
+      def extracts_into
+        return @extracts_into if @extracts_into
+        Pathname.new(@path).basename(EXTENSION)
+      end
+    
+  end
+  
+  
+  # Implements support for extracting tar archives compressed with gzip
+  # compression.
+  #
+  # Archives of this type are identified by the file extension <em>.tgz</em>.
+  class TgzArchive < TarGzArchive
+    EXTENSION = ".tgz".freeze
+    
+    def self.extracts?(path)
+      path.end? EXTENSION
+    end
+    
+    protected
+      def extracts_into
+        return @extracts_into if @extracts_into
+        Pathname.new(@path).basename(EXTENSION)
+      end
+  end
+
+end 
+end

data/lib/chrysalis/ar/zip.rb

@@ -0,0 +1,48 @@
+require 'chrysalis/archive'
+require 'chrysalis/core_ext/string'
+
+
+module Chrysalis
+module Ar
+
+  # Implements support for extracting ZIP archives.
+  #
+  # Archives of this type are identified by the file extension <em>.zip</em>.
+  class ZipArchive < Archive
+    
+    EXTENSION = ".zip".freeze
+    
+    def self.extracts?(path)
+      path.end? EXTENSION
+    end
+    
+    def initialize(path, params = {})
+      super
+      @extract_to = params[:extract_to]
+      @extracts_into = params[:extracts_into]
+      @noop = params[:noop]
+    end
+    
+    def extract(to = '.')
+      dir = Pathname.new(to)
+      dir = dir + @extract_to if @extract_to
+      
+      unless @noop
+        puts "Extracting #{@path} ..."
+        sh "unzip #{@path} -d #{dir.cleanpath}"
+      end
+      
+      ex_path = Pathname.new(dir).join(extracts_into)
+      ex_path.cleanpath.to_s
+    end
+    
+    private
+      def extracts_into
+        return @extracts_into if @extracts_into
+        Pathname.new(@path).basename(EXTENSION)
+      end
+    
+  end
+
+end 
+end

data/lib/chrysalis/ar.rb

@@ -0,0 +1,4 @@
+require 'chrysalis/ar/tar'
+require 'chrysalis/ar/tar_gz'
+require 'chrysalis/ar/tar_bz2'
+require 'chrysalis/ar/zip'

data/lib/chrysalis/archive.rb

@@ -0,0 +1,55 @@
+require 'pathname'
+require 'chrysalis/errors'
+
+
+module Chrysalis
+  
+  class Archive
+    @@archives = []
+    
+    def self.inherited(archive)
+      @@archives << archive
+    end
+    
+    # Extracts the archive, located at +path+, to the directory +to+ (which
+    # defaults to the current directory).  An optional set of parameters is
+    # accepted as +params+.
+    #
+    # Returns the directory the archive was extracted into.
+    #
+    # The return value assumes standard conventions are followed by the archive,
+    # namely that the directory is the name of the archive file, without the
+    # extension.
+    #
+    # For example, given an archive file libfoo-1.4.2.tar.gz, the directory
+    # returned would be libfoo-1.4.2.
+    #
+    # For archives that don't follow this practice, parameters are available
+    # to override default behavior.
+    def self.extract(path, to = '.', params = {})
+      pn = Pathname.new(path)
+      return pn.cleanpath.to_s if pn.directory?
+      return pn.cleanpath.to_s if params[:noop]
+      
+      @@archives.reverse.each { |archive|
+        return archive.new(path, params).extract(to) if archive.extracts?(path)
+      }
+      raise ArchiveError, "Unknown archive format. (ext: #{pn.extname})"
+    end
+    
+    
+    def self.extracts?(path)
+      false
+    end
+    
+    def initialize(path, params = {})
+      @path = path
+    end
+    
+    def extract(to = '.')
+      raise UnimplementedError, "Archive#extract not implemented"
+    end
+    
+  end
+  
+end

data/lib/chrysalis/core_ext/string.rb

@@ -0,0 +1,19 @@
+class String
+  
+  def begin?(other_str)
+    self.index(other_str) == 0
+  end
+
+  def end?(other_str)
+    i = self.rindex(other_str)
+    return false if i.nil?
+    return (self.length == i + other_str.length)
+  end
+  
+  def concat_sep(other_str, sep)
+    return if ! other_str
+    self.concat(sep) if ! empty?
+    self.concat(other_str)
+  end
+
+end

data/lib/chrysalis/errors.rb

@@ -0,0 +1,18 @@
+module Chrysalis
+  
+  class ManifestError < RuntimeError
+  end
+  
+  class RepositoryError < RuntimeError
+  end
+  
+  class ArchiveError < RuntimeError
+  end
+  
+  class ParameterError < RuntimeError
+  end
+  
+  class UnimplementedError < NameError
+  end
+  
+end

data/lib/chrysalis/loader.rb

@@ -0,0 +1,151 @@
+module Chrysalis
+  
+  # Loader is responsible for loading rakefiles.
+  #
+  # The loader loads the rakefiles defined by dependencies.  The tasks defined
+  # within a dependency rakefile are intercepted and re-synthesized as
+  # <em>all:*</em> tasks.
+  #
+  # Additionally, a hook is declared in order to receive notification that the
+  # main rakefile has been loaded.  The tasks in the main rakefile serve to seed
+  # the <em>all:</em> namespace with tasks, prior to retrieving any
+  # dependencies.
+  
+  class Loader
+    include Singleton
+    
+    def initialize
+      @loading = :main
+      @icept_scope = []
+      @icept_tasks = []
+      @last_comment = nil
+      
+      Chrysalis.hook :rakefile_loaded, self.method(:on_rakefile_loaded).to_proc
+    end
+    
+    # Returns the URL of the project currently being loaded.
+    def loading
+      @loading
+    end
+    
+    # Loads a dependency's rakefile.
+    #
+    # The +url+ is the location of the repository from which the dependency was
+    # retrieved.  The +working_copy+ is the WorkingCopy retrieved.
+    #
+    # This function will search for and load the rakefile found in the working
+    # copy's path, if one exists.
+    def load(url, working_copy)
+      @loading = url
+      
+      Rake::Application::DEFAULT_RAKEFILES.each do |file|
+        path = Pathname.new(working_copy.path).join(file)
+        
+        if File.exist?(path)
+          Kernel.load(path, true)
+          return
+        end
+      end
+      
+    ensure
+      # If the manifest does not contain an entry for the URL being loaded, one
+      # of two things occured:
+      #  1. a project was not instantiated in the rakefile  -- or --
+      #  2. no rakefile existed in the working copy's path 
+      #
+      # In either case, an empty project will be created as a placeholder.
+      
+      if Chrysalis::Manifest.instance[@loading].nil?
+        proj = Project.new
+      end
+      
+      Chrysalis::Manifest.instance[@loading].working_copy = working_copy
+      Chrysalis.post :rakefile_loaded
+    end
+    
+    def on_rakefile_loaded  # :nodoc:
+      return if Chrysalis::Manifest.instance[@loading].nil?
+      
+      @icept_tasks.each do |task|
+        Chrysalis::Manifest.instance[@loading].task(task[0], task[1])
+        Chrysalis::TaskManager.synthesize_task(task[0], task[1])
+      end
+      
+    ensure
+      @loading = :main
+      @icept_tasks = []
+    end
+    
+    def task_intercept(name)
+      scoped_name = (@icept_scope + [name]).join(':')
+      @icept_tasks << [scoped_name, @last_comment]
+      @last_comment = nil
+      yield if @loading == :main
+    end
+    
+    def file_task_intercept(name)
+      @icept_tasks << [name, @last_comment]
+      @last_comment = nil
+      yield if @loading == :main
+    end
+    
+    def desc_intercept(comment)
+      @last_comment = comment
+      yield if @loading == :main
+    end
+    
+    #--
+    # TODO: If name is nil, Rake generates an anonymous namespace.  Chrysalis
+    #       currently does not support this feature.  In practice, anonymous
+    #       namespaces are rarely used.  However, support should be implemented
+    #       for maximum compatibility.
+    def namespace_intercept(name, orig_block)
+      @icept_scope.push(name)
+
+      # Call the original block given to the namespace.  This allows is to
+      # progress deeper, intercepting further tasks within the namespace.
+      #
+      # TODO: Rake instantiates a NameSpace, which is yeiled as a parameter.
+      #       In practice, most code doesn't expect this parameter.  However,
+      #       support for it is currently unimplemented, but should be
+      #       implemented for maximum compatibility.
+      #
+      #       Example:
+      #         orig_block.call(a_namespace)
+      if @loading != :main
+        orig_block.call
+      else
+        yield
+      end
+      
+    ensure
+      @icept_scope.pop
+    end
+    
+    def rule_intercept
+      yield if @loading == :main
+    end
+    
+  end
+  
+  
+  module Hookable
+    @@handlers = []
+  
+    def hook(evt, proc)
+      @@handlers << [evt, proc]
+    end
+    
+    def post(evt, *args)
+      callbacks = @@handlers.select { |e, ignore| evt == e }
+      callbacks.each do |ignore, proc|
+        proc.call(*args)
+      end
+    end
+  end
+  
+  class << self
+    include Hookable
+  end
+  
+end