shuber-attr_encrypted 1.0.0 → 1.0.1

data/CHANGELOG

@@ -2,6 +2,9 @@
   * Update comments and documentation
   * Update README
   * Add gemspec
+  * 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
 
 2009-01-07 - Sean Huber (shuber@huberry.com)
   * Initial commit

data/README.markdown

@@ -3,6 +3,8 @@ attr\_encrypted
 
 Generates attr\_accessors that encrypt and decrypt attributes transparently
 
+Works with any class including ActiveRecord and DataMapper
+
 
 Installation
 ------------
@@ -215,12 +217,14 @@ This should help keep your classes clean and DRY.
 ### Encoding ###
 
 You're probably going to be storing your encrypted attributes somehow (e.g. filesystem, database, etc) and may run into some issues trying to store a weird
-encrypted string. I've had this problem myself using MySQL. You can simply pass the `:encode` option to automatically base64 encode/decode when encrypting/decrypting.
+encrypted string. I've had this problem myself using MySQL. You can simply pass the `:encode` option to automatically encode/decode when encrypting/decrypting.
 
 	class User
 	  attr_encrypted :email, :key => 'some secret key', :encode => true
 	end
 
+The default encoding is `m*` (base64). You can change this by setting `:encode => 'some encoding'`. See  [Array#pack](http://www.ruby-doc.org/core/classes/Array.html#M002245) for more encoding options.
+
 
 ### Marshaling ###
 

data/lib/attr_encrypted.rb

@@ -7,4 +7,9 @@ Object.send :include, Huberry::Object
 if defined?(ActiveRecord)
   require 'huberry/active_record'
   ActiveRecord::Base.extend Huberry::ActiveRecord
+end
+
+if defined?(DataMapper)
+  require 'huberry/data_mapper'
+  DataMapper::Resource.send :include, Huberry::DataMapper
 end

data/lib/huberry/active_record.rb

@@ -9,6 +9,7 @@ module Huberry
       # Calls attr_encrypted with the options <tt>:encode</tt> and <tt>:marshal</tt> set to true
       # unless they've already been specified
       def attr_encrypted(*attrs)
+        define_attribute_methods
         options = { :encode => true, :marshal => true }.merge(attrs.last.is_a?(Hash) ? attrs.pop : {})
         super *(attrs << options)
       end

data/lib/huberry/class.rb

@@ -26,12 +26,15 @@ module Huberry
       #                      method before being passed to the encryptor. Proc objects are evaluated as well. Any other key types 
       #                      will be passed directly to the encryptor.
       #
-      #   :encode         => If set to true, attributes will be base64 encoded as well as encrypted. This is useful if you're
-      #                      planning on storing the encrypted attributes in a database. Defaults to false unless you're using
-      #                      it with ActiveRecord.
+      #   :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), 
+      #                      however this can be overwritten by setting the :encode option to some other encoding string instead of
+      #                      just 'true'. See http://www.ruby-doc.org/core/classes/Array.html#M002245 for more encoding directives. 
+      #                      Defaults to false unless you're using it with ActiveRecord or DataMapper.
       #
       #   :marshal        => If set to true, attributes will be marshaled as well as encrypted. This is useful if you're planning
-      #                      on encrypting something other than a string. Defaults to false unless you're using it with ActiveRecord.
+      #                      on encrypting something other than a string. Defaults to false unless you're using it with ActiveRecord 
+      #                      or DataMapper.
       #
       #   :encryptor      => The object to use for encrypting. Defaults to Huberry::Encryptor.
       #
@@ -75,13 +78,14 @@ module Huberry
           :encode => false, 
           :marshal => false 
         }.merge(attr_encrypted_options).merge(attrs.last.is_a?(Hash) ? attrs.pop : {})
+        options[:encode] = 'm*' if options[:encode] == true
         
         attrs.each do |attribute|
           encrypted_attribute_name = options[:attribute].nil? ? options[:prefix].to_s + attribute.to_s + options[:suffix].to_s : options[:attribute].to_s
           
           encrypted_attributes[attribute.to_s] = encrypted_attribute_name
           
-          attr_accessor encrypted_attribute_name.to_sym unless self.new.respond_to?(encrypted_attribute_name)
+          attr_accessor encrypted_attribute_name.to_sym unless instance_methods.include?(encrypted_attribute_name)
           
           define_class_method "encrypt_#{attribute}" do |value|
             if value.nil?
@@ -89,7 +93,7 @@ module Huberry
             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('m*') if options[:encode]
+              encrypted_value = [encrypted_value].pack(options[:encode]) if options[:encode]
             end
             encrypted_value
           end
@@ -98,7 +102,7 @@ module Huberry
             if encrypted_value.nil?
               decrypted_value = nil
             else
-              encrypted_value = encrypted_value.unpack('m*').to_s if options[:encode]
+              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
@@ -110,7 +114,7 @@ module Huberry
             encrypted_value = read_attribute(encrypted_attribute_name)
             original_key = options[:key]
             options[:key] = self.class.send :evaluate_attr_encrypted_key, options[:key], self
