stdouttoggler 0.5.0.pre

data/README.txt

@@ -0,0 +1,129 @@
+= Standard Out Toggler
+
+Standard Out Toggler is a simple executable gem that comments and uncomments 
+output lines from a variety of different file types. Out of the box, this gem 
+handles java, javascript in .js and .jsp, and ruby files. You can configure it to handle 
+any file type of your choice.
+
+== Use Case
+
+Often when debugging, I find myself adding output statements to code,
+for example alert statements to javascript code and System.out.println
+statements to java code. Then I discover I need to comment out the statements 
+from some files, because they're cluttering up my console, or because I get tired
+of crawling through javascript alerts. Later, I might need to uncomment them again.
+
+So I wrote a straightforward ruby program to do what I needed, with support
+for java and javascript.
+
+When I decided to add JSP files to the mix, and had to hard code another set
+of constants and and case statements, I realized that this was a prime opportunity
+for ruby metaprogramming.
+
+As a result, Standard Out Toggler dynamically builds support for default file types
+from a config file in the lib/config directory and offers you the option
+to add additional types via a YAML file in the current directory.
+
+== Running the program
+
+Run the executable from a directory of your choice using the stdouttoggler command.
+The only required option is the instruction option (-i), which tells stdouttoggler
+whether to comment or uncomment. Add one or more files as args (relative or absolute paths), 
+and run the program. For example:
+
+>toggle -i comment JavaFile.java C:/programs/JavaScriptFile.js
+
+== Command Line Options
+
+-h						Help screen.
+
+-i <comment|uncomment>	Tells stdouttoggler whether to comment or uncomment output lines.
+
+-b						Saves a backup of any changed file.
+
+-f						Tells stdouttoggler to find files for commenting or uncommenting
+						in a file called file_names.yaml, which you put in the current
+						directory. This can come in handy if you're changing a lot of files 
+						or using files with long paths. Note that if you use this option,
+						you can't put any files on the command line.
+						
+-c						Tells stdouttoggler that you're adding additional file types to the
+						default java, javascript, JSP, and ruby types, using a file called 
+						additional_types.yaml in the current directory.
+
+Here are some sample commands:
+
+>stdouttoggler -i comment JavaFile.java C:/programs/JavaScriptFile.js
+
+Comments out all System.out.print and System.out.println statements 
+in the java file, and all the alert statements in the javascript file.
+
+>toggle -i uncomment JavaFile.java C:/programs/JavaScriptFile.js
+
+Uncomments out all System.out.print and System.out.println statements 
+in the java file, and all the alert statements in the javascript file.
+
+>toggle -i comment -b JavaFile.java
+
+Comments out all System.out.print and System.out.println statements 
+in the java file and saves a backup (JavaFile.java.bak) of the original file.
+
+>toggle -i comment -f
+
+Comments out all output statements in the file_names.yaml file in your
+current directory. See the Using a File section below for an explanation 
+of the structure of that file.
+
+>toggle -i comment -c AnotherFileType.al
+
+Comments out all the output statements in AnotherFileType.al
+in your current directory, based on configuration instructions in
+additional_types.yaml in your current directory. See the Configuration
+section below for an explanation of the structure of the YAML configuration file.
+
+>toggle -i comment -f -c
+
+Comments out all output statements in the file_names.yaml file in your
+current directory, based on configuration instructions in
+additional_types.yaml in your current directory.
+
+== Using a File
+
+In the templates folder you'll find a sample YAML file called file_names.yaml that lists
+files to comment/uncomment:
+
+--- 
+- JavaFile.java
+- ./JavaScriptFile.js
+- C:/programs/ruby/ruby_file.rb
+- AnotherLanguage.al
+
+Note that you can use relative or absolute paths.
+
+== Configuration
+
+In the templates folder you'll find a sample YAML configuration file called additional_types.yaml 
+that lists three (imaginary) additional languages for commenting/uncommenting. You can use this file
+as a template for types you wish to add.
+
+---
+- :type: anotherlang
+  :extension: .al
+  :keyword: out
+  :comment_string: --
+  :comment_string_escaped: --
+- :type: otherlang
+  :extension: .ol
+  :keyword: print
+  :comment_string: //
+  :comment_string_escaped: \/\/
+- :type: rub
+  :extension: .rub
+  :keyword: putt
+  :comment_string: "#"
+  :comment_string_escaped: "#"
+
+The comment_string_escaped is the tricky one. It will be used in a regular expression,
+so if it contains metacharacters, they need to be escaped. Additionally, if any of the
+values use a character that means something special to the ruby interpreter, such as
+the hash sign, it must be put in quotation marks.

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+	t.libs << 'test'
+end

data/bin/toggle

@@ -0,0 +1,37 @@
+#!usr/bin/env ruby
+
+##############################################################
+# Copyright (c) 2012 Mark Buechler
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+##############################################################
+
+###############################################
+#This is the executable used to comment and
+#uncomment output lines from a variety of different
+#file types.
+
+#A typical command to run the executable is as follows:
+#>toggle -i comment JavaFile.java JavaScriptFile.js
+
+#That command would comment out all System.out.print and
+#System.out.println statements in the java file,
+#and all the alert statements in the javascript file.
+
+#To reactivate the output statements, 
+#you would run the corresponding uncomment command:
+#>toggle -i uncomment JavaFile.java JavaScriptFile.js
+
+#Out of the box, this gem handles java, javascript, jsp, and ruby files.
+#Command line options are available that enable users 
+#to add language types, list files for commenting/uncommenting in a file
+#instead of on the command line, and and create backups.
+
+#See README for additional details.
+###############################################
+
+require 'stdouttoggler'
+StdOutToggler::Application.new.run

data/examples/additional_types.yaml

@@ -0,0 +1,16 @@
+---
+- :type: anotherlang
+  :extension: .al
+  :keyword: out
+  :comment_string: --
+  :comment_string_escaped: --
+- :type: otherlang
+  :extension: .ol
+  :keyword: print
+  :comment_string: //
+  :comment_string_escaped: \/\/
+- :type: rub
+  :extension: .rub
+  :keyword: putt
+  :comment_string: "#"
+  :comment_string_escaped: "#"

data/examples/file_names.yaml

@@ -0,0 +1,5 @@
+--- 
+- JavaFile.java
+- ./JavaScriptFile.js
+- C:/programs/ruby/ruby_file.rb
+- AnotherLanguage.al

data/lib/stdouttoggler/application.rb

@@ -0,0 +1,213 @@
+require 'stdouttoggler/types.rb'
+require 'stdouttoggler/types_validator.rb'
+require 'stdouttoggler/file_writer.rb'
+require 'stdouttoggler/regex/stdout_regex.rb'
+require 'optparse'
+require 'yaml'
+
+module StdOutToggler
+
+	#parses and validates command line options and configuration;
+	#runs the application;
+	#key instance variables:
+	#@options: command line options
+	#@stdout_type_maps: used to generate the regex class methods
+	#@files: list of files to comment/uncomment
+	class Application
+	
+		def initialize
+			prepare_options
+			validate_instruction
+			prepare_files
+			build_stdout_type_maps
+			validate_stdout_type_maps
+		end
+	
+		#parses command line options
+		def prepare_options
+			@options = {}
+			begin
+				optparse = OptionParser.new do |opts|
+					opts.banner = "usage: #{StdOutToggler.executable} [options] [file_paths]"
+					opts.on("-h", "--help", "Display help screen") do
+						puts opts
+						exit
+					end
+					opts.on("-b", "--backup",  "Keep backup file") do |b|
+						@options[:keep_backup] = b
+					end
+					opts.on("-i", "--instruction INSTRUCTION", "Indicate whether to comment or uncomment standard output", %w[comment uncomment]) do |i|
+						@options[:instruction] = i
+					end
+					opts.on("-f", "--file", "Retrieve file names from a file in the current directory called file_names.yaml, rather than as command-line args") do |f|
+						@options[:file] = f
+					end
+					opts.on("-c", "--config", "Configure comment out toggling for file types (other than the default java, javascript, jsp, and ruby) " +
+												"in a file in the current directory called additional_types.yaml") do |c|
+						@options[:config] = c
+					end
+				end.parse!
+			rescue => e
+				puts "Error parsing command line options: #{e.message}"
+				exit 1
+			end
+		end
+		
+		#ensures that we have the required instruction command
+		def validate_instruction
+			unless @options[:instruction]
+				puts "You need to have an -i (or --instruction) flag with an argument indicating comment or uncomment"
+				exit 1
+			end	
+		end
+		
+		#builds the list of files designated for commenting/uncommenting
+		def prepare_files
+			if @options[:file]
+				unless ARGV.length == 0
+					puts "If you use the -f option, indicating that target files will be listed in a file, " +
+							"you cannot name any files on the command line"
+					exit 1
+				end
+				begin
+					@files = File.open("file_names.yaml") do |f|
+						YAML.load(f)
+					end
+				rescue => e
+					puts "Your file_names.yaml file had the following error: #{e.message}"
+					exit 1
+				end
+				#sometimes the best we can do with YAML is ensure we get the data type back we expected
+				unless @files.is_a? Array
+					puts "Your file_names.yaml was invalid"
+					exit 1	
+				end
+			else
+				unless ARGV.length > 0
+					puts "In the absence of the -f option, the command needs to name at least one file"
+					exit 1
+				end
+				@files = ARGV
+			end		
+		end
+		
+		#builds the list of type maps used to dynamically generate methods
+		#in the stdout_regex class
+		def build_stdout_type_maps
+			default_stdout_type_maps = [] 		#part of gem configuration
+			configured_stdout_type_maps = []	#user-defined
+			@stdout_type_maps = []				#merge
+
+			#grabs default file types and associated information (e.g., stdout keyword, comment-out symbol)
+			default_stdout_type_maps = StdOutToggler::Types.new.type_maps
+
+			#grabs user-defined file types
+			if @options[:config]
+				begin
+					configured_stdout_type_maps = File.open("additional_types.yaml") do |f|
+						YAML.load(f)
+					end
+				rescue => e
+					puts "Your additional_types.yaml file had the following error: #{e.message}"
+					exit 1
+				end
+				unless configured_stdout_type_maps.is_a? Array
+					puts "Your additional_types.yaml was invalid"
+					exit 1	
+				end
+			end
+			#now merge and eliminate duplicates to arrive at list of type maps that
+			#will be used to setup our stdout regex classes
+			@stdout_type_maps = (default_stdout_type_maps + configured_stdout_type_maps).uniq
+		end
+		
+		#ensures that all type maps are valid
+		def validate_stdout_type_maps
+			type_maps_validator = TypesValidator.new(@stdout_type_maps)
+
+			#makes sure the maps are all valid
+			begin
+				type_maps_validator.valid_type_maps?
+			rescue RuntimeError => e
+				puts "Your additional_types.yaml file had the following error: #{e.message}"
+				exit 1
+			end
+
+			#check files and file extensions
+			@files.each do |file|
+				unless File.file?(file)
+					puts "#{file} is not a file"
+					exit 1
+				end
+				extension = File.extname(file)
+				unless type_maps_validator.valid_extension? extension
+					puts "The file #{file} must have an extension corresponding " +
+							"to one of the following (based on default types and those configured in additional_types.yaml): " +
+							"#{type_maps_validator.valid_extensions.join(' ')}"
+					exit 1
+				end
+			end		
+		end
+		
+		#comment/uncomment designated files, per command line instruction
+		def run
+			@stdout_type_maps.each do |type_map|
+				StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(type_map)
+			end
+			
+			begin
+				stdout_regex_producer = StdOutRegex::Producer.new()
+
+				#comment or uncomment each file
+				@files.each do |file|
+					type = ""
+					backup_file = file + ".bak"	
+					#infer type from extension
+					extension = File.extname(file)
+					@stdout_type_maps.each do |type_map|
+						if (type_map[:extension] == extension)
+							type = type_map[:type]
+							break
+						end
+					end
+		
+					#call dynamically generated method that produces regex and substitution string based on user input
+					stdout_regex = stdout_regex_producer.send("#{type}_#{@options[:instruction]}_regex");
+
+					#start with a fresh backup
+					if File.file? backup_file
+						File.delete backup_file
+					end
+
+					#original is now the backup
+					File.rename(file, backup_file)
+	
+					#using file handles so we can pass to a testable method
+					#that modifies the original file according to the instruction
+					input_file_handle = File.new(backup_file)
+					output_file_handle = File.new(file, "w")
+					FileWriter.modify_file(input_file_handle, output_file_handle, stdout_regex)
+
+					if @options[:keep_backup]
+						puts "keeping backup file: #{backup_file}" 
+					else
+						File.delete(backup_file)
+					end
+				end
+				
+				notify
+			rescue => e
+				puts "The application encountered the following problem: #{e.message}"
+			end
+				
+		end
+		
+		#displays results
+		def notify
+			file_string = @files.reduce(""){|a,file| a << (file + ", ")}.chop.chop
+			puts "All standard output lines in #{file_string} have been #{@options[:instruction]}ed#{@options[:instruction] == "comment" ? " out" : ""}."		
+		end
+	
+	end #end CommandLineHandler
+
+end

