linen 0.3.1 → 0.3.2

data/lib/linen/command.rb

@@ -8,171 +8,171 @@
 ##############################################################
 
 class Linen::Plugin::Command
-  attr_reader :name
+	attr_reader :name
 
-  def initialize( plugin, name, &block )
-    @plugin    = plugin
-    @name      = name
-    @arguments = []
-    @help_text = "No help for #{plugin.short_name} #{name}"
+	def initialize( plugin, name, &block )
+		@plugin    = plugin
+		@name      = name
+		@arguments = []
+		@help_text = "No help for #{plugin.short_name} #{name}"
 
-    self.instance_eval &block
-  end
+		self.instance_eval &block
+	end
 
 
-  def execute( workspace = Linen::Workspace.new )
-    return workspace.instance_eval( &@action_proc )
-  end
+	def execute( workspace = Linen::Workspace.new )
+		return workspace.instance_eval( &@action_proc )
+	end
 
 
-  def help
-    output = []
+	def help
+		output = []
 
-    output << @help_text.wrap
-    output << nil # blank line
+		output << @help_text.wrap
+		output << nil # blank line
 
-    # this map turns our list of args into a list like this:
-    # <arg1> <arg2> <arg3> <arg4>...
-    arg_list = arguments.map {|a| "<#{a.to_s}>"}.join( ' ' )
+		# this map turns our list of args into a list like this:
+		# <arg1> <arg2> <arg3> <arg4>...
+		arg_list = arguments.map {|a| "<#{a.to_s}>"}.join( ' ' )
 
-    output << "Usage: #{@plugin.short_name} #{name} #{arg_list}"
+		output << "Usage: #{@plugin.short_name} #{name} #{arg_list}"
 
-    return output.join( "\n" )
-  end
+		return output.join( "\n" )
+	end
 
 
-  #############################
-  # PLUGIN DEFINITION METHODS #
-  #############################
+	#############################
+	# PLUGIN DEFINITION METHODS #
+	#############################
 
 
-  def one_of( *args )
-    raise Linen::Plugin::ArgumentError,
-      "You may not specify both required and one_of arguments" if @argument_type == :required
+	def one_of( *args )
+		raise Linen::Plugin::ArgumentError,
+			"You may not specify both required and one_of arguments" if @argument_type == :required
 
-    @argument_type = :one_of
+		@argument_type = :one_of
 
-    args.each do |arg|
-      raise Linen::Plugin::ArgumentError,
-        "Argument '#{arg}' has not been defined" unless @plugin.arguments.include? arg
+		args.each do |arg|
+			raise Linen::Plugin::ArgumentError,
+				"Argument '#{arg}' has not been defined" unless @plugin.arguments.include? arg
 
-      @arguments << arg
-    end
-  end
+			@arguments << arg
+		end
+	end
 
 
-  def required_arguments( *args )
-    raise Linen::Plugin::ArgumentError,
-      "You may not specify both required and one_of arguments" if @argument_type == :one_of
+	def required_arguments( *args )
+		raise Linen::Plugin::ArgumentError,
+			"You may not specify both required and one_of arguments" if @argument_type == :one_of
 
-    @argument_type = :required
+		@argument_type = :required
 
-    args.each do |arg|
-      raise Linen::Plugin::ArgumentError,
-        "Argument '#{arg}' has not been defined" unless @plugin.arguments.include? arg
+		args.each do |arg|
+			raise Linen::Plugin::ArgumentError,
+				"Argument '#{arg}' has not been defined" unless @plugin.arguments.include? arg
 
-      @arguments << arg
-    end
-  end
-  alias required_argument required_arguments
+			@arguments << arg
+		end
+	end
+	alias required_argument required_arguments
 
 
-  def help_message( message )
-    @help_text = message
-  end
+	def help_message( message )
+		@help_text = message
+	end
 
 
-  def action( &block )
-    @action_proc = block
-  end
-  
-  
-  def require_confirmation
-    @require_confirmation = true
-  end
+	def action( &block )
+		@action_proc = block
+	end
 
 
-  ##################
-  # HELPER METHODS #
-  ##################
+	def require_confirmation
+		@require_confirmation = true
+	end
 
-  def validate_arguments( args )
-    if @argument_type == :one_of
-      return validate_one_of_arguments( args.first )
-    else # @argument_type == :required
-      return validate_required_arguments( args )
-    end
 
-    # this is a Can't Happen(tm) so I'm comfortable with the crappy
-    # exception string.  :P
-    raise "Something has happened!"
-  end
-  
-  
-  def requires_confirmation?
-    @require_confirmation
-  end
+	##################
+	# HELPER METHODS #
+	##################
 
-  ###########
-    private #
-  ###########
+	def validate_arguments( args )
+		if @argument_type == :one_of
+			return validate_one_of_arguments( args.first )
+		else # @argument_type == :required
+			return validate_required_arguments( args )
+		end
 
-  ### FIXME:bbleything
-  ###
-  ### The reprompting stuff below is going to come back to bite us when we try to
-  ### add batch mode later... that said, in the interest of getting things out the
-  ### door, we're going to leave it be for now.
+		# this is a Can't Happen(tm) so I'm comfortable with the crappy
+		# exception string.  :P
+		raise "Something has happened!"
+	end
 
-  def validate_one_of_arguments( arg )
-    results = IndifferentHash.new
 
-    begin
-      @arguments.each do |arg_name|
-        argument = @plugin.arguments[ arg_name ]
+	def requires_confirmation?
+		@require_confirmation
+	end
 
-        results[ arg_name ] = argument.validate( arg ) rescue nil
-      end
+	###########
+	private #
+	###########
 
-      raise Linen::Plugin::ArgumentError,
-        "The value you entered ('#{arg}') is invalid for all arguments." if
-          results.values.compact.empty?
+	### FIXME:bbleything
+	###
+	### The reprompting stuff below is going to come back to bite us when we try to
+	### add batch mode later... that said, in the interest of getting things out the
+	### door, we're going to leave it be for now.
 
-    rescue Linen::Plugin::ArgumentError => e
-      print "#{e}  "
+	def validate_one_of_arguments( arg )
+		results = IndifferentHash.new
 
-      arg = Linen::CLI.reprompt.split.first
+		begin
+			@arguments.each do |arg_name|
+				argument = @plugin.arguments[ arg_name ]
 
-      retry
-    end
+				results[ arg_name ] = argument.validate( arg ) rescue nil
+			end
 
-    return results
-  end
+			raise Linen::Plugin::ArgumentError,
+				"The value you entered ('#{arg}') is invalid for all arguments." if
+					results.values.compact.empty?
 
+		rescue Linen::Plugin::ArgumentError => e
+			print "#{e}  "
 
-  def validate_required_arguments( args )
-    results = IndifferentHash.new
+			arg = Linen::CLI.reprompt.split.first
 
-    @arguments.each do |arg_name|
-      argument  = @plugin.arguments[ arg_name ]
-      arg_value = args.shift
+			retry
+		end
 
-      begin
-        arg_value = Linen::CLI.reprompt( argument.prompt ) if arg_value.nil?
+		return results
+	end
 
-        argument.validate arg_value
 
-      rescue Linen::Plugin::ArgumentError => e
-        print "#{e}  "
+	def validate_required_arguments( args )
+		results = IndifferentHash.new
 
-        # reset arg_value to nil so we get prompted on retry
-        arg_value = nil
+		@arguments.each do |arg_name|
+			argument  = @plugin.arguments[ arg_name ]
+			arg_value = args.shift
 
-        retry
-      else
-        results[ arg_name ] = argument.convert( arg_value )
-      end
-    end
+			begin
+				arg_value = Linen::CLI.reprompt( argument.prompt ) if arg_value.nil?
 
-    return results
-  end
+				argument.validate arg_value
+
+			rescue Linen::Plugin::ArgumentError => e
+				print "#{e}  "
+
+				# reset arg_value to nil so we get prompted on retry
+				arg_value = nil
+
+				retry
+			else
+				results[ arg_name ] = argument.convert( arg_value )
+			end
+		end
+
+		return results
+	end
 end

data/lib/linen/exceptions.rb

@@ -14,26 +14,26 @@ class Linen::CLI::PluginNotFoundError  < NameError ; end
 class Linen::CLI::CommandNotFoundError < NameError ; end
 
 class Linen::CLI::AbstractAmbiguityError < NameError
-  attr_accessor :candidates, :input
+	attr_accessor :candidates, :input
 
-  def initialize( candidates = [], input = '' )
-    @candidates = candidates
-    @input      = input
-  end
+	def initialize( candidates = [], input = '' )
+		@candidates = candidates
+		@input      = input
+	end
 
-  def to_s
-    type = self.class.to_s.match( /Ambiguous(.*?)Error/ )[1].downcase
+	def to_s
+		type = self.class.to_s.match( /Ambiguous(.*?)Error/ )[1].downcase
 
-    return "The #{type} you entered ('#{@input}') was ambiguous; please select from the following: #{@candidates.join ', '}"
-  end
+		return "The #{type} you entered ('#{@input}') was ambiguous; please select from the following: #{@candidates.join ', '}"
+	end
 end
 
 class Linen::CLI::AmbiguousPluginError  < Linen::CLI::AbstractAmbiguityError ; end
 
 class Linen::CLI::AmbiguousCommandError < Linen::CLI::AbstractAmbiguityError
