attr_masker 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6c5ae88c368437043840351487b67c3d5a4e9a6
-  data.tar.gz: fca5c1719634945ba02cf3bbc5ba02ee3418816f
+  metadata.gz: 43cbbd6cf1150e2228d2b5fc1323bbdbae852510
+  data.tar.gz: 614372bc5a85ac8b23112062b437a8d468064160
 SHA512:
-  metadata.gz: 659120184ebe3048eda7bfbf459f394a167bdc4902eb1462f26d42918979a0a5b7174807145fd42a1bb0b3a32d51a68c5cd860e27b3fe4ede6fc8e7497fa36a1
-  data.tar.gz: 1c8f330415a6347dc6a7c0f719666f8dceca8d64cb139a2aef01c899fb9ae7602029a7f0e70677835cacf3117852ecba4be693170bb40c0cab375628542d1074
+  metadata.gz: cb815eda36c7a99d2cfebf18df5a1b901a5e597df340b6f2041bd9bdb6ee722b4fac5b21dde71457ad63794de5cc3e1aec2659c02d32c2aea6e0bce7dfff2b8c
+  data.tar.gz: 6e97866032f1d8c1323e11bb160f62d9798f001b2736b98be03907f9269f39ff462be45633ac3c59c04856621196fc8979556c1438cac3b6be5eff68f1f6c238

data/CHANGELOG.adoc