data/lib/stdouttoggler/file_writer.rb

@@ -0,0 +1,15 @@
+module StdOutToggler
+
+	#provides a clean, testable interface that
+	#handles the process of commenting out a file
+	class FileWriter
+		def self.modify_file(input_file_handle, output_file_handle, stdout_regex)
+			input_file_handle.each do |line|
+				output_file_handle.puts "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+			end
+			input_file_handle.close()
+			output_file_handle.close()
+		end
+	end
+
+end

data/lib/stdouttoggler/regex/stdout_regex.rb

@@ -0,0 +1,43 @@
+module StdOutToggler
+
+	#Given a list of maps containing information on a language type 
+	#(file extension, output keyword, and comment string),
+	#the StdoutRegex module dynamically builds a Producer class
+	#that produces a pair of strings. One is designed for use in a regular expression that finds
+	#an output statement, or a commented-out output statement.
+	#The other is designed for use as the replacement string.
+	#See lib/stdouttoggler/types.rb for the default list of maps used by stdouttoggler.
+	module StdOutRegex
+
+		#data type for regex and substitution strings
+		class Holder
+			attr_accessor :regex_interpolation, :substitution_string_interpolation
+			def initialize(regex_interpolation, substitution_string_interpolation)
+				@regex_interpolation, @substitution_string_interpolation = regex_interpolation, substitution_string_interpolation
+			end
+		end
+
+		#uses dynamically generated methods to produce necessary regexes and string substitutions for files
+		class Producer
+			#From the options map argument, this macro creates methods of the form <type>_comment_regex and <type>_uncomment_regex,
+			#for example: java_comment_regex and java_uncomment_regex
+			def self.create_methods_for_producing_stdout_regex_strings (options)
+				type = options[:type].downcase
+				comment_regex_interpolation = "^(\\s*)" + options[:keyword]
+				comment_substitution_string_interpolation = "\\1" + options[:comment_string] + options[:keyword]
+				uncomment_regex_interpolation = "^(\\s*)" + options[:comment_string_escaped] + "(\\s*)" + options[:keyword]
+				uncomment_substitution_string_interpolation = "\\1\\2" + options[:keyword]
+				#comment method
+				define_method ("#{type}_comment_regex").to_sym do
+					Holder.new(comment_regex_interpolation,comment_substitution_string_interpolation)
+				end
+				#uncomment method
+				define_method ("#{type}_uncomment_regex").to_sym do
+					Holder.new(uncomment_regex_interpolation,uncomment_substitution_string_interpolation)
+				end
+			end
+		end
+
+	end #end StdOutRegex module
+
+end

data/lib/stdouttoggler/types.rb

@@ -0,0 +1,15 @@
+module StdOutToggler
+
+	#class to hold our default file types
+	class Types
+		attr_accessor :type_maps
+		def initialize
+			@type_maps = []
+			type_maps[0] = {:type => "java", :extension => ".java", :keyword => "System.out.print", :comment_string => "//", :comment_string_escaped => "\\/\\/"}
+			type_maps[1] = {:type => "javascript", :extension => ".js", :keyword => "alert", :comment_string => "//", :comment_string_escaped => "\\/\\/"}
+			type_maps[2] = {:type => "jsp", :extension => ".jsp", :keyword => "alert", :comment_string => "//", :comment_string_escaped => "\\/\\/"}
+			type_maps[3] = {:type => "ruby", :extension => ".rb", :keyword => "puts", :comment_string => "#", :comment_string_escaped => "#"}
+		end
+	end
+	
+end

data/lib/stdouttoggler/types_validator.rb

@@ -0,0 +1,53 @@
+module StdOutToggler
+
+	#Validates the maps used to build the Producer class.
+	#This is important because users can add additional language types at runtime.
+	class TypesValidator
+
+		attr_reader :valid_extensions
+		
+		def initialize(stdout_type_maps)
+			@valid_extensions = []
+			@stdout_type_maps = stdout_type_maps
+			@stdout_type_maps.each do |type_map|
+				@valid_extensions << type_map[:extension]
+			end		
+		end
+		
+		#validates a file extension
+		def valid_extension?(extension)
+			@valid_extensions.include? extension
+		end
+
+		#validates the standard output information for each file type;
+		#validation rules: each option must exist, and
+		#extension options must be of form /^\.\w+/ (e.g., .java)
+		def valid_type_maps?()
+			@stdout_type_maps.each_with_index do |type_map|
+				unless (type_map[:type] && !type_map[:type].empty?)
+					raise "the type map with the extension #{type_map[:extension]} is missing a type"
+				end
+				unless (type_map[:keyword] && !type_map[:keyword].empty?)
+					raise "The type map for type #{type_map[:type]} is either missing a keyword or has an invalid keyword"
+				end				
+				unless(type_map[:extension] && !type_map[:extension].empty?)
+					raise "The type map for type #{type_map[:type]} is missing an extension"
+				end
+				unless (type_map[:extension].match(/^\.\w+/))
+					raise "The extension for #{type_map[:type]} must be of the form .<ext>"
+				end				
+				unless(type_map[:comment_string] && !type_map[:comment_string].empty?)
+					raise "The type map for type #{type_map[:type]} is either missing a comment string or has an invalid comment string. " + 
+							"One solution may be to put quotation marks around the string."
+				end					
+				unless(type_map[:comment_string_escaped] && !type_map[:comment_string_escaped].empty?)
+					raise "The type map for type #{type_map[:type]} is either missing an escaped comment string or has an invalid escaped comment string. " +
+							"One solution may be to put quotation marks around the string."
+				end
+				#otherwise we're good, return
+			end
+		end
+		
+	end #end Validator
+
+end

data/lib/stdouttoggler.rb

@@ -0,0 +1,22 @@
+##############################################################
+# Copyright (c) 2012 Mark Buechler
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+##############################################################
+
+require 'stdouttoggler/application.rb'
+require 'pathname'
+
+#application namespace
+module StdOutToggler
+	#returns the name of the executable file
+	def self.executable
+		bin = File.join("..", "bin")
+		Pathname.glob("bin/*") do |f|
+			name = File.basename(f)
+		end
+	end
+end

data/stdouttoggler.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s|
+	s.name="stdouttoggler"
+	s.version="0.5.0.pre"
+	s.platform=Gem::Platform::RUBY
+	s.date="2012-09-14"
+	s.summary="Comments and uncomments output lines in code"
+	s.description="As a debugging convenience, sdtouttoggler comments and uncomments output lines, such as alert in javascript"
+	s.author="Mark Buechler"
+	s.files=Dir["stdouttoggler.gemspec", "Rakefile", "README.txt", "lib/**/*", "test/test*.rb", "examples/*.yaml"]
+	s.homepage="http://rubygems.org/stdouttoggler"
+	s.executables=["toggle"]
+	s.require_paths=["lib"]
+end

data/test/test_file_writer.rb

