maskable_attribute 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+.*.swp
+.bundle/
+log/*.log
+pkg/
+test/dummy/db/*.sqlite3
+test/dummy/log/*.log
+test/dummy/tmp/

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2-p290@maskable_attribute

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+gem "rails", "~> 2.3.10"
+gem "sqlite3"
+
+# Declare your gem's dependencies in maskable_attribute.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'ruby-debug19', :require => 'ruby-debug'

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    maskable_attribute (0.0.1)
+      rails (>= 2.3.10)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (2.3.14)
+      actionpack (= 2.3.14)
+    actionpack (2.3.14)
+      activesupport (= 2.3.14)
+      rack (~> 1.1.0)
+    activerecord (2.3.14)
+      activesupport (= 2.3.14)
+    activeresource (2.3.14)
+      activesupport (= 2.3.14)
+    activesupport (2.3.14)
+    rack (1.1.3)
+    rails (2.3.14)
+      actionmailer (= 2.3.14)
+      actionpack (= 2.3.14)
+      activerecord (= 2.3.14)
+      activeresource (= 2.3.14)
+      activesupport (= 2.3.14)
+      rake (>= 0.8.3)
+    rake (0.9.2.2)
+    sqlite3 (1.3.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  maskable_attribute!
+  rails (~> 2.3.10)
+  sqlite3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+# Maskable Attribute
+
+maskable_attribute is an ActiveRecord extension that allows for 'masking' a records' attribute. It provides the ability to have an objects' attribute be dynamically assigned at a given point in time while providing the capability to make a one-location change that propagates through all resulting objects containing the resulting attribute mask.
+
+## Install
+
+### Via rubygems:
+
+    gem install maskable_attribute
+
+### Via bundler:
+
+  Add the following line to Gemfile:
+
+    gem 'maskable_attribute'
+
+  Then, run bundler:
+
+    bundle install
+
+## Usage
+
+To use the maskable_attribute gem, simply create corresponding maskable_attribute attributes in the ActiveRecord model that you wish to affect.
+
+For example, the following User class has a maskable attribute of :foo that can contain values of :bar, :baz and :qux
+
+    class User < ActiveRecord::Base
+      maskable_attribute :foo, [ :bar, :baz ]
+    end
+
+Creating a user with the above mask can be performed via the following:
+
+    user = User.new :bar => "a", :baz => "b", :foo => "{bar}-{baz}"
+
+Now that the user object is created, there are several accessor methods to return different variations of the attribute:
+
+    user.masks              # { :foo => { :bar, :baz } }
+    user.foo.masks          # [ :bar, :baz ]
+    user.foo                # "a-b"
+    user.foo.unmasked       # "{bar}-{baz}"
+
+## Supported Ruby versions
+
+Maskable Attribute supports Ruby 1.9.x+
+
+## Additional Information
+
+* [Git](https://github.com/billy-ran-away/maskable_attribute)
+
+## Contributing
+
+Contributions to the code-base are welcomed and handled via the normal Github pull request process.
+
+## Owner
+
+maskable_attribute is written and maintained by Bill Transue

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MaskableAttribute'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/maskable_attribute.rb

@@ -0,0 +1,6 @@
+require "maskable_attribute/acts_as_maskable_attribute"
+require "maskable_attribute/maskable_attribute"
+require "maskable_attribute/mask"
+require "maskable_attribute/formatting"
+module MaskableAttribute
+end

data/lib/maskable_attribute/acts_as_maskable_attribute.rb

@@ -0,0 +1,48 @@
+module MaskableAttribute
+  module ActsAsMaskableAttribute
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      ##
+      # Specifies an attribute to be masked, followed by masks to be made available to the attribute.
+      #
+      # ==== Examples
+      #
+      # class Foo < ActiveRecord::Base
+      #   maskable_attrribute :some_attribute, [ :some_method_be_used_as_a_mask, :another_attribute_mask ]
+      # end
+
+      def maskable_attribute(attribute_to_mask, masks)
+        raise ArgumentError, "invalid argument (expected attribute)" unless column_names.include? attribute_to_mask.to_s
+
+        cattr_accessor :masks
+        self.masks ||= {}
+        self.masks[attribute_to_mask] = masks
+        self.masks
+
+        define_method attribute_to_mask do
+          send("maskable_#{attribute_to_mask}").to_s
+        end
+
+        define_method "#{attribute_to_mask}=" do |value|
+          write_attribute attribute_to_mask, masked_attribute(attribute_to_mask).set(value)
+        end
+
+        define_method "maskable_#{attribute_to_mask}" do
+          masked_attribute attribute_to_mask
+        end
+      end
+    end
+
+    attr_accessor :masked_attribute
+
+    def masked_attribute(attribute)
+      @masked_attribute ||= MaskableAttribute.new self, attribute, self.class.masks[attribute]
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, MaskableAttribute::ActsAsMaskableAttribute

data/lib/maskable_attribute/formatting.rb

@@ -0,0 +1,71 @@
+module MaskableAttribute
+  module Formatting
+    class Formats < Hash
+
+      #{ :format => :two_digit }
+      #{ :formats => [ :upcase, :downcase ] }
+      #{ :exclusive_format => { :capitalized => Proc.new{ |mask| mask.captialized } } }
+      #{ :exclusive_formats =>{ :capitalized => Proc.new{ |mask| mask.captialized }, :titleized => :titleize } }
+      #{ :default_format => :titleize }
+      attr_accessor :are_exclusive, :has_default, :default
+      def initialize(options = {})
+        @are_exclusive, @has_default = false, false
+        @default = nil
+        unless options.nil?
+          options.each do |type, formats|
+            if formats.is_a? Symbol or formats.is_a? Proc
+              self[formats] = Format.new formats
+            elsif formats.is_a? Array
+              formats.each do |format|
+                self[format] = Format.new format
+              end
+            else
+              formats.each do |format, method|
+                self[format] = Format.new method || format
+              end
+            end
+
+            if type.to_s.include? "exclusive"
+              @are_exclusive = true
+            elsif type.to_s.include? "default"
+              @has_default = true
+              @default = self[formats]
+            end
+          end
+        end
+      end
+
+      def apply(format, &block)
+        fetch(format, (has_default? ? @default : Format.new)).apply yield unless yield.nil?
+      end
+
+      def names
+        keys
+      end
+
+      def are_exclusive?
+        @are_exclusive
+      end
+
+      def has_default?
+        @has_default
+      end
+    end
+
+    class Format
+      def initialize(method=nil)
+        @method = method
+      end
+
+      def apply(input)
+        if @method.is_a? Symbol
+          input.send(@method)
+        elsif @method.is_a? Proc
+          @method.call input
+        else
+          input
+        end
+      end
+    end
+  end
+end

data/lib/maskable_attribute/mask.rb

@@ -0,0 +1,112 @@
+module MaskableAttribute
+  class Masks
+    include Enumerable
+
+    #:bar
+    #:foo => :bar
+    #:foo => [ :bar, baz, :qux ]
+    #:foo => { :format => :two_digit }
+    #:foo => { :formats => [ :two_digit, :upcase, :downcase ] }
+    #:bar => { :exclusive_format => { :capitalized => Proc.new{ |mask| mask.captialized } } }
+    #:bar => { :exclusive_formats => { :capitalized => Proc.new{ |mask| mask.captialized }, :titleized => :titleize } }
+    #:baz => { :default_format => :titleize }
+    #:bar => [ :quux, { :formats => ... } ]
+    #:bar => [ Proc.new { |object| object.size * 3 }, { :formats => ... } ]
+    def initialize(masks)
+      @masks = masks.map do |mask|
+        if mask.is_a? Array
+          Mask.new mask.first => mask.last
+        else
+          Mask.new mask
+        end
+      end
+    end
+
+    def each(&block)
+      @masks.each(&block)
+      return self
+    end
+
+    def [](accessor)
+      (find_by_accessor(accessor) || Mask.new).accessor(accessor)
+    end
+
+    def find_by_accessor(accessor)
+      @masks.find do |mask|
+        mask.accessed_by? accessor
+      end
+    end
+
+    def names
+      @masks.map(&:name).map(&:to_sym)
+    end
+  end
+
+  class Mask
+    attr_accessor :accessor, :name, :method, :formats
+
+    def initialize(options=nil)
+      if options.is_a? Symbol
+        @name = @method = options.to_sym
+        options = {}
+      elsif options.is_a? Hash
+        @name, options = options.flatten
+        if options.is_a? Symbol or options.is_a? Proc
+          @method = options
+          options = {}
+        else
+          if options.is_a? Array
+            @method = options.shift
+            options = options.extract_options!
+          else
+            @method = @name
+          end
+        end
+      end
+      @formats = Formatting::Formats.new options
+    end
+
+    def name
+      @name.to_s.tr "_", " "
+    end
+
+    def accessor(*accessed_with)
+      if accessed_with.empty?
+        @accessor || ""
+      else
+        @accessor = accessed_with.first
+        self
+      end
+    end
+
+    def unmask(*args)
+      object = args.first
+      options = args.extract_options!
+      format = options[:formatted] || accessor.sub(@name.to_s, "").strip.to_sym
+
+      formats.apply format do
+        begin
+          if @method.is_a? Proc
+            @method.call object
+          elsif @method.is_a? Symbol
+            object.send(@method) if object.respond_to? @method
+          else
+            nil
+          end
+        rescue NoMethodError
+          nil
+        end
+      end
+    end
+
+    def 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('_', ' ')
+    end
+  end
+end

data/lib/maskable_attribute/maskable_attribute.rb

@@ -0,0 +1,58 @@
+module MaskableAttribute
+  class MaskableAttribute
+    attr_accessor :object, :attribute, :masks
+
+    def initialize(object, attribute, masks)
+      @object = object
+      @attribute = attribute
+      @masks = Masks.new masks
+    end
+
+    def masks
+      @masks.names
+    end
+
+    def masked
+      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?
+        end
+      end
+      value
+    end
+
+    alias :to_s :masked
+
+    def masked_object
+      @object
+    end
+
+    def unmasked
+      @object.read_attribute attribute
+    end
+
+    def set(value)
+      unless value.blank?
+        @masks.each do |mask|
+          mask.accessed_by.each do |mask_accessor|
+            value.sub! /#{mask.unmask(@object, :formatted => mask_accessor)}(?![^{]*})/, "{#{mask_accessor}}" unless mask.unmask(@object).blank?
+          end
+        end
+      end
+      value
+    end
+
+    class InvalidMask < RuntimeError
+      attr :mask, :obj
+      def initialize(mask, obj)
+        @mask = mask
+        @obj = obj
+      end
+
+      def to_s
+        "Invalid mask '#{@mask}' for #{@obj.class.name}"
+      end
+    end
+  end
+end