cloak_id 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4702a69506e1c0ccc4888a32e69b04161161e20e
+  data.tar.gz: 4701111cd4ec15d847ca64421f54d2862bfb9fef
+SHA512:
+  metadata.gz: daf77844a7c971e5920a567f9dc4d2b1d698e56e16289f8fcf0806d8fe86d9c0cc77e78d06c14018b8ca60f8980c87966cddfb31a62c2aea9897bf287b9f727c
+  data.tar.gz: 5aad2b8a0b8fef298dd5eb6bc79d8acb418e19c9b2c35a053a65006b626b351cbca31bcb9ca857e842e998906b83fab2b3c8c03985bc6abc4b03832fb31e35a0

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea/
+coverage/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cloak_id.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 elleleb
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Beth LeBeau
+
+MIT License
+
+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,122 @@
+# CloakId
+
+### Hide your database ids from users of your webapp.
+
+Using sequential ids makes predicting the ids of other resources in your application simple, and can provide details
+about how your app is growing (how many users, etc.) to current and potential competitors.   Obfuscating identifiers isn't
+meant to be a primary means of providing security, but it can help to keep confidential information from being completely
+public.
+
+Making use of the gem will replace the identifier in URLs:
+e.g.  http://my.railsapp.com/users/U3OFSP23
+
+as well as in JSON representations of resources
+
+e.g.
+{"id":"U3OFSP23", "name": "Joe User", "active":true}
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cloak_id'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cloak_id
+
+To seed the random key used during cloaking, execute the following command
+
+    rails generate cloak_id::install
+
+This command is optional, but if it not done then your application will make use of a global default key, leading to identical
+cloaked ids being generated for identically named models.  This value will be used to seed the transformation, and help ensure
+the quality of the obfuscation.
+
+## Usage
+
+In your model files (that inherit from Active Record) add the 'cloak_id' call to enable the obfuscating of the ids.
+
+    class User < ActiveRecord::Base
+      cloak_id
+    end
+
+
+## What the gem does
+
+The cloak_id gem provides a way to "cloak" your identifiers.   This doesn't provide any real security, but instead makes it
+less obvious to what the underlying database id of a resource really is.  This is desirable in cases where you want to make
+it more difficult for users to guess identifiers, or for observers to judge how fast your application is growing.
+
+This technique does not provide any real security - it only makes it more difficult for casual observers to guess resource
+identifiers.
+
+The logic behind the transformation is to use a prime number to generate a simple, yet reversible hash of the database id.
+That newly obscured hash is then encoded as a string, to further hide its meaning.  This will happen when generating forms
+from ActiveRecords (when using the entire object or the to_param call), as well as when encoding the object in JSON format.
+
+
+## Customizing your cloaking
+
+The cloak_id method call takes an option hash that controls how the cloaking occurs:
+<p>
+<table>
+  <tr>
+    <th>option name</th>
+    <th>description</th>
+  </tr>
+  <tr>
+    <td>key</td>
+    <td>The key to use for obfuscating identifier.   This can be either an integer or a string.   This is an optional
+        parameter.  If the user does not provide one, then this will be based on the name of the model itself.  This
+        means that "common" models (e.g. User) may have the same obfuscated values across different web apps.  This
+        can be prevented by passing in a value to this parameter or by setting a seed (by running rails generate cloak_id install)
+    </td>
+  </tr>
+  <tr>
+    <td> prefix </td>
+    <td> Obfuscating the identifier results in a string.  To better help developers understand what type of resource
+         if being identified, an optional prefix may be specified.   If none is provided, then a prefix will be created
+         based on the name of the model.  This prefix must start with a alphabetic character.
+    </td>
+  </tr>
+</table>
+
+###Examples
+This line will result in a cloaked identifier encoded with a specifically defined key, and the resulting cloaked identifier
+will begin with UU.
+
+    cloak_id key:'SampleKey', prefix:'UU'
+
+After this call, most instances of the id will be replaced with the cloaked id.   This includes calls to serialize the
+resoruce as XML or JSON, as well as when it is used as a parameter in forms, or in RESTful API calls.   The "id" call will
+not change, as this gem does not actually change the underlying id of the object.   Just how it is displayed.
+
+To access the cloaked id directly, you may call
+    self.cloaked_id
+
+Retrieving objects from the database from cloaked ids can happen in two ways
+
+    ClassName.find(cloaked_id)
+or
+
+    ClassName.find_by_cloaked_id(cloaked_id)
+
+Objects that have had their id cloaked will use a "smart" find method.   This method will inspect the id to see if it
+appears to be a cloaked id (all cloaked ids must start with an alphabetic character), and if it does, then it will use
+the find_by_cloaked_id method.   If it is numeric, or if it does not begin with the expected prefix, then it will fall
+back to use the out-of-the-box find functionality.
+
+Because of this logic, most cases will work without any changes to the code that makes use of the cloaked resource.
+
+## Contributing
+
+1. Fork it ( https://github.com/elleleb/cloak_id/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/cloak_id.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cloak_id/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cloak_id"
+  spec.version       = CloakId::VERSION
+  spec.authors       = ["Elle L."]
+  spec.email         = ["elle@pandromos.com"]
+  spec.summary       = %q{Gem to help obfuscate Active Record ids.}
+  spec.description   = %q{The cloak id gem allows developers to easily hide the actual (database) id of resources through obfuscation.}
+  spec.homepage      = "https://github.com/elleleb/cloak_id"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "rails","> 4.0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "generator_spec"
+end

data/lib/cloak_id.rb

@@ -0,0 +1,127 @@
+require "cloak_id/version"
+require "active_record"
+require "zlib"
+require "cloak_id/cloak_id_encoder"
+require "cloak_id/errors"
+
+module CloakId
+
+  # The main entry point for cloak_id  This will cause the Active Record that this is called in to be able to
+  # cloak it's ids.
+  #
+  # options:
+  # :prefix : All cloaked ids will begin with this prefix.  If none is provided, then the letter 'X' will be used
+  # :key : The key that will be used to do the obfuscation.  If none is provided, then the obfuscation will use
+  #        a key based on the model name.  This could result in multiple applications cloaking ids in the same way.
+  def cloak_id(options = {})
+    cattr_accessor :cloak_id_prefix, :cloak_id_key
+    self.cloak_id_prefix = (options[:prefix] || model_name.singular.split('_').slice(0,2).inject('') {|prefix,word| prefix + word[0,1].upcase})
+
+    raise CloakingError, 'Prefix values must start with a letter.' unless (/^[A-Za-z]/ =~ self.cloak_id_prefix)
+
+    key = options[:key]
+
+    if (!key.nil? and key.is_a? String)
+      key = Zlib::crc32(key)
+    end
+
+    self.cloak_id_key = key
+
+    alias_method :old_serializable_hash, :serializable_hash
+    extend ClassMethods
+    include InstanceMethods
+  end
+
+  module InstanceMethods
+
+    # Return the id for the object in cloaked form.  If the id is nil, then this method will also return nil.
+    def cloaked_id
+      if self.id.nil?
+        nil
+      else
+        self.class.cloaked_id_for(self.id)
+      end
+    end
+
+    def to_param
+      self.cloaked_id
+    end
+
+    def serializable_hash (options = nil)
+      attribute_hash = self.old_serializable_hash (options)
+      attribute_hash['id'] = self.cloaked_id
+
+      #now we want to cloak any fk ids that have been cloaked
+      self.class.reflections.values.each  do |association|
+        if association.klass.respond_to? :cloaked_id_for
+          # this is a related item that has been cloaked
+          if attribute_hash.has_key? association.foreign_key
+            attribute_hash[association.foreign_key] = association.klass.cloaked_id_for(attribute_hash[association.foreign_key])
+          end
+        end
+      end
+      attribute_hash
+    end
+  end
+
+  module ClassMethods
+
+    # class method to create the cloaked id.  This will be used when generation a new cloaked id either on demand by the
+    # object itself, or when an association wants to hide the id.
+
+    def cloaked_id_for(id)
+      "#{self.cloak_id_prefix}#{CloakIdEncoder.cloak_mod_35(id, self.cloaking_key)}"
+    end
+
+    # Return the key that we're going to use in the twiddle function during reversible hashing
+    # this value will be based on the CRC check sum of the model name unless one is provided by
+    # the user.
+    def cloaking_key
+      self.cloak_id_key = Zlib::crc32(self.model_name)^CloakIdEncoder.cloak_id_default_key unless self.cloak_id_key.is_a? Integer
+      self.cloak_id_key
+    end
+
+    # Perform a find request based on the cloaked id.  This command will verify that the cloaked id is in the
+    # correct format to allow it to be found.   If it is not then the requested record cannot be found, and a
+    # RecordNotFound error will be raised.
+    def find_by_cloaked_id(cloaked_id,options={})
+      # make sure this is a valid id
+      raise new ActiveRecord::RecordNotFound("Cloaked Id does not have a valid format.") unless cloaked_id.start_with? self.cloak_id_prefix
+
+      decloaked_id = decloak_id_for_class(cloaked_id)
+      self.find(decloaked_id)
+    end
+
+    def decloak_id_for_class(cloaked_id)
+      CloakIdEncoder.decloak_mod_35(cloaked_id[self.cloak_id_prefix.length..-1], self.cloaking_key)
+    end
+
+    ## method to check whether an id might be a valid cloaked id.
+    def is_cloaked_id?(id)
+      id.is_a? String and id.starts_with? self.cloak_id_prefix
+    end
+
+    # This is a "Smart" version of the find method.  It takes a look at the id, and figures out if it might be a cloaked
+    # id.  If it is, then it will perform the search with the decloaked value.  Otherwise it will treat it as a "normal"
+    # identifier.
+    def find(arg)
+      arg_is_cloaked_id = is_cloaked_id? arg
+      if arg_is_cloaked_id
+        find_by_cloaked_id arg
+      elsif arg.is_a? Array
+        arg_list = arg.map do |entry|
+          if is_cloaked_id? entry
+            decloak_id_for_class entry
+          else
+            entry
+          end
+        end
+        super arg_list
+      else
+        super arg
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend CloakId

data/lib/cloak_id/cloak_id_encoder.rb

@@ -0,0 +1,59 @@
+module CloakId
+  # The CloakIdEncoder is a support class that helps with the cloaking process.  It provides the base functionality
+  # need to do the hashing back and forth from the numeric identifier, as well as the mechanism to turn this into
+  # a cloaked id.
+  class CloakIdEncoder
+    TWIDDLE_PRIME = 0x20C8592B
+
+    cattr_accessor :cloak_id_default_key
+
+    # Basic hashing function to go back and forth between a hashed value.
+    def self.twiddle(val,key)
+      hashed = (key ^ val) * TWIDDLE_PRIME
+      hashed >> (hashed & 0x0f) & 0xffff
+    end
+
+    # Take the integer and cloak it as another integer.  This is a reversible function, and cloak(cloak(X)) = X
+    def self.cloak(id,key=CloakIdEncoder.cloak_id_default_key)
+      raise "Id must be an integer to cloak properly" unless id.is_a? Integer
+
+      low = id & 0xffff
+      high = ((id >> 16) & 0xffff) ^ twiddle(low,key)
+      ((low ^ twiddle(high,key||0)) << 16) + high
+    end
+
+
+    # This calls the cloak method, but instead of returning the integer value, it will return it as a base 36 string.
+    # Unlike the main cloak method, this is not reversible in the same way.  To reverse the action of cloaking, the
+    # decloak_base36 method must be used instead.
+    def self.cloak_base36(id,key=CloakIdEncoder.cloak_id_default_key)
+      self.cloak(id,key||0).to_s(36).upcase
+    end
+
+    # This method reverses the cloaking procedure for when the ID has been cloaked using the base36 technique.  It is
+    # important to know that this method does not handle the stripping any prefix that might have been added.  It acts
+    # only as an inverse function to the cloak_base36 function
+    def self.decloak_base36(cloaked_id, key=CloakIdEncoder.cloak_id_default_key)
+      id = cloaked_id.downcase.to_i(36)
+      cloak(id,key||0)
+    end
+
+    # The modified base 35 encoding eliminates Z's from appearing normallty.  This was we can make cloaked id's at least
+    # a given length.  This can help make the representation of the cloaked id, a little bit more homogenized.
+    def self.cloak_mod_35(id, key=CloakIdEncoder.cloak_id_default_key, min_len=7)
+      intermediate_id = self.cloak(id,key||0).to_s(35).upcase
+      if intermediate_id.length < min_len
+        "#{"Z"*(min_len-intermediate_id.length)}#{intermediate_id}"
+      else
+        intermediate_id
+      end
+    end
+
+    # Preform the decloaking operation for the modified base 35 encoding scheme.  This will remove the "Z" characters that
+    # only serve to be place holders, then turn it back into a number and decloak it.
+    def self.decloak_mod_35(id,key=CloakIdEncoder.cloak_id_default_key)
+      intermediate_id = id.slice(/[0-9A-Y]+/).downcase.to_i(35)
+      self.cloak(intermediate_id,key)
+    end
+  end
+end

data/lib/cloak_id/errors.rb

@@ -0,0 +1,6 @@
+module CloakId
+  # A standard error to represent problems with the cloaking process.  This error should be raised when there is a
+  # problem that must be handled to ensure proper functionality.
+  class CloakingError < StandardError
+  end
+end

data/lib/cloak_id/version.rb

@@ -0,0 +1,3 @@
+module CloakId
+  VERSION = "0.1.0"
+end

data/lib/generators/cloak_id/install/install_generator.rb

@@ -0,0 +1,11 @@
+module CloakId
+  module Generators
+    class InstallGenerator  < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def generate_install
+        template 'cloak_id.rb.erb', 'config/initializers/cloak_id.rb'
+      end
+    end
+  end
+end

data/lib/generators/cloak_id/install/templates/cloak_id.rb.erb

@@ -0,0 +1,3 @@
+# This will set the global key for the application.  This is generated at install time to help
+# to better cloak the ids in the app.
+CloakId::CloakIdEncoder.cloak_id_default_key = <%=SecureRandom.random_number(0xffffffff)%>

data/spec/cloak_id/cloak_id_encoder_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require File.dirname(__FILE__)+'/../../lib/cloak_id/cloak_id_encoder'
+
+describe CloakId::CloakIdEncoder do
+
+  it 'should raise exception when the id to be cloaked is not numeric' do
+    expect {CloakId::CloakIdEncoder.cloak(id)}.to raise_error
+  end
+
+  it 'should return the base id after cloaking twice' do
+    cloaked_v = CloakId::CloakIdEncoder.cloak(10000,0)
+    expect(CloakId::CloakIdEncoder.cloak(cloaked_v,0)).to eql 10000
+
+    cloaked_v = CloakId::CloakIdEncoder.cloak(0xffff25,0x1234)
+    expect(CloakId::CloakIdEncoder.cloak(cloaked_v,0x1234)).to eql 0xffff25
+  end
+
+  it 'should be able to perform a base 36 encoding and decoding successfully' do
+    cloaked_v = CloakId::CloakIdEncoder.cloak_base36(10000,0)
+    decloaked_v = CloakId::CloakIdEncoder.decloak_base36(cloaked_v,0)
+    expect(decloaked_v).to eql 10000
+  end
+
+  it 'should enforce a minimum length when using modified base 35 encoding' do
+    cloaked_v = CloakId::CloakIdEncoder.cloak_mod_35(10000,0,40)
+
+    expect(cloaked_v).to include 'ZZZZZZZZZ'
+    expect(cloaked_v).to have(40).characters
+
+    decloaked_id = CloakId::CloakIdEncoder.decloak_mod_35(cloaked_v,0)
+    expect(decloaked_id).to eql 10000
+  end
+
+
+  it 'should not modify the cloaked id if the cloaked value is already long enough' do
+    cloaked_v = CloakId::CloakIdEncoder.cloak_mod_35(10000,0,5)
+    expect(cloaked_v).to_not include 'Z'
+    expect(cloaked_v).to have_at_least(5).characters
+  end
+
+  it 'should make use of the configured default key when none is provided' do
+    key_0_cloaked = CloakId::CloakIdEncoder.cloak_mod_35(1234)
+    CloakId::CloakIdEncoder.cloak_id_default_key = 4321
+    key_4321_cloaked = CloakId::CloakIdEncoder.cloak_mod_35(1234)
+    key_4321_decloaked = CloakId::CloakIdEncoder.decloak_mod_35(key_4321_cloaked)
+
+    expect(key_4321_decloaked).to eql 1234
+    expect(key_0_cloaked).to_not eql key_4321_cloaked
+  end
+end

data/spec/cloak_id/cloak_id_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+
+## helper to make a simple model
+def make_model
+  test_model = TestModel.new
+  test_model.id = 1234
+  test_model.test_field='This is a test field'
+
+  test_model
+end
+
+describe CloakId do
+
+  it 'should provide the obfuscated id on an active record' do
+    test_model = make_model()
+    cloaked_id = test_model.cloaked_id
+
+    expect(cloaked_id).to start_with 'TM'
+    decloaked_id = CloakId::CloakIdEncoder.decloak_mod_35(cloaked_id[2..-1],test_model.cloak_id_key)
+    expect(decloaked_id).to eql test_model.id
+  end
+
+  it 'should use the specified prefix on the front of the cloaked id' do
+    test_model = TestModel.create
+    test_association = TestAssociation.create
+
+    expect(test_model.cloaked_id).to start_with 'TM'     #default
+    expect(test_association.cloaked_id).to start_with 'L'
+  end
+
+  it 'should be able to convert a string key into a numeric key for cloaking' do
+    expect(TestModel2.cloaking_key).to eql Zlib::crc32('my_key')
+  end
+
+  it 'should raise an error when using a prefix that does not start with a letter' do
+    sample_model = UncloakedModel.new
+    expect do
+      class << sample_model
+        cloak_id prefix:'123'
+      end
+    end.to raise_error(CloakId::CloakingError)
+  end
+
+  it 'should return null for the cloaked id when there is no id in place' do
+    model = TestModel.new
+
+    expect(model.cloaked_id).to be_nil
+  end
+
+  it 'should allow the user to used the find_by_cloaked_id method to use the cloaked id to find the resource' do
+    model = TestModel.create
+    cloaked_id = model.cloaked_id
+
+    found_model = TestModel.find_by_cloaked_id(cloaked_id)
+    expect(found_model).to eql model
+  end
+
+  it 'should provide the cloaked id when converting the resource into a parameter' do
+    model = make_model()
+    expect(model.to_param).to eql model.cloaked_id
+  end
+
+  it 'should include the cloaked id in the json that is produced for the resource' do
+    test_model = make_model()
+    model_json = test_model.as_json
+    expect(model_json['id']).to eql test_model.cloaked_id
+  end
+
+
+  it 'should handle cloaking ids with the JSON as it bubbles up' do
+    model = TestModel.create
+    association = TestAssociation.create
+
+    model.test_associations << association
+    model.test_associations  << TestAssociation.create
+    model_json = model.as_json(include: :test_associations)
+
+    # This is ugly, but since this is a single association on the model, we want the first item in the "has many"
+    expect(model_json['test_associations'][0]['id']).to eql association.cloaked_id
+    expect(model_json['test_associations'][0]['test_model_id']).to eql model.cloaked_id
+  end
+
+  it 'should use the right find technique when presented with the cloaked vs. the decloaked id.' do
+    model = TestModel.create
+    model_2 = TestModel.create
+    expect(TestModel.find(model.id)).to eql model
+    expect(TestModel.find(model.cloaked_id)).to eql model
+    expect(TestModel.find([model.id, model_2.id])).to eql [model,model_2]
+    expect(TestModel.find([model.cloaked_id, model_2.cloaked_id])).to eql [model,model_2]
+  end
+end

data/spec/cloak_id/install_generator_spec.rb

@@ -0,0 +1,20 @@
+# Spec file for the installation generator.
+require 'spec_helper'
+require 'generator_spec/test_case'
+require 'generators/cloak_id/install/install_generator'
+
+describe CloakId::Generators::InstallGenerator do
+  include GeneratorSpec::TestCase
+  destination File.expand_path('../../tmp',__FILE__)
+
+  before (:all) do
+    SecureRandom.stub(:random_number).and_return(12345)
+    prepare_destination
+    run_generator
+  end
+
+  it 'should create an initializer' do
+    # We're going to check to make sure that the file has the expected key in it.
+    assert_file 'config/initializers/cloak_id.rb',/CloakId::CloakIdEncoder.cloak_id_default_key = 12345/
+    end
+end

data/spec/schema.rb

@@ -0,0 +1,15 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :test_models, :force => true do |t|
+    t.string :test_field
+  end
+
+  create_table :test_associations, :force => true do |t|
+    t.references :test_model
+  end
+
+  create_table :uncloaked_models, :force => true do |t|
+    t.string :extra_field_for_sample
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'simplecov'
+SimpleCov.start
+require 'rubygems'
+require 'bundler/setup'
+require 'active_record'
+require 'pry'
+
+Bundler.setup
+require 'cloak_id' # and any other gems you need
+require 'support/test_model'
+require 'zlib'
+
+RSpec.configure do |config|
+  config.debug = false
+  config.color_enabled = true
+  config.formatter = 'documentation'
+end
+
+ActiveRecord::Base.establish_connection adapter:'sqlite3', database:':memory:'
+
+load File.dirname(__FILE__) + '/schema.rb'

data/spec/support/test_model.rb

@@ -0,0 +1,20 @@
+# Here lie model classes that help with the unit tests.  We'll use these to create certain sub-categories of
+# models that have cloaked ids.
+class TestModel < ActiveRecord::Base
+  cloak_id
+  has_many :test_associations
+end
+
+class TestAssociation < ActiveRecord::Base
+  cloak_id prefix:'L'
+  belongs_to :test_model
+end
+
+class UncloakedModel < ActiveRecord::Base
+end
+
+class TestModel2 < ActiveRecord::Base
+  self.table_name = 'test_models'
+
+  cloak_id key:'my_key'
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: cloak_id
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Elle L.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: generator_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The cloak id gem allows developers to easily hide the actual (database)
+  id of resources through obfuscation.
+email:
+- elle@pandromos.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- cloak_id.gemspec
+- lib/cloak_id.rb
+- lib/cloak_id/cloak_id_encoder.rb
+- lib/cloak_id/errors.rb
+- lib/cloak_id/version.rb
+- lib/generators/cloak_id/install/install_generator.rb
+- lib/generators/cloak_id/install/templates/cloak_id.rb.erb
+- spec/cloak_id/cloak_id_encoder_spec.rb
+- spec/cloak_id/cloak_id_spec.rb
+- spec/cloak_id/install_generator_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/support/test_model.rb
+homepage: https://github.com/elleleb/cloak_id
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Gem to help obfuscate Active Record ids.
+test_files:
+- spec/cloak_id/cloak_id_encoder_spec.rb
+- spec/cloak_id/cloak_id_spec.rb
+- spec/cloak_id/install_generator_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/support/test_model.rb