my_obfuscate 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e7f50293f88ff7eea7bdce3905110af4602229c
-  data.tar.gz: 4008d4d1bb153fde2125dabcf2afdcbef334fbdc
+  metadata.gz: c81cc9453a733909c1a906c2369cce0999e8c627
+  data.tar.gz: f218ca6b9c443c1046dafa4877b279346258101c
 SHA512:
-  metadata.gz: 77a9e4325cabd6434e89928d6c1939f914cad6bfe0289618c4a91f67a4c6d237c27a81e98ae43a5b4913b75b1504a1723cebd0f9f1829a938bcea249dd36270c
-  data.tar.gz: b55e7c9b10453a22b77c8231a2f9665393aff73bc1fbcda9bf48959ad3a1846042943dc27d7d4a96cf8c9cb991589139d5caa4323ae753a44cc1163b0b47ed3e
+  metadata.gz: fd82ab134257c31299a91e79d2363176e47ae545e0d7f88e3672a01a4f8fce2c92b4e52ee003d20c9bb82cc145840d9a15ee0fbc25d757c40127999945670cd7
+  data.tar.gz: e0698977563fc19685b32e78943cf9633aa476f92dbc25f9bbaf33987d302452bdc264774c5fa6f9900cd2a1998ebb798d229b95e56b6666d3674aa67e542d5b

data/.ruby-version

@@ -1 +1 @@
-ruby-2.1.2
+ruby-2.2.0

data/lib/my_obfuscate.rb

@@ -42,14 +42,14 @@ class MyObfuscate
     database_helper.parse(self, config, input_io, output_io)
   end
 
-  def reassembling_each_insert(line, table_name, columns)
+  def reassembling_each_insert(line, table_name, columns, ignore = nil)
     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
     end
-    database_helper.make_insert_statement(table_name, columns, output)
+    database_helper.make_insert_statement(table_name, columns, output, ignore)
   end
 
   def check_for_defined_columns_not_in_table(table_name, columns)
@@ -63,8 +63,12 @@ class MyObfuscate
     end
   end
 
+  def missing_column_list(table_name, columns)
+    columns - (config[table_name].keys + (globally_kept_columns || []).map {|i| i.to_sym}).uniq
+  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
+    missing_columns = missing_column_list(table_name, columns)
     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."
@@ -73,7 +77,7 @@ class MyObfuscate
     end
   end
 
-  def obfuscate_bulk_insert_line(line, table_name, columns)
+  def obfuscate_bulk_insert_line(line, table_name, columns, ignore = nil)
     table_config = config[table_name]
     if table_config == :truncate
       ""
@@ -83,7 +87,7 @@ class MyObfuscate
       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|
+      reassembling_each_insert(line, table_name, columns, ignore) do |row|
         ConfigApplicator.apply_table_config(row, table_config, columns)
       end
     end

data/lib/my_obfuscate/config_applicator.rb

@@ -30,42 +30,42 @@ class MyObfuscate
         row[index.to_i] = case definition[:type]
           when :email
             md5 = Digest::MD5.hexdigest(rand.to_s)[0...5]
-            clean_quotes("#{Faker::Internet.email}.#{md5}.example.com")
+            clean_quotes("#{FFaker::Internet.email}.#{md5}.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(".  ")))
+            clean_bad_whitespace(clean_quotes(FFaker::Lorem.sentences(definition[:number] || 1).join(".  ")))
           when :like_english
             clean_quotes random_english_sentences(definition[:number] || 1)
           when :name
-            clean_quotes(Faker::Name.name)
+            clean_quotes(FFaker::Name.name)
           when :first_name
-            clean_quotes(Faker::Name.first_name)
+            clean_quotes(FFaker::Name.first_name)
           when :last_name
-            clean_quotes(Faker::Name.last_name)
+            clean_quotes(FFaker::Name.last_name)
           when :address
-            clean_quotes("#{Faker::AddressUS.street_address}\\n#{Faker::AddressUS.city}, #{Faker::AddressUS.state_abbr} #{Faker::AddressUS.zip_code}")
+            clean_quotes("#{FFaker::AddressUS.street_address}\\n#{FFaker::AddressUS.city}, #{FFaker::AddressUS.state_abbr} #{FFaker::AddressUS.zip_code}")
           when :street_address
-            clean_bad_whitespace(clean_quotes(Faker::AddressUS.street_address))
+            clean_bad_whitespace(clean_quotes(FFaker::AddressUS.street_address))
           when :city
-            clean_quotes(Faker::AddressUS.city)
+            clean_quotes(FFaker::AddressUS.city)
           when :state
-            clean_quotes Faker::AddressUS.state_abbr
+            clean_quotes FFaker::AddressUS.state_abbr
           when :zip_code
-            Faker::AddressUS.zip_code
+            FFaker::AddressUS.zip_code
           when :phone
-            clean_quotes Faker::PhoneNumber.phone_number
+            clean_quotes FFaker::PhoneNumber.phone_number
           when :company
-            clean_bad_whitespace(clean_quotes(Faker::Company.name))
+            clean_bad_whitespace(clean_quotes(FFaker::Company.name))
           when :ipv4
-            Faker::Internet.ip_v4_address
+            FFaker::Internet.ip_v4_address
           when :ipv6
-            # Inlined from Faker because ffaker doesn't have ipv6.
+            # Inlined from FFaker because ffaker doesn't have ipv6.
             @@ip_v6_space ||= (0..65535).to_a
             container = (1..8).map{ |_| @@ip_v6_space.sample }
             container.map{ |n| n.to_s(16) }.join(':')
           when :url
-            clean_bad_whitespace(Faker::Internet.http_url)
+            clean_bad_whitespace(FFaker::Internet.http_url)
           when :integer
             random_integer(definition[:between] || (0..1000)).to_s
           when :fixed

data/lib/my_obfuscate/insert_statement_parser.rb

@@ -6,8 +6,9 @@ class MyObfuscate
         if table_data = parse_insert_statement(line)
           table_name = table_data[:table_name]
           columns = table_data[:column_names]
+          ignore = table_data[:ignore]
           if config[table_name]
-            output_io.puts obfuscator.obfuscate_bulk_insert_line(line, table_name, columns)
+            output_io.puts obfuscator.obfuscate_bulk_insert_line(line, table_name, columns, ignore)
           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
@@ -20,3 +21,5 @@ class MyObfuscate
 
   end
 end
+
+

data/lib/my_obfuscate/mysql.rb

@@ -5,22 +5,23 @@ class MyObfuscate
     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 }
