amp 0.5.2 → 0.5.3

data/lib/amp/repository/repository.rb

@@ -1,94 +1,17 @@
 module Amp
   module Repositories
-    
-    def self.pick(config, path='', create=false)
-      # hot path so we don't load the HTTP repos!
-      unless path[0,4] == "http"
-        return LocalRepository.new(find_repo(path), create, config)
-      end
-      return HTTPSRepository.new(path, create, config) if path[0,5] == "https"
-      return HTTPRepository.new(path, create, config)  if path[0,4] == "http"
-    end
-    
-    def self.find_repo path
-      while !(File.directory?(File.join(path, ".hg")))
-        old_path, path = path, File.dirname(path)
-        if path == old_path
-          raise "No Repository Found"
-        end
-      end
-      path
-    end
-    
-    class RepositoryCapabilityError < StandardError; end
     class RepoError < StandardError; end
     
-    ##
-    # = Repository
-    # This is an abstract class that represents a repository.
-    # All repositories must inherit from this class.
-    class Repository
-      
-      ##
-      # Is this repository capable of the given action/format? Or, if the capability
-      # has a value assigned to it (like "revlog" = "version2"), what is it?
-      # 
-      # @param [String] capability the name of the action/format/what have you that we need to test
-      # @return [Boolean, String] whether or not we support the given capability; or, for
-      #   capabilities that have a value, the string value.
-      def capable?(capability)
-        get_capabilities
-        @capabilities[capability]
-      end
-      
-      ##
-      # No-op, to be implemented by remote repo classes.
-      def get_capabilities; end
-      
-      ##
-      # Raises an exception if we don't have a given capability.
-      # 
-      # @param [String] capability what capability we are requiring
-      # @param [String] purpose why we need it - enhances the output
-      # @raise [RepositoryCapabilityError] if we don't support it, this is raised
-      def require_capability(capability, purpose)
-        get_capabilities
-        raise RepositoryCapabilityError.new(<<-EOF
-        Can't #{purpose}; remote repository doesn't support the #{capability} capability.
-        EOF
-        ) unless @capabilities[capability]
-      end
-      
-      ##
-      # is the repository a local repo?
-      # 
-      # @return [Boolean] is the repository local?
-      def local?
-        false
-      end
-      
-      ##
-      # can we copy files? Only for local repos.
-      # 
-      # @return [Boolean] whether we are able to copy files
-      def can_copy?
-        local?
+    # make this git-hg-svn-cvs-whatever friendly!
+    def self.pick(config, path='', create=false)
+      GenericRepoPicker.each do |picker|
+        return picker.pick(config, path, create) if picker.repo_in_dir?(path)
       end
       
-      ##
-      # Joins the given path with our URL. Necessary due to the difference between local
-      # and remote repos.
-      # 
-      # @param [String] path the path we are appending
-      # @return [String] our URL joined with the requested path
-      def add_path(path)
-        myurl = self.url
-        if myurl.end_with? '/'
-          myurl + path
-        else
-          myurl + '/' + path
-        end
-      end
-    end
-  end
-end
+      # We have found... nothing
+      nil
+    end # def self.pick
+    
+  end # module Repositories
+  
+end # module Amp

data/lib/amp/server/extension/amp_extension.rb

@@ -144,7 +144,7 @@ module Sinatra
     def amp_get_capabilities(amp_repo)
       caps = ["lookup", "changegroupsubset"]
       # uncompressed for streaming?
-      caps << "unbundle=#{Amp::RevlogSupport::ChangeGroup::FORMAT_PRIORITIES.join(',')}"
+      caps << "unbundle=#{Amp::Mercurial::RevlogSupport::ChangeGroup::FORMAT_PRIORITIES.join(',')}"
       caps.join ' '
     end
     
@@ -380,11 +380,11 @@ module Sinatra
         header = fp.read(6)
         if header.start_with?("HG") && !header.start_with?("HG10")
           raise ArgumentError.new("unknown bundle version")
-        elsif !Amp::RevlogSupport::ChangeGroup::BUNDLE_HEADERS.include?(header)
+        elsif !Amp::Mercurial::RevlogSupport::ChangeGroup::BUNDLE_HEADERS.include?(header)
           raise ArgumentError.new("unknown bundle compression type")
         end
         
-        stream = Amp::RevlogSupport::ChangeGroup.unbundle(header, fp)
+        stream = Amp::Mercurial::RevlogSupport::ChangeGroup.unbundle(header, fp)
         
       end
       

data/lib/amp/server/fancy_http_server.rb

@@ -108,7 +108,7 @@ module Amp
         
         def load_browser_info(changeset, path)
           
-          mapping = changeset.manifest
+          mapping = changeset.manifest_entry
           orig_path = nil
           # if the path is a file (because we only keep track of files)
           if mapping[path]

data/lib/amp/server/fancy_views/_browser.haml

@@ -14,7 +14,7 @@
   - file_list.each do |file|
     %tr{:class => (path + "/" + file[:link] == orig_path) ? "selected" : ""}
       - if file[:type] == :file
-        - fl = repo.file(path + '/' + file[:name])
+        - fl = repo.file_log(path + '/' + file[:name])
         - last = fl.index[-2].link_rev
       %td.filename
         = link_to_file root, changeset_node, file[:link], :text => file[:name]

data/lib/amp/server/fancy_views/_diff_file.haml

@@ -1,13 +1,6 @@
 - vf_cur = changeset.get_file file
-- new_rev = vf_cur.file_rev
-- parents = vf_cur.parents
 - vf_parent = parents.first
-- parent_rev = vf_parent && vf_parent.file_rev
-- old_date = vf_parent && vf_parent.changeset.easy_date
-- new_date = changeset.easy_date
-- new_path = vf_cur.path
-- old_path = vf_parent ? vf_parent.path : "/dev/null"
 %li
   %h2= vf_cur.path
   %ul.diff
-    = parse_diff(vf_cur.file_log.unified_revision_diff(parent_rev, old_date, new_rev, new_date, old_path, new_path))
+    = parse_diff(vf_cur.unified_diff_with(vf_parent))

data/lib/amp/server/fancy_views/changeset.haml

@@ -25,7 +25,7 @@
               %td.data= @changeset.children.map {|c| link_to_changeset(root, c.node_id.hexlify) }.join(" ")
             %tr
               %td.label files
-              %td.data= @changeset.files.map {|file| link_to_file(root, @changeset.node_id.hexlify, file) }.join("<br />")
+              %td.data= @changeset.changed_files.keys.map {|file| link_to_file(root, @changeset.node_id.hexlify, file) }.join("<br />")
         %ul.diff-list
-          - @changeset.files.each do |file|
+          - @changeset.changed_files.keys.each do |file|
             = haml :_diff_file, :locals => {:file => file, :changeset => @changeset}

data/lib/amp/server/fancy_views/file.haml

@@ -13,7 +13,7 @@
         = haml :_browser, :locals => {:root => root, :vf_cur => vf_cur, :path => path, :orig_path => orig_path, :file_list => file_list, :changeset_node => changeset_node, :repo => repo}
         .browser-file
           - if vf_cur
-            - filelog = repo.file orig_path
+            - filelog = repo.file_log orig_path
             %h2.header Versions
             %ul.versions
               - filelog.each do |rev|

data/lib/amp/server/fancy_views/file_diff.haml

@@ -13,7 +13,7 @@
         = haml :_browser, :locals => {:root => root, :vf_cur => vf_cur, :path => path, :orig_path => orig_path, :file_list => file_list, :changeset_node => changeset_node, :repo => repo}
         .browser-file
           - if vf_cur
-            - filelog = repo.file orig_path
+            - filelog = repo.file_log orig_path
             %h2.header Versions
             %ul.versions
               - filelog.each do |rev|

data/lib/amp/support/amp_ui.rb

@@ -19,8 +19,9 @@ module Amp
     # @return [UIMenu] the new menu
     def initialize
       @choices = []
-      @prompt = "Pick an option, please."
-      @index = :number
+      @prompt  = "Pick an option, please."
+      @index   = :number
+      @config  = nil
     end
     
     ##
@@ -60,7 +61,6 @@ module Amp
   
   module UI
     extend self
-    extend Amp::Merges::MergeUI
     
     class << self
       attr_accessor :config
@@ -72,7 +72,7 @@ module Amp
     #
     # @param [#to_s] warning the warning to print to standard output
     def warn(warning)
-      if !@config || @config["ui","amp-show-warnings",Boolean,true]
+      if !config || config["ui", "amp-show-warnings", Boolean, true]
         err "warning: #{warning}"
       end
     end
@@ -112,7 +112,7 @@ module Amp
     # @return [NilClass]
     def status(update='')
       return unless $display
