omelettes 0.2.0

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Mark Sim
+
+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,69 @@
+# Omelettes #
+
+## Basic Usage ##
+
+    gem install omelettes
+    rails g omelettes:config
+    rake db:cook
+
+## Configuration ##
+
+  After running 'rails g omelettes:config' you will find a config file in 'config/initializers/omelettes.rb'
+
+    Omelettes.setup do |config|
+      # Ignore tables or columns using strings or regular expressions
+      config.ignore_tables = ["schema_migrations", "my_reporting_table", /(a-z_)user/]
+      config.ignore_columns = [/(a-z_)*type/i, "name", "city"]
+      
+      # Override non-standard table names => classes like this
+      #   config.models['admin_users'] = Admin::User
+      
+      # Override model specific columns
+      
+      User.treat(:nickname).as(:name)
+      Person.scramble(:street) {|value| "#{value.reverse}"}
+      
+      # Freeze / Ignore columns on specific models
+      User.harden(:password)
+      
+      # To make a normally "Faker" obfuscated column behave normally, override with :omelette
+      User.scramble(:name).as(:omelette)
+
+      # To override the model associated with a specific table, make sure and specify it here:
+      config.models['logins'] = User
+    end
+
+By default, the following columns will be Faker-ified (replaced with faker info RATHER than obfuscated using omelettes same-length-and-initial-character)
+
+* name
+* first_name
+* last_name
+* city 
+* state
+* country
+* street_address
+* street_name
+* zip_code
+* company_name
+* company
+* email
+* user_name
+* phone
+
+And the following can be used to 'treat' a column 'as':
+* paragraph 
+* paragraphs 
+* sentence 
+* sentences 
+* words
+
+You can also keep model-level configurations within the model itself
+
+    class User < ActiveRecord::Base
+      treat(:login).as(:user_name)
+      ignore :password
+    end
+
+## About ##
+
+omelettets is obfuscated 'obfuscate'.   Omelettes takes strings in your database and replaces them with worlds of the same length and same initial letter.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run RSpec"
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+end
+
+task :default => :spec

data/init.rb

@@ -0,0 +1 @@
+require 'omelettes'

data/lib/generators/omelettes/config/USAGE

@@ -0,0 +1,2 @@
+Description:
+  The omelettes:config generator creates the omelettes.rb config file in the initializers directory.

data/lib/generators/omelettes/config/config_generator.rb

@@ -0,0 +1,11 @@
+module Omelettes
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def generate_config
+        copy_file "omelettes.rb", "config/initializers/omelettes.rb"
+      end
+    end
+  end
+end

data/lib/generators/omelettes/config/templates/omelettes.rb

@@ -0,0 +1,30 @@
+# Omelettes Obfuscation Setup
+#
+# Columns with the following names will be automatically Faker-ified.  
+# You can make columns with other names Faker-ified by overriding the model
+#   specific columns a la:  User.scramble(:nickname).as(:first_name)
+#   
+#     :name, :first_name, :last_name
+#     :city, :state, :country, :street_address, :street_name, :zip_code
+#     :company_name, :company, :email, :user_name, :phone
+#     :paragraph, :paragraphs, :sentence, :sentences, :words
+
+Omelettes.setup do |config|
+  # Ignore tables or columns using strings or regular expressions
+  #   config.ignore_tables = ["schema_migrations", "my_reporting_table", /(a-z_)user/]
+  #   config.ignore_columns = [/(a-z_)*type/i, "name", "city"]
+
+  config.ignore_columns = [/[a-z_]*type/i, /[a-z_]*password[a-z_]*/i]
+  config.ignore_tables  = ['schema_migrations']
+
+  # Override non-standard table names => classes like this
+  #   config.models['admin_users'] = Admin::User
+  
+  # Override model specific columns
+  #   User.scramble(:nickname).as(:name)
+  #   Person.scramble(:street) {|value| "#{value.reverse}"}
+  # Freeze / Ignore columns on specific models
+  #   User.harden(:password)
+  # To make a normally "Faker" obfuscated column behave normally, override with :omelette
+  #   User.scramble(:name).as(:omelette)
+end

data/lib/omelettes/column.rb

