strike 0.3.6 → 0.4.0

data/README.md

@@ -24,6 +24,12 @@ To generate a new dump, use the following command:
 
     $ strike dump mysql://root@localhost/db_production --profile=tables.rb > obfuscated_dump.sql
 
+To obfuscate an existing sql dump, use the following command:
+
+    $ cat original_dump.sql | strike obfuscate --profile=tables.rb > obfuscated_dump.sql
+
+It is very important to generate the mysql dump with the `-c` option.
+
 This command dumps the `database_url` following the tables defined in the `profile`
 file (defaults to `Strikefile`). The default dump output is STDOUT.
 
@@ -69,7 +75,6 @@ end
 
 * `mysqldump`: to create the dump to manipulate.
 * [my_obfuscate][my_obfuscate]: the core of this utility.
-* [Sequel][sequel]: extracts the info for the non defined tables.
 * [Thor][thor]: cli utilities.
 
 ## Notes

data/Rakefile

@@ -3,5 +3,9 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new do |t|
-  t.pattern = "test/**/*_test.rb"
+  t.pattern = "spec/**/*_spec.rb"
 end
+
+task spec: :test
+
+task default: :test

data/TODO.md

@@ -3,4 +3,3 @@
 * Log info in /var/log/strike/`database`-`timestamp`.log
 * Options
   - log: alternative log file
-* BETTER TESTS!

data/VERSION

@@ -1 +1 @@
-0.3.6
+0.4.0

data/lib/strike.rb

@@ -4,16 +4,29 @@ require 'thor'
 
 class Strike < Thor
   require 'strike/interpreter'
-  require 'strike/agent'
+  require 'strike/obfuscator'
+  require 'strike/dumper'
 
   include Thor::Actions
 
+  class_option :profile,
+               aliases:   '-p',
+               type:      :string,
+               default:   'Strikefile',
+               required:  false,
+               desc:      'Profile with the table definitions.'
+  class_option :output,
+               aliases:   '-o',
+               type:      :string,
+               required:  false,
+               desc:      'Output file. If none is given, outputs to STDOUT.'
+
   desc 'version', 'Show version'
   def version
     $stdout.puts "v#{IO.read(File.expand_path('../../VERSION', __FILE__))}"
   end
 
-  desc 'dump <database_url>', 'Dump the <database_url> to STDOUT.'
+  desc 'dump <database_url>', 'Dump the obfuscated <database_url> to --output.'
   long_desc <<-DESC
     Dump the <database_url> following the table definitions defined in the <profile>
     (defaults to `Strikefile`). The default dump output is STDOUT.
@@ -40,34 +53,95 @@ class Strike < Thor
     \x5\t  t.email         :email
     \x5\tend
   DESC
-  method_option :profile,
-                aliases:   '-p',
-                type:      :string,
-                default:   'Strikefile',
-                required:  true,
-                desc:      'Profile with the table definitions.'
-  method_option :output,
-                aliases:   '-o',
-                type:      :string,
-                required:  false,
-                desc:      'Output file. If none is given, outputs to STDOUT.'
   def dump(database_url)
-    file = options[:profile]
+    with_profile do |profile|
+      with_output do |output|
+        Dumper.new.call(self, database_url) do |dump_file|
+          _obfuscate(profile, dump_file, output)
+        end
+      end
+    end
+  end
+
+  desc 'obfuscate', 'Obfuscate a mysqldump (with -c option) from --input to --output.'
+  long_desc <<-DESC
+    Obfuscate the database dump following the table definitions defined in the <profile>
+    (defaults to `Strikefile`). The default obfuscate output is STDOUT and the input
+    is STDIN.
+
+    IMPORTANT! The mysqldump must has been generated with the `-c` option.
 