@@ -0,0 +1,15 @@
+== 0.1.1
+
+* Mask records disregarding default scope
+  (https://github.com/riboseinc/attr_masker/pull/41[#41])
+* Major refactoring (extracting `Attribute` and `Model` classes)
+* Code style improvements (nearly all violations fixed)
+
+== 0.1
+
+* First useful version
+* Rails 4 & 5 compatibility
+* Callable objects as maskers
+* Nice progress bar
+* Built-in maskers: `AttrMasker::Maskers::Replacing`
+  and `AttrMasker::Maskers::SIMPLE`

data/README.adoc

@@ -3,6 +3,7 @@
 :pygments-style: native
 :pygments-linenums-mode: inline
 
+image:https://img.shields.io/gem/v/attr_masker.svg["Gem Version", link="https://rubygems.org/gems/attr_masker"]
 image:https://img.shields.io/travis/riboseinc/attr_masker/master.svg["Build Status", link="https://travis-ci.org/riboseinc/attr_masker"]
 
 Mask ActiveRecord data with ease!
@@ -68,6 +69,11 @@ attr_masker :email :unless => ->(record) { ! record.tester_user? }
 attr_masker :first_name, :if => :tester_user?
 ----
 
+The ActiveRecord's `::default_scope` method has no effect on masking.  All
+table records are updated, provided that :if and :unless filters allow that.
+For example, if you're using a Paranoia[https://github.com/rubysherpas/paranoia]
+gem to soft-delete your data, records marked as deleted will be masked as well.
+
 === Using custom maskers
 
 By default, data is maksed with `AttrMasker::Maskers::SIMPLE` masker which

data/Rakefile

@@ -1,32 +1,5 @@
 # (c) 2017 Ribose Inc.
 #
 
-# require 'rake'
-# require 'rake/testtask'
-# require 'rake/rdoctask'
-
 require "bundler/gem_tasks"
 load "tasks/db.rake"
-
-# desc 'Generate documentation for the attr_masker gem.'
-# Rake::RDocTask.new(:rdoc) do |rdoc|
-#   rdoc.rdoc_dir = 'rdoc'
-#   rdoc.title    = 'attr_masker'
-#   rdoc.options << '--line-numbers' << '--inline-source'
-#   rdoc.rdoc_files.include('README*')
-#   rdoc.rdoc_files.include('lib/**/*.rb')
-# end
-#
-# if RUBY_VERSION < '1.9.3'
-#   require 'rcov/rcovtask'
-#
-#   task :rcov do
-#     system "rcov -o coverage/rcov --exclude '^(?!lib)' " + FileList[ 'test/**/*_test.rb' ].join(' ')
-#   end
-#
-#   desc 'Default: run unit tests under rcov.'
-#   task :default => :rcov
-# else
-#   desc 'Default: run unit tests.'
-#   task :default => :test
-# end

data/attr_masker.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |gem|
                           "of certain models by modifying the database."
 
   gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 

data/lib/attr_masker.rb

@@ -4,6 +4,8 @@
 # Adds attr_accessors that mask an object's attributes
 module AttrMasker
   autoload :Version, "attr_masker/version"
+  autoload :Attribute, "attr_masker/attribute"
+  autoload :Model, "attr_masker/model"
 
   autoload :Error, "attr_masker/error"
   autoload :Performer, "attr_masker/performer"
@@ -14,214 +16,6 @@ module AttrMasker
   end
 
   require "attr_masker/railtie" if defined?(Rails)
-  def self.extended(base) # :nodoc:
-    base.class_eval do
-
-      # Only include the dangerous instance methods during the Rake task!
-      include InstanceMethods
-      attr_writer :attr_masker_options
-      @attr_masker_options, @masker_attributes = {}, {}
-    end
-  end
-
-  # Generates attr_accessors that mask attributes transparently
-  #
-  # Options (any other options you specify are passed to the masker's mask
-  # methods)
-  #
-  #   :marshal          => If set to true, attributes will be marshaled as well as masker. This is useful if you're planning
-  #                        on masking something other than a string. Defaults to false unless you're using it with ActiveRecord
-  #                        or DataMapper.
-  #
-  #   :marshaler        => The object to use for marshaling. Defaults to Marshal.
-  #
-  #   :dump_method      => The dump method name to call on the <tt>:marshaler</tt> object to. Defaults to 'dump'.
-  #
-  #   :load_method      => The load method name to call on the <tt>:marshaler</tt> object. Defaults to 'load'.
-  #
-  #   :masker           => The object to use for masking. It must respond to +#mask+. Defaults to AttrMasker::Maskers::Simple.
-  #
-  #   :if               => Attributes are only masker if this option evaluates to true. If you pass a symbol representing an instance
-  #                        method then the result of the method will be evaluated. Any objects that respond to <tt>:call</tt> are evaluated as well.
-  #                        Defaults to true.
-  #
-  #   :unless           => Attributes are only masker if this option evaluates to false. If you pass a symbol representing an instance
-  #                        method then the result of the method will be evaluated. Any objects that respond to <tt>:call</tt> are evaluated as well.
-  #                        Defaults to false.
-  #
-  # You can specify your own default options
-  #
-  #   class User
-  #     # now all attributes will be encoded and marshaled by default
-  #     attr_masker_options.merge!(:marshal => true, :some_other_option => true)
-  #     attr_masker :configuration
-  #   end
-  #
-  #
-  # Example
-  #
-  #   class User
-  #     attr_masker :email, :credit_card
-  #     attr_masker :configuration, :marshal => true
-  #   end
-  #
-  #   @user = User.new
-  #   @user.masker_email # nil
-  #   @user.email? # false
-  #   @user.email = 'test@example.com'
-  #   @user.email? # true
-  #   @user.masker_email # returns the masker version of 'test@example.com'
-  #
-  #   @user.configuration = { :time_zone => 'UTC' }
-  #   @user.masker_configuration # returns the masker version of configuration
-  #
-  #   See README for more examples
-  def attr_masker(*attributes)
-    options = {
-      :if               => true,
-      :unless           => false,
-      :column_name      => nil,
-      :marshal          => false,
-      :marshaler        => Marshal,
-      :dump_method      => "dump",
-      :load_method      => "load",
-      :masker           => AttrMasker::Maskers::SIMPLE,
-    }.merge!(attr_masker_options).merge!(attributes.last.is_a?(Hash) ? attributes.pop : {})
-
-    attributes.each do |attribute|
-      masker_attributes[attribute.to_sym] = options.merge(attribute: attribute.to_sym)
-    end
-  end
-
-  # Default options to use with calls to <tt>attr_masker</tt>
-  # XXX:Keep
-  #
-  # It will inherit existing options from its superclass
-  def attr_masker_options
-    @attr_masker_options ||= superclass.attr_masker_options.dup
-  end
-
-  # Checks if an attribute is configured with <tt>attr_masker</tt>
-  # XXX:Keep
-  #
-  # Example
-  #
-  #   class User
-  #     attr_accessor :name
-  #     attr_masker :email
-  #   end
-  #
-  #   User.attr_masker?(:name)  # false
-  #   User.attr_masker?(:email) # true
-  def attr_masker?(attribute)
-    masker_attributes.has_key?(attribute.to_sym)
-  end
-
-  # masks a value for the attribute specified
-  # XXX:modify
-  #
-  # Example
-  #
-  #   class User
-  #     attr_masker :email
-  #   end
-  #
-  #   masker_email = User.mask(:email, 'test@example.com')
-  def mask(attribute, value, options = {})
-    options = masker_attributes[attribute.to_sym].merge(options)
-    # if options[:if] && !options[:unless] && !value.nil? && !(value.is_a?(String) && value.empty?)
-    if options[:if] && !options[:unless]
-      value = options[:marshal] ? options[:marshaler].send(options[:dump_method], value) : value.to_s
-      masker_value = options[:masker].call(options.merge!(value: value))
-      masker_value
-    else
-      value
-    end
-  end
-
-  # Contains a hash of masker attributes with virtual attribute names as keys
-  # and their corresponding options as values
-  # XXX:Keep
-  #
-  # Example
-  #
-  #   class User
-  #     attr_masker :email
-  #   end
-  #
-  #   User.masker_attributes # { :email => { :attribute => 'masker_email' } }
-  def masker_attributes
-    @masker_attributes ||= superclass.masker_attributes.dup
-  end
-
-  # Forwards calls to :mask_#{attribute} to the corresponding mask method
-  # if attribute was configured with attr_masker
-  #
-  # Example
-  #
-  #   class User
-  #     attr_masker :email
-  #   end
-  #
-  #   User.mask_email('SOME_masker_EMAIL_STRING')
-  def method_missing(method, *arguments, &block)
-    if method.to_s =~ /^mask_(.+)$/ && attr_masker?($1)
-      send(:mask, $1, *arguments)
-    else
-      super
-    end
-  end
-
-  module InstanceMethods
-
-    # masks a value for the attribute specified using options evaluated in the current object's scope
-    #
-    # Example
-    #
-    #  class User
-    #    attr_accessor :secret_key
-    #    attr_masker :email
-    #
-    #    def initialize(secret_key)
-    #      self.secret_key = secret_key
-    #    end
-    #  end
-    #
-    #  @user = User.new('some-secret-key')
-    #  @user.mask(:email, 'test@example.com')
-    def mask(attribute, value=nil)
-      value = self.send(attribute) if value.nil?
-      self.class.mask(attribute, value, evaluated_attr_masker_options_for(attribute))
-    end
-
-    protected
-
-      # Returns attr_masker options evaluated in the current object's scope for the attribute specified
-      # XXX:Keep
-      def evaluated_attr_masker_options_for(attribute)
-        self.class.masker_attributes[attribute.to_sym].inject({}) do |hash, (option, value)|
-          if %i[if unless].include?(option)
-            hash.merge!(option => evaluate_attr_masker_option(value))
-          else
-            hash.merge!(option => value)
-          end
-        end
-      end
-
-      # Evaluates symbol (method reference) or proc (responds to call) options
-      # XXX:Keep
-      #
-      # If the option is not a symbol or proc then the original option is returned
-      def evaluate_attr_masker_option(option)
-        if option.is_a?(Symbol) && respond_to?(option)
-          send(option)
-        elsif option.respond_to?(:call)
-          option.call(self)
-        else
-          option
-        end
-      end
-  end
 end
 
-Object.extend AttrMasker
+Object.extend AttrMasker::Model

data/lib/attr_masker/attribute.rb

@@ -0,0 +1,70 @@
+# (c) 2017 Ribose Inc.
+#
+
+module AttrMasker
+  # Holds the definition of maskable attribute.
+  class Attribute
+    attr_reader :name, :model, :options
+
+    def initialize(name, model, options)
+      @name = name.to_sym
+      @model = model
+      @options = options
+    end
+
+    # Evaluates the +:if+ and +:unless+ attribute options on given instance.
+    # Returns +true+ or +fasle+, depending on whether the attribute should be
+    # masked for this object or not.
+    def should_mask?(model_instance)
+      not (
+        options.key?(:if) && !evaluate_option(:if, model_instance) ||
+        options.key?(:unless) && evaluate_option(:unless, model_instance)
+      )
+    end
+
+    # Mask the attribute on given model.  Masking will be performed regardless
+    # of +:if+ and +:unless+ options.  A +should_mask?+ method should be called
+    # separately to ensure that given object is eligible for masking.
+    #
+    # The method returns the masked value but does not modify the object's
+    # attribute.
+    #
+    # If +marshal+ attribute's option is +true+, the attribute value will be
+    # loaded before masking, and dumped to proper storage format prior
+    # returning.
+    def mask(model_instance)
+      value = unmarshal_data(model_instance.send(name))
+      masker_value = options[:masker].call(options.merge!(value: value))
+      marshal_data(masker_value)
+    end
+
+    # Evaluates option (typically +:if+ or +:unless+) on given model instance.
+    # That option can be either a proc (a model is passed as an only argument),
+    # or a symbol (a method of that name is called on model instance).
+    def evaluate_option(option_name, model_instance)
+      option = options[option_name]
+
+      if option.is_a?(Symbol)
+        model_instance.send(option)
+      elsif option.respond_to?(:call)
+        option.call(model_instance)
+      else
+        option
+      end
+    end
+
+    def marshal_data(data)
+      return data unless options[:marshal]
+      options[:marshaler].send(options[:dump_method], data)
+    end
+
+    def unmarshal_data(data)
+      return data unless options[:marshal]
+      options[:marshaler].send(options[:load_method], data)
+    end
+
+    def column_name
+      options[:column_name] || name
+    end
+  end
+end

data/lib/attr_masker/model.rb

@@ -0,0 +1,137 @@
+module AttrMasker
+  module Model
+    def self.extended(base) # :nodoc:
+      base.class_eval do
+        attr_writer :attr_masker_options
+        @attr_masker_options = {}
+        @masker_attributes = {}
+      end
+    end
+
+    # Generates attr_accessors that mask attributes transparently
+    #
+    # Options (any other options you specify are passed to the masker's mask
+    # methods)
+    #
+    # [:masker]
+    #     The object to use for masking. It must respond to +#mask+. Defaults to
+    #     AttrMasker::Maskers::Simple.
+    #
+    # [:if]
+    #     Attributes are only masker if this option evaluates to true. If you
+    #     pass a symbol representing an instance method then the result of
+    #     the method will be evaluated. Any objects that respond to
+    #     <tt>:call</tt> are evaluated as well.  Defaults to true.
+    #
+    # [:unless]
+    #     Attributes are only masker if this option evaluates to false. If you
+    #     pass a symbol representing an instance method then the result of
+    #     the method will be evaluated. Any objects that respond to
+    #     <tt>:call</tt> are evaluated as well.  Defaults to false.
+    #
+    # [:marshal]
+    #     If set to true, attributes will be marshaled as well as masker. This
+    #     is useful if you're planning on masking something other than a string.
+    #     Defaults to false unless you're using it with ActiveRecord or
+    #     DataMapper.
+    #
+    # [:marshaler]
+    #     The object to use for marshaling. Defaults to Marshal.
+    #
+    # [:dump_method]
+    #     The dump method name to call on the <tt>:marshaler</tt> object to.
+    #     Defaults to 'dump'.
+    #
+    # [:load_method]
+    #     The load method name to call on the <tt>:marshaler</tt> object.
+    #     Defaults to 'load'.
+    #
+    # You can specify your own default options
+    #
+    #   class User
+    #     # now all attributes will be encoded and marshaled by default
+    #     attr_masker_options.merge!(:marshal => true, :another_option => true)
+    #     attr_masker :configuration
+    #   end
+    #
+    #
+    # Example
+    #
+    #   class User
+    #     attr_masker :email, :credit_card
+    #     attr_masker :configuration, :marshal => true
+    #   end
+    #
+    #   @user = User.new
+    #   @user.masker_email # nil
+    #   @user.email? # false
+    #   @user.email = 'test@example.com'
+    #   @user.email? # true
+    #   @user.masker_email # returns the masker version of 'test@example.com'
+    #
+    #   @user.configuration = { :time_zone => 'UTC' }
+    #   @user.masker_configuration # returns the masker version of configuration
+    #
+    #   See README for more examples
+    def attr_masker(*args)
+      default_options = {
+        if: true,
+        unless: false,
+        column_name: nil,
+        marshal: false,
+        marshaler: Marshal,
+        dump_method: "dump",
+        load_method: "load",
+        masker: AttrMasker::Maskers::SIMPLE,
+      }
+
+      options = args.extract_options!.
+        reverse_merge(attr_masker_options).
+        reverse_merge(default_options)
+
+      args.each do |attribute_name|
+        attribute = Attribute.new(attribute_name, self, options)
+        masker_attributes[attribute.name] = attribute
+      end
+    end
+
+    # Default options to use with calls to <tt>attr_masker</tt>
+    # XXX:Keep
+    #
+    # It will inherit existing options from its superclass
+    def attr_masker_options
+      @attr_masker_options ||= superclass.attr_masker_options.dup
+    end
+
+    # Checks if an attribute is configured with <tt>attr_masker</tt>
+    # XXX:Keep
+    #
+    # Example
+    #
+    #   class User
+    #     attr_accessor :name
+    #     attr_masker :email
+    #   end
+    #
+    #   User.attr_masker?(:name)  # false
+    #   User.attr_masker?(:email) # true
+    def attr_masker?(attribute)
+      masker_attributes.has_key?(attribute.to_sym)
+    end
+
+    # Contains a hash of masker attributes with virtual attribute names as keys
+    # and their corresponding options as values
+    # XXX:Keep
+    #
+    # Example
+    #
+    #   class User
+    #     attr_masker :email
+    #   end
+    #
+    #   User.masker_attributes # { :email => { :attribute => 'masker_email' } }
+    def masker_attributes
+      @masker_attributes ||= superclass.masker_attributes.dup
+    end
+  end
+end

data/lib/attr_masker/performer.rb

@@ -24,7 +24,7 @@ module AttrMasker
 
       def mask_class(klass)
         progressbar_for_model(klass) do |bar|
-          klass.all.each do |model|
+          klass.all.unscoped.each do |model|
             mask_object model
             bar.increment
           end
@@ -36,20 +36,21 @@ module AttrMasker
       def mask_object(instance)
         klass = instance.class
 
-        updates = klass.masker_attributes.reduce({}) do |acc, masker_attr|
-          attr_name = masker_attr[0]
-          column_name = masker_attr[1][:column_name] || attr_name
-          masker_value = instance.mask(attr_name)
+        updates = klass.masker_attributes.values.reduce({}) do |acc, attribute|
+          next acc unless attribute.should_mask?(instance)
+
+          column_name = attribute.column_name
+          masker_value = attribute.mask(instance)
           acc.merge!(column_name => masker_value)
         end
 
-        klass.all.update(instance.id, updates)
+        klass.all.unscoped.update(instance.id, updates)
       end
 
       def progressbar_for_model(klass)
         bar = ProgressBar.create(
           title: klass.name,
-          total: klass.count,
+          total: klass.unscoped.count,
           throttle_rate: 0.1,
           format: %q[%t %c/%C (%j%%) %B %E],
         )

data/lib/attr_masker/version.rb

@@ -6,7 +6,7 @@ module AttrMasker
   module Version
     MAJOR = 0
     MINOR = 1
-    PATCH = 0
+    PATCH = 1
 
     # Returns a version string by joining <tt>MAJOR</tt>, <tt>MINOR</tt>, and
     # <tt>PATCH</tt> with <tt>'.'</tt>

data/spec/dummy/db/schema.rb

@@ -3,6 +3,7 @@ ActiveRecord::Schema.define do
     t.string :first_name
     t.string :last_name
     t.string :email
+    t.text :avatar
     t.timestamps null: false
   end
 end

data/spec/features_spec.rb

@@ -28,6 +28,7 @@ RSpec.describe "Attr Masker gem", :suppress_progressbar do
       first_name: "Han",
       last_name: "Solo",
       email: "han@example.test",
+      avatar: Marshal.dump("Millenium Falcon photo"),
     )
   end
 
