my_obfuscate 0.3.0 → 0.3.7

data/lib/my_obfuscate/mysql.rb

@@ -0,0 +1,91 @@
+class MyObfuscate
+  class Mysql
+    INSERT_REGEX = /^\s*INSERT INTO `(.*?)` \((.*?)\) VALUES\s*/i
+
+    def parse_insert_statement(line)
+      if regex_match = INSERT_REGEX.match(line)
+        {
+            :table_name => regex_match[1].to_sym,
+            :column_names => regex_match[2].split(/`\s*,\s*`/).map { |col| col.gsub('`', "").to_sym }
+        }
+      end
+    end
+
+    def rows_to_be_inserted(line)
+      line = line.gsub(INSERT_REGEX, '').gsub(/\s*;\s*$/, '')
+      context_aware_mysql_string_split(line)
+    end
+
+    def make_valid_value_string(value)
+      if value.nil?
+        "NULL"
+      elsif value =~ /^0x[0-9a-fA-F]+$/
+        value
+      else
+        "'" + value + "'"
+      end
+    end
+
+    def make_insert_statement(table_name, column_names, values_strings)
+      "INSERT INTO `#{table_name}` (`#{column_names.join('`, `')}`) VALUES #{values_strings};"
+    end
+
+    private
+
+    # Be aware, strings must be quoted in single quotes!
+    def context_aware_mysql_string_split(string)
+      in_sub_insert = false
+      in_quoted_string = false
+      escaped = false
+      current_field = nil
+      length = string.length
+      fields = []
+      output = []
+
+      string.each_char do |i|
+        if escaped
+          escaped = false
+          current_field ||= ""
+          current_field << i
+        else
+          if i == "\\"
+            escaped = true
+            current_field ||= ""
+            current_field << i
+          elsif i == "(" && !in_quoted_string && !in_sub_insert
+            in_sub_insert = true
+          elsif i == ")" && !in_quoted_string && in_sub_insert
+            fields << current_field unless current_field.nil?
+            output << fields unless fields.length == 0
+            in_sub_insert = false
+            fields = []
+            current_field = nil
+          elsif i == "'" && !in_quoted_string
+            fields << current_field unless current_field.nil?
+            current_field = ''
+            in_quoted_string = true
+          elsif i == "'" && in_quoted_string
+            fields << current_field unless current_field.nil?
+            current_field = nil
+            in_quoted_string = false
+          elsif i == "," && !in_quoted_string && in_sub_insert
+            fields << current_field unless current_field.nil?
+            current_field = nil
+          elsif i == "L" && !in_quoted_string && in_sub_insert && current_field == "NUL"
+            current_field = nil
+            fields << current_field
+          elsif (i == " " || i == "\t") && !in_quoted_string
+            # Don't add whitespace not in a string
+          elsif in_sub_insert
+            current_field ||= ""
+            current_field << i
+          end
+        end
+      end
+
+      fields << current_field unless current_field.nil?
+      output << fields unless fields.length == 0
+      output
+    end
+  end
+end

data/lib/my_obfuscate/sql_server.rb

