linen 0.3.1 → 0.3.2

data/lib/linen/plugin_registry.rb

@@ -10,56 +10,56 @@
 require 'singleton'
 
 class Linen::PluginRegistry
-  include Singleton
+	include Singleton
 
-  include Enumerable
-  def each
-    ### yield the actual plugin object, which knows its own name
-    @plugins.each { |name, plugin| yield plugin }
-  end
+	include Enumerable
+	def each
+		### yield the actual plugin object, which knows its own name
+		@plugins.each { |name, plugin| yield plugin }
+	end
 
 
-  def register_plugin( plugin )
-    raise Linen::Plugin::ArgumentError, "Attempted to register something that is not a Linen::Plugin" unless
-      plugin < Linen::Plugin
+	def register_plugin( plugin )
+		raise Linen::Plugin::ArgumentError, "Attempted to register something that is not a Linen::Plugin" unless
+			plugin < Linen::Plugin
 
-    @plugins ||= {}
-    @plugins[ plugin.short_name ] = plugin
-  end
-  alias register register_plugin
-  alias <<       register_plugin
+		@plugins ||= {}
+		@plugins[ plugin.short_name ] = plugin
+	end
+	alias register register_plugin
+	alias <<       register_plugin
 
 
-  def size
-    return @plugins.size
-  end
+	def size
+		return @plugins.size
+	end
 
 
-  def []( name )
-    return @plugins[ name ]
-  end
+	def []( name )
+		return @plugins[ name ]
+	end
 
 
-  def commands
-    if @commands.nil?
-      ### create @commands.  Each new key will get an empty array as its default value.
-      @commands = IndifferentHash.new
+	def commands
+		if @commands.nil?
+			### create @commands.  Each new key will get an empty array as its default value.
+			@commands = IndifferentHash.new
 
-      ### populates @commands as a hash of arrays.  The hash key is the command name (.to_s) and the value
-      ### is an array containing each plugin class in which that command is defined.
-      @plugins.each do |name, plugin|
-        plugin.commands.each do |name, cmd|
-          @commands[ name ] ||= []
-          @commands[ name ] << plugin
-        end
-      end
-    end
+			### populates @commands as a hash of arrays.  The hash key is the command name (.to_s) and the value
+			### is an array containing each plugin class in which that command is defined.
+			@plugins.each do |name, plugin|
+				plugin.commands.each do |name, cmd|
+					@commands[ name ] ||= []
+					@commands[ name ] << plugin
+				end
+			end
+		end
 
-    return @commands
-  end
+		return @commands
+	end
 
 
-  def find_command( name )
-    return @commands[ name ]
-  end
+	def find_command( name )
+		return @commands[ name ]
+	end
 end

data/lib/linen/workspace.rb

@@ -8,22 +8,22 @@
 ##############################################################
 
 class Linen::Workspace
-  def set_value( name, value )
-    # add getter
-    (class << self ; self ; end).instance_eval {
-      attr_reader name.to_s.intern
-    }
+	def set_value( name, value )
+		# add getter
+		(class << self ; self ; end).instance_eval {
+			attr_reader name.to_s.intern
+		}
 
-    # add ivar
-    instance_variable_set "@#{name}", value
-  end
+		# add ivar
+		instance_variable_set "@#{name}", value
+	end
 
-  def add_values( hash )
-    raise ArgumentError,
-      "must send a hash" unless hash.is_a? Hash
+	def add_values( hash )
+		raise ArgumentError,
+		"must send a hash" unless hash.is_a? Hash
 
-    hash.each do |k,v|
-      self.set_value k, v
-    end
-  end
+		hash.each do |k,v|
+			self.set_value k, v
+		end
+	end
 end

data/lib/string_extensions.rb

@@ -8,8 +8,8 @@
 ##############################################################
 
 class String
-  def wrap(line_width = 72)
-    self.gsub(/\n/, "\n\n").gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip
-  end
+	def wrap(line_width = 72)
+		self.gsub(/\n/, "\n\n").gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip
+	end
 end
 

data/test/test_cli.rb

@@ -12,100 +12,100 @@ require 'linen'
 
 class TestCLICommandCompletion < Test::Unit::TestCase
 
-  ################
-  # test plugins #
-  ################
+	################
+	# test plugins #
+	################
 
-  class ::TestPlugin < Linen::Plugin
-    command :add do;end
-    command :administer do;end
-    command :somethingelse do;end
-  end
+	class ::TestPlugin < Linen::Plugin
+		command :add do;end
+		command :administer do;end
+		command :somethingelse do;end
+	end
 
 
-  class ::TeaPlugin < Linen::Plugin
-    command :foo do;end
-  end
+	class ::TeaPlugin < Linen::Plugin
+		command :foo do;end
+	end
 
 
-  class ::OtherPlugin < Linen::Plugin
-    command :food do;end
-  end
+	class ::OtherPlugin < Linen::Plugin
+		command :food do;end
+	end
 
 
-  #########
-  # tests #
-  #########
+	#########
+	# tests #
+	#########
 
