fake_pipe 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12b4fbe781cae0694881681c54759347c3aa6f7f
+  data.tar.gz: 31b8a828b0ceb197988aecb655bbd9baa9211741
+SHA512:
+  metadata.gz: 9f9b1f9ead0f631a875b6bcfba1573d6dedb77a83ebb1e0b05362bb6a07bf1063d52835e37559a361db97474feec1bf879c77c978b60ce5fb9b7765c8324a332
+  data.tar.gz: b9ea9be17454c4ac8ec51c59207c9c510e0a6d7da7029e126f9579e5e2f65fa667b9dd3d5caa4d38f33788f8142f22c4a1ea4db04b111edda165d011ea5595b3

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# SQL files don't belong in root
+/*.sql

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,26 @@
+AllCops:
+  TargetRubyVersion: 2.2
+Rails:
+  Enabled: true
+Encoding:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Style/AndOr:
+  EnforcedStyle: conditionals
+Style/CaseEquality:
+  Enabled: false
+Style/ConditionalAssignment:
+  Enabled: false
+Style/GuardClause:
+  Enabled: false
+Style/SingleLineBlockParams:
+  Enabled: false
+Style/StringLiterals:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fake_pipe.gemspec
+gemspec
+
+group :development do
+  gem 'pry'
+end
+
+group :test do
+  gem 'guard'
+  gem 'guard-rspec'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Scott Pierce
+
+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.md

@@ -0,0 +1,124 @@
+# Overview
+
+We need a simply way to [anonymize data](https://en.wikipedia.org/wiki/Data_anonymization)
+for exporting to various departments for analytics and troubleshooting.  This tool
+allows us to annotate a DB schema with special comments that can trigger
+different data mutations
+
+FakePipe
+
+## Workflow with FakePipe
+
+Here's how FakePipe could work in a projects lifecycle. These steps assume a
+Postgres database:
+
+1. Add comment to table column: `COMMENT ON COLUMN user.phone IS 'anon: phone_number';`.
+2. Pipe DB dump to fake_pipe: `pg_dump my_db | fake_pipe > anon-db-dump.sql`.
+3. Send `anon-db-dump.sql` to needy people.
+
+
+## Basic Class Diagram
+
+TODO This is subject to change!
+
+    +---------------+       +----------------------------------+
+    | Piper         |       | DatabaseAdapter/PostgresAdapter  |
+    | * stdin       |       | * match comments                 |
+    | * stdout      +-------> * match dml                      |
+    | * main loop   |       |   * delegate.on_cell(name, cell) |
+    | * def on_cell |       |                                  |
+    |               |       +----------------------------------+
+    |               |
+    |               |       +-----------------+
+    |               |       | Mutator         |
+    |               +-------> * phone_number  |
+    +---------------+       | * email         |
+                            |                 |
+                            +-----------------+
+
+# Comment Dialect
+
+Schema columns comments are in [YAML format](http://www.yaml.org/start.html).
+Using some of it's option quoting, it can look very much like JSON. The reason
+it was chosen over JSON is due for the optional quotes. That means the following
+syntax will resolve to the same Ruby definition:
+
+```
+---
+color: red
+width: 100
+```
+
+```
+{color: "red", width: 100}
+```
+
+For single options, the quotes can be omitted: `color: red`.
+
+Any keys unknown by FakePipe will be ignored. So annotations from other system
+shouldn't interfere. We do hope the abbreviated YAML syntax is simple to parse
+by all systems.
+
+## Currently Support FakePipe Methods
+
+To get a current list try running `rake methods` from terminal.
+
+```sh
+$ rake methods
+anon: email         # Faker email
+anon: md5           # MD5 hash of cell contents
+anon: phone_number  # Faker::PhoneNumber with digits only
+```
+
+TODO clean up README. The following is default stock from `bundle gem ...`
+
+
+# Decisions
+- 2016-06-08
+  - parsing SQL file is okay for now. Reconsider using a temp DB when
+    foreign keys need to be scrambled
+  - MD5sum foreign keys
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fake_pipe'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fake_pipe
+
+## Usage
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake spec` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/centro/fake_pipe.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+desc 'List supported FakePipe methods'
+task :methods do
+  require 'fake_pipe'
+  methods = FakePipe::Mutator.list_with_comments
+  longest_name = methods.map(&:first).max_by(&:size)
+  puts methods.map { |m, c| "anon: #{m.ljust(longest_name.size)}  #{c}" }
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'fake_pipe'
+require 'pry'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/fake_pipe

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'fake_pipe'
+
+FakePipe.pipe(io: ARGF)

data/fake_pipe.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fake_pipe/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fake_pipe'
+  spec.version       = FakePipe::VERSION
+  spec.authors       = ['Scott Pierce']
+  spec.email         = ['ddrscott@gmail.com']
+
+  spec.summary       = 'db_dump.sql | fake_pipe > fake_dump.sql'
+  spec.homepage      = 'https://github.com/centro/fake_pipe'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'faker'
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/fake_pipe/any_block.rb

@@ -0,0 +1,22 @@
+module FakePipe
+  # Catch all text block.
+  # Generic base state while a more interesting text block is not present.
+  class AnyBlock < TextBlock
+  
+    def match_start_text(line)
+      true
+    end
+
+    def start_text?
+      true
+    end
+
+    def end_text?(line)
+      true
+    end
+
+    def parse(line)
+      line
+    end
+  end
+end

data/lib/fake_pipe/commenter.rb

@@ -0,0 +1,65 @@
+module FakePipe
+  # Provides helper migration method to set a valid fake_pipe comment.
+  # Currently this only supports the follwing DB adapter types:
+  #   postgres
+  #
+  # To support more implement aa private `execute_comment_<dialect>` method.
+  module Commenter
+    # Generates an fake_pipe comment for the give table and column.
+    # This is uses `reversible` so it should be safe to use within a `change`
+    # style migration.
+    #
+    # @params [String] table to apply the comment
+    # @params [String] column to apply the comment
+    # @params [String] mutator strategy to apply
+    def anonymize_comment(table, column, mutator)
+      validate_mutator!(mutator)
+      comment_updater.call(table: table, column: column, mutator: mutator)
+    end
+
+    private
+
+    def validate_mutator!(mutator)
+      Mutator.list.include?(mutator) or
+        raise "Mutator #{mutator} is not valid. Try one of: #{Mutator.list}"
+    end
+
+    def comment_updater
+      meth = "execute_comment_#{dialect}"
+      if respond_to?(meth, true)
+        method(meth)
+      else
+        raise NotImplementedError,
+              "DB dialect `#{dialect}` not supported. Try one of: #{supported_dialects}"
+      end
+    end
+
+    def execute_comment_postgresql(table:, column:, mutator:)
+      reversible do |dir|
+        dir.up do
+          execute "COMMENT ON COLUMN #{table}.#{column} IS #{formatted_comment(mutator)};"
+        end
+        dir.down do
+          execute "COMMENT ON COLUMN #{table}.#{column} IS NULL;"
+        end
+      end
+    end
+
+    def formatted_comment(mutator)
+      escape_string("anon: #{mutator}")
+    end
+
+    def escape_string(text)
+      connection.quote(text)
+    end
+
+    def supported_dialects
+      methods.map { |m| m[/^execute_comment_(.*)$/, 1] }.compact
+    end
+
+    # TODO: There's got be a better way
+    def dialect
+      connection.adapter_name.downcase.to_s
+    end
+  end
+end

data/lib/fake_pipe/mutator.rb

@@ -0,0 +1,184 @@
+module FakePipe
+  # This class handles mapping between a configured mutation such as
+  # 'phone_number' and the logic to change the data.
+  #
+  # To create a new mutable named configuration create a method prefixed
+  # with `mutate_`. The method will receive the original cell value and is
+  # expected to return the mutated value. Please add comment to the mutate
+  # method. The comment is used by `rake methods` to get a listing of all
+  # possible mutations.
+  module Mutator
+    module_function
+
+    def mutate(name, cell)
+      mutator_method = "mutate_#{name}"
+      if respond_to? mutator_method
+        public_send(mutator_method, cell)
+      else
+        raise "Mutator named `#{name}` not found. Try one of these: #{list.join(', ')}"
+      end
+    end
+
+    def list
+      @list ||= public_methods
+                .map { |m| m.to_s[/^mutate_(\w+)$/, 1] }
+                .select(&:present?)
+                .sort
+    end
+
+    # Utility method for outputting available mutators.
+    # Only require method source here.
+    # Currently used by a `rake methods`.
+    def list_with_comments
+      require 'method_source'
+      list.map { |short| [short, public_method("mutate_#{short}").comment.strip] }
+    end
+
+    # Faker::PhoneNumber with punctuation and extensions
+    def mutate_phone_number(_)
+      Faker::PhoneNumber.phone_number
+    end
+
+    # Faker::PhoneNumber 10-digits only
+    def mutate_clean_phone_number(_)
+      Faker::PhoneNumber.phone_number.gsub(/\D|(^1)/, '')[0, 10]
+    end
+
+    # Faker email
+    def mutate_email(_)
+      Faker::Internet.email
+    end
+
+    # Faker::Internet.user_name
+    def mutate_user_name(_)
+      Faker::Internet.user_name
+    end
+
+    # Faker::Internet.url
+    def mutate_url(_)
+      Faker::Internet.url
+    end
+
+    # MD5 hash of cell contents
+    def mutate_md5(cell)
+      cell ? Digest::MD5.base64digest(cell) : cell
+    end
+
+    # Faker::Address.street_address
+    def mutate_address_line_1(_)
+      Faker::Address.street_address
+    end
+
+    # Faker::Address.secondary_address
+    def mutate_address_line_2(_)
+      Faker::Address.secondary_address
+    end
+
+    # Faker::Address.country
+    def mutate_address_country(_)
+      Faker::Address.country
+    end
+
+    # Faker::Address.city
+    def mutate_address_city(_)
+      Faker::Address.city
+    end
+
+    # Faker::Address.state
+    def mutate_address_state(_)
+      Faker::Address.state
+    end
+
+    # Faker::Address.postcode
+    def mutate_address_postcode(_)
+      Faker::Address.postcode
+    end
+
+    # Faker::Company.name
+    def mutate_company_name(_)
+      Faker::Company.name
+    end
+
+    # Faker::Company.catch_phrase
+    def mutate_company_catch_phrase(_)
+      Faker::Company.catch_phrase
+    end
+
+    # an empty curly brace '{}' - good for json object and array fields
+    def mutate_empty_curly(_)
+      '{}'
+    end
+
+    # an empty bracket '[]' - good for json::array objects
+    def mutate_empty_bracket(_)
+      '[]'
+    end
+
+    # an empty String
+    def mutate_empty_string(_)
+      ''
+    end
+
+    # Faker::Lorem.paragraph
+    def mutate_lorem_paragraph(_)
+      Faker::Lorem.paragraph
+    end
+
+    # Faker::Lorem.word
+    def mutate_lorem_word(_)
+      Faker::Lorem.word
+    end
+
+    # Faker::Lorem.sentence
+    def mutate_lorem_sentence(_)
+      Faker::Lorem.sentence
+    end
+
+    # Faker::Name.first_name
+    def mutate_first_name(_)
+      Faker::Name.first_name
+    end
+
+    # Faker::Name.last_name
+    def mutate_last_name(_)
+      Faker::Name.last_name
+    end
+
+    # Faker::Name.full_name
+    def mutate_full_name(_)
+      Faker::Name.name
+    end
+
+    # Faker::PhoneNumber.extension
+    def mutate_phone_ext(_)
+      Faker::PhoneNumber.extension
+    end
+
+    # bcrypt password as 'password'
+    def mutate_bcrypt_password(_)
+      '400$8$2d$f6ed5a490c441958$67f59aa61bc617849a3280b5e80f78607e53b5aa5807a44ddbc53e804e2e2a99'
+    end
+
+    # bcrypt salt used to generate password
+    def mutate_bcrypt_salt(_)
+      'au6lOASvp17AGsqkmE7'
+    end
+
+    ALPHABET = ('A'..'Z').to_a
+    DIGITS = ('0'..'9').to_a
+    # Six random uppercase letters followed by four random numbers - ex. 'ABCDEF1234'
+    def mutate_ugcid(_)
+      (ALPHABET.sample(6) + DIGITS.sample(4)).join
+    end
+
+    # UUID
+    def mutate_uuid(_)
+      SecureRandom.uuid
+    end
+
+    # Reopen class to define aliases on module_function
+    class << self
+      alias mutate_guid mutate_uuid
+    end
+  end
+end

data/lib/fake_pipe/piper.rb

@@ -0,0 +1,93 @@
+module FakePipe
+  # This class cooridinates between all the text blocks.
+  # The class is initialized with some input io, an output io, and an adapter.
+  #
+  # ## Adapter
+  # An adapter is created by creating a module directly under fake_pipe. The
+  # module must respond to `text_blocks` which will return all the `TextBlock`
+  # classes needed to call `on_config` and `on_cell`.
+  #
+  # ## General IO Flow
+  # The `run` method is probably the most interesting. It streams in `each_line`
+  # of the input `io` and will output either the same line or the parsed line
+  # from the `TextObject#parse`. It's the responsibility of the TextBlock to
+  # extract relevant table, column, cell information. This class will make
+  # keep track of when to mutate cell.
+  #
+  # Most lines from `io` should be passed directly to the `outputter`
+  class Piper
+    attr_accessor :io, :configs, :outputter, :text_blocks
+
+    # @param [String] adapter should be a module file directly under the 'fake_pipe' path
+    def initialize(io:, outputter:, adapter:)
+      self.configs = {}
+      self.io = io
+      self.outputter = outputter
+      register_adapter(adapter)
+    end
+
+    def register_adapter(adapter)
+      adapter_module = "fake_pipe/#{adapter}"
+      require adapter_module
+      adapter_class = adapter_module.camelize.constantize
+      self.text_blocks = adapter_class.text_blocks.map do |block_class|
+        block_class.new(delegate: self)
+      end
+
+      # AnyBlock is a catch all and needs to come last.
+      text_blocks << AnyBlock.new(delegate: self)
+    end
+
+    def run
+      # used to track which text_block is currently in use
+      current_block = text_blocks.last
+      io.each_line do |line|
+        if current_block.end_text?(line)
+          output line
+          current_block = detect_and_start_text_block(line)
+        elsif configs[current_block.table]    # optimization: only parse of the text block has a table configuration
+          output current_block.parse(line)
+        else                                  # otherwise output the original line
+          output line
+        end
+      end
+    end
+
+    # Check if a line is the begining of a new text block.
+    # When it is, trigger the callbacks so the text block
+    # can initialize itself.
+    def detect_and_start_text_block(line)
+      text_blocks.detect do |block|
+        matcher = block.match_start_text(line)
+        if matcher && block.start_text? 
+          block.on_start_text(matcher, line)
+          true # result for detect
+        end
+      end
+    end
+
+    # Delegate method to be called by the #text_objects to get config information 
+    # from a table's column
+    def on_config(table:, column:, config:)
+      table = (configs[table] ||= {})
+      table[column] = config
+    end
+
+    # @return [String] The mutated cell or the original if there's no config for
+    #                  the table/column.
+    def on_cell(table:, column:, cell:)
+      if config = configs[table].try(:[], column)
+        Mutator.mutate(config, cell)
+      else
+        cell
+      end
+    end
+
+    private
+
+    # Simple wrapper to print to the configured #outputter
+    def output(text)
+      outputter.puts text
+    end
+  end
+end

data/lib/fake_pipe/postgres/comment_block.rb

@@ -0,0 +1,35 @@
+require 'fake_pipe/text_block'
+
+module FakePipe
+  module Postgres
+    # Finds Postgres comment DML.
+    class CommentBlock < TextBlock
+
+      self.start_pattern = /^COMMENT ON COLUMN (?<table>[^\.]+)\.(?<column>\S+) IS '(?<comment>.*)';/
+      self.end_pattern = /^$/
+
+      def on_start_text(match, line)
+        self.table = match[:table]
+        parse_config(match)
+      end
+
+      def parse_config(match)
+        # consolidate escaped single quotes
+        comment = match[:comment].gsub("''", "'")
+        data = YAML.load(comment).with_indifferent_access
+
+        # give the config back to the delegate
+        delegate.on_config(
+          table: match[:table],
+          column: match[:column],
+          config: data[:anon]
+        )
+      end
+
+      def parse(*)
+        raise '`parse` should not be called to extract config from comments. ' \
+             ' Try inspecting the PG dump format for changes. Comments are normally all in a single line.'
+      end
+    end
+  end
+end

data/lib/fake_pipe/postgres/copy_block.rb

@@ -0,0 +1,40 @@
+require 'fake_pipe/text_block'
+
+module FakePipe
+  module Postgres
+    # Finds COPY... text blocks inside of `pg_dumps`
+    class CopyBlock < TextBlock
+
+      DELIMITER = "\t"
+
+      COLUMN_SPLITTER = /,\s*/
+
+      self.start_pattern = /^COPY (?<table>\S+) \((?<columns>[^)]*)\) FROM stdin;/
+      self.end_pattern = /^\\\.$/
+
+      # @return [Hash<Integer,String>] Index for column ordinal and column name: { 1 => column_name }
+      def on_start_text(match, line)
+        @table = match[:table]
+        @columns = match[:columns].split(COLUMN_SPLITTER)
+        @column_idx = Hash[@columns.map.with_index { |name, i| [i, name] }]
+      end
+
+      # Postgres COPY format is NOT CSV.
+      # >  https://www.postgresql.org/docs/9.1/static/sql-copy.html
+      #
+      # @return [String] maybe mutated by `delegate.on_cell`
+      def parse(line)
+        row = line.split(DELIMITER)
+        faked = row.map.with_index do |cell, i|
+          if cell.blank? || cell == '\N'
+            # Don't acknowledge null cells
+            cell
+          else
+            delegate.on_cell(table: @table, column: @column_idx[i], cell: cell)
+          end
+        end
+        faked.join(DELIMITER)
+      end
+    end
+  end
+end

