shuber-attr_encrypted 1.0.2 → 1.0.3

data/CHANGELOG

@@ -7,6 +7,7 @@
   * Add ability to specify your own encoding directives
   * Update logic that evaluates symbol and proc options
   * Add support for :if and :unless options
+  * Add AttrEncrypted namespace
 
 2009-01-07 - Sean Huber (shuber@huberry.com)
   * Initial commit

data/README.markdown

@@ -261,13 +261,18 @@ Then you'll have these two class methods available for each attribute: `User.enc
 be useful when you're using ActiveRecord (see below).
 
 
+### DataMapper ###
+
+For your convenience, the `:encode` and `:marshal` options are set to true by default since you'll be storing everything in a database.
+
+
 ### ActiveRecord ###
 
 If you're using this gem with ActiveRecord, you get a few extra features:
 
 #### Default options ####
 
-For your convenience, the `:encode` and `:marshal` options are set to true by default since you'll be storing everything in a database.
+Just like the default options for DataMapper, the `:encode` and `:marshal` options are set to true by default since you'll be storing everything in a database.
 
 
 #### Dynamic find\_by\_ and scoped\_by\_ methods ####

data/lib/attr_encrypted.rb

@@ -1,15 +1,15 @@
-require 'huberry/class'
-Class.send :include, Huberry::Class
+require 'huberry/attr_encrypted/class'
+Class.send :include, Huberry::AttrEncrypted::Class
 
-require 'huberry/object'
-Object.send :include, Huberry::Object
+require 'huberry/attr_encrypted/object'
+Object.send :include, Huberry::AttrEncrypted::Object
 
 if defined?(ActiveRecord)
-  require 'huberry/active_record'
-  ActiveRecord::Base.extend Huberry::ActiveRecord
+  require 'huberry/attr_encrypted/active_record'
+  ActiveRecord::Base.extend Huberry::AttrEncrypted::ActiveRecord
 end
 
 if defined?(DataMapper)
-  require 'huberry/data_mapper'
-  DataMapper::Resource.send :include, Huberry::DataMapper
+  require 'huberry/attr_encrypted/data_mapper'
+  DataMapper::Resource.send :include, Huberry::AttrEncrypted::DataMapper
 end

data/lib/huberry/attr_encrypted/active_record.rb

@@ -0,0 +1,50 @@
+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/class.rb

@@ -0,0 +1,169 @@
+module Huberry
+  module AttrEncrypted
+    module Class
+      protected
+        # Generates attr_accessors that encrypt and decrypt attributes transparently
+        #
+        # Options (any other options you specify are passed to the encryptor's encrypt and decrypt methods)
+        #
+        #   :attribute      => The name of the referenced encrypted attribute. For example 
+        #                      <tt>attr_accessor :email, :attribute => :ee</tt> would generate an 
+        #                      attribute named 'ee' to store the encrypted email. This is useful when defining
+        #                      one attribute to encrypt at a time or when the :prefix and :suffix options
+        #                      aren't enough. Defaults to nil.
+        #
+        #   :prefix         => A prefix used to generate the name of the referenced encrypted attributes.
+        #                      For example <tt>attr_accessor :email, :password, :prefix => 'crypted_'</tt> would 
+        #                      generate attributes named 'crypted_email' and 'crypted_password' to store the 
+        #                      encrypted email and password. Defaults to 'encrypted_'.
+        #
+        #   :suffix         => A suffix used to generate the name of the referenced encrypted attributes.
+        #                      For example <tt>attr_accessor :email, :password, :prefix => '', :suffix => '_encrypted'</tt>  
+        #                      would generate attributes named 'email_encrypted' and 'password_encrypted' to store the 
+        #                      encrypted email. Defaults to ''.
+        #
+        #   :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. 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), 
+        #                      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 
+        #                      or DataMapper.
+        #
+        #   :encryptor      => The object to use for encrypting. Defaults to Huberry::Encryptor.
+        #
+        #   :encrypt_method => The encrypt method name to call on the <tt>:encryptor</tt> object. Defaults to :encrypt.
+        #
+        #   :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
+        #
+        #   class User
+        #     # now all attributes will be encoded and marshaled by default
+        #     attr_encrypted_options.merge!(:encode => true, :marshal => true, :some_other_option => true)
+        #     attr_encrypted :configuration
+        #   end
+        #
+        #
+        # Example
+        #
+        #   class User
+        #     attr_encrypted :email, :credit_card, :key => 'some secret key'
+        #     attr_encrypted :configuration, :key => 'some other secret key', :marshal => true
+        #   end
+        #
+        #   @user = User.new
+        #   @user.encrypted_email # returns nil
+        #   @user.email = 'test@example.com'
+        #   @user.encrypted_email # returns the encrypted version of 'test@example.com'
+        #
+        #   @user.configuration = { :time_zone => 'UTC' }
+        #   @user.encrypted_configuration # returns the encrypted version of configuration
+        #
+        #   See README for more examples
+        def attr_encrypted(*attrs)
+          options = { 
+            :prefix => 'encrypted_', 
+            :suffix => '', 
+            :encryptor => Huberry::Encryptor, 
+            :encrypt_method => :encrypt,
+            :decrypt_method => :decrypt,
+            :encode => 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
+        
+          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)
+          
+            define_class_method "encrypt_#{attribute}" do |value|
+              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
+              end
+            end
+          
+            define_class_method "decrypt_#{attribute}" do |encrypted_value|
+              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
+              end
+            end
+          
+            define_method "#{attribute}" do
+              value = instance_variable_get("@#{attribute}")
+              encrypted_value = read_attribute(encrypted_attribute_name)
+              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.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))
+              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)
+          if option.is_a?(Symbol) && object.respond_to?(option)
+            object.send(option)
+          elsif option.respond_to?(:call)
+            option.call(object)
+          else
+            option
+          end
+        end
+    end
+  end
+end

data/lib/huberry/attr_encrypted/data_mapper.rb

@@ -0,0 +1,23 @@
+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

data/lib/huberry/attr_encrypted/object.rb

@@ -0,0 +1,47 @@
+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
+      end
+    
+      # Wraps instance_variable_get
+      def read_attribute(attribute)
+        instance_variable_get("@#{attribute}")
+      end
+    
+      # Wraps instance_variable_set
+      def write_attribute(attribute, value)
+        instance_variable_set("@#{attribute}", value)
+      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
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: shuber-attr_encrypted
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors: 
 - Sean Huber
@@ -41,10 +41,10 @@ extra_rdoc_files: []
 files: 
 - CHANGELOG
 - lib/attr_encrypted.rb
-- lib/huberry/active_record.rb
-- lib/huberry/class.rb
-- lib/huberry/data_mapper.rb
-- lib/huberry/object.rb
+- lib/huberry/attr_encrypted/active_record.rb
+- lib/huberry/attr_encrypted/class.rb
+- lib/huberry/attr_encrypted/data_mapper.rb
+- lib/huberry/attr_encrypted/object.rb
 - MIT-LICENSE
 - Rakefile
 - README.markdown

data/lib/huberry/active_record.rb

@@ -1,48 +0,0 @@
-module Huberry
-  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

data/lib/huberry/class.rb

@@ -1,167 +0,0 @@
-module Huberry
-  module Class
-    protected
-      # Generates attr_accessors that encrypt and decrypt attributes transparently
-      #
-      # Options (any other options you specify are passed to the encryptor's encrypt and decrypt methods)
-      #
-      #   :attribute      => The name of the referenced encrypted attribute. For example 
-      #                      <tt>attr_accessor :email, :attribute => :ee</tt> would generate an 
-      #                      attribute named 'ee' to store the encrypted email. This is useful when defining
-      #                      one attribute to encrypt at a time or when the :prefix and :suffix options
-      #                      aren't enough. Defaults to nil.
-      #
-      #   :prefix         => A prefix used to generate the name of the referenced encrypted attributes.
-      #                      For example <tt>attr_accessor :email, :password, :prefix => 'crypted_'</tt> would 
-      #                      generate attributes named 'crypted_email' and 'crypted_password' to store the 
-      #                      encrypted email and password. Defaults to 'encrypted_'.
-      #
-      #   :suffix         => A suffix used to generate the name of the referenced encrypted attributes.
-      #                      For example <tt>attr_accessor :email, :password, :prefix => '', :suffix => '_encrypted'</tt>  
-      #                      would generate attributes named 'email_encrypted' and 'password_encrypted' to store the 
-      #                      encrypted email. Defaults to ''.
-      #
-      #   :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. 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), 
-      #                      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 
-      #                      or DataMapper.
-      #
-      #   :encryptor      => The object to use for encrypting. Defaults to Huberry::Encryptor.
-      #
-      #   :encrypt_method => The encrypt method name to call on the <tt>:encryptor</tt> object. Defaults to :encrypt.
-      #
-      #   :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
-      #
-      #   class User
-      #     # now all attributes will be encoded and marshaled by default
-      #     attr_encrypted_options.merge!(:encode => true, :marshal => true, :some_other_option => true)
-      #     attr_encrypted :configuration
-      #   end
-      #
-      #
-      # Example
-      #
-      #   class User
-      #     attr_encrypted :email, :credit_card, :key => 'some secret key'
-      #     attr_encrypted :configuration, :key => 'some other secret key', :marshal => true
-      #   end
-      #
-      #   @user = User.new
-      #   @user.encrypted_email # returns nil
-      #   @user.email = 'test@example.com'
-      #   @user.encrypted_email # returns the encrypted version of 'test@example.com'
-      #
-      #   @user.configuration = { :time_zone => 'UTC' }
-      #   @user.encrypted_configuration # returns the encrypted version of configuration
-      #
-      #   See README for more examples
-      def attr_encrypted(*attrs)
-        options = { 
-          :prefix => 'encrypted_', 
-          :suffix => '', 
-          :encryptor => Huberry::Encryptor, 
-          :encrypt_method => :encrypt,
-          :decrypt_method => :decrypt,
-          :encode => 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
-        
-        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)
-          
-          define_class_method "encrypt_#{attribute}" do |value|
-            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
-            end
-          end
-          
-          define_class_method "decrypt_#{attribute}" do |encrypted_value|
-            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
-            end
-          end
-          
-          define_method "#{attribute}" do
-            value = instance_variable_get("@#{attribute}")
-            encrypted_value = read_attribute(encrypted_attribute_name)
-            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.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))
-            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)
-        if option.is_a?(Symbol) && object.respond_to?(option)
-          object.send(option)
-        elsif option.respond_to?(:call)
-          option.call(object)
-        else
-          option
-        end
-      end
-  end
-end

data/lib/huberry/data_mapper.rb

@@ -1,21 +0,0 @@
-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

@@ -1,45 +0,0 @@
-module Huberry
-  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
-    end
-    
-    # Wraps instance_variable_get
-    def read_attribute(attribute)
-      instance_variable_get("@#{attribute}")
-    end
-    
-    # Wraps instance_variable_set
-    def write_attribute(attribute, value)
-      instance_variable_set("@#{attribute}", value)
-    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
-    end
-  end
-end