data-anonymization 0.3.0 → 0.5.0

data/lib/strategy/field/number/random_float_delta.rb

@@ -1,6 +1,12 @@
 module DataAnon
   module Strategy
     module Field
+
+      # Shifts the current value randomly within given delta + and -. Default is 10.0
+      #
+      #    !!!ruby
+      #    anonymize('points').using FieldStrategy::RandomFloatDelta.new(2.5)
+
       class RandomFloatDelta
 
         def initialize delta = 10.0

data/lib/strategy/field/number/random_integer.rb

@@ -2,6 +2,10 @@ module DataAnon
   module Strategy
     module Field
 
+      # Generates random integer number between given two numbers. Default range is 0 to 100.
+      #
+      #    !!!ruby
+      #    anonymize('Age').using FieldStrategy::RandomInteger.new(18,70)
 
       class RandomInteger
 

data/lib/strategy/field/number/random_integer_delta.rb

@@ -1,6 +1,12 @@
 module DataAnon
   module Strategy
     module Field
+
+      # Shifts the current value randomly within given delta + and -. Default is 10
+      #
+      #    !!!ruby
+      #    anonymize('Age').using FieldStrategy::RandomIntegerDelta.new(2)
+
       class RandomIntegerDelta
 
         def initialize delta = 10

data/lib/strategy/field/string/formatted_string_numbers.rb

@@ -2,21 +2,25 @@ module DataAnon
   module Strategy
     module Field
 
+      # Keeping the format same it changes each digit in the string with random digit.
+      #
+      #    !!!ruby
+      #    anonymize('CreditCardNumber').using FieldStrategy::FormattedStringNumber.new
 
       class FormattedStringNumber
 
         def anonymize field
-          @original_phone_number = field.value
-          @anonymized_phone_number = ""
-          @original_phone_number.each_char do |char|
+          @original_string = field.value
+          @anonymized_string = ""
+          @original_string.each_char do |char|
             if /\d/.match(char).nil?
-              @anonymized_phone_number += char
+              @anonymized_string += char
             else
-              @anonymized_phone_number += DataAnon::Utils::RandomInt.generate(0,9).to_s
+              @anonymized_string += DataAnon::Utils::RandomInt.generate(0,9).to_s
             end
           end
 
-          @anonymized_phone_number
+          @anonymized_string
         end
 
       end

data/lib/strategy/field/string/lorem_ipsum.rb

@@ -2,6 +2,15 @@ module DataAnon
   module Strategy
     module Field
 
+      # Default anonymization strategy for `string` content. Uses default 'Lorem ipsum...' text or text supplied in strategy to generate same length string.
+      #    !!!ruby
+      #    anonymize('UserName').using FieldStrategy::LoremIpsum.new
+      #
+      #    !!!ruby
+      #    anonymize('UserName').using FieldStrategy::LoremIpsum.new("very large string....")
+      #
+      #    !!!ruby
+      #    anonymize('UserName').using FieldStrategy::LoremIpsum.new(File.read('my_file.txt'))
 
       class LoremIpsum
 

data/lib/strategy/field/string/random_formatted_string.rb

@@ -0,0 +1,39 @@
+module DataAnon
+  module Strategy
+    module Field
+
+      # Keeping the format same it changes each digit with random digit, character with character preserving the case.
+      #
+      #    !!!ruby
+      #    anonymize('PhoneNumber').using FieldStrategy::RandomFormattedString.new
+      #    anonymize('Email').using FieldStrategy::RandomFormattedString.new
+
+      class RandomFormattedString
+
+        SMALL_CHARS = "abcdefghjkmnpqrstuvwxyz"
+        CAPS_CHARS = "ABCDEFGHJKLMNPQRSTUVWXYZ"
+
+        def anonymize field
+          @original_string = field.value
+          @anonymized_string = ""
+          @original_string.each_char do |char|
+            if /\d/.match(char)
+              @anonymized_string += DataAnon::Utils::RandomInt.generate(0, 9).to_s
+            elsif /[a-z]/.match(char)
+              @anonymized_string += SMALL_CHARS[rand(SMALL_CHARS.length)]
+            elsif /[A-Z]/.match(char)
+              @anonymized_string += CAPS_CHARS[rand(CAPS_CHARS.length)]
+            else
+              @anonymized_string += char
+            end
+          end
+
+          @anonymized_string
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/strategy/field/string/random_string.rb

