attr_encrypted 1.1.2 → 1.2.0

data/lib/attr_encrypted/adapters/active_record.rb

@@ -2,13 +2,15 @@ if defined?(ActiveRecord)
   module AttrEncrypted
     module Adapters
       module ActiveRecord
-        def self.extended(base)
-          base.attr_encrypted_options[:encode] = true
-          base.eigenclass_eval { alias_method_chain :method_missing, :attr_encrypted }
+        def self.extended(base) # :nodoc:
+          base.class_eval do
+            attr_encrypted_options[:encode] = true
+            class << self; alias_method_chain :method_missing, :attr_encrypted; end
+          end
         end
-        
+
         protected
-        
+
           # Ensures the attribute methods for db fields have been defined before calling the original 
           # <tt>attr_encrypted</tt> method
           def attr_encrypted(*attrs)
@@ -16,7 +18,7 @@ if defined?(ActiveRecord)
             super
             attrs.reject { |attr| attr.is_a?(Hash) }.each { |attr| alias_method "#{attr}_before_type_cast", attr }
           end
-          
+
           # Allows you to use dynamic methods like <tt>find_by_email</tt> or <tt>scoped_by_email</tt> for 
           # encrypted attributes
           #
@@ -40,7 +42,7 @@ if defined?(ActiveRecord)
               attribute_names.each_with_index do |attribute, index|
                 if attr_encrypted?(attribute)
                   args[index] = send("encrypt_#{attribute}", args[index])
-                  attribute_names[index] = encrypted_attributes[attribute]
+                  attribute_names[index] = encrypted_attributes[attribute.to_sym][:attribute]
                 end
               end
               method = "#{match.captures[0]}_#{match.captures[1]}_#{attribute_names.join('_and_')}".to_sym
@@ -50,6 +52,6 @@ if defined?(ActiveRecord)
       end
     end
   end
-  
+
   ActiveRecord::Base.extend AttrEncrypted::Adapters::ActiveRecord
 end

data/lib/attr_encrypted/adapters/data_mapper.rb

@@ -2,13 +2,13 @@ if defined?(DataMapper)
   module AttrEncrypted
     module Adapters
       module DataMapper
-        def self.extended(base)
-          base.eigenclass_eval do 
+        def self.extended(base) # :nodoc:
+          class << base
             alias_method :included_without_attr_encrypted, :included
             alias_method :included, :included_with_attr_encrypted
           end
         end
-        
+
         def included_with_attr_encrypted(base)
           included_without_attr_encrypted(base)
           base.attr_encrypted_options[:encode] = true
@@ -16,6 +16,6 @@ if defined?(DataMapper)
       end
     end
   end
-  
+
   DataMapper::Resource.extend AttrEncrypted::Adapters::DataMapper
 end

data/lib/attr_encrypted/adapters/sequel.rb

@@ -2,12 +2,12 @@ if defined?(Sequel)
   module AttrEncrypted
     module Adapters
       module Sequel
-        def self.extended(base)
+        def self.extended(base) # :nodoc:
           base.attr_encrypted_options[:encode] = true
         end
       end
     end
   end
-  
+
   Sequel::Model.extend AttrEncrypted::Adapters::Sequel
 end

data/lib/attr_encrypted/version.rb

@@ -0,0 +1,17 @@
+module AttrEncrypted
+  # Contains information about this gem's version
+  module Version
+    MAJOR = 1
+    MINOR = 2
+    PATCH = 0
+
+    # Returns a version string by joining <tt>MAJOR</tt>, <tt>MINOR</tt>, and <tt>PATCH</tt> with <tt>'.'</tt>
+    #
+    # Example
+    #
+    #   Version.string # '1.0.2'
+    def self.string
+      [MAJOR, MINOR, PATCH].join('.')
+    end
+  end
+end

data/test/active_record_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path('../test_helper', __FILE__)
 
 ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
 
@@ -18,15 +18,25 @@ end
 # The table needs to exist before defining the class
 create_people_table
 
+ActiveRecord::MissingAttributeError = ActiveModel::MissingAttributeError unless defined?(ActiveRecord::MissingAttributeError)
+
 class Person < ActiveRecord::Base
   attr_encrypted :email, :key => 'a secret key'
   attr_encrypted :credentials, :key => Proc.new { |user| Encryptor.encrypt(:value => user.salt, :key => 'some private key') }, :marshal => true
