redcar 0.3.10.1dev → 0.4

data/plugins/scm/vendor/ruby-blockcache/lib/blockcache.rb

@@ -0,0 +1,120 @@
+
+# This is a class used to cache data from the repository, so that it 
+# needn't be queried over and over. Use a timeout of a few seconds to
+# prevent repeated queries in the same operation, but preserve the 
+# ability to retrieve up to date data.
+#
+# You can call #refresh to reset all the timeouts manually if you
+# need to guarantee fresh data
+#
+# Example usage:
+#
+# def cache
+#   @cache ||= begin
+#     c = BlockCache.new
+#     c.add("test", 10) { "Hello world!" }
+#     # This block always returns the same thing, so never refresh it
+#     c.add("test2") { |name| "Hello #{name}" }
+#     c
+#   end
+# end
+#
+# cache["test2", "Matthew"] # "Hello Matthew"
+
+class BlockCache
+  
+  #attr_reader :values, :accessed
+  
+  def initialize(default=nil)
+    @default_value = default
+    @blocks = {}
+    @timeouts = {}
+    @accessed = {}
+    @values = {}
+  end
+  
+  def add(name, timeout, &block)
+    @blocks[name] = block
+    @timeouts[name] = timeout
+  end
+  
+  def [](name, *args)
+    return @default_value if not @blocks.keys.include?(name)
+    
+    atime = get_accessed(@accessed, [name, *args])
+    ctime = Time.now
+    
+    if ((not @timeouts[name].nil?) or (not value_exist?(@values, [name, *args]))) and ctime - atime > (@timeouts[name] || 0)
+      begin
+        set_value(@values, @blocks[name].call(*args), [name, *args])
+      rescue
+        # dump errors to the console, but otherwise, keep on trucking
+        puts $!.message
+        puts $!.backtrace
+        set_value(@values, @default_value, [name, *args])
+      end
+      
+      set_accessed(@accessed, ctime, [name, *args])
+    end
+    
+    get_value(@values, [name, *args])
+  end
+  
+  def refresh(times=@accessed)
+    times.each do |k, v|
+      if v.respond_to? '[]'
+        refresh v
+      else
+        times[k] = Time.at(0)
+      end
+    end
+  end
+  
+  private
+  
+  def value_exist?(values, path)
+    while path.length > 1
+      curr = path.shift
+      values = values[curr]
+      return false if not values.respond_to? '[]'
+    end
+    
+    return values.keys.include?(path[0])
+  end
+  
+  def get_value(values, path)
+    get_from_path(values, path, @default_value)
+  end
+  
+  def get_accessed(times, path)
+    get_from_path(times, path, Time.at(0))
+  end
+  
+  def get_from_path(hash, path, default)
+    while path.length > 1
+      curr = path.shift
+      hash = hash[curr]
+      return default if not hash.respond_to? '[]'
+    end
+    
+    return hash[path[0]] || default
+  end
+  
+  def set_value(values, value, path)
+    set_from_path(values, value, path)
+  end
+  
+  def set_accessed(times, time, path)
+    set_from_path(times, time, path)
+  end
+  
+  def set_from_path(hash, value, path)
+    while path.length > 1
+      curr = path.shift
+      hash[curr] ||= {}
+      hash = hash[curr]
+    end
+    
+    hash[path[0]] = value
+  end
+end

data/plugins/scm_git/lib/scm_git.rb