-      if !@config || @config["ui", "amp-show-status", Boolean, true]
+      if !config || config["ui", "amp-show-status", Boolean, true]
         say "status: #{update}"
       end
     end
@@ -124,7 +124,7 @@ module Amp
     # @return [NilClass]
     def note(note='')
       return unless $display
-      if !@config || @config["ui", "amp-show-notes", Boolean, false]
+      if !config || config["ui", "amp-show-notes", Boolean, false]
         say "note: #{note}"
       end
     end
@@ -165,8 +165,8 @@ module Amp
     def ask(question='', type=String)
       type = type.to_s.downcase.to_sym
       
-      print question.to_s
-      result = gets.chomp unless type == :password
+      tell question.to_s
+      result = $stdin.gets.chomp unless type == :password
       
       # type conversion
       case type
@@ -174,6 +174,8 @@ module Amp
         result
       when :integer, :fixnum, :bignum, :numeric
         result.to_i
+      when :float
+        result.to_f
       when :array
         result.split(',').map {|e| e.strip }
       when :password
@@ -225,7 +227,7 @@ EOS
     #
     # @param [String, #to_s] message The debug message to be printed
     def debug(message='')
-      if @config && @config["debug","messages", Boolean, false]
+      if config && config["debug","messages", Boolean, false]
         say message
       end
     end
@@ -245,7 +247,7 @@ EOS
       tempfile.write text
       tempfile.close
       
-      ENV["AMPUSER"] = username
+      ENV["HGUSER"] = username
       edit_file path
       
       text = File.open(path) {|tf| tf.read } || ''
@@ -255,24 +257,6 @@ EOS
       text.gsub!(/^AMP:.*\n/,"")
       text
     end
-    
-    ##
-    # Asks the user something.
-    # 
-    # @deprecated
-    # @param [#to_s] message the message to send
-    # @param [Class, lambda] type anything to force a type. If you supply
-    #   a class, then the answer will be parsed into that class. If you
-    #   supply a lambda, the string will be provided, and you do the conversion
-    # @param [] default Whatever the default answer is, if they fail to provide
-    #   a valid answer.
-    # @return [String] their response with whitespace removed, or the default value
-    def prompt(message='', type=String, default=nil)
-      say message.to_s
-      response = STDIN.gets.strip
-      response = default if response == ""
-      return response
-    end
       
     ##
     # Gets the editor for the current system using environment variables or 
@@ -280,7 +264,7 @@ EOS
     #
     # @return [String] the name of the editor command to execute
     def get_editor
-      return ENV["AMPEDITOR"] || ENV["HGEDITOR"] || (@config && @config["ui","editor"]) ||
+      return ENV["AMPEDITOR"] || ENV["HGEDITOR"] || (config && config["ui","editor"]) ||
              ENV["VISUAL"] || ENV["EDITOR"] || "vi"
     end
   end

data/lib/amp/support/generator.rb

@@ -43,7 +43,7 @@ class Generator
     # return to its caller.
     callcc do |here|
       @current_context = here
-      if @yield_context
+      if (@yield_context ||= nil)
         # Run next iteration of the running loop
         @yield_context.call
       else

data/lib/amp/support/loaders.rb

@@ -76,7 +76,6 @@ private :caller_file
 # @param [String] path_to_alt the path to the pure ruby version of the C library. Will
 #   be loaded relative to the caller's file
 def amp_c_extension(path_to_c, path_to_alt)
-  
   if $USE_RUBY
     Amp::UI.debug "Loading alternative ruby: #{path_to_alt}"
     require File.join(File.dirname(caller_file(1)), path_to_alt)
@@ -85,7 +84,7 @@ def amp_c_extension(path_to_c, path_to_alt)
   
   begin
     offset = RUBY_VERSION < "1.9" ? 1 : 0
-    require File.expand_path(File.join(File.dirname(caller_file(offset)), path_to_c))
+    require path_to_c #File.expand_path(File.join(File.dirname(caller_file(offset)), path_to_c))
   rescue LoadError # C Version could not be found, try ruby version
     Amp::UI.debug "Loading alternative ruby: #{path_to_alt}"
     require File.join(File.dirname(caller_file(1)), path_to_alt)

data/lib/amp/support/logger.rb

@@ -2,17 +2,16 @@ require 'delegate'
 require 'logger'
 module Amp
   module Support
+    LOGGER_LEVELS = [:warn, :info, :fatal, :error, :debug]
     module SingletonLogger
       attr_accessor :singleton_object
       def global_logger
         singleton_object
       end
       