@@ -0,0 +1,81 @@
+class MyObfuscate
+  class SqlServer
+    INSERT_REGEX = /^\s*INSERT (?:INTO )?\[dbo\]\.\[(.*?)\] \((.*?)\) VALUES\s*/i
+
+    def parse_insert_statement(line)
+      if regex_match = INSERT_REGEX.match(line)
+        {
+            :table_name => regex_match[1].to_sym,
+            :column_names => regex_match[2].split(/\]\s*,\s*\[/).map { |col| col.gsub(/[\[\]]/, "").to_sym }
+        }
+      end
+    end
+
+    def rows_to_be_inserted(line)
+      line = line.gsub(INSERT_REGEX, '').gsub(/\s*;?\s*$/, '').gsub(/^\(/, '').gsub(/\)$/, '')
+      context_aware_sql_server_string_split(line)
+    end
+
+    def make_valid_value_string(value)
+      if value.nil?
+        "NULL"
+      elsif value.match(/^[A-Z]+\(.*?\)$/)
+        value
+      else
+        "N'#{value}'"
+      end
+    end
+
+    def make_insert_statement(table_name, column_names, values_strings)
+      "INSERT [dbo].[#{table_name}] ([#{column_names.join("], [")}]) VALUES #{values_strings};"
+    end
+
+    private
+
+    def context_aware_sql_server_string_split(string)
+      in_quoted_string = false
+      backslash_escape = false
+      previous_char_single_quote = false
+      current_field_value = nil
+      completed_fields = []
+
+      string.each_char do |char|
+        if char == "'" && !in_quoted_string
+          if current_field_value != "N"
+            completed_fields << current_field_value unless current_field_value.nil?
+          end
+          current_field_value = ""
+          in_quoted_string = true
+        elsif previous_char_single_quote
+          previous_char_single_quote = false
+          if char == "'"
+            current_field_value << "''"
+          else
+            completed_fields << current_field_value unless current_field_value.nil?
+            in_quoted_string = false
+            current_field_value = nil
+          end
+        elsif char == "'" && in_quoted_string
+          previous_char_single_quote = true
+        elsif char == "," && !in_quoted_string
+          completed_fields << current_field_value unless current_field_value.nil?
+          current_field_value = nil
+        elsif char == "L" && !in_quoted_string && current_field_value == "NUL"
+          current_field_value = nil
+          completed_fields << current_field_value
+        elsif (char == " " || char == "\t") && !in_quoted_string
+          if !current_field_value.nil? && current_field_value.start_with?("CAST(")
+            current_field_value << char
+          end
+          # Don't add whitespace not in a string
+        else
+          current_field_value ||= ""
+          current_field_value << char
+        end
+      end
+
+      completed_fields << current_field_value unless current_field_value.nil?
+      [completed_fields]
+    end
+  end
+end

data/lib/my_obfuscate/version.rb

@@ -0,0 +1,3 @@
+class MyObfuscate
+  VERSION = "0.3.7"
+end

data/my_obfuscate.gemspec

@@ -1,54 +1,22 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "my_obfuscate/version"
 
 Gem::Specification.new do |s|
   s.name = %q{my_obfuscate}
-  s.version = "0.3.0"
+  s.version = MyObfuscate::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Andrew Cantino", "Dave Willett", "Mike Grafton", "Mason Glaves"]
-  s.date = %q{2009-10-09}
+  s.authors = ["Andrew Cantino", "Dave Willett", "Mike Grafton", "Mason Glaves", "Greg Bell", "Mavenlink"]
   s.description = %q{Standalone Ruby code for the selective rewriting of MySQL dumps in order to protect user privacy.}
-  s.email = %q{andrew@pivotallabs.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/my_obfuscate.rb",
-     "my_obfuscate.gemspec",
-     "spec/my_obfuscate_spec.rb",
-     "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/honkster/myobfuscate}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{my-obfuscate}
-  s.rubygems_version = %q{1.3.5}
+  s.email = %q{andrew@iterationlabs.com}
+  s.homepage = %q{http://github.com/iterationlabs/my_obfuscate}
   s.summary = %q{Standalone Ruby code for the selective rewriting of MySQL dumps in order to protect user privacy.}
-  s.test_files = [
-    "spec/my_obfuscate_spec.rb",
-     "spec/spec_helper.rb"
-  ]
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.add_development_dependency "rspec"
+  s.add_dependency "faker", ">= 1.0.1"
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-    else
-      s.add_dependency(%q<rspec>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rspec>, [">= 0"])
-  end
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
 end

data/spec/my_obfuscate_spec.rb

@@ -1,51 +1,19 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 describe MyObfuscate do
-  describe "MyObfuscate.context_aware_mysql_string_split" do
-    it "should split a mysql string into fields" do
-      string = "('bob@bob.com','bob', 'somethingelse1', 25, '2', 10,    'hi')"
-      fields = [['bob@bob.com', 'bob', 'somethingelse1', '25', '2', '10', "hi"]]
-      MyObfuscate.context_aware_mysql_string_split(string).should == fields
-    end
-
-    it "should work ok with escaped characters" do
-      string = "('bob,@bob.c  , om', 'bo\\', b', 'some\"thin\\gel\\\\\\'se1', 25, '2', 10,    'hi', 5)"
-      fields = [['bob,@bob.c  , om', 'bo\\\', b', 'some"thin\\gel\\\\\\\'se1', '25', '2', '10', "hi", "5"]]
-      MyObfuscate.context_aware_mysql_string_split(string).should == fields
-    end
-
-    it "should work with multiple subinserts" do
-      string = "(1,2,3, '((m))(oo()s,e'), ('bob,@bob.c  , om', 'bo\\', b', 'some\"thin\\gel\\\\\\'se1', 25, '2', 10,    'hi', 5)"
-      fields = [["1", "2", "3", "((m))(oo()s,e"], ['bob,@bob.c  , om', 'bo\\\', b', 'some"thin\\gel\\\\\\\'se1', '25', '2', '10', "hi", "5"]]
-      MyObfuscate.context_aware_mysql_string_split(string).should == fields
-    end
-
-    it "should work ok with NULL values" do
-      string = "(NULL    , 'bob@bob.com','bob', NULL, 25, '2', NULL,    'hi', NULL  )"
-      fields = [[nil, 'bob@bob.com', 'bob', nil, '25', '2', nil, "hi", nil]]
-      MyObfuscate.context_aware_mysql_string_split(string).should == fields
-    end
-
-    it "should work with empty strings" do
-      string = "(NULL    , '', ''      , '', 25, '2','',    'hi','')"
-      fields = [[nil, '', '', '', '25', '2', '', "hi", '']]
-      MyObfuscate.context_aware_mysql_string_split(string).should == fields
-    end
-  end
-
-  describe "MyObfuscate.reasembling_each_insert" do
+  describe "MyObfuscate.reassembling_each_insert" do
     before do
       @column_names = [:a, :b, :c, :d]
       @test_insert = "INSERT INTO `some_table` (`a`, `b`, `c`, `d`) VALUES ('(\\'bob@bob.com','b()ob','some(thingelse1','25)('),('joe@joe.com','joe','somethingelse2','54');"
       @test_insert_passes = [
-        ["(\\'bob@bob.com","b()ob", "some(thingelse1", "25)("],
-        ["joe@joe.com","joe", "somethingelse2", "54"]
+          ["(\\'bob@bob.com", "b()ob", "some(thingelse1", "25)("],
+          ["joe@joe.com", "joe", "somethingelse2", "54"]
       ]
     end
 
     it "should yield each subinsert and reassemble the result" do
       count = 0
-      reassembled = MyObfuscate.reasembling_each_insert(@test_insert, "some_table", @column_names) do |sub_insert|
+      reassembled = MyObfuscate.new.reassembling_each_insert(@test_insert, "some_table", @column_names) do |sub_insert|
         sub_insert.should == @test_insert_passes.shift
         count += 1
         sub_insert
@@ -57,13 +25,13 @@ describe MyObfuscate do
 
   describe "MyObfuscate.apply_table_config" do
     it "should work on email addresses" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else"], { :a => { :type => :email }}, [:a, :b])
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else"], {:a => {:type => :email}}, [:a, :b])
       new_row.length.should == 2
-      new_row.first.should =~ /^\w+\@\w+\.\w+$/
+      new_row.first.should =~ /^[\w\.]+\@\w+\.\w+$/
     end
 
     it "should work on strings" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "something crazy"], { :b => { :type => :string, :length => 7 }}, [:a, :b, :c])
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "something crazy"], {:b => {:type => :string, :length => 7}}, [:a, :b, :c])
       new_row.length.should == 3
       new_row[1].length.should == 7
       new_row[1].should_not == "something_else"
