maskable_attribute 0.0.5 → 0.0.6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    maskable_attribute (0.0.4)
+    maskable_attribute (0.0.6)
       rails (>= 2.3.10)
 
 GEM

data/lib/maskable_attribute/acts_as_maskable_attribute.rb

@@ -13,8 +13,7 @@ module MaskableAttribute
       #
       # class Foo < ActiveRecord::Base
       #   maskable_attrribute :some_attribute,
-      #                       [ :some_method_be_used_as_a_mask, :another_attribute_mask ],
-      #                       :protected_prefixes => [ 'prefix' ]
+      #                       [ :some_method_be_used_as_a_mask, :another_attribute_mask ]
       # end
 
       def maskable_attribute(attribute_to_mask, masks, options = {})
@@ -28,10 +27,12 @@ module MaskableAttribute
 
         define_method attribute_to_mask do
           send("maskable_#{attribute_to_mask}").to_s
+          #masked_attribute attribute_to_mask, options
         end
 
         define_method "#{attribute_to_mask}=" do |value|
-          write_attribute attribute_to_mask, masked_attribute(attribute_to_mask, options).set(value)
+          #write_attribute attribute_to_mask, masked_attribute(attribute_to_mask, options).set(value)
+          write_attribute attribute_to_mask, value
         end
 
         define_method "maskable_#{attribute_to_mask}" do

data/lib/maskable_attribute/maskable_attribute.rb

@@ -6,7 +6,6 @@ module MaskableAttribute
       @object = object
       @attribute = attribute
       @masks = Masks.new masks
-      @protected_prefixes = Array.wrap(options.delete(:protected_prefixes) || options.delete(:protected_prefix)).join('|')
     end
 
     def masks
@@ -24,12 +23,14 @@ module MaskableAttribute
       value
     end
 
-    alias :to_s :masked
-
-    def masked_object
-      @object
+    # update an attribute to replace all masks in place
+    # i.e. "something{some_mask}cool" will become "somethingelsecool"
+    def demask
+      @object.write_attribute attribute, masked
     end
 
+    alias :to_s :masked
+
     def unmasked
       @object.read_attribute attribute
     end
@@ -42,6 +43,7 @@ module MaskableAttribute
           end
         end
       end
+
       value
     end
 

data/lib/maskable_attribute/version.rb

@@ -1,3 +1,3 @@
 module MaskableAttribute
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/test/maskable_attribute_test.rb

@@ -5,29 +5,23 @@ class MaskableAttributeTest < ActiveSupport::TestCase
     assert_kind_of Module, MaskableAttribute
   end
 
-  test "should be able to set an attribute to be maskable" do
+  test "should set an attribute to be maskable" do
     assert_respond_to Hickwell, :maskable_attribute, "Can't mask an attribute"
   end
 
-  test "should be able to get available masks" do
+  test "should get available masks" do
     @hickwell = Hickwell.create!
 
     assert_respond_to @hickwell.maskable_qux, :masks, "Couldn't get available masks"
   end
 
-  test "should get available masks" do
+  test "should get all available masks" do
     @hickwell = Hickwell.create!
 
     assert_equal [ :foo, :bar, :baz ], @hickwell.maskable_qux.masks, "Masks method did not return list of masks"
   end
 
-  test "should have masked_object available to itself" do
-    @hickwell = Hickwell.create!
-
-    assert_equal @hickwell, @hickwell.maskable_qux.masked_object, "Couldn't determine the masked object"
-  end
-
-  test "should be able to set masking of attribute" do
+  test "should set masking of attribute" do
     @hickwell = Hickwell.create!
 
     @hickwell.qux = "{foo}{bar}{baz}"
@@ -37,78 +31,84 @@ class MaskableAttributeTest < ActiveSupport::TestCase
   test "should not overwrite attribute with unmasked attribute" do
     @hickwell = Hickwell.create! :foo => "a", :bar => "b", :baz => "c", :qux => "{foo}{bar}{baz}"
 
-    assert_equal "abc", @hickwell.qux
     assert_equal "abc", @hickwell.qux
     assert_equal "{foo}{bar}{baz}", @hickwell.read_attribute(:qux), "Overwriting attribute with unmasked value"
   end
 
-  test "should be able to get attribute masked (by default)" do
+  test "should get attribute masked by default" do
     @hickwell = Hickwell.create! :foo => "a", :bar => "b", :baz => "c", :qux => "{foo}{bar}{baz}"
 
     assert_equal "abc", @hickwell.qux, "Couldn't get attribute masked"
   end
 
-  test "should be able to get attribute unmasked" do
+  test "should get attribute unmasked" do
     @hickwell = Hickwell.create! :foo => "a", :bar => "b", :baz => "c", :qux => "{foo}{bar}{baz}"
 
     assert_equal "{foo}{bar}{baz}", @hickwell.maskable_qux.unmasked, "Could not get attribute unmasked"
   end
 
-  test "should be able to get set value of attribute and have masks persist" do
+  test "should demask attribute to a string" do
     @hickwell = Hickwell.create! :foo => "a", :bar => "b", :baz => "c", :qux => "{foo}{bar}{baz}"
-    @hickwell.qux = "bac"
+    @hickwell.maskable_qux.demask
+
+    assert_equal "abc", @hickwell.maskable_qux.unmasked, "Did not demask attribute"
+  end
+
+  test "should only save masks when defined explicitly" do
+    @hickwell = Hickwell.new :foo => "a", :bar => "b", :baz => "c", :qux => "{foo}{bar}{baz}"
+    @hickwell.qux = "b{bar}a{baz}"
 
-    assert_equal "{bar}{foo}{baz}", @hickwell.maskable_qux.unmasked, "Masks didn't persist though update"
+    assert_equal @hickwell.maskable_qux.unmasked, "b{bar}a{baz}", "Incorrectly saved masks for non-specified values"
   end
 
-  test "masks should be able to reference differently named methods" do
+  test "should reference differently named methods" do
     class Rickwell < Hickwell
       maskable_attribute :bar, :qux => :quux
     end
 
     @hickwell = Rickwell.create! :bar => "{qux}"
 
-    assert_equal "thud", @hickwell.bar
+    assert_equal "thud", @hickwell.maskable_bar.masked
   end
 
   test "should allow maskable_attribute to be nil" do
     @hickwell = Hickwell.create! :foo => "a", :bar => "b", :baz => "c", :qux => "{foo}{bar}{baz}"
     @hickwell.qux = nil
 
-    assert_nil @hickwell.qux, "Maskable attribute not set to nil"
+    assert_nil @hickwell.maskable_qux.masked, "Maskable attribute not set to nil"
   end
 
-  test "masks should be able to reference a Proc block" do
+  test "should reference a Proc block" do
     class Wickwell < Hickwell
       maskable_attribute :baz, :ack => Proc.new { "syn" }
     end
 
     @hickwell = Wickwell.create! :baz => "{ack}"
 
-    assert_equal "syn", @hickwell.baz
+    assert_equal "syn", @hickwell.maskable_baz.masked
   end
 
-  test "masks should be able to handle multiple words" do
+  test "should handle multiple words" do
     class Dickwell < Hickwell
       maskable_attribute :bar, :foo_bar => Proc.new { "syn" }
     end
 
     @hickwell = Dickwell.create! :bar => "{foo_bar}"
 
-    assert_equal "syn", @hickwell.bar, "Did not retrieve mask for multiple words"
+    assert_equal "syn", @hickwell.maskable_bar.masked, "Did not retrieve mask for multiple words"
   end
 
-  test "masks should be able to handle multiple words with spaces" do
+  test "should handle multiple words with spaces" do
     class Zickwell < Hickwell
       maskable_attribute :bar, :foo_bar => Proc.new { "syn" }
     end
 
     @hickwell = Zickwell.create! :bar => "{foo bar}"
 
-    assert_equal "syn", @hickwell.bar, "Did not retrieve mask for multiple words with spaces"
+    assert_equal "syn", @hickwell.maskable_bar.masked, "Did not retrieve mask for multiple words with spaces"
   end
 
-  test "masks should be able to directly reference methods for the class object" do
+  test "should directly reference methods for the class object" do
     class Fickwell < Hickwell
       maskable_attribute :bar, [ :foo_bar_baz ]
 
@@ -118,10 +118,10 @@ class MaskableAttributeTest < ActiveSupport::TestCase
     end
     @fickwell = Fickwell.create! :bar => "{foo bar baz}"
 