@@ -1,6 +1,12 @@
 module DataAnon
   module Strategy
     module Field
+
+      # Generates random string of same length.
+      #
+      #   !!!ruby
+      #   anonymize('UserName').using FieldStrategy::RandomString.new
+
       class RandomString
 
         def anonymize field

data/lib/strategy/field/string/random_url.rb

@@ -1,7 +1,13 @@
 module DataAnon
   module Strategy
     module Field
-      class RandomUrl
+
+      # Generates a randomized URL while maintaining the structure of the original url
+      #
+      #    !!!ruby
+      #    anonymize('fb_profile').using FieldStrategy::RandomURL.new
+
+    class RandomUrl
 
         def anonymize field
 

data/lib/strategy/field/string/select_from_database.rb

@@ -2,7 +2,13 @@ module DataAnon
   module Strategy
     module Field
 
-      class SelectFromDatabase
+      # Similar to SelectFromList with difference is the list of values are collected from the database table using distinct column query.
+      #
+      #    !!!ruby
+      #    # values are collected using `select distinct state from customers` query
+      #    anonymize('State').using FieldStrategy::SelectFromDatabase.new('customers','state')
+
+      class SelectFromDatabase < SelectFromFile
         include Utils::Logging
 
         def initialize table_name, field_name, connection_spec
@@ -13,10 +19,6 @@ module DataAnon
 
         end
 
-        def anonymize field
-          @values[DataAnon::Utils::RandomInt.generate(0,(@values.length - 1))]
-        end
-
       end
 
 

data/lib/strategy/field/string/select_from_file.rb

@@ -2,6 +2,12 @@ module DataAnon
   module Strategy
     module Field
 
+      # Similar to SelectFromList only difference is the list of values are picked up from file. Classical usage is like states field anonymization.
+      #
+      #    !!!ruby
+      #    anonymize('State').using FieldStrategy::SelectFromFile.new('states.txt')
+      #
+
       class SelectFromFile
 
         def initialize file_path
@@ -9,6 +15,7 @@ module DataAnon
         end
 
         def anonymize field
+          return @values.sample(field.value.length) if field.value.kind_of? Array
           @values.sample
         end
 

data/lib/strategy/field/string/select_from_list.rb

@@ -2,6 +2,14 @@ module DataAnon
   module Strategy
     module Field
 
+      # Select randomly one of the values specified.
+      #
+      #    !!!ruby
+      #    anonymize('State').using FieldStrategy::SelectFromList.new(['New York','Georgia',...])
+      #
+      #    !!!ruby
+      #    anonymize('NameTitle').using FieldStrategy::SelectFromList.new(['Mr','Mrs','Dr',...])
+      #
 
       class SelectFromList < SelectFromFile
 

data/lib/strategy/field/string/string_template.rb

@@ -2,6 +2,17 @@ module DataAnon
   module Strategy
     module Field
 
+      # Simple string evaluation within [DataAnon::Core::Field](#dataanon-core-field) context. Can be used for email, username anonymization.
+      # Make sure to put the string in 'single quote' else it will get evaluated inline.
+      #
+      #    !!!ruby
+      #    anonymize('UserName').using FieldStrategy::StringTemplate.new('user#{row_number}')
+      #
+      #    !!!ruby
+      #    anonymize('Email').using FieldStrategy::StringTemplate.new('valid.address+#{row_number}@gmail.com')
+      #
+      #    !!!ruby
+      #    anonymize('Email').using FieldStrategy::StringTemplate.new('useremail#{row_number}@mailinator.com')
 
       class StringTemplate
 