-  def test_plugin_completion
-    all_plugins = Linen.plugins.map {|p| p.short_name}.sort
+	def test_plugin_completion
+		all_plugins = Linen.plugins.map {|p| p.short_name}.sort
 
-    assert_raises_plugin_ambiguity_error( all_plugins ) do
-      complete ''
-    end
+		assert_raises_plugin_ambiguity_error( all_plugins ) do
+			complete ''
+		end
 
-    assert_raises_plugin_ambiguity_error( all_plugins.select {|p| p =~ /^te/} ) do
-      complete 'te'
-    end
+		assert_raises_plugin_ambiguity_error( all_plugins.select {|p| p =~ /^te/} ) do
+			complete 'te'
+		end
 
-    assert_nothing_raised do
-      ### strip'ing because completion returns it with a trailing space
-      assert_equal "test", complete( 'tes' ).strip
-    end
-  end
+		assert_nothing_raised do
+			### strip'ing because completion returns it with a trailing space
+			assert_equal "test", complete( 'tes' ).strip
+		end
+	end
 
 
-  def test_command_completion
-    test_commands = Linen.plugins[ 'test' ].commands.keys.map {|k| k.to_s}.sort
+	def test_command_completion
+		test_commands = Linen.plugins[ 'test' ].commands.keys.map {|k| k.to_s}.sort
 
-    assert_raises_command_ambiguity_error( test_commands ) do
-      complete 'tes '
-    end
+		assert_raises_command_ambiguity_error( test_commands ) do
+			complete 'tes '
+		end
 
-    assert_raises_command_ambiguity_error( test_commands ) do
-      complete 'test '
-    end
+		assert_raises_command_ambiguity_error( test_commands ) do
+			complete 'test '
+		end
 
-    starts_with_ad = test_commands.select {|c| c =~ /^ad/}
+		starts_with_ad = test_commands.select {|c| c =~ /^ad/}
 
-    assert_raises_command_ambiguity_error( starts_with_ad ) do
-      assert_equal "test ad", complete( 'test ad' )
-    end
+		assert_raises_command_ambiguity_error( starts_with_ad ) do
+			assert_equal "test ad", complete( 'test ad' )
+		end
 
-    assert_raises_command_ambiguity_error( starts_with_ad ) do
-      assert_equal "test ad", complete( 'tes ad' )
-    end
+		assert_raises_command_ambiguity_error( starts_with_ad ) do
+			assert_equal "test ad", complete( 'tes ad' )
+		end
 
-    assert_nothing_raised do
-      ### strip'ing because completion returns it with a trailing space
-      assert_equal "test administer", complete( 'test adm' ).strip
-      assert_equal "test administer", complete( 'tes adm' ).strip
-    end
-  end
+		assert_nothing_raised do
+			### strip'ing because completion returns it with a trailing space
+			assert_equal "test administer", complete( 'test adm' ).strip
+			assert_equal "test administer", complete( 'tes adm' ).strip
+		end
+	end
 
 
-  #######
-  private
-  #######
-  def complete( str )
-    return Linen::CLI.expand_command( str )
-  end
+	#######
+	private
+	#######
+	def complete( str )
+		return Linen::CLI.expand_command( str )
+	end
 
-  def assert_raises_ambiguity_error( exception, candidates, &block )
-    begin
-      block.call
-    rescue exception => e
-      assert_equal candidates, e.candidates
-    else
-      flunk 'no exception raised!'
-    end
-  end
+	def assert_raises_ambiguity_error( exception, candidates, &block )
+		begin
+			block.call
+		rescue exception => e
+			assert_equal candidates, e.candidates
+		else
+			flunk 'no exception raised!'
+		end
+	end
 
-  def assert_raises_plugin_ambiguity_error( candidates, &block )
-    assert_raises_ambiguity_error Linen::CLI::AmbiguousPluginError, candidates, &block
-  end
+	def assert_raises_plugin_ambiguity_error( candidates, &block )
+		assert_raises_ambiguity_error Linen::CLI::AmbiguousPluginError, candidates, &block
+	end
 
-  def assert_raises_command_ambiguity_error( candidates, &block )
-    assert_raises_ambiguity_error Linen::CLI::AmbiguousCommandError, candidates, &block
-  end
+	def assert_raises_command_ambiguity_error( candidates, &block )
+		assert_raises_ambiguity_error Linen::CLI::AmbiguousCommandError, candidates, &block
+	end
 end

