attr_encrypted-magicless 1.3.42

data/test/legacy_attr_encrypted_test.rb

@@ -0,0 +1,306 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../test_helper', __FILE__)
+
+class LegacySillyEncryptor
+  def self.silly_encrypt(options)
+    (options[:value] + options[:some_arg]).reverse
+  end
+
+  def self.silly_decrypt(options)
+    options[:value].reverse.gsub(/#{options[:some_arg]}$/, '')
+  end
+end
+
+class LegacyUser
+  include AttrEncrypted
+
+  self.attr_encrypted_options[:key] = Proc.new { |user| user.class.to_s } # default key
+
+  attr_encrypted :email, :without_encoding, :key => 'secret key'
+  attr_encrypted :password, :prefix => 'crypted_', :suffix => '_test'
+  attr_encrypted :ssn, :key => :salt, :attribute => 'ssn_encrypted'
+  attr_encrypted :credit_card, :encryptor => LegacySillyEncryptor, :encrypt_method => :silly_encrypt, :decrypt_method => :silly_decrypt, :some_arg => 'test'
+  attr_encrypted :with_encoding, :key => 'secret key', :encode => true
+  attr_encrypted :with_custom_encoding, :key => 'secret key', :encode => 'm'
+  attr_encrypted :with_marshaling, :key => 'secret key', :marshal => true
+  attr_encrypted :with_true_if, :key => 'secret key', :if => true
+  attr_encrypted :with_false_if, :key => 'secret key', :if => false
+  attr_encrypted :with_true_unless, :key => 'secret key', :unless => true
+  attr_encrypted :with_false_unless, :key => 'secret key', :unless => false
+  attr_encrypted :with_if_changed, :key => 'secret key', :if => :should_encrypt
+
+  attr_encryptor :aliased, :key => 'secret_key'
+
+  attr_accessor :salt
+  attr_accessor :should_encrypt
+
+  def initialize
+    self.salt = Time.now.to_i.to_s
+    self.should_encrypt = true
+  end
+end
+
+class LegacyAdmin < LegacyUser
+  attr_encrypted :testing
+end
+
+class LegacySomeOtherClass
+  include AttrEncrypted
+
+  def self.call(object)
+    object.class
+  end
+end
+
+class CryptedObject
+  include AttrEncrypted
+end
+
+
+class LegacyAttrEncryptedTest < Minitest::Test
+
+  def test_should_store_email_in_encrypted_attributes
+    assert LegacyUser.encrypted_attributes.include?(:email)
+  end
+
+  def test_should_not_store_salt_in_encrypted_attributes
+    assert !LegacyUser.encrypted_attributes.include?(:salt)
+  end
+
+  def test_attr_encrypted_should_return_true_for_email
+    assert LegacyUser.attr_encrypted?('email')
+  end
+
+  def test_attr_encrypted_should_not_use_the_same_attribute_name_for_two_attributes_in_the_same_line
+    refute_equal LegacyUser.encrypted_attributes[:email][:attribute], LegacyUser.encrypted_attributes[:without_encoding][:attribute]
+  end
+
+  def test_attr_encrypted_should_return_false_for_salt
+    assert !LegacyUser.attr_encrypted?('salt')
+  end
+
+  def test_should_generate_an_encrypted_attribute
+    assert LegacyUser.new.respond_to?(:encrypted_email)
+  end
+
+  def test_should_generate_an_encrypted_attribute_with_a_prefix_and_suffix
+    assert LegacyUser.new.respond_to?(:crypted_password_test)
+  end
+
+  def test_should_generate_an_encrypted_attribute_with_the_attribute_option
+    assert LegacyUser.new.respond_to?(:ssn_encrypted)
+  end
+
+  def test_should_not_encrypt_nil_value
+    assert_nil LegacyUser.encrypt_email(nil)
+  end
+
+  def test_should_not_encrypt_empty_string
+    assert_equal '', LegacyUser.encrypt_email('')
+  end
+
+  def test_should_encrypt_email
+    refute_nil LegacyUser.encrypt_email('test@example.com')
+    refute_equal 'test@example.com', LegacyUser.encrypt_email('test@example.com')
+  end
+
+  def test_should_encrypt_email_when_modifying_the_attr_writer
+    @user = LegacyUser.new
+    assert_nil @user.encrypted_email
+    @user.email = 'test@example.com'
+    refute_nil @user.encrypted_email
+    assert_equal LegacyUser.encrypt_email('test@example.com'), @user.encrypted_email
+  end
+
+  def test_should_not_decrypt_nil_value
+    assert_nil LegacyUser.decrypt_email(nil)
+  end
+
+  def test_should_not_decrypt_empty_string
+    assert_equal '', LegacyUser.decrypt_email('')
+  end
+
+  def test_should_decrypt_email
+    encrypted_email = LegacyUser.encrypt_email('test@example.com')
+    refute_equal 'test@test.com', encrypted_email
+    assert_equal 'test@example.com', LegacyUser.decrypt_email(encrypted_email)
+  end
+
+  def test_should_decrypt_email_when_reading
+    @user = LegacyUser.new
+    assert_nil @user.email
+    @user.encrypted_email = LegacyUser.encrypt_email('test@example.com')
+    assert_equal 'test@example.com', @user.email
+  end
+
+  def test_should_encrypt_with_encoding
+    assert_equal LegacyUser.encrypt_with_encoding('test'), [LegacyUser.encrypt_without_encoding('test')].pack('m')
+  end
+
+  def test_should_decrypt_with_encoding
+    encrypted = LegacyUser.encrypt_with_encoding('test')
+    assert_equal 'test', LegacyUser.decrypt_with_encoding(encrypted)
+    assert_equal LegacyUser.decrypt_with_encoding(encrypted), LegacyUser.decrypt_without_encoding(encrypted.unpack('m').first)
+  end
+
+  def test_should_decrypt_utf8_with_encoding
+    encrypted = LegacyUser.encrypt_with_encoding("test\xC2\xA0utf-8\xC2\xA0text")
+    assert_equal "test\xC2\xA0utf-8\xC2\xA0text", LegacyUser.decrypt_with_encoding(encrypted)
+    assert_equal LegacyUser.decrypt_with_encoding(encrypted), LegacyUser.decrypt_without_encoding(encrypted.unpack('m').first)
+  end
+
+  def test_should_encrypt_with_custom_encoding
+    assert_equal LegacyUser.encrypt_with_custom_encoding('test'), [LegacyUser.encrypt_without_encoding('test')].pack('m')
+  end
+
+  def test_should_decrypt_with_custom_encoding
+    encrypted = LegacyUser.encrypt_with_custom_encoding('test')
+    assert_equal 'test', LegacyUser.decrypt_with_custom_encoding(encrypted)
+    assert_equal LegacyUser.decrypt_with_custom_encoding(encrypted), LegacyUser.decrypt_without_encoding(encrypted.unpack('m').first)
+  end
+
+  def test_should_encrypt_with_marshaling
+    @user = LegacyUser.new
+    @user.with_marshaling = [1, 2, 3]
+    refute_nil @user.encrypted_with_marshaling
+    assert_equal LegacyUser.encrypt_with_marshaling([1, 2, 3]), @user.encrypted_with_marshaling
+  end
+
+  def test_should_decrypt_with_marshaling
+    encrypted = LegacyUser.encrypt_with_marshaling([1, 2, 3])
+    @user = LegacyUser.new
+    assert_nil @user.with_marshaling
+    @user.encrypted_with_marshaling = encrypted
+    assert_equal [1, 2, 3], @user.with_marshaling
+  end
+
+  def test_should_use_custom_encryptor_and_crypt_method_names_and_arguments
+    assert_equal LegacySillyEncryptor.silly_encrypt(:value => 'testing', :some_arg => 'test'), LegacyUser.encrypt_credit_card('testing')
+  end
+
+  def test_should_evaluate_a_key_passed_as_a_symbol
+    @user = LegacyUser.new
+    assert_nil @user.ssn_encrypted
+    @user.ssn = 'testing'
+    refute_nil @user.ssn_encrypted
+    assert_equal Encryptor.encrypt(:value => 'testing', :key => @user.salt), @user.ssn_encrypted
+  end
+
+  def test_should_evaluate_a_key_passed_as_a_proc
+    @user = LegacyUser.new
+    assert_nil @user.crypted_password_test
+    @user.password = 'testing'
+    refute_nil @user.crypted_password_test
+    assert_equal Encryptor.encrypt(:value => 'testing', :key => 'LegacyUser'), @user.crypted_password_test
+  end
+
+  def test_should_use_options_found_in_the_attr_encrypted_options_attribute
+    @user = LegacyUser.new
+    assert_nil @user.crypted_password_test
+    @user.password = 'testing'
+    refute_nil @user.crypted_password_test
+    assert_equal Encryptor.encrypt(:value => 'testing', :key => 'LegacyUser'), @user.crypted_password_test
+  end
+
+  def test_should_inherit_encrypted_attributes
+    assert_equal [LegacyUser.encrypted_attributes.keys, :testing].flatten.collect { |key| key.to_s }.sort, LegacyAdmin.encrypted_attributes.keys.collect { |key| key.to_s }.sort
+  end
+
+  def test_should_inherit_attr_encrypted_options
+    assert !LegacyUser.attr_encrypted_options.empty?
+    assert_equal LegacyUser.attr_encrypted_options, LegacyAdmin.attr_encrypted_options
+  end
+
+  def test_should_not_inherit_unrelated_attributes
+    assert LegacySomeOtherClass.attr_encrypted_options.empty?
+    assert LegacySomeOtherClass.encrypted_attributes.empty?
+  end
+
+  def test_should_evaluate_a_symbol_option
+    assert_equal CryptedObject, CryptedObject.new.send(:evaluate_attr_encrypted_option, :class)
+  end
+
+  def test_should_evaluate_a_proc_option
+    assert_equal CryptedObject, CryptedObject.new.send(:evaluate_attr_encrypted_option, proc { |object| object.class })
+  end
+
+  def test_should_evaluate_a_lambda_option
+    assert_equal CryptedObject, CryptedObject.new.send(:evaluate_attr_encrypted_option, lambda { |object| object.class })
+  end
+
+  def test_should_evaluate_a_method_option
+    assert_equal CryptedObject, CryptedObject.new.send(:evaluate_attr_encrypted_option, LegacySomeOtherClass.method(:call))
+  end
+
+  def test_should_return_a_string_option
+    assert_equal 'CryptedObject', CryptedObject.new.send(:evaluate_attr_encrypted_option, 'CryptedObject')
+  end
+
+  def test_should_encrypt_with_true_if
+    @user = LegacyUser.new
+    assert_nil @user.encrypted_with_true_if
+    @user.with_true_if = 'testing'
+    refute_nil @user.encrypted_with_true_if
+    assert_equal Encryptor.encrypt(:value => 'testing', :key => 'secret key'), @user.encrypted_with_true_if
+  end
+
+  def test_should_not_encrypt_with_false_if
+    @user = LegacyUser.new
+    assert_nil @user.encrypted_with_false_if
+    @user.with_false_if = 'testing'
+    refute_nil @user.encrypted_with_false_if
+    assert_equal 'testing', @user.encrypted_with_false_if
+  end
+
+  def test_should_encrypt_with_false_unless
+    @user = LegacyUser.new
+    assert_nil @user.encrypted_with_false_unless
+    @user.with_false_unless = 'testing'
+    refute_nil @user.encrypted_with_false_unless
+    assert_equal Encryptor.encrypt(:value => 'testing', :key => 'secret key'), @user.encrypted_with_false_unless
+  end
+
+  def test_should_not_encrypt_with_true_unless
+    @user = LegacyUser.new
+    assert_nil @user.encrypted_with_true_unless
+    @user.with_true_unless = 'testing'
+    refute_nil @user.encrypted_with_true_unless
+    assert_equal 'testing', @user.encrypted_with_true_unless
+  end
+
+  def test_should_work_with_aliased_attr_encryptor
+    assert LegacyUser.encrypted_attributes.include?(:aliased)
+  end
+
+  def test_should_always_reset_options
+    @user = LegacyUser.new
+    @user.with_if_changed = "encrypt_stuff"
+    @user.stubs(:instance_variable_get).returns(nil)
+    @user.stubs(:instance_variable_set).raises("BadStuff")
+    assert_raises RuntimeError do
+      @user.with_if_changed
+    end
+
+    @user = LegacyUser.new
+    @user.should_encrypt = false
+    @user.with_if_changed = "not_encrypted_stuff"
+    assert_equal "not_encrypted_stuff", @user.with_if_changed
+    assert_equal "not_encrypted_stuff", @user.encrypted_with_if_changed
+  end
+
+  def test_should_cast_values_as_strings_before_encrypting
+    string_encrypted_email = LegacyUser.encrypt_email('3')
+    assert_equal string_encrypted_email, LegacyUser.encrypt_email(3)
+    assert_equal '3', LegacyUser.decrypt_email(string_encrypted_email)
+  end
+
+  def test_should_create_query_accessor
+    @user = LegacyUser.new
+    assert !@user.email?
+    @user.email = ''
+    assert !@user.email?
+    @user.email = 'test@example.com'
+    assert @user.email?
+  end
+
+end

data/test/legacy_compatibility_test.rb

@@ -0,0 +1,87 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../test_helper', __FILE__)
+
+# Test to ensure that existing representations in database do not break on
+# migrating to new versions of this gem. This ensures that future versions of
+# this gem will retain backwards compatibility with data generated by earlier
+# versions.
+class LegacyCompatibilityTest < Minitest::Test
+  class LegacyNonmarshallingPet < ActiveRecord::Base
+    PET_NICKNAME_SALT = Digest::SHA256.hexdigest('my-really-really-secret-pet-nickname-salt')
+    PET_NICKNAME_KEY = 'my-really-really-secret-pet-nickname-key'
+    PET_BIRTHDATE_SALT = Digest::SHA256.hexdigest('my-really-really-secret-pet-birthdate-salt')
+    PET_BIRTHDATE_KEY = 'my-really-really-secret-pet-birthdate-key'
+
+    attr_encrypted :nickname,
+      :key => proc { Encryptor.encrypt(:value => PET_NICKNAME_SALT, :key => PET_NICKNAME_KEY) }
+    attr_encrypted :birthdate,
+      :key => proc { Encryptor.encrypt(:value => PET_BIRTHDATE_SALT, :key => PET_BIRTHDATE_KEY) }
+  end
+
+  class LegacyMarshallingPet < ActiveRecord::Base
+    PET_NICKNAME_SALT = Digest::SHA256.hexdigest('my-really-really-secret-pet-nickname-salt')
+    PET_NICKNAME_KEY = 'my-really-really-secret-pet-nickname-key'
+    PET_BIRTHDATE_SALT = Digest::SHA256.hexdigest('my-really-really-secret-pet-birthdate-salt')
+    PET_BIRTHDATE_KEY = 'my-really-really-secret-pet-birthdate-key'
+
+    attr_encrypted :nickname,
+      :key => proc { Encryptor.encrypt(:value => PET_NICKNAME_SALT, :key => PET_NICKNAME_KEY) },
+      :marshal => true
+    attr_encrypted :birthdate,
+      :key => proc { Encryptor.encrypt(:value => PET_BIRTHDATE_SALT, :key => PET_BIRTHDATE_KEY) },
+      :marshal => true
+  end
+
+  def setup
+    ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
+    create_tables
+  end
+
+  def test_nonmarshalling_backwards_compatibility
+    pet = LegacyNonmarshallingPet.create!(
+      :name => 'Fido',
+      :encrypted_nickname => 'uSUB6KGzta87yxesyVc3DA==',
+      :encrypted_birthdate => 'I3d691B2PtFXLx15kO067g=='
+    )
+
+    assert_equal 'Fido', pet.name
+    assert_equal 'Fido the Dog', pet.nickname
+    assert_equal '2011-07-09', pet.birthdate
+  end
+
+  def test_marshalling_backwards_compatibility
+    pet = LegacyMarshallingPet.create!(
+      :name => 'Fido',
+      :encrypted_nickname => '7RwoT64in4H+fGVBPYtRcN0K4RtriIy1EP4nDojUa8g=',
+      :encrypted_birthdate => 'bSp9sJhXQSp2QlNZHiujtcK4lRVBE8HQhn1y7moQ63bGJR20hvRSZ73ePAmm+wc5'
+    )
+
+    assert_equal 'Fido', pet.name
+    assert_equal 'Mummy\'s little helper', pet.nickname
+
+    assert_equal Date.new(2011, 7, 9), pet.birthdate
+  end
+
+  private
+
+  def create_tables
+    silence_stream(STDOUT) do
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :legacy_nonmarshalling_pets do |t|
+          t.string :name
+          t.string :encrypted_nickname
+          t.string :encrypted_birthdate
+          t.string :salt
+        end
+        create_table :legacy_marshalling_pets do |t|
+          t.string :name
+          t.string :encrypted_nickname
+          t.string :encrypted_birthdate
+          t.string :salt
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+if RUBY_VERSION >= '1.9.3'
+  require 'simplecov'
+  require 'simplecov-rcov'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    SimpleCov::Formatter::RcovFormatter,
+  ]
+
+  SimpleCov.start do
+    add_filter 'test'
+  end
+end
+
+# ENV['ACTIVE_RECORD_VERSION'] ||= ENV['ACTIVERECORD']
+
+require 'minitest'
+require 'minitest/autorun'
+require 'digest/sha2'
+require 'rubygems'
+gem 'activerecord', ENV['ACTIVE_RECORD_VERSION'] if ENV['ACTIVE_RECORD_VERSION']
+require 'active_record'
+require 'mocha/test_unit'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.dirname(__FILE__))
+require 'attr_encrypted'
+
+require 'active_support/lazy_load_hooks'
+
+ActiveSupport.on_load(:active_record) do
+  include AttrEncrypted
+end
+
+puts "\nTesting with ActiveRecord #{ActiveRecord::VERSION::STRING rescue ENV['ACTIVE_RECORD_VERSION']}"
+
+SECRET_KEY = 4.times.map { Digest::SHA256.hexdigest((Time.now.to_i * rand(5)).to_s) }.join
+

