my_obfuscate 0.2.2 → 0.3.0

data/README.rdoc

@@ -26,8 +26,8 @@ Make an obfuscator.rb script:
       :photo_content_type        => { :type => :null },
       :photo_file_size           => { :type => :null },
       :photo_updated_at          => { :type => :null },
-      :postal_code               => { :type => :fixed, :string => "94109" },
-      :name                      => { :type => :fixed, :string => "Production User" },
+      :postal_code               => { :type => :fixed, :string => "94109", :unless => lambda {|person| person[:postal_code] == "12345"} },
+      :name                      => { :type => :fixed, :string => "Production User", :if => lambda {|person| person[:email] == "hello@example.com"} },
       :relationship_status       => { :type => :fixed, :one_of => ["Single", "Divorced", "Married", "Engaged", "In a Relationship"] },
       :has_children              => { :type => :integer, :between => 0..1 },
     },
@@ -47,7 +47,7 @@ And to get an obfuscated dump:
 Note that the -c option on mysqldump is required to use my_obfuscator.
 
 == 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.

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/lib/my_obfuscate.rb

@@ -25,7 +25,7 @@ class MyObfuscate
         table_name = regex_result[1].to_sym
         columns = regex_result[2].split(/`\s*,\s*`/).map { |col| col.gsub('`',"").to_sym }
         if config[table_name]
-          output_io.puts obfuscate_line(line, table_name, columns)
+          output_io.puts obfuscate_bulk_insert_line(line, table_name, columns)
         else
           output_io.write line
         end
@@ -108,12 +108,22 @@ class MyObfuscate
     output
   end
 
+  def self.row_as_hash(row, columns)
+    columns.zip(row).inject({}) {|m, (name, value)| m[name] = value; m}
+  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)
 
+      next if definition[:unless] && definition[:unless].call(row_hash)
+      if definition[:if]
+        next unless definition[:if].call(row_hash)
+      end
+
       if definition[:skip_regexes]
         next if definition[:skip_regexes].any? {|regex| row[index] =~ regex}
       end
@@ -162,7 +172,7 @@ class MyObfuscate
     end
   end
 
-  def obfuscate_line(line, table_name, columns)
+  def obfuscate_bulk_insert_line (line, table_name, columns)
     table_config = config[table_name]
     if table_config == :truncate
       ""

data/my_obfuscate.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{my_obfuscate}
-  s.version = "0.2.2"
+  s.version = "0.3.0"
 
   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-01}
+  s.date = %q{2009-10-09}
   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 = [

data/spec/my_obfuscate_spec.rb

@@ -69,6 +69,50 @@ describe MyObfuscate do
       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"
+      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"
+      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
@@ -104,6 +148,12 @@ describe MyObfuscate do
 
   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
     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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: my_obfuscate
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors: 
 - Andrew Cantino
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-01 00:00:00 -07:00
+date: 2009-10-09 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency