maskable_attribute 0.0.1 → 0.0.2

data/lib/maskable_attribute/mask.rb

@@ -28,10 +28,12 @@ module MaskableAttribute
     end
 
     def [](accessor)
+      accessor = accessor.tr " ", "_"
       (find_by_accessor(accessor) || Mask.new).accessor(accessor)
     end
 
     def find_by_accessor(accessor)
+      accessor = accessor.tr " ", "_"
       @masks.find do |mask|
         mask.accessed_by? accessor
       end
@@ -47,10 +49,11 @@ module MaskableAttribute
 
     def initialize(options=nil)
       if options.is_a? Symbol
-        @name = @method = options.to_sym
+        self.name = (@method = options.to_sym)
         options = {}
       elsif options.is_a? Hash
-        @name, options = options.flatten
+        self.name = options.flatten.first
+        options = options.flatten.last
         if options.is_a? Symbol or options.is_a? Proc
           @method = options
           options = {}
@@ -59,15 +62,15 @@ module MaskableAttribute
             @method = options.shift
             options = options.extract_options!
           else
-            @method = @name
+            @method = name.to_sym
           end
         end
       end
       @formats = Formatting::Formats.new options
     end
 
-    def name
-      @name.to_s.tr "_", " "
+    def name=(value)
+      @name = value.to_s.tr(' ', '_')
     end
 
     def accessor(*accessed_with)
@@ -82,7 +85,7 @@ module MaskableAttribute
     def unmask(*args)
       object = args.first
       options = args.extract_options!
-      format = options[:formatted] || accessor.sub(@name.to_s, "").strip.to_sym
+      format = options[:formatted] || accessor.sub("_" + name.to_s, "").strip.to_sym
 
       formats.apply format do
         begin
@@ -100,13 +103,13 @@ module MaskableAttribute
     end
 
     def accessed_by
-      formats.names.map { |format| format.to_s + " " + name}.tap do |accessed_by|
+      formats.names.map { |format| format.to_s + "_" + name}.tap do |accessed_by|
         accessed_by.push name unless formats.are_exclusive?
       end
     end
 
     def accessed_by?(possible_accessor)
-      accessed_by.include? possible_accessor.tr('_', ' ')
+      accessed_by.include? possible_accessor
     end
   end
 end

data/lib/maskable_attribute/maskable_attribute.rb

@@ -16,7 +16,8 @@ module MaskableAttribute
       value = unmasked
       if !value.blank? and value.match(/\{.*\}/)
         value.scan(/(?<={)[^}]+(?=})/).each do |mask| #mask: two_digit model_series
-          value = value.sub "{#{mask}}", @masks[mask].unmask(@object).to_s unless @masks[mask].unmask(@object).nil?
+          mask_value = @masks[mask].unmask(@object)
+          value = value.sub "{#{mask}}", mask_value.to_s unless mask_value.nil?
         end
       end
       value

data/lib/maskable_attribute/version.rb

@@ -1,3 +1,3 @@
 module MaskableAttribute
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/mask_test.rb

@@ -38,52 +38,59 @@ class MaskTest < ActiveSupport::TestCase
     assert_equal 'Success', mask.unmask('SUCCESS', { :formatted => :capitalize })
   end
 
-  test "should turn underscores into spaces for its name" do
-    mask = MaskableAttribute::Mask.new  :foo_bar
+  test "should turn spaces into underscores for its name" do
+    mask = MaskableAttribute::Mask.new :"foo bar" => :foo_bar
 
-    assert_equal "foo bar", mask.name
+    assert_equal "foo_bar", mask.name
     assert_equal :foo_bar, mask.method
   end
 
   test "should return all accessed_by names" do
     mask = MaskableAttribute::Mask.new :downcase => { :formats => { :capitalized => :capitalize } }
 
-    assert_equal ["capitalized downcase", "downcase"], mask.accessed_by
+    assert_equal ["capitalized_downcase", "downcase"], mask.accessed_by
   end
 
   test "should return all formatted exclusively accessed_by names" do
     mask = MaskableAttribute::Mask.new :downcase => { :exclusive_format => { :capitalized => :capitalize } }
 
-    assert_equal ["capitalized downcase"], mask.accessed_by
+    assert_equal ["capitalized_downcase"], mask.accessed_by
   end
 
   test "should determine whether a string matches its accessible names" do
     mask = MaskableAttribute::Mask.new :downcase => { :exclusive_format => { :capitalized => :capitalize } }
 
     assert !mask.accessed_by?("downcase")
-    assert mask.accessed_by?("capitalized downcase")
+    assert mask.accessed_by?("capitalized_downcase")
+  end
+
+  test "should accept two word formats with two word masks" do
+    mask = MaskableAttribute::Mask.new :down_cased => [ :downcase, :formats => { :capitalized_but => :capitalize } ]
+
+    assert mask.accessed_by?("capitalized_but_down_cased")
+    assert_equal 'Success', mask.unmask('SUCCESS', :formatted => :capitalized_but)
   end
 
   #describe masks
   test "should find correct mask by accessor" do
-    masks = MaskableAttribute::Masks.new [ :bar => { :exclusive_format => { :capitalized => :capitalize } },
-                                           :baz => { :format => :upcase } ]
+    masks = MaskableAttribute::Masks.new [ { :bar => { :exclusive_format => { :capitalized => :capitalize } } },
+                                           { :baz => { :format => :upcase } } ]
 
     assert_equal "bar", masks.find_by_accessor("capitalized bar").name
   end
 
   test "should be accessible by accessor" do
-    masks = MaskableAttribute::Masks.new [ :bar => { :exclusive_format => { :capitalized => :capitalize } },
-                                           :baz => { :format => :upcase } ]
+    masks = MaskableAttribute::Masks.new [ { :bar => { :exclusive_format => :capitalize } },
+                                           { :baz => { :format => :upcase } } ]
 
-    assert_equal "bar", masks["capitalized bar"].name
+    assert_equal "baz", masks["upcase baz"].name
   end
 
-  test "should unmask given object with correct mask and format" do
-    masks = MaskableAttribute::Masks.new [ :downcase => { :exclusive_format => { :capitalized => :capitalize } },
-                                           :bar => { :format => :upcase } ]
+  test "should unmask given object with correct mask and its exlusive format" do
+    masks = MaskableAttribute::Masks.new [ { :downcase => { :exclusive_format => :capitalize } },
+                                           { :bar => { :format => :upcase } } ]
 
-    assert_equal "Success", masks["capitalized downcase"].unmask("SUCCESS")
+    assert_equal "Success", masks["capitalize downcase"].unmask("SUCCESS")
   end
 
   test "should return nil when trying to access and get value of a non-existent mask" do

data/test/maskable_attribute_test.rb

@@ -116,9 +116,9 @@ class MaskableAttributeTest < ActiveSupport::TestCase
         "ack one"
       end
     end
-    @hickwell = Fickwell.create! :bar => "{foo bar baz}"
+    @fickwell = Fickwell.create! :bar => "{foo bar baz}"
 
-    assert_equal "ack one", @hickwell.bar, "Did not retrieve mask for object method reference"
+    assert_equal "ack one", @fickwell.bar, "Did not retrieve mask for object method reference"
   end
 
   test "masks should be able to directly reference aliased methods for the class object" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maskable_attribute
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-28 00:00:00.000000000Z
+date: 2012-06-29 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70319231502920 !ruby/object:Gem::Requirement
+  requirement: &70349364129120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: 2.3.10
   type: :runtime
   prerelease: false
-  version_requirements: *70319231502920
+  version_requirements: *70349364129120
 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: