coral_core 0.2.26 → 0.2.30

data/lib/coral_core/plugin_base.rb

@@ -0,0 +1,147 @@
+
+module Coral
+module Plugin
+class Base < Core
+  # All Plugin classes should directly or indirectly extend Base
+  
+  def initialize(type, provider, options)
+    config = Config.ensure(options)
+    name   = Util::Data.ensure_value(config.delete(:name), provider)
+    
+    set_meta(config.delete(:meta, Config.new))
+    
+    super(config)
+    
+    self.name = name
+    
+    normalize
+  end
+  
+  #---
+  
+  def initialized?(options = {})
+    return true  
+  end
+  
+  #---
+  
+  def method_missing(method, *args, &block)  
+    return nil  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+  
+  def name
+    return get(:name)
+  end
+  
+  #---
+  
+  def name=name
+    set(:name, string(name))
+  end
+  
+  #---
+  
+  def meta
+    return @meta
+  end
+  
+  #---
+  
+  def set_meta(meta)
+    @meta = Config.ensure(meta)
+  end
+  
+  #---
+  
+  def plugin_type
+    return meta.get(:type)
+  end
+  
+  #---
+  
+  def plugin_provider
+    return meta.get(:provider)
+  end
+  
+  #---
+  
+  def plugin_directory
+    return meta.get(:directory)
+  end
+  
+  #---
+  
+  def plugin_file
+    return meta.get(:file)
+  end
+  
+  #---
+  
+  def plugin_instance_name
+    return meta.get(:instance_name)
+  end
+  
+  #---
+  
+  def plugin_parent=parent
+    meta.set(:parent, parent) if parent.is_a?(Coral::Plugin::Base)
+  end
+  
+  #---
+  
+  def plugin_parent
+    return meta.get(:parent)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Plugin operations
+    
+  def normalize
+  end
+
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.build_info(type, data)  
+    plugins = []
+    
+    if data.is_a?(Hash)
+      data = [ data ]
+    end
+    
+    if data.is_a?(Array)
+      data.each do |info|
+        unless Util::Data.empty?(info)
+          info = translate(info)
+          
+          if Util::Data.empty?(info[:provider])
+            info[:provider] = Plugin.type_default(type)
+          end
+          
+          plugins << info
+        end
+      end
+    end
+    return plugins
+  end
+  
+  #---
+
+  def self.translate(data)
+    return ( data.is_a?(Hash) ? symbol_map(data) : {} )
+  end
+  
+  #---
+  
+  def self.ensure_plugin_collection
+    include Mixin::Settings
+    include Mixin::SubConfig
+    
+    extend Mixin::Macro::PluginInterface
+  end
+end
+end
+end

data/lib/coral_core/repository.rb

@@ -1,164 +1,553 @@
-
 module Coral
 class Repository < Core
-    
+  
+  @@repositories = {}
+  
+  #---
+  
+  def self.collection
+    return @@repositories
+  end
+     
   #-----------------------------------------------------------------------------
   # Constructor / Destructor
   
+  def self.init(directory, url, revision, options = {})
+    config = Config.ensure(options)
+    
+    return new(config.import({
+      :directory => directory,
+      :origin => url,
+      :revision => revision
+    }))
+  end
+  
+  #---
+  
+  def self.open(directory, options = {})
+    config = Config.ensure(options)
+    
+    directory = Util::Disk.filename(directory)
+    
+    if ! @@repositories.has_key?(directory) || config.get(:reset, false)
+      return new(config.import({
+        :directory => directory
+      }))
+    end
+    return @@repositories[directory]
+  end
+  
+  #-----------------------------------------------------------------------------
+  
   def initialize(options = {})
     config = Config.ensure(options)
     
     super(config)
     
-    @name       = config.get(:name, '')
-    @directory  = config.get(:directory, '')
-    @submodule  = config.get(:submodule, '')
-    @remote_dir = config.get(:remote_dir, '')
+    set_location(config.get(:directory, Dir.pwd))
     
-    ensure_git(true) 
-  end
+    @cloud       = config.get(:object_container, nil)
+    @remote_path = config.get(:remote_path, nil)
     
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
+    @origin   = config.get(:origin, nil)
+    @revision = config.get(:revision, nil)
+    
+    set_origin(@origin) unless @origin.nil?
+    checkout(@revision) unless @revision.nil?
+    
+    pull if config.get(:pull, false)
+  end
+  
+  #---
   
-  attr_accessor :name, :remote_dir
-  attr_reader :directory, :submodule, :git
+  def inspect
+    "#<#{self.class}: #{directory} : #{@origin} : #{@revision}>"
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Location information
+      
+  def self.git_dir(path, require_top_level = false)
+    path = File.expand_path(path)
+    git_dir = File.join(path, '.git')
 