data/lib/fake_pipe/postgres.rb

@@ -0,0 +1,11 @@
+require_relative './postgres/comment_block'
+require_relative './postgres/copy_block'
+
+module FakePipe
+  # Adapter to handle Postgres `pg_dump`
+  module Postgres
+    def self.text_blocks
+      [CommentBlock, CopyBlock]
+    end
+  end
+end

data/lib/fake_pipe/text_block.rb

@@ -0,0 +1,38 @@
+module FakePipe
+  # Blocks are considered between the #start_text? and #end_text?
+  # Any lines in between the start and end are passed to #parse
+  #
+  # @start_match is available in case there's information in there #parse could
+  # find interesting.
+  class TextBlock
+
+    class_attribute :start_pattern
+    class_attribute :end_pattern
+
+    attr_accessor :delegate, :start_match, :table
+
+    def initialize(delegate:)
+      self.delegate = delegate
+    end
+
+    def match_start_text(line)
+      start_pattern && (self.start_match = start_pattern.match(line))
+    end
+
+    def start_text?
+      !start_match.nil?
+    end
+
+    def end_text?(line)
+      end_pattern && !!end_pattern.match(line)
+    end
+
+    # Override to do something interesting with the initial match or line
+    def on_start_text(_match, _line)
+    end
+
+    def parse(_line)
+      raise NotImplementedError, "#{self} doesn't implement `parse`."
+    end
+  end
+end