-    if options[:output]
-      modes  = File::CREAT|File::TRUNC|File::RDWR
-      output = File.new(options[:output], modes, 0644)
+    Usage example:
+
+    $ strike obfuscate < dump.sql > obfuscated-dump.sql
+
+    $ cat dump.sql | strike obfuscate > obfuscated-dump.sql --profile=tables.rb
+
+    $ strike obfuscate --input=dump.sql --output=obfuscated-dump.sql
+
+    The tables are defined with a DSL, which is a wrapper
+    arround the obfuscation types defined in the MyObfuscate gem.
+
+    Example:
+    \x5\t# tables.rb
+    \x5\ttable :users do |t|
+    \x5\t  # t.column_name :obfuscation_type
+    \x5\t  t.name          :first_name
+    \x5\t  t.email         :email
+    \x5\tend
+  DESC
+  method_option :input,
+                aliases:   '-i',
+                type:      :string,
+                required:  false,
+                desc:      'Input file. If none is given, is read from STDIN.'
+  def obfuscate
+    with_profile do |profile|
+      with_input do |input|
+        with_output do |output|
+          _obfuscate(profile, input, output)
+        end
+      end
     end
+  end
+
+  private
+
+  def _obfuscate(profile, input, output)
+    tables = Interpreter.new.parse(profile.read)
+    Obfuscator.new.call(tables, input, output)
+  end
+
+  def with_input
+    input = options[:input] ? File.open(options[:input]) : $stdin
+
+    yield input
+  ensure
+    input.close if input != $stdin
+  end
+
+  def with_output
+    output = if options[:output]
+               modes  = File::CREAT|File::TRUNC|File::RDWR
+               File.new(options[:output], modes, 0644)
+             else
+               $stdout
+             end
+
+    yield output
+  ensure
+    output.close if output != $stdout
+  end
+
+  def with_profile
+    file = options[:profile]
 
     if file && File.exist?(file)
       File.open(file) do |profile|
-        tables = Interpreter.new.parse(profile.read)
-        Agent.new.call(self, database_url, tables, output || $stdout)
+        yield profile
       end
     else
       $stderr.puts "Profile Error: No such file #{file}"
     end
-  ensure
-    output.close if output
   end
 end

