yattr_encrypted 0.1.5 → 0.1.6

data/README.mdown

@@ -1,6 +1,6 @@
 # YattrEncrypted #
 
-Version: 0.1.5  (but you should check lib/yattr_encrypted/version.rb to be sure)
+Version: 0.1.6  (but you should check lib/yattr_encrypted/version.rb to be sure)
 
 ## Applicability ##
 
@@ -53,6 +53,9 @@ random *iv* and including it in the encrypted data. See *openssl* documentation
 for details [OpenSSL::Cipher]
 * detects when fields are modified by actions other than assignment. This supports
 encrypting complex types - such as hashes and arrays. This is implemented by adding
+* supports special field processing and initialization by use of `:read_filter` and
+`:write_filter` options which define Proc's or methods which are run on during
+read and write accessors for plaintext versions of the encrypted fields.
 a `before_save` calleback to the private method *yattr_update_encrypted_values*
 * Rails 3.1 & Rails 3.2 - doesn't pretend to support anything lower (but it might work)
 
@@ -131,24 +134,31 @@ and 'this is a very long secret key' is not.
 
 If you supply your own key, it can be a String or a Proc which returns a String.
 
-### Special Attribute Processing ###
+### Special Attribute Processing: read\_filter and write\_filter ###
 
 Special processing for attribute values can be implemented by using the `:read_filter` and
 `:write_filter` options of the `yattr_encrypted` macro.
 
-A `:read_filter` is a proc (or lambda) which accepts a single argument. It is called on the
-value of the *attribute* immediately before being returned by the clear text attribute accessor.
+Both options take *either* a Proc, lambda, or instance method name. In both cases, the callable
+must take a single argument. The argument will be the plaintext value of the field or value
+being assigned.
+
+A `:read_filter` is called on the value of the *attribute* before being returned by the
+clear text attribute accessor. The processed value is saved in the instance variable
+used to support the plaintext version of the *attribute*.
 
 **NOTE:** The read filter is called every time the *attribute* is read via the attribute
-reader. It should be idempotent in the sense that read_filter(attribute) == read_filter(read_filter(attribute)).
+reader. It should be idempotent in the sense that:
+
+    read_filter(attribute) == read_filter(read_filter(attribute)).
 
-**NOTE:** The read filter result is reflected in the instance variable which supports the
-plain text version of the *attribute*, so it can be used to set the *attribute* to a default
+**NOTE:** Because the read filter result is saved in the instance variable which supports the
+plain text version of the *attribute*, it can be used to set the *attribute* to a default
 value - such as an empty Hash.
 
     yattr_encrypted :bag, :read_filter => lambda { |val| val.is_a?(Hash) ? val : {} }
 
-A `:write_filter` is a proc (or lambda) which accepts a single argument. It is called
+A `:write_filter` is a proc, lambda, or instance method which accepts a single argument. It is called
 on the value passed to the *attribute* writer prior to any other action in the writer.
 
 **NOTE:** the write filter is called on every value which is assigned to the *attribute*.

data/lib/yattr_encrypted.rb

@@ -73,7 +73,7 @@ module YattrEncrypted
 
         # collect existing instance methods
         instance_methods_as_symbols = instance_methods.map { |method| method.to_sym }
-
+ 
         # iterate through attributes and create accessors, verify encryped accessors exist
         attributes.map { |x| x.to_sym }.each do |attribute|
           encrypted_attribute_name = [options[:prefix], attribute, options[:suffix]].join.to_sym
@@ -91,11 +91,19 @@ module YattrEncrypted
               @#{attribute} = #{encrypted_attribute_name} ? \
                   yate_decrypt(#{encrypted_attribute_name}, options[:key]) : \
                   ''
-              @#{attribute} = options[:read_filter].call(@#{attribute}) if options[:read_filter]
+              if options[:read_filter].respond_to? :call
+                  @#{attribute} = options[:read_filter].call(@#{attribute})
+              elsif options[:read_filter]
+                @#{attribute} = self.send options[:read_filter].to_sym, @#{attribute}
+              end
               self.yate_checksums[:#{attribute}] = yate_attribute_hash_value(:#{attribute})
               self.yate_dirty[:#{attribute}] = true
             elsif options[:read_filter]
-              @#{attribute} = options[:read_filter].call(@#{attribute})
+              if options[:read_filter].respond_to? :call
+                @#{attribute} = options[:read_filter].call(@#{attribute})
+              else
+                @#{attribute} = self.send options[:read_filter].to_sym, @#{attribute}
+              end
             end
             @#{attribute}
           end
@@ -105,7 +113,11 @@ module YattrEncrypted
           tmp =<<-XXX
           def #{attribute}= value
             options = yate_encrypted_attributes[:#{attribute}]
-            value = options[:write_filter].call(value) if options[:write_filter]
+            if options[:write_filter].respond_to? :call
+              value = options[:write_filter].call(value)
+            elsif options[:write_filter]
+              value = self.send options[:write_filter], value
+            end
             @#{attribute} = value
             self.#{encrypted_attribute_name} = yate_encrypt(value, options[:key])
             self.yate_checksums[:#{attribute}] = yate_attribute_hash_value(:#{attribute})

data/lib/yattr_encrypted/version.rb

@@ -1,3 +1,3 @@
 module YattrEncrypted
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

data/test/yattr_encrypted_test.rb

@@ -35,12 +35,19 @@ module ActiveRecord
 end
 
 class SomeClass < ActiveRecord::Base
-  attr_accessor :field_encrypted, :special_reader_encrypted, :special_writer_encrypted
+  attr_accessor :field_encrypted, :special_reader_encrypted, :special_writer_encrypted,
+    :method_filtered_encrypted
   yattr_encrypted :field, :key => 'a honkin big key: honk honk honk honk honk'
   yattr_encrypted :special_reader, :key => 'a honkin big key: honk honk honk honk honk',
     :read_filter => lambda { |val| val.strip }
   yattr_encrypted :special_writer, :key => 'a honkin big key: honk honk honk honk honk',
     :write_filter => lambda { |val| val.upcase }
+  yattr_encrypted :method_filtered, :key => 'a honkin big key: honk honk honk honk honk',
+    :read_filter => 'foo'
+  
+  def foo attr
+    'foo filtered'
+  end
 end
 
 class TestYattrEncrypted < MiniTest::Unit::TestCase
@@ -94,4 +101,12 @@ class TestYattrEncrypted < MiniTest::Unit::TestCase
       "@special_writer should be upcased"
     assert_equal value.upcase, @sc.special_writer, "@sc.special_writer should be upcased"
   end
+  
+  def test_method_filtered
+    value = 'a string with leading and trailing white space'
+    @sc.method_filtered = value
+    assert_equal value, @sc.instance_variable_get(:@method_filtered),
+      "@method_filtered should be '#{value}'"
+    assert_equal 'foo filtered', @sc.method_filtered, "@sc.method_filtered should be 'foo filtered"
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yattr_encrypted
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-19 00:00:00.000000000Z
+date: 2012-03-20 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &2151769620 !ruby/object:Gem::Requirement
+  requirement: &2157537060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2151769620
+  version_requirements: *2157537060
 description: Generates yattr_accessors that encrypt and decrypt attributes transparently.
   Based on attr_encrypted by Sean Huber [https://github.com/shuber]
 email: mike@clove.com
@@ -56,7 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 677455391031981630
+      hash: -1485568723198089794
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: