shuber-attr_encrypted 1.0.3 → 1.0.4

data/CHANGELOG

@@ -1,3 +1,14 @@
+2009-01-12 - Sean Huber (shuber@huberry.com)
+  * Remove read_attribute and write_attribute methods - unnecessary
+  * ActiveRecord and DataMapper extensions are now "adapters"
+  * Check for existing reader and writer methods separately before creating default ones for encrypted attributes
+
+2009-01-11 - Sean Huber (shuber@huberry.com)
+  * Update README
+
+2009-01-10 - Sean Huber (shuber@huberry.com)
+  * Update README
+
 2009-01-08 - Sean Huber (shuber@huberry.com)
   * Update comments and documentation
   * Update README

data/README.markdown

@@ -3,7 +3,7 @@ attr\_encrypted
 
 Generates attr\_accessors that encrypt and decrypt attributes transparently
 
-Works with any class including ActiveRecord and DataMapper
+Works with ANY class including ActiveRecord and DataMapper
 
 
 Installation
@@ -97,7 +97,7 @@ If your class has an instance method that determines the encryption key to use,
 
 #### Procs as keys ####
 
-You can pass a proc object as the `:key` option as well:
+You can pass a proc/lambda object as the `:key` option as well:
 
 	class User
 	  attr_encrypted :email, :key => proc { |user| ... }
@@ -109,12 +109,12 @@ You can pass a proc object as the `:key` option as well:
 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
+	class User < ActiveRecord::Base
 	  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.
+Any objects that respond to `:call` are evaluated as well.
 
 
 ### Custom encryptor ###

data/lib/attr_encrypted.rb

@@ -2,14 +2,6 @@ require 'huberry/attr_encrypted/class'
 Class.send :include, Huberry::AttrEncrypted::Class
 
 require 'huberry/attr_encrypted/object'
-Object.send :include, Huberry::AttrEncrypted::Object
+Object.extend Huberry::AttrEncrypted::Object
 
-if defined?(ActiveRecord)
-  require 'huberry/attr_encrypted/active_record'
-  ActiveRecord::Base.extend Huberry::AttrEncrypted::ActiveRecord
-end
-
-if defined?(DataMapper)
-  require 'huberry/attr_encrypted/data_mapper'
-  DataMapper::Resource.send :include, Huberry::AttrEncrypted::DataMapper
-end
+Dir[File.join(File.dirname(__FILE__), 'huberry', 'attr_encrypted', 'adapters', '*.rb')].each { |file| require file }

data/lib/huberry/attr_encrypted/adapters/active_record.rb

@@ -0,0 +1,58 @@
+if defined?(ActiveRecord)
+  module Huberry
+    module AttrEncrypted
+      module Adapters
+        module ActiveRecord
+          def self.extended(base)
+            base.eigenclass_eval { alias_method_chain :method_missing, :attr_encrypted }
+          end
+        
+          protected
+        
+            # Calls attr_encrypted with the options <tt>:encode</tt> and <tt>:marshal</tt> set to true
+            # unless they've already been specified
+            #
+            # Also defines the attribute methods for db fields if they don't exist yet
+            def attr_encrypted(*attrs)
+              define_attribute_methods
+              options = { :encode => true, :marshal => true }.merge(attrs.last.is_a?(Hash) ? attrs.pop : {})
+              super *(attrs << options)
+            end
+          
+            # Allows you to use dynamic methods like <tt>find_by_email</tt> or <tt>scoped_by_email</tt> for 
+            # encrypted attributes
+            #
+            # NOTE: This only works when the <tt>:key</tt> option is specified as a string (see the README)
+            #
+            # This is useful for encrypting fields like email addresses. Your user's email addresses 
+            # are encrypted in the database, but you can still look up a user by email for logging in
+            #
+            # Example
+            #
+            #   class User < ActiveRecord::Base
+            #     attr_encrypted :email, :key => 'secret key'
+            #   end
+            #
+            #   User.find_by_email_and_password('test@example.com', 'testing')
+            #   # results in a call to
+            #   User.find_by_encrypted_email_and_password('the_encrypted_version_of_test@example.com', 'testing')
+            def method_missing_with_attr_encrypted(method, *args, &block)
+              if match = /^(find|scoped)_(all_by|by)_([_a-zA-Z]\w*)$/.match(method.to_s)
+                attribute_names = match.captures.last.split('_and_')
+                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]
+                  end
+                end
+                method = "#{match.captures[0]}_#{match.captures[1]}_#{attribute_names.join('_and_')}".to_sym
+              end
+              method_missing_without_attr_encrypted(method, *args, &block)
+            end
+        end
+      end
+    end
+  end
+  
+  ActiveRecord::Base.extend Huberry::AttrEncrypted::Adapters::ActiveRecord
+end