+            :ignore     => !regex_match[1].nil?,
+            :table_name => regex_match[2].to_sym,
+            :column_names => regex_match[3].split(/`\s*,\s*`/).map { |col| col.gsub('`', "").to_sym }
         }
       end
     end
 
-    def make_insert_statement(table_name, column_names, values)
+    def make_insert_statement(table_name, column_names, values, ignore = nil)
       values_strings = values.collect do |values|
         "(" + values.join(",") + ")"
       end.join(",")
 
-      "INSERT INTO `#{table_name}` (`#{column_names.join('`, `')}`) VALUES #{values_strings};"
+      "INSERT #{ignore ? 'IGNORE ' : '' }INTO `#{table_name}` (`#{column_names.join('`, `')}`) VALUES #{values_strings};"
     end
 
     def insert_regex
-      /^\s*INSERT INTO `(.*?)` \((.*?)\) VALUES\s*/i
+      /^\s*INSERT\s*(IGNORE )?\s*INTO `(.*?)` \((.*?)\) VALUES\s*/i
     end
 
     def rows_to_be_inserted(line)

data/lib/my_obfuscate/postgres.rb

@@ -2,7 +2,7 @@ class MyObfuscate
   class Postgres
     include MyObfuscate::CopyStatementParser
 
-    # Copy statements contain the column values tab seperated like so:
+    # Copy statements contain the column values tab separated like so:
     #   blah	blah	blah	blah
     # which we want to turn into:
     #   [['blah','blah','blah','blah']]
@@ -33,7 +33,7 @@ class MyObfuscate
       end
     end
 
-    def make_insert_statement(table_name, column_names, values)
+    def make_insert_statement(table_name, column_names, values, ignore = nil)
       values.join("\t")
     end
 

data/lib/my_obfuscate/sql_server.rb

@@ -26,7 +26,7 @@ class MyObfuscate
       end
     end
 
-    def make_insert_statement(table_name, column_names, values)
+    def make_insert_statement(table_name, column_names, values, ignore = nil)
       values_strings = values.collect do |values|
         "(" + values.join(",") + ")"
       end.join(",")

data/lib/my_obfuscate/version.rb

@@ -1,3 +1,3 @@
 class MyObfuscate
-  VERSION = "0.5.3"
+  VERSION = "0.5.4"
 end

data/spec/my_obfuscate/config_applicator_spec.rb

@@ -232,11 +232,11 @@ describe MyObfuscate::ConfigApplicator do
 
     describe "when faker generates values with quotes in them" do
       before do
-        allow(Faker::Address).to receive(:city).and_return("O'ReillyTown")
-        allow(Faker::Name).to receive(:name).and_return("Foo O'Reilly")
-        allow(Faker::Name).to receive(:first_name).and_return("O'Foo")
-        allow(Faker::Name).to receive(:last_name).and_return("O'Reilly")
-        allow(Faker::Lorem).to receive(:sentences).with(any_args).and_return(["Foo bar O'Thingy"])
+        allow(FFaker::Address).to receive(:city).and_return("O'ReillyTown")
+        allow(FFaker::Name).to receive(:name).and_return("Foo O'Reilly")
+        allow(FFaker::Name).to receive(:first_name).and_return("O'Foo")
+        allow(FFaker::Name).to receive(:last_name).and_return("O'Reilly")
+        allow(FFaker::Lorem).to receive(:sentences).with(any_args).and_return(["Foo bar O'Thingy"])
       end
 
       it "should remove single quotes from the value" do

data/spec/my_obfuscate/mysql_spec.rb

@@ -73,7 +73,14 @@ describe MyObfuscate::Mysql do
 
     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);")
-      expect(hash).to eq({:table_name => :some_table, :column_names => [:email, :name, :something, :age]})
+      expect(hash).to eq({:ignore => false, :table_name => :some_table, :column_names => [:email, :name, :something, :age]})
+    end
+  end
+
+  describe "#parse_insert_ignore_statement" do
+    it "should return a hash of IGNORE, table name, column names for MySQL insert statements" do
+      hash = subject.parse_insert_statement("INSERT IGNORE INTO `some_table` (`email`, `name`, `something`, `age`) VALUES ('bob@honk.com','bob', 'some\\'thin,ge())lse1', 25),('joe@joe.com','joe', 'somethingelse2', 54);")
+      expect(hash).to eq({:ignore => true, :table_name => :some_table, :column_names => [:email, :name, :something, :age]})
     end
   end
 

data/spec/spec_helper.rb

@@ -6,5 +6,5 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'my_obfuscate'
 
 RSpec.configure do |config|
-#  config.mock_with :rr
+ config.mock_with :rspec
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: my_obfuscate
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Andrew Cantino
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-24 00:00:00.000000000 Z
+date: 2015-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffaker