capable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa1fd9dbe475e8c9d2adee0ed641c67effba968c
+  data.tar.gz: 0129dfec50822cbb114a5790b72c4ec98e951bdb
+SHA512:
+  metadata.gz: c545e3aaba428c7500f5140aecb3483f2832d188560aaf418d8eedfce3519150a7d4025f679adbb9a9e72fb006cb3a58c490c979b2e3940890fdb5053f951e66
+  data.tar.gz: 700965da9ea69f247dc233d27d40a0e1a1e28f706e7629734e429bf2499bce3f77c7177c04bdcfbdc652c90c1ceb63645cecd3c996e13b043ccaf9991860439b

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 TODO: Write your name
+
+MIT License
+
+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,147 @@
+# Capable
+
+This Gem works similar to UNIX group permissions.  The server defines different 'abilities' that can then be applied to *capable* objects via a *capabilities* join table.  The *capabilities* table also allows expiration dates to be defined and applies the concept of *renewer*'s where another object can renew the expiration date of the *capability*.
+
+This scheme was originally developed to provide purchasable features in an APP via In App Purchase that would renew based on subscriptions.  The *User* is the *capable* object and the *Receipt* is the renewer.  If a receipt renews, it has the ability to update the *capabilities* for the *User*
+
+One good feature about this class is if a user has a certain ability from 2 different sources, if one of them expires or is deleted, the user will still have the ability from the other source.  For example
+
+ - User purchases [pro, gold] abilities.  User is now [pro, gold]
+ - User purchases [sponsor, gold] abilities.  User is now [sponsor, pro, gold]
+ - User expires [pro, gold] abilities.  User is now [sponsor, gold]
+
+This *ability* scheme can be applied to any object in the database by using the *acts_as_capable* method.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'capable'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capable
+
+## Usage
+
+### Setup Database Schema
+
+Run the following code to create the *Ability* and *Capability* models and migration file.
+
+    $ rails generate capable
+
+In order to activate the local caching features of this Gem, you will need to add the following to your migration file for each class you are going to declare as *capable*.
+
+```ruby
+add_column :<capable class>, :ability_list, :string
+```
+
+**If you do not add the above attribute to all of your *capable* objects, the system will query for the abilities EVERY TIME you call *ability_array* on a *capable* object.**  Once complete, migrate the database by running
+
+    $ rake db:migrate
+
+### Configuration
+
+To set different configuration options, create the file "config/initializers/capable.rb" with the following code (currently you can only turn on 'verbose')
+
+```ruby
+require 'capable'
+
+Capable.configure do |config|
+  config.verbose = true
+end
+```
+
+### Ability
+
+The *Ability* class provides a way for the admin to create different abilities that can be assigned to *capable* objects.  It has the following instance methods
+
+```ruby
+# This will assign an ability to a capable object via the capability class (the options in []'s are optional)
+ability.assign_capable(capable, [active=true, expires_at=nil, renewer=nil])
+```
+
+### Capability
+
+The *Capability* class is what ties the *abilities* to *capable* objects.  It also has a *renewer* hook that provides a way for something to periodically renew the expiration date.  Another cool feature of this class is that when updated, it will automatically re-initialize the *ability_list* of the *capable* object if it is defined.  Here are it's methods
+
+```ruby
+# Create a capability (the options in []'s are optional)
+Capability.create_capability(capable, ability, [active=true, expires_at=nil, renewer=nil])
+
+# Expires all capabilities that have an expiration date that is not nil and is older than the passed in date (sets active to false).  This will automatically update the abilities of the corresponding capable object
+Capability.expire_capabilities(expiration_date)
+
+# Renew the capability
+capability.renew(expires_at)
+```
+
+### Acts As Capable
+
+For each class that you would like to assign *abilities* to, do the following in your class.  For this example, we will use the class *User*.
+
+```ruby
+require 'capable'
+
+class User < ActiveRecord::Base
+  acts_as_capable # Rails 4
+  # note for Rails <= 3.x, you need to use 'acts_as_capable_3x'
+end
+```
+
+Also note from above that you will want to create a string called *ability_list* on the class to allow for local caching of abilities in the *capable* object.  This is all handled automatically by the Gem when a capability is updated.
+
+Once an object is declared as *capable* it allows the following methods to be defined
+
+```ruby
+# See if the user has a certain ability.  Note that 'ability' can either be an ability object OR the 'ability' string attribute of an ability object
+user.has_ability?(ability)
+
+# Return a comma delimited list of strings of the different abilities.  This is useful for example when serializing the object over an API.  The mobile client can simply work off of this array.
+user.ability_array
+
+# Assign an ability to a user (the options in []'s are optional)
+user.assign_ability(ability, [active=true, expires_at=nil, renewer=nil])
+
+# Unassign an ability from a user (just sets active to false.  The options in []'s are optional)
+user.unassign_ability(ability, [renewer=nil])
+```
+### Acts As Capability Renewer
+
+A *capability renewer* is a class that can renew the expiration date of capabilities such as a subscription.  To create these classes do the following
+
+```ruby
+require 'capable'
+
+class Renewer < ActiveRecord::Base
+  acts_as_capability_renewer
+end
+```
+
+Once an object is declared as a capability renewer, it has the following instance methods available to it
+
+```ruby
+# Create capabilities for a capable object with this as the renewer.  This will only create the capabilities if capable is not nil, the abilities array has values, and the current count of the capabilities is 0
+renewer.create_capabilities(capable, abilities, active, expires_at)
+
+# Renew the expiration date for the capabilities of a renewer (note that this sets active attribute based on the current date so if it is in the past, active will be set to 'false')
+renewer.renew_capabilities(expires_at)
+```
+
+The renewer concept allows a capability to be renewed when the expiration date is updated.  This is good for example when a user purchases more time on a role.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/capable/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+> Written with [StackEdit](https://stackedit.io/).

data/Rakefile

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+require 'rubygems'
+require 'bundler' unless defined?(Bundler)
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require 'capable/version'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.test_files = Dir.glob("test/**/*_test.rb")
+  test.verbose = true
+end
+
+require 'rake'
+require 'rspec/core/rake_task'
+ 
+RSpec::Core::RakeTask.new(:spec) do |test|
+  test.pattern = Dir.glob('spec/**/*_spec.rb')
+  test.rspec_opts = '--format documentation'
+  # test.rspec_opts << ' more options'
+  # test.rcov = true
+end
+task :default => :spec
+
+task :build do
+  system "gem build capable.gemspec"
+end
+
+task :release => :build do
+  system "gem push capable-#{Capable::VERSION}.gem"
+  system "rm capable-#{Capable::VERSION}.gem"
+end
+
+task :test_all_databases do
+  # Test MySQL, Postgres and SQLite3
+  # ENV['DB'] = 'mysql'
+  # Rake::Task['spec'].execute
+  # ENV['DB'] = 'postgres'
+  # Rake::Task['spec'].execute
+  ENV['DB'] = 'sqlite3'
+  Rake::Task['spec'].execute
+end
+
+task :default => :test_all_databases
+

data/capable.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "capable"
+  spec.version       = Capable::VERSION
+  spec.authors       = ["Eric Chapman"]
+  spec.email         = ["contact@ericjchapman.com"]
+  spec.summary       = %q{Gem that will allow 'abilities' to be assigned to 'capable' objects that can be independantly expired and renewed.}
+  spec.description   = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec'
+  if RUBY_VERSION < '1.9.3'
+    spec.add_runtime_dependency('activerecord', '< 4.0.0')
+  else
+    spec.add_runtime_dependency('activerecord')
+  end
+  spec.add_development_dependency('mysql2')
+  spec.add_development_dependency('pg')
+  spec.add_development_dependency('sqlite3')
+end

data/lib/acts_as_ability.rb

@@ -0,0 +1,28 @@
+module Capable
+  module ActsAsAbility
+
+    def self.included(base)
+      base.extend Capable::Base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def acts_as_ability
+        has_many :capabilities, :dependent => :destroy
+        has_many :capables, :through => :capabilities
+
+        include Capable::ActsAsAbility::InstanceMethods
+      end
+
+    end
+
+    module InstanceMethods
+
+      def assign_capable(capable, active=true, expires_at=nil, renewer=nil)
+        Capability.create_capability(capable, self, active, expires_at, renewer)
+      end
+
+    end
+  end
+end

data/lib/acts_as_capability.rb

@@ -0,0 +1,61 @@
+module Capable
+  module ActsAsCapability
+
+    def self.included(base)
+      base.extend Capable::Base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def acts_as_capability
+        belongs_to :ability
+        belongs_to :capable, :polymorphic => true
+        belongs_to :renewer, :polymorphic => true
+
+        after_create :update_capables
+        after_update :update_capables
+
+        include Capable::ActsAsCapability::InstanceMethods
+      end
+
+      def create_capability(capable, ability, active=true, expires_at=nil, renewer=nil)
+        create(
+          capable: capable,
+          ability: ability,
+          active: active,
+          expires_at: expires_at,
+          renewer: renewer
+        )
+      end
+
+      def expire_capabilities(expiration_date)
+        self.where('expires_at is not null and expires_at < ? and active = ?', expiration_date, true).find_each do |capability|
+          puts "CAPABILITY_EXPIRE: Capable #{capability.capable_type} (#{capability.capable_id}) expired the ability #{capability.ability.name}" if Capable.configuration[:verbose]
+          capability.active = false
+          capability.save!
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+      def update_capables
+        if self.capable.respond_to? :ability_list=
+          self.capable.ability_list = self.capable.abilities.pluck(:ability).uniq.join(",")
+          self.capable.save!
+        else
+          puts "CAPABILITY_ERROR: Accessor method 'ability_list' is not defined for the class '#{self.capable_type}'" if Capable.configuration[:verbose]
+        end
+      end
+
+      def renew(expires_at)
+        self.expires_at = expires_at
+        self.active = (expires_at.nil? or expires_at > Time.now)
+        self.save
+      end
+
+    end
+  end
+end

data/lib/acts_as_capability_renewer.rb

@@ -0,0 +1,39 @@
+module Capable
+  module ActsAsCapabilityRenewer
+
+    def self.included(base)
+      base.extend Capable::Base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def acts_as_capability_renewer
+        has_many :capabilities, as: :renewer, :dependent => :destroy
+
+        include Capable::ActsAsCapabilityRenewer::InstanceMethods
+      end
+
+    end
+
+    module InstanceMethods
+
+      def create_capabilities(capable, abilities, active, expires_at)
+        if capable.present? and abilities.present? and self.capabilities.count == 0
+          abilities.each do |ability|
+            Capability.create_capability(capable, ability, active, expires_at, self)
+          end
+        end
+      end
+
+      def renew_capabilities(expires_at)
+        self.capabilities.each do |capability|
+          capability.renew(expires_at)
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/acts_as_capable.rb

@@ -0,0 +1,65 @@
+module Capable
+  module ActsAsCapable
+
+    def self.included(base)
+      base.extend Capable::Base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def acts_as_capable_3x
+        has_many :capabilities, as: :capable, :dependent => :destroy
+        has_many :abilities, :through => :capabilities, :conditions => 'capabilities.active = true'
+
+        include Capable::ActsAsCapable::InstanceMethods
+      end
+
+      def acts_as_capable
+        has_many :capabilities, as: :capable, :dependent => :destroy
+        has_many :abilities, -> { where(capabilities: { active: true }) }, :through => :capabilities
+
+        include Capable::ActsAsCapable::InstanceMethods
+      end
+
+    end
+
+    module InstanceMethods
+
+      def ability_array
+        if self.respond_to? :ability_list
+          if self.ability_list.present?
+            return self.ability_list.split(",")
+          else
+            return Array.new
+          end
+        else
+          puts "CAPABLE_WARNING: It is recommended to create the string 'ability_list' for the class '#{self.class.name}' in order to speed up ability checking" if Capable.configuration[:verbose]
+          return self.abilities.pluck(:ability).uniq
+        end
+      end
+
+      def has_ability?(ability)
+        if ability.kind_of? String
+          return ability_array.include? ability
+        else
+          return ability_array.include? ability.ability
+        end
+      end
+
+      def assign_ability(ability, active=true, expires_at=nil, renewer=nil)
+        Capability.create_capability(self, ability, active, expires_at, renewer)
+      end
+
+      def unassign_ability(ability, renewer=nil)
+        Capability.where(capable: self, ability: ability, renewer: renewer, active: true).each do |capability|
+          capability.active = false
+          capability.save # This will kickoff the update logic
+        end
+      end
+
+    end
+  end
+end
+
+

data/lib/capable.rb

@@ -0,0 +1,40 @@
+require "acts_as_ability"
+require "acts_as_capability"
+require "acts_as_capable"
+require "acts_as_capability_renewer"
+require "capable/version"
+require 'capable/configuration'
+require 'capable/base'
+require 'active_record'
+
+module Capable
+
+  class << self
+
+    # An Capable::Configuration object. Must act like a hash and return sensible
+    # values for all Capable::Configuration::OPTIONS. See Capable::Configuration.
+    attr_writer :configuration
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Capable.configure do |config|
+    #     config.<attr> = <value>
+    #   end
+    def configure
+      yield(configuration)
+    end
+
+    # The configuration object.
+    # @see Capable::Configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+
+end
+
+ActiveRecord::Base.send(:include, Capable::ActsAsAbility)
+ActiveRecord::Base.send(:include, Capable::ActsAsCapability)
+ActiveRecord::Base.send(:include, Capable::ActsAsCapable)
+ActiveRecord::Base.send(:include, Capable::ActsAsCapabilityRenewer)

data/lib/capable/base.rb

@@ -0,0 +1,11 @@
+module Capable
+  module Base
+    def quoted_true
+      ActiveRecord::Base.connection.quoted_true
+    end
+
+    def quoted_false
+      ActiveRecord::Base.connection.quoted_false
+    end
+  end
+end

data/lib/capable/configuration.rb

@@ -0,0 +1,36 @@
+module Capable
+  class Configuration
+
+    OPTIONS = [:verbose].freeze
+
+    attr_accessor :verbose
+
+    def initialize
+      # these defaults can be overridden in the Tokengen.config block
+      @verbose = false
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash[option.to_sym] = self.send(option)
+        hash
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+  end
+end

data/lib/capable/version.rb

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

data/lib/generators/capable/capable_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators/active_record'
+
+class CapableGenerator < Rails::Generators::Base
+
+  include Rails::Generators::Migration
+
+  source_root File.expand_path('../templates', __FILE__)
+
+  # Implement the required interface for Rails::Generators::Migration.
+  def self.next_migration_number(dirname) #:nodoc:
+    next_migration_number = current_migration_number(dirname) + 1
+    if ActiveRecord::Base.timestamped_migrations
+      [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+    else
+      "%.3d" % next_migration_number
+    end
+  end
+
+  def create_capable_migration
+    migration_template 'migration.rb', File.join('db', 'migrate', 'capable_migration.rb')
+  end
+
+  def move_ability_model
+    template 'ability.rb', File.join('app', 'models', 'ability.rb')
+  end
+
+  def move_capability_model
+    template 'capability.rb', File.join('app', 'models', 'capability.rb')
+  end
+
+end

data/lib/generators/capable/templates/ability.rb

@@ -0,0 +1,5 @@
+class Ability < ActiveRecord::Base
+  acts_as_ability
+
+  # Add custom code here
+end 

data/lib/generators/capable/templates/capability.rb

@@ -0,0 +1,5 @@
+class Capability < ActiveRecord::Base
+  acts_as_capability
+
+  # Add custom code here
+end

data/lib/generators/capable/templates/migration.rb

@@ -0,0 +1,33 @@
+class CapableMigration < ActiveRecord::Migration
+  def self.up
+
+    create_table :abilities, :force => true do |t|
+      t.string :ability, :null => false
+      t.string :name, :null => false
+      t.string :description, :null => false
+      t.timestamps
+    end
+
+    create_table :capabilities, :force => true do |t|
+      t.integer :ability_id, :null => false
+      t.references :capable, :polymorphic => true, :null => false
+      t.references :renewer, :polymorphic => true
+      t.boolean :active, :default => true
+      t.datetime :expires_at, :null => true
+      t.timestamps
+    end
+
+    add_index :capabilities, [:active, :expires_at]
+    add_index :capabilities, [:capable_id, :capable_type, :active]
+    add_index :capabilities, [:capable_id, :capable_type, :ability_id, :renewer_id, :renewer_type], :name => 'capabilities_all_index'
+
+  end
+
+  def self.down
+
+    drop_table :abilities
+    drop_table :capabilities
+
+  end
+
+end

data/spec/capable_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Capable do
+
+  before do
+    Ability.delete_all
+    Capability.delete_all
+    User.delete_all
+    Renewer.delete_all
+  end
+
+  describe 'Capability Assignment' do
+    let (:non_cached_user) { NonCachedUser.create(name:'Eric') }
+    let (:user) { User.create(name:'Eric') }
+    let (:admin_ability) { Ability.create(name: 'Admin Ability', description: 'Ability for admin', ability: 'admin') }
+    let (:pro_ability) { Ability.create(name: 'Pro Ability', description: 'Ability for pro', ability: 'pro') }
+    let (:renewer) { Renewer.create() }
+
+    it 'Test Acts As Capable Instance Methods' do
+      expect(user.has_ability?(admin_ability)).to eq false
+      expect(user.has_ability?(admin_ability.ability)).to eq false
+
+      # Test assigning ability
+      user.assign_ability(admin_ability)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq true
+      expect(user.has_ability?(admin_ability.ability)).to eq true
+
+      # Test unassigning ability
+      user.unassign_ability(admin_ability)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq false
+      expect(user.has_ability?(admin_ability.ability)).to eq false
+    end
+
+    it 'Test Acts As Capable Instance Methods without array_list defined' do
+      expect(non_cached_user.has_ability?(admin_ability)).to eq false
+      expect(non_cached_user.has_ability?(admin_ability.ability)).to eq false
+
+      # Test assigning ability
+      non_cached_user.assign_ability(admin_ability)
+      non_cached_user.reload
+
+      expect(non_cached_user.has_ability?(admin_ability)).to eq true
+      expect(non_cached_user.has_ability?(admin_ability.ability)).to eq true
+
+      # Test unassigning ability
+      non_cached_user.unassign_ability(admin_ability)
+      non_cached_user.reload
+
+      expect(non_cached_user.has_ability?(admin_ability)).to eq false
+      expect(non_cached_user.has_ability?(admin_ability.ability)).to eq false
+    end
+
+    it 'Test Acts As Capability Renewer Instance Methods' do
+
+      # Test create_capabilities works
+      renewer.create_capabilities(user, [pro_ability, admin_ability], true, Time.now+4)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq true
+      expect(user.has_ability?(pro_ability)).to eq true
+
+      Capability.expire_capabilities(Time.now+6)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq false
+      expect(user.has_ability?(pro_ability)).to eq false
+
+      # Test renewing capabilities works
+      renewer.renew_capabilities(Time.now+8)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq true
+      expect(user.has_ability?(pro_ability)).to eq true
+
+      # Test expiration
+      Capability.expire_capabilities(Time.now+10)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq false
+      expect(user.has_ability?(pro_ability)).to eq false
+
+      # Test renewing capabilities does not work for the past
+      renewer.renew_capabilities(Time.now-1)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq false
+      expect(user.has_ability?(pro_ability)).to eq false
+    end
+
+
+    it 'Test Acts As Capability Expiration Logic' do
+      user.assign_ability(admin_ability)
+      user.assign_ability(pro_ability, true, Time.now)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq true
+      expect(user.has_ability?(pro_ability)).to eq true
+
+      # Test expiration
+      Capability.expire_capabilities(Time.now+2)
+      user.reload
+
+      expect(user.has_ability?(admin_ability)).to eq true
+      expect(user.has_ability?(pro_ability)).to eq false
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,113 @@
+require 'capable'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'active_record'
+
+config = {
+  :database => 'device_token_test',
+  :username => 'test'
+}
+
+case ENV['DB']
+  when 'mysql'
+    config = {
+      :adapter => 'mysql2',
+      :database => 'device_token_test',
+      :username => 'test',
+      :password => 'test',
+      :socket => '/tmp/mysql.sock'
+    }
+    if ENV['TRAVIS']
+      config = {
+        :adapter => 'mysql2',
+        :database => 'device_token_test',
+        :username => 'root'
+      }
+    end
+    ActiveRecord::Base.establish_connection(config)
+    ActiveRecord::Base.connection.drop_database(config[:database]) rescue nil
+    ActiveRecord::Base.connection.create_database(config[:database])
+  when 'postgres'
+    config = {
+      :adapter => 'postgresql',
+      :database => 'device_token_test',
+      :username => 'test',
+    }
+    if ENV['TRAVIS']
+      config = {
+        :adapter => 'postgresql',
+        :database => 'device_token_test',
+        :username => 'postgres',
+      }
+    end
+    ActiveRecord::Base.establish_connection(config.merge({ :database => 'postgres' }))
+    ActiveRecord::Base.connection.drop_database(config[:database])
+    ActiveRecord::Base.connection.create_database(config[:database])
+  when 'sqlite3'
+    config = {
+      :adapter => 'sqlite3',
+      :database => 'test.sqlite3',
+      :username => 'test',
+    }
+end
+
+ActiveRecord::Base.establish_connection(config)
+
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+
+  create_table :abilities, :force => true do |t|
+    t.string :ability, :null => false
+    t.string :name, :null => false
+    t.string :description, :null => false
+    t.timestamps
+  end
+
+  create_table :capabilities, :force => true do |t|
+    t.integer :ability_id, :null => false
+    t.references :capable, :polymorphic => true, :null => false
+    t.references :renewer, :polymorphic => true
+    t.boolean :active, :default => true
+    t.datetime :expires_at, :null => true
+    t.timestamps
+  end
+
+  create_table :users, :force => true do |t|
+    t.string :name
+    t.string :ability_list
+    t.timestamps
+  end
+
+  create_table :non_cached_users, :force => true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  create_table :renewers, :force => true do |t|
+    t.timestamps
+  end
+
+end
+
+class Ability < ActiveRecord::Base
+  acts_as_ability
+end
+
+class Capability < ActiveRecord::Base
+  acts_as_capability
+end
+
+class User < ActiveRecord::Base
+  acts_as_capable
+end
+
+class NonCachedUser < ActiveRecord::Base
+  acts_as_capable
+end
+
+class Renewer < ActiveRecord::Base
+  acts_as_capability_renewer
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: capable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eric Chapman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- contact@ericjchapman.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- capable.gemspec
+- lib/acts_as_ability.rb
+- lib/acts_as_capability.rb
+- lib/acts_as_capability_renewer.rb
+- lib/acts_as_capable.rb
+- lib/capable.rb
+- lib/capable/base.rb
+- lib/capable/configuration.rb
+- lib/capable/version.rb
+- lib/generators/capable/capable_generator.rb
+- lib/generators/capable/templates/ability.rb
+- lib/generators/capable/templates/capability.rb
+- lib/generators/capable/templates/migration.rb
+- spec/capable_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Gem that will allow 'abilities' to be assigned to 'capable' objects that
+  can be independantly expired and renewed.
+test_files:
+- spec/capable_spec.rb
+- spec/spec_helper.rb