shuber-attr_encrypted 1.0.1 → 1.0.2

data/CHANGELOG

@@ -5,6 +5,8 @@
   * Add support for data mapper
   * Attribute methods are now defined before calling attr_encrypted when using active record
   * Add ability to specify your own encoding directives
+  * Update logic that evaluates symbol and proc options
+  * Add support for :if and :unless options
 
 2009-01-07 - Sean Huber (shuber@huberry.com)
   * Initial commit

data/README.markdown

@@ -104,6 +104,19 @@ You can pass a proc object as the `:key` option as well:
 	end
 
 
+### Conditional encrypting ###
+
+There may be times that you want to only encrypt when certain conditions are met. For example maybe you're using rails and you don't want to encrypt 
+attributes when you're in development mode. You can specify conditions like this:
+
+	class User
+	  attr_encrypted :email, :key => 'a secret key', :unless => Rails.env.development?
+	end
+
+You can specify both `:if` and `:unless` options. If you pass a symbol representing an instance method then the result of the method will be evaluated. 
+Any objects that respond to :call are evaluated as well.
+
+
 ### Custom encryptor ###
 
 The [Huberry::Encryptor](http://github.com/shuber/encryptor) class is used by default. You may use your own custom encryptor by specifying

data/lib/huberry/class.rb

@@ -23,8 +23,8 @@ module Huberry
       #
       #   :key            => The encryption key. This option may not be required if you're using a custom encryptor. If you pass 
       #                      a symbol representing an instance method then the :key option will be replaced with the result of the 
-      #                      method before being passed to the encryptor. Proc objects are evaluated as well. Any other key types 
-      #                      will be passed directly to the encryptor.
+      #                      method before being passed to the encryptor. Objects that respond to :call are evaluated as well (including procs). 
+      #                      Any other key types will be passed directly to the encryptor.
       #
       #   :encode         => If set to true, attributes will be encoded as well as encrypted. This is useful if you're
       #                      planning on storing the encrypted attributes in a database. The default encoding is 'm*' (base64), 
@@ -42,6 +42,13 @@ module Huberry
       #
       #   :decrypt_method => The decrypt method name to call on the <tt>:encryptor</tt> object. Defaults to :decrypt.
       #
+      #   :if             => Attributes are only encrypted if this option evaluates to true. If you pass a symbol representing an instance 
+      #                      method then the result of the method will be evaluated. Any objects that respond to :call are evaluated as well. 
+      #                      Defaults to true.
+      #
+      #   :unless         => Attributes are only encrypted if this option evaluates to false. If you pass a symbol representing an instance 
+      #                      method then the result of the method will be evaluated. Any objects that respond to :call are evaluated as well. 
+      #                      Defaults to false.
       #
       # You can specify your own default options
       #
@@ -76,7 +83,9 @@ module Huberry
           :encrypt_method => :encrypt,
           :decrypt_method => :decrypt,
           :encode => false, 
-          :marshal => false 
+          :marshal => false, 
+          :if => true, 
+          :unless => false 
         }.merge(attr_encrypted_options).merge(attrs.last.is_a?(Hash) ? attrs.pop : {})
         options[:encode] = 'm*' if options[:encode] == true
         
@@ -88,57 +97,70 @@ module Huberry
           attr_accessor encrypted_attribute_name.to_sym unless instance_methods.include?(encrypted_attribute_name)
           
           define_class_method "encrypt_#{attribute}" do |value|
-            if value.nil?
-              encrypted_value = nil
+            if options[:if] && !options[:unless]
+              if value.nil?
+                encrypted_value = nil
+              else
+                value = Marshal.dump(value) if options[:marshal]
+                encrypted_value = options[:encryptor].send options[:encrypt_method], options.merge(:value => value)
+                encrypted_value = [encrypted_value].pack(options[:encode]) if options[:encode]
+              end
+              encrypted_value
             else
-              value = Marshal.dump(value) if options[:marshal]
-              encrypted_value = options[:encryptor].send options[:encrypt_method], options.merge(:value => value)
-              encrypted_value = [encrypted_value].pack(options[:encode]) if options[:encode]
+              value
             end
-            encrypted_value
           end
           
           define_class_method "decrypt_#{attribute}" do |encrypted_value|
-            if encrypted_value.nil?
-              decrypted_value = nil
+            if options[:if] && !options[:unless]
+              if encrypted_value.nil?
+                decrypted_value = nil
+              else
+                encrypted_value = encrypted_value.unpack(options[:encode]).to_s if options[:encode]
+                decrypted_value = options[:encryptor].send(options[:decrypt_method], options.merge(:value => encrypted_value))
+                decrypted_value = Marshal.load(decrypted_value) if options[:marshal]
+              end
+              decrypted_value
             else