@@ -36,6 +37,7 @@ RSpec.describe "Attr Masker gem", :suppress_progressbar do
       first_name: "Luke",
       last_name: "Skywalker",
       email: "luke@jedi.example.test",
+      avatar: Marshal.dump("photo with a light saber"),
     )
   end
 
@@ -180,6 +182,76 @@ RSpec.describe "Attr Masker gem", :suppress_progressbar do
     )
   end
 
+  example "Masking a marshalled attribute" do
+    User.class_eval do
+      attr_masker :avatar, marshal: true
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      preserve { han.first_name } &
+      preserve { han.last_name } &
+      preserve { han.email } &
+      change { han.avatar }
+    )
+
+    expect(han.avatar).to eq(Marshal.dump("(redacted)"))
+
+    expect { luke.reload }.to(
+      preserve { luke.first_name } &
+      preserve { luke.last_name } &
+      preserve { luke.email } &
+      change { luke.avatar }
+    )
+
+    expect(luke.avatar).to eq(Marshal.dump("(redacted)"))
+  end
+
+  example "Masking a marshalled attribute with a custom marshaller" do
+    module CustomMarshal
+      module_function
+
+      def load_marshalled(*args)
+        Marshal.load(*args) # rubocop:disable Security/MarshalLoad
+      end
+
+      def dump_json(*args)
+        JSON.dump(json: args)
+      end
+    end
+
+    User.class_eval do
+      attr_masker(
+        :avatar,
+        marshal: true,
+        marshaler: CustomMarshal,
+        load_method: :load_marshalled,
+        dump_method: :dump_json,
+      )
+    end
+
+    expect { run_rake_task }.not_to(change { User.count })
+
+    expect { han.reload }.to(
+      preserve { han.first_name } &
+      preserve { han.last_name } &
+      preserve { han.email } &
+      change { han.avatar }
+    )
+
+    expect(han.avatar).to eq({ json: ["(redacted)"] }.to_json)
+
+    expect { luke.reload }.to(
+      preserve { luke.first_name } &
+      preserve { luke.last_name } &
+      preserve { luke.email } &
+      change { luke.avatar }
+    )
+
+    expect(luke.avatar).to eq({ json: ["(redacted)"] }.to_json)
+  end
+
   example "It is disabled in production environment" do
     allow(Rails).to receive(:env) { "production".inquiry }
 
