file_editor 0.5

data/README.txt

@@ -0,0 +1,57 @@
+File Editor makes it easy to edit a file in place. Just send it a file name and a short block with some instructions, and it will perform string substitution as indicated in the block
+
+===Using File Editor
+
+Your program block can use File Editor in two modes, with or without an explicit receiver:
+
+ FileEditor.edit('test.txt') do |editor|
+   editor.regex = /java/i
+   editor.substitution_string = 'ruby'
+   editor.run
+ end
+
+OR
+
+ FileEditor.edit('test.txt') do
+   @regex = /java/i
+   @substitution_string = 'ruby'
+   run
+ end
+
+The first version does not use instance_eval internally and is therefore able to use variables in the program's local scope. The second version does use instance_eval internally.
+
+Here are some examples, alternating between approaches:
+
+====Standard substitution. File editor will do a line-by-line gsub on the given file
+
+ FileEditor.edit('test.txt') do |editor|
+   editor.regex = /java/i
+   editor.substitution_string = 'ruby'
+   editor.run
+ end
+
+====Setting global to false triggers the use of sub instead of gsub (in effect replacing only the first match on each line)
+
+ FileEditor.edit('test.txt') do
+   @regex = /java/i
+   @substitution_string = 'ruby'
+   @global = false
+   run
+ end
+
+====Setting keep_backup = true ensures that you'll have a backup of your original file
+
+ FileEditor.edit('test.txt') do |editor|
+   editor.regex = /java/i
+   editor.substitution_string = 'ruby'
+   editor.keep_backup = true
+   editor.run
+ end
+
+====If you pass in a multiline regex, FileEditor will detect it, read the entire file into a string, and match across new lines
+
+ FileEditor.edit('test.txt') do
+   @regex = /ja.*?va/mi
+   @substitution_string = 'ruby'
+   run
+ end

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+	t.libs << 'test'
+end
+
+task :default => [:test]

data/file_editor.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+	s.name="file_editor"
+	s.version="0.5"
+	s.platform=Gem::Platform::RUBY
+	s.date="2013-02-14"
+	s.summary="Edit a file in place"
+	s.description="File editor makes it easy to edit a file in place, with options for saving a backup"
+	s.author="Mark Buechler"
+	s.files=Dir["file_editor.gemspec", "Rakefile", "README.txt", "lib/**/*", "test/test*.rb"]
+	s.homepage="http://rubygems.org/sqlfinder"
+	s.require_paths=["lib"]
+	s.has_rdoc=true
+	s.extra_rdoc_files=["README.txt"]
+	s.rdoc_options=["--main", "README.txt"]
+end

data/lib/file_editor.rb

@@ -0,0 +1,84 @@
+class FileEditor
+
+	attr_accessor :file_name, :regex, :substitution_string, :keep_backup, :global
+
+	def initialize(file_name)
+		@file_name = file_name
+		@keep_backup = false
+		@global = true #this will yield the equivalent of gsub instead of sub
+	end
+
+	#You can send an explicit receiver as an argument to this block
+	#and set variables on it (useful inside another object where you need to access its
+	#own methods inside the block), or simply set variables without an explicit receiver.
+	#Either way, the block must call the run method. See Ruby Best Practices by Gregory Brown, p. 63-64,
+	#for elaboration of this approach
+	def self.edit(file_name, &b)
+		editor = FileEditor.new(file_name)
+		b.arity == 0 ? editor.instance_eval(&b) : b.call(editor)
+	end
+	
+	#runs file editor
+	def run
+		raise "You need to provide a regular expression to the editor" unless @regex
+		raise "You need to provide a substitution string" unless @substitution_string
+		raise "The file #{@file_name} does not exist" unless File.exist?(@file_name)
+		raise "The path #{@file_name} does not point to a file" unless File.file?(@file_name)
+		raise "You do not have permission to read #{@file_name}" unless File.readable?(@file_name)
+		raise "You do not have permission to edit #{@file_name}" unless File.writable?(@file_name)
+		begin
+			if @keep_backup
+				temp_file_name = @file_name + ".backup"
+				File.delete(temp_file_name) if File.exist?(temp_file_name)
+			else
+				temp_file_name = @file_name + "." + get_random_extension
+			end
+			File.rename(@file_name, temp_file_name)
+			read_handle = File.new(temp_file_name, "r")
+			write_handle = File.new(@file_name, "w")
+			write_to_file(read_handle, write_handle)
+		ensure
+			read_handle.close if read_handle
+			write_handle.close if write_handle
+			File.delete(temp_file_name) unless @keep_backup
+		end
+	end
+	
+	#testable write method, using io handles as arguments
+	#to enable the use of String.IO in testing
+	def write_to_file(read_handle, write_handle)
+		if is_multiline(@regex.to_s) 
+			file_string = read_handle.read #no sense doing a line-by-line multiline
+			if (@global)
+				write_handle.puts(file_string.gsub(@regex, @substitution_string))
+			else
+				write_handle.puts(file_string.sub(@regex, @substitution_string))
+			end
+		else
+			if (@global)
+				read_handle.each do |line|
+					write_handle.puts (line.gsub(@regex, @substitution_string))
+				end
+			else
+				read_handle.each do |line|
+					write_handle.puts (line.sub(@regex, @substitution_string))
+				end		
+			end
+		end
+	end
+	
+	#Determines if a string derived from regexp.to_s
+	#represents a regular expression with the multiline option turned on
+	def is_multiline(regex_string)
+		regex_string.match(/\?.*?m.*?-/) || regex_string.match(/\?[^-]+:/)
+	end
+	
+	#returns a random 6-letter extension (e.g., 'kjeihl');
+	#this ensures that we don't inadvertantly delete a pre-existing
+	#backup file if we're not saving the backup
+	def get_random_extension
+		('a'..'z').to_a.shuffle.slice(0..5).join
+	end
+	
+end
+

data/test/test_file_editor.rb

@@ -0,0 +1,469 @@
+#ruby -Ilib -I. test/test_file_editor.rb
+
+require 'test/unit'
+require 'file_editor'
+require 'stringio'
+
+#NOTE: these tests are not examples of how to use FileEditor in code;
+#the gem was designed with a separate method for the actual IO operations,
+#precisely so it could be tested without recourse to external files,
+#using StringIO
+#See README.txt for actual code examples
+
+class FileEditorTest < Test::Unit::TestCase
+
+def setup
+@original = %q[
+I like java and java likes me.
+Java is a great language
+
+Vote for ja
+va.
+
+]
+end
+
+#NO OPTIONS
+
+#defaults to global, don't ignore case
+def test_no_options_without_explicit_receiver
+expected = %q[
+I like ruby and ruby likes me.
+Java is a great language
+
+Vote for ja
+va.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do
+	@regex = /java/
+	@substitution_string = "ruby"
+	write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+def test_no_options_with_explicit_receiver
+expected = %q[
+I like ruby and ruby likes me.
+Java is a great language
+
+Vote for ja
+va.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do |editor|
+	editor.regex = /java/
+	editor.substitution_string = "ruby"
+	editor.write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+#IGNORE CASE
+
+def test_ignore_case_without_explicit_receiver
+expected = %q[
+I like ruby and ruby likes me.
+ruby is a great language
+
+Vote for ja
+va.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do
+	@regex = /java/i
+	@substitution_string = "ruby"
+	write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+def test_ignore_case_with_explicit_receiver
+expected = %q[
+I like ruby and ruby likes me.
+ruby is a great language
+
+Vote for ja
+va.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do |editor|
+	editor.regex = /java/i
+	editor.substitution_string = "ruby"
+	editor.write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+#IGNORE CASE AND GLOBAL SUBSTITUTION
+
+def test_ignore_case_and_global_false_without_explicit_receiver
+expected = %q[
+I like ruby and java likes me.
+ruby is a great language
+
+Vote for ja
+va.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do
+	@regex = /java/i
+	@substitution_string = "ruby"
+	@global = false
+	write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+def test_ignore_case_and_global_substitution_with_explicit_receiver
+expected = %q[
+I like ruby and java likes me.
+ruby is a great language
+
+Vote for ja
+va.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do |editor|
+	editor.regex = /java/i
+	editor.substitution_string = "ruby"
+	editor.global = false
+	editor.write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+#MULTILINE (can't imagine doing this with global set to false, but we test that option anyway)
+
+def test_multiline_and_global_without_explicit_receiver
+expected = %q[
+I like ruby and ruby likes me.
+ruby is a great language
+
+Vote for ruby.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do
+	@regex = /ja.*?va/mi
+	@substitution_string = "ruby"
+	write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+def test_multiline_and_not_global_without_explicit_receiver
+expected = %q[
+I like ruby and java likes me.
+Java is a great language
+
+Vote for ja
+va.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do
+	@regex = /ja.*?va/mi
+	@substitution_string = "ruby"
+	@global = false
+	write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+def test_multiline_global_with_explicit_receiver
+expected = %q[
+I like ruby and ruby likes me.
+Java is a great language
+
+Vote for ruby.
+
+]
+read_handle = StringIO.new(@original)
+write_handle = StringIO.new("")
+FileEditor.edit("dummy.txt") do |editor|
+	editor.regex = /ja.*?va/m
+	editor.substitution_string = "ruby"
+	editor.write_to_file(read_handle, write_handle)
+end
+read_handle.close()
+write_handle.close()
+assert_equal(expected, write_handle.string)
+
+end
+
+	def test_no_regex
+		non_existent_file = 'no_file.txt'
+		e = assert_raise(RuntimeError) do
+			FileEditor.edit("#{non_existent_file}") do
+				#@regex = /a/
+				@substitution_string = 'b'
+				run
+			end		
+		end
+		assert_equal("You need to provide a regular expression to the editor", e.message)
+	end
+
+	def test_no_substitution_string
+		non_existent_file = 'no_file.txt'
+		e = assert_raise(RuntimeError) do
+			FileEditor.edit("#{non_existent_file}") do
+				@regex = /a/
+				#@substitution_string = 'b'
+				run
+			end		
+		end
+		assert_equal("You need to provide a substitution string", e.message)
+	end
+
+	def test_file_not_found
+		non_existent_file = 'no_file.txt'
+		e = assert_raise(RuntimeError) do
+			FileEditor.edit("#{non_existent_file}") do
+				@regex = /a/
+				@substitution_string = 'b'
+				run
+			end		
+		end
+		assert_equal("The file #{non_existent_file} does not exist", e.message)
+	end
+	
+	def test_not_a_file
+		path_to_dir = 'lib'
+		e = assert_raise(RuntimeError) do
+			FileEditor.edit("#{path_to_dir}") do
+				@regex = /a/
+				@substitution_string = 'b'
+				run
+			end		
+		end
+		assert_equal("The path #{path_to_dir} does not point to a file", e.message)
+	end
+	
+#THE FOLLOWING TESTS DO NOT TEST THE APPLICATION;
+#THEY WERE AD HOC TEST TO DETERMINE HOW MULTILINE REGEXES WORK, AMONG OTHER THINGS
+
+	def test_is_multiline
+	
+		editor = FileEditor.new("dummy.txt")
+	
+		#these should not match
+		ignore = /anything/i.to_s 					#(?i-mx:anything)
+		extended =  /anything/x.to_s 				#(?x-mi:anything)
+		ignore_plus_extended = /anything/ix.to_s 	#(?ix-m:anything)
+		
+		not_multi = [ignore, extended, ignore_plus_extended]
+		not_multi.each do |r|
+			assert(!editor.is_multiline(r))
+		end
+		
+		#these should match
+		multi = /anything/m.to_s #(?m-ix:anything)
+		multi_plus_ignore = /anything/mi.to_s #(?mi-x:anything)
+		multi_plus_extended = /anything/mx.to_s #(?mx-i:anything)
+		
+		#special case that should match
+		all = /anything/mix.to_s #(?mix:anything)
+		
+		is_multi = [multi, multi_plus_ignore, multi_plus_extended, all]
+		is_multi.each do |r|
+			assert(editor.is_multiline(r))
+		end
+		
+	end
+
+	#second test is for special case of all: if there's no hyphen, the we know all options are included
+	def is_multiline(regex_string)
+		regex_string.match(/\?.*?m.*?-/) || regex_string.match(/\?[^-]+:/)
+	end
+
+	def test_regex_object_and_modifiers
+		r = Regexp.new("ell", Regexp::IGNORECASE)
+		#puts "ignore case: #{r.to_s}"
+		assert_equal(1, r.options)
+		
+		r = Regexp.new("ell", Regexp::EXTENDED)
+		#puts "extended: #{r.to_s}"
+		assert_equal(2, r.options)
+		
+		r = Regexp.new("ell", Regexp::MULTILINE)
+		#puts "MULTILINE: #{r.to_s}"
+		assert_equal(4, r.options)
+		
+		r = Regexp.new("ell", (Regexp::EXTENDED | Regexp::IGNORECASE))
+		#puts "EXTENDED AND IGNORE: #{r.to_s}"
+		assert_equal(3, r.options)
+
+		r = Regexp.new("ell", (Regexp::MULTILINE | Regexp::IGNORECASE))
+		#puts "MULTILINE AND IGNORE: #{r.to_s}"
+		assert_equal(5, r.options)
+
+		r = Regexp.new("ell", (Regexp::MULTILINE | Regexp::EXTENDED))
+		#puts "MULTILINE AND EXTENDED: #{r.to_s}"
+		assert_equal(6, r.options)
+		
+		r = Regexp.new("ell", (Regexp::EXTENDED | Regexp::IGNORECASE | Regexp::MULTILINE))
+		#puts "all three: #{r.to_s}"
+		assert_equal(7, r.options)
+	
+		#puts
+		
+		ops_orred = [Regexp::IGNORECASE, Regexp::EXTENDED].reduce{|a,b| a|b }
+		assert_equal(3, ops_orred) #0001 | 0010 => 0011
+		
+		ops_orred = [Regexp::IGNORECASE, Regexp::MULTILINE].reduce{|a,b| a|b }
+		assert_equal(5, ops_orred) #0001 | 0100 => 0101
+
+		ops_orred = [Regexp::IGNORECASE, Regexp::EXTENDED, Regexp::MULTILINE].reduce{|a,b| a|b }
+		assert_equal(7, ops_orred) #0001 | 0010 | 0100 => 0111
+	end
+	
+def test_multiline
+#note we have to use non-greedy quantifiers (probably always with multiline, or results could be way unexpected)
+multiline_string = %q[
+You are fine.
+I like you.
+Y
+ou are weird.
+]
+expected_multiline_string = %q[
+yous are fine.
+I like yous.
+yous are weird.
+]
+edited_multiline_string = multiline_string.gsub(/y.*?ou/im, 'yous');
+assert_equal(expected_multiline_string, edited_multiline_string)
+	
+m = "you".match (/y.*ou/)
+assert m
+m = "you".match (/y.*ou/m)
+assert m
+m = "y\nou".match (/y.*ou/m)
+assert m
+s = %q[
+y
+ou
+]
+m = s.match (/y.*ou/m)
+assert m
+
+result = "you".gsub(/y.*ou/m, 'Z')
+assert_equal('Z', result)
+
+#shows one of the tricks that greedy interpretations will play on multiline searches
+test = %q[
+you
+y
+ou
+]
+expected = 
+%q[
+Z
+]
+result = test.gsub(/y.*ou/m, 'Z')
+assert_equal(expected, result)
+#note that we end up with one replacement instead of two, 
+#because the greedy interpretation matches the first y and then the last ou
+
+#here's what we probably intended
+test = %q[
+you
+y
+ou
+]
+expected = 
+%q[
+Z
+Z
+]
+result = test.gsub(/y.*?ou/m, 'Z')
+assert_equal(expected, result)
+
+
+end
+	
+end
+
+
+=begin
+
+	#TEMP
+	def test_ell
+		FileEditor.new("test.txt") do |editor|
+			editor.regex = /ell/i
+			editor.substitution_string = "ojj"
+			editor.keep_backup = false
+			editor.run
+		end
+	end
+
+	def test_ojj
+		FileEditor.new("test.txt") do |editor|
+			editor.regex = /ojj/i
+			editor.substitution_string = "ell"
+			editor.keep_backup = false
+			editor.run
+		end
+	end
+
+	#this feels like proper course going forward,
+	#pending the problem with including it in another class
+	def test_ell_with_instance_eval
+		FileEditor.edit("test.txt") do 
+			@regex = /ell/i
+			@substitution_string = "ojj"
+			@keep_backup = false
+		end
+	end
+
+
+	def test_regex
+		s = "heLlo"
+		r = Regexp.new("ell", Regexp::IGNORECASE)
+		#r = Regexp.new(/ell/ix)
+		puts "r.to_s: #{r.to_s}"
+		puts "r.options: #{r.options}"
+		result = s.sub(r, "ojj")
+		puts "result: #{result}"
+	end
+	
+=end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: file_editor
+version: !ruby/object:Gem::Version
+  version: '0.5'
+  prerelease: 
+platform: ruby
+authors:
+- Mark Buechler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-14 00:00:00.000000000 Z
+dependencies: []
+description: File editor makes it easy to edit a file in place, with options for saving
+  a backup
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.txt
+files:
+- file_editor.gemspec
+- Rakefile
+- README.txt
+- lib/file_editor.rb
+- test/test_file_editor.rb
+homepage: http://rubygems.org/sqlfinder
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.txt
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Edit a file in place
+test_files: []