linen 0.3.1 → 0.3.2

data/lib/indifferent_hash.rb

@@ -8,15 +8,15 @@
 ##############################################################
 
 class IndifferentHash < Hash
-  def []( key )
-    candidate = self.fetch( key ) rescue false
-    return candidate if candidate
+	def []( key )
+		candidate = self.fetch( key ) rescue false
+		return candidate if candidate
 
-    [ :to_s, :intern ].each do |modifier|
-      candidate = self.fetch( key.send(modifier) ) if key.respond_to? modifier rescue false
-      return candidate if candidate
-    end
+		[ :to_s, :intern ].each do |modifier|
+			candidate = self.fetch( key.send(modifier) ) if key.respond_to? modifier rescue false
+			return candidate if candidate
+		end
 
-    return nil
-  end
+		return nil
+	end
 end

data/lib/linen.rb

@@ -18,18 +18,18 @@ require 'string_extensions'
 
 
 module Linen
-  VERSION = "0.3.1"
-  SVNRev  = %q$Rev: 84 $
+	VERSION = "0.3.2"
+	SVNRev  = %q$Rev: 86 $
 
 
-  def self::plugins
-    return Linen::PluginRegistry.instance
-  end
+	def self::plugins
+		return Linen::PluginRegistry.instance
+	end
 
 
-  def self::start
-    Linen::CLI.start_loop
-  end
+	def self::start
+		Linen::CLI.start_loop
+	end
 end
 
 

data/lib/linen/argument.rb

@@ -8,31 +8,31 @@
 ##############################################################
 
 class Linen::Plugin::Argument
-  attr_reader :prompt
+	attr_reader :prompt
 
-  def initialize( plugin, name, opts )
-    @plugin     = plugin
-    @name       = name
-    @prompt     = opts[:prompt]     || "Please enter the value for #{@name}"
-    @validation = opts[:validation] || /^\w+$/
-    @conversion = opts[:conversion] || nil
-  end
+	def initialize( plugin, name, opts )
+		@plugin     = plugin
+		@name       = name
+		@prompt     = opts[:prompt]     || "Please enter the value for #{@name}"
+		@validation = opts[:validation] || /^\w+$/
+		@conversion = opts[:conversion] || nil
+	end
 
 
-  def convert( value )
-    return value unless @conversion
-    return @conversion.call( value )
-  end
+	def convert( value )
+		return value unless @conversion
+		return @conversion.call( value )
+	end
 
 
-  def validate( value )
-    if @validation.is_a? Proc
-      result = @validation.call( value )
-    else
-      result = ( value =~ @validation )
-    end
+	def validate( value )
+		if @validation.is_a? Proc
+			result = @validation.call( value )
+		else
+			result = ( value =~ @validation )
+		end
 
-    raise Linen::Plugin::ArgumentError, "Value '#{value}' is invalid for #{@name}." unless result
-    return value
-  end
+		raise Linen::Plugin::ArgumentError, "Value '#{value}' is invalid for #{@name}." unless result
+		return value
+	end
 end

data/lib/linen/cli.rb

@@ -8,144 +8,144 @@
 ##############################################################
 
 class Linen::CLI
-  class << self
-    attr_accessor :prompt
-  end
-
-  @prompt = "linen > "
-
-  def self::parse_command( input )
-    ### * nil means ctrl-d, so exit.
-    ### * if they said "quit" or "exit", do so
-    ### * Size == 0 means empty command, so just return.
-    ###
-    ### otherwise, add to history.
-    if input.nil?
-      ### blank line to make ctrl-d not make the error live on the existing line
-      puts ; cleanup and exit
-    elsif input.chomp.size == 0 # empty string
-      return
-    else
-      Readline::HISTORY.push( input )
-    end
-
-    plugin, command, *arguments = input.split
-
-    if ['quit', 'exit'].abbrev.include? plugin
-      cleanup and exit
-    elsif ['help', '?'].abbrev.include? plugin
-      # they entered "help <plugin> <command> or some subset there of, which means
-      # that we have the plugin in command and the command in the first element of args.
-      plugin  = command.dup     rescue nil
-      command = arguments.shift rescue nil
-
-      if plugin and command
-        plugin, command = canonicalize( "#{plugin} #{command}" ).split rescue nil
-
-        # if either plugin or command is nil, lookup will fail; bail
-        return unless plugin = Linen.plugins[ plugin ]
-        return unless command = plugin.commands[ command ]
-
-        puts command.help
-      elsif plugin
-        return unless plugin = Linen.plugins[ canonicalize( plugin ) ]
-        puts plugin.help
-      else
-        help
-      end
-    elsif plugin.nil? or command.nil?
-      puts "You must enter both a plugin name and a command."
-    else
-      plugin, command, *args = canonicalize( input ).split
-
-      execute_command plugin, command, args
-    end
-  end
-
-
-  def self::start_loop
-    loop do
-      begin
-        input = Readline.readline( @prompt )
-      rescue Interrupt
-        puts "\nPlease type 'quit' or 'exit' to quit."
-      else
-        parse_command input
-      end
-
-      puts # blank line to clean things up
-    end
-  end
-
-
-  #######
-  private
-  #######
-
-  def self::canonicalize( input )
-    begin
-      expansion = expand_command( input )
-    rescue Linen::CLI::PluginNotFoundError, Linen::CLI::CommandNotFoundError, Linen::CLI::AmbiguousPluginError, Linen::CLI::AmbiguousCommandError => e
-      puts e
-    end
-
-    return expansion
-  end
-
-
-  def self::cleanup
-    puts "Exiting..."
-
-    Linen.plugins.each do |p|
-      p.cleanup
-    end
-  end
-
-
-  def self::execute_command( plugin, command, args )
-    plugin    = Linen.plugins[ plugin ]
-    command   = plugin.commands[ command ]
-    workspace = Linen::Workspace.new
-    results   = command.validate_arguments( args )
-
-    input = ''
-    if command.requires_confirmation?
-      puts "Running '#{plugin.short_name} #{command.name}' with arguments:"
-
-      puts results.map { |arg, value|
-        next unless value
-        "#{arg}: #{value}"
-      }.join( "\n" )
-
-      while input !~ /^(y|n)/i
-        input = Readline.readline( "\nContinue [y/N]? ")
-        input = "n" if input == ''
-      end
-    end
-    
-    if input =~ /^y/i
-      puts # blank line
-
-      workspace.add_values( results )
-      command.execute( workspace )
-    end
-  end
-
-
-  def self::reprompt( prompt = "Re-enter: " )
-    old_completion_proc = Readline.completion_proc
-    Readline.completion_proc = proc {}
+	class << self
+		attr_accessor :prompt
+	end
+
+	@prompt = "linen > "
+
+	def self::parse_command( input )
+		### * nil means ctrl-d, so exit.
+		### * if they said "quit" or "exit", do so
+		### * Size == 0 means empty command, so just return.
+		###
+		### otherwise, add to history.
+		if input.nil?
+			### blank line to make ctrl-d not make the error live on the existing line
+			puts ; cleanup and exit
+		elsif input.chomp.size == 0 # empty string
+			return
+		else
+			Readline::HISTORY.push( input )
+		end
+
+		plugin, command, *arguments = input.split
+
+		if ['quit', 'exit'].abbrev.include? plugin
+			cleanup and exit
+		elsif ['help', '?'].abbrev.include? plugin
+			# they entered "help <plugin> <command> or some subset there of, which means
+			# that we have the plugin in command and the command in the first element of args.
+			plugin  = command.dup     rescue nil
+			command = arguments.shift rescue nil
+
+			if plugin and command
+				plugin, command = canonicalize( "#{plugin} #{command}" ).split rescue nil
+
+				# if either plugin or command is nil, lookup will fail; bail
+				return unless plugin = Linen.plugins[ plugin ]
+				return unless command = plugin.commands[ command ]
+
+				puts command.help
+			elsif plugin
+				return unless plugin = Linen.plugins[ canonicalize( plugin ) ]
+				puts plugin.help
+			else
+				help
+			end
+		elsif plugin.nil? or command.nil?
+			puts "You must enter both a plugin name and a command."
+		else
+			plugin, command, *args = canonicalize( input ).split
+
+			execute_command plugin, command, args
+		end
+	end
+
+
+	def self::start_loop
+		loop do
+			begin
+				input = Readline.readline( @prompt )
+			rescue Interrupt
+				puts "\nPlease type 'quit' or 'exit' to quit."
+			else
+				parse_command input
+			end
+
+			puts # blank line to clean things up
+		end
+	end
+
+
+	#######
+	private
+	#######
+
+	def self::canonicalize( input )
+		begin
+			expansion = expand_command( input )
+		rescue Linen::CLI::PluginNotFoundError, Linen::CLI::CommandNotFoundError, Linen::CLI::AmbiguousPluginError, Linen::CLI::AmbiguousCommandError => e
+			puts e
+		end
+
+		return expansion
+	end
+
+
+	def self::cleanup
+		puts "Exiting..."
+
+		Linen.plugins.each do |p|
+			p.cleanup
+		end
+	end
+
+
+	def self::execute_command( plugin, command, args )
+		plugin    = Linen.plugins[ plugin ]
+		command   = plugin.commands[ command ]
+		workspace = Linen::Workspace.new
+		results   = command.validate_arguments( args )
+
+		input = ''
+		if command.requires_confirmation?
+			puts "\nRunning '#{plugin.short_name} #{command.name}' with arguments:"
+
+			puts results.map { |arg, value|
+				next unless value
+				"#{arg}: #{value}"
+			}.join( "\n" )
+
+			while input !~ /^(y|n)/i
+				input = Readline.readline( "\nContinue [y/N]? ")
+				input = "n" if input == ''
+			end
+		end
+
+		if input =~ /^y/i
+			puts # blank line
 
-    input = Readline.readline( prompt )
+			workspace.add_values( results )
+			command.execute( workspace )
+		end
+	end
 
-    Readline.completion_proc = old_completion_proc
-
-    return input
-  end
 
+	def self::reprompt( prompt = "Re-enter: " )
+		old_completion_proc = Readline.completion_proc
+		Readline.completion_proc = proc {}
 
-  def self::help
-    puts <<-END
+		input = Readline.readline( prompt )
+
+		Readline.completion_proc = old_completion_proc
+
+		return input
+	end
+
+
+	def self::help
+		puts <<-END
 Usage: <plugin> <command> [<argument>, <argument>...]
 
 You may shorten the plugin and commands as long as the abbreviation
@@ -154,92 +154,92 @@ is non-ambiguous.  For example, given two plugins 'addition' and
 
 Available plugins and commands:
 
-    END
+		END
 
-    Linen.plugins.each do |plugin|
-      puts "- #{plugin.short_name}"
+		Linen.plugins.each do |plugin|
+			puts "- #{plugin.short_name}"
 
-      plugin.commands.each do |name, command|
-        puts "  - #{name}"
-      end
-    end
+			plugin.commands.each do |name, command|
+				puts "  - #{name}"
+			end
+		end
 
-    puts <<-END
+		puts <<-END
 
 To get help with a plugin, enter "help <plugin>".  You may also enter
 "help <plugin> <command>" for help on a specific command.
-    END
-  end
-
-
-  ### First, try to complete the plugin name.  If we can't,
-  ### raise an exception saying so.
-  ###
-  ### Second, try to complete the command name.  If we can't,
-  ### raise an exception saying so.
-  ###
-  ### The caller is now responsible for flow control.
-  def self::expand_command( str )
-    plugin_candidates = Linen.plugins.collect {|p| p.short_name}.sort
-
-    ### empty string means we're trying to complete the plugin with nothing to go on
-    raise Linen::CLI::AmbiguousPluginError.new( plugin_candidates ) if str.empty?
-
-    plugin, command, *arguments = str.split
-
-    ### attempt to complete the plugin, raising an exception if it failes
-    completed_plugin = plugin_candidates.abbrev[ plugin ]
-
-    unless completed_plugin
-      refined_candidates = plugin_candidates.select {|p| p =~ /^#{plugin}/}
-
-      raise Linen::CLI::PluginNotFoundError, "Plugin '#{plugin}' not found." if refined_candidates.empty?
-      raise Linen::CLI::AmbiguousPluginError.new( refined_candidates, plugin )
-    end
-
-    ### if there's no command entered and no space after the plugin,
-    ### just return the plugin
-    return completed_plugin if command.nil? and str !~ /\s$/
-
-    ### If we've gotten here, we've now got the plugin in completed_plugin,
-    ### so attempt to complete the command
-    command_candidates = Linen.plugins[ completed_plugin ].commands.keys.map {|k| k.to_s}.sort
-
-    completed_command = command_candidates.abbrev[ command ]
-
-    unless completed_command
-      refined_candidates = command_candidates.select {|c| c =~ /^#{command}/}
-
-      raise Linen::CLI::CommandNotFoundError,
-        "Command '#{command}' not found." if refined_candidates.empty?
-
-      raise Linen::CLI::AmbiguousCommandError.new( refined_candidates, command ),
-        "The command you entered ('#{command}') is ambiguous; please select from the following:"
-    end
-
-    ### if we've gotten here, we're golden.  Everything is completed.  Rejoice!
-    output =  completed_plugin
-    output << " " + completed_command if completed_command
-    output << " " + arguments.join(' ') unless arguments.empty?
-
-    return output
-  end
-
-  Readline.basic_word_break_characters = ""
-
-  Readline.completion_proc = proc do |str|
-    begin
-      output = expand_command( str )
-    rescue Linen::CLI::PluginNotFoundError, Linen::CLI::CommandNotFoundError => e
-      output = ''
-    rescue Linen::CLI::AmbiguousPluginError => e
-      output = e.candidates
-    rescue Linen::CLI::AmbiguousCommandError => e
-      output = e.candidates.map {|c| "#{str.split.first} #{c}"}
-    ensure
-      return output
-    end
-  end
+		END
+	end
+
+
+	### First, try to complete the plugin name.  If we can't,
+	### raise an exception saying so.
+	###
+	### Second, try to complete the command name.  If we can't,
+	### raise an exception saying so.
+	###
+	### The caller is now responsible for flow control.
+	def self::expand_command( str )
+		plugin_candidates = Linen.plugins.collect {|p| p.short_name}.sort
+
+		### empty string means we're trying to complete the plugin with nothing to go on
+		raise Linen::CLI::AmbiguousPluginError.new( plugin_candidates ) if str.empty?
+
+		plugin, command, *arguments = str.split
+
+		### attempt to complete the plugin, raising an exception if it failes
+		completed_plugin = plugin_candidates.abbrev[ plugin ]
+
+		unless completed_plugin
+			refined_candidates = plugin_candidates.select {|p| p =~ /^#{plugin}/}
+
+			raise Linen::CLI::PluginNotFoundError, "Plugin '#{plugin}' not found." if refined_candidates.empty?
+			raise Linen::CLI::AmbiguousPluginError.new( refined_candidates, plugin )
+		end
+
+		### if there's no command entered and no space after the plugin,
+		### just return the plugin
+		return completed_plugin if command.nil? and str !~ /\s$/
+
+		### If we've gotten here, we've now got the plugin in completed_plugin,
+		### so attempt to complete the command
+		command_candidates = Linen.plugins[ completed_plugin ].commands.keys.map {|k| k.to_s}.sort
+
+		completed_command = command_candidates.abbrev[ command ]
+
+		unless completed_command
+			refined_candidates = command_candidates.select {|c| c =~ /^#{command}/}
+
+			raise Linen::CLI::CommandNotFoundError,
+				"Command '#{command}' not found." if refined_candidates.empty?
+
+			raise Linen::CLI::AmbiguousCommandError.new( refined_candidates, command ),
+				"The command you entered ('#{command}') is ambiguous; please select from the following:"
+		end
+
+		### if we've gotten here, we're golden.  Everything is completed.  Rejoice!
+		output =  completed_plugin
+		output << " " + completed_command if completed_command
+		output << " " + arguments.join(' ') unless arguments.empty?
+
+		return output
+	end
+
+	Readline.basic_word_break_characters = ""
+
+	Readline.completion_proc = proc do |str|
+		begin
+			output = expand_command( str )
+		rescue Linen::CLI::PluginNotFoundError, Linen::CLI::CommandNotFoundError => e
+			output = ''
+		rescue Linen::CLI::AmbiguousPluginError => e
+			output = e.candidates
+		rescue Linen::CLI::AmbiguousCommandError => e
+			output = e.candidates.map {|c| "#{str.split.first} #{c}"}
+		ensure
+			return output
+		end
+	end
 end
 
 Signal.trap( 'INT' ) { raise Interrupt }