data/lib/strategy/mongodb/anonymize_field.rb

@@ -0,0 +1,44 @@
+module DataAnon
+  module Strategy
+    module MongoDB
+      class AnonymizeField
+
+        def initialize field, field_strategy, anonymization_strategy
+          @field = field
+          @field_strategy = field_strategy
+          @anonymization_strategy = anonymization_strategy
+        end
+
+        def anonymize
+          if sub_document?
+            @anonymization_strategy.anonymize_document(@field.value, @field.row_number, @field_strategy)
+          elsif sub_documents?
+            anonymize_sub_documents
+          else
+            anonymize_field
+          end
+        end
+
+        def anonymize_sub_documents
+          @field.value.collect { |value| @anonymization_strategy.anonymize_document(value, @field.row_number, @field_strategy) }
+        end
+
+        def anonymize_field
+          @field_strategy = @field_strategy || @anonymization_strategy.default_strategy(@field.name)
+          raise "Improper fields strategy defined for '#{@field.name}' within document \n #{@field.ar_record}" unless @field_strategy.respond_to?(:anonymize)
+          @field_strategy.anonymize(@field)
+        end
+
+        def sub_documents?
+          @field.value.kind_of?(Array) && @field.value[0].kind_of?(Hash)
+        end
+
+        def sub_document?
+          @field.value.kind_of? Hash
+        end
+
+
+      end
+    end
+  end
+end

data/lib/strategy/mongodb/blacklist.rb

@@ -0,0 +1,29 @@
+module DataAnon
+  module Strategy
+    module MongoDB
+      class Blacklist < DataAnon::Strategy::MongoDB::Whitelist
+
+        def self.whitelist?
+          false
+        end
+
+        def process_record index, document
+          source_collection.save anonymize_document(document, index, @fields)
+        end
+
+        def anonymize_document document, index, field_strategies = {}
+          field_strategies.each do |field_name, field_strategy|
+            field_value = document[field_name]
+            unless field_value.nil?
+              field = DataAnon::Core::Field.new(field_name, field_value, index, document, @name)
+              document[field.name] = AnonymizeField.new(field, field_strategy, self).anonymize
+            end
+          end
+          document
+        end
+
+      end
+
+    end
+  end
+end

data/lib/strategy/mongodb/whitelist.rb

@@ -0,0 +1,62 @@
+require 'mongo'
+
+class Mongo::Collection
+  alias :all :find
+end
+
+module DataAnon
+  module Strategy
+    module MongoDB
+      class Whitelist < DataAnon::Strategy::Base
+
+        def self.whitelist?
+          true
+        end
+
+        def collection field, &block
+          whitelist = self.class.new @source_database, @destination_database, @name, @user_strategies
+          whitelist.process_fields &block
+          @fields[field] = whitelist.fields
+        end
+
+        alias :document :collection
+
+        def mongo_collection(database)
+          options = database[:options] || {}
+          Mongo::Connection.from_uri(database[:mongodb_uri], options)[database[:database]][@name]
+        end
+
+        def dest_collection
+          database = @destination_database
+          @dest_collection ||= mongo_collection(database)
+        end
+
+        def source_collection
+          @source_collection ||= mongo_collection(@source_database)
+        end
+
+        alias :source_table :source_collection
+        alias :dest_table :dest_collection
+
+        def process_record index, document
+          dest_collection.insert anonymize_document(document, index, @fields)
+        end
+
+        def anonymize_document document, index, field_strategies = {}
+          anonymized_document = {}
+          document.each do |field_name, field_value|
+            field_strategy = field_strategies[field_name.downcase] if field_strategies.kind_of?(Hash)
+            unless field_value.nil?
+              field = DataAnon::Core::Field.new(field_name, field_value, index, document, @name)
+              anonymized_document[field.name] = AnonymizeField.new(field, field_strategy, self).anonymize
+            end
+          end
+          anonymized_document
+        end
+
+
+      end
+
+    end
+  end
+end