-    assert_equal "ack one", @fickwell.bar, "Did not retrieve mask for object method reference"
+    assert_equal "ack one", @fickwell.maskable_bar.masked, "Did not retrieve mask for object method reference"
   end
 
-  test "masks should be able to directly reference aliased methods for the class object" do
+  test "should directly reference aliased methods for the class object" do
     class Fickwell < Hickwell
       maskable_attribute :bar, [ :fbb ]
 
@@ -133,10 +133,10 @@ class MaskableAttributeTest < ActiveSupport::TestCase
     end
     @hickwell = Fickwell.create! :bar => "{fbb}"
 
-    assert_equal "syn two", @hickwell.bar, "Did not retrieve mask for object aliased method reference"
+    assert_equal "syn two", @hickwell.maskable_bar.masked, "Did not retrieve mask for object aliased method reference"
   end
 
-  test "should be able to handle masks for non-string types" do
+  test "should handle masks for non-string types" do
     class Nickwell < Hickwell
       maskable_attribute :baz, [ :number ]
 
@@ -146,7 +146,7 @@ class MaskableAttributeTest < ActiveSupport::TestCase
     end
     @hickwell = Nickwell.create! :baz => "fixture {number}"
 
-    assert_equal "fixture 5", @hickwell.baz, "Could not handle non-string type mask"
+    assert_equal "fixture 5", @hickwell.maskable_baz.masked, "Could not handle non-string type mask"
   end
 
   test "should raise exception if maskable_attribute isn't actually an attribute" do
@@ -161,7 +161,7 @@ class MaskableAttributeTest < ActiveSupport::TestCase
     end
   end
 
-  test "should be able to handle a proc and a format" do
+  test "should handle a proc and a format" do
     class Tickwell < Hickwell
       maskable_attribute :bar, { :foo => {
                                    :method => Proc.new { "2" },
@@ -172,10 +172,10 @@ class MaskableAttributeTest < ActiveSupport::TestCase
 
     @hickwell = Tickwell.create! :bar => "{foo}"
 
-    assert_equal "02", @hickwell.bar, "Did not retrieve mask having a proc and a format specified"
+    assert_equal "02", @hickwell.maskable_bar.masked, "Did not retrieve mask having a proc and a format specified"
   end
 
-  test "should not confuse masks' formatting" do
+  test "should not confuse mask formatting" do
     class Pickwell < Hickwell
       maskable_attribute :bar, { :foo => {
                                    :method => Proc.new { "2" },
@@ -186,23 +186,10 @@ class MaskableAttributeTest < ActiveSupport::TestCase
 
     @pickwell = Pickwell.create! :bar => "{foo}"
 
-    assert_equal "2", @pickwell.bar
-    @pickwell.bar = "2"
+    assert_equal "2", @pickwell.maskable_bar.masked
     assert_equal "{foo}", @pickwell.maskable_bar.unmasked
-    @pickwell.bar = "02"
+    @pickwell.bar = "{two_digit_foo}"
     assert_equal "{two_digit_foo}", @pickwell.maskable_bar.unmasked
-    assert_equal "02", @pickwell.bar
-  end
-
-  test "should not mask if specified as a non-maskable prefix" do
-    class Zickwell < Hickwell
-      maskable_attribute :bar, { :foo => { :method => Proc.new { "TEST" } } }, { :protected_prefixes => [ "prefix" ] }
-    end
-
-    @zickwell = Zickwell.create! :bar => "TEST"
-    assert_equal "{foo}", @zickwell.maskable_bar.unmasked, "Mask not being replaced"
-
-    @zickwell.update_attribute :bar, "prefixTEST"
-    assert_equal "prefixTEST", @zickwell.maskable_bar.unmasked, "Incorrectly masked for non-maskable prefix"
+    assert_equal "02", @pickwell.maskable_bar.masked
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maskable_attribute
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-23 00:00:00.000000000 Z
+date: 2012-08-15 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &70148099593740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,12 +21,7 @@ dependencies:
         version: 2.3.10
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.3.10
+  version_requirements: *70148099593740
 description: A maskable attribute is an attribute that is made up of other attributes
   (masks), this ordering is set in the masked attribute and preserved across updates.
 email:
@@ -121,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: maskable_attribute
-rubygems_version: 1.8.24
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Allows Ruby on Rails to have a maskable attribute.