mercurial-ruby 0.3.0

data/lib/mercurial-ruby/helper.rb

@@ -0,0 +1,23 @@
+module Mercurial
+  
+  module Helper
+    
+    def hg(cmd)
+      repository.shell.hg(cmd)
+    end
+    
+    def shell(cmd)
+      repository.shell.run(cmd)
+    end
+    
+    def hg_to_array(cmd, separator="\n", &block)
+      [].tap do |returning|
+        hg(cmd).split(separator).each do |line|
+          returning << block.call(line)
+        end
+      end.compact
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/hook.rb

@@ -0,0 +1,23 @@
+module Mercurial
+  
+  class Hook
+    
+    attr_reader :repository, :name, :value
+    
+    def initialize(repository, name, value)
+      @repository = repository
+      @name = name
+      @value = value
+    end
+    
+    def save
+      repository.config.add_setting('hooks', name, value)
+    end
+    
+    def destroy!
+      repository.config.delete_setting!('hooks', name)
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/manifest.rb

@@ -0,0 +1,58 @@
+module Mercurial
+  
+  #
+  # Represents Mercurial manifest file. Use this class to get manifest's contents
+  # and scan it for file paths at specific revisions.
+  #
+  # Read more about Mercurial manifest:
+  #
+  # http://mercurial.selenic.com/wiki/Manifest
+  #
+  class Manifest
+    include Mercurial::Helper
+    
+    # Instance of {Mercurial::Repository Repository}.
+    attr_reader :repository
+    
+    def initialize(repository)
+      @repository = repository
+    end
+    
+    # Returns contents of the manifest as a String at a specified revision.
+    # Latest version of the manifest is used if +revision+ is ommitted.
+    #
+    # == Example:
+    #  repository.manifest.contents
+    #
+    def contents(revision=nil)
+      revision ||= 'tip'
+      hg(manifest_cmd(revision))
+    end
+    
+    # Returns an array of file paths from manifest that start with the specified +path+ at a specified +revision+.
+    # Latest version of the manifest is used if +revision+ is ommitted.
+    #
+    # == Example:
+    #  repository.manifest.scan_for_path('/')
+    #  repository.manifest.scan_for_path('some-interesting-directory/', '2d32410d9629')
+    #
+    def scan_for_path(path, revision=nil)
+      revision ||= 'tip'
+      path = path.without_trailing_slash
+      if path == '/' || path == ''
+        search_for = ".*"
+      else
+        path_re = Regexp.escape(path)
+        search_for = "#{ path_re }$|#{ path_re }\/.*"
+      end
+      contents(revision).scan(/^(\w{40}) (\d{3}) (\*?) +(#{ search_for })/)
+    end
+    
+  private
+  
+    def manifest_cmd(revision)
+      ["manifest -r ? --debug", revision]
+    end
+  end
+    
+end

data/lib/mercurial-ruby/node.rb

@@ -0,0 +1,100 @@
+module Mercurial
+  
+  #
+  # The class represents Mercurial file or directory. Data obtained by scanning +hg manifest+ output.
+  #
+  # The class represents Node object itself, {Mercurial::NodeFactory NodeFactory} is responsible
+  # for assembling instances of Node. For the list of all possible branch-related operations please 
+  # look documentation for {Mercurial::NodeFactory NodeFactory}.
+  #
+  # Additionally {Mercurial::Manifest Manifest} is responsible for reading and scanning the manifest.
+  #
+  class Node
+    include Mercurial::Helper
+    
+    # Instance of {Mercurial::Repository Repository}.
+    attr_reader :repository
+    
+    # Absolute path to the node.
+    attr_reader :path
+    
+    # File mode of the node in Octal notation (if file).
+    attr_reader :fmode
+    
+    # Executable flag of the node (if file).
+    attr_reader :executable
+    
+    # nodeid value for the node (if file).
+    attr_reader :nodeid
+    
+    # Node's parent, instance of {Mercurial::Node Node}.
+    attr_reader :parent
+    
+    def initialize(opts={})
+      @repository = opts[:repository]
+      @path       = opts[:path]
+      @parent     = opts[:parent]
+      @name       = opts[:name]
+      @fmode      = opts[:fmode]
+      @executable = opts[:executable] == '*' ? true : false
+      @revision   = opts[:revision]
+      @nodeid     = opts[:nodeid]
+    end
+    
+    def name
+      @name ||= begin
+        n = path.split('/').last
+        n << '/' if path =~ /\/$/
+        n
+      end
+    end
+    
+    def revision
+      @revision || (parent ? parent.revision : nil) || 'tip'
+    end
+    
+    def path_without_parent
+      if parent
+        path.gsub(/^#{ Regexp.escape(parent.path) }/, '')
+      else
+        path
+      end
+    end
+    
+    def entries
+      @_entries ||= repository.nodes.entries_for(path, revision, self)
+    end
+    
+    def has_entry?(name)
+      entries.find do |e|
+        e.name == name
+      end
+    end
+    
+    def directory?
+      not file?
+    end
+    
+    def file?
+      (name =~ /\/$/).nil?
+    end
+    
+    def root?
+      false
+    end
+    
+    def binary?
+      false
+    end
+    
+    def contents
+      hg(["cat ? -r ?", path, revision])
+    end
+    
+    def size
+      contents.size
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/repository.rb

@@ -0,0 +1,94 @@
+module Mercurial  
+  class RepositoryNotFound < Error; end
+  
+  class Repository
+    
+    def self.create(destination)
+      init_repository(destination)      
+    end
+    
+    def self.open(destination)
+      if File.exists?(destination)
+        new(destination)
+      else
+        raise Mercurial::RepositoryNotFound.new(destination)
+      end
+    end
+    
+    def initialize(source)
+      @path = source
+    end
+    
+    def shell
+      @_shell ||= Mercurial::Shell.new(self)
+    end
+    
+    def config
+      @_config ||= Mercurial::ConfigFile.new(self)
+    end
+    
+    def hooks
+      @_hook_factory ||= Mercurial::HookFactory.new(self)
+    end
+    
+    def commits
+      @_commits ||= Mercurial::CommitFactory.new(self)
+    end
+    
+    def branches
+      @_branches ||= Mercurial::BranchFactory.new(self)
+    end
+    
+    def tags
+      @_tags ||= Mercurial::TagFactory.new(self)
+    end
+    
+    def diffs
+      @_diffs ||= Mercurial::DiffFactory.new(self)
+    end
+    
+    def nodes
+      @_nodes ||= Mercurial::NodeFactory.new(self)
+    end
+    
+    def manifest
+      @_manifest ||= Mercurial::Manifest.new(self)
+    end
+    
+    def file_index
+      @_file_index ||= Mercurial::FileIndex.new(self)
+    end
+    
+    def node(name, hash_id)
+      nodes.find(name, hash_id)
+    end
+    
+    def destroy!
+      FileUtils.rm_rf(path)
+    end
+    
+    def path
+      File.expand_path(@path)
+    end
+    
+    def dothg_path
+      File.join(path, '.hg')
+    end
+    
+    def mtime
+      File.mtime(dothg_path).to_i
+    end
+    
+  protected
+  
+    def self.init_repository(destination)
+      Mercurial::Shell.run("mkdir -p #{ destination }")
+      open(destination).tap do |repo|
+        repo.shell.hg('init', :cache => false)
+        repo.shell.hg('update null', :cache => false)
+      end
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/root_node.rb

@@ -0,0 +1,27 @@
+module Mercurial
+  
+  class RootNode < Node
+    
+    def directory?
+      true
+    end
+    
+    def file?
+      false
+    end
+    
+    def root?
+      true
+    end
+    
+    def binary?
+      false
+    end
+    
+    def path
+      ''
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/shell.rb

@@ -0,0 +1,64 @@
+module Mercurial
+  
+  class Shell
+    
+    attr_reader :repository
+    
+    def self.run(cmd, options={})
+      options[:cache] = true if options[:cache].nil?
+      build = []
+
+      if options[:in]
+        build << "cd #{ options[:in] }"
+      end
+      
+      if cmd.kind_of?(Array)
+        cmd = interpolate_arguments(cmd)
+      end
+
+      build << cmd
+      to_run = build.join(' && ')
+      Mercurial::Command.new(to_run, :repository => options[:repository], :cache => options[:cache]).execute
+    end
+    
+    def initialize(repository)
+      @repository = repository
+    end
+    
+    def hg(cmd, options={})
+      options[:in] ||= repository.path
+      options[:repository] = repository
+      cmd = append_command_with(hg_binary_path, cmd)
+      run(cmd, options)
+    end
+    
+    def run(cmd, options={})
+      self.class.run(cmd, options)
+    end
+    
+  private
+  
+    def hg_binary_path
+      Mercurial.configuration.hg_binary_path
+    end
+    
+    def self.interpolate_arguments(cmd_with_args)
+      cmd_with_args.shift.tap do |cmd|
+        cmd.gsub!(/\?/) do
+          cmd_with_args.shift.to_s.enclose_in_single_quotes
+        end
+      end
+    end
+    
+    def append_command_with(append, cmd)
+      if cmd.kind_of?(Array)
+        cmd[0].insert(0, "#{ append } ")
+        cmd
+      else
+        "#{ append } #{ cmd }"
+      end
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/style.rb

@@ -0,0 +1,23 @@
+module Mercurial
+  
+  module Style
+    extend self
+    
+    FIELD_SEPARATOR = '|><|'
+    CHANGESET_SEPARATOR = "||$||\n"
+    
+    def root_path
+      File.expand_path(File.join(File.dirname(__FILE__), '..', 'styles'))
+    end
+    
+    def changeset
+      File.join(root_path, 'changeset.style')
+    end
+    
+    def file_index
+      File.join(root_path, 'file_index.style')
+    end
+    
+  end
+  
+end

data/lib/mercurial-ruby/tag.rb

@@ -0,0 +1,33 @@
+module Mercurial
+  
+  #
+  # The class represents Mercurial tag. Obtained by running an +hg tags+ command.
+  #
+  # The class represents Tag object itself, {Mercurial::TagFactory TagFactory} is responsible
+  # for assembling instances of Tag. For the list of all possible tag-related operations please 
+  # look documentation for {Mercurial::TagFactory TagFactory}.
+  #
+  # Read more about Mercurial tags:
+  #
+  # http://mercurial.selenic.com/wiki/Tag
+  #
+  class Tag
+    
+    # Instance of {Mercurial::Repository Repository}.
+    attr_reader :repository
+    
+    # Name of the tag.
+    attr_reader :name
+    
+    # Mercurial changeset ID of the tag. 40-chars long SHA1 hash.
+    attr_reader :hash_id
+    
+    def initialize(repository, name, hash_id)
+      @repository = repository
+      @name       = name
+      @hash_id    = hash_id
+    end
+    
+  end
+  
+end