data/lib/strike/dumper.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+require 'tempfile'
+require 'uri'
+
+class Strike
+  class Dumper
+    def initialize(config = {})
+      @dumpfile_source = config[:dumpfile_source]
+    end
+
+    # Dumps the data from the given database to a tmp file.
+    #
+    # @param [#run] cli the cli program that responds to `#run`.
+    # @param [String] database_url the connection info. @see `#parse_url`.
+    # @param [Proc] optional block in which the tmp file will be used.
+    #
+    # @return [nil]
+    def call(cli, database_url)
+      tempfile do |file|
+        begin
+          dump_data(cli, parse_url(database_url), file)
+          yield(file) if block_given?
+        ensure
+          file.unlink
+        end
+      end
+    end
+
+    # Converts a database_url to Hash with all the db data.
+    #
+    # Example:
+    #   parse_url('mysql://user:pass@localhost:100/test_db')
+    #
+    # @param [String] database_url the connection info.
+    #
+    # @return [Hash] the database configuration with the following fields.
+    #                {
+    #                  db_type: String || nil,
+    #                  host: String || nil,
+    #                  port: String || nil,
+    #                  user: String || nil,
+    #                  password: String || nil,
+    #                  database: String || nil,
+    #                }
+    def parse_url(database_url)
+      uri = URI.parse(database_url)
+
+      {
+        db_type:  uri.scheme.gsub(/^mysql2/, 'mysql'),
+        host:     uri.host,
+        port:     uri.port.to_s,
+        user:     uri.user,
+        password: uri.password,
+        database: uri.path.gsub(/^\//, ''),
+      }
+    end
+
+    # Create a tmp file
+    #
+    # @param [Proc] yields the file.
+    #
+    # @return [nil, Tempfile]
+    def tempfile
+      tmp = dumpfile_source.call(['original_dump', 'sql'])
+      block_given? ? yield(tmp) : tmp
+    end
+    protected :tempfile
+
+    # Tmp file generator
+    #
+    # @return [Proc] a lambda that generates the file.
+    def dumpfile_source
+      @dumpfile_source ||= Tempfile.public_method(:new)
+    end
+    protected :dumpfile_source
+
+    # Dump the data from the database configuration and
+    # outputs it to the given file.
+    #
+    # @param [#run] cli the cli program that responds to `#run`.
+    # @param [Hash] db_config database configuration from `#parse_url`.
+    # @param [Tempfile, IO, File] file the file to write the dump.
+    #
+    # @return [nil]
+    def dump_data(cli, db_config, file)
+      dump_options = %w(-c
+                        --add-drop-table
+                        --add-locks
+                        --single-transaction
+                        --set-charset
+                        --create-options
+                        --disable-keys
+                        --quick).join(' ')
+      dump_options << " -u #{db_config[:user]}" if db_config[:user]
+      dump_options << " -h #{db_config[:host]}" if db_config[:host]
+      if db_config[:port] && !db_config[:port].empty?
+        dump_options << " -P #{db_config[:port]}"
+      end
+      dump_options << " -p#{db_config[:password]}" if db_config[:password]
+      dump_options << " #{db_config[:database]}"
+
+      run cli, dump_cmd(dump_options, file)
+    end
+
+    # Dump cli command
+    def dump_cmd(options, file)
+      "mysqldump #{options} > #{file.path}"
+    end
+    protected :dump_cmd
+
+    # Run the command with the cli
+    #
+    # @param [#run] cli the cli program that responds to `#run`.
+    # @param [String] cmd the command to run.
+    #
+    # @return [nil]
+    def run(cli, cmd)
+      cli.run cmd, verbose: false, capture: true
+    end
+    protected :run
+  end
+end

data/lib/strike/interpreter.rb

@@ -8,7 +8,7 @@ class Strike
 
     def initialize(table_source = nil)
       @table_source = table_source
-      @tables ||= Hash.new { |h, k| h[k] = -> { :keep } }
+      @tables ||= Hash.new { |h, k| h[k] = :keep }
     end
 
     # Parse the given profile and generate the tables defined in it.
@@ -27,7 +27,7 @@ class Strike
     def table(name, &block)
       table = table_source.call(&block)
 
-      @tables[name.to_sym] = table
+      @tables[name.to_sym] = table.call
     end
 
     def table_source

data/lib/strike/obfuscator.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'my_obfuscate'
+
+class Strike
+  class Obfuscator
+    def initialize(config = {})
+      @adapter_source = config[:adapter_source]
+    end
+
+    # Obfuscates the data from input to output with the given information.
+    #
+    # @param [Hash] tables the tables definitions
+    # @param [IO] input the input source to read from.
+    # @param [IO] output the output source to write to.
+    #
+    # @return [nil]
+    def call(tables, input, output)
+      adapter = adapter_source.call(tables)
+      adapter.globally_kept_columns = %w(id created_at updated_at)
+
+      adapter.obfuscate(input, output)
+    end
+
+    # Adapter generator.
+    def adapter_source
+      @adapter_source ||= MyObfuscate.public_method(:new)
+    end
+    protected :adapter_source
+  end
+end

data/spec/assets/dump.sql

@@ -0,0 +1,53 @@
+-- MySQL dump 10.13  Distrib 5.5.29, for osx10.8 (i386)
+--
+-- Host: localhost    Database: example
+-- ------------------------------------------------------
+-- Server version	5.5.29
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!40101 SET NAMES utf8 */;
+/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
+/*!40103 SET TIME_ZONE='+00:00' */;
+/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
+
+--
+-- Table structure for table `devices`
+--
+
+DROP TABLE IF EXISTS `devices`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `devices` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
+  `created_at` datetime DEFAULT NULL,
+  `updated_at` datetime DEFAULT NULL,
+  PRIMARY KEY (`id`),
+) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `devices`
+--
+
+LOCK TABLES `devices` WRITE;
+/*!40000 ALTER TABLE `devices` DISABLE KEYS */;
+INSERT INTO `devices` (`id`, `name`, `created_at`, `updated_at`) VALUES (1,'Original name','2010-10-20 13:40:20','2012-08-24 06:32:31'),(2,'Original name','2010-10-20 13:40:32','2012-10-24 07:39:02'),(3,'Original name','2010-10-20 13:40:46','2012-09-13 10:17:37');
+/*!40000 ALTER TABLE `devices` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
+/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
+/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
+/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
+
+-- Dump completed on 2013-01-11 15:47:10

data/spec/assets/dump_profile.rb

@@ -0,0 +1,3 @@
+table :devices do |t|
+  t.name type: :fixed, string: proc { 'Obfuscated name' }
+end

data/spec/bin/strike_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require_relative '../minitest_helper'
+require 'strike'
+
+describe Strike, 'Use of Strike in the cli' do
+  describe '#obfuscate' do
+    let(:assets_path) { File.join(File.dirname(__FILE__), '..', 'assets') }
+    let(:input)   { "#{assets_path}/dump.sql" }
+    let(:profile) { "#{assets_path}/dump_profile.rb" }
+    let(:params)  { %W(obfuscate --input=#{input} --profile=#{profile}) }
+
+    it 'should obfuscate the sql dump' do
+      out = capture_io { Strike.start(params) }.join('')
+
+      out.wont_match /Original name/
+      # dump_profile.rb sets this string in each name
+      out.must_match /Obfuscated name/
+    end
+  end
+end

data/spec/lib/strike/dumper_spec.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+require_relative '../../minitest_helper'
+require 'strike/dumper'
+
+describe Strike::Dumper do
+  let(:database_url) { 'mysql://test:pass@localhost:3005/test' }
+  let(:database_config) do
+    {
+      db_type:  'mysql',
+      host:     'localhost',
+      port:     '3005',
+      user:     'test',
+      password: 'pass',
+      database: 'test',
+    }
+  end
+
+  let(:options) do
+    dump_options = %w(-c
+                      --add-drop-table
+                      --add-locks
+                      --single-transaction
+                      --set-charset
+                      --create-options
+                      --disable-keys
+                      --quick).join(' ')
+    dump_options << " -u #{database_config[:user]}"
+    dump_options << " -h #{database_config[:host]}"
+    dump_options << " -P #{database_config[:port]}"
+    dump_options << " -p#{database_config[:password]}"
+    dump_options << " #{database_config[:database]}"
+
+    dump_options
+  end
+
+  let(:cli) do
+    MiniTest::Mock.new.expect(
+      :run,
+      true,
+      ["mysqldump #{options} > path", { verbose: false, capture: true }]
+    )
+  end
+
+  let(:dumper) { Strike::Dumper.new }
+
+  subject { dumper }
+
+  describe '#parse_url' do
+    it 'should parse the given connection as a url' do
+      subject.parse_url(database_url).must_equal database_config
+    end
+  end
+
+  describe '#dump_data' do
+    let(:output) { MiniTest::Mock.new.expect(:path, 'path') }
+
+    it 'should dump data with the default options' do
+      subject.dump_data(cli, database_config, output).must_equal true
+    end
+
+    after do
+      output.verify
+      cli.verify
+    end
+  end
+
+  describe '#call' do
+    let(:output) do
+      MiniTest::Mock.new.
+        expect(:path, 'path').
+        expect(:unlink, true).
+        expect(:must_equal, true, [MiniTest::Mock])
+    end
+
+    let(:dumpfile_source) do
+      MiniTest::Mock.new.expect(:call, output, [['original_dump', 'sql']])
+    end
+
+    let(:dumper) { Strike::Dumper.new(dumpfile_source: dumpfile_source) }
+
+    it 'should generate dump file with default options and a database_url' do
+      subject.call(cli, database_url) do |file|
+        file.must_equal output
+      end
+    end
+
+    after do
+      dumpfile_source.verify
+      output.verify
+      cli.verify
+    end
+  end
+end

data/spec/lib/strike/interpreter_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require_relative '../../minitest_helper'
+require 'strike/interpreter'
+
+describe Strike::Interpreter do
+
+  let(:table_users) { { name: :keep } }
+  let(:table_movies) { :keep }
+
+  let(:table_source) do
+    ->(&block) { block ? block.call(table_mock) : -> { table_movies } }
+  end
+
+  let(:table_users) { {name: :keep } }
+
+  let(:table_mock) do
+    tb = MiniTest::Mock.new.expect(:call, table_users)
+
+    MiniTest::Mock.new.expect(:name, tb, [:first_name])
+  end
+
+  let(:profile) do
+    <<-PROFILE
+    table :users do |t|
+      t.name :first_name
+    end
+
+    table :movies
+    PROFILE
+  end
+
+  subject { Strike::Interpreter.new(table_source) }
+
+  describe '#parse' do
+    let(:tables) { subject.parse(profile) }
+
+    it 'should parse all profile tables' do
+      tables.count.must_equal 2
+    end
+
+    it 'should parse tables with a block' do
+      tables[:users].must_equal table_users
+      table_mock.verify
+    end
+
+    it 'should parse tables without a block' do
+      tables[:movies].must_equal table_movies
+    end
+  end
+
+  describe '#tables' do
+    let(:tables) { subject.tables }
+
+    it 'should have default tables' do
+      tables[:test].must_equal :keep
+      tables[:test2].must_equal :keep
+    end
+  end
+end

data/spec/lib/strike/obfuscator_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require_relative '../../minitest_helper'
+require 'strike/obfuscator'
+
+describe Strike::Obfuscator do
+  let(:input)  { Object.new }
+  let(:output) { Object.new }
+  let(:tables) { { users: :keep, movies: :keep } }
+  let(:adapter_mock) do
+    MiniTest::Mock.new.
+      expect(:globally_kept_columns=, true, [%w(id created_at updated_at)]).
+      expect(:obfuscate, true, [input, output])
+  end
+  let(:adapter_source) do
+    MiniTest::Mock.new.expect(:call, adapter_mock, [tables])
+  end
+
+  let(:obfuscator) { Strike::Obfuscator.new(adapter_source: adapter_source) }
+
+  subject { obfuscator }
+
+  describe '#call' do
+    it 'should prepare the adapter and call it' do
+      subject.call(tables, input, output).must_equal true
+    end
+
+    after do
+      adapter_source.verify
+      adapter_mock.verify
+    end
+  end
+end

data/spec/lib/strike/table_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require_relative '../../minitest_helper'
+require 'strike/table'
+
+describe Strike::Table do
+  let(:hash) { { name: :test } }
+  let(:table) { Strike::Table.new }
+
+  subject { table }
+
+  describe '#method_missing' do
+    it 'should respond to missing methods' do
+      subject.name(:test).wont_be_nil
+      subject.test.wont_be_nil
+    end
+  end
+
+  describe '#to_hash' do
+    before { subject.name(:test) }
+
+    it 'should save method calls as hash' do
+      subject.to_hash.must_equal hash
+    end
+  end
+
+  describe '#initialize' do
+    let(:table) do
+      Strike::Table.new do |t|
+        t.name :test
+      end
+    end
+
+    it 'should accept a block' do
+      subject.to_hash.must_equal hash
+    end
+  end
+
+  describe '#call' do
+    it 'should respond with a Hash' do
+      subject.call.must_equal Hash.new
+    end
+  end
+end

data/strike.gemspec

@@ -3,8 +3,8 @@
 Gem::Specification.new do |gem|
   gem.authors       = ['Juan Hernández']
   gem.email         = ['juan.hernandez@wuaki.tv']
-  gem.description   = %q{Dump a mysql database with sensitive data encrypted}
-  gem.summary       = %q{Dump a mysql database with sensitive data encrypted}
+  gem.description   = %q{Obfuscate a mysql dump database with sensitive data}
+  gem.summary       = %q{Dump and obfuscate a mysql database with sensitive data}
   gem.homepage      = 'https://github.com/wuakitv/strike'
 
   gem.files         = `git ls-files`.split($\)
@@ -16,8 +16,5 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency 'rake',         '~> 0.9'
   gem.add_runtime_dependency 'my_obfuscate', '~> 0.3.7'
-  gem.add_runtime_dependency 'sequel',       '~> 3.39'
-  gem.add_runtime_dependency 'mysql2',       '~> 0.3.11'
-  gem.add_runtime_dependency 'sqlite3',      '~> 1.3.6'
   gem.add_runtime_dependency 'thor',         '~> 0.16.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strike
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-27 00:00:00.000000000 Z
+date: 2013-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -43,54 +43,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.3.7
-- !ruby/object:Gem::Dependency
-  name: sequel
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3.39'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3.39'
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.3.11
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.3.11
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.3.6
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.3.6
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -107,7 +59,7 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.16.0
-description: Dump a mysql database with sensitive data encrypted
+description: Obfuscate a mysql dump database with sensitive data
 email:
 - juan.hernandez@wuaki.tv
 executables:
@@ -125,13 +77,19 @@ files:
 - VERSION
 - bin/strike
 - lib/strike.rb
-- lib/strike/agent.rb
+- lib/strike/dumper.rb
 - lib/strike/interpreter.rb
+- lib/strike/obfuscator.rb
 - lib/strike/table.rb
+- spec/assets/dump.sql
+- spec/assets/dump_profile.rb
+- spec/bin/strike_spec.rb
+- spec/lib/strike/dumper_spec.rb
+- spec/lib/strike/interpreter_spec.rb
+- spec/lib/strike/obfuscator_spec.rb
+- spec/lib/strike/table_spec.rb
+- spec/minitest_helper.rb
 - strike.gemspec
-- test/lib/strike/interpreter_test.rb
-- test/lib/strike/table_test.rb
-- test/minitest_helper.rb
 homepage: https://github.com/wuakitv/strike
 licenses: []
 post_install_message: 
@@ -155,8 +113,13 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Dump a mysql database with sensitive data encrypted
+summary: Dump and obfuscate a mysql database with sensitive data
 test_files:
-- test/lib/strike/interpreter_test.rb
-- test/lib/strike/table_test.rb
-- test/minitest_helper.rb
+- spec/assets/dump.sql
+- spec/assets/dump_profile.rb
+- spec/bin/strike_spec.rb
+- spec/lib/strike/dumper_spec.rb
+- spec/lib/strike/interpreter_spec.rb
+- spec/lib/strike/obfuscator_spec.rb
+- spec/lib/strike/table_spec.rb
+- spec/minitest_helper.rb

data/lib/strike/agent.rb

@@ -1,106 +0,0 @@
-# encoding: utf-8
-
-require 'tempfile'
-require 'mysql2'
-require 'sequel'
-require 'my_obfuscate'
-
-class Strike
-  class Agent
-    def initialize(config = {})
-      @db_connector      = config[:db_connector]
-      @dumpfile_source   = config[:dumpfile_source]
-      @obfuscator_source = config[:obfuscator_source]
-    end
-
-    def connect_to_db(database_url)
-      db_connector.call(database_url.gsub(/^mysql:/, 'mysql2:'))
-    end
-    protected :connect_to_db
-
-    def db_connector
-      @db_connector ||= Sequel.public_method(:connect)
-    end
-    protected :db_connector
-
-    def call(cli, database_url, tables, output = $stdout)
-      @cli    = cli
-      @db     = connect_to_db(database_url)
-      @tables = tables
-
-      tempfile do |file|
-        dump_data(@db.opts, file)
-        obfuscate_data(file, output)
-      end
-    end
-
-    def tempfile(&block)
-      tmp = dumpfile_source.call(['original_dump', 'sql']) do |file|
-        block.call(file)
-        file
-      end
-    ensure
-      tmp.unlink if tmp
-    end
-    protected :tempfile
-
-    def dumpfile_source
-      @dumpfile_source ||= Tempfile.public_method(:open)
-    end
-    protected :dumpfile_source
-
-    # TODO: support more databases
-    def dump_data(db_config, file)
-      dump_options = %w(-c
-                        --add-drop-table
-                        --add-locks
-                        --single-transaction
-                        --set-charset
-                        --create-options
-                        --disable-keys
-                        --quick).join(' ')
-      dump_options << " -u #{db_config[:user]}" if db_config[:user]
-      dump_options << " -h #{db_config[:host]}" if db_config[:host]
-      dump_options << " -P #{db_config[:port]}" if db_config[:port]
-      dump_options << " -p#{db_config[:password]}" if db_config[:password]
-      dump_options << " #{db_config[:database]}"
-
-      run dump_cmd(dump_options, file)
-    end
-
-    def dump_cmd(options, file)
-      "mysqldump #{options} > #{file.path}"
-    end
-    protected :dump_cmd
-
-    def run(cmd)
-      @cli.run cmd, verbose: false, capture: true
-    end
-    protected :run
-
-    def obfuscate_data(input, output)
-      obfuscator = obfuscator_source.call(table_definitions)
-      obfuscator.globally_kept_columns = %w(id created_at updated_at)
-
-      obfuscator.obfuscate(input, output)
-    end
-
-    def obfuscator_source
-      @obfuscator_source ||= MyObfuscate.public_method(:new)
-    end
-    protected :obfuscator_source
-
-    def table_definitions
-      db_tables.reduce({}) do |acc, table|
-        acc[table] = @tables[table].call
-        acc
-      end
-    end
-    protected :table_definitions
-
-    def db_tables
-      @db.tables
-    end
-    protected :db_tables
-  end
-end

data/test/lib/strike/interpreter_test.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-require_relative '../../minitest_helper'
-require 'strike/interpreter'
-
-class Strike::InterpreterTest < MiniTest::Unit::TestCase
-  def setup
-    @interpreter = Strike::Interpreter.new(table_source)
-    @profile = <<-PROFILE
-    table :users do |t|
-      t.name :first_name
-    end
-
-    table :movies
-    PROFILE
-  end
-
-  def test_should_parse_a_profile_into_tables
-    tables = @interpreter.parse(@profile)
-
-    assert_equal 2, tables.count
-    assert tables[:users]
-    assert tables[:movies]
-
-    table_mock.verify
-  end
-
-  def test_should_have_default_tables
-    tables = @interpreter.tables
-
-    assert_equal :keep, tables[:test].call
-    assert_equal :keep, tables[:test2].call
-  end
-
-  private
-
-  def table_source
-    ->(&block) { block ? block.call(table_mock) : table_mock }
-  end
-
-  def table_mock
-    @table_mock ||= MiniTest::Mock.new.expect(:name, true, [:first_name])
-  end
-end

data/test/lib/strike/table_test.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-require_relative '../../minitest_helper'
-require 'strike/table'
-
-class Strike::TableTest < MiniTest::Unit::TestCase
-  def setup
-    @table = Strike::Table.new
-  end
-
-  def test_should_respond_to_missing_methods
-    assert @table.name(:test)
-    assert @table.test
-  end
-
-  def test_should_save_method_calls_as_hash
-    expected = { name: :test }
-    @table.name(:test)
-
-    assert_equal expected, @table.to_hash
-  end
-
-  def test_should_respond_to_call
-    assert_equal Hash.new, @table.call
-  end
-
-  def test_should_accept_a_block_when_its_initialized
-    table = Strike::Table.new do |t|
-      t.name :test
-    end
-    expected = { name: :test }
-
-    assert_equal expected, table.to_hash
-  end
-end