-  def to_s
-    @candidates.map! {|c| [plugin, c].join ' '}
+	def to_s
+		@candidates.map! {|c| [plugin, c].join ' '}
 
-    super
-  end
+		super
+	end
 end

data/lib/linen/plugin.rb

@@ -8,94 +8,94 @@
 ##############################################################
 
 class Linen::Plugin
-  class << self
-    attr_reader :commands
-  end
+	class << self
+		attr_reader :commands
+	end
 
 
-  def self::inherited( plugin )
-    Linen::PluginRegistry.instance.register plugin
-  end
+	def self::inherited( plugin )
+		Linen::PluginRegistry.instance.register plugin
+	end
 
 
-  def self::short_name( short_name = nil )
-    @short_name = short_name if short_name
-    return @short_name || self.to_s.downcase.gsub( /plugin$/, '' )
-  end
+	def self::short_name( short_name = nil )
+		@short_name = short_name if short_name
+		return @short_name || self.to_s.downcase.gsub( /plugin$/, '' )
+	end
 
 
-  def self::help
-    output = []
+	def self::help
+		output = []
 
-    desc = description || "No help for #{short_name}"
+		desc = description || "No help for #{short_name}"
 
-    output << desc
-    output << nil #blank line
-    output << "Available commands:"
-    output << nil #blank line
+		output << desc
+		output << nil #blank line
+		output << "Available commands:"
+		output << nil #blank line
 
-    commands.each do |name, command|
-      output << "- #{name}"
-    end
+		commands.each do |name, command|
+			output << "- #{name}"
+		end
 
-    output << nil #blank line
-    output << "For detailed help on a command, enter \"help #{short_name} <command>\"".wrap
+		output << nil #blank line
+		output << "For detailed help on a command, enter \"help #{short_name} <command>\"".wrap
 
-    return output.join( "\n" )
-  end
+		return output.join( "\n" )
+	end
 
 
-  def self::argument( name, opts = {} )
-    @defined_arguments ||= IndifferentHash.new
+	def self::argument( name, opts = {} )
+		@defined_arguments ||= IndifferentHash.new
 
-    if opts[:error_message].nil? and opts['error_message'].nil?
-      opts[ :error_message ] = "The value for #{name} is invalid."
-    end
+		if opts[:error_message].nil? and opts['error_message'].nil?
+			opts[ :error_message ] = "The value for #{name} is invalid."
+		end
 
-    @defined_arguments[ name ] = Argument.new( self, name, opts )
-  end
+		@defined_arguments[ name ] = Argument.new( self, name, opts )
+	end
 
 
-  ### If args is empty, assume it was called like Plugin.arguments,
-  ### so return the hash.
-  def self::arguments( *args )
-    @defined_arguments ||= IndifferentHash.new
+	### If args is empty, assume it was called like Plugin.arguments,
+	### so return the hash.
+	def self::arguments( *args )
+		@defined_arguments ||= IndifferentHash.new
 
-    return @defined_arguments if args.empty?
+		return @defined_arguments if args.empty?
 
-    args.each do |arg|
-      argument arg
-    end
-  end
+		args.each do |arg|
+			argument arg
+		end
+	end
 
 
-  def self::command( name, &block )
-    @commands ||= IndifferentHash.new
+	def self::command( name, &block )
+		@commands ||= IndifferentHash.new
 
-    @commands[ name ] = Command.new( self, name, &block )
-  end
+		@commands[ name ] = Command.new( self, name, &block )
+	end
 
 
-  ### multi-purpose method!
-  ###
-  ### if passed a block, set this plugin's cleanup proc to the block.
-  ### if called without a block, execute the proc.
-  ###
-  ### this is meant to allow plugins to clean up after themselves.
-  def self::cleanup( &block )
-    if block_given?
-      @cleanup_proc = block
-    else
-      # if we didn't define a proc, don't try to call it
-      @cleanup_proc.call if @cleanup_proc
-    end
-  end
+	### multi-purpose method!
+	###
+	### if passed a block, set this plugin's cleanup proc to the block.
+	### if called without a block, execute the proc.
+	###
+	### this is meant to allow plugins to clean up after themselves.
+	def self::cleanup( &block )
+		if block_given?
+			@cleanup_proc = block
+		else
+			# if we didn't define a proc, don't try to call it
+			@cleanup_proc.call if @cleanup_proc
+		end
+	end
 
 
-  ### define the plugin's description, or fetch it if nothing passed
-  def self::description( input = nil )
-    return @description unless input
+	### define the plugin's description, or fetch it if nothing passed
+	def self::description( input = nil )
+		return @description unless input
 
-    @description = input
-  end
+		@description = input
+	end
 end