houston-core 0.5.0.beta1 → 0.5.0

data/app/adapters/houston/adapters/version_control/errors.rb

@@ -1,37 +1,37 @@
 module Houston
   module Adapters
     module VersionControl
-      
+
       class Error < StandardError
         def initialize(original_error=nil, message=nil)
           original_error, message = nil, original_error if original_error.is_a?(String)
-          
+
           if original_error
             message ||= original_error.message
             set_backtrace(original_error.backtrace)
           end
-          
+
           @original_error = original_error
           @message = message
           super(message)
         end
-        
+
         attr_accessor :message
         attr_reader :original_error
       end
-      
+
       class CommitNotFound < Error
       end
-      
+
       class BranchNotFound < Error
       end
-      
+
       class FileNotFound < Error
       end
-      
+
       class InvalidShaError < ArgumentError
       end
-      
+
     end
   end
 end

data/app/adapters/houston/adapters/version_control/git_adapter/github_repo.rb

@@ -3,61 +3,61 @@ module Houston
     module VersionControl
       class GitAdapter
         class GithubRepo < RemoteRepo
-          
-          
+
+
           def project_url
             location.to_s
               .gsub(/^git@(?:www\.)?github.com:/, "https://github.com/")
               .gsub(/^git:/, "https:")
               .gsub(/\.git$/, "")
           end
-          
+
           def commit_url(sha)
             "#{project_url}/commit/#{sha}"
           end
-          
+
           def commit_range_url(sha0, sha1)
             "#{project_url}/compare/#{sha0}...#{sha1}"
           end
-          
+
           def commit_status_url(sha)
             # GitHub requires the full 40-character sha
             sha = native_commit(sha).sha if sha.length < 40
             path = Addressable::URI.parse(project_url).path[1..-1]
             "https://api.github.com/repos/#{path}/statuses/#{sha}"
           end
-          
+
           def repo_name
             location.path[0...-4]
           end
-          
-          
-          
+
+
+
           # GitHub API
-          
+
           def pull_requests(options={})
             Houston.github.pull_requests(repo_name, options)
           end
-          
+
           def create_pull_request(base: nil, head: nil, title: nil, body: nil, options: {})
             Houston.github.create_pull_request(repo_name, base, head, title, body, options)
           end
-          
+
           def issues(options={})
             Houston.github.issues(repo_name, options)
           end
-          
+
           def add_labels_to(labels, issue_number)
             issue_number = issue_number.number if issue_number.respond_to? :number
             Houston.github.add_labels_to_an_issue repo_name, issue_number, Array(labels)
           end
           alias :add_label_to :add_labels_to
-          
+
           def remove_label_from(label, issue_number)
             issue_number = issue_number.number if issue_number.respond_to? :number
             Houston.github.remove_label repo_name, issue_number, label
           end
-          
+
         end
       end
     end

data/app/adapters/houston/adapters/version_control/git_adapter/remote_repo.rb

@@ -4,57 +4,62 @@ module Houston
       class GitAdapter
         class RemoteRepo < Repo
           RETRY_COOLDOWN = 4 # seconds
-          
-          
+
+
           def initialize(connection, location)
             super(connection)
             @location = location
+            @branch_location = :remote
           end
-          
-          
-          
+
+
+
           # Public API for a VersionControl::Adapter Repo
           # ------------------------------------------------------------------------- #
-          
+
           attr_reader :location
-          
+
           def refresh!(async: false)
             return clone!(async: async) unless exists?
             pull!(async: async)
           end
-          
+
           # ------------------------------------------------------------------------- #
-          
+
           def to_s
             location.to_s
           end
-          
-          
-          
+
+
+
           def clone!(async: false)
             GitAdapter.clone!(location, connection.path, async: false)
           end
-          
+
           def pull!(async: false)
             async ? Houston.async { _pull!(true) } : _pull!(false)
           end
-          
+
           def origin
             @origin ||= connection.remotes["origin"]
           end
-          
-          
-          
+
+
+
         protected
-          
+
           def find_commit(sha)
             pull_and_retry { super(sha) }
           end
-          
-          
-          
+
+          def name_of_branch(branch)
+            super.gsub /^origin\//, ""
+          end
+
+
+
         private
-          
+
           def pull_and_retry
             begin
               yield
@@ -65,21 +70,39 @@ module Houston
               retry
             end
           end
-          
+
           def _pull!(async)
             Houston.benchmark("[git:pull#{":async" if async}] #{connection.path}") do
               options = {credentials: GitAdapter.credentials}
-              
+
               # Fetch
               Houston.try({max_tries: 3, base: 0}, Rugged::OSError, Rugged::SshError) do
-                connection.remotes["origin"].fetch(nil, options)
+                connection.remotes["origin"].fetch(nil, options.merge({
+                  update_tips: Proc.new do |refname, _, new_oid|
+                    if new_oid.nil?
+                      Rails.logger.debug "[git:pull] Deleting #{refname}"
+                      connection.references.delete(refname)
+                    else
+                      Rails.logger.debug "[git:pull] Setting #{refname} to #{new_oid[0...7]}"
+                      connection.references.create(refname, new_oid, force: true)
+                    end
+                  end
+                }))
                 release
               end
-              
-              # Prune
-              local_refs = connection.refs.map(&:name).grep(/^refs\//)
+
+              # Don't prune local branches, just local references to remote branches
+              local_refs = connection.refs.map(&:name)
+                .grep(/^refs\/remotes\//)
+
+              # These are represented as branches (refs/heads/) remotely, but
+              # as remote tips (refs/remotes/origin/) locally.
               remote_refs = connection.remotes["origin"].ls(options)
-                .map { |attrs| attrs[:name] }.grep(/^refs\//)
+                .map { |attrs| attrs[:name] }
+                .grep(/^refs\//)
+                .map { |name| name.gsub("refs/heads/", "refs/remotes/origin/") }
+
+              # Prune references to branches that were deleted from origin
               prune_refs = local_refs - remote_refs
               prune_refs.each do |ref|
                 begin
@@ -96,7 +119,7 @@ module Houston
           ensure
             close
           end
-          
+
         end
       end
     end

data/app/adapters/houston/adapters/version_control/git_adapter/repo.rb

@@ -5,29 +5,30 @@ module Houston
     module VersionControl
       class GitAdapter
         class Repo
-          
-          
+
+
           def initialize(connection)
             @connection = connection
+            @branch_location = :local
           end
-          
-          
-          
+
+
+
           # Public API for a VersionControl::Adapter Repo
           # ------------------------------------------------------------------------- #
-          
+
           def all_commit_times
             `git --git-dir=#{git_dir} log --all --pretty='%at'`.split(/\n/).uniq
           end
-          
+
           def all_commits
             `git --git-dir=#{git_dir} log --all --pretty='%H'`.split(/\n/).uniq
           end
-          
+
           def ancestors(sha, options={})
             ancestor_walker(sha, options, &method(:to_commit))
           end
-          
+
           def ancestors_until(sha, options={})
             commits = []
             ancestor_walker(sha, options) do |commit|
@@ -35,78 +36,78 @@ module Houston
               commits << commit
               return commits if yield commit
             end
-            
+
             raise CommitNotFound, "No matching ancestor of \"#{sha}\" was found"
           end
-          
+
           def branches
             Hash[connection.branches
-              .each(:local)
-              .map { |branch| [branch.name, branch.target.oid] }]
+              .each(branch_location)
+              .map { |branch| [name_of_branch(branch), branch.target.oid] }]
           ensure
             release
           end
-          
+
           def branches_at(sha)
             connection.branches
-              .each(:local)
+              .each(branch_location)
               .select { |branch| branch.target.oid.start_with?(sha) }
-              .map(&:name)
+              .map { |branch| name_of_branch(branch) }
           ensure
             release
           end
-          
+
           def commits_between(sha1, sha2)
             sha1 = sha1.sha if sha1.respond_to?(:sha)
             sha2 = sha2.sha if sha2.respond_to?(:sha)
             sha1 = nil if sha1 == Houston::NULL_GIT_COMMIT
-            
+
             ancestors(sha2, including_self: true, hide: sha1).reverse
-            
+
           rescue
             $!.additional_information[:repo] = to_s
             $!.additional_information[:commit_range] = "#{sha1}...#{sha2}"
             raise
           end
-          
+
           def location
             connection.path
           end
-          
+
           def native_commit(sha)
             return NullCommit.new if sha == Houston::NULL_GIT_COMMIT
             to_commit find_commit(sha)
           ensure
             release
           end
-          
+
           def read_file(file_path, options={})
             blob = find_file(file_path, options={})
             blob && blob.content
           ensure
             release
           end
-          
+
           def refresh!(async: false)
           end
-          
+
           def exists?
             File.exists?(connection.path)
           end
-          
+
           # ------------------------------------------------------------------------- #
-          
-          
-          
+
+
+
           def branch(branch)
             ref("refs/remotes/origin/#{branch}") || ref("refs/heads/#{branch}")
           end
-          
+
           def ref(ref)
             ref = connection.ref(ref)
             ref.target.oid if ref
           end
-          
+
           def find_file(file_path, options={})
             commit = options[:commit] || connection.head.target.oid
             head = find_commit(commit)
@@ -122,17 +123,17 @@ module Houston
           ensure
             release
           end
-          
+
           def changes(old_sha, new_sha)
             find_commit old_sha
             find_commit new_sha
             DiffChanges.new `git --git-dir=#{git_dir} diff --name-status #{old_sha} #{new_sha}`
           end
-          
+
           def to_s
             location
           end
-          
+
           # !todo: Does this need to be a public method?
         protected
           def close
@@ -148,23 +149,23 @@ module Houston
             #               members.repo.send(:connection).close }
             #
             # The first two raised exceptions but the last one didn't.
-            
+
             # We have to call the GC.start (I think) to clean up
             # the objects hanging on to file descriptors.
             GC.start
-            
+
             # We have to call connection.close to actually release
             # those file descriptors.
             connection.close
           end
           alias :release :close
-          
-          
-          
+
+
+
         protected
-          
-          attr_reader :connection
-          
+
+          attr_reader :connection, :branch_location
+
           def find_commit(sha)
             normalize_sha!(sha)
             object = connection.lookup(sha)
@@ -177,11 +178,15 @@ module Houston
           rescue Rugged::ObjectError
             raise CommitNotFound, "\"#{sha}\" is too short"
           end
-          
-          
-          
+
+          def name_of_branch(branch)
+            branch.name
+          end
+
+
+
         private
-          
+
           def normalize_sha!(sha)
             return unless sha
             return if sha == Houston::NULL_GIT_COMMIT
@@ -189,17 +194,17 @@ module Houston
             sha.slice!(40)
             validate_sha!(sha)
           end
-          
+
           def validate_sha!(sha)
             unless sha =~ /^[0-9a-f]+$/i
               raise InvalidShaError, "\"#{sha}\" is not a valid SHA"
             end
           end
-          
+
           def git_dir
             connection.path.chomp("/")
           end
-          
+
           def to_commit(rugged_commit)
             Houston::Adapters::VersionControl::Commit.new({
               original: rugged_commit,
@@ -214,32 +219,32 @@ module Houston
               committer_email: rugged_commit.committer[:email]
             })
           end
-          
+
           def ancestor_walker(sha, options={})
             commit = find_commit(sha)
             push_shas = [commit.oid]
-            
+
             # by default, start with the commit's parent
             push_shas = commit.parents.map(&:oid) unless options[:including_self]
             hide_shas = Array(options.fetch(:hide, []))
               .map { |sha| find_commit(sha).oid } # ensure that each of these exists in the repo
-            
+
             # start by releasing any files we've got open
             release
-            
+
             walker = Rugged::Walker.new(connection)
             push_shas.each { |sha| walker.push(sha) }
             hide_shas.each { |sha| walker.hide(sha) }
-            
+
             walker.each_with_index.map do |commit, i|
               release if i % 200 == 0
               yield commit
             end
-            
+
           ensure
             release
           end
-          
+
         end
       end
     end

data/app/adapters/houston/adapters/version_control/git_adapter.rb

@@ -3,12 +3,12 @@ module Houston
     module VersionControl
       class GitAdapter
         class << self
-          
-          
-          
+
+
+
           # Public API for a VersionControl::Adapter
           # ------------------------------------------------------------------------- #
-          
+
           def errors_with_parameters(project, location)
             location = Addressable::URI.parse(location.to_s)
             connect_to_repo!(location, project.version_control_temp_path)
@@ -17,17 +17,17 @@ module Houston
             Rails.logger.error "#{$!.class.name}: #{$!.message}\n  #{$!.backtrace.take(7).join("\n  ")}"
             { git_location: ["might not be right. Houston can't seem to connect to it."] }
           end
-          
+
           def build(project, location)
             connect location, project.version_control_temp_path
           end
-          
+
           def connect(location, temp_path)
             location = Addressable::URI.parse(location.to_s)
             return Houston::Adapters::VersionControl::NullRepo if location.blank?
-            
+
             connection = connect_to_repo! location, temp_path
-            
+
             return self::Repo.new(connection) unless location.absolute?
             return self::GithubRepo.new(connection, location) if /github/ === location
             return self::RemoteRepo.new(connection, location)
@@ -35,20 +35,20 @@ module Houston
             Rails.logger.warn "\e[33m[git_adapter] #{$!.class}: #{$!.message}\e[0m"
             Houston::Adapters::VersionControl::NullRepo
           end
-          
+
           def parameters
             [:git_location]
           end
-          
+
           # ------------------------------------------------------------------------- #
-          
-          
-          
+
+
+
           def connect_to_repo!(repo_uri, temp_path)
             git_path = get_local_path_to_repo(repo_uri, temp_path.to_s)
             Rugged::Repository.new(git_path)
           end
-          
+
           def get_local_path_to_repo(repo_uri, temp_path)
             if repo_uri.absolute?
               clone!(repo_uri, temp_path) unless File.exists?(temp_path)
@@ -57,7 +57,7 @@ module Houston
               repo_uri.to_s
             end
           end
-          
+
           def clone!(origin_uri, local_path, async: false)
             if async
               Houston.async { _clone!(origin_uri, local_path, true) }
@@ -65,18 +65,18 @@ module Houston
               _clone!(origin_uri, local_path, false)
             end
           end
-          
+
           def credentials
             Rugged::Credentials::SshKey.new(
               username: SSH_USERNAME,
               privatekey: SSH_PRIVATEKEY,
               publickey: SSH_PUBLICKEY)
           end
-          
-          
-          
+
+
+
         private
-          
+
           def _clone!(origin_uri, local_path, async)
             Houston.benchmark("[git:clone#{":async" if async}] #{origin_uri} => #{local_path}") do
               Rugged::Repository.clone_at origin_uri.to_s, local_path.to_s,
@@ -84,11 +84,11 @@ module Houston
                 bare: true
             end
           end
-          
+
           SSH_USERNAME = "git".freeze
           SSH_PRIVATEKEY = File.expand_path("~/.ssh/id_rsa").freeze
           SSH_PUBLICKEY = File.expand_path("~/.ssh/id_rsa.pub").freeze
-          
+
         end
       end
     end

data/app/adapters/houston/adapters/version_control/none_adapter.rb

@@ -2,19 +2,19 @@ module Houston
   module Adapters
     module VersionControl
       class NoneAdapter
-        
+
         def self.errors_with_parameters(*args)
           {}
         end
-        
+
         def self.build(*args)
           Houston::Adapters::VersionControl::NullRepo
         end
-        
+
         def self.parameters
           []
         end
-        
+
       end
     end
   end

data/app/adapters/houston/adapters/version_control/null_commit.rb

@@ -2,19 +2,19 @@ module Houston
   module Adapters
     module VersionControl
       class NullCommit
-        
+
         def sha
           Houston::NULL_GIT_COMMIT
         end
-        
+
         def to_s
           sha[0...7]
         end
-        
+
         def nil?
           true
         end
-        
+
       end
     end
   end