+    if File.exist?(git_dir)
+      if File.directory?(git_dir)
+        return git_dir
+      elsif ! require_top_level
+        git_dir = Util::Disk.read(git_dir)
+        unless git_dir.nil?
+          git_dir = git_dir.gsub(/^gitdir\:\s*/, '').strip
+          return git_dir if File.directory?(git_dir)
+        end
+      end
+    elsif File.exist?(path) && (path =~ /\.git$/ && File.exist?(File.join(path, 'HEAD')))
+      return path
+    end
+    return nil
+  end
+
+  #-----------------------------------------------------------------------------
+  # URLs
+
+  def self.url(host, repo, options = {})
+    config = Config.ensure(options)
+    
+    user = config.get(:user, 'git')
+    auth = config.get(:auth, true)
+    return user + (auth ? '@' : '://') + host + (auth ? ':' : '/') + repo
+  end
+  
   #---
+  
+  def self.edit_url(url, options = {})
+    config = Config.ensure(options)
+    
+    if matches = url.strip.match(/^(https?|git)\:\/\/([^\/]+)\/(.+)/)
+      host, path = matches.captures
+      return url(host, path, config.import({ :auth => true }))
+    end
+    return url
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Checks
    
   def ensure_git(reset = false)
-    if reset || ! @git
-      if @directory.empty?
-        @git = nil
-      else
-        directory = @directory
-        unless Util::Data.empty?(@submodule)
-          directory = File.join(@directory, @submodule) 
+    if reset || ! @git_lib
+      @git_lib = nil
+      unless directory.empty?
+        @git_lib = Git.new(directory)
+      end
+    end
+    return self
+  end
+  protected :ensure_git
+  
+  #---
+   
+  def can_persist?
+    ensure_git
+    return true if @git_lib
+    return false
+  end
+ 
+  #---
+          
+  def self.top?(path)
+    git_dir = File.join(path, '.git')
+    if File.exist?(git_dir)
+      return true if File.directory?(git_dir)
+    elsif File.exist?(path) && (path =~ /\.git$/ && File.exist?(File.join(path, 'HEAD')))
+      return true
+    end
+    return false
+  end
+  
+  #---
+  
+  def top?
+    return self.class.top?(directory)
+  end
+    
+  #---
+          
+  def self.submodule?(path)
+    git_dir = File.join(path, '.git')
+    if File.exist?(git_dir)
+      unless File.directory?(git_dir)
+        git_dir = Util::Disk.read(git_dir)
+        unless git_dir.nil?
+          git_dir = git_dir.gsub(/^gitdir\:\s*/, '').strip
+          return true if File.directory?(git_dir)
         end
-        @git = Git.open(directory, {
-          :log => logger,
-        })
       end
     end
+    return false
+  end
+  
+  #---
+  
+  def submodule?
+    return self.class.submodule?(directory)
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_reader :directory
+   
+  #---
+  
+  def path
+    if parent.nil?
+      return directory
+    end
+    return directory.gsub(parent.directory + File::SEPARATOR, '')
+  end
+ 
+  #---
+  
+  def git
+    return @git_lib.git if can_persist?
+    return nil
+  end
+  protected :git
+  
+  #---
+  
+  def config(name, options = {})
+    config = Config.ensure(options) # Just in case we throw a configuration in
+    return git.config(config.export, name) if can_persist?
+    return nil
+  end
+  
+  #---
+  
+  def set_config(name, value, options = {})
+    config = Config.ensure(options) # Just in case we throw a configuration in
+    git.config(config.export, name, string(value)) if can_persist?
     return self
   end
   
   #---
+  
+  def delete_config(name, options = {})
+    config = Config.ensure(options)
+    git.config(config.import({ :remove_section => true }).options, name) if can_persist?
+    return self
+  end
+  
+  #---
+   
+  def set_location(directory)
+    @@repositories.delete(@directory) if @directory
+    
+    if Util::Data.empty?(directory)
+      @directory = Dir.pwd
+    else
+      @directory = Util::Disk.filename(directory)
+    end
+    
+    @@repositories[@directory] = self
     
-  def set_repository(directory = '', submodule = '')
-    @directory = string(directory)
-    @submodule = string(submodule)
     ensure_git(true)
+    
+    init_parent
+    init_remotes
+    load_revision
     return self
   end
-      
+
   #-----------------------------------------------------------------------------
+  # Basic Git operations
+  
+  attr_reader :parent, :revision
+  
+  #---
+  
+  def init_parent
+    @parent = nil
     