data/test/test_indifferent_hash.rb

@@ -11,41 +11,41 @@ require 'test/unit'
 require 'indifferent_hash'
 
 class TestIndifferentHash < Test::Unit::TestCase
-  def setup
-    @rhash = {
-      :symbol  => 'regular symbol',
-      'string' => 'regular string'
-    }
+	def setup
+		@rhash = {
+			:symbol  => 'regular symbol',
+			'string' => 'regular string'
+		}
 
-    @ihash = IndifferentHash.new
-    @ihash[ :symbol ]  = 'indifferent symbol'
-    @ihash[ 'string' ] = 'indifferent string'
-  end
+		@ihash = IndifferentHash.new
+		@ihash[ :symbol ]  = 'indifferent symbol'
+		@ihash[ 'string' ] = 'indifferent string'
+	end
 
 
-  def test_string_to_symbol_lookups
-    key = 'symbol'
+	def test_string_to_symbol_lookups
+		key = 'symbol'
 
-    assert_nil @rhash[ key ]
-    assert_equal 'indifferent symbol', @ihash[ key ]
-  end
+		assert_nil @rhash[ key ]
+		assert_equal 'indifferent symbol', @ihash[ key ]
+	end
 
 
-  def test_symbol_to_string_lookups
-    key = :string
+	def test_symbol_to_string_lookups
+		key = :string
 
-    assert_nil @rhash[ key ]
-    assert_equal 'indifferent string', @ihash[ key ]
-  end
+		assert_nil @rhash[ key ]
+		assert_equal 'indifferent string', @ihash[ key ]
+	end
 
 
-  def test_literal_key_priority
-    ihash = IndifferentHash.new
+	def test_literal_key_priority
+		ihash = IndifferentHash.new
 
-    ihash[ :key  ] = "symbol"
-    ihash[ 'key' ] = "string"
+		ihash[ :key  ] = "symbol"
+		ihash[ 'key' ] = "string"
 
-    assert_equal "symbol", ihash[ :key  ]
-    assert_equal "string", ihash[ 'key' ]
-  end
+		assert_equal "symbol", ihash[ :key  ]
+		assert_equal "string", ihash[ 'key' ]
+	end
 end

data/test/test_plugins.rb

@@ -12,54 +12,54 @@ require 'linen'
 
 ### a little helper for later
 class String
-  def to_regex
-    return /#{self}/
-  end
+	def to_regex
+		return /#{self}/
+	end
 end
 
 
 class TestPlugins < Test::Unit::TestCase
 
-  ########################
-  # "constant" variables #
-  ########################
+	########################
+	# "constant" variables #
+	########################
 
-  @description = "This is some descriptions"
-  @help_msg  = "This is some help messagesess"
-  class << self
-    attr_reader :description, :help_msg
-  end
+	@description = "This is some descriptions"
+	@help_msg  = "This is some help messagesess"
+	class << self
+		attr_reader :description, :help_msg
+	end
 
-  ################
-  # test plugins #
-  ################
+	################
+	# test plugins #
+	################
 
-  class ::HelpfulPlugin < Linen::Plugin
-    puts TestPlugins.description
-    description TestPlugins.description
+	class ::HelpfulPlugin < Linen::Plugin
+		puts TestPlugins.description
+		description TestPlugins.description
 
-    command :test do
-      help_message TestPlugins.help_msg
-    end
-  end
+		command :test do
+			help_message TestPlugins.help_msg
+		end
+	end
 
 
-  class ::UnhelpfulPlugin < Linen::Plugin
-    command :test do;end
-  end
+	class ::UnhelpfulPlugin < Linen::Plugin
+		command :test do;end
+	end
 
-  #########
-  # tests #
-  #########
+	#########
+	# tests #
+	#########
 
-  def test_plugin_help
-    assert HelpfulPlugin.help =~ TestPlugins.description.to_regex
-    assert UnhelpfulPlugin.help =~ /No help for unhelpful/
-  end
+	def test_plugin_help
+		assert HelpfulPlugin.help =~ TestPlugins.description.to_regex
+		assert UnhelpfulPlugin.help =~ /No help for unhelpful/
+	end
 
 
-  def test_command_help
-    assert HelpfulPlugin.commands[ :test ].help =~ TestPlugins.help_msg.to_regex
-    assert UnhelpfulPlugin.commands[ :test ].help =~ /No help for unhelpful test/
-  end
+	def test_command_help
+		assert HelpfulPlugin.commands[ :test ].help =~ TestPlugins.help_msg.to_regex
+		assert UnhelpfulPlugin.commands[ :test ].help =~ /No help for unhelpful test/
+	end
 end