-            value = write_attribute(attribute, self.class.send("decrypt_#{attribute}".to_sym, encrypted_value)) if value.nil? && !encrypted_value.nil?
+            value = instance_variable_set("@#{attribute}", self.class.send("decrypt_#{attribute}".to_sym, encrypted_value)) if value.nil? && !encrypted_value.nil?
             options[:key] = original_key
             value
           end

data/lib/huberry/data_mapper.rb

@@ -0,0 +1,21 @@
+module Huberry
+  module DataMapper
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        alias_method :read_attribute, :attribute_get
+        alias_method :write_attribute, :attribute_set
+      end
+    end
+    
+    module ClassMethods
+      protected    
+        # Calls attr_encrypted with the options <tt>:encode</tt> and <tt>:marshal</tt> set to true
+        # unless they've already been specified
+        def attr_encrypted(*attrs)
+          options = { :encode => true, :marshal => true }.merge(attrs.last.is_a?(Hash) ? attrs.pop : {})
+          super *(attrs << options)
+        end
+    end
+  end
+end

data/lib/huberry/object.rb

@@ -10,15 +10,11 @@ module Huberry
     end
     
     # Wraps instance_variable_get
-    #
-    # ActiveRecord overwrites this (if you're using it)
     def read_attribute(attribute)
       instance_variable_get("@#{attribute}")
     end
     
     # Wraps instance_variable_set
-    #
-    # ActiveRecord overwrites this (if you're using it)
     def write_attribute(attribute, value)
       instance_variable_set("@#{attribute}", value)
     end

data/test/attr_encrypted_test.rb

@@ -18,6 +18,7 @@ class User
   attr_encrypted :ssn, :key => :salt, :attribute => 'ssn_encrypted'
   attr_encrypted :credit_card, :encryptor => SillyEncryptor, :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_accessor :salt
   
@@ -107,6 +108,16 @@ class AttrEncryptedTest < Test::Unit::TestCase
     assert_equal User.decrypt_with_encoding(encrypted), User.decrypt_without_encoding(encrypted.unpack('m*').to_s)
   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)
+  end
+  
   def test_should_encrypt_with_marshaling
     @user = User.new
     @user.with_marshaling = [1, 2, 3]

data/test/data_mapper_test.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+DataMapper.setup(:default, "sqlite3::memory:")
+
+class Client
+  include DataMapper::Resource
+  
+  property :id, Serial
+  property :encrypted_email, String
+  property :encrypted_credentials, Text
+  property :salt, String
+  
+  attr_encrypted :email, :key => 'a secret key'
+  attr_encrypted :credentials, :key => Proc.new { |client| Huberry::Encryptor.encrypt(:value => client.salt, :key => 'some private key') }
+  
+  def initialize(attrs = {})
+    super attrs
+    self.salt ||= Digest::SHA1.hexdigest((Time.now.to_i * rand(5)).to_s)
+    self.credentials ||= { :username => 'example', :password => 'test' }
+  end
+end
+
+DataMapper.auto_migrate!
+
+class DataMapperTest < Test::Unit::TestCase
+  
+  def setup
+    Client.all.each(&:destroy)
+  end
+  
+  def test_should_encrypt_email
+    @person = Client.new :email => 'test@example.com'
+    assert @person.save
+    assert_not_nil @person.encrypted_email
+    assert_not_equal @person.email, @person.encrypted_email
+    assert_equal @person.email, Client.first.email
+  end
+  
+  def test_should_marshal_and_encrypt_credentials
+    @person = Client.new
+    assert @person.save
+    assert_not_nil @person.encrypted_credentials
+    assert_not_equal @person.credentials, @person.encrypted_credentials
+    assert_equal @person.credentials, Client.first.credentials
+    assert Client.first.credentials.is_a?(Hash)
+  end
+  
+end

data/test/test_helper.rb

@@ -5,9 +5,11 @@ require 'rubygems'
 gem 'shuber-eigenclass', '>= 1.0.1'
 gem 'shuber-encryptor'
 gem 'activerecord'
+gem 'datamapper'
 
 require 'eigenclass'
 require 'encryptor'
 require 'active_record'
+require 'datamapper'
 
 require File.dirname(__FILE__) + '/../lib/attr_encrypted'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: shuber-attr_encrypted
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Sean Huber
@@ -43,6 +43,7 @@ files:
 - lib/attr_encrypted.rb
 - lib/huberry/active_record.rb
 - lib/huberry/class.rb
+- lib/huberry/data_mapper.rb
 - lib/huberry/object.rb
 - MIT-LICENSE
 - Rakefile
@@ -80,3 +81,4 @@ summary: Generates attr_accessors that encrypt and decrypt attributes transparen
 test_files: 
 - test/active_record_test.rb
 - test/attr_encrypted_test.rb
+- test/data_mapper_test.rb