amp-pure 0.5.0

data/lib/amp/commands/command_support.rb

@@ -0,0 +1,137 @@
+module Amp
+  
+  module CommandSupport
+    # When a user specifies a range, REV_SEP is between the given revisions. 
+    REV_SEP = ":"
+    
+    ##
+    # Looks up the node ID of a given revision in the repository. Since this method uses
+    # Repository#lookup, the choices for "value" are very flexible. You can choose a
+    # revision number, a partial node ID, "tip", and so on. See LocalRepository#lookup
+    # for more details.
+    #
+    # @see {LocalRepository#lookup}
+    # @param [Repository] repo the repository in which to lookup the node
+    # @param [String, Integer] value the search term for the node - could be a revision
+    #   index #, a partial node ID, and so on
+    # @param [String, Integer] default the default search term, in case +value+ is nil.
+    # @return [String] the full node ID of the node that is found, or +nil+ if none is found.
+    def revision_lookup(repo, value, default = nil)
+      value ||= default
+      repo.lookup(value)
+    end
+    
+    ##
+    # Prints the statistics returned from an update or merge. These are given in the form
+    # of a hash, such as {:added => 0, :unresolved => 3, ...}, and should be printed
+    # in a nice manner.
+    #
+    # @param [Hash<Symbol => Fixnum>] stats the statistics resulting from an update, merge
+    #   or clean command.
+    def print_update_stats(stats)
+      Amp::UI.status stats.map {|note, files| "#{files.size} files #{note}" }.join(", ")
+    end
+      
+    ##
+    # Parses strings that represent a range of 
+    # 
+    # @example
+    #      revision_pair(repo, ["10:tip"])     #=> [repo.lookup(10), repo.lookup("tip")]
+    #      revision_pair(repo, ["10", "tip"])  #=> [repo.lookup(10), repo.lookup("tip")]
+    #      revision_pair(repo, ":tip")         #=> [repo.lookup(0),  repo.lookup("tip")]
+    # @param [Repository] repo the repository to use when looking up revisions
+    # @param [Array, String] revisions the revisions to parse. Could be a set of strings,
+    #   passed directly in from the command line, or could just be 1 string.
+    # @return [Array<String>] the node IDs that correspond to the start and end of the
+    #   specified range of changesets
+    def revision_pair(repo, revisions)
+      #revisions = [revisions] unless revisions.is_a?(Array)
+      if !revisions || revisions.empty?
+        return repo.dirstate.parents.first, nil
+      end
+      stop = nil
+      
+      if revisions.size == 1
+        #old revision compared with working dir?
+        if revisions[0].include? REV_SEP
+          start, stop = revisions.first.split REV_SEP, 2
+          start = revision_lookup repo, start, 0
+          stop  = revision_lookup repo, stop, repo.size - 1
+        else
+          start = revision_lookup repo, revisions.first
+        end
+      elsif revisions.size == 2
+        if revisions.first.include?(REV_SEP) ||
+           revisions.second.include?(REV_SEP)
+           raise ArgumentError.new("too many revisions specified")
+        end
+        start = revision_lookup(repo, revisions.first)
+        stop  = revision_lookup(repo, revisions.second)
+      else
+        raise ArgumentError.new("too many revisions specified")
+      end
+      [start, stop]
+    end
+    
+    # returns [String, Array || nil, String]
+    def parse_url(*arr)
+      url  = arr.shift
+      revs = arr.shift || []
+      
+      unless url =~ /#/
+        hds = revs.any? ? revs : []
+        return url, hds, revs[-1]
+      end
+      
+      url, branch = url.split('#')[0..1]
+      checkout = revs[-1] || branch
+      [url, revs + [branch], checkout]
+    end
+    
+    def local_path(path)
+      case path
+      when /file:\/\/localhost\//
+        path[17..-1]
+      when /file:\/\//
+        path[8..-1]
+      when /file:/
+        path[6..-1]
+      else
+        path
+      end
+    end
+    
+    # Return repository location relative to cwd or from [paths]
+    def expand_path(*arr)
+      loc  = arr.shift
+      dflt = arr.shift # dflt = default
+      cnfg = arr.pop   # always take the last
+    
+      return loc if loc =~ /:\/\// or File.directory?(File.join(loc, '.hg'))
+    
+      path = cnfg['paths'][loc]
+    
+      if !path && dflt
+        path = cnfg['paths'][dflt]
+      end
+      path || loc
+    end
+    
+    def log_message(message, logfile)
+      if message && logfile
+        raise abort('options --message and --logfile are mutually exclusive')
+      end
+      
+      if !message && logfile
+        begin
+          message = logfile == '-' ? $stdin.read : File.read(logfile)
+        rescue IOError => e
+          raise abort("can't read commit message '#{logfile}': #{e}")
+        end
+      end
+      
+      message
+    end
+    
+  end
+end

data/lib/amp/commands/commands/config.rb

@@ -0,0 +1,143 @@
+command :config do |c|
+  c.workflow :all
+  c.desc "Configure amp interactively."
+  c.help <<-HELP
+amp config
+
+enter an interactive configuration program to adjust Amp's settings
+This command:
+    
+    * Allows the user to adjust Amp's settings without knowledge of
+      how these settings are stored, knowing obscure invisible files
+      and their formats
+      
+    * Does not require that the user call it from within an amp repo-
+      sitory, as long as only global settings are changed.
+    
+HELP
+  c.maybe_repo
+  c.on_run do |opts, args|
+    repo = opts[:repository]
+    
+    Amp::UI.say "Welcome to the Amp configuration editor. Pull up a seat!"
+    while true
+      choice = nil
+      Amp::UI.choose do |menu|
+        menu.prompt = "Would you like to work with local settings (repo-specific), or global ones?"
+        menu.choice("Local Settings")  { choice = :local  }
+        menu.choice("Global Settings") { choice = :global }
+        menu.choice("Exit")            { exit(0) }
+      end
+      
+      case choice
+      when :local
+        config = opts[:global_config]
+      when :global
+        config = opts[:global_config]
+        while config.parent_config
+          config = config.parent_config
+        end
+      end
+      
+      choice = nil
+      Amp::UI.choose do |menu|
+        menu.prompt = "Would you like to view your configuration, or change settings?"
+        menu.choice("View Configuration") { choice = :view }
+        menu.choice("Change Settings")    { choice = :edit }
+        menu.choice("Remove Setting")     { choice = :remove }
+        menu.choice("Exit")               { }
+      end
+      
+      all_sections = config.config.sections.keys.map {|n| "[#{n}]"}.join(" ")
+      
+      case choice
+      when :view
+        Amp::UI.say config.to_s
+      when :edit
+        section = Amp::UI.ask("Which section of settings would you like to edit? You may choose "+
+                              "an existing section, or create a new one.\nCurrent sections:\n"+
+                              all_sections+"\n> ")
+        key = Amp::UI.ask("Which setting would you like to change? You may choose an existing "+
+                          "setting, or create a new one.\n Current settings: "+
+                          config[section].keys.map {|n| "#{n}"}.join(" ")+"\n> ")
+        value = Amp::UI.ask("What would you like to set [#{section}:#{key}] to? ")
+        config[section,key] = value
+        config.save!
+      when :remove
+        section = Amp::UI.ask("Which section of settings would you like to edit? You may choose "+
+                              "an existing section.\nCurrent sections:\n"+
+                              all_sections+"\n> ")
+        key = Amp::UI.ask("Which setting would you like to change? You may choose an existing "+
+                          "setting.\n Current settings: ["+
+                          config[section].keys.map {|n| "#{n}"}.join(" ")+"]\n> ")
+        config[section].delete key
+        config.save!
+      end
+    end
+  end
+end
+
+namespace :config do
+  command :set do |c|
+    c.workflow :all
+    c.maybe_repo
+    c.opt :global, "Sets the value to the global configuration file", :short => "-g"
+    c.desc "Sets a configuration value in Amp's settings"
+    c.before do |opts, args|
+      if args.size < 2 || args.size > 3 || (args.size == 2 && args.first !~ /\:/)
+        puts "Usage:      amp config:set setting-section:setting-name new-setting-value"
+        puts "Alt. Usage: amp config:set setting-section setting-name new-setting-value"
+        puts
+        c.break
+      end
+      true
+    end
+    c.on_run do |opts, args|
+      config = opts[:global_config]
+      if opts[:global]
+        while config.parent_config
+          config = config.parent_config
+        end
+      end
+      if args.size == 2
+        section, key = args.first.split(":")
+        value = args[1]
+      else
+        section, key, value = *args
+      end
+      
+      config[section][key] = value
+      config.save!
+    end
+  end
+  command :get do |c|
+    c.workflow :all
+    c.maybe_repo
+    c.opt :global, "Gets the value from the global configuration file", :short => "-g"
+    c.desc "Gets a configuration value in Amp's settings"
+    c.before do |opts, args|
+      if args.size < 1 || args.size > 2 || (args.size == 1 && args.first !~ /\:/)
+        puts "Usage:      amp config:get setting-section:setting-name"
+        puts "Alt. Usage: amp config:set setting-section setting-name"
+        puts
+        c.break
+      end
+      true
+    end
+    c.on_run do |opts, args|
+      config = opts[:global_config]
+      if opts[:global]
+        while config.parent_config
+          config = config.parent_config
+        end
+      end
+      if args.size == 1
+        section, key = args.first.split(":")
+      else
+        section, key = *args
+      end
+      
+      Amp::UI.say config[section][key]
+    end
+  end
+end

data/lib/amp/commands/commands/help.rb

@@ -0,0 +1,29 @@
+command :help do |c|
+  c.workflow :all
+  c.desc "Prints the help for the program."
+  
+  c.on_run do |options, args|
+    output = ""
+    
+    if args.empty?
+      output << "These are the following commands available:\n"
+      
+      Amp::Command.all_for_workflow(options[:global_config]["amp", "workflow"], false).sort {|k1, k2| k1.to_s <=> k2.to_s}.each do |k, v| 
+        output << "\t#{k.to_s.ljust(30, " ")}#{v.desc}" + "\n"
+      end
+      
+      output << 'Run "amp help [command]" for more information.'
+      
+      Amp::UI.say output
+    else
+      
+      unless cmd = Amp::Command.all_for_workflow(options[:global_config]["amp","workflow"])[args.first.to_sym]
+        Amp::UI.say "The command #{args.first} was not found."
+      else
+        cmd.collect_options
+        cmd.educate
+      end
+      
+    end
+  end
+end

data/lib/amp/commands/commands/init.rb

@@ -0,0 +1,10 @@
+command :init do |c|
+  c.workflow :all
+  c.desc "Initializes a new repository in the current directory."
+  c.on_run do |options, args|
+    path = args.first ? args.first : '.'
+    
+    Amp::Repositories::LocalRepository.new(path, true, options[:global_config])
+    puts "New repository initialized."
+  end
+end

data/lib/amp/commands/commands/templates.rb

@@ -0,0 +1,137 @@
+# Create an anonymous module so that the extra methods in the templates aren't
+# entered into the global namespace
+# 
+# This bears explanation:
+# The `command` method operates regardless of location and communicates back to
+# command HQ (command.rb). We use some helper methods here, which are defined at
+# the bottom, and we want them to be hidden for everyone else. To do this, we wrap
+# the entire `command` method call in an anonymous module so that `command`, which
+# will operate anywhere, will work, but all extraneous data (the helper methods)
+# is lost in memory.
+Module.new do
+  command :templates do |c|
+    c.workflow :all
+    c.add_opt :list, "Lists all templates", :short => "-l"
+    c.desc "Starts an interactive template editor"
+    c.maybe_repo
+    c.on_run do |opts, args|
+      
+      
+      
+      repo = opts[:repository]
+      
+      if opts[:list]
+        print_templates(repo)
+        next
+      end
+      begin
+        Amp::UI.say "Welcome to the Amp template editor."
+        
+        scope = 0
+        Amp::UI.choose do |menu|
+          menu.prompt = "Which kind of template do you want to modify?"
+          menu.choice("Global Templates") { scope = TEMPLATE_GLOBAL_SCOPE }
+          menu.choice("Local Templates (this Repo Only)") { scope = TEMPLATE_LOCAL_SCOPE }
+          menu.choice("Quit") { exit(0) }
+          menu.index = :number
+        end
+        
+        if scope == TEMPLATE_LOCAL_SCOPE && !repo
+          puts "No local repository found! Sorry."
+          next
+        end
+        
+        template_directory = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "templates"))
+        Amp::UI.say "\n"
+        mode = 0
+        Amp::UI.choose do |menu|
+          menu.prompt = "Do you want to edit, add, or remove a template?"
+          menu.choice("Edit") { mode = TEMPLATE_EDIT_MODE }
+          menu.choice("Add") { mode = TEMPLATE_ADD_MODE }
+          menu.choice("Remove") { mode = TEMPLATE_DELETE_MODE }
+          menu.choice("Start Over") { }
+          menu.index = :number
+        end
+        Amp::UI.say "\n"
+        case mode
+        when TEMPLATE_EDIT_MODE
+          filename = nil
+          Amp::UI.choose do |menu|
+            menu.prompt = "Which template would you like to edit?"
+            templates_for_scope(scope, repo).each do |template|
+              menu.choice(template.name) { filename = template.file }
+            end
+            menu.choice("Start Over") { } #do nothing
+            menu.index = :number
+          end
+          Amp::UI.edit_file(filename) if filename
+        when TEMPLATE_ADD_MODE
+          filename = Amp::UI.ask("What would you like to name your template? ", String)
+          type = Amp::UI.ask("What kind of template? (log, commit) ", String) {|q| q.in = ["log","commit"]}
+          old_file = Amp::Support::Template["blank-#{type}"].file
+          new_file = File.join(template_directory, filename + ".erb")
+          File.copy(old_file, new_file)
+          Amp::UI.edit_file new_file
+          Amp::Support::FileTemplate.new(filename, new_file)
+        when TEMPLATE_DELETE_MODE
+          filename = nil
+          Amp::UI.choose do |menu|
+            menu.prompt = "Which template would you like to delete?"
+            templates_for_scope(scope, repo).each do |template|
+              menu.choice(template.name) do 
+                Amp::Support::Template.unregister template.name
+                filename = template.file
+              end
+            end
+            menu.choice("Start Over") {  }  #do nothing
+            menu.index = :number
+          end
+          if filename # didn't start over
+            shortname = filename.split("/").last.gsub(/\.erb/,"")
+            sure = Amp::UI.agree "Are you sure you want to delete the template \"#{shortname}\"? (y/n/yes/no) "
+            if sure
+              File.safe_unlink(filename)
+            end
+          end
+        end
+        Amp::UI.say "\n"
+      end while true
+      
+    end
+    
+    
+  end
+  TEMPLATE_GLOBAL_SCOPE = 1
+  TEMPLATE_LOCAL_SCOPE  = 2
+
+  TEMPLATE_EDIT_MODE = 1
+  TEMPLATE_ADD_MODE = 2
+  TEMPLATE_DELETE_MODE = 3
+  # This is how we scope methods such that the command has access to them, but nobody else, without
+  # defining nested methods.
+  class << self
+    
+    def templates_for_scope(scope, repo)
+      case scope
+      when TEMPLATE_GLOBAL_SCOPE
+        Amp::Support::Template.all_templates.values
+      when TEMPLATE_LOCAL_SCOPE
+        path = repo.join("templates")
+        FileUtils.makedirs path unless File.exists? path
+        Dir.entries(path).reject {|e| e =~ /^\./}.map {|f| File.join(dir, f)}
+      end
+    end
+    
+    def print_templates(repo)
+      Amp::UI.say "Global Templates"
+      Amp::UI.say "================"
+      templates_for_scope(TEMPLATE_GLOBAL_SCOPE, repo).each {|template| Amp::UI.say template.name}
+      if repo
+        Amp::UI.say "\nLocal Templates"
+        Amp::UI.say "================"
+        # templates_for_scope(TEMPLATE_LOCAL_SCOPE, repo).each {|f| Amp::UI.say f.split("/").last.gsub(/\.erb/,"")}
+      end
+      Amp::UI.say "\n"
+    end
+  end
+end