@@ -197,6 +269,22 @@ RSpec.describe "Attr Masker gem", :suppress_progressbar do
     end
   end
 
+  example "It masks records disregarding default scope" do
+    User.class_eval do
+      attr_masker :last_name
+
+      default_scope ->() { where(last_name: "Solo") }
+    end
+
+    expect { run_rake_task }.not_to(change { User.unscoped.count })
+
+    [han, luke].each do |record|
+      expect { record.reload }.to(
+        change { record.last_name }.to("(redacted)")
+      )
+    end
+  end
+
   def run_rake_task
     Rake::Task["db:mask"].execute
   end

data/spec/unit/attribute_spec.rb

@@ -0,0 +1,128 @@
+# (c) 2017 Ribose Inc.
+#
+
+require "spec_helper"
+
+RSpec.describe AttrMasker::Attribute do
+  describe "::new" do
+    subject { described_class.method :new }
+
+    it "instantiates a new attribute definition" do
+      opts = { arbitrary: :options }
+      retval = subject.call(:some_attr, :some_model, opts)
+      expect(retval.name).to eq(:some_attr)
+      expect(retval.model).to eq(:some_model)
+      expect(retval.options).to eq(opts)
+    end
+  end
+
+  describe "#column_name" do
+    subject { receiver.method :column_name }
+    let(:receiver) { described_class.new :some_attr, :some_model, options }
+    let(:options) { {} }
+
+    it "defaults to attribute name" do
+      expect(subject.call).to eq(:some_attr)
+    end
+
+    it "can be overriden with :column_name option" do
+      options[:column_name] = :some_column
+      expect(subject.call).to eq(:some_column)
+    end
+  end
+
+  describe "#should_mask?" do
+    subject { described_class.instance_method :should_mask? }
+
+    let(:model_instance) { double }
+    let(:truthy) { double call: true }
+    let(:falsey) { double call: false }
+
+    example { expect(retval_for_opts({})).to be(true) }
+    example { expect(retval_for_opts(if: truthy)).to be(true) }
+    example { expect(retval_for_opts(if: falsey)).to be(false) }
+    example { expect(retval_for_opts(unless: truthy)).to be(false) }
+    example { expect(retval_for_opts(unless: falsey)).to be(true) }
+    example { expect(retval_for_opts(if: truthy, unless: truthy)).to be(false) }
+    example { expect(retval_for_opts(if: truthy, unless: falsey)).to be(true) }
+    example { expect(retval_for_opts(if: falsey, unless: truthy)).to be(false) }
+    example { expect(retval_for_opts(if: falsey, unless: falsey)).to be(false) }
+
+    def retval_for_opts(opts)
+      receiver = described_class.new(:some_attr, :some_model, opts)
+      callable = subject.bind(receiver)
+      callable.(model_instance)
+    end
+  end
+
+  describe "#evaluate_option" do
+    subject { receiver.method :evaluate_option }
+    let(:receiver) { described_class.new :some_attr, model_instance, options }
+    let(:options) { {} }
+    let(:model_instance) { double }
+    let(:retval) { subject.call(:option_name, model_instance) }
+
+    context "when that option value is a symbol" do
+      let(:options) { { option_name: :meth } }
+
+      before do
+        allow(model_instance).to receive(:meth).with(no_args).and_return(:rv)
+      end
+
+      it "evaluates an object's method pointed by that symbol" do
+        expect(retval).to be(:rv)
+      end
+    end
+
+    context "when that option_nameion value responds to #call" do
+      let(:options) { { option_name: callable } }
+      let(:callable) { double }
+
+      before do
+        allow(callable).to receive(:call).with(model_instance).and_return(:rv)
+      end
+
+      it "calls #call on it passing model instance as the only argument" do
+        expect(retval).to be(:rv)
+      end
+    end
+  end
+
+  describe "#marshal_data" do
+    subject { receiver.method :marshal_data }
+    let(:receiver) { described_class.new :some_attr, model_instance, options }
+    let(:options) { { marshaler: marshaller, dump_method: :dump_m } }
+    let(:marshaller) { double }
+    let(:model_instance) { double }
+
+    it "returns unmodified argument when marshal option is falsey" do
+      options[:marshal] = false
+      expect(subject.call(:data)).to be(:data)
+    end
+
+    it "returns unmodified argument when marshal option is falsey" do
+      options[:marshal] = true
+      expect(marshaller).to receive(:dump_m).with(:data).and_return(:retval)
+      expect(subject.call(:data)).to be(:retval)
+    end
+  end
+
+  describe "#unmarshal_data" do
+    subject { receiver.method :unmarshal_data }
+    let(:receiver) { described_class.new :some_attr, model_instance, options }
+    let(:options) { { marshaler: marshaller, load_method: :load_m } }
+    let(:marshaller) { double }
+    let(:model_instance) { double }
+
+    it "returns unmodified argument when marshal option is falsey" do
+      options[:marshal] = false
+      expect(subject.call(:data)).to be(:data)
+    end
+
+    it "returns unmodified argument when marshal option is falsey" do
+      options[:marshal] = true
+      expect(marshaller).to receive(:load_m).with(:data).and_return(:retval)
+      expect(subject.call(:data)).to be(:retval)
+    end
+  end
+end