@@ -0,0 +1,48 @@
+require 'faker'
+
+module Omelettes
+  class Column
+    attr_accessor :name, :style, :custom_block
+    def initialize(name, style=nil, &block)
+      @name = name
+      @style = style
+      @custom_block = block
+    end
+
+    def process(string)
+      if @custom_block
+        return @custom_block.call(string)
+      else
+        Column.default(@style || @name, string)
+      end
+    end
+
+    def self.default(name, value)
+      name = name.downcase.to_sym
+      case name
+      when :hardened
+        return value
+      when :name, :first_name, :last_name
+        return Faker::Name.send(name)
+      when :city, :state, :country, :street_address, :street_name, :zip_code
+        return Faker::Address.send(name)
+      when :company_name, :company
+        return Faker::Company.name
+      when :email, :user_name
+        return Faker::Internet.send(name)
+      when :paragraph, :paragraphs, :sentence, :sentences, :words
+        return Faker::Lorem.send(name)
+      when :phone
+        return Faker::PhoneNumber.phone_number
+      else
+        return Omelettes::Obfuscate.obfuscate(value)
+      end
+    end
+
+    def as(style)
+      @style = style unless @style == :hardened
+      self
+    end
+    alias :like :as
+  end
+end

data/lib/omelettes/model_additions.rb

@@ -0,0 +1,45 @@
+module Omelettes
+  module ModelAdditions
+    module ClassMethods
+      def column_config(column_name)
+        @column_config ||= {}
+        @column_config[column_name.to_s]
+      end
+      
+      def treat(column_name, style=nil, &block)
+        @column_config ||= {}
+        column = Column.new(column_name, style, &block)
+        @column_config[column_name.to_s] = column
+        column
+      end
+      alias :scramble :treat
+      
+      def ignore(column_name)
+        @column_config ||= {}
+        column = Column.new(column_name, :hardened)
+        @column_config[column_name.to_s] = column
+        column
+      end
+      alias :harden :ignore
+    end
+
+    def obfuscate(column_name)
+      column = self.class.column_config(column_name)
+      original_value = self.send(column_name)
+      if column
+        value = column.process(original_value)
+      else
+        value = Column.default(column_name, original_value)
+      end
+      self.update_attribute(column_name, value) if original_value != value
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include Omelettes::ModelAdditions
+end

data/lib/omelettes/obfuscate.rb

@@ -0,0 +1,64 @@
+module Omelettes
+  class Obfuscate
+    class << self
+      def cook(silent=false)
+        total_tables = 0
+        total_attributes = 0
+        Words.load(word_list || "/usr/share/dict/words")
+        tables.each do |table|
+          next if ignore_table?(table)
+          print "\nProcessing #{model(table).name}" unless silent
+          model(table).find_each do |object|
+            model(table).columns.each do |column|
+              next if ignore_column?(column.name) || column.type != :string
+              object.obfuscate(column.name)
+              total_attributes += 1
+            end
+            print "." unless silent
+          end
+          total_tables += 1
+        end
+        print "\n" unless silent
+        [total_tables, total_attributes]
+      end
+
+      def tables
+        ActiveRecord::Base.connection.tables
+      end
+
+      def model(table)
+        self.models ||= {}
+        self.models[table] ||= table.camelcase.singularize.constantize
+        self.models[table]
+      end
+
+      def ignore_table?(table)
+        ignore_tables.each do |ignore|
+          return true if table.match(ignore).to_s == table
+        end
+        false
+      end
+
+      def ignore_column?(column)
+        ignore_columns.each do |ignore|
+          return true if column.match(ignore).to_s == column
+        end
+        false
+      end
+
+      def obfuscate(string)
+        return nil if string.nil?
+        result = []
+        string.split(/(\s+)|([[:punct:]])/).each do |word|
+          result << (word.match(/[a-zA-Z]+/).nil? ? word : Words.replace(word))
+        end
+        result.join("")
+      end
+
+      attr_accessor :ignore_tables
+      attr_accessor :ignore_columns
+      attr_accessor :word_list
+      attr_accessor :models
+    end
+  end
+end

data/lib/omelettes/railtie.rb

@@ -0,0 +1,10 @@
+require 'omelettes'
+require 'rails'
+
+module Omelettes
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/omelettes.rake"
+    end
+  end
+end

data/lib/omelettes/words.rb

@@ -0,0 +1,36 @@
+module Omelettes
+  class Words
+    class << self
+
+      def word_hash
+        @word_hash ||= {}
+      end
+
+      def add(word)
+        key = "#{word[0].downcase}#{word.length}"
+        @word_hash[key] ||= []
+        @word_hash[key] << word
+      end
+
+      def replace(word)
+        key = "#{word[0].downcase}#{word.length}"
+        valid_words = (@word_hash[key] || [])
+        new_word = valid_words[rand(valid_words.size)]
+        return new_word.send(word[0].upcase == word[0] ? :capitalize : :downcase) unless new_word.nil?
+        word
+      end
+
+      def load(path="/usr/share/dict/words")
+        clear
+        (path.is_a?(Array) ? path : File.readlines(path)).each do |word|
+          add(word.strip)
+        end
+      end
+
+      def clear
+        @word_hash = {}
+      end
+    end
+  end
+
+end