@@ -0,0 +1,244 @@
+#!usr/bin/env ruby
+
+require 'test/unit'
+require 'stdouttoggler/application.rb'
+require 'stdouttoggler/types.rb'
+
+#So here we are testing whether our FileWriter.modify_file method 
+#actually writes what we expect to be written
+class FileWriterTest < Test::Unit::TestCase
+	
+	#using the actual default type maps for the application
+	def setup
+		@stdout_type_maps = StdOutToggler::Types.new.type_maps
+
+
+#puts java_file_commented
+
+
+	
+	end #setup
+	
+	def teardown
+		@stdout_type_maps = []
+	end
+
+#####################################
+	def test_java
+
+	@java_file_uncommented = <<EOS
+//don't touch this
+
+public class Whatever {
+
+	private String s;
+
+	public Whatever(String s) {
+		System.out.println("in constructor");
+		this.s = s;
+	}
+	
+	public meth1() {
+		s = s + "whatever";
+System.out.println("s: " + s);
+	}
+
+	System.out.println("toto");
+
+}
+EOS
+
+@java_file_commented = <<EOS
+//don't touch this
+
+public class Whatever {
+
+	private String s;
+
+	public Whatever(String s) {
+		//System.out.println("in constructor");
+		this.s = s;
+	}
+	
+	public meth1() {
+		s = s + "whatever";
+//System.out.println("s: " + s);
+	}
+
+	//System.out.println("toto");
+
+}
+EOS
+
+		#this is the java type map
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[0])
+
+		#comment
+		comment_regex_holder = StdOutToggler::StdOutRegex::Producer.new().java_comment_regex
+		input = StringIO.new(@java_file_uncommented)
+		output = StringIO.new
+		StdOutToggler::FileWriter.modify_file(input, output, comment_regex_holder)
+		assert_equal(@java_file_commented, output.string)
+
+		#uncomment
+		uncomment_regex_holder = StdOutToggler::StdOutRegex::Producer.new().java_uncomment_regex
+		input = StringIO.new(@java_file_commented)
+		output = StringIO.new
+		StdOutToggler::FileWriter.modify_file(input, output, uncomment_regex_holder)
+		assert_equal(@java_file_uncommented, output.string)
+		
+	end #end java test
+
+	
+#####################################
+	def test_javascript
+
+	@javascript_file_uncommented = <<EOS
+var x = 3
+			alert("hello");
+if (x == 3) {
+	alert("OK");
+}
+alert()
+EOS
+
+@javascript_file_commented = <<EOS
+var x = 3
+			//alert("hello");
+if (x == 3) {
+	//alert("OK");
+}
+//alert()
+EOS
+
+		#this is the javascript type map
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[1])
+
+		#comment
+		comment_regex_holder = StdOutToggler::StdOutRegex::Producer.new().javascript_comment_regex
+		input = StringIO.new(@javascript_file_uncommented)
+		output = StringIO.new
+		StdOutToggler::FileWriter.modify_file(input, output, comment_regex_holder)
+		assert_equal(@javascript_file_commented, output.string)
+
+		#uncomment
+		uncomment_regex_holder = StdOutToggler::StdOutRegex::Producer.new().javascript_uncomment_regex
+		input = StringIO.new(@javascript_file_commented)
+		output = StringIO.new
+		StdOutToggler::FileWriter.modify_file(input, output, uncomment_regex_holder)
+		assert_equal(@javascript_file_uncommented, output.string)
+		
+	end #end javascript test
+
+
+#####################################
+	def test_jsp
+
+	@jsp_file_uncommented = <<EOS
+<!-- not touching this -->
+
+<script>
+var x = 3
+			alert("hello");
+if (x == 3) {
+	alert("OK");
+}
+alert();
+</script>
+
+<h3>Hello</h3>
+
+<%
+	System.out.println("don't touch this");
+%>
+EOS
+
+@jsp_file_commented = <<EOS
+<!-- not touching this -->
+
+<script>
+var x = 3
+			//alert("hello");
+if (x == 3) {
+	//alert("OK");
+}
+//alert();
+</script>
+
+<h3>Hello</h3>
+
+<%
+	System.out.println("don't touch this");
+%>
+EOS
+
+		#this is the jsp type map
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[2])
+
+		#comment
+		jsp_comment_regex_holder = StdOutToggler::StdOutRegex::Producer.new().jsp_comment_regex
+		input = StringIO.new(@jsp_file_uncommented)
+		output = StringIO.new
+		StdOutToggler::FileWriter.modify_file(input, output, jsp_comment_regex_holder)
+		assert_equal(@jsp_file_commented, output.string)
+
+		#uncomment
+		jsp_uncomment_regex_holder = StdOutToggler::StdOutRegex::Producer.new().jsp_uncomment_regex
+		input = StringIO.new(@jsp_file_commented)
+		output = StringIO.new
+		StdOutToggler::FileWriter.modify_file(input, output, jsp_uncomment_regex_holder)
+		assert_equal(@jsp_file_uncommented, output.string)
+		
+	end #end jsp test
+	
+#####################################
+	def test_ruby
+
+	@ruby_file_uncommented = <<EOS
+#don't touch this
+
+s = "hello"
+
+def meth1
+	puts "chase"
+	return false
+end
+
+puts "finished"
+EOS
+
+@ruby_file_commented = <<EOS
+#don't touch this
+
+s = "hello"
+
+def meth1
+	#puts "chase"
+	return false
+end
+
+#puts "finished"
+EOS
+
+		#this is the ruby type map
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[3])
+
+		#comment
+		ruby_comment_regex_holder = StdOutToggler::StdOutRegex::Producer.new().ruby_comment_regex
+		input = StringIO.new(@ruby_file_uncommented)
+		output = StringIO.new
+		StdOutToggler::FileWriter.modify_file(input, output, ruby_comment_regex_holder)
+		assert_equal(@ruby_file_commented, output.string)
+
+		#uncomment
+		ruby_uncomment_regex_holder = StdOutToggler::StdOutRegex::Producer.new().ruby_uncomment_regex
+		input = StringIO.new(@ruby_file_commented)
+		output = StringIO.new
+		StdOutToggler::FileWriter.modify_file(input, output, ruby_uncomment_regex_holder)
+		assert_equal(@ruby_file_uncommented, output.string)
+		
+	end #end ruby test
+
+	
+	
+end

