amp 0.5.2 → 0.5.3

data/lib/amp/support/openers.rb

@@ -19,7 +19,7 @@ module Amp
     def initialize(base)
       @root        = File.expand_path base
       @create_mode = nil
-      @default     = nil
+      @default     = :open_hg
     end
     
     ##
@@ -27,10 +27,15 @@ module Amp
     #
     # @return path to the opener's root, as an absolute path.
     def path
-      if @default == :open_file
+      case @default
+      when :open_file
         "#{root}/"
-      else
+      when :open_hg
         "#{root}/.hg/"
+      when :open_git
+        "#{root}/.git"
+      else
+        abort "Unknown opener format #{@default.inspect}"
       end
     end
     

data/lib/amp/support/support.rb

@@ -1,7 +1,6 @@
-
 require 'digest'
 
-if RUBY_VERSION < "1.9"
+if RUBY_VERSION < "1.9" || RUBY_VERSION >= "1.9.2"
   require 'ftools'
   
   autoload :Etc,      'etc'
@@ -9,6 +8,7 @@ if RUBY_VERSION < "1.9"
   autoload :Tempfile, 'tempfile'
   autoload :Socket,   'socket'
   autoload :WeakRef,  'weakref'
+  autoload :Find,     'find'
 else
   require 'fileutils'
   require 'socket'
@@ -16,6 +16,7 @@ else
   require 'etc'
   require 'tempfile'
   require 'weakref'
+  require 'find'
 end
 autoload :ERB,      'erb'
 
@@ -41,12 +42,6 @@ class AbortError < StandardError
   end
 end
 
-module Kernel
-  def abort(str)
-    AbortError.new str
-  end
-end
-
 class LockError < StandardError
   attr_reader :errno, :filename, :desc
   def initialize(errno, strerror, filename, desc)
@@ -187,6 +182,30 @@ class Module
     end
     self
   end
+  
+  ##
+  # Creates an opposite method based on a defined method:
+  # one that returns true if the base method returns false, and vice-versa.
+  #
+  # @param [Symbol] new_method The new method to define
+  # @param [Symbol] base_method the base method we use to define the opposite
+  #   method
+  def opposite_method(new_method, base_method)
+    class_eval <<-EOF
+def #{new_method}(*args, &block)
+  not #{base_method}(*args, &block)
+end
+EOF
+  end
+end
+
+class Object
+  
+  ##
+  # Because tap isn't defined in 1.8.6
+  def tap
+    yield self
+  end unless defined?(tap)
 end
 
 module Kernel
@@ -216,23 +235,32 @@ module Kernel
   #
   # @yield The block is run, and any exceptions raised print their full backtrace.
   def full_backtrace_please
-    message = ["***** Left engine failure *****",
-               "***** Ejection system error *****",
-               "***** Vaccuum in booster engine *****"
-              ][rand(3)]
     begin
       yield
     rescue AbortError => e
       Amp::UI.say "Operation aborted."
       raise
     rescue StandardError => e
+      message = ["***** Left engine failure *****",
+                 "***** Ejection system error *****",
+                 "***** Vaccuum in booster engine *****"
+                ][rand(3)]
       Amp::UI.say message
       Amp::UI.say e.to_s
       e.backtrace.each {|err| Amp::UI.say "\tfrom #{err}" }
-      exit
+      return
     end
   end
   
+  def amp_pause
+    Amp::UI.say "Amp is paused. Type 'go' and hit enter to continue"
+    until gets.strip == 'go'
+    end
+  end
+  
+  def abort(str)
+    AbortError.new str
+  end
 end
 
 class Dir
@@ -464,6 +492,7 @@ class File
   # @param  [Boolean] empty whether or not to return an empty string as well
   # @return [Array] the directories leading up to this path
   def self.amp_directories_to(path, empty=false)
+    path = File.expand_path(path)
     dirs = path.split('/')[0..-2]
     ret  = []
     
@@ -548,25 +577,41 @@ class Hash
   # @param  [Object] value (true) the value to assign each key to in the resultant hash
   # @return [Hash] a hash with keys from +iterable+, all set to +value+
   def self.with_keys(iterable, value=true)
-    iterable.inject({}) {|h, k| h.merge!(k => value) }
+    # we try to be functional when it doesn't fuck us over
+    # here, the list of keys will never be ridiculous
+    # so we go fuctional
+    iterable.inject({}) {|h, k| h[k] = value; h }
   end
   
   ##
   # Create a subset of +self+ with keys +keys+.
   def pick(*keys)
-    keys.inject({}) {|h, (k, v)| h[k] = v }
+    keys.inject({}) {|h, (k, v)| h[k] = v; h }
   end
   
+  ##
+  # Construct a new hash with only the specified +keyz+
+  # 
+  # @return [Hash]
+  def only(*keyz)
+    keyz.inject({}) {|h, k| h[k] = self[k]; h }
+  end
 end
 
 class Array
 
   ## 