data/lib/omelettes.rb

@@ -0,0 +1,19 @@
+begin
+  require 'active_record'
+rescue LoadError
+  require 'activerecord' unless defined?(ActiveRecord)
+end
+
+require 'omelettes/column'
+require 'omelettes/model_additions'
+require 'omelettes/obfuscate'
+require 'omelettes/words'
+
+module Omelettes
+  require 'omelettes/railtie' if defined?(Rails)
+
+  def self.setup
+    Omelettes::Obfuscate.models = {}
+    yield Omelettes::Obfuscate
+  end
+end

data/lib/tasks/omelettes.rake

@@ -0,0 +1,10 @@
+namespace :db do
+  desc "Obfuscate the database with Omelettes"
+  task :cook => :environment do
+    print "Are you sure you want to scramble all strings in the database? (y/n): "
+    input = $stdin.gets.strip
+    if input == "y"
+      Omelettes::Obfuscate.cook
+    end
+  end
+end

data/spec/README.rdoc

@@ -0,0 +1,10 @@
+= Omelettes Specs
+
+== Running the specs
+
+To run the specs first run the +bundle+ command to install the necessary gems and the +rake+ command to run the specs.
+
+  bundle
+  rake
+
+The specs currently require Ruby 1.9.2

data/spec/omelettes/column_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Omelettes::Column do
+  describe "creation" do
+    it "accepts a name" do
+      c = nil
+      lambda { c = Omelettes::Column.new(:name) }.should_not raise_error
+      c.name.should == :name
+    end
+
+    it "accepts a name and an optional style" do
+      c = nil
+      lambda { c = Omelettes::Column.new(:name, :city) }.should_not raise_error
+      c.name.should == :name
+      c.style.should == :city
+    end
+
+    it "accepts a block" do
+      c = Omelettes::Column.new(:name) {|value| value.reverse}
+      c.custom_block.should_not be_nil
+    end
+
+    it "allows 'as' or 'like' syntax to alter the style" do
+      Omelettes::Column.new(:name).as(:test).style.should == :test
+      Omelettes::Column.new(:value).like(:key).style.should == :key
+    end
+  end
+
+  describe "process" do
+    it "executes a block if present" do
+      c = Omelettes::Column.new(:name) {|value| value.reverse}
+      c.process("eggs").should == "sgge"
+    end
+
+    it "calls the default processing method if no block present" do
+      c = Omelettes::Column.new(:name)
+      Faker::Name.should_receive(:name).once
+      c.process("Mark")
+    end
+
+    it "calls the passed 'style' if passed, overriding the name" do
+      c = Omelettes::Column.new(:name).as(:paragraph)
+      Faker::Lorem.should_receive(:paragraph).once
+      c.process("Some stuff")
+    end
+
+    it "calls the standard obfuscation method if the style is not recognized" do
+      c = Omelettes::Column.new(:name).as(:omelettes)
+      Omelettes::Obfuscate.should_receive(:obfuscate).once
+      c.process("Some Stuff")
+    end
+  end
+end

data/spec/omelettes/model_additions_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe "Model Additions" do
+  describe "treat / scramble" do
+    it "should create a column with a specified style for a model" do
+      User.treat(:middle_name).as(:first_name)
+      User.column_config(:middle_name).style.should == :first_name
+    end
+
+    it "should create a column with a custom block specified for a model" do
+      User.scramble(:middle_name) {|value| value.reverse}
+      User.column_config(:middle_name).custom_block.should_not be_nil
+    end
+  end
+
+  describe "ignore / harden" do
+    it "should create a column with a style of ':hardened'" do
+      User.ignore(:middle_name)
+      User.column_config(:middle_name).style.should == :hardened
+    end
+
+    it "should not be overwritten with 'as'" do
+      User.ignore(:middle_name).as(:first_name)
+      User.column_config(:middle_name).style.should == :hardened
+    end
+  end
+
+  describe "obfuscate" do
+    before(:each) do
+      @user = User.new
+      @user.stub(:first_name).and_return("Ed")
+      @user.stub(:middle_name).and_return("Jeremy")
+      @user.stub(:last_name).and_return("Stevens")
+      @user.stub(:city).and_return("Stuckeyville")
+      User.stub(:find_each).and_return([@user])
+    end
+
+    it "should process the column result back to the database" do
+      User.treat(:middle_name).as(:first_name)
+      @user.should_receive(:update_attribute).once
+      @user.obfuscate(:middle_name)
+    end
+
+    it "should not write anything to the database if the column is ignored" do
+      User.ignore(:city)
+      @user.should_not_receive(:update_attribute)
+      @user.obfuscate(:city)
+    end
+
+    it "should call the passed block and write the result to the database" do
+      User.treat(:last_name) {|value| "Vessy"}
+      @user.should_receive(:update_attribute).with(:last_name, "Vessy").once
+      @user.obfuscate(:last_name)
+    end
+
+    it "should call Faker for default column names, even if not explicitly configured" do
+      Faker::Name.should_receive(:first_name).once
+      @user.should_receive(:update_attribute).once
+      @user.obfuscate(:first_name)
+    end
+  end
+end