@@ -71,67 +39,95 @@ describe MyObfuscate do
 
     describe "conditional directives" do
       it "should honor :unless conditionals" do
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a=> { :type => :fixed, :string => "123", :unless => lambda {|row| row[:a] == "blah"} }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :unless => lambda { |row| row[:a] == "blah" }}}, [:a, :b, :c])
         new_row[0].should_not == "123"
         new_row[0].should == "blah"
 
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a=> { :type => :fixed, :string => "123", :unless => lambda {|row| row[:a] == "not blah"} }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :unless => lambda { |row| row[:a] == "not blah" }}}, [:a, :b, :c])
         new_row[0].should == "123"
+
+        new_row = MyObfuscate.apply_table_config([nil, "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :unless => :nil}, :b=> {:type => :fixed, :string => "123", :unless => :nil}}, [:a, :b, :c])
+        new_row[0].should == nil
+        new_row[1].should == "123"
+
+        new_row = MyObfuscate.apply_table_config(['', "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :unless => :blank}, :b=> {:type => :fixed, :string => "123", :unless => :blank}}, [:a, :b, :c])
+        new_row[0].should == ''
+        new_row[1].should == "123"
       end
 
       it "should honor :if conditionals" do
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a=> { :type => :fixed, :string => "123", :if => lambda {|row| row[:a] == "blah"} }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "blah" }}}, [:a, :b, :c])
         new_row[0].should == "123"
 
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a=> { :type => :fixed, :string => "123", :if=> lambda {|row| row[:a] == "not blah"} }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if=> lambda { |row| row[:a] == "not blah" }}}, [:a, :b, :c])
         new_row[0].should_not == "123"
         new_row[0].should == "blah"
