concerns_on_rails 1.12.1 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56664d3e955f53dbeec1d586c31b57c860a208cedff76990236a728de1c6f9ec
-  data.tar.gz: 6a427597a32d8a2d848d2f51ed9cf45d6a3ea41dd9ea77c2b215b4a66846170e
+  metadata.gz: 4b5bc2f3b03563d643ff2e9cffe13038cf90482499d88475ef49fea9d37ea5f9
+  data.tar.gz: d4b3228e473a838929c108d548674cb7b17738c62af1e1dee7454651f405e68c
 SHA512:
-  metadata.gz: b34bc02259d6a33a0d1fa1dac2f2e71473cc543515df2088766b736eed4cdc8e9925616cca6397a5318d22bdcafbf910e8bea6ea9f93e1de4746613f3aa747b2
-  data.tar.gz: 52e3f5a2dda49da303b118a4962ca479bb43b628d363ff133c23939fc523235a01065441cea4002dccd33130ace25149da275ddb9839dc864b2e442377f88a28
+  metadata.gz: 9f860c2f0c0a6d7570985c6a0f13c5b923ddb7aa12bcb08060b9dbbcd7ee6106182679d99ac3e7826835d8ccea708ef8bc82101aeb6c142fe20cbfbac77f636b
+  data.tar.gz: 865441dcf91d87c664809919a930ac2aedfa27fce106570a77e0dcf2331cc074313d0f63abecd21691b36c3af5861c72cc21b956ed70e11896ef411737287671

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 <!-- CHANGELOG.md -->
 
+## 1.13.0 (2026-06-06)
+
+### Added
+- **Models::Maskable**: non-destructive display masking for sensitive attributes. `maskable :email, with: :email` adds a `masked_<field>` reader and never writes the column (the raw value stays in the DB). Presets `:email` / `:phone` / `:credit_card` / `:last4` / `:all`, a configurable `mask:` character, and a `Proc` escape hatch. Backed by `Support::Masker`; complements `Sanitizable`.
+- **Models::Monetizable**: exact, float-free money handling over an integer subunit column. `monetizable :price_cents` derives `price` / `price=` / `formatted_price` (the `_cents` suffix is stripped, or name them with `as:`). Options `unit:` / `precision:` / `delimiter:` / `separator:` / `subunit_to_unit:`. Uses `BigDecimal` throughout; backed by `Support::Money`.
+- **Controllers::Localizable**: per-request locale selection from `params` and/or the `Accept-Language` header via an `around_action` (`I18n.with_locale`). `localizable available: %i[en fr], default: :en`; options `param:` / `header:`. The resolved locale is always validated against `I18n.available_locales`, so it can never raise `I18n::InvalidLocale`.
+
+### Notes
+- All changes are additive and backward-compatible, with zero new runtime dependencies (BigDecimal and I18n already ship with the existing stack). `ConcernsOnRails::Maskable` / `ConcernsOnRails::Monetizable` are aliased to their `Models::*` modules; the controller concern stays namespace-only (`ConcernsOnRails::Controllers::Localizable`).
+
 ## 1.12.1 (2026-06-06)
 
 ### Added

data/README.md

