concealer 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# Specify your gem's dependencies in concealer.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 flinc AG
+
+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.rdoc

@@ -0,0 +1,148 @@
+= concealer
+
+Privacy control your models (or any other Ruby object) with ease.
+
+== Requirements
+
+* activesupport (~> 3.0)
+
+
+== Install
+
+To install concealer, simply add it to your Gemfile:
+
+  gem 'concealer'
+
+In order to get the latest development version of concealer:
+
+  gem 'concealer', :git => 'git://github.com/flinc/concealer'
+
+Finally run:
+
+  bundle install
+
+
+== Usage
+
+To use concealer simply include the Concealer module:
+
+  class User
+    include Concealer
+
+    attr_accessor :name, :email
+  end
+
+This will add a #concealed method to your object. Calling this will return a proxy object that checks every call and only forwards allowed ones to the original object.
+
+  user = User.new
+  user.concealed.name # => user.name
+  user.concealed.email # => user.email
+
+=== Strategies
+
+The default strategy for Concealer is Concealer::Strategy::Allow which forwards every call to the original object. At the moment there are several other strategies available:
+
+* Concealer::Strategy::Allow
+* Concealer::Strategy::Deny
+* Concealer::Strategy::Whitelist
+* Concealer::Strategy::Blacklist
+
+You can set the strategy for Concealer using <tt>Concealer.strategy=</tt>
+
+  Concealer.strategy = Concealer::Strategy::Deny.new
+
+  user = User.new
+  user.concealed.name # => nil
+  user.concealed.email # => nil
+
+=== Advanced Strategies
+
+There is one more advanced privacy strategies available: <tt>Concealer::Strategy::MultiLevel</tt>.
+To use it you'll have to implement your own subclass of it to match your domain model. The example below illustrates what it might look like.
+
+Your custom multi level privacy strategy:
+
+  class CustomPrivacyStrategy < Concealer::Strategy::MultiLevel
+
+    def required_level_for(model, name, args)
+      case model
+        when Profile, User:
+          return privacy_level_for(owner_of(model), :name) if [:firstname, :lastname].include?(name.to_sym)
+          return privacy_level_for(owner_of(model), :age)  if [:age].include?(name.to_sym)
+      end
+
+      :myself
+    end
+
+    protected
+
+    def privacy_level_for(user, key)
+      user.privacy_settings.send(key).try(:to_sym)
+    end
+  end
+
+
+Your User model:
+
+  class User
+
+    # ...
+
+    def relation_level_to(other)
+      if other == self
+        :myself
+      elsif self.friend_of?(other)
+        :friends
+      else
+        :everyone
+      end
+    end
+  end
+
+In your Rails ApplicationController:
+
+  around_filter :setup_privacy_strategy
+
+  def setup_privacy_strategy(&block)
+    Concealer.with_strategy(CustomPrivacyStrategy.new(current_user, [:myself, :friends, :everyone]), &block)
+  end
+
+
+=== Implementing Strategies
+
+You can implement your own strategies by subclassing Concealer::Strategy or adding an <tt>#allow?(model, attribute, args)</tt> method to any object you pass into <tt>Concealer.strategy=</tt>.
+
+
+=== Fallbacks
+
+In some cases you don't want to just return nil for unallowed method calls. In order to provide sensible return values Concealer has a fallbacks. Available fallbacks are:
+
+* Concealer::Fallback::Nil
+* Concealer::Fallback::String
+* Concealer::Fallback::Paperclip
+
+You can add fallbacks for method calls like this:
+
+  Concealer.register_fallback(User, :email, Concealer::Fallback::String.new("unkown"))
+  Concealer.register_fallback(User, :avatar, Concealer::Fallback::Paperclip.new)
+  Concealer.register_fallback(User, :name, lambda { |model, method, args| "#{model.send(method).at(0)}." })
+
+
+== Known issues
+
+See https://github.com/flinc/concealer/issues
+
+
+== Repository
+
+See https://github.com/flinc/concealer and feel free to fork it!
+
+
+== Contributors
+
+See a list of all contributors at https://github.com/flinc/concealer/contributors. Thanks a lot everyone!
+
+
+== Copyright
+
+Copyright (c) 2011 flinc AG. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'bundler/setup'
+
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/concealer.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "concealer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "concealer"
+  s.version     = Concealer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Benedikt Deicke", "Christian Bäuerlein"]
+  s.email       = ["benedikt@synatic.net", "fabrik42@gmail.com"]
+  s.homepage    = "https://flinc.github.com/concealer"
+  s.summary     = %q{Privacy control your models with ease}
+  s.description = %q{Privacy control your models with ease}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency('activesupport', ['~> 3.0'])
+
+  s.add_development_dependency('rspec', ['~> 2.3'])
+  s.add_development_dependency('rake')
+end

data/lib/concealer/fallback/nil.rb

@@ -0,0 +1,5 @@
+class Concealer::Fallback::Nil
+  def call(model, method, args)
+    nil
+  end
+end

data/lib/concealer/fallback/paperclip.rb

@@ -0,0 +1,5 @@
+class Concealer::Fallback::Paperclip
+  def call(model, method, args)
+    ::Paperclip::Attachment.new(method, model.class.new, model.class.attachment_definitions[method])
+  end
+end

data/lib/concealer/fallback/string.rb

@@ -0,0 +1,10 @@
+class Concealer::Fallback::String
+
+  def initialize(value = "")
+    @value = value
+  end
+
+  def call(model, method, args)
+    @value
+  end
+end

data/lib/concealer/fallback.rb

@@ -0,0 +1,12 @@
+module Concealer
+  class Fallback
+
+    autoload :Nil,          'concealer/fallback/nil'
+    autoload :String,  'concealer/fallback/string'
+    autoload :Paperclip,    'concealer/fallback/paperclip'
+
+    def call(model, method, args)
+      raise "The fallback must implement #call(model, method, args)"
+    end
+  end
+end

data/lib/concealer/proxy.rb

@@ -0,0 +1,20 @@
+module Concealer
+  class Proxy
+    instance_methods.each { |m| undef_method(m) unless m =~ /(^__|^send$|^object_id$)/ }
+
+    def initialize(target, strategy)
+      @target = target
+      @strategy = strategy
+    end
+
+    protected
+
+    def method_missing(name, *args, &block)
+      if @strategy.allow?(@target, name, args)
+        @target.send(name, *args, &block)
+      else
+        Concealer.fallback_for(@target, name).call(@target, name, args)
+      end
+    end
+  end
+end

data/lib/concealer/strategy/allow.rb

@@ -0,0 +1,5 @@
+class Concealer::Strategy::Allow < Concealer::Strategy
+  def allow?(model, method, args)
+    true
+  end
+end

data/lib/concealer/strategy/blacklist.rb

@@ -0,0 +1,17 @@
+class Concealer::Strategy::Blacklist < Concealer::Strategy::Allow
+
+  def initialize(blacklist)
+    @blacklist = blacklist
+  end
+
+  def allow?(model, method, args)
+    return false if blacklisted_methods(model).include?(method)
+    super
+  end
+
+  private
+
+  def blacklisted_methods(model)
+    @blacklist[model.class] ||= []
+  end
+end

data/lib/concealer/strategy/deny.rb

@@ -0,0 +1,5 @@
+class Concealer::Strategy::Deny < Concealer::Strategy
+  def allow?(model, method, args)
+    false
+  end
+end

data/lib/concealer/strategy/multi_level.rb

@@ -0,0 +1,38 @@
+class Concealer::Strategy::MultiLevel < Concealer::Strategy
+
+  def initialize(current_user, levels)
+    @current_user = current_user
+    @levels = levels
+  end
+
+  def allow?(model, method, args)
+    required_level = required_level_for(model, method, args)
+    actual_level = @current_user.relation_level_to(owner_of(model))
+
+    raise "The level #{required_level} is not valid." unless @levels.include?(required_level)
+    raise "The level #{actual_level} is not valid."   unless @levels.include?(actual_level)
+
+    return @levels.index(actual_level) <= @levels.index(required_level)
+  end
+
+  protected
+
+  def current_user
+    @current_user
+  end
+
+  def required_level_for(model, method, args)
+    @levels.first
+  end
+
+  def owner_of(model)
+    if model.respond_to?(:relation_level_to)
+      model
+    elsif model.respond_to?(:user)
+      model.user
+    else
+      nil
+    end
+  end
+
+end

data/lib/concealer/strategy/whitelist.rb

@@ -0,0 +1,17 @@
+class Concealer::Strategy::Whitelist < Concealer::Strategy::Deny
+
+  def initialize(whitelist)
+    @whitelist = whitelist
+  end
+
+  def allow?(model, method, args)
+    return true if whitelisted_methods(model).include?(method)
+    super
+  end
+
+  private
+
+  def whitelisted_methods(model)
+    @whitelist[model.class] ||= []
+  end
+end

data/lib/concealer/strategy.rb

@@ -0,0 +1,14 @@
+module Concealer
+  class Strategy
+
+    autoload :Allow,      'concealer/strategy/allow'
+    autoload :Deny,       'concealer/strategy/deny'
+    autoload :Blacklist,  'concealer/strategy/blacklist'
+    autoload :Whitelist,  'concealer/strategy/whitelist'
+    autoload :MultiLevel, 'concealer/strategy/multi_level'
+
+    def allow?(model, method, args)
+      raise "The stragegy must implement #allow?(model, method, args)"
+    end
+  end
+end

data/lib/concealer/version.rb

@@ -0,0 +1,3 @@
+module Concealer
+  VERSION = "0.0.1"
+end

data/lib/concealer.rb

@@ -0,0 +1,43 @@
+require 'active_support/concern'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module Concealer
+  extend ActiveSupport::Concern
+
+  autoload :Proxy,    'concealer/proxy'
+  autoload :Strategy, 'concealer/strategy'
+  autoload :Fallback, 'concealer/fallback'
+
+  mattr_accessor :default_fallback
+  @@default_fallback = Concealer::Fallback::Nil.new
+
+  def self.strategy=(strategy)
+    Thread.current[:concealer_strategy] = strategy
+  end
+
+  def self.strategy
+    Thread.current[:concealer_strategy] || Concealer::Strategy::Allow.new
+  end
+
+  def self.with_strategy(strategy)
+    save, self.strategy = self.strategy, strategy
+    yield
+    self.strategy = save
+  end
+
+  def self.register_fallback(model, method, fallback)
+    @@fallbacks ||= {}
+    @@fallbacks[model.to_s.to_sym] ||= {}
+    @@fallbacks[model.to_s.to_sym][method] = fallback
+  end
+
+  def self.fallback_for(model, method)
+    @@fallbacks ||= {}
+    @@fallbacks.try(:[], model.class.to_s.to_sym).try(:[], method.to_sym) || @@default_fallback
+  end
+
+  def concealed
+    Proxy.new(self, Concealer.strategy)
+  end
+end

data/spec/concealer/fallback/nil_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Concealer::Fallback::Nil do
+  describe '#call' do
+    it "should return nil" do
+      subject.call(nil, nil, nil).should be_nil
+    end
+  end
+end

data/spec/concealer/fallback/paperclip_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Concealer::Fallback::Paperclip do
+  describe '#call' do
+    it "should return a paperclip attachment" do
+      ConcealedModel.stub!(:attachment_definitions).and_return({ :avatar => :something })
+      Paperclip::Attachment.should_receive(:new).with(:avatar, anything, :something).and_return(:paperclip)
+      subject.call(ConcealedModel.new, :avatar, nil).should eq(:paperclip)
+    end
+  end
+end

data/spec/concealer/fallback/string_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Concealer::Fallback::String do
+  describe '#call' do
+    it "should return an empty string" do
+      subject.call(nil, nil, nil).should eq("")
+    end
+  end
+end

data/spec/concealer/fallback_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Concealer::Fallback do
+  describe '#call' do
+    it "should raise an exception when called directly" do
+      expect { subject.call(nil, nil, nil) }.to raise_error /must implement/
+    end
+  end
+end

data/spec/concealer/proxy_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Concealer::Proxy do
+
+  let(:model) { ConcealedModel.new }
+  let(:strategy) { Concealer::Strategy::Allow.new }
+  subject { Concealer::Proxy.new(model, strategy) }
+
+  describe "#initializer" do
+    it "should require a target and a strategy" do
+      expect { Concealer::Proxy.new }.to raise_error ArgumentError
+    end
+
+    it "should accept a target object and a strategy" do
+      expect { Concealer::Proxy.new(model, Concealer.strategy) }.to_not raise_error ArgumentError
+    end
+  end
+
+  it "should delegate all unknown method calls to the target" do
+    model.should_receive(:allowed_method)
+    subject.allowed_method
+  end
+
+  it "should ask the strategy whether the method is allowed for the object" do
+    strategy.should_receive(:allow?).with(model, :allowed_method, [:args])
+    subject.allowed_method(:args)
+  end
+
+  it "should return the fallback for unallowed methods" do
+    strategy.stub!(:allow?).and_return(false)
+
+    fallback = mock(Concealer::Fallback, :call => :fallback)
+    Concealer.stub!(:fallback_for).and_return(fallback)
+
+    subject.allowed_method.should eq(:fallback)
+  end
+end

data/spec/concealer/strategy/allow_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Concealer::Strategy::Allow do
+  it "should allow everything" do
+    subject.allow?(nil, nil, nil).should be_true
+  end
+end

data/spec/concealer/strategy/blacklist_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Concealer::Strategy::Blacklist do
+
+  subject { Concealer::Strategy::Blacklist.new({ ConcealedModel => [:denied_method] }) }
+
+  it "should allow unlisted methods" do
+    subject.allow?(ConcealedModel.new, :some_method, nil).should be_true
+  end
+
+  it "should allow unlisted methods" do
+    subject.allow?(ConcealedModel.new, :denied_method, nil).should be_false
+  end
+
+end

data/spec/concealer/strategy/deny_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Concealer::Strategy::Deny do
+  it "should deny everything" do
+    subject.allow?(nil, nil, nil).should be_false
+  end
+end

data/spec/concealer/strategy/multi_level_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Concealer::Strategy::MultiLevel do
+
+  let(:levels) { [:myself, :friends, :friends_of_friends, :everyone] }
+
+  let(:current_user) { User.new("benedikt") }
+  let(:other_user) { User.new("christian") }
+
+  subject { Concealer::Strategy::MultiLevel.new(current_user, levels) }
+
+  context 'required level higher than actual level' do
+    before(:each) do
+      subject.stub!(:required_level_for).and_return(:myself)
+    end
+
+    it "should deny the call" do
+      subject.allow?(other_user, :name, nil).should be_false
+    end
+  end
+
+  context 'required level lower than actual level' do
+    before(:each) do
+      subject.stub!(:required_level_for).and_return(:friends_of_friends)
+    end
+
+    it "should allow the call" do
+      subject.allow?(other_user, :name, nil).should be_true
+    end
+  end
+
+  context 'required level equals actual level' do
+    before(:each) do
+      subject.stub!(:required_level_for).and_return(:friends)
+    end
+
+    it "should allow the call" do
+      subject.allow?(other_user, :name, nil).should be_true
+    end
+  end
+end

data/spec/concealer/strategy/whitelist_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Concealer::Strategy::Whitelist do
+
+  subject { Concealer::Strategy::Whitelist.new({ ConcealedModel => [:allowed_method] }) }
+
+  it "should deny unlisted methods" do
+    subject.allow?(ConcealedModel.new, :some_method, nil).should be_false
+  end
+
+  it "should deny unlisted methods" do
+    subject.allow?(ConcealedModel.new, :allowed_method, nil).should be_true
+  end
+
+end

data/spec/concealer/strategy_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Concealer::Strategy do
+  it "should raise an exception when called directly" do
+    expect { subject.allow?(nil, nil, nil) }.to raise_error /must implement/
+  end
+end

data/spec/concealer_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Concealer do
+
+  subject { ConcealedModel.new }
+
+  describe '.strategy' do
+
+    it "should be Concealer::Strategy::Allow by default" do
+      Concealer.strategy.should be_kind_of(Concealer::Strategy::Allow)
+    end
+
+  end
+
+
+  describe '.with_strategy' do
+
+    it "should change the strategy within the block" do
+      strategy = Concealer::Strategy::Deny.new
+      Concealer.with_strategy(strategy) do
+        Concealer.strategy.should be(strategy)
+      end
+    end
+
+    it "should reset the strategy after the block was executed" do
+      strategy = Concealer.strategy
+      Concealer.with_strategy(Concealer::Strategy::Deny.new) {}
+      Concealer.strategy.should be(strategy)
+    end
+
+  end
+
+  describe '.default_fallback' do
+
+    it "should default to Concealer::Fallback::Nil" do
+      Concealer.default_fallback.should be_kind_of(Concealer::Fallback::Nil)
+    end
+
+  end
+
+  describe '.fallback_for' do
+
+    it "should return the default_fallback if no specific fallback is found" do
+      Concealer.fallback_for(ConcealedModel.new, :unknown_method).should be_kind_of(Concealer::Fallback::Nil)
+    end
+
+  end
+
+
+  describe '#concealed' do
+
+    it "should be defined on the model" do
+      should respond_to(:concealed)
+    end
+
+    it "should return a proxy object" do
+      subject.concealed.should be
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec'
+require 'concealer'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/support/concealed_model.rb

@@ -0,0 +1,11 @@
+class ConcealedModel
+  include Concealer
+
+  def allowed_method
+    :allowed_method
+  end
+
+  def denied_method
+    :denied_method
+  end
+end

data/spec/support/paperclip.rb

@@ -0,0 +1,6 @@
+module Paperclip
+  class Attachment
+    def initialize(*args)
+    end
+  end
+end

data/spec/support/user.rb

@@ -0,0 +1,13 @@
+class User
+
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def relation_level_to(user)
+    (user == self) ? :myself : :friends
+  end
+
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification 
+name: concealer
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Benedikt Deicke
+- "Christian B\xC3\xA4uerlein"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-28 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  requirement: *id001
+  name: activesupport
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        version: "2.3"
+  requirement: *id002
+  name: rspec
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
+  name: rake
+  type: :development
+description: Privacy control your models with ease
+email: 
+- benedikt@synatic.net
+- fabrik42@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- concealer.gemspec
+- lib/concealer.rb
+- lib/concealer/fallback.rb
+- lib/concealer/fallback/nil.rb
+- lib/concealer/fallback/paperclip.rb
+- lib/concealer/fallback/string.rb
+- lib/concealer/proxy.rb
+- lib/concealer/strategy.rb
+- lib/concealer/strategy/allow.rb
+- lib/concealer/strategy/blacklist.rb
+- lib/concealer/strategy/deny.rb
+- lib/concealer/strategy/multi_level.rb
+- lib/concealer/strategy/whitelist.rb
+- lib/concealer/version.rb
+- spec/concealer/fallback/nil_spec.rb
+- spec/concealer/fallback/paperclip_spec.rb
+- spec/concealer/fallback/string_spec.rb
+- spec/concealer/fallback_spec.rb
+- spec/concealer/proxy_spec.rb
+- spec/concealer/strategy/allow_spec.rb
+- spec/concealer/strategy/blacklist_spec.rb
+- spec/concealer/strategy/deny_spec.rb
+- spec/concealer/strategy/multi_level_spec.rb
+- spec/concealer/strategy/whitelist_spec.rb
+- spec/concealer/strategy_spec.rb
+- spec/concealer_spec.rb
+- spec/spec_helper.rb
+- spec/support/concealed_model.rb
+- spec/support/paperclip.rb
+- spec/support/user.rb
+has_rdoc: true
+homepage: https://flinc.github.com/concealer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Privacy control your models with ease
+test_files: 
+- spec/concealer/fallback/nil_spec.rb
+- spec/concealer/fallback/paperclip_spec.rb
+- spec/concealer/fallback/string_spec.rb
+- spec/concealer/fallback_spec.rb
+- spec/concealer/proxy_spec.rb
+- spec/concealer/strategy/allow_spec.rb
+- spec/concealer/strategy/blacklist_spec.rb
+- spec/concealer/strategy/deny_spec.rb
+- spec/concealer/strategy/multi_level_spec.rb
+- spec/concealer/strategy/whitelist_spec.rb
+- spec/concealer/strategy_spec.rb
+- spec/concealer_spec.rb
+- spec/spec_helper.rb
+- spec/support/concealed_model.rb
+- spec/support/paperclip.rb
+- spec/support/user.rb