plugems_deploy 0.1.0

data/README

@@ -0,0 +1,5 @@
+Provides capistrano recipes for managing plugems.
+
+The recipes can be overriden in standard capistrano files (i.e. ~/.caprc, config/deploy.rb, etc) or in a plugems_deploy_ext gem.
+
+

data/bin/plugem

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'capistrano'
+
+require 'plugems_deploy/cli'
+
+PlugemsDeploy::Cli.execute!

data/config/manifest.yml

@@ -0,0 +1,7 @@
+:version: [0, 1, 0]  
+:name: "plugems_deploy"
+:description: "Plugems deployment scripts"
+:executables: [ 'plugem' ]
+:dependencies:
+  - ['capistrano', '~> 1.0']
+

data/lib/plugems_deploy/capistrano.rb

@@ -0,0 +1,27 @@
+module Capistrano
+  class Configuration
+    alias :standard_cap_load :load
+    def load(*args, &block)
+      # we always call the original load
+      standard_cap_load(*args, &block)
+      
+      # if this happens to be 'config.load "standard"' coming from the CLI, we hook in after
+      # and load all our own recipes before system/dot preferences... if capistrano changes how
+      # they load their "default" recipes, this will probably break
+      if args == ["standard"]
+        load_plugem_deploy_recipes(File.dirname(__FILE__) + '/../..')
+        begin
+          require 'plugems_deploy_ext'
+          load_plugem_deploy_recipes(PLUGEMS_DEPLOY_EXT_DIR) # Overriding from extensions
+        rescue Exception
+          # No extension is loaded
+        end
+      end
+    end
+    
+    def load_plugem_deploy_recipes(dir)
+      Dir[File.join(dir, 'recipes', '*')].each { |f| standard_cap_load(f) }
+    end
+      
+  end
+end

data/lib/plugems_deploy/cli.rb

@@ -0,0 +1,128 @@
+module PlugemsDeploy
+  class Cli
+        
+  require 'optparse'
+  require 'capistrano/cli'
+  require 'plugems_deploy/capistrano'
+
+  def self.execute!
+    new.execute!
+  end
+
+  # The array of (unparsed) command-line options
+  attr_reader :args
+
+  # The hash of (parsed) command-line options
+  attr_reader :options
+
+  def initialize(args = ARGV)
+    @args = args
+    @options = { :version => '> 0.0', :deps_only => false, :debug => false }
+
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] ACTION ARGS"
+
+      opts.separator ""
+      opts.separator "Options -----------------------"
+      opts.separator ""
+
+      opts.on("-v", "--version VERSION",
+        "The gem version to use. Any valid gem spec",
+        "version expression can be specified."
+      ) { |value| @options[:version] = value }
+
+      opts.on("-o", "--only-dependencies",
+      "Update only gem dependencies but not itself."
+      ) { @options[:deps_only] = true }
+      
+      opts.on("-d", "--debug",
+      "Prints some additional debug information."
+      ) { @options[:debug] = true }
+
+      opts.on("-h", "--help", "Display this help message") do
+        puts opts
+        exit
+      end
+
+      opts.separator ""
+      opts.separator "Actions -----------------------"
+      opts.separator ""
+      opts.separator <<-DETAILS.split(/\n/)
+  push -- pushes gems to the base gem server
+  publish -- builds a gem from the current directory and pushes it to the base gem server
+  build -- builds a gem from the current directory
+  update -- updates gems from the local gem server
+  get -- updates gems from the local gem server for dependencies defined in config/manifest.yml
+DETAILS
+
+      if args.empty?
+        $stderr.puts opts
+        exit(-1)
+      else
+        opts.parse!(args)
+        @opts = opts
+      end
+    end
+
+    if args.size < 1
+      $stderr.puts @opts
+      exit(-1)
+    end
+
+    @options[:action] = args.shift
+    @options[:name] = args.shift
+  
+  end
+
+  def execute!
+    begin
+      process_aliases
+      validate_arguments
+    rescue => ex
+      puts "Invalid arguments: #{ ex }"
+      exit(-1)
+    end
+    begin
+      Capistrano::CLI.new(converted_arguments).execute!
+    rescue Exception => ex
+      if @options[:debug]
+        raise
+      else
+        puts "Failed to execute: #{ ex }"
+        exit(-1)
+      end
+    end
+  end
+  
+  
+private
+
+  def validate_arguments
+
+    case
+      when ['push', 'update'].include?(@options[:action]) && @options[:name].nil? then
+        fail "You need to specify the name of the plugem to #{ @options[:action] }"
+    end
+  
+  end
+
+  def process_aliases
+    case @options[:action]
+      when 'up' then @options[:action] = 'update'
+    end
+  end
+  
+  def converted_arguments
+  
+    args = [ "plugem_#{ @options.delete(:action) }" ]
+  
+    @options.each do |k, v|
+      args << "-s" << "plugem_#{ k }=#{ v }"
+    end
+  
+    args
+  
+  end
+  
+  end
+end

data/lib/plugems_deploy/dependency_handler.rb

@@ -0,0 +1,88 @@
+module PlugemsDeploy
+  class DependencyHandler
+ 
+  require 'rubygems'
+  require 'yaml'
+  require 'plugems_deploy/gem_service'
+  
+  MAX_DEPENDENCY_DEPTH = 10000
+  
+  def initialize(source = local_cache)
+    @gems = []
+    @source = source
+  end
+     
+  def dependencies(name, version, deps_only = false, show = false)
+      
+    gem = gem_data(query_gem_spec(name, version))
+
+    mark_dependency(gem) unless deps_only == 'true'
+    collect_dependencies(gem, show)
+    
+    compacted_collected_dependencies
+  
+  end
+  
+  def collect_dependencies(start_point, show)
+        
+    fail("Circular dependencies?\n#{ @gems.to_yaml }") if @gems.size > MAX_DEPENDENCY_DEPTH
+        
+    show_data("#{ start_point[:name] }: [ ", show)
+    query_dependencies(start_point).each do |gem|
+      mark_dependency(gem)
+      show_data("  { #{ gem[:name] } => #{ gem[:version] } }", show)
+      collect_dependencies(gem, show && (show + 4))      
+    end
+    show_data("]", show)
+    
+  end 
+
+  
+private
+
+  def query_dependencies(gem)
+    query_gem_spec(gem[:name], gem[:version]).dependencies.collect do |dependency|
+      spec = query_gem_spec(dependency.name, dependency.version_requirements.to_s)
+      gem_data(spec)
+    end
+  end
+
+  def gem_data(spec)
+    {
+      :name => spec.name,
+      :version => spec.version.to_s,
+      :homepage => spec.homepage,
+      :authors => spec.authors,
+      :download_source => spec.download_source
+    }
+  end
+  
+  def mark_dependency(gem)
+    @gems.unshift(gem) 
+  end
+  
+  def marked?(gem)
+    @gems.any? { |marked| marked[:name] == gem[:name] }
+  end    
+
+  def compacted_collected_dependencies
+    @gems.inject([]) do |dependencies, gem|
+      dependencies << gem unless dependencies.include?(gem)
+      dependencies
+    end
+  end
+
+  def query_gem_spec(name, version)
+    @source.find_gem(name, version) || fail("No gem found for ['#{ name }', '#{ version }']")
+  end
+
+  def local_cache
+    GemService.new
+  end
+  
+  def show_data(data, show)
+    puts  " " * show + data if show
+  end
+            
+  end
+end

data/lib/plugems_deploy/gem_service.rb

@@ -0,0 +1,47 @@
+module PlugemsDeploy
+  class GemService
+
+  require 'rubygems'
+  require 'yaml'
+  require 'rubygems/remote_installer'
+    
+  def initialize(sources = [ cache ])
+    @sources = sources
+    @indexes = { cache => Gem.cache }
+  end
+  
+  def find_gem(name, version)
+  
+    @sources.each do |source|
+      specs = index(source).search(/^#{ name }$/, version)
+      return spec_with_source(specs.last, source) unless specs.empty?
+    end
+    
+    nil
+  
+  end
+  
+private
+
+  LATEST_RUBYGEMS = Gem::RubyGemsVersion.split('.').map{|v|v.to_i}.extend(Comparable) > [0,9,0]
+
+  def cache
+    'cache'
+  end
+  
+  def index(source)
+    @indexes[source] ||= source_index(source)
+  end
+  
+  def spec_with_source(spec, source)
+    spec.class.send(:attr_accessor, :download_source)
+    spec.download_source = source
+    spec
+  end
+
+  def source_index(source)
+    LATEST_RUBYGEMS ? Gem::SourceIndex.new.update(source) : Gem::RemoteSourceFetcher.new(source, nil).source_index
+  end
+
+  end
+end

data/lib/plugems_deploy/manifest.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+require 'erb'
+module PlugemsDeploy
+	class Manifest
+
+		attr_accessor :manifest
+
+    [:name, :version, :description, :author, :executables].each do |property|
+      define_method(property) { manifest[property] }
+    end
+    
+		def initialize(file_name = nil)
+			begin
+				@manifest = load_file(file_name || self.class.manifest_file)
+			rescue Exception => e
+				puts "#{e}. Manifest file is not set? (via Plugems::Manifest.manifest_file =)"
+				puts e
+			end
+		end
+
+		def dependencies
+			manifest[:dependencies] || []
+		end
+
+		module ClassMethods
+		  
+		  @@manifest_file = nil
+			
+			def manifest_file
+				 @@manifest_file || default_manifest_file
+			end
+
+			def load(file_name)
+				new(file_name)
+			end
+
+			def default_manifest_file
+			  "config/manifest.yml"
+			end
+
+			def manifest_file=(file)
+			   @@manifest_file = file
+		  end
+		  
+		end
+
+		extend ClassMethods
+		
+	private
+		  
+		  def load_file(file)
+		    YAML.load(ERB.new(IO.read(file)).result)
+	    end
+
+	end
+
+end

data/recipes/build.rb

@@ -0,0 +1,119 @@
+require 'rake'
+require 'rake/gempackagetask'
+require 'plugems_deploy/manifest'
+require 'fileutils'
+
+module PlugemsDeployBuild
+
+  include FileUtils
+
+  def gem_version
+    version_specified? ? plugem_version : get_gem_version
+  end
+  
+  def version_specified?
+    ! (plugem_version.empty? || (plugem_version == '> 0.0'))
+  end
+  
+  def get_gem_version
+    micro = gem_micro_revision || @manifest.version[2] || 0
+    ver = (@manifest.version + [0,0])[0..1].join('.')
+    "#{ ver }.#{ micro }"
+  end
+  
+  def gem_homepage
+    nil
+  end
+  
+  def gem_author
+    @manifest.author
+  end
+  
+  def gem_requirements
+    [ 'none' ]
+  end
+  
+  def gem_require_path
+    'lib'
+  end
+    
+  def add_gem_dependencies(s)
+    @manifest.dependencies.each do |name,version|
+      s.add_dependency(name, version || '>= 0.0.0') unless package_ignored_gems.include?(name)
+    end
+  end
+  
+  def gem_files
+    Dir["**/*"].reject { |f| f == 'test' }
+  end
+  
+  def gem_test_files
+    Dir['test/**/*_test.rb']
+  end
+  
+  def add_auto_require(s)
+    s.autorequire = plugem_name if File.exist?("lib/#{plugem_name}.rb")
+  end
+  
+  def plugem_name
+    @manifest.name
+  end
+
+  def gem_spec
+
+    @manifest = PlugemsDeploy::Manifest.new
+    
+    spec = Gem::Specification.new do |s|
+    
+      s.platform = Gem::Platform::RUBY
+      s.summary = @manifest.description
+      s.name = plugem_name
+      s.version = gem_version
+      s.homepage = gem_homepage if gem_homepage
+
+      s.author = gem_author
+      s.requirements = gem_requirements
+      s.require_path = gem_require_path
+                    
+      s.files = gem_files
+      s.test_files = gem_test_files
+      s.description = @manifest.description
+
+      s.executables = @manifest.executables
+    
+      add_auto_require(s)
+    
+      add_gem_dependencies(s)
+    
+      finalize_gem_spec(s)
+      
+    end
+    
+  end
+  
+  def finalize_gem_spec(s)
+    # Use this method to add/overwrite any spec attributes
+  end
+  
+end
+
+# Allows to have some gem depdencies used at the run time only but not at the packaging time
+set :package_ignored_gems, []
+
+# Allows to define the micro revision from the external recipe file
+set :gem_micro_revision, nil
+
+desc 'Builds a gem package locally'
+task :plugem_build do
+
+  self.class.send(:include, PlugemsDeployBuild)
+
+  rm_rf('pkg')
+
+  Rake::GemPackageTask.new(gem_spec) do |pkg|
+    additional_gem_packaging_tasks(pkg) if self.class.method_defined?(:additional_gem_packaging_tasks)
+  end
+  
+  Rake::Task['package'].invoke 
+    
+end

data/recipes/configuration.rb

@@ -0,0 +1,16 @@
+require 'yaml'
+# require 'erb'
+
+def cfg_dir
+  File.join(File.dirname(__FILE__), '../config')
+end
+
+# Should be defined in projects
+set :gem_servers, lambda { fail("No gem servers are defined. Set :gem_servers to an array of your gem servers") }
+
+def local_gem_servers
+  gem_servers
+end
+
+# Force sudo usage for installing missing gems instead of running 'sudo plugem'
+set :force_sudo_for_plugem, false

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: plugems_deploy
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-03 00:00:00 -04:00
+summary: Plugems deployment scripts
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: Plugems deployment scripts
+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
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- 
+files: 
+- bin
+- config
+- lib
+- README
+- recipes
+- bin/plugem
+- config/manifest.yml
+- lib/plugems_deploy
+- lib/plugems_deploy/capistrano.rb
+- lib/plugems_deploy/cli.rb
+- lib/plugems_deploy/dependency_handler.rb
+- lib/plugems_deploy/gem_service.rb
+- lib/plugems_deploy/manifest.rb
+- recipes/build.rb
+- recipes/configuration.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- plugem
+extensions: []
+
+requirements: 
+- none
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: