mercurial-ruby 0.3.0

data/lib/mercurial-ruby/factories/commit_factory.rb

@@ -0,0 +1,154 @@
+module Mercurial
+  
+  #
+  # This class represents a factory for {Mercurial::Commit Commit} instances.
+  #
+  class CommitFactory
+    include Mercurial::Helper
+    
+    # Instance of {Mercurial::Repository Repository}.
+    attr_reader :repository
+    
+    def initialize(repository) #:nodoc:
+      @repository = repository
+    end
+    
+    # Return an array of {Mercurial::Commit Commit} instances for all changesets in the repository.
+    #
+    # == Example:
+    #  repository.commits.all 
+    #
+    def all
+      hg_to_array ["log --style ?", style], changeset_separator do |line|
+        build(line)
+      end
+    end
+    
+    # Run a block for every {Mercurial::Commit Commit} instance of all changesets in the repository.
+    #
+    # == Example:
+    #  repository.commits.each {|commit| ... }
+    #
+    def each(&block)
+      all.each do |commit|
+        block.call(commit)
+      end
+    end
+    
+    # Count all changesets in the repository.
+    #
+    # == Example:
+    #  repository.commits.count
+    #
+    def count
+      hg_to_array %Q[log --template "{node}\n"], "\n" do |line|
+        line
+      end.size
+    end
+    
+    # Return an array of {Mercurial::Commit Commit} instances for changesets in a specific branch.
+    #
+    # == Example:
+    #  repository.commits.by_branch('brancname')
+    #
+    def by_branch(branch)
+      hg_to_array ["log -b ? --style ?", branch, style], changeset_separator do |line|
+        build(line)
+      end
+    end
+    
+    # Return an instance of {Mercurial::Commit Commit} for a changeset with a specified id.
+    #
+    # == Example:
+    #  repository.commits.by_hash_id('291a498f04e9')
+    #
+    def by_hash_id(hash)
+      build do
+        hg(["log -r ? --style ?", hash, style])
+      end
+    end
+    
+    # Return an array of {Mercurial::Commit Commit} instances for changesets with specified ids.
+    #
+    # == Example:
+    #  repository.commits.by_hash_ids('291a498f04e9', '63f70b2314ed')
+    #
+    def by_hash_ids(*args)
+      if args.size == 1 && args.first.kind_of?(Array)
+        array = args.first
+      else
+        array = args
+      end      
+      return [] if array.empty?
+
+      args = array.map{|hash| " -r#{ hash }"}
+      hg_to_array ["log#{ args } --style ?", style], changeset_separator do |line|
+        build(line)
+      end
+    end
+    
+    # Return an array of {Mercurial::Commit Commit} instances for a specified range of changeset ids.
+    #
+    # == Example:
+    #  repository.commits.for_range('bf6386c0a0cc', '63f70b2314ed')
+    #
+    def for_range(hash_a, hash_b)
+      hg_to_array ["log -r ?:? --style ?", hash_a, hash_b, style], changeset_separator do |line|
+        build(line)
+      end
+    end
+    
+    # Return an instance of {Mercurial::Commit Commit} for a repository's tip changeset (latest).
+    #
+    # == Example:
+    #  repository.commits.tip
+    #
+    def tip
+      build do
+        hg(["tip --style ?", style])
+      end
+    end
+    alias :latest :tip
+    
+  protected
+  
+    def changeset_separator
+      Mercurial::Style::CHANGESET_SEPARATOR
+    end
+    
+    def field_separator
+      Mercurial::Style::FIELD_SEPARATOR
+    end
+  
+    def build(data=nil, &block)
+      data ||= block.call
+      return if data.empty?
+      data = data.gsub(/#{ Regexp.escape(changeset_separator) }$/, '')
+      data = data.split(field_separator)
+      commit = Mercurial::Commit.new(
+        repository,
+        :hash_id         => data[0],
+        :author          => data[1],
+        :author_email    => data[2],
+        :date            => data[3],
+        :message         => data[4],
+        :changed_files   => [data[5], data[6], data[7], data[8]],
+        :branches_names  => data[9],
+        :tags_names      => data[10],
+        :parents         => data[11]
+      )
+      
+      if commit.blank?
+        nil
+      else
+        commit
+      end
+    end
+  
+    def style
+      Mercurial::Style.changeset
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/factories/diff_factory.rb

@@ -0,0 +1,63 @@
+module Mercurial
+  
+  #
+  # This class represents a factory for {Mercurial::Diff Diff} instances.
+  #
+  class DiffFactory
+    include Mercurial::Helper
+    
+    # Instance of {Mercurial::Repository Repository}.
+    attr_reader :repository
+    
+    def initialize(repository)
+      @repository = repository
+    end
+    
+    # Returns an array of {Mercurial::Diff Diff} instances for a specified
+    # instance of {Mercurial::Commit Commit}. Represents changeset's diffs.
+    #
+    # == Example:
+    #  commit = repository.commits.by_hash_id('291a498f04e9')
+    #  repository.diffs.for_commit(commit)
+    #
+    def for_commit(commit)
+      [].tap do |returning|
+        data = hg(["diff -c ?", commit.hash_id])
+        chunks = data.split(/^diff/)[1..-1]
+        unless chunks.nil?
+          chunks.map do |piece| 
+            piece = "diff" << piece
+            returning << build(commit, piece)
+          end
+        end
+      end
+    end
+    
+  private
+  
+    def build(commit, data)
+      return if data.empty?      
+      hash_a, hash_b = *data.scan(/^diff -r (\w+) -r (\w+)/).first
+
+      if binary_file = data.scan(/^Binary file (.+) has changed/).flatten.first
+        file_a = binary_file
+        body = 'Binary files differ'
+      else
+        file_a = data.scan(/^--- (?:a\/(.+)|\/dev\/null)\t/).flatten.first
+        file_b = data.scan(/^\+\+\+ (?:b\/(.+)|\/dev\/null)\t/).flatten.first
+        body = data[data.index("\n")+1..-1]
+      end
+
+      Mercurial::Diff.new(commit,
+        :hash_a => hash_a,
+        :hash_b => hash_b,
+        :file_a => file_a,
+        :file_b => file_b,
+        :body   => body,
+        :binary => !!binary_file
+      )
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/factories/hook_factory.rb

@@ -0,0 +1,45 @@
+module Mercurial
+  
+  class HookFactory
+    
+    attr_reader :repository
+    
+    def initialize(repository)
+      @repository = repository
+    end
+    
+    def all
+      [].tap do |returning|
+        repository.config.find_header('hooks').each_pair do |name, value|
+          returning << build(name, value)
+        end
+      end
+    end
+    
+    def by_name(name)
+      all.find do |h|
+        h.name == name
+      end
+    end
+    
+    def add(name, value)
+      build(name, value).tap do |hook|
+        hook.save
+      end
+    end
+    
+    def remove(name)
+      if hook = by_name(name)
+        hook.destroy!
+      end
+    end
+    
+  protected
+  
+    def build(name, value)
+      Mercurial::Hook.new(repository, name, value)
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/factories/node_factory.rb

@@ -0,0 +1,111 @@
+module Mercurial
+  class NodeMissing < Error; end
+
+  #
+  # This class represents a factory for {Mercurial::Node Node} instances.
+  #
+  class NodeFactory
+    include Mercurial::Helper
+    
+    # Instance of {Mercurial::Repository Repository}.
+    attr_reader :repository
+    
+    def initialize(repository)
+      @repository = repository
+    end
+    
+    # Finds a specified file or a directory in the repository at a specified revision.
+    # Returns an instance of {Mercurial::Node Node}.
+    #
+    # Will find node in the latest version of repo if revision is ommitted.
+    # Will return nil if node wasn't found.
+    #
+    # == Example:
+    #  repository.nodes.find('/')
+    #  repository.nodes.find('some-fancy-directory/Weird File Name.pdf', '291a498f04e9')
+    #  repository.nodes.find('some-fancy-directory/subdirectory/', '291a498f04e9')
+    #
+    def find(path, revision=nil)
+      revision ||= 'tip'
+      return RootNode.new(:repository => repository, :revision => revision) if path == '/'
+      entry = repository.manifest.scan_for_path(path, revision).first
+      return unless entry
+      if exact_path = entry[3].scan(/^(#{ Regexp.escape(path.without_trailing_slash) }\/)/).flatten.first
+        name = exact_path.split('/').last + '/'
+        build(
+          :path     => exact_path,
+          :name     => name,
+          :revision => revision
+        )
+      else
+        build(
+          :path     => entry[3],
+          :name     => entry[3].split('/').last,
+          :revision => revision,
+          :nodeid   => entry[0],
+          :fmode    => entry[1],
+          :exec     => entry[2]
+        )
+      end
+    end
+    
+    # Same as +find+ but will raise a NodeMissing exception if node wasn't found.
+    def find!(path, revision=nil)
+      find(path, revision) || raise(NodeMissing, "#{ path } at revision #{ revision }")
+    end
+    
+    # Find all entries (files and directories) inside a specified path and revision.
+    # Returns an array of {Mercurial::Node Node} instances.
+    #
+    # Will find node in the latest version of repo if revision is ommitted.
+    #
+    # == Example:
+    #  repository.nodes.entries_for('/')
+    #  repository.nodes.entries_for('some-fancy-directory/subdirectory/', '291a498f04e9')
+    #
+    def entries_for(path, revision=nil, parent=nil)
+      revision ||= 'tip'
+      entries = []
+      manifest_entries = repository.manifest.scan_for_path(path, revision)
+      manifest_entries.each do |me|
+        path_without_source = me[3].gsub(/^#{ Regexp.escape(path.without_trailing_slash) }\//, '')
+        entry_name = path_without_source.split('/').first
+        entry_path = File.join(path, entry_name).gsub(/^\//, '')
+        dir = me[3].scan(/^(#{ Regexp.escape(entry_path) }\/)/).flatten.first ? true : false
+        entry_name << '/' if dir
+        
+        entries << build(
+          :path     => entry_path,
+          :name     => entry_name,
+          :revision => revision,
+          :nodeid   => (me[0] unless dir),
+          :fmode    => dir ? nil : me[1],
+          :exec     => dir ? nil : me[2],
+          :parent   => parent
+        )
+      end
+      
+      entries = entries.inject({}) do |hash,item|
+        hash[item.name] ||= item
+        hash 
+      end.values
+    end
+    
+  private
+  
+    def build(opts={})
+      Mercurial::Node.new(
+        :repository => repository,
+        :path       => opts[:path],
+        :name       => opts[:name],
+        :revision   => opts[:revision],
+        :nodeid     => opts[:nodeid],
+        :fmode      => opts[:fmode],
+        :executable => opts[:exec],
+        :parent     => opts[:parent]
+      )
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/factories/tag_factory.rb

@@ -0,0 +1,48 @@
+module Mercurial
+
+  #
+  # This class represents a factory for {Mercurial::Tag Tag} instances.
+  #
+  class TagFactory
+    include Mercurial::Helper
+    
+    # Instance of {Mercurial::Repository Repository}.
+    attr_reader :repository
+    
+    def initialize(repository)
+      @repository = repository
+    end
+    
+    # Return an array of {Mercurial::Tag Tag} instances for all tags in the repository.
+    #
+    # == Example:
+    #  repository.tags.all 
+    #
+    def all
+      hg_to_array "tags" do |line|
+        build(line)
+      end
+    end
+    
+    # Return a {Mercurial::Tag Tag} instance for a tag with a specified name.
+    #
+    # == Example:
+    #  repository.tags.by_name('tagname')
+    #
+    def by_name(name)
+      all.find do |b|
+        b.name == name
+      end
+    end
+    
+  private
+  
+    def build(data)
+      name, hash_id = *data.scan(/([\w-]+)\s+\d+:(\w+)\s*/).first
+      return if name == 'tip'
+      Mercurial::Tag.new(repository, name, hash_id)
+    end
+
+  end
+  
+end

data/lib/mercurial-ruby/file_index.rb

@@ -0,0 +1,209 @@
+module Mercurial
+
+  # This class was ported from grit.
+  #
+  # This implements a file-based 'file index', an simple index of
+  # all of the reachable commits in a repo, along with the parents
+  # and which files were modified during each commit.
+  #
+  # This class creates and reads a file named '[.hg]/file-index'.
+  #
+  class FileIndex
+    include Mercurial::Helper
+
+    class IndexFileNotFound < StandardError
+    end
+
+    class UnsupportedRef < StandardError
+    end
+
+    class << self
+      attr_accessor :max_file_size
+    end
+
+    self.max_file_size = 10_000_000 # ~10M
+
+    attr_reader :repository
+
+    # initializes index given repository
+    def initialize(repository)
+      @repository = repository      
+    end
+    
+    def reload
+      @_read_complete = false
+    end
+    
+    # updates file index
+    def update(oldrev=nil, newrev=nil)
+      if index_file_exists? && oldrev != "0"*40
+        hg([
+            "log --debug -r ?:? --style ? >> ?",
+            oldrev, newrev, Style.file_index, path
+          ])
+      else
+        hg(["log --debug -r : --style ? > ?", Style.file_index, path])
+      end
+    end
+
+    # returns count of all commits
+    def count_all
+      read_if_needed
+      @sha_count
+    end
+
+    # returns count of all commits reachable from SHA
+    # note: originally did this recursively, but ruby gets pissed about that on
+    # really big repos where the stack level gets 'too deep' (thats what she said)
+    def count(commit_sha)
+      read_if_needed
+      commits_from(commit_sha).size
+    end
+
+    # builds a list of all commits reachable from a single commit
+    def commits_from(commit_sha)
+      raise UnsupportedRef if commit_sha.is_a? Array
+      read_if_needed
+
+      already = {}
+      final = []
+      left_to_do = [commit_sha]
+
+      while commit_sha = left_to_do.shift
+        next if already[commit_sha]
+
+        final << commit_sha
+        already[commit_sha] = true
+
+        commit = @commit_index[commit_sha]
+        commit[:parents].each do |sha|
+          left_to_do << sha
+        end if commit
+      end
+
+      sort_commits(final)
+    end
+
+    # returns files changed at commit sha
+    def files(commit_sha)
+      read_if_needed
+      if commit = @commit_index[commit_sha]
+        commit[:files]
+      else
+        []
+      end
+    end
+
+    # returns all commits for a file
+    def commits_for(file)
+      read_if_needed
+      @all_files[file] || []
+    end
+
+    # returns the shas of the last commits for all
+    # the files in [] from commit_sha
+    # files_matcher can be a regexp or an array
+    def last_commits(commit_sha, files_matcher)
+      read_if_needed
+      acceptable = commits_from(commit_sha)
+
+      matches = {}
+
+      if files_matcher.is_a? Regexp
+        files = @all_files.keys.select { |file| file =~ files_matcher }
+        files_matcher = files
+      end
+
+      if files_matcher.is_a? Array
+        # find the last commit for each file in the array
+        files_matcher.each do |f|
+          @all_files[f].each do |try|
+            if acceptable.include?(try)
+              matches[f] = try
+              break
+            end
+          end if @all_files[f]
+        end
+      end
+
+      matches
+    end
+    
+    def destroy!
+      FileUtils.rm_f(path)
+    end
+    
+    def path
+      File.join(repository.dothg_path, 'file-index')
+    end
+
+  private
+    
+    def index_file_exists?
+      FileTest.exists?(path)
+    end
+    
+    def index_file_valid?
+      File.file?(path) && (File.size(path) < Mercurial::FileIndex.max_file_size)
+    end
+    
+    def sort_commits(sha_array)
+      read_if_needed
+      sha_array.sort { |a, b| @commit_order[b].to_i <=> @commit_order[a].to_i }
+    end
+    
+    def read_if_needed
+      if @_read_complete
+        true
+      else
+        begin
+          read_index
+        rescue IndexFileNotFound => e
+          if @_tried_updating
+            raise e
+          else
+            @_tried_updating = true
+            update
+            retry
+          end
+        end
+      end
+    end
+
+    def read_index
+      raise IndexFileNotFound unless index_file_valid?
+      f = File.new(path)
+      @sha_count = 0
+      @commit_index = {}
+      @commit_order = {}
+      @all_files = {}
+      while line = f.gets
+        if /^(\w{40})/.match(line)
+          shas = line.scan(/(\w{40})/)
+          current_sha = shas.shift.first
+          parents = shas.map { |sha| sha.first }
+          parents = parents.delete_if { |sha| sha == '0'*40 }
+          @commit_index[current_sha] = {:files => [], :parents => parents }
+          @commit_order[current_sha] = @sha_count
+          @sha_count += 1
+        else
+          file_name = line.chomp
+          unless file_name.empty?
+            tree = ''
+            File.dirname(file_name).split('/').each do |part|
+              next if part == '.'
+              tree += part + '/'
+              @all_files[tree] ||= []
+              @all_files[tree].unshift(current_sha)
+            end
+            @all_files[file_name] ||= []
+            @all_files[file_name].unshift(current_sha)
+            @commit_index[current_sha][:files] << file_name
+          end
+        end
+      end
+      @_read_complete = true
+    end
+
+  end
+end