capricorn 0.2.25 → 2.0.0

data/lib/capricorn/exception_handler.rb

@@ -1,79 +0,0 @@
-
-module Capricorn
-  module ExceptionHandler
-    
-    def self.setup(out=STDOUT, err=STDERR)
-      if String === out
-        @out    = Logger.new(out, 'daily')
-        @stdout = @out.instance_variable_get('@logdev').instance_variable_get('@dev')
-      else
-        @out    = Logger.new(out)
-        @stdout = out
-      end
-      
-      if String === err
-        @err = Logger.new(err, 'daily')
-        @stderr = @err.instance_variable_get('@logdev').instance_variable_get('@dev')
-      else
-        @err    = Logger.new(err)
-        @stderr = err
-      end
-      
-      @out.level = Logger::DEBUG
-      @err.level = Logger::DEBUG
-    end
-    
-    def self.err
-      @err
-    end
-    
-    def self.out
-      @out
-    end
-    
-    def self.stderr
-      @stderr
-    end
-    
-    def self.stdout
-      @stdout
-    end
-    
-    def self.redirect_std
-      if STDOUT != self.stdout
-        STDOUT.reopen self.stdout
-      end
-      
-      if STDERR != self.stderr
-        STDERR.reopen self.stderr
-      end
-      
-      STDIN.reopen "/dev/null"
-    end
-    
-    def logger
-      Capricorn::ExceptionHandler
-    end
-    
-    def log(*args, &block)
-      args = [args.inspect] if args.size == 1 and Array === args.first
-      logger.out.info(*args, &block)
-    end
-    
-    def report
-      yield
-    rescue Exception => e
-      if StandardError === e
-        logger.err.error(e)
-      else
-        logger.err.fatal(e)
-      end
-      raise e
-    end
-    
-  end
-end
-
-def FileUtils.fu_output_message(msg)
-  Capricorn::ExceptionHandler.out.info(msg)
-end

data/lib/capricorn/extentions/rubygems_plugin.rb

@@ -1,27 +0,0 @@
-require 'rubygems/specification'
-
-module Gem # :nodoc:
-  class Specification
-    attribute :engine_dependencies, {}
-    
-    def add_engine_dependency(name, options={})
-      name = name.to_s
-      add_runtime_dependency(name, *[options[:version]].compact)
-      @engine_dependencies ||= {}
-      @engine_dependencies[name] = options
-    end
-    
-    alias_method :ruby_code_without_engines, :ruby_code # :nodoc:
-    def ruby_code(obj) # :nodoc:
-      return obj.inspect if Hash === obj
-      return ruby_code_without_engines(obj)
-    end
-    
-    alias_method :to_ruby_without_engines, :to_ruby # :nodoc:
-    def to_ruby # :nodoc:
-      code = to_ruby_without_engines
-      code.gsub!(/s\.engine_dependencies\s+[=]([^\n]+)/, 's.instance_variable_set(:@engine_dependencies,\1)')
-      code
-    end
-  end
-end

data/lib/capricorn/extentions/thor_extentions.rb