@@ -0,0 +1,478 @@
+
+$:.push(
+  File.expand_path(File.join(File.dirname(__FILE__), %w{.. vendor ruby-git lib}))
+)
+
+# Don't error if we don't have git installed
+begin
+  require 'git'
+rescue
+end
+
+require 'scm_git/config_file'
+require 'scm_git/change'
+require 'scm_git/commit'
+
+module Redcar
+  module Scm
+    module Git
+      class Manager
+        include Redcar::Scm::Model
+        
+        #######
+        ## SCM plugin hooks
+        #####
+        def self.scm_module
+          Redcar::Scm::Git::Manager
+        end
+        
+        def self.supported?
+          begin
+            if ::Git::Lib.new.meets_required_version?
+              return true
+            end
+          rescue
+            puts $!.class.name + ": " + $!.message
+          end
+          false
+        end
+        
+        # Whether to print debugging messages. Default to whatever scm is using.
+        def self.debug
+          Redcar::Scm::Manager.debug
+        end
+        
+        def debug
+          Redcar::Scm::Git::Manager.debug
+        end
+        
+        def from_data(data)
+          data = data.split(':')
+          file = ::Git::Status::StatusFile.new(nil, {
+            :type_raw => data[0],
+            :path => data[1],
+          })
+          repo = Scm::Git::Manager.new.load(data[2])
+          Scm::Git::Change.new(file, repo, :file, data[4] == "true")
+        end
+        
+        #######
+        ## General stuff
+        #####
+        
+        def inspect
+          if @repo
+            %Q{#<Scm::Git::Manager "#{@repo.dir.path}">}
+          else
+            %Q{#<Scm::Git::Manager>}
+          end
+        end
+        
+        def cache
+          @cache ||= begin
+            c = ::BlockCache.new
+            
+            c.add('branches', 15) do
+              head = File.read(File.join(@repo.dir.path, '.git', 'HEAD')).strip
+              branches = Dir.glob(File.join(@repo.dir.path, '.git', 'refs', 'heads', '*')).map {|f| File.basename(f)}
+              
+              branches.map {|b| [b, ('ref: refs/heads/' + b == head)]}
+            end
+            
+            c.add('all branches', 15) do
+              raise "not implemented"
+            end
+            
+            c.add('status', 5) { @repo.status }
+            
+            c.add('full status', 5) { @repo.lib.full_status }
+            
+            c.add('config', 30) do
+              config = Scm::Git::ConfigFile.parse(File.join(@repo.dir.path, '.git', 'config'))
+              conf = {}
+              
+              config.each do |key, values|                
+                prefix = key.sub(/^([a-z]+) "(.+)"$/i, '\1.\2')
+                
+                values.each do |key2, value|
+                  conf[prefix + '.' + key2] = value
+                end
+              end
+              
+              conf
+            end
+            
+            c.add('log', 60*60) do |start, finish| 
+              @repo.lib.log_commits(:between => [start, finish]).reverse.map do |c|
+                @repo.gcommit(c)
+              end
+            end
+            
+            c.add('submodules', 60*60) do
+              begin
+                modules = Scm::Git::ConfigFile.parse(File.join(@repo.dir.path, '.gitmodules'))
+                
+                mods = {}
+                modules.each {|k, v|
+                  mod = Scm::Git::Manager.new
+                  mod.load(File.join(@repo.dir.path, v['path']))
+                  mods[v['path']] = mod
+                }
+                mods
+              rescue Errno::ENOENT => e
+                {}
+              end
+            end
+            
+            c
+          end
+        end
+        
+        #######
+        ## SCM hooks
+        #####
+        attr_reader :repo
+        
+        def repository_type
+          "git"
+        end
+        
+        def repository?(path)
+          File.exist?(File.join(path, %w{.git}))
+        end
+        
+        def supported_commands
+          [:init, :commit, :index, :switch_branch, :push]
+        end
+        
+        def refresh
+          cache.refresh
+        end
+        
+        def init!(path)
+          # Be nice and don't blow away another repository accidentally.
+          return nil if File.exist?(File.join(path, %w{.git}))
+          
+          ::Git.init(path)
+        end
+        
+        def load(path)
+          raise "Already loaded repository" if @repo
+          @repo = ::Git.open(path)
+          cache.refresh
+          self
+        end
+        
+        # Not used by scm, but we do use this internally.
+        def uncommited_changes
+          indexed_changes + unindexed_changes
+        end
+        
+        # @return [Array<Redcar::Scm::ScmChangeMirror::Change>]
+        def indexed_changes
+          prepare_changes(true)
+        end
+        
+        # @return [Array<Redcar::Scm::ScmChangeMirror::Change>]
+        def unindexed_changes
+          prepare_changes(false)
+        end
+        
+        private 
+        
+        CHANGE_PRIORITIES = {:sub_project => 0, :directory => 1, :file => 2}
+        
+        def prepare_changes(indexed)
+          changes = cache['submodules'].find_all do |k,s| 
+            s.uncommited_changes.length > 0
+          end.map do |k,s| 
+            file = ::Git::Status::StatusFile.new(nil, {
+              :path => k,
+              :type => "M",
+              :type_raw => "MM"
+            })
+            [k, file]
+          end
+          
+          changes += cache['status'].all_changes.find_all {|c| not changes.find{|d| c[0] == d[0]}}
+          
+          # f[0] is the path, and f[1] is the actual StatusFile
+          changes.find_all {|c| valid_change?(c[1].type_raw, indexed)}.map do |f| 
+            full_path = File.join(@repo.dir.path, f[0])
+            type = (((not File.exist?(full_path)) or File.file?(full_path)) ? :file : :directory)
+            
+            if type == :directory and File.exist?(File.join(full_path, '.git'))
+              type = :sub_project
+            end
+            
+            if type == :sub_project
+              submodule = cache['submodules'][f[0]]
+              Scm::Git::Change.new(f[1], self, type, indexed, indexed ? submodule.indexed_changes : submodule.unindexed_changes)
+            else
+              Scm::Git::Change.new(f[1], self, type, indexed)
+            end
+          end.sort_by {|m| m.path}.sort_by {|m| CHANGE_PRIORITIES[m.type]}
+        end
+        
+        def valid_change?(type, indexed)
+          if (not indexed) and type[1,1] != " "
+            true
+          elsif indexed
+            not ([" ", "?", "U"].include? type[0,1])
+          else
+            false
+          end
+        end
+        
+        public
+        
+        # REQUIRED for :index. Adds a new file to the index.
+        def index_add(change)
+          # delegate to the proper submodule
+          if self != change.repo
+            return change.repo.index_add(change)
+          end
+          
+          @repo.add(change.path)
+          cache.refresh
+          true # refresh trees
+        end
+        
+        # REQUIRED for :index. Ignores a new file so it won't show in changes.
+        def index_ignore(change)
+          # delegate to the proper submodule
+          if self != change.repo
+            change.repo.index_ignore(change)
+            return
+          end
+          
+          gitignore = File.join(repo.dir.path, '.gitignore')
+          if not File.exist? gitignore
+            File.new(gitignore, "w").close
+          end
+          gitignore = File.new(gitignore, 'r+')
+          
+          # Make sure there's data in the file, otherwise we can't seek.
+          if File.size(gitignore) > 0
+            # Check the last byte of the file for a newline
+            gitignore.seek(-1, IO::SEEK_END)
+              if gitignore.sysread(1) != "\n"
+              gitignore.syswrite("\n")
+            end
+          end
+          
+          gitignore.syswrite(change.path + "\n")
+          gitignore.close
+          cache.refresh
+          true # refresh trees
+        end
+        
+        # REQUIRED for :index. Reverts a file to its last commited state.
+        def index_revert(change)
+          # delegate to the proper submodule
+          if self != change.repo
+            return change.repo.index_revert(change)
+          end
+          
+          if change.git_status[0,1] != ' '
+            # Git requires us to unindex any changes before we can revert them.
+            index_unsave(change)
+          end
+          if change.git_status[0,1] == 'A' or change.git_status[0,1] == '?'
+            # if this was a new file, then revert it by deleting it
+            File.unlink(File.join(@repo.dir.path, change.path))
+          else
+            # otherwise checkout the old version
+            @repo.checkout_file('HEAD', change.path)
+          end
+          cache.refresh
+          true # refresh trees
+        end
+        
+        # REQUIRED for :index. Reverts a file in the index back to it's 
+        # last commited state, but leaves the file intact.
+        def index_unsave(change)
+          # delegate to the proper submodule
+          if self != change.repo
+            return change.repo.index_unsave(change)
+          end
+          
+          @repo.reset('HEAD', :file => change.path)
+          
+          cache.refresh
+          true # refresh trees
+        end
+        
+        # REQUIRED for :index. Saves changes made to a file in the index.
+        def index_save(change)
+          # delegate to the proper submodule
+          if self != change.repo
+            return change.repo.index_save(change)
+          end
+          
+          @repo.add(change.path)
+          cache.refresh
+          true # refresh trees
+        end
+        
+        # REQUIRED for :index. Restores a file to the last known state of
+        # the file. This may be from the index, or the last commit.
+        def index_restore(change)
+          # delegate to the proper submodule
+          if self != change.repo
+            return change.repo.index_restore(change)
+          end
+          
+          @repo.checkout_file('HEAD', change.path)
+          cache.refresh
+          true # refresh trees
+        end
+        
+        # REQUIRED for :index. Marks a file as deleted in the index.
+        def index_delete(change)
+          # delegate to the proper submodule
+          if self != change.repo
+            return change.repo.index_delete(change)
+          end
+          
+          if change.git_status[1,1] == '?'
+            FileUtils.rm(File.join(@repo.dir.path, change.path))
+          else
+            @repo.remove(change.path)
+          end
+          cache.refresh
+          true # refresh trees
+        end
+        
+        # REQUIRED for :commit. Commits the currently indexed changes 
+        # in the subproject.
+        #
+        # @param change Required for :commitable changes. Ignore if
+        # you don't provide these.
+        def commit!(message, change=nil)
+          if change
+            # delegate to the proper submodule
+            if self != change.repo
+              return change.repo.commit!(change)
+            end
+            
+            # redelegate the commit to the subproject to handle
+            cache['submodules'][change.path].commit!(message)
+          else
+            @repo.commit(message)
+            cache.refresh
+          end
+        end
+        
+        # REQUIRED for :commit. Gets a default commit message for the 
+        # currently indexed changes.
+        #
+        # @param change Required for :commitable changes. Ignore if
+        # you don't provide these.
+        def commit_message(change=nil)
+          if change
+            # delegate to the proper submodule
+            if self != change.repo
+              return change.repo.commit!(change)
+            end
+          
+            # redelegate the call to the subproject to handle
+            cache['submodules'][change.path].commit_message
+          else
+            "\n\n" + cache['full status']
+          end
+        end
+        
+        # REQUIRED for :switch_branch. Returns an array of branch names.
+        #
+        # @return [Array<String>]
+        def branches
+          cache['branches'].map {|b| b[0]}
+        end
+        
+        # REQUIRED for :switch_branch. Returns the name of the current branch.
+        def current_branch
+          b = cache['branches'].select { |b| b[1] }.first
+          
+          b.nil? ? "" : b[0]
+        end
+        
+        # REQUIRED for :switch_branch. Switches to the named branch.
+        def switch!(branch)
+          @repo.checkout(branch)
+          cache.refresh
+        end
+        
+        def push_targets
+          targets = branches.map {|b| Scm::ScmCommitsMirror::CommitsNode.new(self, b)}
+          modules = cache['submodules'].clone
+          
+          while m = modules.shift
+            path = m[0]
+            m[1].cache['submodules'].each {|k,v| modules[File.join(path, k)] = v}
+            
+            targets += m[1].branches.map {|b| Scm::ScmCommitsMirror::CommitsNode.new(m[1], b, "#{b} (#{path})")}
+          end
+          
+          # only return targets we can actually push to
+          targets.find_all do |t|
+            remote = t.repo.cache['config']['branch.' + t.branch + '.remote']
+            
+            if remote
+              push_target = t.repo.cache['config']['branch.' + t.branch + '.push'] || t.repo.cache['config']['branch.' + t.branch + '.merge']
+              
+              push_target.gsub!(/^refs\/heads\//, '')
+              r_ref_file = File.join(t.repo.repo.dir.path, '.git', 'refs', 'remotes', remote, push_target)
+              
+              File.exist?(r_ref_file)
+            end
+          end
+        end
+        
+        # REQUIRED for :push. Returns an array of unpushed changesets.
+        #
+        # @return [Array<Redcar::Scm::ScmMirror::Commit>]
+        def unpushed_commits(branch=current_branch)
+          # Hit `git config -l` to figure out which remote/ref this branch uses for pushing.
+          remote = cache['config']['branch.' + branch + '.remote']
+          push_target = cache['config']['branch.' + branch + '.push'] || cache['config']['branch.' + branch + '.merge']
+          
+          # We don't have a remote setup for pushes, so we can't automatically push
+          return [] if remote.nil?
+          
+          # Hit .git/remotes/$REMOTE/$REF to find out which revision that ref is at.
+          push_target.gsub!(/^refs\/heads\//, '')
+          r_ref_file = File.join(@repo.dir.path, '.git', 'refs', 'remotes', remote, push_target)
+          return [] if not File.exist?(r_ref_file)
+          r_ref = File.read(r_ref_file).strip
+          
+          # Hit .git/refs/heads/$BRANCH to figure out which revision we're at locally.
+          l_ref = File.read(File.join(@repo.dir.path, '.git', 'refs', 'heads', branch)).strip
+          
+          # Hit `git log $R_REV..$L_REV` to get a list of commits that are unpushed.
+          if r_ref != l_ref
+            cache['log', r_ref, l_ref].map {|c| Scm::Git::Commit.new(c)}
+          else
+            []
+          end
+        end
+        
+        # REQUIRED for :push. Pushes all current changesets to the remote
+        # repository.
+        def push!(branch=current_branch)
+          remote = cache['config']['branch.' + branch + '.remote']
+          push_target = cache['config']['branch.' + branch + '.push'] || cache['config']['branch.' + branch + '.merge']
+          
+          # don't block while trying to push changes
+          Thread.new do
+            repo.push(remote, '+refs/heads/' + branch + ':' + push_target)
+            
+            Redcar.update_gui { cache.refresh; Scm::Manager.refresh_trees }
+          end
+          
+          false # don't refresh trees
+        end
+      end
+    end
+  end
+end