@@ -41,6 +41,8 @@ Article.published.without_deleted.find("hello-world")
   - [Addressable](#-addressable) — postal address normalization + format validation
   - [Taggable](#-taggable) — lightweight tagging over a single column
   - [Sanitizable](#-sanitizable) — opt-in HTML sanitization (XSS defense-in-depth)
+  - [Maskable](#-maskable) — non-destructive display masking of sensitive fields
+  - [Monetizable](#-monetizable) — integer-cents money columns (BigDecimal)
 - **Controller concerns**
   - [Paginatable](#-paginatable) — offset pagination with headers
   - [Filterable](#-filterable) — declarative URL-param filters
@@ -49,6 +51,7 @@ Article.published.without_deleted.find("hello-world")
   - [ErrorHandleable](#-errorhandleable) — JSON `rescue_from` handlers for common controller errors
   - [Includable](#-includable) — whitelisted association sideloading + sparse fieldsets
   - [SecureHeadable](#-secureheadable) — security response headers + native CSP DSL
+  - [Localizable](#-localizable) — per-request locale from params / Accept-Language
 - [Module paths & namespacing](#-module-paths--namespacing)
 - [Development](#-development)
 - [Contributing](#-contributing)
@@ -58,7 +61,7 @@ Article.published.without_deleted.find("hello-world")
 
 ## ✨ Why this gem?
 
-- **Sixteen model concerns + seven controller concerns**, all production-ready
+- **Eighteen model concerns + eight controller concerns**, all production-ready
 - **One include, one macro** — no boilerplate, no glue code
 - **Lean dependencies** — only `acts_as_list` (Sortable) and `friendly_id` (Sluggable); controller concerns have zero extra deps
 - **Schema-validated configuration** — every macro checks that the configured column exists and raises `ArgumentError` early
@@ -871,6 +874,64 @@ article.sanitized_body  # => "<b>Hi</b>alert(1)"                    (script tag
 
 ---
 
+## 🙈 Maskable
+
+Non-destructive display masking for sensitive attributes. Each declaration adds a `masked_<field>` reader and **never writes the column** — the raw value stays in the database (masking is a presentation concern). Dependency-free.
+
+```ruby
+class User < ApplicationRecord
+  include ConcernsOnRails::Maskable
+
+  maskable :email, with: :email          # => user.masked_email  "j****@example.com"
+  maskable :card,  with: :credit_card    # => user.masked_card   "**** **** **** 4242"
+  maskable :ssn,   with: :last4, mask: "•"
+  maskable :token, with: ->(v) { "#{v.to_s[0, 3]}…" }
+end
+```
+
+**Presets** (`with:`)
+
+| Preset         | Result                                      |
+|----------------|---------------------------------------------|
+| `:email`       | `j****@example.com` (first char + domain)   |
+| `:phone`       | `***-2671` (last 4 digits)                  |
+| `:credit_card` | `**** **** **** 4242` (last 4 digits)       |
+| `:last4`       | keep the last 4 characters                  |
+| `:all`         | mask every character (the default)          |
+| `Proc`         | used as-is (you own the non-String guard)   |
+
+`mask:` sets the mask character (default `*`). Nil and non-string values pass through untouched. To strip dangerous HTML instead, see [Sanitizable](#-sanitizable).
+
+---
+
+## 💰 Monetizable
+
+Money handling for an integer "subunit" column (e.g. cents) — exact and float-free via `BigDecimal`. `monetizable :price_cents` derives three methods (the `_cents` suffix is stripped):
+
+```ruby
+class Product < ApplicationRecord
+  include ConcernsOnRails::Monetizable
+
+  monetizable :price_cents                          # => price / price= / formatted_price
+  monetizable :shipping_cents, as: :shipping
+  monetizable :total_cents, unit: "€", delimiter: ".", separator: ","
+end
+
+product.price = 19.99   # stores price_cents = 1999 (rounded to whole cents)
+product.price           # => BigDecimal 19.99
+product.formatted_price # => "$19.99"
+```
+
+| Method            | Returns                                       |
+|-------------------|-----------------------------------------------|
+| `price`           | the amount as a `BigDecimal` (cents ÷ 100)    |
+| `price=`          | assign in major units; rounded to whole cents |
+| `formatted_price` | a display string (`"$1,234.56"`)              |
+
+**Options**: `as:` (explicit method name — required when the column does not end in `_cents`), `unit:` (`"$"`), `precision:` (`2`), `delimiter:` (`","`), `separator:` (`"."`), `subunit_to_unit:` (`100`). `nil` stays `nil` across all three methods.
+
+---
+
 # 🎮 Controller Concerns
 
 Pure ActionController + ActiveRecord — **zero extra runtime dependencies** (no Kaminari, Pundit, or Ransack).
@@ -1134,6 +1195,25 @@ end
 
 ---
 
+## 🌐 Localizable
+
+Per-request locale selection from the request params and/or the `Accept-Language` header, wrapped in an `around_action` so `I18n.locale` is set for the action and restored afterwards. Dependency-free.
+
+```ruby
+class ApplicationController < ActionController::Base
+  include ConcernsOnRails::Controllers::Localizable
+
+  localizable available: %i[en fr de], default: :en
+  # localizable param: :lang, header: false   # params[:lang] only
+end
+```
+
+Resolution order: `params[param]` → first match in `Accept-Language` → `default` → `I18n.default_locale`. The chosen locale is always validated against `I18n.available_locales`, so a stray param or a mismatched `available:` list can never raise `I18n::InvalidLocale`.
+
+**Options**: `available:` (allow-list for matching; defaults to `I18n.available_locales`), `default:`, `param:` (default `:locale`), `header:` (default `true`).
+
+---
+
 ## 🗂️ Module paths & namespacing
 
 Every concern is available under two paths:

data/lib/concerns_on_rails/controllers/localizable.rb

@@ -0,0 +1,96 @@
+require "active_support/concern"
+
+module ConcernsOnRails
+  module Controllers
+    # Per-request locale selection from the request params and/or the
+    # `Accept-Language` header, wrapped in an `around_action` so `I18n.locale`
+    # is set for the action and restored afterwards.
+    #
+    #   class ApplicationController < ActionController::Base
+    #     include ConcernsOnRails::Controllers::Localizable
+    #
+    #     localizable available: %i[en fr de], default: :en
+    #     # localizable param: :lang, header: false   # params[:lang] only
+    #   end
+    #
+    # Resolution order: `params[param]` → first match in `Accept-Language` →
+    # `default` → `I18n.default_locale`. The chosen locale is always validated
+    # against `I18n.available_locales` before use, so a stray param or a
+    # mismatched `available:` list can never raise `I18n::InvalidLocale`.
+    #
+    # Options: `available:` (allow-list for param/header matching; defaults to
+    # `I18n.available_locales`), `default:`, `param:` (default `:locale`),
+    # `header:` (default `true`).
+    module Localizable
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :localizable_options, instance_accessor: false, default: {}
+        around_action :switch_locale
+      end
+
+      class_methods do
+        def localizable(available: nil, default: nil, param: :locale, header: true)
+          self.localizable_options = {
+            available: available&.map(&:to_sym),
+            default: default&.to_sym,
+            param: param&.to_sym,
+            header: header
+          }
+        end
+      end
+
+      # Public so subclasses can override; runs the action under the resolved locale.
+      def switch_locale(&)
+        I18n.with_locale(resolved_locale, &)
+      end
+
+      # The locale chosen for this request — always one I18n can switch to.
+      def resolved_locale
+        opts = self.class.localizable_options
+        allowed = opts[:available].presence || I18n.available_locales
+        candidate = locale_from_param(opts, allowed) || locale_from_header(opts, allowed) || opts[:default]
+
+        candidate && I18n.available_locales.include?(candidate.to_sym) ? candidate.to_sym : I18n.default_locale
+      end
+
+      private
+
+      def locale_from_param(opts, allowed)
+        return nil unless opts[:param] && respond_to?(:params) && params
+
+        match_locale(params[opts[:param]], allowed)
+      end
+
+      def locale_from_header(opts, allowed)
+        return nil unless opts[:header]
+
+        header = accept_language_header
+        header.blank? ? nil : parse_accept_language(header, allowed)
+      end
+
+      def accept_language_header
+        return nil unless respond_to?(:request)
+
+        req = request
+        req.respond_to?(:headers) ? req.headers["Accept-Language"] : nil
+      end
+
+      def parse_accept_language(header, allowed)
+        header.split(",").each do |part|
+          lang = part.split(";").first.to_s.strip.split("-").first
+          match = match_locale(lang, allowed)
+          return match if match
+        end
+        nil
+      end
+
+      def match_locale(candidate, allowed)
+        return nil if candidate.blank?
+
+        wanted = candidate.to_s.downcase
+        allowed.find { |loc| loc.to_s.downcase == wanted }
+      end
+    end
+  end
+end

data/lib/concerns_on_rails/legacy_aliases.rb

@@ -18,4 +18,6 @@ module ConcernsOnRails
   Sequenceable  = Models::Sequenceable
   Taggable      = Models::Taggable
   Sanitizable   = Models::Sanitizable
+  Maskable      = Models::Maskable
+  Monetizable   = Models::Monetizable
 end

data/lib/concerns_on_rails/models/maskable.rb

@@ -0,0 +1,79 @@
+require "active_support/concern"
+require "concerns_on_rails/support/masker"
+
+module ConcernsOnRails
+  module Models
+    # Non-destructive display masking for sensitive string attributes.
+    #
+    # Masking is ALWAYS read-only: each declaration adds a `masked_<field>`
+    # reader and never writes the stored column (the raw value stays in the DB,
+    # because masking is a presentation concern). For stripping dangerous HTML
+    # see Models::Sanitizable.
+    #
+    #   class User < ApplicationRecord
+    #     include ConcernsOnRails::Models::Maskable
+    #
+    #     maskable :email, with: :email          # => user.masked_email  "j****@example.com"
+    #     maskable :card,  with: :credit_card    # => user.masked_card   "**** **** **** 4242"
+    #     maskable :ssn,   with: :last4, mask: "•"
+    #     maskable :token, with: ->(v) { "#{v.to_s[0, 3]}…" }
+    #   end
+    #
+    # Presets (the `with:` argument):
+    #   :email       — mask the local part, keep first char + domain
+    #   :phone       — keep the last 4 digits ("***-2671")
+    #   :credit_card — keep the last 4 digits ("**** **** **** 4242")
+    #   :last4       — keep the last 4 characters
+    #   :all         — mask every character (the default)
+    #   Proc         — used as-is (the caller owns the non-String guard)
+    #
+    # `mask:` sets the mask character (default "*") for the preset forms.
+    module Maskable
+      extend ActiveSupport::Concern
+
+      PRESETS = %i[email phone credit_card last4 all].freeze
+
+      included do
+        class_attribute :maskable_rules, instance_accessor: false, default: {}
+      end
+
+      class_methods do
+        include ConcernsOnRails::Support::ColumnGuard
+
+        def maskable(*fields, with: :all, mask: "*")
+          raise ArgumentError, "ConcernsOnRails::Models::Maskable: at least one field is required" if fields.empty?
+
+          masker = resolve_masker(with, mask)
+          ensure_columns!("ConcernsOnRails::Models::Maskable", fields)
+
+          fields.each do |field|
+            key = field.to_sym
+            self.maskable_rules = maskable_rules.merge(key => masker)
+            define_method("masked_#{field}") { masker.call(self[key]) }
+          end
+        end
+      end
+
+      class_methods do
+        private
+
+        def resolve_masker(with, mask)
+          case with
+          when Symbol
+            unless PRESETS.include?(with)
+              raise ArgumentError,
+                    "ConcernsOnRails::Models::Maskable: unknown preset '#{with}'. " \
+                    "Valid presets: #{PRESETS.join(', ')}"
+            end
+
+            ->(v) { ConcernsOnRails::Support::Masker.public_send(with, v, mask: mask) }
+          when Proc then with
+          else
+            raise ArgumentError,
+                  "ConcernsOnRails::Models::Maskable: :with must be a preset symbol or a Proc/lambda, got #{with.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concerns_on_rails/models/monetizable.rb

@@ -0,0 +1,89 @@
+require "active_support/concern"
+require "concerns_on_rails/support/money"
+
+module ConcernsOnRails
+  module Models
+    # Money handling for an integer "subunit" column (e.g. cents) — exact,
+    # float-free, via BigDecimal.
+    #
+    # Declaring `monetizable :price_cents` adds three methods derived from the
+    # column name (the `_cents` suffix is stripped):
+    #   * `price`            — the amount as a BigDecimal (cents / 100)
+    #   * `price=`           — assign in major units; rounded to whole cents
+    #   * `formatted_price`  — a display string ("$1,234.56")
+    #
+    #   class Product < ApplicationRecord
+    #     include ConcernsOnRails::Models::Monetizable
+    #
+    #     monetizable :price_cents                       # => price / price= / formatted_price
+    #     monetizable :shipping_cents, as: :shipping
+    #     monetizable :total_cents, unit: "€", separator: ",", delimiter: "."
+    #   end
+    #
+    #   product.price = 19.99   # stores price_cents = 1999
+    #   product.price           # => 0.1999e2  (BigDecimal 19.99)
+    #   product.formatted_price # => "$19.99"
+    #
+    # Options: `as:` (explicit method name — required when the column does not
+    # end in `_cents`), `unit:` ("$"), `precision:` (2), `delimiter:` (","),
+    # `separator:` ("."), `subunit_to_unit:` (100).
+    module Monetizable
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :monetizable_rules, instance_accessor: false, default: {}
+      end
+
+      class_methods do
+        include ConcernsOnRails::Support::ColumnGuard
+
+        def monetizable(*fields, as: nil, unit: "$", precision: 2, delimiter: ",", separator: ".", subunit_to_unit: 100)
+          raise ArgumentError, "ConcernsOnRails::Models::Monetizable: at least one field is required" if fields.empty?
+
+          raise ArgumentError, "ConcernsOnRails::Models::Monetizable: :as cannot be combined with multiple fields" if as && fields.size > 1
+
+          ensure_columns!("ConcernsOnRails::Models::Monetizable", fields)
+          config = { unit: unit, precision: precision, delimiter: delimiter, separator: separator, subunit_to_unit: subunit_to_unit }
+          fields.each { |cents_field| define_money_accessors(cents_field.to_sym, as, config) }
+        end
+      end
+
+      class_methods do # rubocop:disable Metrics/BlockLength
+        private
+
+        def define_money_accessors(cents_field, as, config)
+          name = money_name(cents_field, as)
+          subunit = config[:subunit_to_unit]
+          self.monetizable_rules = monetizable_rules.merge(cents_field => name)
+
+          define_method(name) do
+            cents = self[cents_field]
+            cents.nil? ? nil : BigDecimal(cents.to_s) / subunit
+          end
+
+          define_method("#{name}=") do |amount|
+            self[cents_field] = amount.nil? ? nil : (BigDecimal(amount.to_s) * subunit).round
+          end
+
+          define_method("formatted_#{name}") do
+            cents = self[cents_field]
+            cents.nil? ? nil : ConcernsOnRails::Support::Money.format(cents, config)
+          end
+        end
+
+        def money_name(cents_field, as)
+          return as.to_sym if as
+
+          str = cents_field.to_s
+          unless str.end_with?("_cents")
+            raise ArgumentError,
+                  "ConcernsOnRails::Models::Monetizable: cannot derive a money method name from '#{cents_field}' " \
+                  "(it does not end in '_cents'); pass `as:` to name it explicitly"
+          end
+
+          str.delete_suffix("_cents").to_sym
+        end
+      end
+    end
+  end
+end

data/lib/concerns_on_rails/support/masker.rb

@@ -0,0 +1,60 @@
+require "active_support/concern"
+
+module ConcernsOnRails
+  module Support
+    # Display-only value-masking helpers shared by Models::Maskable.
+    #
+    # Every method is string-safe: a non-String argument is returned untouched,
+    # exactly like the Normalizable / Sanitizable preset lambdas. Masking is for
+    # presentation only — callers keep the original value in the database.
+    module Masker
+      module_function
+
+      DEFAULT_MASK = "*".freeze
+
+      # Replace every character with the mask character.
+      def all(value, mask: DEFAULT_MASK)
+        value.is_a?(String) ? mask * value.length : value
+      end
+
+      # Keep only the last four characters visible.
+      def last4(value, mask: DEFAULT_MASK)
+        return value unless value.is_a?(String)
+
+        value.length <= 4 ? mask * value.length : (mask * (value.length - 4)) + value[-4..]
+      end
+
+      # Mask the local part of an email, keeping the first character + domain:
+      #   "john.doe@example.com" => "j*******@example.com"
+      def email(value, mask: DEFAULT_MASK)
+        return value unless value.is_a?(String)
+
+        local, at, domain = value.partition("@")
+        return value if at.empty? # not an email-shaped string; leave it alone
+
+        masked_local = local.length <= 1 ? mask : local[0] + (mask * (local.length - 1))
+        "#{masked_local}@#{domain}"
+      end
+
+      # Keep the last four digits of a phone number visible: "***-2671".
+      def phone(value, mask: DEFAULT_MASK)
+        return value unless value.is_a?(String)
+
+        digits = value.gsub(/\D/, "")
+        return value if digits.empty?
+
+        "#{mask * 3}-#{digits.length <= 4 ? digits : digits[-4..]}"
+      end
+
+      # Keep the last four digits of a card number: "**** **** **** 4242".
+      def credit_card(value, mask: DEFAULT_MASK)
+        return value unless value.is_a?(String)
+
+        digits = value.gsub(/\D/, "")
+        return all(value, mask: mask) if digits.length <= 4
+
+        "#{mask * 4} #{mask * 4} #{mask * 4} #{digits[-4..]}"
+      end
+    end
+  end
+end

data/lib/concerns_on_rails/support/money.rb

@@ -0,0 +1,38 @@
+require "bigdecimal"
+
+module ConcernsOnRails
+  module Support
+    # Formats an integer subunit amount (e.g. cents) as a human-readable money
+    # string. Pure and stateless; used by Models::Monetizable. Uses BigDecimal
+    # throughout so there is no binary-float rounding drift.
+    module Money
+      module_function
+
+      # format(199999) => "$1,999.99"
+      # format(-500, unit: "£") => "-£5.00"
+      # format(1234, unit: "¥", precision: 0, subunit_to_unit: 1) => "¥1,234"
+      def format(cents, options = {})
+        unit      = options.fetch(:unit, "$")
+        precision = options.fetch(:precision, 2)
+        delimiter = options.fetch(:delimiter, ",")
+        separator = options.fetch(:separator, ".")
+        subunit   = options.fetch(:subunit_to_unit, 100)
+
+        decimal = BigDecimal(cents.to_s) / subunit
+        # BigDecimal#round returns an Integer for precision <= 0, so re-wrap it
+        # in a BigDecimal before #to_s("F") (Integer#to_s would read "F" as a radix).
+        rounded = BigDecimal(decimal.abs.round(precision).to_s)
+        whole, _, frac = rounded.to_s("F").partition(".")
+        whole = delimit(whole, delimiter)
+        number = precision.positive? ? "#{whole}#{separator}#{frac.ljust(precision, '0')[0, precision]}" : whole
+
+        "#{'-' if decimal.negative?}#{unit}#{number}"
+      end
+
+      # Insert the thousands delimiter into a non-negative integer string.
+      def delimit(integer_string, delimiter)
+        integer_string.reverse.gsub(/(\d{3})(?=\d)/, "\\1#{delimiter}").reverse
+      end
+    end
+  end
+end

data/lib/concerns_on_rails/version.rb

@@ -1,3 +1,3 @@
 module ConcernsOnRails
-  VERSION = "1.12.1".freeze
+  VERSION = "1.13.0".freeze
 end

data/lib/concerns_on_rails.rb

@@ -13,6 +13,8 @@ require "concerns_on_rails/support/random_value"
 require "concerns_on_rails/support/address_data"
 require "concerns_on_rails/support/sequence_calculator"
 require "concerns_on_rails/support/html_sanitizers"
+require "concerns_on_rails/support/masker"
+require "concerns_on_rails/support/money"
 
 # Model concerns
 require "concerns_on_rails/models/sluggable"
@@ -31,6 +33,8 @@ require "concerns_on_rails/models/addressable"
 require "concerns_on_rails/models/sequenceable"
 require "concerns_on_rails/models/taggable"
 require "concerns_on_rails/models/sanitizable"
+require "concerns_on_rails/models/maskable"
+require "concerns_on_rails/models/monetizable"
 
 # Controller concerns
 require "concerns_on_rails/controllers/paginatable"
@@ -40,6 +44,7 @@ require "concerns_on_rails/controllers/respondable"
 require "concerns_on_rails/controllers/error_handleable"
 require "concerns_on_rails/controllers/includable"
 require "concerns_on_rails/controllers/secure_headable"
+require "concerns_on_rails/controllers/localizable"
 
 # Backwards compatibility (top-level aliases for pre-1.6 module paths)
 require "concerns_on_rails/legacy_aliases"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concerns_on_rails
 version: !ruby/object:Gem::Version
-  version: 1.12.1
+  version: 1.13.0
 platform: ruby
 authors:
 - Ethan Nguyen
@@ -73,6 +73,7 @@ files:
 - lib/concerns_on_rails/controllers/error_handleable.rb
 - lib/concerns_on_rails/controllers/filterable.rb
 - lib/concerns_on_rails/controllers/includable.rb
+- lib/concerns_on_rails/controllers/localizable.rb
 - lib/concerns_on_rails/controllers/paginatable.rb
 - lib/concerns_on_rails/controllers/respondable.rb
 - lib/concerns_on_rails/controllers/secure_headable.rb
@@ -82,6 +83,8 @@ files:
 - lib/concerns_on_rails/models/addressable.rb
 - lib/concerns_on_rails/models/expirable.rb
 - lib/concerns_on_rails/models/hashable.rb
+- lib/concerns_on_rails/models/maskable.rb
+- lib/concerns_on_rails/models/monetizable.rb
 - lib/concerns_on_rails/models/normalizable.rb
 - lib/concerns_on_rails/models/publishable.rb
 - lib/concerns_on_rails/models/sanitizable.rb
@@ -97,6 +100,8 @@ files:
 - lib/concerns_on_rails/support/address_data.rb
 - lib/concerns_on_rails/support/column_guard.rb
 - lib/concerns_on_rails/support/html_sanitizers.rb
+- lib/concerns_on_rails/support/masker.rb
+- lib/concerns_on_rails/support/money.rb
 - lib/concerns_on_rails/support/random_value.rb
 - lib/concerns_on_rails/support/sequence_calculator.rb
 - lib/concerns_on_rails/version.rb