data/lib/huberry/attr_encrypted/adapters/data_mapper.rb

@@ -0,0 +1,25 @@
+if defined?(DataMapper)
+  module Huberry
+    module AttrEncrypted
+      module Adapters
+        module DataMapper
+          def self.included(base)
+            base.extend ClassMethods
+          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
+    end
+  end
+  
+  DataMapper::Resource.send :include, Huberry::AttrEncrypted::Adapters::DataMapper
+end

data/lib/huberry/attr_encrypted/class.rb

@@ -89,14 +89,15 @@ module Huberry
             :unless => 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 instance_methods.include?(encrypted_attribute_name)
-          
+            
+            attr_reader encrypted_attribute_name.to_sym unless instance_methods.include?(encrypted_attribute_name)
+            attr_writer encrypted_attribute_name.to_sym unless instance_methods.include?("#{encrypted_attribute_name}=")
+            
             define_class_method "encrypt_#{attribute}" do |value|
               if options[:if] && !options[:unless]
                 if value.nil?
@@ -111,7 +112,7 @@ module Huberry
                 value
               end
             end
-          
+            
             define_class_method "decrypt_#{attribute}" do |encrypted_value|
               if options[:if] && !options[:unless]
                 if encrypted_value.nil?
@@ -126,10 +127,10 @@ module Huberry
                 encrypted_value
               end
             end
-          
+            
             define_method "#{attribute}" do
               value = instance_variable_get("@#{attribute}")
-              encrypted_value = read_attribute(encrypted_attribute_name)
+              encrypted_value = send(encrypted_attribute_name.to_s)
               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
@@ -139,20 +140,20 @@ module Huberry
               options.merge!(original_options)
               value
             end
-          
+            
             define_method "#{attribute}=" do |value|
               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))
+              send("#{encrypted_attribute_name}=".to_sym, self.class.send("encrypt_#{attribute}".to_sym, value))
               options.merge!(original_options)
               instance_variable_set("@#{attribute}", value)
             end
           end
         end
-      
+        
         # 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)

data/lib/huberry/attr_encrypted/object.rb

@@ -1,46 +1,50 @@
 module Huberry
   module AttrEncrypted
     module Object
-      def self.included(base)
-        base.class_eval do
-          extend ClassMethods
-          eattr_accessor :attr_encrypted_options, :encrypted_attributes
-          attr_encrypted_options = {}
-          encrypted_attributes = {}
-        end
+      def self.extended(base)
+        base.attr_encrypted_options = {}
+        base.instance_variable_set('@encrypted_attributes', {})
       end
-    
-      # Wraps instance_variable_get
-      def read_attribute(attribute)
-        instance_variable_get("@#{attribute}")
+      
+      # Default options to use with calls to <tt>attr_encrypted</tt>.
+      #
+      # It will inherit existing options from its parent class
+      def attr_encrypted_options
+        @attr_encrypted_options ||= superclass.attr_encrypted_options.nil? ? {} : superclass.attr_encrypted_options.dup
+      end
+      
+      # Sets default options to use with calls to <tt>attr_encrypted</tt>.
+      def attr_encrypted_options=(options)
+        @attr_encrypted_options = options
       end
-    
-      # Wraps instance_variable_set
-      def write_attribute(attribute, value)
-        instance_variable_set("@#{attribute}", value)
+      
+      # Contains a hash of encrypted attributes with virtual attribute names as keys and real attribute 
+      # names as values
+      #
+      # Example
+      #
+      #   class User
+      #     attr_encrypted :email
+      #   end
+      #
+      #   User.encrypted_attributes # { 'email' => 'encrypted_email' }
+      def encrypted_attributes
+        @encrypted_attributes ||= superclass.encrypted_attributes.nil? ? {} : superclass.encrypted_attributes.dup
       end
