indentation 0.0.1

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.0.1 2010-05-03
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,20 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+features/development.feature
+features/step_definitions/common_steps.rb
+features/support/common.rb
+features/support/env.rb
+features/support/matchers.rb
+lib/indentation.rb
+lib/indentation/array_mod.rb
+lib/indentation/string_mod.rb
+script/console
+script/destroy
+script/generate
+spec/indentation_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,5 @@
+-------------------------------------------------------------------------------
+Thanks for installing the indentation gem! :)
+
+For more information on indentation, see http://indentation.rubyforge.org
+-------------------------------------------------------------------------------

data/README.rdoc

@@ -0,0 +1,131 @@
+= Indentation
+
+* http://github.com/samueldana/indentation
+
+== DESCRIPTION:
+
+A small library of extensions to Ruby's Array and String classes that allow indentation manipulation of Strings and Arrays of Strings. Has the capability of working with multi-line strings. If you frequently use String arrays to manipulate text, see synopsis below for examples of how indentation can make your life easier.
+
+== SYNOPSIS:
+  
+=== Indent
+
+  # Default indentation is 2 spaces
+    "test".indent # => "  test"
+
+  # Amount of indentation can be changed
+    "test".indent(3) # => "   test"
+
+  # Indentation character (or string) is set as the second parameter of indent.
+    "test".indent(2, "\t") # => "\t\ttest"
+  
+  # Operates on multi-line strings
+    "this\nis\na\ntest".indent # => "  this\n  is\n  a\n  test"
+
+  # Indent method accepts negative values (Removes tabs, spaces, and supplied indentation string)
+    "  test".indent(-1) # => " test"
+    "\t test".indent(-5) # => "test"
+    "\t--     Test".indent(-10) # => "--     Test"
+    "\t--     Test".indent(-10, '-') # => "Test"
+    "--- Test".indent(-2, '--') # => "- Test"
+
+  # Operates on arrays
+    ["one", "two"].indent # => ["  one", "  two"]
+    [["one", "  two"], ["uno", "\t\tdos"]].indent # => [["  one", "    two"], ["  uno", "  \t\tdos"]]
+
+
+=== Reset Indentation
+
+  # 'resets' the indentation of a string by finding the least amount of indentation in the String/Array, and
+  # removing that amount from every line.
+    "  def method_name\n    # Do stuff\n  end".reset_indentation # => "def method_name\n  # Do stuff\nend"
+  
+  # Operates on arrays
+    ["  def method_name", "    # Do stuff", "  end"].reset_indentation # => ["def method_name", "  # Do stuff", "end"]
+  
+  # Useful for heredocs - must chomp to remove trailing newline
+    my_string = <<-EOS.chomp.reset_indentation
+      def method_name
+        # Do stuff
+      end
+      EOS
+    my_string # => "def method_name\n  # Do stuff\nend"
+
+  # Accepts an indentation modifier
+    " one\n  two".reset_indentation(1) # => " one\n  two"
+    "   one\n  two".reset_indentation(0) # => " one\ntwo" - Default behavior
+    " one\n  two".reset_indentation(-1) # => "one\ntwo"
+  
+  
+=== Append Separator
+
+  # Given an Array of Arrays or an Array of Strings, appends a separator object to all but the last element in the Array.
+  # NOTE: For an Array of Strings the separator object must be a String, since it is appended to other Strings
+    ["arg1", "arg2", "arg3"].append_separator("!") # => ["arg1!", "arg2!", "arg3"]
+    [["line1"], ["line2"], ["line3"]].append_separator("") # => [["line1", ""], ["line2", ""], ["line3"]]
+    [["line1", "line2"], ["line3", "line4"]].append_separator("") # => [["line1", "line2", ""], ["line3", "line4"]]
+  
+  # Useful combined with indent and join
+    vars = ["var1", "var2", "var3", "var4"]
+    method_def = ["def add_up(#{vars.join(', ')})"]
+    method_body = vars.append_separator(" + ")
+    method_def += method_body.indent
+    method_def << "end"
+    method_def.join("\n") # =>
+      # def add_up(var1, var2, var3, var4)
+      #   var1 + 
+      #   var2 + 
+      #   var3 + 
+      #   var4
+      # end
+  
+  # Handy for separating arrays of string arrays
+    test_array = [["this", "is", "a", "test"], ["quick", "brown", "fox"], ["lazy", "typist"]]
+    test_array.append_separator("").join("\n") # =>
+      # this
+      # is
+      # a
+      # test
+      # 
+      # quick
+      # brown
+      # fox
+      # 
+      # lazy
+      # typist
+  
+== REQUIREMENTS:
+
+* rake (for installation)
+
+== INSTALL:
+
+* git clone git://github.com/samueldana/indentation.git
+* cd indentation
+* rake install_gem
+  * Or if using rvm: rake rvm_install_gem (doesn't use sudo)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Prometheus Computing
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/indentation'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'indentation' do
+  self.developer 'Samuel Dana', 's.dana@prometheuscomputing.com'
+  self.post_install_message = File.read(File.join(File.dirname(__FILE__),'PostInstall.txt'))
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]
+
+# Add rvm gem install tasks
+desc 'Install the package as a gem for rvm (no sudo), without generating documentation(ri/rdoc)'
+task :rvm_install_gem_no_doc => [:clean, :package] do
+  sh "gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+desc 'Shortcut to rvm_install_gem_no_doc task'
+task :rig => [:rvm_install_gem_no_doc] do
+end
+
+desc 'Install the package as a gem for rvm (no sudo)'
+task :rvm_install_gem => [:clean, :package] do
+  sh "gem install pkg/*.gem"
+end

data/features/development.feature

@@ -0,0 +1,13 @@
+Feature: Development processes of newgem itself (rake tasks)
+
+  As a Newgem maintainer or contributor
+  I want rake tasks to maintain and release the gem
+  So that I can spend time on the tests and code, and not excessive time on maintenance processes
+    
+  Scenario: Generate RubyGem
+    Given this project is active project folder
+    And "pkg" folder is deleted
+    When I invoke task "rake gem"
+    Then folder "pkg" is created
+    And file with name matching "pkg/*.gem" is created else you should run "rake manifest" to fix this
+    And gem spec key "rdoc_options" contains /(--mainREADME.rdoc|\[\"--main\", \"README.rdoc\"\])/

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,168 @@
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to "(.*)"/ do |env_var, value|
+  ENV[env_var] = value
+end
+
+Given /"(.*)" folder is deleted/ do |folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  in_project_folder do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end

data/features/support/common.rb

@@ -0,0 +1,29 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/../../lib/indentation"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end

data/features/support/matchers.rb

@@ -0,0 +1,11 @@
+module Matchers
+  def contain(expected)
+    simple_matcher("contain #{expected.inspect}") do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to contain #{expected.inspect}"
+      matcher.negative_failure_message = "expected #{given.inspect} not to contain #{expected.inspect}"
+      given.index expected
+    end
+  end
+end
+
+World(Matchers)

data/lib/indentation.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'indentation/string_mod.rb'
+require 'indentation/array_mod.rb'
+
+module Indentation
+  VERSION = '0.0.1'
+end

data/lib/indentation/array_mod.rb

@@ -0,0 +1,74 @@
+class Array
+  # Appends a given separator(s) to all but the last element in an array of Strings
+  # or if performed on an array of arrays, appends the separator element to the end of each array except the last
+  def append_separator(*separators)
+    len = self.length
+    ret_array = Array.new
+    self.each_with_index do |element, i|
+      new_element = element.dup
+      unless i == len - 1
+        separators.each do |separator|
+          new_element << separator 
+        end
+      end
+      ret_array << new_element
+    end
+    ret_array
+  end
+
+  # Append the given separator(s) to the current array
+  def append_separator!(*separators)
+    len = self.length
+    self.each_with_index do |element, i|
+      unless i == len - 1
+        separators.each do |separator|
+          element << separator 
+        end
+      end
+    end
+  end
+  
+  # Return an indented array of strings (or an array of other arrays containing strings)
+  # Arguments:
+  # * num - How many of the specified indentation to use.
+  #         Default for spaces is 2. Default for other is 1.
+  #         If set to a negative value, removes that many of the specified indentation character,
+  #         tabs, or spaces from the beginning of the string
+  # * i_char - Character (or string) to use for indentation
+  def indent(num = nil, i_char = ' ')
+    self.collect do |array_element|
+      array_element.indent(num, i_char)
+    end
+  end
+  
+  # Apply indentation to this array
+  # Arguments:
+  # * num - How many of the specified indentation to use.
+  #         Default for spaces is 2. Default for other is 1.
+  #         If set to a negative value, removes that many of the specified indentation character,
+  #         tabs, or spaces from the beginning of the string
+  # * i_char - Character (or string) to use for indentation
+  def indent!(num = nil, i_char = ' ')
+    self.collect! do |array_element|
+      array_element.indent!(num, i_char)
+    end
+  end
+  
+  # Get the least indentation of all elements
+  def find_least_indentation
+    self.collect{|array_element| array_element.find_least_indentation }.min
+  end
+  
+  # Find the least indentation of all elements and remove that amount (if any)
+  # Can pass an optional modifier that changes the indentation amount removed
+  def reset_indentation(modifier = 0)
+    indent(-find_least_indentation + modifier)
+  end
+  
+  # Replaces the current array with one that has its indentation reset
+  # Can pass an optional modifier that changes the indentation amount removed
+  def reset_indentation!(modifier = 0)
+    indent!(-find_least_indentation + modifier)
+  end
+  
+end

data/lib/indentation/string_mod.rb

@@ -0,0 +1,64 @@
+class String
+  # Return an indented copy of this string
+  # Arguments:
+  # * num - How many of the specified indentation to use.
+  #         Default for spaces is 2. Default for other is 1.
+  #         If set to a negative value, removes that many of the specified indentation character,
+  #         tabs, or spaces from the beginning of the string
+  # * i_char - Character (or string) to use for indentation
+  def indent(num = nil, i_char = ' ')
+    _indent(num, i_char)
+  end
+  
+  # Indents this string
+  # Arguments:
+  # * num - How many of the specified indentation to use.
+  #         Default for spaces is 2. Default for other is 1.
+  #         If set to a negative value, removes that many of the specified indentation character,
+  #         tabs, or spaces from the beginning of the string
+  # * i_char - Character (or string) to use for indentation
+  def indent!(num = nil, i_char = ' ')
+    replace(_indent(num, i_char))
+  end
+  
+  # Split across newlines and return the fewest number of indentation characters found on each line
+  def find_least_indentation
+    empty? ? 0 : split("\n", -1).collect{|substr| substr.match(/^[ \t]*/).to_s.length}.min
+  end
+  
+  # Find the least indentation of all lines within this string and remove that amount (if any)
+  # Can pass an optional modifier that changes the indentation amount removed
+  def reset_indentation(modifier = 0)
+    indent(-find_least_indentation + modifier)
+  end
+  
+  # Replaces the current string with one that has had its indentation reset
+  # Can pass an optional modifier that changes the indentation amount removed
+  def reset_indentation!(modifier = 0)
+    indent!(-find_least_indentation + modifier)
+  end
+  
+  private
+  def _indent(num = nil, i_char = ' ')
+    # Define number of indentations to use
+    number = num
+    # Default number to 2 if spaces or 1 if other
+    number ||= (i_char == ' ') ? 2 : 1
+  
+    case
+    when number >= 0
+      split("\n", -1).collect{|line| (i_char * number) + line}.join("\n")
+    else
+      i_regexp = Regexp.new("^([ \t]|#{i_char})")
+      split("\n", -1).collect do |line|
+        ret_str = String.new(line)
+        number.abs.times do
+          match = ret_str.sub!(i_regexp, '')
+          break unless match
+        end
+        ret_str
+      end.join("\n")
+    end
+  end
+  
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/indentation.rb'}"
+puts "Loading indentation gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/indentation_spec.rb

@@ -0,0 +1,356 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "Single-line String indentation" do
+  
+  it "should indent a string using 2 spaces as the default" do
+    "test string".indent.should == "  test string"
+  end
+  
+  it "should indent a given string the passed amount of indentation" do
+    "test string".indent(3).should == "   test string"
+    "test string".indent(0).should == "test string"
+  end
+  
+  it "should indent a string using 1 tab as default, if tabs were specified but an amount was not" do
+    "test string".indent(nil, "\t").should == "\ttest string"
+  end
+  
+  it "should indent a string the passed amount of tabbed indentation" do
+    "test string ".indent(3, "\t").should == "\t\t\ttest string "
+    "test string ".indent(0, "\t").should == "test string "
+  end
+  
+  it "should indent a string using the passed indentation character" do
+    "test string".indent(1, "!").should == "!test string"
+    "test string".indent(2, "--").should == "----test string"
+  end
+  
+  it "should remove tab and space indentation if a negative amount is specified" do
+    "   test string ".indent(-2).should == " test string "
+    "   test string ".indent(-3).should == "test string "
+    "   test string ".indent(-4).should == "test string "
+    
+    "\t  test string ".indent(-2).should == " test string "
+    "\t  test string ".indent(-3).should == "test string "
+    "\t  test string ".indent(-4).should == "test string "
+
+    " \t test string ".indent(-2).should == " test string "
+    " \t test string ".indent(-3).should == "test string "
+    " \t test string ".indent(-4).should == "test string "
+    
+    "  \ttest string ".indent(-2).should == "\ttest string "
+    "  \ttest string ".indent(-3).should == "test string "
+    "  \ttest string ".indent(-4).should == "test string "
+    
+    "\t\t\ttest string ".indent(-2).should == "\ttest string "
+    "\t\t\ttest string ".indent(-3).should == "test string "
+    "\t\t\ttest string ".indent(-4).should == "test string "
+  end
+  
+  it "should remove tab, space, and the specified indentation type if a negative amount and indentation character is specified" do
+    "   \t\t\t---my string".indent(-8, '-').should == "-my string"
+    "   \t\t\t---my string".indent(-8).should == "---my string"
+    "   --- my string".indent(-4, "---").should == " my string"
+  end
+  
+end
+
+describe "Multi-line String indentation" do
+  
+  it "should indent each line within the given string" do
+    "  this\nis\na\n test\n".indent.should == "    this\n  is\n  a\n   test\n  "
+    "  this\nis\na\n test\n".indent(3).should == "     this\n   is\n   a\n    test\n   "
+    "  this\nis\na\n test\n".indent(3, "\t").should == "\t\t\t  this\n\t\t\tis\n\t\t\ta\n\t\t\t test\n\t\t\t"
+  end
+  
+  it "should de-indent each line within the given string" do
+    "   \t\t\t This\n   is \n a\ntest\n ".indent(-1).should == "  \t\t\t This\n  is \na\ntest\n"
+    "   \t\t\t This\n   is \n a\ntest\n ".indent(-2).should == " \t\t\t This\n is \na\ntest\n"
+    "   \t\t\t This\n   is \n a\ntest\n ".indent(-3).should == "\t\t\t This\nis \na\ntest\n"
+    "   \t\t\t This\n   is \n a\ntest\n ".indent(-6).should == " This\nis \na\ntest\n"
+    "   \t\t\t This\n   is \n a\ntest\n ".indent(-7).should == "This\nis \na\ntest\n"
+    "   \t\t\t This\n   is \n a\ntest\n ".indent(-8).should == "This\nis \na\ntest\n"
+  end
+end
+
+describe "Single-line Array indentation" do
+  before :all do
+    @test_array = ['ali', '  bob', 'charlie']
+  end
+  
+  it "should indent each element 2 spaces by default" do
+    indented_array = @test_array.indent
+    
+    indented_array[0].should == '  ali'
+    indented_array[1].should == '    bob'
+    indented_array[2].should == '  charlie'
+  end
+  
+  it "should indent each element using 1 tab as default, if tabs were specified but an amount was not" do
+    indented_array = @test_array.indent(nil, "\t")
+    
+    indented_array[0].should == "\tali"
+    indented_array[1].should == "\t  bob"
+    indented_array[2].should == "\tcharlie"
+  end
+  
+  it "should remove indentation if a negative amount was specified" do
+    indented_array = @test_array.indent.indent(1, "\t").indent(3) # => ["   \t  ali", "   \t    bob", "   \t  charlie"]
+    # Check that the array was correctly created
+    indented_array[0].should == "   \t  ali"
+    indented_array[1].should == "   \t    bob"
+    indented_array[2].should == "   \t  charlie"
+    
+    # De-indent the array
+    deindented_array = indented_array.indent(-7)
+    deindented_array[0].should == "ali"
+    deindented_array[1].should == " bob"
+    deindented_array[2].should == "charlie"
+  end
+  
+end
+
+describe "Multi-line Array indentation" do
+  before :all do
+    @test_array = ["\n \t\n test\n", " One\n  Two\n   Three", "This\nis\na\ntest"]
+  end
+  
+  it "should indent each line of each element 2 spaces by default" do
+    indented_array = @test_array.indent
+    
+    indented_array[0].should == "  \n   \t\n   test\n  "
+    indented_array[1].should == "   One\n    Two\n     Three"
+    indented_array[2].should == "  This\n  is\n  a\n  test"
+  end
+  
+  it "should indent each line of each element using 1 tab as default, if tabs were specified but an amount was not" do
+    indented_array = @test_array.indent(nil, "\t")
+    
+    indented_array[0].should == "\t\n\t \t\n\t test\n\t"
+    indented_array[1].should == "\t One\n\t  Two\n\t   Three"
+    indented_array[2].should == "\tThis\n\tis\n\ta\n\ttest"
+  end
+  
+  it "should remove indentation if a negative amount was specified" do
+    deindented_array = @test_array.indent(-1)
+    
+    deindented_array[0].should == "\n\t\ntest\n"
+    deindented_array[1].should == "One\n Two\n  Three"
+    deindented_array[2].should == "This\nis\na\ntest"
+  end
+  
+  it "should indent any contained arrays if they exist" do
+    array = @test_array
+    array << ["This", 'is', "a", "test"]
+    indented_array = array.indent
+    
+    indented_array[3][0].should == "  This"
+    indented_array[3][1].should == "  is"
+    indented_array[3][2].should == "  a"
+    indented_array[3][3].should == "  test"
+  end
+end
+
+describe "Append Separator function" do
+  before :each do
+    @strings = ['bob', 'sue', 'joe']
+    @arrays = [['one', 'two', 'three'], ['1', '2', '3'], ['uno', 'dos', 'tres']]
+  end
+  
+  it "should append the given separator to the end of each string except the last if called on an array of strings" do
+    separated_array = @strings.append_separator("!")
+
+    separated_array[0].should == "bob!"
+    separated_array[1].should == "sue!"
+    separated_array[2].should == "joe"
+  end
+  
+  it "should append the given separator to the end of each array except the last if called on an array of arrays" do
+    separated_array = @arrays.append_separator("!")
+    
+    separated_array[0].last.should == "!"
+    separated_array[1].last.should == "!"
+    separated_array[2].last.should == "tres"
+  end
+  
+  it "should not modify the current array unless the '!' version of the function is used - Strings" do
+    @strings.append_separator("!")
+    @strings[0].should == 'bob'
+    @strings[1].should == 'sue'
+    @strings[2].should == 'joe'
+  end
+  
+  it "should not modify the current array unless the '!' version of the function is used - Arrays" do
+    @arrays.append_separator("!")
+    @arrays[0].last.should == "three"
+    @arrays[1].last.should == "3"
+    @arrays[2].last.should == "tres"
+  end
+  
+  it "should apply changes to the current array if the '!' version of the function is used - Strings" do
+    @strings.append_separator!("!")
+    @strings[0].should == 'bob!'
+    @strings[1].should == 'sue!'
+    @strings[2].should == 'joe'
+  end
+  
+  it "should apply changes to the current array if the '!' version of the function is used - Arrays" do
+    @arrays.append_separator!("!")
+    @arrays[0].last.should == "!"
+    @arrays[1].last.should == "!"
+    @arrays[2].last.should == "tres"
+  end
+end
+  
+describe "Find Least Indentation function" do
+  it "should return the least amount of indentation on any line within an Array or String" do
+    test_string_one = "   \tThis\n         is a\n \ttest"
+    test_string_two = "     \t Test\n             Number\n                  Two"
+    test_string_one.find_least_indentation.should == 2
+    test_string_two.find_least_indentation.should == 7
+    
+    test_array = [test_string_one, test_string_two]
+    test_array.find_least_indentation.should == 2
+    test_array << "    Test\n again!"
+    test_array.find_least_indentation.should == 1
+    test_array << "No Indentation!"
+    test_array.find_least_indentation.should == 0
+    test_array << ""
+    test_array.find_least_indentation.should == 0
+  end
+end
+
+describe "Reset Indentation function" do
+  it "should remove the least amount of indentation found in a String or Array" do
+    test_string = <<-EOS.chomp.reset_indentation
+      def method_name(arg)
+        # Do stuff here
+      end
+      EOS
+    test_string.should == "def method_name(arg)\n  # Do stuff here\nend"
+    
+    test_array = ["      def method_name(arg)", "        # Do stuff here", "      end"]
+    
+    test_array.reset_indentation.join("\n").should == test_string
+  end
+  
+  it "should allow a modifier to be passed that changes how much indentation is added/removed" do
+    
+    string = <<-EOS
+      def method_name(arg)
+        # Do stuff here
+      end
+      EOS
+    
+    test_string = string.chomp.reset_indentation(2)
+    test_string.should == "  def method_name(arg)\n    # Do stuff here\n  end"
+
+    test_array = ["      def method_name(arg)", "        # Do stuff here", "      end"]
+
+    test_array.reset_indentation(2).join("\n").should == test_string
+    
+    # Use of negative indentation works here too
+    string.chomp.reset_indentation(-1).should == "def method_name(arg)\n # Do stuff here\nend"
+    test_array.reset_indentation(-1).join("\n").should == string.chomp.reset_indentation(-1)
+  end
+    
+  it "should not modify the current object unless the '!' version of the function is used - String" do
+    string = "  This\n    is\n  a test"
+    string.reset_indentation.should == "This\n  is\na test"
+    string.should == "  This\n    is\n  a test"
+  end
+  
+  it "should not modify the current object unless the '!' version of the function is used - Array" do
+    array = ["  This", "    is", "  a test"]
+    array.reset_indentation.should == ["This", "  is", "a test"]
+    array.should == ["  This", "    is", "  a test"]
+  end
+  
+  it "should apply changes to the current object if the '!' version of the function is used - String" do
+    string = "  This\n    is\n  a test"
+    string.reset_indentation!.should == "This\n  is\na test"
+    string.should == "This\n  is\na test"
+  end
+  
+  it "should apply changes to the current object if the '!' version of the function is used - Array" do
+    array = ["  This", "    is", "  a test"]
+    array.reset_indentation!.should == ["This", "  is", "a test"]
+    array.should == ["This", "  is", "a test"]
+  end
+  
+end
+
+describe "README.rdoc" do
+  it "should have correct examples for indent" do
+
+    # Default indentation is 2 spaces
+      "test".indent.should == "  test"
+
+    # Amount of indentation can be changed
+      "test".indent(3).should == "   test"
+
+    # Indentation character (or string) is set as the second parameter of indent.
+      "test".indent(2, "\t").should == "\t\ttest"
+
+    # Operates on multi-line strings
+      "this\nis\na\ntest".indent.should == "  this\n  is\n  a\n  test"
+
+    # Indent method accepts negative values (Removes tabs, spaces, and supplied indentation string)
+      "  test".indent(-1).should == " test"
+      "\t test".indent(-5).should == "test"
+      "\t--     Test".indent(-10).should == "--     Test"
+      "\t--     Test".indent(-10, '-').should == "Test"
+      "--- Test".indent(-2, '--').should == "- Test"
+
+    # Operates on arrays
+      ["one", "two"].indent.should == ["  one", "  two"]
+      [["one", "  two"], ["uno", "\t\tdos"]].indent.should == [["  one", "    two"], ["  uno", "  \t\tdos"]]
+
+  end
+  
+  it "should have correct examples for reset indentation" do  
+
+    # 'resets' the indentation of a string by finding the least amount of indentation in the String/Array, and
+    # removing that amount from every line.
+      "  def method_name\n    # Do stuff\n  end".reset_indentation.should == "def method_name\n  # Do stuff\nend"
+
+    # Operates on arrays
+      ["  def method_name", "    # Do stuff", "  end"].reset_indentation.should == ["def method_name", "  # Do stuff", "end"]
+
+    # Useful for heredocs - must chomp to remove trailing newline
+      my_string = <<-EOS.chomp.reset_indentation
+        def method_name
+          # Do stuff
+        end
+        EOS
+      my_string.should == "def method_name\n  # Do stuff\nend"
+
+    # Accepts an indentation modifier
+      " one\n  two".reset_indentation(1).should == " one\n  two"
+      "   one\n  two".reset_indentation(0).should == " one\ntwo" # Default behavior
+      " one\n  two".reset_indentation(-1).should == "one\ntwo"
+  end
+  
+  it "should have correct examples for append separator" do
+    
+    # Given an Array of Arrays or an Array of Strings, appends a separator object to all but the last element in the Array.
+    # NOTE: For an Array of Strings the separator object must be a String, since it is appended to other Strings
+      ["arg1", "arg2", "arg3"].append_separator("!").should == ["arg1!", "arg2!", "arg3"]
+      [["line1"], ["line2"], ["line3"]].append_separator("").should == [["line1", ""], ["line2", ""], ["line3"]]
+      [["line1", "line2"], ["line3", "line4"]].append_separator("").should == [["line1", "line2", ""], ["line3", "line4"]]
+
+    # Useful combined with indent and join
+      vars = ["var1", "var2", "var3", "var4"]
+      method_def = ["def add_up(#{vars.join(', ')})"]
+      method_body = vars.append_separator(" + ")
+      method_def += method_body.indent
+      method_def << "end"
+      method_def.join("\n").should == "def add_up(var1, var2, var3, var4)\n  var1 + \n  var2 + \n  var3 + \n  var4\nend"
+
+    # Handy for separating arrays of string arrays
+      test_array = [["this", "is", "a", "test"], ["quick", "brown", "fox"], ["lazy", "typist"]]
+      test_array.append_separator("").join("\n").should == "this\nis\na\ntest\n\nquick\nbrown\nfox\n\nlazy\ntypist"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'indentation'

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: indentation
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Samuel Dana
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-06 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id002
+description: A small library of extensions to Ruby's Array and String classes that allow indentation manipulation of Strings and Arrays of Strings. Has the capability of working with multi-line strings. If you frequently use String arrays to manipulate text, see synopsis below for examples of how indentation can make your life easier.
+email: 
+- s.dana@prometheuscomputing.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- features/development.feature
+- features/step_definitions/common_steps.rb
+- features/support/common.rb
+- features/support/env.rb
+- features/support/matchers.rb
+- lib/indentation.rb
+- lib/indentation/array_mod.rb
+- lib/indentation/string_mod.rb
+- script/console
+- script/destroy
+- script/generate
+- spec/indentation_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+has_rdoc: true
+homepage: http://github.com/samueldana/indentation
+licenses: []
+
+post_install_message: |-
+  -------------------------------------------------------------------------------
+  Thanks for installing the indentation gem! :)
+  
+  For more information on indentation, see http://indentation.rubyforge.org
+  -------------------------------------------------------------------------------
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: indentation
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A small library of extensions to Ruby's Array and String classes that allow indentation manipulation of Strings and Arrays of Strings
+test_files: []
+