data/lib/fake_pipe/version.rb

@@ -0,0 +1,3 @@
+module FakePipe
+  VERSION = '0.2.0'.freeze
+end

data/lib/fake_pipe.rb

@@ -0,0 +1,21 @@
+# external gems
+require 'faker'
+require 'active_support/all'
+require 'csv'
+require 'yaml'
+
+# internal
+require 'fake_pipe/version'
+require 'fake_pipe/text_block'
+require 'fake_pipe/any_block'
+require 'fake_pipe/piper'
+require 'fake_pipe/mutator'
+
+module FakePipe
+  module_function
+
+  def pipe(io:, outputter: $stdout, adapter: 'postgres')
+    piper = FakePipe::Piper.new(io: io, outputter: outputter, adapter: adapter)
+    piper.run
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: fake_pipe
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Scott Pierce
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- ddrscott@gmail.com
+executables:
+- fake_pipe
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/fake_pipe
+- fake_pipe.gemspec
+- lib/fake_pipe.rb
+- lib/fake_pipe/any_block.rb
+- lib/fake_pipe/commenter.rb
+- lib/fake_pipe/mutator.rb
+- lib/fake_pipe/piper.rb
+- lib/fake_pipe/postgres.rb
+- lib/fake_pipe/postgres/comment_block.rb
+- lib/fake_pipe/postgres/copy_block.rb
+- lib/fake_pipe/text_block.rb
+- lib/fake_pipe/version.rb
+homepage: https://github.com/centro/fake_pipe
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: db_dump.sql | fake_pipe > fake_dump.sql
+test_files: []