-  # Sums all the items in the array
+  # Sums all the items in the array.
+  # 
+  # From activesupport-2.3.5, activesupport/lib/active_support/core_ext/enumerable.rb, line 57
   # 
   # @return [Array] the items summed
-  def sum
-    inject(0) {|sum, x| sum + x }
+  def sum(identity=0, &block)
+    if block_given?
+      map(&block).sum(identity)
+    else
+      inject { |sum, element| sum + element } || identity
+    end
   end
   
   ##
@@ -587,7 +632,7 @@ class Array
   end
   
   def to_hash
-    inject({}) {|h, (k, v)| h.merge k => v }
+    inject({}) {|h, (k, v)| h[k] = v; h }
   end
   
   def short_hex
@@ -627,18 +672,6 @@ class Integer
   alias_method :gigabyte, :gigabytes
   alias_method :gb,       :gigabytes
   
-  
-  ##
-  # Forces this integer to be negative if it's supposed to be!
-  # 
-  # @param [Fixnum] bits the number of bits to use - signed shorts are different from
-  #   signed longs!
-  def to_signed(bits)
-    return to_signed_16 if bits == 16
-    return to_signed_32 if bits == 32
-    raise "Unexpected number of bits: #{bits}"
-  end
-  
 end
 
 class String
@@ -648,18 +681,32 @@ class String
   # @param [String] color_code a TTY color code
   # @return [String] the string wrapped in non-printing characters to make the text
   #   appear in a given color
-  def colorize(color_code)
-    "#{color_code}#{self}\e[0m"
+  def colorize(color_code, closing_tag = 39)
+    "\e[#{color_code}m#{self}\e[#{closing_tag}m"
+  end
+  
+  [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white].tap do |list|
+    list.each_with_index do |arg, idx|
+      define_method(arg) { colorize(30 + idx, 39) }
+      define_method("on_#{arg}") { colorize(40 + idx, 49) }
+    end
+    define_method :color do |*args|
+      result = self
+      args.each do |arg|
+        if arg.to_s[0,3] == "on_"
+        then base = 40; arg = arg.to_s[3..-1].to_sym
+        else base = 30
+        end
+        result = result.colorize(base + list.index(arg), base + 9)
+      end
+      result
+    end
   end
   
   # Returns the string, colored red.
-  def red; colorize("\e[31m"); end
-  def green; colorize("\e[32m"); end
-  def yellow; colorize("\e[33m"); end
-  def blue; colorize("\e[34m"); end
-  def magenta; colorize("\e[35m"); end
-  def cyan; colorize("\e[36m"); end
-  def white; colorize("\e[37m"); end
+  def bold; colorize(1, 22); end
+  def underline; colorize(4, 24); end
+  def blink; colorize(5, 25); end
   
   ##
   # Returns the path from +root+ to the path represented by the string. Will fail
@@ -677,12 +724,12 @@ class String
   
   # Am I equal to the NULL_ID used in revision logs?
   def null?
-    self == Amp::RevlogSupport::Node::NULL_ID
+    self == Amp::Mercurial::RevlogSupport::Node::NULL_ID
   end
   
   # Am I not equal to the NULL_ID used in revision logs?
   def not_null?
-    !(null?)
+    !null?
   end
   
   ##
@@ -1081,11 +1128,9 @@ module Amp
     # architecture, and upates the SYSTEM[] hash in the Support module.
     def self.determine_endianness
       num = 0x12345678
-      little = '78563412'
-      big    = '12345678'
       native = [num].pack('l')
-      netunpack = native.unpack('N')
-      if native == netunpack
+      netunpack = native.unpack('N')[0]
+      if num == netunpack
         SYSTEM[:endian] = :big
       else
         SYSTEM[:endian] = :little

data/lib/amp/templates/template.rb

@@ -7,7 +7,7 @@ module Amp
     # Class representing a template in the amp system
     class Template
       
-      @all_templates = {}
+      @all_templates = Hash.new {|h, k| h[k] = {} }
       class << self
         attr_accessor :all_templates
         
@@ -16,9 +16,9 @@ module Amp
         #
         # @param [String, Symbol, #to_sym] template the name of the template to retrieve
         # @return [Template] the template with the given name
-        def [](template)
+        def [](type, template)
           ensure_templates_loaded
-          return all_templates[template.to_sym]
+          return all_templates[type.to_sym][template.to_sym]
         end
         
         ##
@@ -26,8 +26,8 @@ module Amp
         #
         # @param [String, Symbol, #to_sym] name the name of the template. Should be unique.
         # @param [Template] template the template to register.
-        def register(name, template)
-          all_templates[name.to_sym] = template
+        def register(type, name, template)
+          all_templates[type.to_sym][name.to_sym] = template
         end
         
         ##
@@ -36,9 +36,9 @@ module Amp
         #
         # @param [String, Symbol, #to_sym] name the name of the template to remove from
         #   the system.
-        def unregister(name)
-          raise ArgumentError.new("Unknown template: #{name}") unless all_templates[name.to_sym]
-          all_templates.delete name.to_sym
+        def unregister(type, name)
+          raise ArgumentError.new("Unknown template: #{name}") unless all_templates[type.to_sym][name.to_sym]
+          all_templates[type.to_sym].delete name.to_sym
         end
         
         ##
@@ -53,9 +53,10 @@ module Amp
         # Registers the default templates. Separated into a method (instead of automatically
         # run) because templates aren't used enough to justify the IO hit from loading them in.
         def load_default_templates
-          Dir[File.expand_path(File.join(File.dirname(__FILE__), "*.erb"))].each do |f|
+          Dir[File.expand_path(File.join(File.dirname(__FILE__), "**/*.erb"))].each do |f|
             name = f.split('/').last.chomp('.erb').sub('.','-')
-            FileTemplate.new(name, f)
+            type = f.split('/')[-2]
+            FileTemplate.new(type, name, f)
           end
         end
         
@@ -69,6 +70,7 @@ module Amp
           instance_eval do
             def ensure_templates_loaded; end
           end
+          true
         end
       end
       
@@ -83,9 +85,9 @@ module Amp
       # @param [Symbol] type the type of the template. Indicates the renderer used.
       # @param [String] text the text of the template, which presumably has some templating
       #   code to substitute in local variables and make a nice output system.
-      def initialize(name, renderer = :erb, text = "")
+      def initialize(type, name, renderer = :erb, text = "")
         @name, @renderer, @text = name, renderer, text
-        Template.register(name, self)
+        Template.register(type, name, self)
       end
       
       ##
@@ -103,7 +105,7 @@ module Amp
         case renderer.to_sym
         when :erb
           require 'erb'
-          locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
+          locals_assigns = locals.map { |k,v| "#{k} = locals[:#{k}]" }
           eval locals_assigns.join("\n"), render_binding
           
           erb = ERB.new(text, 0, "-")
@@ -128,17 +130,17 @@ module Amp
     class FileTemplate < Template
       KNOWN_EXTENSIONS = ["erb", "haml"]
     
-      attr_accessor :file        
+      attr_accessor :file
       
       ##
       # Initializes a new FileTemplate with different 
-      def initialize(name, file, renderer = nil)
+      def initialize(type, name, file, renderer = nil)
         if renderer.nil?
           renderer = KNOWN_EXTENSIONS.select {|ext| file.end_with? ext}.first
         end
         raise ArgumentError.new("No renderer specified for #{file.inspect}") if renderer.nil?
         @file = file
-        super(name, renderer, File.read(file))
+        super(type, name, renderer, File.read(file))
       end
       
       def save!
@@ -146,8 +148,6 @@ module Amp
       end
     end
     
-    
-    
   end
 end
 

data/man/amp.1

@@ -0,0 +1,51 @@
+.Dd January 10, 2010
+.Os
+.Dt amp 1
+.Sh NAME
+.Nm amp
+.Nd Ruby-based VCS engine
+.Sh SYNOPSIS
+.Nm
+.Op Fl d
+.Op Fl verbose
+.Op Fl profile
+.Op Fl R Ar repo_dir
+.Op Fl pure-ruby
+.Op Fl testing
+.Ar command ...
+.Sh DESCRIPTION
+  Amp is a revolutionary change in how we approach version control systems. Not only does it re-implement
+Mercurial's core in Ruby, but re-thinks how we interact with version control. It intends to wrap multiple
+VCS systems - git, hg, svn - under the same API, allowing the unique Amp command system to work with all
+repositories in the same manner.
+
+  Amp currently implements Mercurial and a large subset of the Mercurial command-set.
+.Bl -tag -width "mmmmmmmmmm" -compact
+.Pp
+.It Fl verbose
+Enables verbose output for the entire Amp process.
+.Pp
+.It Fl d
+Prings a variety of debug information about the arguments and options passed into amp.
+.Pp
+.It Fl profile
+Profiles the amp process as it runs the requested command. Deprecated and unwise.
+.Pp
+.It Fl R Ar repo_dir
+The path to the repository to use
+.Pp
+.It Fl pure-ruby
+Use only pure ruby (no C-extensions)
+.Pp
+.It Fl testing
+Running a test. Don't touch this.
+.El
+.Pp
+.Sh SEE ALSO
+.Xr git 1
+.Xr hg 1
+.Xr ruby 1
+.Xr amprc 5
+.Sh AUTHORS
+.An "Michael Edgar" Aq adgar@carboni.ca
+.An "Ari Brown" Aq seydar@carboni.ca