-  def set_remote(name, hosts, options = {})
+    unless top?
+      search_dir = directory
+      
+      while File.directory?((search_dir = File.expand_path('..', search_dir)))
+        if self.class.git_dir(search_dir)
+          @parent = self.class.open(search_dir)
+          break;
+        end
+      end
+    end
+    return self
+  end
+  protected :init_parent
+
+  #---
+  
+  def load_revision
+    if can_persist?
+      @revision = git.native(:rev_parse, { :abbrev_ref => true }, 'HEAD').strip
+    
+      if @revision.empty?
+        @revision = git.native(:rev_parse, {}, 'HEAD').strip
+      end
+      load_submodules
+    end
+    return self
+  end
+  protected :load_revision
+
+  #---
+  
+  def checkout(revision)
+    if can_persist?
+      revision = revision.strip
+      
+      git.checkout({}, revision) unless @git_lib.bare
+      @revision = revision
+      load_submodules
+    end
+    return self
+  end
+  
+  #---
+  
+  def commit(files = '.', options = {})
     config = Config.ensure(options)
     
     if can_persist?
-      hosts = array(hosts)
+      time = Time.new.strftime("%Y-%m-%d %H:%M:%S")
+      user = ENV['USER']
+      message = config.get(:message, 'Saving state')
       
-      delete_remote(name)
-      return self if hosts.empty?
+      user = 'UNKNOWN' unless user && ! user.empty?
+            
+      git.reset({}, 'HEAD') # Clear the index so we get a clean commit
+      
+      files = array(files)
+      git.add(files) # Get all added and updated files
+      git.add({ :update => true }, files) # Get all deleted files
+    
+      git.commit({
+        :m => "#{time} by <#{user}> - #{message}",
+        :author => config.get(:author, false),
+        :allow_empty => config.get(:allow_empty, false)
+      })
       
-      if @remote_dir && ! config.get(:repo, false)
-        config[:repo] = @remote_dir
+      if ! parent.nil? && config.get(:propogate, true)
+        parent.commit(directory, config.import({
+          :message => "Updating submodule #{path} with: #{message}"
+        }))
       end
+    end
+    return self
+  end
+
+  #-----------------------------------------------------------------------------
+  # Submodule operations
+  
+  attr_reader :submodules
+  
+  #---
+  
+  def load_submodules
+    @submodules = {}
+    
+    if can_persist?
+      # Returns a Hash of { <path:String> => { 'url' => <url:String>, 'id' => <id:String> } }
+      # Returns {} if no .gitmodules file was found
+      Grit::Submodule.config(@git_lib, revision).each do |path, data|
+        repo = self.class.open(File.join(directory, path))
+        repo.set_origin(data['url']) # Just a sanity check (might disapear)
+        
+        @submodules[path] = repo
+      end
+    end
+    return self
+  end
+  protected :load_submodules
+  
+  #---
+  
+  def add_submodule(path, url, revision, options = {})
+    if can_persist?
+      git.submodule({ :branch => revision }, 'add', url, path)
+      commit([ '.gitmodules', path ], { :message => "Adding submodule #{url} to #{path}" })
+      load_submodules
+    end
+  end
+  
+  #---
+  
+  def delete_submodule(path)
+    if can_persist?
+      submodule_key = "submodule.#{path}"
       
-      git.add_remote(name, Git.url(hosts.shift, config[:repo], options))
+      delete_config(submodule_key)
+      delete_config(submodule_key, { :file => '.gitmodules' })
       
-      if ! hosts.empty?
-        remote = git.remote(name)
-        
-        config[:add] = true
+      git.rm({ :cached => true }, path)
+      FileUtils.rm_rf(File.join(directory, path))
+      FileUtils.rm_rf(File.join(git.git_dir, 'modules', path))
       
-        hosts.each do |host|
-          git_url = Git.url(host, config[:repo], config.options)
-          remote.set_url(git_url, config.options)
-        end
-      end
+      commit([ '.gitmodules', path ], { :message => "Removing submodule #{url} from #{path}" })
+      load_submodules
     end
+  end
+ 
+  #---
+   
+  def update_submodules
+    git.submodule({ :init => true, :recursive => true }, 'update') if can_persist?
     return self
   end
+  protected :update_submodules
   
   #---
   
-  def delete_remote(name)
+  def foreach!
     if can_persist?
-      remote = git.remote(name)
-      if remote && remote.url && ! remote.url.empty?
-        remote.remove
+      submodules.each do |path, repo|
+        yield(path, repo)
       end
     end
-    return self  
+    return self
   end
-  
+         
   #-----------------------------------------------------------------------------
-  # Git operations
+  # Remote operations
   