metadata

@@ -0,0 +1,245 @@
+--- !ruby/object:Gem::Specification
+name: attr_encrypted-magicless
+version: !ruby/object:Gem::Version
+  version: 1.3.42
+platform: ruby
+authors:
+- Sean Huber
+- S. Brent Faulkner
+- William Monk
+- Stephen Aghaulor
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: encryptor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: rdoc
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.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: simplecov-rcov
+  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: Generates attr_accessors that encrypt and decrypt attributes transparently
+email:
+- shuber@huberry.com
+- sbfaulkner@gmail.com
+- billy.monk@gmail.com
+- saghaulor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- attr_encrypted-magicless.gemspec
+- lib/attr_encrypted-magicless.rb
+- lib/attr_encrypted.rb
+- lib/attr_encrypted/adapters/active_record.rb
+- lib/attr_encrypted/version.rb
+- test/active_record_test.rb
+- test/attr_encrypted_test.rb
+- test/compatibility_test.rb
+- test/legacy_active_record_test.rb
+- test/legacy_attr_encrypted_test.rb
+- test/legacy_compatibility_test.rb
+- test/test_helper.rb
+homepage: https://github.com/estum/attr_encrypted
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--line-numbers"
+- "--inline-source"
+- "--main"
+- README.rdoc
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Encrypt and decrypt attributes
+test_files:
+- test/active_record_test.rb
+- test/attr_encrypted_test.rb
+- test/compatibility_test.rb
+- test/legacy_active_record_test.rb
+- test/legacy_attr_encrypted_test.rb
+- test/legacy_compatibility_test.rb
+- test/test_helper.rb
+has_rdoc: false