-      def warn(*args);  global_logger.warn(*args);  end
-      def info(*args);  global_logger.info(*args);  end
-      def fatal(*args); global_logger.fatal(*args); end
-      def error(*args); global_logger.error(*args); end
-      def debug(*args); global_logger.debug(*args); end
+      LOGGER_LEVELS.each do |message|
+        define_method(message) { |*args| global_logger.send(message, *args) }
+      end
       
       def method_missing(meth, *args, &block)
         if global_logger.respond_to?(meth)
@@ -28,11 +27,9 @@ module Amp
         @output = output
       end
       
-      def warn(input); @output.puts(input); end
-      def info(input); @output.puts(input); end
-      def fatal(input); @output.puts(input); end
-      def error(input); @output.puts(input); end
-      def debug(input); @output.puts(input); end
+      LOGGER_LEVELS.each do |message|
+        define_method(message) {|input| @output.puts(input) }
+      end
     end
     
     class Logger < DelegateClass(::Logger)
@@ -72,12 +69,9 @@ module Amp
         self
       end
       
-      def warn(input);  @source.warn( "\t\t"*@indent + input); self; end
-      def info(input);  @source.info( "\t\t"*@indent + input); self; end
-      def fatal(input); @source.fatal("\t\t"*@indent + input); self; end
-      def error(input); @source.error("\t\t"*@indent + input); self; end
-      def debug(input); @source.debug("\t\t"*@indent + input); self; end
-      
+      LOGGER_LEVELS.each do |message|
+        define_method(message) { |input| @source.send(message, "\t\t"*@indent + input); self }
+      end
       
       def level=(level)
         receiver = @source

data/lib/amp/support/match.rb

@@ -10,7 +10,7 @@ module Amp
   # their Match class, because we needed access to three things from this
   # one object: the explicit files passed, the includes, and the excludes.
   class Match
-    extend Ignore
+    extend Mercurial::Ignore
     
     attr_reader :block
     attr_reader :files
@@ -109,6 +109,21 @@ module Amp
       @exclude && @exclude.any? {|r| file =~ r}
     end
     
+    ##
+    # Filters a list of filenames, weeding out ones that do not match at all.
+    # 
+    # @param [Array<String>] list a list of filenames to run against the matcher
+    # @param [Hash] opts options for filtering. See below.
+    # @option opts [Boolean] :precision (false) returns the list not as a list of
+    #    filenames, but as a list of hashes, with a key :filename for the file, and
+    #    a key :exact with a boolean value specifying if the match was exact or not.
+    # @return [Array<String>] the filtered list of filenames
+    def filter_list(list, opts={})
+      result = list.select {|filename| self.call(filename)}
+      result.map! {|k| {:filename => k, :exact => exact?(k)}} if opts[:precision]
+      result
+    end
+    
     ##
     # Is it an exact match or an approximate match and not
     # a file to be excluded?
@@ -119,11 +134,10 @@ module Amp
     # @param [String] file the file to test
     # @return [Boolean] does it pass?
     def call(file)
-      if exact? file and failure? file
+      if exact?(file) && failure?(file)
         raise StandardError.new("File #{file.inspect} is to be both included and excluded")
       end
-      # `and` because it's loosely binding
-      exact?(file) || included?(file) || approximate?(file) and !failure?(file)
+      (exact?(file) || included?(file) || approximate?(file)) && !failure?(file)
     end
     alias_method :[], :call
     

data/lib/amp/support/mercurial/ignore.rb

