maskable_attribute 0.0.1

data/test/dummy/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/test/dummy/script/about

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+$LOAD_PATH.unshift "#{RAILTIES_PATH}/builtin/rails_info"
+require 'commands/about'

data/test/dummy/script/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/console'

data/test/dummy/script/dbconsole

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/dbconsole'

data/test/dummy/script/destroy

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/destroy'

data/test/dummy/script/generate

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/generate'

data/test/dummy/script/performance/benchmarker

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../../config/boot',  __FILE__)
+require 'commands/performance/benchmarker'

data/test/dummy/script/performance/profiler

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../../config/boot',  __FILE__)
+require 'commands/performance/profiler'

data/test/dummy/script/plugin

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/plugin'

data/test/dummy/script/runner

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/runner'

data/test/dummy/script/server

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path('../../config/boot',  __FILE__)
+require 'commands/server'

data/test/dummy/test/fixtures/hickwells.yml

@@ -0,0 +1,9 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/Fixtures.html
+
+one:
+  foo: MyString
+  bar: MyString
+
+two:
+  foo: MyString
+  bar: MyString

data/test/dummy/test/test_helper.rb

@@ -0,0 +1,40 @@
+ENV["RAILS_ENV"] = "test"
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..'
+
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+
+class ActiveSupport::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/test/dummy/test/unit/hickwell_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class HickwellTest < ActiveSupport::TestCase
+  def setup
+    @hickwell = Hickwell.create!
+  end
+
+  test "should have 4 attributes, foo, bar, baz, qux" do
+    assert Hickwell.column_names.include?("foo"), "Missing attribute: foo"
+    assert Hickwell.column_names.include?("bar"), "Missing attribute: bar"
+    assert Hickwell.column_names.include?("baz"), "Missing attribute: baz"
+    assert Hickwell.column_names.include?("qux"), "Missing attribute: qux"
+  end
+
+  test "should have maskable_attribute qux" do
+    assert @hickwell.maskable_qux.is_a?(MaskableAttribute::MaskableAttribute), "Masked attribute isn't a MaskableAttribute"
+  end
+
+  test "should have getter and setter methods for qux" do
+    assert_respond_to @hickwell, :qux,  "No getter method"
+    assert_respond_to @hickwell, :qux=, "No setter method"
+  end
+
+  test "should have a quux method" do
+    assert @hickwell.respond_to? :quux, "Missing quux method"
+  end
+
+  test "returns 'thud' from quux method" do
+    assert_equal 'thud', @hickwell.quux, "#quux not returning 'thud'"
+  end
+end

data/test/formatting_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class FormattingTest < ActiveSupport::TestCase
+
+  #describe Format
+  test "should accept a symbol as the format method" do
+    format = MaskableAttribute::Formatting::Format.new :upcase
+    assert_equal "SUCCESS", format.apply("success")
+  end
+
+  test "should accept a Proc as the format method" do
+    format = MaskableAttribute::Formatting::Format.new Proc.new { |value| value.upcase }
+    assert_equal "SUCCESS", format.apply("success")
+  end
+
+  #describe Formats
+  test "should accept a hash of a single format" do
+    formats = MaskableAttribute::Formatting::Formats.new :formats => :upcase
+
+    assert_equal "SUCCESS", formats[:upcase].apply("success")
+  end
+
+  test "should accept a hash of an array of formats" do
+    formats = MaskableAttribute::Formatting::Formats.new :formats => [ :upcase, :downcase ]
+
+    assert_equal "SUCCESS", formats[:upcase].apply("success"), "First element not assigned as name/method"
+    assert_equal "success", formats[:downcase].apply("SUCCESS"), "Second element not assigned as name/method"
+  end
+
+  test "should accept a hash of a hash with a symbol as a value" do
+    formats = MaskableAttribute::Formatting::Formats.new :formats => { :upcased => :upcase }
+
+    assert_equal "SUCCESS", formats[:upcased].apply("success")
+  end
+
+  test "should accept a hash of a hash of formats" do
+    formats = MaskableAttribute::Formatting::Formats.new :formats => { :two_digit => Proc.new { |value| format '%02d', value },
+                                                                       :upcased => :upcase,
+                                                                       :downcase => nil }
+
+    assert_equal '01', formats[:two_digit].apply(1), "Proc not used as method"
+    assert_equal "SUCCESS", formats[:upcased].apply("success"), "Symbol not used as method"
+    assert_equal "success", formats[:downcase].apply("SUCCESS"), "Name, in leu of nil, not used as method"
+  end
+
+  test "should recognize exclusive formats" do
+    formats = MaskableAttribute::Formatting::Formats.new :exclusive_formats => [ :upcase, :downcase ]
+
+    assert formats.are_exclusive?, "Did not recognize exclusive formats"
+  end
+
+  test "should recognize a default_format" do
+    formats = MaskableAttribute::Formatting::Formats.new :default_format => :upcase
+
+    assert formats.has_default?
+    assert_equal formats[:upcase], formats.default, "Default format not assigned"
+    assert_equal 'SUCCESS', formats.default.apply("success"), "Default format not applied"
+  end
+
+  test "should be able to use a block for applying formats" do
+    formats = MaskableAttribute::Formatting::Formats.new :formats => :upcase
+
+    assert_equal 'SUCCESS', formats.apply(:upcase) { "success" }
+  end
+
+  test "should provide all format names" do
+    formats = MaskableAttribute::Formatting::Formats.new :formats => [ :upcase, :downcase ]
+
+    assert_equal [ :upcase, :downcase ], formats.names, "Did not provide all format names"
+  end
+end

data/test/mask_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+class MaskTest < ActiveSupport::TestCase
+
+  #describe mask
+  test "should accept symbol as both a name and its method" do
+    mask = MaskableAttribute::Mask.new :upcase
+
+    assert_equal "upcase", mask.name
+    assert_equal 'SUCCESS', mask.unmask('success')
+  end
+
+  test "should accept symbol as a name and method in its hash" do
+    mask = MaskableAttribute::Mask.new :lowercase => :downcase
+
+    assert_equal 'lowercase', mask.name
+    assert_equal 'success', mask.unmask('SUCCESS')
+  end
+
+  test "should accept proc as a method in its hash" do
+    mask = MaskableAttribute::Mask.new :lowercase => Proc.new { |value| value.downcase }
+
+    assert_equal 'lowercase', mask.name
+    assert_equal 'success', mask.unmask('SUCCESS')
+  end
+
+  test "should accept a hash of hash for options" do
+    mask = MaskableAttribute::Mask.new :downcase => { :formats => { :capitalized => :capitalize } }
+
+    assert_equal 'downcase', mask.name
+    assert_equal 'Success', mask.unmask('SUCCESS', :formatted => :capitalized)
+  end
+
+  test "should accept a hash of an array for options" do
+    mask = MaskableAttribute::Mask.new :lowercase => [ :downcase, { :formats => :capitalize } ]
+
+    assert_equal 'lowercase', mask.name
+    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
+
+    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
+  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
+  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")
+  end
+
+  #describe masks
+  test "should find correct mask by accessor" do
+    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 } ]
+
+    assert_equal "bar", masks["capitalized bar"].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 } ]
+
+    assert_equal "Success", masks["capitalized downcase"].unmask("SUCCESS")
+  end
+
+  test "should return nil when trying to access and get value of a non-existent mask" do
+    masks = MaskableAttribute::Masks.new [ :downcase => { :exclusive_format => { :capitalized => :capitalize } },
+                                           :bar => { :format => :upcase } ]
+
+    assert_nil masks["not a real mask"].unmask("nil is success!"), "This will probably be an error..."
+  end
+end

data/test/maskable_attribute_test.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+
+class MaskableAttributeTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, MaskableAttribute
+  end
+
+  test "should be able to 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
+    @hickwell = Hickwell.create!
+
+    assert_respond_to @hickwell.maskable_qux, :masks, "Couldn't get available masks"
+  end
+
+  test "should get 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
+    @hickwell = Hickwell.create!
+
+    @hickwell.qux = "{foo}{bar}{baz}"
+    assert_equal "{foo}{bar}{baz}", @hickwell.read_attribute(:qux), "Couldn't set masking of attribute"
+  end
+
+  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
+    @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
+    @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
+    @hickwell = Hickwell.create! :foo => "a", :bar => "b", :baz => "c", :qux => "{foo}{bar}{baz}"
+    @hickwell.qux = "bac"
+
+    assert_equal "{bar}{foo}{baz}", @hickwell.maskable_qux.unmasked, "Masks didn't persist though update"
+  end
+
+  test "masks should be able to reference differently named methods" do
+    class Rickwell < Hickwell
+      maskable_attribute :bar, :qux => :quux
+    end
+
+    @hickwell = Rickwell.create! :bar => "{qux}"
+
+    assert_equal "thud", @hickwell.bar
+  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"
+  end
+
+  test "masks should be able to 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
+  end
+
+  test "masks should be able to 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"
+  end
+
+  test "masks should be able to 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"
+  end
+
+  test "masks should be able to directly reference methods for the class object" do
+    class Fickwell < Hickwell
+      maskable_attribute :bar, [ :foo_bar_baz ]
+
+      def foo_bar_baz
+        "ack one"
+      end
+    end
+    @hickwell = Fickwell.create! :bar => "{foo bar baz}"
+
+    assert_equal "ack one", @hickwell.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
+    class Fickwell < Hickwell
+      maskable_attribute :bar, [ :fbb ]
+
+      def foo_bar_baz
+        "syn two"
+      end
+
+      alias :fbb :foo_bar_baz
+    end
+    @hickwell = Fickwell.create! :bar => "{fbb}"
+
+    assert_equal "syn two", @hickwell.bar, "Did not retrieve mask for object aliased method reference"
+  end
+
+  test "should be able to handle masks for non-string types" do
+    class Nickwell < Hickwell
+      maskable_attribute :baz, [ :number ]
+
+      def number
+        5
+      end
+    end
+    @hickwell = Nickwell.create! :baz => "fixture {number}"
+
+    assert_equal "fixture 5", @hickwell.baz, "Could not handle non-string type mask"
+  end
+
+  test "should raise exception if maskable_attribute isn't actually an attribute" do
+    assert_raise ArgumentError do
+      Hickwell.maskable_attribute :fail, [ :foo, :bar, :baz ]
+    end
+  end
+
+  test "should raise exception if no masks are passed" do
+    assert_raise ArgumentError do
+      Hickwell.maskable_attribute :qux
+    end
+  end
+end