-  
-  def after_initialize
-    self.salt ||= Digest::SHA256.hexdigest((Time.now.to_i * rand(5)).to_s)
-    self.credentials ||= { :username => 'example', :password => 'test' }
-  rescue ActiveRecord::MissingAttributeError
-  end
+
+  ActiveSupport::Deprecation.silenced = true
+  def after_initialize; end
+  ActiveSupport::Deprecation.silenced = false
+
+  after_initialize :initialize_salt_and_credentials
+
+  protected
+
+    def initialize_salt_and_credentials
+      self.salt ||= Digest::SHA256.hexdigest((Time.now.to_i * rand(5)).to_s)
+      self.credentials ||= { :username => 'example', :password => 'test' }
+    rescue ActiveRecord::MissingAttributeError
+    end
 end
 
 class PersonWithValidation < Person
@@ -35,64 +45,64 @@ class PersonWithValidation < Person
 end
 
 class ActiveRecordTest < Test::Unit::TestCase
-  
+
   def setup
     ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
     create_people_table
   end
-  
+
   def test_should_encrypt_email
     @person = Person.create :email => 'test@example.com'
     assert_not_nil @person.encrypted_email
     assert_not_equal @person.email, @person.encrypted_email
     assert_equal @person.email, Person.find(:first).email
   end
-  
+
   def test_should_marshal_and_encrypt_credentials
     @person = Person.create
     assert_not_nil @person.encrypted_credentials
     assert_not_equal @person.credentials, @person.encrypted_credentials
     assert_equal @person.credentials, Person.find(:first).credentials
   end
-  
+
   def test_should_find_by_email
     @person = Person.create(:email => 'test@example.com')
     assert_equal @person, Person.find_by_email('test@example.com')
   end
-  
+
   def test_should_find_by_email_and_password
     Person.create(:email => 'test@example.com', :password => 'invalid')
     @person = Person.create(:email => 'test@example.com', :password => 'test')
     assert_equal @person, Person.find_by_email_and_password('test@example.com', 'test')
   end
-  
+
   def test_should_scope_by_email
     @person = Person.create(:email => 'test@example.com')
     assert_equal @person, Person.scoped_by_email('test@example.com').find(:first) rescue NoMethodError
   end
-  
+
   def test_should_scope_by_email_and_password
     Person.create(:email => 'test@example.com', :password => 'invalid')
     @person = Person.create(:email => 'test@example.com', :password => 'test')
     assert_equal @person, Person.scoped_by_email_and_password('test@example.com', 'test').find(:first) rescue NoMethodError
   end
-  
+
   def test_should_encode_by_default
     assert Person.attr_encrypted_options[:encode]
   end
-  
+
   def test_should_validate_presence_of_email
     @person = PersonWithValidation.new
     assert !@person.valid?
-    assert @person.errors.on(:email)
+    assert !@person.errors[:email].empty? || @person.errors.on(:email)
   end
-  
+
   def test_should_validate_uniqueness_of_email
     @person = PersonWithValidation.new :email => 'test@example.com'
     assert @person.save
     @person2 = PersonWithValidation.new :email => @person.email
     assert !@person2.valid?
-    assert @person2.errors.on(:encrypted_email)
+    assert !@person2.errors[:encrypted_email].empty? || @person2.errors.on(:encrypted_email)
   end
-  
+
 end

data/test/attr_encrypted_test.rb

@@ -1,11 +1,10 @@
-require File.dirname(__FILE__) + '/test_helper'
-require 'mocha'
+require File.expand_path('../test_helper', __FILE__)
 
 class SillyEncryptor
   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
@@ -13,7 +12,7 @@ end
 
 class User
   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'
@@ -26,12 +25,12 @@ class User
   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
@@ -49,48 +48,48 @@ class SomeOtherClass
 end
 
 class AttrEncryptedTest < Test::Unit::TestCase
-  
+
   def test_should_store_email_in_encrypted_attributes
-    assert User.encrypted_attributes.include?('email')
+    assert User.encrypted_attributes.include?(:email)
   end
-  
+
   def test_should_not_store_salt_in_encrypted_attributes
-    assert !User.encrypted_attributes.include?('salt')
+    assert !User.encrypted_attributes.include?(:salt)
   end
-  
+
   def test_attr_encrypted_should_return_true_for_email
     assert User.attr_encrypted?('email')
   end
-  
+
   def test_attr_encrypted_should_return_false_for_salt
     assert !User.attr_encrypted?('salt')
   end
-  
+
   def test_should_generate_an_encrypted_attribute
     assert User.new.respond_to?(:encrypted_email)
   end
-  
+
   def test_should_generate_an_encrypted_attribute_with_a_prefix_and_suffix
     assert User.new.respond_to?(:crypted_password_test)
   end
-  
+
   def test_should_generate_an_encrypted_attribute_with_the_attribute_option
     assert User.new.respond_to?(:ssn_encrypted)
   end
-  
+
   def test_should_not_encrypt_nil_value
     assert_nil User.encrypt_email(nil)
   end
-  
+
   def test_should_not_encrypt_empty_string
     assert_equal '', User.encrypt_email('')
   end
-  
+
   def test_should_encrypt_email
     assert_not_nil User.encrypt_email('test@example.com')
     assert_not_equal 'test@example.com', User.encrypt_email('test@example.com')
   end
-  
+
   def test_should_encrypt_email_when_modifying_the_attr_writer
     @user = User.new
     assert_nil @user.encrypted_email
@@ -98,55 +97,55 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_not_nil @user.encrypted_email
     assert_equal User.encrypt_email('test@example.com'), @user.encrypted_email
   end
-  
+
   def test_should_not_decrypt_nil_value
     assert_nil User.decrypt_email(nil)
   end
-  
+
   def test_should_not_decrypt_empty_string
     assert_equal '', User.decrypt_email('')
   end
-  
+
   def test_should_decrypt_email
     encrypted_email = User.encrypt_email('test@example.com')
     assert_not_equal 'test@test.com', encrypted_email
     assert_equal 'test@example.com', User.decrypt_email(encrypted_email)
   end
-  
+
   def test_should_decrypt_email_when_reading
     @user = User.new
     assert_nil @user.email
     @user.encrypted_email = User.encrypt_email('test@example.com')
     assert_equal 'test@example.com', @user.email
   end
-  
+
   def test_should_encrypt_with_encoding
-    assert_equal User.encrypt_with_encoding('test'), [User.encrypt_without_encoding('test')].pack('m*')
+    assert_equal User.encrypt_with_encoding('test'), [User.encrypt_without_encoding('test')].pack('m')
   end
-  
+
   def test_should_decrypt_with_encoding
     encrypted = User.encrypt_with_encoding('test')
     assert_equal 'test', User.decrypt_with_encoding(encrypted)
-    assert_equal User.decrypt_with_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m*').to_s)
+    assert_equal User.decrypt_with_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m').first)
   end
-  
+
   def test_should_encrypt_with_custom_encoding
     assert_equal User.encrypt_with_encoding('test'), [User.encrypt_without_encoding('test')].pack('m')
   end
-  
+
   def test_should_decrypt_with_custom_encoding
     encrypted = User.encrypt_with_encoding('test')
     assert_equal 'test', User.decrypt_with_encoding(encrypted)
-    assert_equal User.decrypt_with_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m').to_s)
+    assert_equal User.decrypt_with_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m').first)
   end
-  
+
   def test_should_encrypt_with_marshaling
     @user = User.new
     @user.with_marshaling = [1, 2, 3]
     assert_not_nil @user.encrypted_with_marshaling
     assert_equal User.encrypt_with_marshaling([1, 2, 3]), @user.encrypted_with_marshaling
   end
-  
+
   def test_should_decrypt_with_marshaling
     encrypted = User.encrypt_with_marshaling([1, 2, 3])
     @user = User.new
@@ -154,11 +153,11 @@ class AttrEncryptedTest < Test::Unit::TestCase
     @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 SillyEncryptor.silly_encrypt(:value => 'testing', :some_arg => 'test'), User.encrypt_credit_card('testing')
   end