data/lib/strategy/strategies.rb

@@ -1,4 +1,13 @@
 require 'strategy/base'
 require 'strategy/whitelist'
 require 'strategy/blacklist'
-require 'strategy/field/fields'
+require 'strategy/field/fields'
+
+begin
+  require 'mongo'
+  require 'strategy/mongodb/anonymize_field'
+  require 'strategy/mongodb/whitelist'
+  require 'strategy/mongodb/blacklist'
+rescue LoadError
+  "Ignoring the mongodb specific libraries if monog driver is not specified in gem"
+end

data/lib/strategy/whitelist.rb

@@ -2,12 +2,16 @@ module DataAnon
   module Strategy
     class Whitelist < DataAnon::Strategy::Base
 
+      def self.whitelist?
+        true
+      end
+
       def process_record(index, record)
         dest_record_map = {}
         record.attributes.each do |field_name, field_value|
           unless field_value.nil? || is_primary_key?(field_name)
-            field = DataAnon::Core::Field.new(field_name, field_value, index, record)
-            field_strategy = @fields[field_name.downcase] || DataAnon::Strategy::Field::DefaultAnon.new(@user_strategies)
+            field = DataAnon::Core::Field.new(field_name, field_value, index, record, @name)
+            field_strategy = @fields[field_name.downcase] || default_strategy(field_name)
             dest_record_map[field_name] = field_strategy.anonymize(field)
           end
         end
@@ -18,6 +22,7 @@ module DataAnon
         dest_record.save!
       end
 
+
     end
   end
 end

data/lib/thor/helpers/mongodb_dsl_generator.rb

@@ -0,0 +1,66 @@
+require 'erb'
+require 'thor'
+
+module DataAnon
+  module ThorHelpers
+    class MongoDBDSLGenerator
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      def initialize(configuration_hash, whitelist_patterns)
+        @mongodb_uri = DataAnon::Utils::TemplateHelper.mongo_uri(configuration_hash)
+        @whitelist_patterns = whitelist_patterns || [/^_/,/_at$/,/_id$/,/_type$/]
+        @configuration_hash = configuration_hash
+        @output = []
+      end
+
+      def generate
+
+        db = Mongo::Connection.from_uri(@mongodb_uri)[@configuration_hash[:database]]
+        collections = db.collections
+        collections.each do |collection|
+          unless collection.name.start_with?('system.')
+            depth = 2
+            @output << "\tcollection '#{collection.name}' do"
+            document = collection.find_one
+            process_document(depth, document)
+            @output << "\tend\n"
+          end
+        end
+
+        erb = ERB.new( File.new(RDBMSDSLGenerator.source_root + "/../templates/mongodb_whitelist_template.erb").read, nil, '-')
+        File.open('mongodb_whitelist_generated.rb', 'w') do |f|
+          f.write erb.result(binding)
+          f.close
+        end
+
+      end
+
+      def process_document(depth, document)
+        return if document.nil?
+        document.each do |key, value|
+          @output << ("\t"*depth)
+          if value.kind_of?(Hash)
+            end_statement = @output[-1]+"end"
+            @output[-1] << "document '#{key}' do"
+            process_document depth+1, value
+            @output << end_statement
+          elsif value.kind_of?(Array) && value[0].kind_of?(Hash)
+            end_statement = @output[-1]+"end"
+            @output[-1] << "collection '#{key}' do"
+            process_document depth+1, value[0]
+            @output << end_statement
+          elsif @whitelist_patterns.collect { |pattern| key.match(pattern) }.compact.length > 0
+            @output[-1] << "whitelist '#{key}'"
+          elsif
+            @output[-1] << "anonymize '#{key}'"
+          end
+        end
+      end
+
+    end
+  end
+end
+