data/spec/unit/model_spec.rb

@@ -0,0 +1,12 @@
+# (c) 2017 Ribose Inc.
+#
+
+require "spec_helper"
+
+RSpec.describe AttrMasker::Model do
+  it "extends every class and provides class methods" do
+    c = Class.new
+    expect(c).to respond_to(:attr_masker)
+    expect(c.singleton_class.included_modules).to include(described_class)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attr_masker
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-02 00:00:00.000000000 Z
+date: 2017-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -156,6 +156,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.adoc
 - Gemfile
 - LICENSE
 - README.adoc
@@ -169,9 +170,11 @@ files:
 - gemfiles/Rails-5.1.gemfile
 - gemfiles/Rails-head.gemfile
 - lib/attr_masker.rb
+- lib/attr_masker/attribute.rb
 - lib/attr_masker/error.rb
 - lib/attr_masker/maskers/replacing.rb
 - lib/attr_masker/maskers/simple.rb
+- lib/attr_masker/model.rb
 - lib/attr_masker/performer.rb
 - lib/attr_masker/railtie.rb
 - lib/attr_masker/version.rb
@@ -181,14 +184,16 @@ files:
 - spec/dummy/db/schema.rb
 - spec/dummy/public/favicon.ico
 - spec/features_spec.rb
-- spec/maskers/replacing_spec.rb
-- spec/maskers/simple_spec.rb
 - spec/spec_helper.rb
 - spec/support/0_combustion.rb
 - spec/support/db_cleaner.rb
 - spec/support/matchers.rb
 - spec/support/rake.rb
 - spec/support/silence_stdout.rb
+- spec/unit/attribute_spec.rb
+- spec/unit/maskers/replacing_spec.rb
+- spec/unit/maskers/simple_spec.rb
+- spec/unit/model_spec.rb
 homepage: https://github.com/riboseinc/attr_masker
 licenses:
 - MIT
@@ -219,11 +224,13 @@ test_files:
 - spec/dummy/db/schema.rb
 - spec/dummy/public/favicon.ico
 - spec/features_spec.rb
-- spec/maskers/replacing_spec.rb
-- spec/maskers/simple_spec.rb
 - spec/spec_helper.rb
 - spec/support/0_combustion.rb
 - spec/support/db_cleaner.rb
 - spec/support/matchers.rb
 - spec/support/rake.rb
 - spec/support/silence_stdout.rb
+- spec/unit/attribute_spec.rb
+- spec/unit/maskers/replacing_spec.rb
+- spec/unit/maskers/simple_spec.rb
+- spec/unit/model_spec.rb