iterationlabs-my_obfuscate 0.3.3

data/.gitignore

@@ -0,0 +1,8 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+.idea
+.rvmrc
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in my_obfuscate.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Honk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,85 @@
+= my_obfuscate
+
+Standalone Ruby code for the selective rewriting of SQL dumps in order to protect user privacy.  Supports MySQL and SQL Server.
+
+= Install
+
+  sudo gem install my_obfuscate
+
+= Example Usage
+
+Make an obfuscator.rb script:
+
+  #!/usr/bin/env ruby
+  require "rubygems"
+  require "my_obfuscate"
+
+  obfuscator = MyObfuscate.new({
+    :people => {
+      :email                     => { :type => :email, :skip_regexes => [/^[\w\.\_]+@my_company\.com$/i] },
+      :ethnicity                 => :keep,
+      :crypted_password          => { :type => :fixed, :string => "SOME_FIXED_PASSWORD_FOR_EASE_OF_DEBUGGING" },
+      :salt                      => { :type => :fixed, :string => "SOME_THING" },
+      :remember_token            => :null,
+      :remember_token_expires_at => :null,
+      :age                       => { :type => :null, :unless => lambda { |person| person[:email] == "hello@example.com" } },
+      :photo_file_name           => :null,
+      :photo_content_type        => :null,
+      :photo_file_size           => :null,
+      :photo_updated_at          => :null,
+      :postal_code               => { :type => :fixed, :string => "94109", :unless => lambda {|person| person[:postal_code] == "12345"} },
+      :name                      => :name,
+      :full_address              => :address,
+      :bio                       => { :type => :lorem, :number => 4 },
+      :relationship_status       => { :type => :fixed, :one_of => ["Single", "Divorced", "Married", "Engaged", "In a Relationship"] },
+      :has_children              => { :type => :integer, :between => 0..1 },
+    },
+
+    :invites                     => :truncate,
+    :invite_requests             => :truncate,
+    :tags                        => :keep,
+
+    :relationships => {
+      :account_id                => :keep,
+      :code                      => { :type => :string, :length => 8, :chars => MyObfuscate::USERNAME_CHARS }
+    }
+  })
+  obfuscator.fail_on_unspecified_columns = true # if you want it to require every column in the table to be in the above definition
+  obfuscator.globally_kept_columns = %w[id created_at updated_at] # if you set fail_on_unspecified_columns, you may want this as well
+  obfuscator.obfuscate(STDIN, STDOUT)
+
+And to get an obfuscated dump:
+  mysqldump -c --add-drop-table -u user -ppassword database | ruby obfuscator.rb > obfuscated_dump.sql
+Note that the -c option on mysqldump is required to use my_obfuscator.
+
+== Database Server
+
+By default the database type is assumed to be MySQL, but you can use the
+builtin SQL Server support by specifying:
+
+    obfuscator.database_type = :sql_server
+
+== Changes
+
+* Support for SQL Server
+* :unless and :if now support :nil as a shorthand for a Proc that checks for nil
+* :name, :lorem, and :address are all now supported types.  You can pass :number to :lorem to specify how many sentences to generate.  The default is one.
+* <tt>{ :type => :whatever }</tt> is now optional when no additional options are needed.  Just use <tt>:whatever</tt>.
+* Warnings are thrown when an unknown column type or table is encountered.  Use <tt>:keep</tt> in both cases.
+* <tt>{ :type => :fixed, :string => Proc { |row| ... } }</tt> is now available.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.  (If you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Thanks
+
+Thanks to Mavenlink and Pivotal Labs for patches and updates!
+
+== Copyright
+
+Copyright (c) 2009 Honk. Now maintained by Iteration Labs, LLC. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/iterationlabs-my_obfuscate.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "my_obfuscate/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{iterationlabs-my_obfuscate}
+  s.version = MyObfuscate::VERSION
+
+  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@iterationlabs.com}
+  s.homepage = %q{http://github.com/iterationlabs/myobfuscate}
+  s.summary = %q{Standalone Ruby code for the selective rewriting of MySQL dumps in order to protect user privacy.}
+
+  s.add_development_dependency "rspec"
+  s.add_dependency "faker", "=0.9.5"
+
+  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/lib/my_obfuscate.rb

@@ -0,0 +1,213 @@
+require 'jcode' if RUBY_VERSION < '1.9'
+require 'faker'
+require 'my_obfuscate/mysql'
+require 'my_obfuscate/sql_server'
+
+# Class for obfuscating MySQL dumps. This can parse mysqldump outputs when using the -c option, which includes
+# column names in the insert statements.
+class MyObfuscate
+  attr_accessor :config, :globally_kept_columns, :fail_on_unspecified_columns, :database_type
+
+  NUMBER_CHARS = "1234567890"
+  USERNAME_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_" + NUMBER_CHARS
+  SENSIBLE_CHARS = USERNAME_CHARS + '+-=[{]}/?|!@#$%^&*()`~'
+
+  # Make a new MyObfuscate object.  Pass in a configuration structure to define how the obfuscation should be
+  # performed.  See the README.rdoc file for more information.
+  def initialize(configuration = {})
+    @config = configuration
+  end
+
+  def fail_on_unspecified_columns?
+    @fail_on_unspecified_columns
+  end
+
+  def database_helper
+    if @database_helper.nil?
+      if @database_type == :sql_server
+        @database_helper = SqlServer.new
+      else
+        @database_helper = Mysql.new
+      end
+    end
+
+    @database_helper
+  end
+
+  # Read an input stream and dump out an obfuscated output stream.  These streams could be StringIO objects, Files,
+  # or STDIN and STDOUT.
+  def obfuscate(input_io, output_io)
+
+    # We assume that every INSERT INTO line occupies one line in the file, with no internal linebreaks.
+    input_io.each do |line|
+      if table_data = database_helper.parse_insert_statement(line)
+        table_name = table_data[:table_name]
+        columns = table_data[:column_names]
+        if config[table_name]
+          output_io.puts obfuscate_bulk_insert_line(line, table_name, columns)
+        else
+          $stderr.puts "Deprecated: #{table_name} was not specified in the config.  A future release will cause this to be an error.  Please specify the table definition or set it to :keep."
+          output_io.write line
+        end
+      else
+        output_io.write line
+      end
+    end
+  end
+
+  def reassembling_each_insert(line, table_name, columns)
+    output = database_helper.rows_to_be_inserted(line).map do |sub_insert|
+      result = yield(sub_insert)
+      result = result.map do |i|
+        database_helper.make_valid_value_string(i)
+      end
+      result = result.join(",")
+      "(" + result + ")"
+    end.join(",")
+    database_helper.make_insert_statement(table_name, columns, output)
+  end
+
+  def self.row_as_hash(row, columns)
+    columns.zip(row).inject({}) {|m, (name, value)| m[name] = value; m}
+  end
+
+  def self.make_conditional_method(conditional_method, index, row)
+    if conditional_method.is_a?(Symbol)
+      if conditional_method == :blank
+        conditional_method = lambda { |row_hash| row[index].nil? || row[index] == '' }
+      elsif conditional_method == :nil
+        conditional_method = lambda { |row_hash| row[index].nil? }
+      end
+    end
+    conditional_method
+  end
+
+  def self.apply_table_config(row, table_config, columns)
+    return row unless table_config.is_a?(Hash)
+    row_hash = row_as_hash(row, columns)
+
+    table_config.each do |column, definition|
+      index = columns.index(column)
+      
+      definition = { :type => definition } if definition.is_a?(Symbol)
+
+      if definition.has_key?(:unless)
+        unless_check = make_conditional_method(definition[:unless], index, row)
+
+        next if unless_check.call(row_hash)
+      end
+
+
+      if definition.has_key?(:if)
+        if_check = make_conditional_method(definition[:if], index, row)
+
+        next unless if_check.call(row_hash)
+      end
+
+      if definition[:skip_regexes]
+        next if definition[:skip_regexes].any? {|regex| row[index] =~ regex}
+      end
+
+      row[index.to_i] = case definition[:type]
+        when :email
+          random_string(definition[:length] || (4..10), USERNAME_CHARS) + "@example.com"
+        when :string
+          random_string(definition[:length] || 30, definition[:chars] || SENSIBLE_CHARS)
+        when :lorem
+          clean_bad_whitespace(clean_quotes(Faker::Lorem.sentences(definition[:number] || 1).join(".  ")))
+        when :name
+          clean_quotes(Faker::Name.name)
+        when :first_name
+          clean_quotes(Faker::Name.first_name)
+        when :last_name
+          clean_quotes(Faker::Name.last_name)
+        when :address
+          clean_quotes("#{Faker::Address.street_address}\\n#{Faker::Address.city}, #{Faker::Address.state_abbr} #{Faker::Address.zip_code}")
+        when :street_address
+          clean_bad_whitespace(clean_quotes(Faker::Address.street_address))
+        when :city
+          clean_quotes(Faker::Address.city)
+        when :state
+          Faker::Address.state_abbr
+        when :zip_code
+          Faker::Address.zip_code
+        when :phone
+          Faker::PhoneNumber.phone_number
+        when :integer
+          random_integer(definition[:between] || (0..1000)).to_s
+        when :fixed
+          if definition[:one_of]
+            definition[:one_of][(rand * definition[:one_of].length).to_i]
+          else
+            definition[:string].is_a?(Proc) ? definition[:string].call(row_hash) : definition[:string]
+          end
+        when :null
+          nil
+        when :keep
+          row[index]
+        else
+          $stderr.puts "Keeping a column value by providing an unknown type (#{definition[:type]}) is deprecated.  Use :keep instead."
+          row[index]
+      end
+    end
+    row
+  end
+
+  def self.random_integer(between)
+    (between.min + (between.max - between.min) * rand).round
+  end
+
+  def self.random_string(length_or_range, chars)
+    length_or_range = (length_or_range..length_or_range) if length_or_range.is_a?(Fixnum)
+    times = random_integer(length_or_range)
+    out = ""
+    times.times { out << chars[rand * chars.length] }
+    out
+  end
+
+  def check_for_defined_columns_not_in_table(table_name, columns)
+    missing_columns = config[table_name].keys - columns
+    unless missing_columns.length == 0
+      error_message = missing_columns.map do |missing_column|
+        "Column '#{missing_column}' could not be found in table '#{table_name}', please fix your obfuscator config."
+      end.join("\n")
+      raise RuntimeError.new(error_message)
+    end
+  end
+
+  def check_for_table_columns_not_in_definition(table_name, columns)
+    missing_columns = columns - (config[table_name].keys + (globally_kept_columns || []).map {|i| i.to_sym}).uniq
+    unless missing_columns.length == 0
+      error_message = missing_columns.map do |missing_column|
+        "Column '#{missing_column}' defined in table '#{table_name}', but not found in table definition, please fix your obfuscator config."
+      end.join("\n")
+      raise RuntimeError.new(error_message)
+    end
+  end
+
+  def obfuscate_bulk_insert_line(line, table_name, columns)
+    table_config = config[table_name]
+    if table_config == :truncate
+      ""
+    elsif table_config == :keep
+      line
+    else
+      check_for_defined_columns_not_in_table(table_name, columns)
+      check_for_table_columns_not_in_definition(table_name, columns) if fail_on_unspecified_columns?
+      # Note: Remember to SQL escape strings in what you pass back.
+      reassembling_each_insert(line, table_name, columns) do |row|
+        MyObfuscate.apply_table_config(row, table_config, columns)
+      end
+    end
+  end
+  
+  private
+  
+  def self.clean_quotes(value)
+    value.gsub(/['"]/, '')
+  end
+  
+  def self.clean_bad_whitespace(value)
+    value.gsub(/[\n\t\r]/, '')
+  end
+end

data/lib/my_obfuscate/mysql.rb

@@ -0,0 +1,87 @@
+class MyObfuscate::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"
+    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

data/lib/my_obfuscate/sql_server.rb

@@ -0,0 +1,79 @@
+class MyObfuscate::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

data/lib/my_obfuscate/version.rb

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

data/spec/my_obfuscate_spec.rb

@@ -0,0 +1,531 @@
+require 'spec_helper'
+
+describe MyObfuscate 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"]
+      ]
+    end
+
+    it "should yield each subinsert and reassemble the result" do
+      count = 0
+      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
+      end
+      count.should == 2
+      reassembled.should == @test_insert
+    end
+  end
+
+  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.length.should == 2
+      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.length.should == 3
+      new_row[1].length.should == 7
+      new_row[1].should_not == "something_else"
+    end
+
+    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[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[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[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[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[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[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[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[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[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.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.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.length.should == 3
+        original_looking_for.should include(new_row[0])
+        looking_for.delete new_row[0]
+        guard += 1
+      end
+      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.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 :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
+    it "will map row values into a hash with column names as keys" do
+      MyObfuscate.row_as_hash([1, 2, 3, 4], [:a, :b, :c, :d]).should == {:a => 1, :b => 2, :c => 3, :d => 4}
+    end
+  end
+
+  describe "#obfuscate" do
+    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
+
+      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
+        end
+      end
+
+      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,
+                                     :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
+end

data/spec/mysql_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe MyObfuscate::Mysql do
+  describe "#parse_insert_statement" do
+    it "should return nil for other SQL syntaxes (MS SQL Server)" do
+      subject.parse_insert_statement("INSERT [dbo].[TASKS] ([TaskID], [TaskName]) VALUES (61, N'Report Thing')").should be_nil
+    end
+
+    it "should return nil for MySQL non-insert statements" do
+      subject.parse_insert_statement("CREATE TABLE `some_table`;").should be_nil
+    end
+
+    it "should return a hash of table name, column names for MySQL insert statements" do
+      hash = subject.parse_insert_statement("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);")
+      hash.should == {:table_name => :some_table, :column_names => [:email, :name, :something, :age]}
+    end
+  end
+
+  describe "#rows_to_be_inserted" do
+    it "should split a mysql string into fields" do
+      string = "INSERT INTO `some_table` (thing1,thing2) VALUES ('bob@bob.com','bob', 'somethingelse1', 25, '2', 10,    'hi')  ;  "
+      fields = [['bob@bob.com', 'bob', 'somethingelse1', '25', '2', '10', "hi"]]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+
+    it "should work ok with escaped characters" do
+      string = "INSERT INTO `some_table` (thing1,thing2) VALUES ('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"]]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+
+    it "should work with multiple subinserts" do
+      string = "INSERT INTO `some_table` (thing1,thing2) VALUES (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"]]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+
+    it "should work ok with NULL values" do
+      string = "INSERT INTO `some_table` (thing1,thing2) VALUES (NULL    , 'bob@bob.com','bob', NULL, 25, '2', NULL,    'hi', NULL  ); "
+      fields = [[nil, 'bob@bob.com', 'bob', nil, '25', '2', nil, "hi", nil]]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+
+    it "should work with empty strings" do
+      string = "INSERT INTO `some_table` (thing1,thing2) VALUES (NULL    , '', ''      , '', 25, '2','',    'hi','') ;"
+      fields = [[nil, '', '', '', '25', '2', '', "hi", '']]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :development)
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'my_obfuscate'
+
+RSpec.configure do |config|
+#  config.mock_with :rr
+end

data/spec/sql_server_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe MyObfuscate::SqlServer do
+  describe "#parse_insert_statement" do
+    it "should return a hash of table_name, column_names for SQL Server input statements" do
+      hash = subject.parse_insert_statement("INSERT [dbo].[TASKS] ([TaskID], [TaskName]) VALUES (61, N'Report Thing')")
+      hash.should == { :table_name => :TASKS, :column_names => [:TaskID, :TaskName] }
+    end
+
+    it "should return nil for SQL Server non-insert statements" do
+      subject.parse_insert_statement("CREATE TABLE [dbo].[WORKFLOW](").should be_nil
+    end
+
+    it "should return nil for non-SQL Server insert statements (MySQL)" do
+      subject.parse_insert_statement("INSERT INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);").should be_nil
+    end
+  end
+
+  describe "#rows_to_be_inserted" do
+    it "should split a SQL Server string into fields" do
+      string = "INSERT [dbo].[some_table] ([thing1],[thing2]) VALUES (N'bob@bob.com',N'bob', N'somethingelse1',25, '2', 10,    'hi', CAST(0x00009E1A00000000 AS DATETIME))  ;  "
+      fields = [['bob@bob.com', 'bob', 'somethingelse1', '25', '2', '10', "hi", "CAST(0x00009E1A00000000 AS DATETIME)"]]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+
+    it "should work ok with single quote escape" do
+      string = "INSERT [dbo].[some_table] ([thing1],[thing2]) VALUES (N'bob,@bob.c  , om', 'bo'', b', N'some\"thingel''se1', 25, '2', 10,    'hi', 5)  ; "
+      fields = [['bob,@bob.c  , om', "bo'', b", "some\"thingel''se1", '25', '2', '10', "hi", "5"]]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+
+    it "should work ok with NULL values" do
+      string = "INSERT [dbo].[some_table] ([thing1],[thing2]) VALUES (NULL    , N'bob@bob.com','bob', NULL, 25, N'2', NULL,    'hi', NULL  ); "
+      fields = [[nil, 'bob@bob.com', 'bob', nil, '25', '2', nil, "hi", nil]]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+
+    it "should work with empty strings" do
+      string = "INSERT [dbo].[some_table] ([thing1],[thing2]) VALUES (NULL    , N'', ''      , '', 25, '2','',    N'hi','') ;"
+      fields = [[nil, '', '','', '25', '2', '', "hi", '']]
+      subject.rows_to_be_inserted(string).should == fields
+    end
+  end
+
+  describe "#make_valid_value_string" do
+    it "should output 'NULL' when the value is nil" do
+      subject.make_valid_value_string(nil).should == "NULL"
+    end
+
+    it "should enclose the value in quotes if it's a string" do
+      subject.make_valid_value_string("something").should == "N'something'"
+    end
+
+    it "should not enclose the value in quotes if it is a method call" do
+      subject.make_valid_value_string("CAST(0x00009E1A00000000 AS DATETIME)").should == "CAST(0x00009E1A00000000 AS DATETIME)"
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: iterationlabs-my_obfuscate
+version: !ruby/object:Gem::Version
+  version: 0.3.3
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Cantino
+- Dave Willett
+- Mike Grafton
+- Mason Glaves
+- Greg Bell
+- Mavenlink
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+description: Standalone Ruby code for the selective rewriting of MySQL dumps in order
+  to protect user privacy.
+email: andrew@iterationlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- iterationlabs-my_obfuscate.gemspec
+- lib/my_obfuscate.rb
+- lib/my_obfuscate/mysql.rb
+- lib/my_obfuscate/sql_server.rb
+- lib/my_obfuscate/version.rb
+- spec/my_obfuscate_spec.rb
+- spec/mysql_spec.rb
+- spec/spec_helper.rb
+- spec/sql_server_spec.rb
+homepage: http://github.com/iterationlabs/myobfuscate
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Standalone Ruby code for the selective rewriting of MySQL dumps in order
+  to protect user privacy.
+test_files: []