-    
-      module ClassMethods
-        # Checks if an attribute has been configured to be encrypted
-        #
-        # Example
-        #
-        #   class User
-        #     attr_accessor :name
-        #     attr_encrypted :email
-        #   end
-        #
-        #   User.attr_encrypted?(:name) # false
-        #   User.attr_encrypted?(:email) # true
-        def attr_encrypted?(attribute)
-          encrypted_attributes.keys.include?(attribute.to_s)
-        end
       
-        # Copies existing encrypted attributes and options to the derived class
-        def inherited(base)
-          base.attr_encrypted_options = self.attr_encrypted_options.nil? ? {} : self.attr_encrypted_options.dup
-          base.encrypted_attributes = self.encrypted_attributes.nil? ? {} : self.encrypted_attributes.dup
-        end
+      # Checks if an attribute has been configured to be encrypted
+      #
+      # Example
+      #
+      #   class User
+      #     attr_accessor :name
+      #     attr_encrypted :email
+      #   end
+      #
+      #   User.attr_encrypted?(:name) # false
+      #   User.attr_encrypted?(:email) # true
+      def attr_encrypted?(attribute)
+        encrypted_attributes.keys.include?(attribute.to_s)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: shuber-attr_encrypted
 version: !ruby/object:Gem::Version 
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors: 
 - Sean Huber
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-08 00:00:00 -08:00
+date: 2009-01-12 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,9 +41,9 @@ extra_rdoc_files: []
 files: 
 - CHANGELOG
 - lib/attr_encrypted.rb
-- lib/huberry/attr_encrypted/active_record.rb
+- lib/huberry/attr_encrypted/adapters/active_record.rb
+- lib/huberry/attr_encrypted/adapters/data_mapper.rb
 - lib/huberry/attr_encrypted/class.rb
-- lib/huberry/attr_encrypted/data_mapper.rb
 - lib/huberry/attr_encrypted/object.rb
 - MIT-LICENSE
 - Rakefile

data/lib/huberry/attr_encrypted/active_record.rb

@@ -1,50 +0,0 @@
-module Huberry
-  module AttrEncrypted
-    module ActiveRecord
-      def self.extended(base)
-        base.eigenclass_eval { alias_method_chain :method_missing, :attr_encrypted }
-      end
-    
-      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)
-          define_attribute_methods
-          options = { :encode => true, :marshal => true }.merge(attrs.last.is_a?(Hash) ? attrs.pop : {})
-          super *(attrs << options)
-        end
-    
-        # Allows you to use dynamic methods like <tt>find_by_email</tt> or <tt>scoped_by_email</tt> for 
-        # encrypted attributes
-        #
-        # NOTE: This only works when the <tt>:key</tt> option is specified as a string (see the README)
-        #
-        # This is useful for encrypting fields like email addresses. Your user's email addresses 
-        # are encrypted in the database, but you can still look up a user by email for logging in
-        #
-        # Example
-        #
-        #   class User < ActiveRecord::Base
-        #     attr_encrypted :email, :key => 'secret key'
-        #   end
-        #
-        #   User.find_by_email_and_password('test@example.com', 'testing')
-        #   # results in a call to
-        #   User.find_by_encrypted_email_and_password('the_encrypted_version_of_test@example.com', 'testing')
-        def method_missing_with_attr_encrypted(method, *args, &block)
-          if match = /^(find|scoped)_(all_by|by)_([_a-zA-Z]\w*)$/.match(method.to_s)
-            attribute_names = match.captures.last.split('_and_')
-            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]
-              end
-            end
-            method = "#{match.captures[0]}_#{match.captures[1]}_#{attribute_names.join('_and_')}".to_sym
-          end
-          method_missing_without_attr_encrypted(method, *args, &block)
-        end
-    end
-  end
-end

data/lib/huberry/attr_encrypted/data_mapper.rb

@@ -1,23 +0,0 @@
-module Huberry
-  module AttrEncrypted
-    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
-end