+
+        new_row = MyObfuscate.apply_table_config([nil, "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => :nil}, :b=> {:type => :fixed, :string => "123", :if => :nil}}, [:a, :b, :c])
+        new_row[0].should == "123"
+        new_row[1].should == "something_else"
+
+        new_row = MyObfuscate.apply_table_config(['', "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => :blank}, :b=> {:type => :fixed, :string => "123", :if => :blank}}, [:a, :b, :c])
+        new_row[0].should == "123"
+        new_row[1].should == "something_else"
       end
 
       it "should supply the original row values to the conditional" do
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else"], { :a => { :type => :fixed, :string => "123" }, :b => { :type => :fixed, :string => "yup", :if => lambda {|row| row[:a] == "blah"}}}, [:a, :b])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else"], {:a => {:type => :fixed, :string => "123"}, :b => {:type => :fixed, :string => "yup", :if => lambda { |row| row[:a] == "blah" }}}, [:a, :b])
         new_row[0].should == "123"
         new_row[1].should == "yup"
       end
 
       it "should honor combined :unless and :if conditionals" do
         #both true
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a=> { :type => :fixed, :string => "123", :if => lambda {|row| row[:a] == "blah"}, :unless =>  lambda {|row| row[:b] == "something_else"} }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "blah" }, :unless => lambda { |row| row[:b] == "something_else" }}}, [:a, :b, :c])
         new_row[0].should == "blah"
 
         #both false
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a=> { :type => :fixed, :string => "123", :if => lambda {|row| row[:a] == "not blah"}, :unless =>  lambda {|row| row[:b] == "not something_else"} }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "not blah" }, :unless => lambda { |row| row[:b] == "not something_else" }}}, [:a, :b, :c])
         new_row[0].should == "blah"
 
         #if true, #unless false
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a=> { :type => :fixed, :string => "123", :if => lambda {|row| row[:a] == "blah"}, :unless =>  lambda {|row| row[:b] == "not something_else"} }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "blah" }, :unless => lambda { |row| row[:b] == "not something_else" }}}, [:a, :b, :c])
         new_row[0].should == "123"
 
         #if false, #unless true
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a=> { :type => :fixed, :string => "123", :if => lambda {|row| row[:a] == "not blah"}, :unless =>  lambda {|row| row[:b] == "something_else"} }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a=> {:type => :fixed, :string => "123", :if => lambda { |row| row[:a] == "not blah" }, :unless => lambda { |row| row[:b] == "something_else" }}}, [:a, :b, :c])
         new_row[0].should == "blah"
       end
     end
 
     it "should be able to generate random integers in ranges" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :c => { :type => :integer, :between => 10..100 }}, [:a, :b, :c])
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:c => {:type => :integer, :between => 10..100}}, [:a, :b, :c])
       new_row.length.should == 3
       new_row[2].to_i.to_s.should == new_row[2] # It should be an integer.
       new_row[2].should_not == "5"
     end
 
     it "should be able to substitute fixed strings" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :b => { :type => :fixed, :string => "hello" }}, [:a, :b, :c])
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :fixed, :string => "hello"}}, [:a, :b, :c])
       new_row.length.should == 3
       new_row[1].should == "hello"
     end
 
+    it "should be able to substitute a proc that returns a string" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :fixed, :string => proc { "Hello World" }}}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[1].should == "Hello World"
+    end
+
+    it "should provide the row to the proc" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :fixed, :string => proc { |a| a[:b] }}}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[1].should == "something_else"
+    end
+
     it "should be able to substitute fixed strings from a random set" do
       looking_for = ["hello", "world"]
       original_looking_for = looking_for.dup
       guard = 0
       while !looking_for.empty? && guard < 1000
-        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :a => { :type => :fixed, :one_of => ["hello", "world"] }}, [:a, :b, :c])
+        new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => {:type => :fixed, :one_of => ["hello", "world"]}}, [:a, :b, :c])
         new_row.length.should == 3
         original_looking_for.should include(new_row[0])
         looking_for.delete new_row[0]
@@ -140,12 +136,135 @@ describe MyObfuscate do
       looking_for.should be_empty
     end
 
+    it "should treat a symbol in the column definition as an implicit { :type => symbol }" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => :null, :a => :keep}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should == "blah"
+      new_row[1].should == nil
+    end
+
     it "should be able to set things NULL" do
-      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], { :b => { :type => :null }}, [:a, :b, :c])
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :null}}, [:a, :b, :c])
       new_row.length.should == 3
       new_row[1].should == nil
     end
 