data/spec/omelettes/obfuscate_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Omelettes::Obfuscate do
+
+  describe "models" do 
+    it "allows for override" do
+      Omelettes.setup do |config|
+        config.models['logins'] = User
+      end
+
+      Omelettes::Obfuscate.model("logins").should == User
+    end
+
+    it "returns the model" do
+      Omelettes::Obfuscate.model("users").should == User
+    end
+  end
+
+  describe "ignore tables" do
+    it "ignores matching strings" do
+      Omelettes.setup do |config|
+        config.ignore_tables = ["alpha", "beta", "kappa"]
+      end
+
+      Omelettes::Obfuscate.ignore_table?("alpha").should be_true
+      Omelettes::Obfuscate.ignore_table?("beta").should be_true
+      Omelettes::Obfuscate.ignore_table?("kappa").should be_true
+      Omelettes::Obfuscate.ignore_table?("delta").should be_false
+    end
+
+    it "ignores matching regex" do
+      Omelettes.setup do |config|
+        config.ignore_tables = [/[a-z_]*type/i]
+      end
+
+      Omelettes::Obfuscate.ignore_table?("type").should be_true
+      Omelettes::Obfuscate.ignore_table?("my_favorite_type").should be_true
+      Omelettes::Obfuscate.ignore_table?("matype").should be_true
+      Omelettes::Obfuscate.ignore_table?("typedef").should be_false
+      Omelettes::Obfuscate.ignore_table?("another").should be_false
+    end
+  end
+
+  describe "ignore columns" do
+    it "ignores matching strings" do
+      Omelettes.setup do |config|
+        config.ignore_columns = ["alpha", "beta", "kappa"]
+      end
+
+      Omelettes::Obfuscate.ignore_column?("alpha").should be_true
+      Omelettes::Obfuscate.ignore_column?("beta").should be_true
+      Omelettes::Obfuscate.ignore_column?("kappa").should be_true
+      Omelettes::Obfuscate.ignore_column?("delta").should be_false
+    end
+
+    it "ignores matching regex" do
+      Omelettes.setup do |config|
+        config.ignore_columns = [/[a-z_]*type/i]
+      end
+
+      Omelettes::Obfuscate.ignore_column?("type").should be_true
+      Omelettes::Obfuscate.ignore_column?("my_favorite_type").should be_true
+      Omelettes::Obfuscate.ignore_column?("matype").should be_true
+      Omelettes::Obfuscate.ignore_column?("typedef").should be_false
+      Omelettes::Obfuscate.ignore_column?("another").should be_false
+    end
+  end
+
+  describe "obfuscate" do
+    it "returns nil if passed nil" do
+      Omelettes::Obfuscate.obfuscate(nil).should be_nil
+    end
+
+    it "replaces words" do
+      Omelettes::Words.clear
+      ["barfs", "foo", "queen", "tad"].each do |word|
+        Omelettes::Words.add(word)
+      end
+      Omelettes::Obfuscate.obfuscate("the quick brown fox").should == "tad queen barfs foo"
+    end
+
+    it "preserves punctuation" do
+      Omelettes::Words.clear
+      ["barfs", "foo", "queen", "tad"].each do |word|
+        Omelettes::Words.add(word)
+      end
+      Omelettes::Obfuscate.obfuscate("the: quick, brown! fox :)").should == "tad: queen, barfs! foo :)"
+    end
+  end
+
+  describe "cook" do
+    before(:each) do
+      Omelettes.setup do |config|
+        config.word_list = %w(barfs foo queen tad pole)
+      end
+
+      Omelettes::Obfuscate.stub(:tables).and_return(["users"])
+
+      User.stub(:find_each).and_return(User.new(:first_name => "Mark", :last_name => "Sim", :city => "Austin"))
+    end
+
+    it "ignores specified tables" do
+      Omelettes::Obfuscate.ignore_tables = ["users"]
+      Omelettes::Obfuscate.cook(true).should == [0, 0]
+    end
+
+    it "ignores specified columns" do
+      Omelettes::Obfuscate.ignore_tables = []
+      Omelettes::Obfuscate.ignore_columns = ['first_name', 'middle_name', 'last_name', 'city']
+      Omelettes::Obfuscate.cook(true).should == [1, 0]
+    end
+  end
+end