data/test/test_std_out_regex.rb

@@ -0,0 +1,280 @@
+#!usr/bin/env ruby
+
+require 'test/unit'
+require 'stdouttoggler/regex/stdout_regex.rb'
+require 'stdouttoggler/types_validator.rb'
+
+class TypesValidatorTest < Test::Unit::TestCase
+	
+	#config maps for testing
+	#(these aren't real php and python characteristics, just using made up ones for testing)
+	def setup
+		@stdout_type_maps = []
+		@stdout_type_maps[0] = {:type => "PHP", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		@stdout_type_maps[1] = {:type => "Python", :extension => ".py", :keyword => "pp", :comment_string => "//", :comment_string_escaped => "\/\/"}	
+	end
+	
+	def teardown
+		@stdout_type_maps = []
+	end
+
+	#making sure that the class macro is generating the correct methods
+	def test_respond_to 
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[0])
+		crp = StdOutToggler::StdOutRegex::Producer.new()
+		assert(crp.respond_to? "php_comment_regex")
+		assert(crp.respond_to? "php_uncomment_regex")
+	end
+
+	#calling generated methods
+	def test_direct_method_calls
+	
+		#php
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[0])
+		crp = StdOutToggler::StdOutRegex::Producer.new()
+		comment_regex_holder = crp.php_comment_regex()	#I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)printout", comment_regex_holder.regex_interpolation, "keyword for php comment should be printout")
+		assert_equal("\\1@@printout", comment_regex_holder.substitution_string_interpolation, "substitution string for php uncomment should be @@printout")
+		uncomment_regex_holder = crp.php_uncomment_regex()	#I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)@@(\\s*)printout", uncomment_regex_holder.regex_interpolation, "keyword for php uncomment should be @@printout")
+		assert_equal("\\1\\2printout", uncomment_regex_holder.substitution_string_interpolation, "substitution string for php uncomment should be printout")
+		
+		#python
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[1])
+		crp = StdOutToggler::StdOutRegex::Producer.new()
+		comment_regex_holder = crp.python_comment_regex() #I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)pp", comment_regex_holder.regex_interpolation, "keyword for python should be pp")
+		assert_equal("\\1//pp", comment_regex_holder.substitution_string_interpolation, "substitution string for python should be pp")		
+		uncomment_regex_holder = crp.python_uncomment_regex()
+		assert_equal("^(\\s*)\/\/(\\s*)pp", uncomment_regex_holder.regex_interpolation, "keyword for python should be \/\/pp")
+		assert_equal("\\1\\2pp", uncomment_regex_holder.substitution_string_interpolation, "substitution string for python should be pp")
+
+	end
+
+	#testing same methods as the test_direct_method_calls, just making sure we 
+	#can use send, because that's what the executable will use
+	def test_indirect_method_calls
+
+		#php
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[0])
+		crp = StdOutToggler::StdOutRegex::Producer.new()
+		comment_regex_holder = crp.send("php_comment_regex")	#I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)printout", comment_regex_holder.regex_interpolation, "keyword for php comment should be printout")
+		assert_equal("\\1@@printout", comment_regex_holder.substitution_string_interpolation, "substitution string for php uncomment should be @@printout")
+		uncomment_regex_holder = crp.send("php_uncomment_regex")	#I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)@@(\\s*)printout", uncomment_regex_holder.regex_interpolation, "keyword for php uncomment should be @@printout")
+		assert_equal("\\1\\2printout", uncomment_regex_holder.substitution_string_interpolation, "substitution string for php uncomment should be printout")
+		
+		#python
+		StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(@stdout_type_maps[1])
+		crp = StdOutToggler::StdOutRegex::Producer.new()
+		comment_regex_holder = crp.send("python_comment_regex") #I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)pp", comment_regex_holder.regex_interpolation, "keyword for python should be pp")
+		assert_equal("\\1//pp", comment_regex_holder.substitution_string_interpolation, "substitution string for python should be pp")		
+		uncomment_regex_holder = crp.send("python_uncomment_regex")
+		assert_equal("^(\\s*)\/\/(\\s*)pp", uncomment_regex_holder.regex_interpolation, "keyword for python should be \/\/pp")
+		assert_equal("\\1\\2pp", uncomment_regex_holder.substitution_string_interpolation, "substitution string for python should be pp")
+
+	end
+	
+	#making sure we can use a list of maps
+	def test_list_of_maps
+
+		@stdout_type_maps.each do |type_map|
+			StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(type_map)
+		end
+
+		#our object should now be completely set up
+
+		#php
+		crp = StdOutToggler::StdOutRegex::Producer.new()
+		comment_regex_holder = crp.send("php_comment_regex")	#I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)printout", comment_regex_holder.regex_interpolation, "keyword for php comment should be printout")
+		assert_equal("\\1@@printout", comment_regex_holder.substitution_string_interpolation, "substitution string for php uncomment should be @@printout")
+		uncomment_regex_holder = crp.send("php_uncomment_regex")	#I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)@@(\\s*)printout", uncomment_regex_holder.regex_interpolation, "keyword for php uncomment should be @@printout")
+		assert_equal("\\1\\2printout", uncomment_regex_holder.substitution_string_interpolation, "substitution string for php uncomment should be printout")
+		
+		#python
+		crp = StdOutToggler::StdOutRegex::Producer.new()
+		comment_regex_holder = crp.send("python_comment_regex") #I know what this method is called by examining variables in the test map
+		assert_equal("^(\\s*)pp", comment_regex_holder.regex_interpolation, "keyword for python should be pp")
+		assert_equal("\\1//pp", comment_regex_holder.substitution_string_interpolation, "substitution string for python should be pp")		
+		uncomment_regex_holder = crp.send("python_uncomment_regex")
+		assert_equal("^(\\s*)\/\/(\\s*)pp", uncomment_regex_holder.regex_interpolation, "keyword for python should be \/\/pp")
+		assert_equal("\\1\\2pp", uncomment_regex_holder.substitution_string_interpolation, "substitution string for python should be pp")
+
+	end
+	
+	#we're not testing the API here, just testing (and demonstrating)
+	#the way the stdout classes use regexes to support commenting:
+	#the basic regex we're building dynamically for comment is something such as:
+	#	/^(\s*)puts/
+	#the basic pattern for the substitution string is:
+	#	"\\1#puts"	(preserve spaces, add comment-out string)
+	#we're testing with a variety of spacing patterns
+	def test_comment_regex
+
+		line = "puts"
+		result = line.sub(/^(\s*)puts/,"\\1#puts")
+		assert_equal("#puts", result)
+	
+		line = " puts"	#space
+		result = line.sub(/^(\s*)puts/,"\\1#puts")
+		assert_equal(" #puts", result)
+	
+		line = "	puts"	#tab
+		result = line.sub(/^(\s*)puts/,"\\1#puts")
+		assert_equal("	#puts", result)
+		
+	end
+	
+
+	#we're not testing the API here, just testing (and demonstrating)
+	#the way the stdout classes use regexes to support uncommenting:
+	#the basic regex we're building dynamically for uncomment is something such as:
+	#	/^(\s*)#(\s*)puts/		#because we have to capture spaces after the comment string as well as before
+	#the basic pattern for the substitution string is:
+	#	"\\1\\2puts"	(preserve spaces, add comment-out string)
+	#we're testing with a variety of spacing patterns
+	def test_uncomment_regex
+
+		line = "puts"
+		result = line.sub(/^(\s*)puts/,"\\1#puts")
+		assert_equal("#puts", result)
+	
+		line = " puts"	#space
+		result = line.sub(/^(\s*)puts/,"\\1#puts")
+		assert_equal(" #puts", result)
+	
+		line = "	puts"	#tab
+		result = line.sub(/^(\s*)puts/,"\\1#puts")
+		assert_equal("	#puts", result)
+		
+	end
+	
+	#these are the key tests, which build a stdout class according
+	#to provided data and apply regexes and substitutions from the class
+	#to actual strings
+	
+	def test_comment_using_sample_lines
+		@stdout_type_maps.each do |type_map|
+			StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(type_map)
+		end
+		stdout_regex_producer = StdOutToggler::StdOutRegex::Producer.new()
+
+		#"PHP comment"
+		stdout_regex = stdout_regex_producer.send("php_comment_regex");
+
+		line = "printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("@@printout", result)
+		
+		#test with tab
+		line = "	printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("	@@printout", result)		
+
+		#test with 3 spaces
+		line = "   printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("   @@printout", result)
+		
+		#"python comment"
+		stdout_regex = stdout_regex_producer.send("python_comment_regex");
+		
+		line = "pp"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("//pp", result)
+		
+		#test with tab
+		line = "	pp"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("	//pp", result)		
+
+		#test with 3 spaces
+		line = "   pp"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("   //pp", result)
+		
+		#make sure nothing changes if the lines are already commented out
+		#and I run the comment method
+		stdout_regex = stdout_regex_producer.send("php_comment_regex");
+
+		line = "@@printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("@@printout", result)
+		
+		#test with tab
+		line = "	@@printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("	@@printout", result)		
+
+		#test with 3 spaces
+		line = "   @@printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("   @@printout", result)
+		
+	end
+	
+	def test_uncomment_using_sample_lines
+		@stdout_type_maps.each do |type_map|
+			StdOutToggler::StdOutRegex::Producer.create_methods_for_producing_stdout_regex_strings(type_map)
+		end
+		stdout_regex_producer = StdOutToggler::StdOutRegex::Producer.new()
+
+		#"PHP uncomment"
+		stdout_regex = stdout_regex_producer.send("php_uncomment_regex");
+
+		line = "@@printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("printout", result)
+		
+		#test with tab
+		line = "	@@printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("	printout", result)		
+
+		#test with 3 spaces
+		line = "   @@printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("   printout", result)
+		
+		#"python uncomment"
+		stdout_regex = stdout_regex_producer.send("python_uncomment_regex");
+		
+		line = "//pp"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("pp", result)
+		
+		#test with tab
+		line = "	//pp"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("	pp", result)		
+
+		#test with 3 spaces
+		line = "   //pp"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("   pp", result)
+		
+		#make sure nothing changes if the lines are already uncommented
+		#and I run the uncomment method
+		stdout_regex = stdout_regex_producer.send("php_uncomment_regex");
+
+		line = "printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("printout", result)
+		
+		#test with tab
+		line = "	printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("	printout", result)		
+
+		#test with 3 spaces
+		line = "   printout"
+		result = "#{line.sub(/#{stdout_regex.regex_interpolation}/, "#{stdout_regex.substitution_string_interpolation}")}"
+		assert_equal("   printout", result)
+		
+	end
+	
+end