+    it "should be able to :keep the value the same" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :keep}}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[1].should == "something_else"
+    end
+
+    it "should keep the value when given an unknown type, but should display a warning" do
+      $stderr = error_output = StringIO.new
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:b => {:type => :unknown_type}}, [:a, :b, :c])
+      $stderr = STDERR
+      new_row.length.should == 3
+      new_row[1].should == "something_else"
+      error_output.rewind
+      error_output.read.should =~ /Keeping a column value by.*?unknown_type/
+    end
+
+    it "should be able to substitute lorem ipsum text" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :lorem, :b => {:type => :lorem, :number => 2}}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "blah"
+      new_row[0].should_not =~ /\w\.(?!\Z)/
+      new_row[1].should_not == "something_else"
+      new_row[1].should =~ /\w\.(?!\Z)/
+    end
+
+    it "should be able to generate an :company" do
+      new_row = MyObfuscate.apply_table_config(["Smith and Sons", "something_else", "5"], {:a => :company}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "Smith and Sons"
+      new_row[0].should =~ /\w+/
+    end
+
+    it "should be able to generate an :url" do
+      new_row = MyObfuscate.apply_table_config(["http://mystuff.blogger.com", "something_else", "5"], {:a => :url}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "http://mystuff.blogger.com"
+      new_row[0].should =~ /http:\/\/\w+/
+    end
+
+    it "should be able to generate an :ipv4" do
+      new_row = MyObfuscate.apply_table_config(["1.2.3.4", "something_else", "5"], {:a => :ipv4}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "1.2.3.4"
+      new_row[0].should =~ /\d+\.\d+\.\d+\.\d+/
+    end
+
+    it "should be able to generate an :ipv6" do
+      new_row = MyObfuscate.apply_table_config(["fe80:0000:0000:0000:0202:b3ff:fe1e:8329", "something_else", "5"], {:a => :ipv6}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
+      new_row[0].should =~ /[0-9a-f:]+/
+    end
+
+    it "should be able to generate an :address" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :address}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "blah"
+      new_row[0].should =~ /\d+ \w/
+    end
+
+    it "should be able to generate a :name" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :name}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "blah"
+      new_row[0].should =~ / /
+    end
+
+    it "should be able to generate just a street address" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :street_address}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "blah"
+      new_row[0].should =~ /\d+ \w/
+    end
+
+    it "should be able to generate a city" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :city}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "blah"
+    end
+
+    it "should be able to generate a state" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :state}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "blah"
+    end
+
+    it "should be able to generate a zip code" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :zip_code}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "blah"
+      new_row[0].should =~ /\d+/
+    end
+
+    it "should be able to generate a phone number" do
+      new_row = MyObfuscate.apply_table_config(["blah", "something_else", "5"], {:a => :phone}, [:a, :b, :c])
+      new_row.length.should == 3
+      new_row[0].should_not == "blah"
+      new_row[0].should =~ /\d+/
+    end
+    
+    describe "when faker generates values with quotes in them" do
+      before do
+        Faker::Address.stub(:city).and_return("O'ReillyTown")
+        Faker::Name.stub(:name).and_return("Foo O'Reilly")
+        Faker::Name.stub(:first_name).and_return("O'Foo")
+        Faker::Name.stub(:last_name).and_return("O'Reilly")
+        Faker::Lorem.stub(:sentences).with(any_args).and_return(["Foo bar O'Thingy"])
+      end
+      
+      it "should remove single quotes from the value" do
+        new_row = MyObfuscate.apply_table_config(["address", "city", "first", "last", "fullname", "some text"],
+                  {:a => :address, :b => :city, :c => :first_name, :d => :last_name, :e => :name, :f => :lorem},
+                  [:a, :b, :c, :d, :e, :f])
+        new_row.each {|value| value.should_not include("'")}
+      end
+    end
   end
 
   describe "MyObfuscate.row_as_hash" do
@@ -155,91 +274,285 @@ describe MyObfuscate do
   end
 
   describe "#obfuscate" do
-    context "when there is nothing to obfuscate" do
-      it "should accept an IO object for input and output, and copy the input to the output" do
-        ddo = MyObfuscate.new
-        string = "hello, world\nsup?"
-        input = StringIO.new(string)
-        output = StringIO.new
-        ddo.obfuscate(input, output)
-        input.rewind
-        output.rewind
-        output.read.should == string
+    describe "when using MySQL" do
+      context "when there is nothing to obfuscate" do
+        it "should accept an IO object for input and output, and copy the input to the output" do
+          ddo = MyObfuscate.new
+          string = "hello, world\nsup?"
+          input = StringIO.new(string)
+          output = StringIO.new
+          ddo.obfuscate(input, output)
+          input.rewind
+          output.rewind
+          output.read.should == string
+        end
       end
-    end
 
-    context "when the dump to obfuscate is missing columns" do
-      before do
-        @database_dump = StringIO.new(<<-SQL)
+      context "when the dump to obfuscate is missing columns" do
+        before do
+          @database_dump = StringIO.new(<<-SQL)
           INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);
-        SQL
-        @ddo = MyObfuscate.new({
-          :some_table => {
-            :email => { :type => :email, :honk_email_skip => true },
-            :name => { :type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS },
-            :gender => { :type => :fixed, :string => "m" }
-          }})
-        @output = StringIO.new
-      end
-
-      it "should raise an error if a column name can't be found" do
-        lambda {
-          @ddo.obfuscate(@database_dump, @output)
-        }.should raise_error
+          SQL
+          @ddo = MyObfuscate.new({
+                                     :some_table => {
+                                         :email => {:type => :email, :honk_email_skip => true},
+                                         :name => {:type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS},
+                                         :gender => {:type => :fixed, :string => "m"}
+                                     }})
+          @output = StringIO.new
+        end
+
+        it "should raise an error if a column name can't be found" do
+          lambda {
+            @ddo.obfuscate(@database_dump, @output)
+          }.should raise_error
+        end
       end
-    end
 
-    context "when there is something to obfuscate" do
-      before do
-        @database_dump = StringIO.new(<<-SQL)
+      context "when there is something to obfuscate" do
+        before do
+          @database_dump = StringIO.new(<<-SQL)
           INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54),('dontmurderme@direwolf.com','direwolf', 'somethingelse3', 44);
           INSERT INTO `another_table` (`a`, `b`, `c`, `d`) VALUES (1,2,3,4), (5,6,7,8);