-  
+
   def test_should_evaluate_a_key_passed_as_a_symbol
     @user = User.new
     assert_nil @user.ssn_encrypted
@@ -166,7 +165,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_not_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 = User.new
     assert_nil @user.crypted_password_test
@@ -174,7 +173,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_not_nil @user.crypted_password_test
     assert_equal Encryptor.encrypt(:value => 'testing', :key => 'User'), @user.crypted_password_test
   end
-  
+
   def test_should_use_options_found_in_the_attr_encrypted_options_attribute
     @user = User.new
     assert_nil @user.crypted_password_test
@@ -182,41 +181,41 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_not_nil @user.crypted_password_test
     assert_equal Encryptor.encrypt(:value => 'testing', :key => 'User'), @user.crypted_password_test
   end
-  
+
   def test_should_inherit_encrypted_attributes
-    assert_equal User.encrypted_attributes.merge('testing' => 'encrypted_testing'), Admin.encrypted_attributes
+    assert_equal [User.encrypted_attributes.keys, :testing].flatten.collect { |key| key.to_s }.sort, Admin.encrypted_attributes.keys.collect { |key| key.to_s }.sort
   end
-  
+
   def test_should_inherit_attr_encrypted_options
     assert !User.attr_encrypted_options.empty?
     assert_equal User.attr_encrypted_options, Admin.attr_encrypted_options
   end
-  
+
   def test_should_not_inherit_unrelated_attributes
     assert SomeOtherClass.attr_encrypted_options.empty?
     assert SomeOtherClass.encrypted_attributes.empty?
   end
-  
+
   def test_should_evaluate_a_symbol_option
-    assert_equal Object, Object.send(:evaluate_attr_encrypted_option, :class, Object.new)
+    assert_equal Object, Object.new.send(:evaluate_attr_encrypted_option, :class)
   end
-  
+
   def test_should_evaluate_a_proc_option
-    assert_equal Object, Object.send(:evaluate_attr_encrypted_option, proc { |object| object.class }, Object.new)
+    assert_equal Object, Object.new.send(:evaluate_attr_encrypted_option, proc { |object| object.class })
   end
-  
+
   def test_should_evaluate_a_lambda_option
-    assert_equal Object, Object.send(:evaluate_attr_encrypted_option, lambda { |object| object.class }, Object.new)
+    assert_equal Object, Object.new.send(:evaluate_attr_encrypted_option, lambda { |object| object.class })
   end
-  
+
   def test_should_evaluate_a_method_option
-    assert_equal Object, Object.send(:evaluate_attr_encrypted_option, SomeOtherClass.method(:call), Object.new)
+    assert_equal Object, Object.new.send(:evaluate_attr_encrypted_option, SomeOtherClass.method(:call))
   end
-  
+
   def test_should_return_a_string_option
-    assert_equal 'Object', Object.send(:evaluate_attr_encrypted_option, 'Object', Object.new)
+    assert_equal 'Object', Object.new.send(:evaluate_attr_encrypted_option, 'Object')
   end
-  
+
   def test_should_encrypt_with_true_if
     @user = User.new
     assert_nil @user.encrypted_with_true_if
@@ -224,7 +223,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_not_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 = User.new
     assert_nil @user.encrypted_with_false_if
@@ -232,7 +231,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_not_nil @user.encrypted_with_false_if
     assert_equal 'testing', @user.encrypted_with_false_if
   end
-  
+
   def test_should_encrypt_with_false_unless
     @user = User.new
     assert_nil @user.encrypted_with_false_unless
@@ -240,7 +239,7 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_not_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 = User.new
     assert_nil @user.encrypted_with_true_unless
@@ -248,11 +247,11 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_not_nil @user.encrypted_with_true_unless
     assert_equal 'testing', @user.encrypted_with_true_unless
   end
-  
+
   def test_should_work_with_aliased_attr_encryptor
-    assert User.encrypted_attributes.include?('aliased')
+    assert User.encrypted_attributes.include?(:aliased)
   end
-  
+
   def test_should_always_reset_options
     @user = User.new
     @user.with_if_changed = "encrypt_stuff"
@@ -261,12 +260,12 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_raise RuntimeError do 
       @user.with_if_changed
     end
-    
+
     @user = User.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
-  
+
 end