-  def commit(files = '.', options = {})
+  attr_reader :origin, :edit
+    
+  #---
+  
+  def init_remotes
+    @origin = config('remote.origin.url')
+    set_edit(edit_url(@origin)) unless config('remote.edit.url')
+    return self
+  end
+  protected :init_remotes
+
+  #---
+  
+  def set_origin(url)
+    set_remote('origin', url)
+    @origin = url
+    return self
+  end
+
+  #---
+  
+  def set_edit(url)
+    set_remote('edit', url)
+    @edit = url
+    return self
+  end
+  
+  #---
+  
+  def set_remote(name, url)
+    delete_remote(name)
+    git.remote({}, 'add', name.to_s, url) if can_persist?
+    return self
+  end
+  
+  #---
+  
+  def add_remote_url(name, url, options = {})
     config = Config.ensure(options)
     
     if can_persist?
-      time    = Time.new.strftime("%Y-%m-%d %H:%M:%S")
-      user    = ENV['USER']
-      message = config.get(:message, 'Saving state')
+      git.remote({
+        :add => true,
+        :delete => config.get(:delete, false),
+        :push => config.get(:push, false)
+      }, 'set-url', name.to_s, url)
+    end
+    return self
+  end
+  
+  #---
+    
+  def set_host_remote(name, hosts, path, options = {})
+    config = Config.ensure(options)
+    
+    if can_persist?
+      hosts = array(hosts)
+      
+      return self if hosts.empty?
       
-      config[:author]      = config.get(:author, '')
-      config[:allow_empty] = config.get(:allow_empty, false)
+      set_remote(name.to_s, url(hosts.shift, path, config.options))
       
-      unless user && ! user.empty?
-        user = 'UNKNOWN'
+      unless hosts.empty?
+        hosts.each do |host|
+          add_remote_url(name.to_s, url(host, path, config.options), config)
+        end
       end
+    end
+    return self
+  end
+  
+  #---
+  
+  def delete_remote(name)
+    if can_persist? && git.list_remotes.include?(name)
+      git.remote({}, 'rm', name.to_s)
+    end
+    return self
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # SSH operations
+ 
+  def pull!(remote = :origin, options = {})
+    config = Config.ensure(options)
+    success = false
     
-      array(files).each do |file|
-        git.add(file)                      # Get all added and updated files
-        git.add(file, { :update => true }) # Get all deleted files
+    if can_persist?
+      success = Command.new({
+        :command => :git,
+        :data => { 'git-dir=' => git.git_dir },
+        :subcommand => {
+          :command => :pull,
+          :flags => ( config.get(:tags, true) ? :tags : '' ),
+          :args => [ remote, config.get(:branch, '') ]
+        }
+      }).exec!(config) do |line|
+        block_given? ? yield(line) : true
+      end
+      
+      update_submodules
+      
+      if success && ! parent.nil? && config.get(:propogate, true)
+        parent.commit(directory, config.import({
+          :message => "Pulling updates for submodule #{path}",
+          :allow_empty => true
+        }))
       end
-        
-      git.commit("#{time} by <#{user}> - #{message}", config.options)                
     end
-    return self      
+    return success
   end
   
-  #-----------------------------------------------------------------------------
+  #---
+  
+  def pull(remote = :origin, options = {})
+    return pull!(remote, options)
+  end
   
-  def push!(remote = 'origin', options = {})
+  #---
+    
+  def push!(remote = :edit, options = {})
     config = Config.ensure(options)
+    success = false
     
     if can_persist?
-      branch = config.get(:branch, 'master')
-      tags   = config.get(:tags, false)
-    
-      return Coral::Command.new({
+      success = Command.new({
         :command => :git,
-        :data => { 'git-dir=' => git.repo.to_s },
+        :data => { 'git-dir=' => git.git_dir },
         :subcommand => {
           :command => :push,
-          :flags => ( tags ? :tags : '' ),
-          :args => [ remote, branch ]
+          :flags => ( config.get(:tags, true) ? :tags : '' ),
+          :args => [ remote, config.get(:branch, '') ]
         }
       }).exec!(config) do |line|
         block_given? ? yield(line) : true
       end
+      
+      if success && config.get(:propogate, true)
+        foreach! do |path, repo|
+          repo.push(remote, config)
+        end
+      end
     end
+    return success
   end
   
   #---
   
-  def push(remote = 'origin', options = {})
+  def push(remote = :edit, options = {})
     return push!(remote, options)
-  end  
-     
-  #-----------------------------------------------------------------------------
-  # Checks
-  
-  def can_persist?
-    ensure_git
-    return true if @git
-    return false
   end
 end
 end