+          INSERT INTO `some_table_to_keep` (`a`, `b`, `c`, `d`) VALUES (1,2,3,4), (5,6,7,8);
           INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh', 'aawefjkafe'), ('hello1','kjhj!', 892938), ('hello2','moose!!', NULL);
           INSERT INTO `an_ignored_table` (`col`, `col2`) VALUES ('hello','kjhjd^&dkjh'), ('hello1','kjhj!'), ('hello2','moose!!');
-        SQL
-
-        @ddo = MyObfuscate.new({
-          :some_table => {
-            :email => { :type => :email, :skip_regexes => [/^[\w\.\_]+@honk\.com$/i, /^dontmurderme@direwolf.com$/] },
-            :name => { :type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS },
-            :age => { :type => :integer, :between => 10...80 }
-          },
-          :another_table => :truncate,
-          :one_more_table => {
-            # Note: fixed strings must be pre-SQL escaped!
-            :password => { :type => :fixed, :string => "monkey" },
-            :c => { :type => :null }
-          }
-        })
-        @output = StringIO.new
-        @ddo.obfuscate(@database_dump, @output)
-        @output.rewind
-        @output_string = @output.read
-      end
-
-      it "should be able to truncate tables" do
-        @output_string.should_not include("INSERT INTO `another_table`")
-        @output_string.should include("INSERT INTO `one_more_table`")
-      end
-
-      it "should ignore tables that it doesn't know about" do
-        @output_string.should include("INSERT INTO `an_ignored_table` (`col`, `col2`) VALUES ('hello','kjhjd^&dkjh'), ('hello1','kjhj!'), ('hello2','moose!!');")
-      end
-
-      it "should obfuscate the tables" do
-        @output_string.should include("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES (")
-        @output_string.should include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES (")
-        @output_string.should include("'some\\'thin,ge())lse1'")
-        @output_string.should include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','monkey',NULL),('hello1','monkey',NULL),('hello2','monkey',NULL);")
-        @output_string.should_not include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh', 'aawefjkafe'), ('hello1','kjhj!', 892938), ('hello2','moose!!', NULL);")
-        @output_string.should_not include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh','aawefjkafe'),('hello1','kjhj!',892938),('hello2','moose!!',NULL);")
-        @output_string.should_not include("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);")
-      end
-
-      it "honors a special case: on the people table, rows with anything@honk.com in a slot marked with :honk_email_skip do not change this slot" do
-        @output_string.should include("('bob@honk.com',")
-        @output_string.should include("('dontmurderme@direwolf.com',")
-        @output_string.should_not include("joe@joe.com")
+          SQL
+
+          @ddo = MyObfuscate.new({
+                                     :some_table => {
+                                         :email => {:type => :email, :skip_regexes => [/^[\w\.\_]+@honk\.com$/i, /^dontmurderme@direwolf.com$/]},
+                                         :name => {:type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS},
+                                         :age => {:type => :integer, :between => 10...80}
+                                     },
+                                     :another_table => :truncate,
+                                     :some_table_to_keep => :keep,
+                                     :one_more_table => {
+                                         # Note: fixed strings must be pre-SQL escaped!
+                                         :password => {:type => :fixed, :string => "monkey"},
+                                         :c => {:type => :null}
+                                     }
+                                 })
+          @output = StringIO.new
+          $stderr = @error_output = StringIO.new
+          @ddo.obfuscate(@database_dump, @output)
+          $stderr = STDERR
+          @output.rewind
+          @output_string = @output.read
+        end
+
+        it "should be able to truncate tables" do
+          @output_string.should_not include("INSERT INTO `another_table`")
+          @output_string.should include("INSERT INTO `one_more_table`")
+        end
+
+        it "should be able to declare tables to keep" do
+          @output_string.should include("INSERT INTO `some_table_to_keep` (`a`, `b`, `c`, `d`) VALUES (1,2,3,4), (5,6,7,8);")
+        end
+
+        it "should ignore tables that it doesn't know about, but should warn" do
+          @output_string.should include("INSERT INTO `an_ignored_table` (`col`, `col2`) VALUES ('hello','kjhjd^&dkjh'), ('hello1','kjhj!'), ('hello2','moose!!');")
+          @error_output.rewind
+          @error_output.read.should =~ /an_ignored_table was not specified in the config/
+        end
+
+        it "should obfuscate the tables" do
+          @output_string.should include("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES (")
+          @output_string.should include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES (")
+          @output_string.should include("'some\\'thin,ge())lse1'")
+          @output_string.should include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','monkey',NULL),('hello1','monkey',NULL),('hello2','monkey',NULL);")
+          @output_string.should_not include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh', 'aawefjkafe'), ('hello1','kjhj!', 892938), ('hello2','moose!!', NULL);")
+          @output_string.should_not include("INSERT INTO `one_more_table` (`a`, `password`, `c`, `d,d`) VALUES ('hello','kjhjd^&dkjh','aawefjkafe'),('hello1','kjhj!',892938),('hello2','moose!!',NULL);")
+          @output_string.should_not include("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);")
+        end
+
+        it "honors a special case: on the people table, rows with anything@honk.com in a slot marked with :honk_email_skip do not change this slot" do
+          @output_string.should include("('bob@honk.com',")
+          @output_string.should include("('dontmurderme@direwolf.com',")
+          @output_string.should_not include("joe@joe.com")
+        end
+      end
+
+      context "when fail_on_unspecified_columns is set to true" do
+        before do
+          @database_dump = StringIO.new(<<-SQL)
+          INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54),('dontmurderme@direwolf.com','direwolf', 'somethingelse3', 44);
+          SQL
+
+          @ddo = MyObfuscate.new({
+                                     :some_table => {
+                                         :email => {:type => :email, :skip_regexes => [/^[\w\.\_]+@honk\.com$/i, /^dontmurderme@direwolf.com$/]},
+                                         :name => {:type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS},
+                                         :age => {:type => :integer, :between => 10...80}
+                                     }
+                                 })
+          @ddo.fail_on_unspecified_columns = true
+        end
+
+        it "should raise an exception when an unspecified column is found" do
+          lambda {
+            @ddo.obfuscate(@database_dump, StringIO.new)
+          }.should raise_error(/column 'something' defined/i)
+        end
+
+        it "should accept columns defined in globally_kept_columns" do
+          @ddo.globally_kept_columns = %w[something]
+          lambda {
+            @ddo.obfuscate(@database_dump, StringIO.new)
+          }.should_not raise_error
+        end
+      end
+    end
+
+    describe "when using MS SQL Server" do
+      context "when there is nothing to obfuscate" do
+        it "should accept an IO object for input and output, and copy the input to the output" do
+          ddo = MyObfuscate.new
+          ddo.database_type = :sql_server
+          string = "hello, world\nsup?"
+          input = StringIO.new(string)
+          output = StringIO.new
+          ddo.obfuscate(input, output)
+          input.rewind
+          output.rewind
+          output.read.should == string
+        end
+      end
+
+      context "when the dump to obfuscate is missing columns" do
+        before do
+          @database_dump = StringIO.new(<<-SQL)
+          INSERT [dbo].[some_table] ([email], [name], [something], [age]) VALUES ('bob@honk.com','bob', 'some''thin,ge())lse1', 25);
+          SQL
+          @ddo =  MyObfuscate.new({
+              :some_table => {
+                  :email => {:type => :email, :honk_email_skip => true},
+                  :name => {:type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS},
+                  :gender => {:type => :fixed, :string => "m"}
+              }})
+          @ddo.database_type = :sql_server
+          @output = StringIO.new
+        end
+
+        it "should raise an error if a column name can't be found" do
+          lambda {
+            @ddo.obfuscate(@database_dump, @output)
+          }.should raise_error
+        end
+      end
+
+      context "when there is something to obfuscate" do
+        before do
+          @database_dump = StringIO.new(<<-SQL)
+          INSERT [dbo].[some_table] ([email], [name], [something], [age], [bday]) VALUES (N'bob@honk.com',N'bob', N'some''thin,ge())lse1', 25, CAST(0x00009E1A00000000 AS DATETIME));
+          INSERT [dbo].[some_table] ([email], [name], [something], [age], [bday]) VALUES (N'joe@joe.com',N'joe', N'somethingelse2', 54, CAST(0x00009E1A00000000 AS DATETIME));
+          INSERT [dbo].[some_table] ([email], [name], [something], [age], [bday]) VALUES (N'dontmurderme@direwolf.com',N'direwolf', N'somethingelse3', 44, CAST(0x00009E1A00000000 AS DATETIME));
+          INSERT [dbo].[another_table] ([a], [b], [c], [d]) VALUES (1,2,3,4);
+          INSERT [dbo].[another_table] ([a], [b], [c], [d]) VALUES (5,6,7,8);
+          INSERT [dbo].[some_table_to_keep] ([a], [b], [c], [d]) VALUES (1,2,3,4);
+          INSERT [dbo].[some_table_to_keep] ([a], [b], [c], [d]) VALUES (5,6,7,8);
+          INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello',N'kjhjd^&dkjh', N'aawefjkafe');
+          INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello1',N'kjhj!', 892938);
+          INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello2',N'moose!!', NULL);
+          INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello',N'kjhjd^&dkjh');
+          INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello1',N'kjhj!');
+          INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello2',N'moose!!');
+          SQL
+
+          @ddo = MyObfuscate.new({
+               :some_table => {
+                   :email => {:type => :email, :skip_regexes => [/^[\w\.\_]+@honk\.com$/i, /^dontmurderme@direwolf.com$/]},
+                   :name => {:type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS},
+                   :age => {:type => :integer, :between => 10...80},
+                   :bday => :keep
+               },
+               :another_table => :truncate,
+               :some_table_to_keep => :keep,
+               :one_more_table => {
+                   # Note: fixed strings must be pre-SQL escaped!
+                   :password => {:type => :fixed, :string => "monkey"},
+                   :c => {:type => :null}
+               }
+           })
+          @ddo.database_type = :sql_server
+
+          @output = StringIO.new
+          $stderr = @error_output = StringIO.new
+          @ddo.obfuscate(@database_dump, @output)
+          $stderr = STDERR
+          @output.rewind
+          @output_string = @output.read
+        end
+
+        it "should be able to truncate tables" do
+          @output_string.should_not include("INSERT [dbo].[another_table]")
+          @output_string.should include("INSERT [dbo].[one_more_table]")
+        end
+
+        it "should be able to declare tables to keep" do
+          @output_string.should include("INSERT [dbo].[some_table_to_keep] ([a], [b], [c], [d]) VALUES (1,2,3,4);")
+          @output_string.should include("INSERT [dbo].[some_table_to_keep] ([a], [b], [c], [d]) VALUES (5,6,7,8);")
+        end
+
+        it "should ignore tables that it doesn't know about, but should warn" do
+          @output_string.should include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello',N'kjhjd^&dkjh');")
+          @output_string.should include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello1',N'kjhj!');")
+          @output_string.should include("INSERT [dbo].[an_ignored_table] ([col], [col2]) VALUES (N'hello2',N'moose!!');")
+          @error_output.rewind
+          @error_output.read.should =~ /an_ignored_table was not specified in the config/
+        end
+
+        it "should obfuscate the tables" do
+          @output_string.should include("INSERT [dbo].[some_table] ([email], [name], [something], [age], [bday]) VALUES (")
+          @output_string.should include("CAST(0x00009E1A00000000 AS DATETIME)")
+          @output_string.should include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (")
+          @output_string.should include("'some''thin,ge())lse1'")
+          @output_string.should include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello',N'monkey',NULL);")
+          @output_string.should include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello1',N'monkey',NULL);")
+          @output_string.should include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello2',N'monkey',NULL);")
+          @output_string.should_not include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello',N'kjhjd^&dkjh', N'aawefjkafe');")
+          @output_string.should_not include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello1',N'kjhj!', 892938);")
+          @output_string.should_not include("INSERT [dbo].[one_more_table] ([a], [password], [c], [d,d]) VALUES (N'hello2',N'moose!!', NULL);")
+          @output_string.should_not include("INSERT [dbo].[some_table] ([email], [name], [something], [age]) VALUES (N'bob@honk.com',N'bob', N'some''thin,ge())lse1', 25, CAST(0x00009E1A00000000 AS DATETIME));")
+          @output_string.should_not include("INSERT [dbo].[some_table] ([email], [name], [something], [age]) VALUES (N'joe@joe.com',N'joe', N'somethingelse2', 54, CAST(0x00009E1A00000000 AS DATETIME));")
+        end
+
+        it "honors a special case: on the people table, rows with anything@honk.com in a slot marked with :honk_email_skip do not change this slot" do
+          @output_string.should include("(N'bob@honk.com',")
+          @output_string.should include("(N'dontmurderme@direwolf.com',")
+          @output_string.should_not include("joe@joe.com")
+        end
+      end
+
+      context "when fail_on_unspecified_columns is set to true" do
+        before do
+          @database_dump = StringIO.new(<<-SQL)
+          INSERT INTO [dbo].[some_table] ([email], [name], [something], [age]) VALUES ('bob@honk.com','bob', 'some''thin,ge())lse1', 25);
+          SQL
+
+          @ddo = MyObfuscate.new({
+                                     :some_table => {
+                                         :email => {:type => :email, :skip_regexes => [/^[\w\.\_]+@honk\.com$/i, /^dontmurderme@direwolf.com$/]},
+                                         :name => {:type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS},
+                                         :age => {:type => :integer, :between => 10...80}
+                                     }
+                                 })
+          @ddo.database_type = :sql_server
+          @ddo.fail_on_unspecified_columns = true
+        end
+
+        it "should raise an exception when an unspecified column is found" do
+          lambda {
+            @ddo.obfuscate(@database_dump, StringIO.new)
+          }.should raise_error(/column 'something' defined/i)
+        end
+
+        it "should accept columns defined in globally_kept_columns" do
+          @ddo.globally_kept_columns = %w[something]
+          lambda {
+            @ddo.obfuscate(@database_dump, StringIO.new)
+          }.should_not raise_error
+        end
       end
     end
   end