data/test/test_types_validator.rb

@@ -0,0 +1,149 @@
+#!usr/bin/env ruby
+
+require 'test/unit'
+require 'stdouttoggler/types_validator.rb'
+
+class StdOutRegexTest < Test::Unit::TestCase
+
+	#config maps for testing
+	#(these aren't real php and python characteristics, just using made up ones for testing)
+	def setup
+		@stdout_type_maps = []
+		@stdout_type_maps[0] = {:type => "PHP", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		@stdout_type_maps[1] = {:type => "Python", :extension => ".py", :keyword => "pp", :comment_string => "//", :comment_string_escaped => "\/\/"}	
+	end
+	
+	def teardown
+		@stdout_type_maps = []
+	end
+
+	def test_valid_extensions
+		crp = StdOutToggler::TypesValidator.new(@stdout_type_maps)
+		assert(crp.respond_to? "valid_extension?")
+		assert(crp.valid_extension?(".php"))
+		assert(crp.valid_extension?(".py"))
+	end
+
+	def test_valid_type_maps
+		assert(StdOutToggler::TypesValidator.new(@stdout_type_maps).valid_type_maps?())
+	end
+
+	def test_invalid_type_map_missing_type
+	
+		#nil
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("the type map with the extension .php is missing a type", exception.message)
+
+		#empty
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("the type map with the extension .php is missing a type", exception.message)
+		
+		#make sure we get the index right
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("the type map with the extension .php is missing a type", exception.message)
+		
+	end
+	
+	def test_invalid_type_map_missing_keyword
+
+		#nil
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The type map for type whatever2 is either missing a keyword or has an invalid keyword", exception.message)
+		
+		#empty
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The type map for type whatever1 is either missing a keyword or has an invalid keyword", exception.message)
+		
+	end
+	
+	def test_invalid_type_map_missing_extension
+
+		#nil
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The type map for type whatever2 is either missing a comment string or has an invalid comment string. One solution may be to put quotation marks around the string.", exception.message)
+		
+		#empty
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "printout", :comment_string => "", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The type map for type whatever1 is either missing a comment string or has an invalid comment string. One solution may be to put quotation marks around the string.", exception.message)
+		
+	end
+	
+	def test_invalid_type_map_invalid_extension
+
+		#no dot
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => "php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The extension for whatever2 must be of the form .<ext>", exception.message)
+		
+		#nothing after dot
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The extension for whatever1 must be of the form .<ext>", exception.message)
+
+		#invalid characters
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".&&&", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The extension for whatever1 must be of the form .<ext>", exception.message)
+		
+	end
+	
+
+	def test_invalid_type_map_missing_comment_string
+
+		#nil
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The type map for type whatever2 is either missing a comment string or has an invalid comment string. One solution may be to put quotation marks around the string.", exception.message)
+		
+		#empty
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "printout", :comment_string => "", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The type map for type whatever1 is either missing a comment string or has an invalid comment string. One solution may be to put quotation marks around the string.", exception.message)
+		
+	end
+
+	def test_invalid_type_map_missing_comment_string_escaped
+
+		#nil
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The type map for type whatever2 is either missing an escaped comment string or has an invalid escaped comment string. One solution may be to put quotation marks around the string.", exception.message)
+		
+		#empty
+		stdout_type_maps_with_typeless_map = []
+		stdout_type_maps_with_typeless_map[0] = {:type => "whatever1", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => ""}
+		stdout_type_maps_with_typeless_map[1] = {:type => "whatever2", :extension => ".php", :keyword => "printout", :comment_string => "@@", :comment_string_escaped => "@@"}
+		exception = assert_raise(RuntimeError) {StdOutToggler::TypesValidator.new(stdout_type_maps_with_typeless_map).valid_type_maps?()}
+		assert_equal("The type map for type whatever1 is either missing an escaped comment string or has an invalid escaped comment string. One solution may be to put quotation marks around the string.", exception.message)
+		
+	end
+	
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: stdouttoggler
+version: !ruby/object:Gem::Version
+  version: 0.5.0.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Mark Buechler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-14 00:00:00.000000000 Z
+dependencies: []
+description: As a debugging convenience, sdtouttoggler comments and uncomments output
+  lines, such as alert in javascript
+email: 
+executables:
+- toggle
+extensions: []
+extra_rdoc_files: []
+files:
+- stdouttoggler.gemspec
+- Rakefile
+- README.txt
+- lib/stdouttoggler/application.rb
+- lib/stdouttoggler/file_writer.rb
+- lib/stdouttoggler/regex/stdout_regex.rb
+- lib/stdouttoggler/types.rb
+- lib/stdouttoggler/types_validator.rb
+- lib/stdouttoggler.rb
+- test/test_file_writer.rb
+- test/test_std_out_regex.rb
+- test/test_types_validator.rb
+- examples/additional_types.yaml
+- examples/file_names.yaml
+- bin/toggle
+homepage: http://rubygems.org/stdouttoggler
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Comments and uncomments output lines in code
+test_files: []