@@ -0,0 +1,151 @@
+module Amp
+  module Mercurial
+    module Ignore
+      extend self
+      
+      COMMENT = /((^|[^\\])(\\\\)*)#.*/
+      SYNTAXES = {'re'      => :regexp,  'regexp' => :regexp, 'glob' => :glob,
+                  'relglob' => :relglob, 'relre'  => :regexp, 'path' => :glob,
+                  'relpath' => :relglob}
+      
+      ##
+      # Parses the ignore file, +file+ (or ".hgignore")
+      # 
+      # @param [String] root the root of the repo
+      # @param [Array<String>] files absolute paths to files
+      def parse_ignore(root, files=[])
+        real_files   = files.select {|f| File.exist? File.join(root, f) }
+        all_patterns = real_files.inject [] do |collection, file|  
+          text = File.read File.join(root, file)
+          collection.concat matcher_for_text(text) # i know this is evil
+        end # real_files.inject
+        
+        # here's the proc to do the tests
+        regexps_to_proc all_patterns
+      end
+      
+      ##
+      # Parse the lines into valid syntax. Removes empty lines.
+      # 
+      # @param [String] file and open file
+      def parse_lines(text)
+        lines = text.split("\n").inject [] do |lines, line|
+          line = strip_comment line
+          line.rstrip!
+          line.empty? ? lines : lines << line # I KNOW THIS IS EVIL
+        end
+      end
+      
+      ##
+      # Strips comments from a line of text
+      #
+      # @param [String] line the line of text to de-commentify
+      # @return [String] the same line of text, with comments removed.
+      def strip_comment(line)
+        if line =~ /#/
+          line.sub! COMMENT, "\\1"
+          line.gsub! "\\#", "#"
+        end
+        line
+      end
+      
+      ##
+      # Produces an array of regexps which can be used
+      # for matching files
+      # 
+      # @param [String] text the text to parse
+      # @return [Array<Regexp>] the regexps generated from the strings and syntaxes
+      def matcher_for_text(text)
+        return [] unless text
+        syntax   = nil
+        lines    = parse_lines(text).reject {|line| line.empty? }
+        
+        # take the lines and create a new array of the patterns
+        lines.inject [] do |lines, line|
+          # check for syntax changes
+          if line.start_with? "syntax:"
+            syntax = SYNTAXES[line[7..-1].strip] || :regexp
+            lines # move on
+          else
+            # I KNOW THIS IS EVIL
+            lines << parse_line(syntax, line) # could be nil, so we need to compact it
+          end
+        end # lines.inject
+      end
+      
+      ##
+      # Much like matcher_for_text, except tailored to single line strings
+      # 
+      # @see matcher_for_text
+      # @param [String] string the string to parse
+      # @return [Regexp] the regexps generated from the strings and syntaxes
+      def matcher_for_string(string)
+        scanpt = string =~ /(\w+):(.+)/
+        if scanpt.nil?
+          include_syntax = :regexp      # just a line, no specified syntax
+          include_regexp = string       # no syntax, thus whole thing is pattern
+        else
+          include_syntax = $1.to_sym    # the syntax is the first match
+          include_regexp = $2.strip     # the rest of the string is the pattern
+        end
+        parse_line include_syntax, include_regexp
+      end
+      
+      ##
+      # Turns a single line, given a syntax, into either
+      # a valid regexp or nil. If it is nil, it means the
+      # syntax was incorrect.
+      # 
+      # @param [Symbol] syntax the syntax to parse with (:regexp, :glob, :relglob)
+      # @param [String] line the line to parse
+      # @return [NilClass, Regexp] nil means the syntax was a bad choice
+      def parse_line(syntax, line)
+        return nil unless syntax
+        syntax = syntax.to_sym
+        # find more valid syntax stuff
+        # we need to make everything here valid regexps
+        case syntax
+        when :regexp
+          # basic regex
+          pattern = /#{line}/
+        when :glob, :relglob
+          # glob: glob (shell style), relative to the root of the repository
+          # relglob: glob, except we just match somewhere in the string, not
+          # from the root of the repository
+          ps = line.split '/**/'
+          ps.map! do |l|
+            parts = l.split '*' # split it up and we'll escape all the parts
+            parts.map! {|p| Regexp.escape p }
+            parts.join '[^/]*' # anything but a slash, ie, no change in directories
+          end
+          joined = ps.join '/(?:.*/)*'
+          pattern = syntax == :glob ? /^#{joined}/ : /#{joined}/
+        else
+          pattern = nil
+        end
+        
+        pattern
+      end
+      
+      ##
+      # Converts all the ignored regexps into a proc that matches against all of these
+      # regexps. That way we can pass around a single proc that checks if a file is ignored.
+      #
+      # @param [Array<Regexp>] regexps all of the regexes that we need to match against
+      # @return [Proc] a proc that, when called with a file's path, will return whether
+      #   it matches any of the regexps.
+      def regexps_to_proc(*regexps)
+        # flatten: because if you pass in an array vs. three single args
+        # compact: because #parse_line can return nil (and it will travel to here)
+        regexps = regexps.flatten.compact
+        if regexps.empty?
+          proc { false }
+        else
+          proc { |file| regexps.any? {|p| file =~ p } }
+        end
+      end
+      alias_method :regexp_to_proc, :regexps_to_proc
+      
+    end
+  end
+end