data/spec/omelettes/words_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Omelettes::Words do
+  describe "load" do
+    it "loads from the default path" do
+      Omelettes::Words.clear
+      Omelettes::Words.word_hash.should == {}
+      Omelettes::Words.load
+      Omelettes::Words.word_hash.should_not == {}
+      Omelettes::Words.word_hash.should_not be_nil
+
+    end
+
+    it "optionally accepts a load path" do
+      File.should_receive(:readlines).once.and_return(["one"])
+      Omelettes::Words.load("test.path")
+      Omelettes::Words.word_hash.should == {"o3" => ["one"]}
+    end
+  end
+
+  describe "add" do
+    before(:each) do
+      Omelettes::Words.clear
+    end
+    it "adds a word to the values of the word_hash" do
+      Omelettes::Words.add("fate")
+      Omelettes::Words.word_hash.values.flatten.should include("fate")
+    end
+
+    it "indexes based on word length and first letter" do
+      Omelettes::Words.add("tony")
+      Omelettes::Words.word_hash["t4"].should include("tony")
+    end
+
+    it "does not care the case" do
+      Omelettes::Words.add("FaT")
+      Omelettes::Words.word_hash["f3"].should include("FaT")
+    end
+  end
+
+  describe "replace" do
+    before(:each) do
+      Omelettes::Words.clear
+    end
+
+    it "returns a word of the same length" do
+      Omelettes::Words.add("bra")
+      Omelettes::Words.add("brak")
+      Omelettes::Words.add("brake")
+
+      Omelettes::Words.replace("bat").should == "bra"
+    end
+
+    it "returns a word starting with the same letter" do
+      Omelettes::Words.add("abc")
+      Omelettes::Words.add("bcd")
+      Omelettes::Words.add("cde")
+
+      Omelettes::Words.replace("att").should == "abc"
+    end
+
+    it "returns itself if there is no word in the dictionary matching the first letter and length" do
+      Omelettes::Words.add("bra")
+      Omelettes::Words.add("cake")
+      Omelettes::Words.add("brake")
+
+      Omelettes::Words.replace("bork").should == "bork"
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'omelettes'
+
+RSpec.configure do |config|
+end
+
+class TablelessModel < ActiveRecord::Base
+  def self.columns() @columns ||= []; end
+ 
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+  end
+
+end
+
+class User < TablelessModel
+  column :id, :integer
+  column :first_name, :string
+  column :middle_name, :string
+  column :last_name, :string
+  column :city, :string
+  column :age, :integer
+end
+

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: omelettes
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Mark Sim
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-27 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: faker
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id003
+description: Low-to-no configuration solution for obfuscating sensitive data in your database.
+email: mark@quarternotecoda.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/generators/omelettes/config/config_generator.rb
+- lib/generators/omelettes/config/templates/omelettes.rb
+- lib/generators/omelettes/config/USAGE
+- lib/omelettes/column.rb
+- lib/omelettes/model_additions.rb
+- lib/omelettes/obfuscate.rb
+- lib/omelettes/railtie.rb
+- lib/omelettes/words.rb
+- lib/omelettes.rb
+- lib/tasks/omelettes.rake
+- spec/omelettes/column_spec.rb
+- spec/omelettes/model_additions_spec.rb
+- spec/omelettes/obfuscate_spec.rb
+- spec/omelettes/words_spec.rb
+- spec/README.rdoc
+- spec/spec.opts
+- spec/spec_helper.rb
+- Gemfile
+- LICENSE
+- Rakefile
+- README.md
+- init.rb
+homepage: http://github.com/marksim/omelettes
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.4
+requirements: []
+
+rubyforge_project: omelettes
+rubygems_version: 1.8.4
+signing_key: 
+specification_version: 3
+summary: Database obfuscation.
+test_files: []
+