@@ -1,32 +0,0 @@
-Capricorn.runtime_gem('thor', Capricorn::THOR_VERSION)
-
-class Thor
-  class << self
-    attr_accessor :real_namespace # :nodoc:
-  end
-  def self.namespace=(value)
-    Thor.real_namespace = value
-  end
-  def self.namespace
-    Thor.real_namespace
-  end
-  self.namespace = nil
-end
-
-module Thor::Util # :nodoc:
-  class << self
-    alias_method :old_constant_to_thor_path, :constant_to_thor_path
-    alias_method :old_constant_from_thor_path, :constant_from_thor_path
-  end
-  
-  def self.constant_to_thor_path(*args) # :nodoc:
-    path = old_constant_to_thor_path(*args)
-    path.sub!(/^#{Thor.namespace}:/, '') if Thor.namespace
-    path
-  end
-  
-  def self.constant_from_thor_path(path) # :nodoc:
-    path = "#{Thor.namespace}:"+path if Thor.namespace
-    old_constant_from_thor_path(path)
-  end
-end

data/lib/capricorn/job_queue.rb

@@ -1,203 +0,0 @@
-require 'thread'
-
-module Capricorn
-  class JobQueue
-    include DRbUndumped
-    
-    # create a new job queue
-    def initialize
-      @immediated_jobs = Array.new
-      @canceled_jobs = Array.new
-      @job_queue = Array.new
-      @jobs      = Hash.new
-      @mutex     = Mutex.new
-      @next_id   = 1
-      
-      @worker    = Thread.new(self) do |job_queue|
-        while job_queue.running? or job_queue.peek
-          
-          job = job_queue.peek
-          if job
-            job.run(job_queue)
-            job_queue.delete(job.id)
-          else
-            sleep(1)
-          end
-          
-        end
-      end
-    end
-    
-    # enqueue a new job with the given +name+, +options+ and +proc+
-    def enqueue(name, options={}, &proc)
-      @mutex.synchronize do
-        job = Job.new(@next_id, name, options, &proc)
-        @next_id += 1
-        @jobs[job.id] = job
-        @job_queue.push job.id
-        if options[:immediate]
-          @immediated_jobs.push(id)
-        end
-        return job.id
-      end
-    end
-    
-    # dequeue the next job of the queue.
-    def dequeue
-      @mutex.synchronize do
-        id = @job_queue.shift
-        return @jobs.delete(id) if id
-      end
-    end
-    
-    # delete the job associated with the given +id+.
-    def delete(id)
-      @mutex.synchronize do
-        id = @job_queue.delete(id)
-        return @jobs.delete(id) if id
-      end
-    end
-    
-    # peek at the next job in the queue
-    def peek
-      job = nil
-      @mutex.synchronize do
-        id = @job_queue.first
-        job = @jobs[id] if id
-      end
-      job
-    end
-    
-    # get the size of the job queue
-    def size
-      @mutex.synchronize do
-        @job_queue.size
-      end
-    end
-    
-    # cancel the job associated with the given +id+.
-    def cancel(id)
-      @mutex.synchronize do
-        id = @job_queue.delete(id)
-        if id
-          @jobs.delete(id)
-          @canceled_jobs.push(id)
-        end
-      end
-    end
-    
-    # is the job associated with the given +id+ canceled.
-    def canceled?(id)
-      @mutex.synchronize do
-        return !@canceled_jobs.delete(id).nil?
-      end
-    end
-    
-    # run the job associated with the given +id+ immediately.
-    def immediate(id)
-      @mutex.synchronize do
-        @immediated_jobs.push(id) if @jobs[id]
-      end
-    end
-    
-    # should the job associated with the given +id+ be run immediately.
-    def immediated?(id)
-      @mutex.synchronize do
-        return !@immediated_jobs.delete(id).nil?
-      end
-    end
-    
-    # join the worker thread
-    def join!
-      @worker.join
-    end
-    
-    # wait until the queue is empty then stop the worker
-    def stop!
-      @mutex.synchronize do
-        @stopped = true
-      end
-      join!
-    end
-    
-    # is the queue stopping or stopped?
-    def stopped?
-      @mutex.synchronize do
-        return !!@stopped
-      end
-    end
-    
-    # is the queue running
-    def running?
-      !stopped?
-    end
-    
-    # iterate through all the jobs on the queue
-    def each
-      @mutex.synchronize do
-        @job_queue.each do |id|
-          job        = @jobs[id]
-          canceled   = @canceled_jobs.include?(id)
-          immediated = @immediated_jobs.include?(id)
-          
-          yield(job, canceled, immediated)
-        end
-      end
-    end
-    
-    class Job
-      include DRbUndumped
-      
-      attr_accessor :id, :name, :options, :proc
-      
-      def initialize(id, name, options={}, &proc)
-        @id = id.to_i
-        @mutex = Mutex.new
-        @name, @options, @proc = name, options, proc
-        @run_at = Time.now + (options.delete(:delay) || 30)
-      end
-      
-      def delay
-        @mutex.synchronize do
-          delay = @run_at - Time.now
-          delay = 0 if delay < 0
-          return delay
-        end
-      end
-      
-      def running?
-        @mutex.synchronize do
-          return @running
-        end
-      end
-      
-      def waiting?
-        @mutex.synchronize do
-          return @waiting
-        end
-      end
-      
-      def run(job_queue)
-        Capricorn.report do
-          @waiting = true
-          immediated = canceled = false
-          Capricorn.log "waiting #{@run_at - Time.now}s."
-          until immediated or canceled or @run_at <= Time.now
-            sleep(1)
-            canceled   = job_queue.canceled?(self.id)
-            immediated = job_queue.immediated?(self.id)
-          end
-          
-          unless canceled
-            @waiting = false
-            @running = true
-            Capricorn.log("[queue]> #{@name}")
-            @proc.call(@options)
-          end
-        end
-      end
-      
-    end
-    
-  end
-end

data/lib/capricorn/satellite.rb

@@ -1,52 +0,0 @@
-
-module Capricorn
-  class Satellite
-    include DRbUndumped
-    
-    autoload :Actions,          File.dirname(__FILE__)+'/satellite/actions'
-    autoload :Persistence,      File.dirname(__FILE__)+'/satellite/persistence'
-    autoload :DependencyLoader, File.dirname(__FILE__)+'/satellite/dependency_loader'
-    
-    include Capricorn::Satellite::Actions
-    include Capricorn::Satellite::Persistence
-    
-    attr_reader :domain, :engines
-    attr_accessor :development, :module_name
-    
-    def initialize(domain)
-      if Hash === domain
-        domain.each do |name, value|
-          instance_variable_set("@#{name}".to_sym, value)
-        end
-      else
-        @domain = domain
-        @engines = {}
-        @development = false
-      end
-      @domain.gsub!(/^www\./, '')
-    end
-    
-    def basedomain
-      unless @basedomain
-        parts = self.domain.split('.')
-        parts = parts[-2..-1]
-        @basedomain = parts.join('.')
-      end
-      @basedomain
-    end
-    
-    def subdomain
-      unless @subdomain
-        parts = self.domain.split('.')
-        parts = parts[0..-3]
-        @subdomain = parts.join('.')
-      end
-      @subdomain unless @subdomain == ''
-    end
-    
-    def subdomain?
-      !self.subdomain.nil?
-    end
-    
-  end
-end

data/lib/capricorn/satellite/actions.rb

@@ -1,55 +0,0 @@
-
-module Capricorn
-  class Satellite
-    module Actions
-      
-      def add_engine(name, options={})
-        unless @engines.key? name
-          @engines[name] = options
-          true
-        else
-          false
-        end
-      end
-      
-      def update_all_engines
-        @engines.each do |gem_name,options|
-          Capricorn.system.gem_update(gem_name)
-          
-          dep = Gem::Dependency.new(gem_name.to_s, Gem::Requirement.default)
-          specs = Gem::SourceIndex.from_installed_gems.search(dep)
-          
-          return false if specs.empty?
-          
-          specs.sort! do |a,b|
-            b.version <=> a.version
-          end
-          
-          spec_version = specs.first.version.to_s
-          options[:version] = spec_version
-        end
-        
-        return true
-      end
-      
-      def update_engine(name, options={})
-        if @engines.key? name
-          @engines[name] = options
-          true
-        else
-          false
-        end
-      end
-      
-      def remove_engine(name)
-        if @engines.key? name
-          @engines.delete(name)
-          true
-        else
-          false
-        end
-      end
-      
-    end
-  end
-end