planify 1.0.0

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,20 @@
+.ruby-gemset
+.ruby-version
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rspec

data/.travis.yml

@@ -0,0 +1,8 @@
+services:
+  - mongodb
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+gemspec
+
+gem "rake"
+
+group :test do
+  gem "rspec", "~> 2.14"
+  gem "pry"
+  gem "simplecov", require: false
+
+  if ENV["CI"]
+    gem "coveralls", require: false
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kyle Dayton
+
+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,158 @@
+Planify [![Build Status](https://secure.travis-ci.org/maildropr/planify.png?branch=master)](http://travis-ci.org/maildropr/planify) [![Code Climate](https://codeclimate.com/github/maildropr/planify.png)](https://codeclimate.com/github/maildropr/planify) [![Coverage Status](https://coveralls.io/repos/maildropr/planify/badge.png)](https://coveralls.io/r/maildropr/planify)
+========
+
+Make subscription plans and enforce their limits with Planify.
+
+## Requirements
+
+Ruby:
+* 1.9.3
+* 2.0.0
+* JRuby (1.9 mode)
+* Rubinius (1.9 mode)
+
+Mongoid 3 (Support for other ORMs will be a future improvement)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'planify'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install planify
+
+## Setup 
+
+### Limitables
+Limitables are classes which can be limited based on plan settings. To create a limitable, include the `Planify::Limitable` mixin in your class.
+
+```ruby
+# app/models/widget.rb
+class Widget
+  include Mongoid::Document
+  include Planify::Limitable
+  ...
+end
+```
+
+### Plans
+Plans hold information about how many instances of a `Limitable` can be created, as well as which features are available to users subscribed to this plan:
+
+```ruby
+# config/initializers/plans.rb
+Planify::Plans.define :starter do
+  max Widget, 100 # Can only create up to 100 widgets before needing to upgrade
+
+  feature :ajax_search
+end
+```
+
+### Users
+Add the `Planify::User` mixin to your user class. This will keep track of how many limitables the user has created, as well as their plan and plan overrides:
+
+```ruby
+class User
+  include Mongoid::Document
+  include Planify::User
+  ...
+end
+```
+
+Then assign the user a plan:
+
+```ruby
+@user = User.create
+@user.has_plan :starter
+```
+
+You can also assign user-specific overrides to plan limits and features:
+
+```ruby
+# This user has half the widgets and no ajax-search
+@user.has_plan :starter do
+  max Widget, 50
+  feature :ajax_search, false
+end
+```
+
+## Usage
+
+After creating your Limitables, Plans, and User, you are ready to start enforcing limits.
+
+```ruby
+# widgets_controller.rb
+
+def create
+  @user = current_user
+  @widget = Widget.create(params[:widget])
+
+  if @user.can_create? @widget # User has not hit their Widget cap
+    @widget.save
+    @user.created :widget
+  end
+end
+
+def destroy
+  @user = current_user
+  @widget = Widget.find(params[:id])
+
+  @widget.destroy
+  @user.destroyed @widget
+end
+```
+
+You can also test for features:
+
+```ruby
+# _nav.haml
+
+-if current_user.has_feature? :ajax_search
+  =ajax_search_form
+```
+
+## Rails Integration
+
+When used inside a Rails project, Planify automatically adds two methods to your controllers: `enforce_limit!` and `limit_exceeded!`. `enforce_limit!` will call `limit_exceeded!` if the user is over their limit.
+
+```ruby
+# app/controllers/widget_controller.rb
+class WidgetController < ApplicationController
+  before_filter :enforce_widget_limit, only: [:new, :create]
+
+  ...
+
+  private
+
+  def enforce_widget_limit
+    # If the user's Widget limit is exceeded, limit_exceeded! will be called
+    enforce_limit! current_user, Widget
+  end
+end
+```
+
+The default behavior of `limit_exceeded!` is to raise an Exception. You can change this behavior by creating your own `limit_exceeded!` method in your `ApplicationController`.
+
+```ruby
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  def limit_exceeded!
+    redirect_to upgrade_plan_url, notice: "You must upgrade your account!"
+  end
+end
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Add some specs (so I don't accidentally break your feature in the future)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/planify.rb

@@ -0,0 +1,13 @@
+require "mongoid"
+require "active_support"
+
+require "planify/limitations"
+require "planify/plan"
+require "planify/plans"
+require "planify/user"
+
+require "planify/railtie" if defined?(Rails)
+
+module Planify
+  module Limitable; end
+end

data/lib/planify/integrations/rails.rb

@@ -0,0 +1,26 @@
+module Planify
+  module Integrations
+
+    module Rails
+
+      def self.included(base)
+        base.class_eval do
+          extend Helpers
+          include Helpers
+          helper Helpers
+        end
+      end
+      
+      module Helpers
+        def limit_exceeded!
+          raise "Limit exceeded"
+        end
+
+        def enforce_limit!(user, limitable)
+          limit_exceeded! unless user.can_create? limitable
+        end
+      end
+    end
+
+  end
+end

data/lib/planify/limitations.rb

@@ -0,0 +1,46 @@
+require "planify/util/class_helper"
+
+module Planify
+
+  # +Planify::Limitations+ is a simple container for Class constants and their associated limits
+  class Limitations
+    include ActiveSupport::Inflector
+    include Planify::ClassHelper
+
+    def initialize(limits = {})
+      @limits = limits
+    end
+
+    # Sets the limit for the given class constant
+    # @raise [ArgumentError] if +klass+ does not include module +Planify::Limitable+
+    # @param [String,Symbol,Class,Object] klass The class to set the limit for
+    # @param [Integer] limit The number of instances of +klass+ which can be created
+    # @return [Integer] The value of +limit+
+    def set(klass, limit)
+      key = normalize_class(klass)
+      raise ArgumentError unless constantize(key).include?(Planify::Limitable)
+      @limits[key] = limit
+    end
+
+    # Fetches the limit for the given class constant
+    # @param [String,Symbol,Class,Object] klass The class to find the limit for
+    # @param [Integer] default_limit The default value to return, if one is not defined for +klass+
+    # @return [Integer] The limit value for +klass+, or +default_limit+ if none exists.
+    def get(klass, default_limit = Float::INFINITY)
+      key = normalize_class(klass)
+
+      begin
+        @limits.fetch(key)
+      rescue
+        return default_limit
+      end
+    end
+
+    # Returns all limits defined in this instance
+    # @return [Hash(String,Integer)] A hash mapping class constant name to it's limit
+    def all
+      @limits
+    end
+
+  end
+end

data/lib/planify/plan.rb

@@ -0,0 +1,70 @@
+module Planify
+
+  # The +Planify::Plan+ class provides functionality for storing class creation limits and available features. It also embodies a simple DSL for defining these attributes.
+  class Plan
+
+    attr_reader :features, :limits
+
+    def initialize(limits = {}, features = {})
+      @limits = Limitations.new(limits)
+      @features = features
+    end
+
+    # Sets the maximum number of a +Planify::Limitable+ that a user can create on this plan
+    # @param [String,Symbol,Class,Object] limitable The class to set the limit of
+    # @param [Integer] limit The maxiumum number of +limitable+ that can be created
+    def max(limitable, limit)
+      @limits.set(limitable, limit)
+    end
+
+    # Gets the plan's limit for a given class constant
+    # @param [String,Symbol,Class,Object] limitable The class to get the limit for
+    # @return [Integer, Float::INFINITY] The plan limit for +limitable+, if one exists. Otherwise +Float::INFINITY+
+    def limit(limitable)
+      @limits.get(limitable)
+    end
+
+    def feature(feature_name, enabled = true) 
+      @features[feature_name.to_sym] = enabled
+    end
+
+    # Boolean method for determining if a certain feature is enabled in this plan
+    # @param [String,Symbol] feature the feature to check
+    # @return [Boolean] +true+ if +feature+ is enabled, +false+ if +feature+ is disabled or undefined.
+    def feature_enabled?(feature)
+      @features[feature.to_sym] || false
+    end
+
+    # Boolean method for determining if a certain feature is disabled in this plan
+    # @param [String,Symbol] feature the feature to check
+    # @return [Boolean] +true+ if +feature+ is disabled or undefined, +false+ if +feature+ is enabled.
+    def feature_disabled?(feature)
+      !feature_enabled?(feature)
+    end
+
+    # Returns a duplicate instance of this plan
+    # @return [Planify::Plan] an exact copy of this plan
+    def dup
+      duplicate = Plan.new
+      duplicate.merge! self
+
+      duplicate
+    end
+
+    # Merges limits and features from +other_plan+ into self.
+    # @param [Planify::Plan] other_plan the plan to merge with
+    # @return [nil]
+    def merge!(other_plan)
+      other_plan.features.each do |f, enabled|
+        feature f, enabled
+      end
+
+      other_plan.limits.all.each do |klass, lim|
+        max klass, lim
+      end
+
+      nil
+    end
+
+  end
+end

data/lib/planify/plans.rb

@@ -0,0 +1,30 @@
+module Planify
+  module Plans
+
+    @plans = ActiveSupport::HashWithIndifferentAccess.new
+
+    def self.define(name, &block)
+      plan = Plan.new
+      plan.instance_eval(&block) if block_given?
+
+      @plans[name] = plan
+    end
+
+    def self.get(name)
+      begin
+        @plans.fetch(name)
+      rescue
+        raise ArgumentError, "A plan named '#{name}' is not defined"
+      end
+    end
+
+    def self.all
+      @plans
+    end
+
+    def self.clear
+      @plans.clear
+    end
+
+  end
+end

data/lib/planify/railtie.rb

@@ -0,0 +1,9 @@
+require "planify/integrations/rails"
+
+module Planify
+  class PlanifyRailtie < Rails::Railtie
+    initializer "planify.hooks" do
+      ActionController::Base.send(:include, Planify::Integrations::Rails)
+    end
+  end
+end

data/lib/planify/user.rb

@@ -0,0 +1,82 @@
+require "planify/user/limitable_counts"
+require "planify/user/plan_info"
+
+require "planify/util/class_helper"
+
+module Planify
+  module User
+    include Planify::ClassHelper
+
+    def self.included(base)
+      base.class_eval do
+        embeds_one :planify_plan_info, as: :planify_user, class_name: "Planify::User::PlanInfo", validate: false
+        embeds_one :planify_limitable_counts, as: :planify_user, class_name: "Planify::User::LimitableCounts", validate: false
+      end
+    end
+
+    def has_plan(plan_name, &block)
+      plan = Planify::Plans.get(plan_name)
+      plan_info = PlanInfo.new(name: plan_name)
+
+      if block_given?
+        plan = plan.dup
+        configuration = Planify::Plan.new
+        configuration.instance_eval &block
+
+        plan.merge! configuration
+
+        plan_info.limit_overrides = configuration.limits.all
+        plan_info.feature_overrides = configuration.features
+      end
+
+      self.planify_plan_info = plan_info
+      nil
+    end
+
+    def plan
+      @plan ||= load_plan_from_info(self.planify_plan_info)
+    end
+
+    def limitable_counts
+      self.planify_limitable_counts ||= LimitableCounts.new
+    end
+
+    def creation_count(limitable)
+      key = normalize_class(limitable)
+      limitable_counts.fetch(key)
+    end
+
+    def created(limitable)
+      key = normalize_class(limitable)
+      limitable_counts.increment(key)
+    end
+
+    def destroyed(limitable)
+      key = normalize_class(limitable)
+      limitable_counts.decrement(key)
+    end
+
+    def can_create?(limitable)
+      key = normalize_class(limitable)
+      limitable_counts.fetch(key) < plan.limit(key)
+    end
+
+    def has_feature?(feature)
+      plan.feature_enabled?(feature)
+    end
+
+    private
+
+    def load_plan_from_info(plan_info)
+      return nil unless plan_info
+      plan = Planify::Plans.get(plan_info.name).dup
+
+      if plan_info.has_overrides?
+        plan.merge! plan_info.overrides_as_plan
+      end
+
+      return plan
+    end
+
+  end
+end

data/lib/planify/user/limitable_counts.rb

@@ -0,0 +1,23 @@
+module Planify
+  module User
+
+    class LimitableCounts
+      include Mongoid::Document
+
+      embedded_in :planify_user, polymorphic: true
+
+      def increment(limitable)
+        self.inc(limitable, 1)
+      end
+
+      def decrement(limitable)
+        self.inc(limitable, -1)
+      end
+
+      def fetch(limitable, default = 0)
+        self.attributes[limitable] || default
+      end
+    end
+
+  end
+end

data/lib/planify/user/plan_info.rb

@@ -0,0 +1,32 @@
+module Planify
+  module User
+
+    class PlanInfo
+      include Mongoid::Document
+
+      embedded_in :planify_user, polymorphic: true
+
+      field :name, type: String, default: nil
+      field :limit_overrides, type: Hash, default: nil
+      field :feature_overrides, type: Hash, default: nil
+
+      def has_overrides?
+        limit_overrides.present? || feature_overrides.present?
+      end
+
+      def overrides_as_plan
+        Plan.new.tap do |p|
+          limit_overrides.try(:each) do |klass, limit|
+            p.max klass, limit
+          end
+
+          feature_overrides.try(:each) do |f, enabled|
+            p.feature f, enabled
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/planify/util/class_helper.rb

@@ -0,0 +1,18 @@
+module Planify
+  module ClassHelper
+    include ActiveSupport::Inflector
+
+    def normalize_class(klass)
+      return klass.name if klass.is_a? Module
+      return klass.name if klass.respond_to? :new # Class constant
+
+      if klass.is_a?(String) || klass.is_a?(Symbol)
+        computed_class = constantize camelize(klass.to_s)
+        computed_class.to_s
+      else
+        klass.class.name
+      end
+    end # normalize_class
+
+  end
+end

data/lib/planify/version.rb

@@ -0,0 +1,3 @@
+module Planify
+  VERSION = [1, 0, 0].join(".")
+end

data/planify.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "planify/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "planify"
+  gem.version       = Planify::VERSION
+  gem.authors       = ["Kyle Dayton"]
+  gem.email         = ["kyle@graphicflash.com"]
+  gem.homepage      = "http://github.com/kdayton-/planify"
+
+  gem.description   = %q{A Mongoid plugin for managing subscription plans and features}
+  gem.summary       = gem.description
+
+  gem.files         = `git ls-files`.split($/)
+  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"]
+
+  gem.add_dependency "mongoid", ">= 3.0.0"
+  gem.add_dependency "activesupport"
+end

data/spec/config/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: planify
+      hosts:
+        - localhost:27017

data/spec/models/post.rb

@@ -0,0 +1,4 @@
+class Post
+  include Mongoid::Document
+  include Planify::Limitable
+end

data/spec/models/user.rb

@@ -0,0 +1,6 @@
+class User
+  include Mongoid::Document
+  include Planify::User
+
+  field :name, default: "John"
+end

data/spec/planify/limitations_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+describe Planify::Limitations do
+  describe ".set" do
+
+    context "when specfied class does not include the Limitable module" do
+      it "raises ArgumentError" do
+        expect { subject.set(Object, 100) }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context "with a class constant" do
+      it "sets the limitation for the given class" do
+        subject.set(Post, 100)
+        subject.get(Post).should eq 100
+      end
+    end
+
+    context "with a class instance" do
+      it "sets the limitation for the instance class" do
+        @post = Post.new
+
+        subject.set(@post, 100)
+        subject.get(Post).should eq 100
+      end
+    end
+
+    context "with a module" do
+      it "sets the limitation for the module" do
+        module Foo; end
+        Foo.send(:include, Planify::Limitable)
+
+        subject.set(Foo, 200)
+        subject.get(Foo).should eq 200
+      end
+    end
+
+    context "with a string" do
+      context "string represents a constant name" do
+        it "sets the limitation for the constant" do
+          subject.set("Post", 100)
+          subject.get(Post).should eq 100
+        end
+      end
+
+      context "string does not represent a constant name" do
+        it "raises NameError" do
+          expect { subject.set("Not a class", 100) }.to raise_exception(NameError)
+        end
+      end
+    end
+
+    context "with a symbol" do
+      context "symbol represents a constant name" do
+        it "sets the limitation for the constant" do
+          subject.set(:post, 100)
+          subject.get(Post).should eq 100
+        end
+      end
+
+      context "symbol does not represent a constant name" do
+        it "raises NameError" do
+          expect { subject.set(:non_class, 100) }.to raise_exception(NameError)
+        end
+      end
+    end 
+  end # .set
+
+  describe ".get" do
+
+    context "when class limit is defined" do
+      before { subject.set(:post, 100) }
+      it "returns the limit" do
+        subject.get(Post).should == 100
+      end
+    end
+
+    context "when class limit is undefined" do
+      it "returns the default value" do
+        subject.get(User, 1).should == 1
+      end
+    end
+
+  end # .get
+end

data/spec/planify/plan_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Planify::Plan do
+  subject { Planify::Plans.get(:starter) }
+
+  describe ".limit" do
+    before { subject.max(Post, 100) }
+
+    it "returns the max limit for a Limitable class" do
+      subject.limit(Post).should eq 100
+    end
+  end
+
+  describe ".max" do
+    before { subject.max(Post, 5) }
+
+    it "sets the maximum number of Class allowed" do
+      subject.limit(Post).should eq 5
+    end
+  end
+
+  describe ".feature" do
+    before do
+      subject.feature :ajax_search
+      subject.feature :live_reload, false
+    end
+
+    it "sets availability of the feature" do
+      subject.features.keys.should include :ajax_search, :live_reload
+    end
+
+    it "defaults features to enabled" do
+      subject.features[:ajax_search].should be_true
+    end
+  end
+
+  describe ".feature_enabled?" do
+    before { subject.feature(:ajax_search) }
+
+    it "returns true if the feature is enabled for this plan" do
+      subject.feature_enabled?(:ajax_search).should be_true
+    end
+
+    it "returns false if the feature if explicitly disabled" do
+      subject.feature(:ajax_search, false)
+      subject.feature_enabled?(:ajax_search).should be_false
+    end
+
+    it "returns false if the feature does not exist" do
+      subject.feature_enabled?(:dne_feature).should be_false
+    end
+  end
+
+  describe ".feature_disabled?" do
+    before { subject.feature(:ajax_search) }
+
+    it "returns true if the feature is not enabled for this plan" do
+      subject.feature_disabled?(:ajax_search).should be_false
+    end
+
+    it "returns true if the feature if explicitly disabled" do
+      subject.feature(:ajax_search, false)
+      subject.feature_disabled?(:ajax_search).should be_true
+    end
+
+    it "returns true if the feature does not exist" do
+      subject.feature_disabled?(:dne_feature).should be_true
+    end
+
+    it "returns false if the feature is enabled" do
+      subject.feature_disabled?(:ajax_search).should be_false
+    end
+  end
+
+  describe ".dup" do
+    it "returns a duplicate plan with the same features and limits" do
+      duplicate = subject.dup
+
+      duplicate.should_not be subject
+      duplicate.limits.all.should == subject.limits.all
+      duplicate.features.should == subject.features
+    end
+  end
+
+  describe ".merge!" do
+
+    let(:pro_plan) do
+      Planify::Plans.define :pro do
+        max Post, 1000
+        feature :ajax_search
+      end
+    end
+
+    it "merges settings in other plan into this plan" do
+      subject.merge! pro_plan
+
+      subject.features.keys.should include :ajax_search
+      subject.limit(Post).should == 1000
+    end
+  end
+
+end

data/spec/planify/plans_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe Planify::Plans do
+
+  before(:each) { Planify::Plans.clear }
+
+  describe ".define" do
+    it "creates a plan with the given name" do
+      plan = Planify::Plans.define :starter
+      Planify::Plans.get(:starter).should == plan
+    end
+
+    it "given block should be evaluated on plan" do
+      plan = Planify::Plans.define :starter do
+        max Post, 10
+      end
+
+      Planify::Plans.get(:starter).limit(Post).should == 10
+    end
+  end
+
+  describe ".get" do
+    context "with a string" do
+      it "will match the plan" do
+        Planify::Plans.define :starter
+        Planify::Plans.get("starter").should be_an_instance_of Planify::Plan
+      end
+    end
+
+    context "when plan is defined" do
+      before do
+        Planify::Plans.define :starter do
+          max Post, 10
+        end
+      end
+
+      it "returns the plan" do
+        Planify::Plans.get(:starter).limit(Post).should == 10
+      end
+    end
+
+    context "when plan is undefined" do
+      it "raises an ArgumentError" do
+        expect { Planify::Plans.get(:non_existant) }.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe ".clear" do
+    before { Planify::Plans.define :starter }
+
+    it "destroys all plans" do
+      Planify::Plans.all.should_not be_empty
+      Planify::Plans.clear
+      Planify::Plans.all.should be_empty
+    end
+  end
+end

data/spec/planify/user/plan_info_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Planify::User::PlanInfo do
+  describe ".overrides_as_plan" do
+    it "returns an instance of Planify::Plan" do
+      subject.overrides_as_plan.should be_an_instance_of Planify::Plan
+    end
+  end
+
+  describe ".has_overrides?" do
+    it "returns true if limit overrides exist" do
+      subject.limit_overrides = {post: 100}
+      subject.should have_overrides
+    end
+
+    it "returns true if feature overrides exist" do
+      subject.feature_overrides = {ajax_search: false}
+      subject.should have_overrides
+    end
+
+    it "returns true if both limit and feature overrides exist" do
+      subject.limit_overrides = {post: 100}
+      subject.feature_overrides = {ajax_search: false}
+      subject.should have_overrides
+    end
+
+    it "returns false if neither limit nor feature overrides exist" do
+      subject.should_not have_overrides
+    end
+  end
+end

data/spec/planify/user_spec.rb

@@ -0,0 +1,115 @@
+require "spec_helper"
+
+describe Planify::User, focus: false do
+  subject { User.new }
+  before(:each) do
+    Planify::Plans.define :starter do
+      max Post, 100
+      feature :ajax_search
+    end
+
+    subject.has_plan :starter
+  end
+
+  describe ".has_plan" do
+    it "should assign the plan" do
+      subject.plan.limit(Post).should == 100
+    end
+
+    it "should persist the plan name" do
+      subject.save!
+      user = User.find(subject.id)
+
+      user.plan.limit(Post).should == 100
+    end
+
+    context "with a configuration block" do
+      before do
+        subject.has_plan :starter do
+          max Post, 5
+          feature :ajax_search, false
+        end
+      end
+
+      it "the configuration should override the plan defaults" do
+        subject.plan.limit(Post).should == 5
+      end
+
+      it "should store the configuration change" do
+        subject.save!
+        user = User.find(subject.id)
+
+        user.plan.limit(Post).should == 5
+      end
+
+      it "should not change the base plan" do
+        Planify::Plans.get(:starter).limit(Post).should == 100
+      end
+    end
+  end
+
+  describe ".can_create?" do
+    before { subject.plan.max(Post, 1) }
+    
+    it "should return true if limit for class is not reached" do
+      subject.can_create?(:post).should be_true
+    end
+
+    it "should return false if limit for class is exceeded" do
+      subject.created Post
+      subject.can_create?(Post).should be_false
+    end
+  end
+
+  describe ".has_feature?" do
+    it "returns true if the users plan has the given feature enabled" do
+      subject.has_feature?(:ajax_search).should be_true
+    end
+
+    it "returns false if the users plan does not have the feature" do
+      subject.has_feature?(:dne_feature).should be_false
+    end
+
+    it "returns false if the feature is disabled for the users plan" do
+      subject.plan.feature(:ajax_search, false)
+      subject.has_feature?(:ajax_search).should be_false
+    end
+  end
+
+  describe ".created" do
+    it "should increase the creation count for the given limitable" do
+      expect { subject.created Post }.to change{ subject.creation_count(Post) }.by(1)
+    end
+
+    it "should persist the change" do
+      subject.save!
+      subject.created Post
+
+      user = User.find(subject.id)
+      user.creation_count(Post).should == 1
+    end
+  end
+
+  describe ".destroyed" do
+    before { subject.created Post }
+    it "should decrease the creation count for the given limitable" do
+      expect { subject.destroyed Post }.to change{ subject.creation_count(Post) }.by(-1)
+    end
+
+    it "should persist the change" do
+      subject.save!
+      subject.destroyed Post
+
+      user = User.find(subject.id)
+      user.creation_count(Post).should == 0
+    end
+  end
+
+  describe ".creation_count" do
+    before { subject.created(Post) }
+
+    it "returns the number of limitable created" do
+      subject.creation_count(Post).should == 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "simplecov"
+
+if ENV["CI"]
+  require "coveralls"
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  Coveralls.wear!
+end
+
+SimpleCov.start do
+  add_filter "spec"
+end
+
+require "mongoid"
+require "rspec"
+require "pry"
+
+require "planify"
+
+Mongoid.load!("spec/config/mongoid.yml", :test)
+
+MODELS = File.join(File.dirname(__FILE__), "models")
+Dir[ File.join(MODELS, "*.rb") ].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+
+  config.before :all do
+    Planify::Plans.define :starter do
+      max Post, 100
+    end
+  end
+
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: planify
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Kyle Dayton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Mongoid plugin for managing subscription plans and features
+email:
+- kyle@graphicflash.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .coveralls.yml
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/planify.rb
+- lib/planify/integrations/rails.rb
+- lib/planify/limitations.rb
+- lib/planify/plan.rb
+- lib/planify/plans.rb
+- lib/planify/railtie.rb
+- lib/planify/user.rb
+- lib/planify/user/limitable_counts.rb
+- lib/planify/user/plan_info.rb
+- lib/planify/util/class_helper.rb
+- lib/planify/version.rb
+- planify.gemspec
+- spec/config/mongoid.yml
+- spec/models/post.rb
+- spec/models/user.rb
+- spec/planify/limitations_spec.rb
+- spec/planify/plan_overrides_spec.rb
+- spec/planify/plan_spec.rb
+- spec/planify/plans_spec.rb
+- spec/planify/user/plan_info_spec.rb
+- spec/planify/user_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/kdayton-/planify
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 654973981249883969
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 654973981249883969
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: A Mongoid plugin for managing subscription plans and features
+test_files:
+- spec/config/mongoid.yml
+- spec/models/post.rb
+- spec/models/user.rb
+- spec/planify/limitations_spec.rb
+- spec/planify/plan_overrides_spec.rb
+- spec/planify/plan_spec.rb
+- spec/planify/plans_spec.rb
+- spec/planify/user/plan_info_spec.rb
+- spec/planify/user_spec.rb
+- spec/spec_helper.rb