-              encrypted_value = encrypted_value.unpack(options[:encode]).to_s if options[:encode]
-              decrypted_value = options[:encryptor].send(options[:decrypt_method], options.merge(:value => encrypted_value))
-              decrypted_value = Marshal.load(decrypted_value) if options[:marshal]
+              encrypted_value
             end
-            decrypted_value
           end
           
           define_method "#{attribute}" do
             value = instance_variable_get("@#{attribute}")
             encrypted_value = read_attribute(encrypted_attribute_name)
-            original_key = options[:key]
-            options[:key] = self.class.send :evaluate_attr_encrypted_key, options[:key], self
+            original_options = [:key, :if, :unless].inject({}) do |hash, option|
+              hash[option] = options[option]
+              options[option] = self.class.send :evaluate_attr_encrypted_option, options[option], self
+              hash
+            end
             value = instance_variable_set("@#{attribute}", self.class.send("decrypt_#{attribute}".to_sym, encrypted_value)) if value.nil? && !encrypted_value.nil?
-            options[:key] = original_key
+            options.merge!(original_options)
             value
           end
           
           define_method "#{attribute}=" do |value|
-            original_key = options[:key]
-            options[:key] = self.class.send :evaluate_attr_encrypted_key, options[:key], self
+            original_options = [:key, :if, :unless].inject({}) do |hash, option|
+              hash[option] = options[option]
+              options[option] = self.class.send :evaluate_attr_encrypted_option, options[option], self
+              hash
+            end
             write_attribute(encrypted_attribute_name, self.class.send("encrypt_#{attribute}".to_sym, value))
-            options[:key] = original_key
+            options.merge!(original_options)
             instance_variable_set("@#{attribute}", value)
           end
         end
       end
       
-      # Evaluates encryption keys specified as symbols (representing instance methods) or procs
-      # If the key is not a symbol or proc then the original key is returned
-      def evaluate_attr_encrypted_key(key, object)
-        case key
-        when Symbol
-          object.send(key)
-        when Proc
-          key.call(object)
+      # Evaluates an option specified as a symbol representing an instance method or a proc
+      # If the option is not a symbol or proc then the original option is returned
+      def evaluate_attr_encrypted_option(option, object)
+        if option.is_a?(Symbol) && object.respond_to?(option)
+          object.send(option)
+        elsif option.respond_to?(:call)
+          option.call(object)
         else
-          key
+          option
         end
       end
   end

data/test/attr_encrypted_test.rb

@@ -20,6 +20,10 @@ class User
   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_accessor :salt
   
   def initialize
@@ -32,6 +36,9 @@ class Admin < User
 end
 
 class SomeOtherClass
+  def self.call(object)
+    object.class
+  end
 end
 
 class AttrEncryptedTest < Test::Unit::TestCase
@@ -175,4 +182,56 @@ class AttrEncryptedTest < Test::Unit::TestCase
     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)
+  end
+  
+  def test_should_evaluate_a_proc_option
+    assert_equal Object, Object.send(:evaluate_attr_encrypted_option, proc { |object| object.class }, Object.new)
+  end
+  
+  def test_should_evaluate_a_lambda_option
+    assert_equal Object, Object.send(:evaluate_attr_encrypted_option, lambda { |object| object.class }, Object.new)
+  end
+  
+  def test_should_evaluate_a_method_option
+    assert_equal Object, Object.send(:evaluate_attr_encrypted_option, SomeOtherClass.method(:call), Object.new)
+  end
+  
+  def test_should_return_a_string_option
+    assert_equal 'Object', Object.send(:evaluate_attr_encrypted_option, 'Object', Object.new)
+  end
+  
+  def test_should_encrypt_with_true_if
+    @user = User.new
+    assert_nil @user.encrypted_with_true_if
+    @user.with_true_if = 'testing'
+    assert_not_nil @user.encrypted_with_true_if
+    assert_equal Huberry::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
+    @user.with_false_if = 'testing'
+    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
+    @user.with_false_unless = 'testing'
+    assert_not_nil @user.encrypted_with_false_unless
+    assert_equal Huberry::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
+    @user.with_true_unless = 'testing'
+    assert_not_nil @user.encrypted_with_true_unless
+    assert_equal 'testing', @user.encrypted_with_true_unless
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: shuber-attr_encrypted
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Sean Huber