superfeature 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3b624d4e0260cabbdebb2675fc22a8236889d92197859336a19700528e23b07
-  data.tar.gz: '09256cd31eea44abffe554ad183fb98ce061dcc416259d5b47b55651019edac2'
+  metadata.gz: ea2cc79603e2a605076a000f1c99224a460e812ca128b1685c9b2ccf84189de9
+  data.tar.gz: b7c1cc123dd6fadaefbb64b50a0eb2191ce0bab4ffe89aa07ed9e74d4a008776
 SHA512:
-  metadata.gz: 02070efdf5658cce58e722464d2932f4908dfa0a848ac50adcc0adda1809566a25cbed61e206a759fd782782e4399639ece9f392d4d631d551c3c36dbb91bbb5
-  data.tar.gz: 0304f49be57b23352e1e8857b6a2e75b92c1dc71fe23c44151e85409b9bb2bd9a8b5f04f4bf8cf9ac5f7d0066d0129945412e739c5c7903b23d78fae05828f5b
+  metadata.gz: bfa175930e17f348f4a2766601b45515b7f8c242526dd07ce37229c8bf4b06a8bdc031cccf0e99a7df1720d59c6c70a520412c93c62a1b2dd1c437a81443973f
+  data.tar.gz: 99fce65c67de1d832c0298bb6dfe0c4e75b07131d9c8e2ddaeb11451d573d45da2e46cd74a54e362f9a5f8d5b22f5c4814c4e94aa9e93bb130b69daa2b9cfd27

data/README.md

@@ -2,7 +2,7 @@
 
 Features are simple boolean flags that say whether or not they're enabled, right? Not quite. Features can get quite complicated, as you'll read below in the use cases.
 
-This gem makes reasoning through those complexities much more sane by isolating them all into the `app/features` folder as plain 'ol Ruby objects (POROS), that way your team can reason through the features available in an app much better, test them, and do really complicated stuff when needed.
+This gem makes reasoning through those complexities much more sane by isolating them all into the `app/plans` folder as plain 'ol Ruby objects (POROS), that way your team can reason through the features available in an app much better, test them, and do really complicated stuff when needed.
 
 ## Use cases
 
@@ -32,72 +32,339 @@ $ rails generate superfeature:install
 
 Restart your server and it's off to the races!
 
-First thing you'll want to checkout is the `./app/plans/application_plan.rb` file:
+## Generated Files
+
+The generator creates the following structure:
+
+### `app/plans/base.rb`
+
+The base plan defines all features with sensible defaults:
 
 ```ruby
-class ApplicationPlan < Superfeature::Plan
-  attr_reader :user, :account
+module Plans
+  class Base < Superfeature::Plan
+    attr_reader :user
+
+    def initialize(user)
+      @user = user
+    end
+
+    # Boolean features - simple on/off flags
+    feature def priority_support = disable("Priority support", group: "Support")
+    feature def phone_support = disable("Phone support", group: "Support")
+
+    # Hard limits - strict maximum that cannot be exceeded
+    feature def api_calls = hard_limit("API calls", group: "Limits", quantity: user.api_calls_count, maximum: 1000)
 
-  def initialize(user)
-    @user = user
-    @account = user.account
+    # Soft limits - has a soft and hard boundary for overages
+    feature def storage_gb = soft_limit("Storage", group: "Limits", quantity: user.storage_used_gb, soft_limit: 100, hard_limit: 150)
+
+    # Unlimited - no restrictions
+    feature def projects = unlimited("Projects", group: "Limits", quantity: user.projects_count)
+
+    protected
+
+    def feature(name, **options)
+      Features::Base.new(name, **options)
+    end
   end
+end
+```
+
+### `app/plans/features/base.rb`
 
-  def team_size
-    hard_limit maximum: 0, quantity: account.users.count
+Extends `Superfeature::Feature` with `name` and `group` for display purposes:
+
+```ruby
+module Plans
+  module Features
+    class Base < Superfeature::Feature
+      attr_reader :name, :group
+
+      def initialize(name = nil, group: nil, **)
+        super(**)
+        @name = name
+        @group = group
+      end
+    end
   end
+end
+```
+
+You can add whatever else you want to a feature class, including logic, calculation methods, new types of limits, and more.
+
+### `app/plans/free.rb` and `app/plans/paid.rb`
 
-  def moderation
-    enabled account.moderation_enabled?
+Plans are linked together using `next` and `previous` methods:
+
+```ruby
+module Plans
+  class Free < Base
+    def name = "Free"
+    def price = 0
+    def description = "Get started for free"
+
+    def next = plan Paid
   end
+end
 
-  def support
-    disabled
+module Plans
+  class Paid < Free
+    def name = "Paid"
+    def price = 9.99
+    def description = "Full access to all features"
+
+    # Override features from Base to enable them
+    def priority_support = super.enable
+
+    def next = nil
+    def previous = plan Free
   end
 end
 ```
 
-Here's what it would look like when you add an enterprise plan to the lign up in the ``./app/plans/application_plan.rb`` file.
+The `next` and `previous` methods create a linked list of plans that `Superfeature::Plan::Collection` can traverse.
+
+## Usage
+
+### Setting up User#plan
+
+Add a `plan` column to your users table to track which plan they're on:
+
+```ruby
+add_column :users, :plan, :string, default: "free"
+```
+
+Then add a `plan` method to your User model:
 
 ```ruby
-class EnerprisePlan < ApplicationPlan
-  def support = enabled
-  def saml = enabled
+class User < ApplicationRecord
+  def plan
+    @plan ||= Superfeature::Plan::Collection.new(Plans::Free.new(self)).find(plan_key)
+  end
+
+  def plan_key
+    self[:plan]&.to_sym || :free
+  end
 end
 ```
 
-## Usage
+Now you can access features directly from the user:
+
+```ruby
+current_user.plan                          # => Collection wrapping Plans::Free or Plans::Paid
+current_user.plan.priority_support.enabled? # => false
+current_user.plan.upgrades.to_a            # => available upgrade plans
+```
 
-Then you can do things from controllers like:
+### Checking features in controllers
 
 ```ruby
 class ModerationController < ApplicationController
   def show
-    if feature.moderation.enabled?
+    if current_plan.moderation.enabled?
       render "moderation"
     else
-      redirect_to moderation_upgrade_path
+      redirect_to upgrade_path
     end
   end
 
-  protected
+  private
 
-  def plan = ApplicationPlan.new
-  def feature = plan.moderation
+  def current_plan
+    @current_plan ||= current_user.plan
+  end
+  helper_method :current_plan
 end
 ```
 
-Or from views:
+### Checking features in views
 
 ```erb
 <h1>Moderation</h1>
-<% if feature.enabled? %>
-  <p><% render partial: "moderation" %></p>
+<% if current_plan.moderation.enabled? %>
+  <%= render partial: "moderation" %>
 <% else %>
   <p>Call sales to upgrade to moderation</p>
 <% end %>
 ```
 
+### Working with Plan::Collection
+
+The `Collection` class wraps a plan and provides navigation and enumeration:
+
+```ruby
+# Create a collection starting from any plan
+collection = Superfeature::Plan::Collection.new(Plans::Free.new(current_user))
+
+# Find a specific plan by symbol key
+collection.find(:paid)  # => Paid plan instance
+
+# Find a specific plan by class
+collection.find(Plans::Paid)  # => Paid plan instance
+
+# Get multiple plans with slice
+collection.slice(:free, :paid)  # => Array of matching plans
+collection.slice(Plans::Free, Plans::Paid)  # => Also works with classes
+
+# Iterate through all plans (includes Enumerable)
+collection.each do |plan|
+  puts "#{plan.name}: $#{plan.price}"
+end
+
+collection.to_a  # All plans as an array
+```
+
+### Building a pricing page
+
+```ruby
+# In controller
+def index
+  @plans = Superfeature::Plan::Collection.new(Plans::Free.new(User.new)).to_a
+end
+
+# In view
+<% @plans.each do |plan| %>
+  <div class="plan">
+    <h2><%= plan.name %></h2>
+    <p class="price">$<%= plan.price %>/month</p>
+    <p><%= plan.description %></p>
+
+    <ul>
+      <% plan.features.each do |feature| %>
+        <li>
+          <%= feature.name %>:
+          <%= feature.enabled? ? "✓" : "—" %>
+        </li>
+      <% end %>
+    </ul>
+
+    <%= link_to "Select", plan_path(plan) %>
+  </div>
+<% end %>
+```
+
+### Checking limits
+
+```ruby
+plan = current_user.plan
+
+# Hard limits
+if plan.api_calls.exceeded?
+  render "api_limit_reached"
+end
+
+puts plan.api_calls.quantity  # current usage
+puts plan.api_calls.maximum   # max allowed
+puts plan.api_calls.remaining # how many left
+
+# Boolean features
+plan.priority_support.enabled?  # => false
+plan.priority_support.disabled? # => true
+```
+
+### Preventing inheritance with `exclusively`
+
+When plans inherit from each other, methods are inherited too. Sometimes you want a method to only apply to the exact class it's defined in, not subclasses. Use `exclusively`:
+
+```ruby
+module Plans
+  class Pro < Basic
+    # Only Pro gets this badge, not Enterprise which inherits from Pro
+    exclusively def badge = "Most Popular"
+  end
+end
+
+module Plans
+  class Enterprise < Pro
+    # badge returns nil here, not "Most Popular"
+  end
+end
+```
+
+## Adding new plans
+
+Generate a new plan:
+
+```bash
+$ rails generate superfeature:plan Enterprise
+```
+
+This creates `app/plans/enterprise.rb`:
+
+```ruby
+module Plans
+  class Enterprise < Base
+    def name = "Enterprise"
+    def price = 0
+    def description = "Description for Enterprise plan"
+
+    # Override features from Base to enable them
+    # def priority_support = super.enable
+
+    # Link to adjacent plans for navigation
+    # def next = plan NextPlan
+    # def previous = plan PreviousPlan
+  end
+end
+```
+
+Then wire it into your plan chain by updating `next` and `previous` methods:
+
+```ruby
+# In paid.rb
+def next = plan Enterprise
+
+# In enterprise.rb
+def previous = plan Paid
+```
+
+## Pricing with discounts
+
+The `Price` class helps you work with prices and discounts in views:
+
+```ruby
+# Apply discounts
+price = Superfeature::Price.new(100.00)
+price.discount_fixed(20)      # => $80.00 (fixed $20 off)
+price.discount_percent(0.25)  # => $75.00 (25% off)
+price.discount("25%")         # => $75.00 (parses string)
+price.discount("$20")         # => $80.00 (parses string)
+price.discount(20)            # => $80.00 (numeric = dollars)
+
+# Chain discounts
+price = Superfeature::Price.new(100.00)
+  .discount_percent(0.10)  # 10% off = $90
+  .discount_fixed(5.0)     # $5 off = $85
+
+# Read discount info
+price.amount           # => 85.0
+price.original.amount  # => 90.0 (previous price in chain)
+price.fixed_discount   # => 5.0 (dollars saved from last discount)
+price.percent_discount # => 0.0556 (percent saved from last discount)
+price.discounted?      # => true
+```
+
+### Displaying discounts in views
+
+```erb
+<% if price.discounted? %>
+  <span class="original-price line-through">$<%= price.original.to_formatted_s %></span>
+  <span class="sale-price">$<%= price.to_formatted_s %></span>
+  <span class="savings"><%= (price.percent_discount * 100).to_i %>% off!</span>
+<% else %>
+  <span class="price">$<%= price.to_formatted_s %></span>
+<% end %>
+```
+
+### Custom precision
+
+```ruby
+# Configure precision for currency and percentages
+price = Superfeature::Price.new(99.999, amount_precision: 3, percent_precision: 6)
+price.to_formatted_s  # => "99.999"
+```
+
 ## Comparable libraries
 
 There's a few pretty great feature flag libraries that are worth mentioning so you can better evaluate what's right for you.
@@ -126,4 +393,4 @@ Roll-out is similar to Flipper, but is backed soley by Redis.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/generators/superfeature/install/install_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators'
+
+module Superfeature
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_plans_directory
+        empty_directory "app/plans"
+        empty_directory "app/plans/features"
+      end
+
+      def copy_base_plan
+        template "base.rb", "app/plans/base.rb"
+      end
+
+      def copy_features_base
+        template "features/base.rb", "app/plans/features/base.rb"
+      end
+
+      def copy_plans
+        template "free.rb", "app/plans/free.rb"
+        template "paid.rb", "app/plans/paid.rb"
+      end
+
+      def create_initializer
+        template "plans_initializer.rb", "config/initializers/plans.rb"
+      end
+    end
+  end
+end

data/lib/generators/superfeature/install/templates/base.rb

@@ -0,0 +1,26 @@
+module Plans
+  class Base < Superfeature::Plan
+    attr_reader :user
+
+    def initialize(user)
+      @user = user
+    end
+
+    # Boolean features - simple on/off flags
+    # feature def priority_support = disable("Priority support", group: "Support")
+    # feature def phone_support = disable("Phone support", group: "Support")
+
+    # Hard limits - strict maximum that cannot be exceeded
+    # feature def api_calls = hard_limit("API calls", group: "Limits", quantity: user.api_calls_count, maximum: 1000)
+
+    # Soft limits - has a soft and hard boundary for overages
+    # feature def storage_gb = soft_limit("Storage", group: "Limits", quantity: user.storage_used_gb, soft_limit: 100, hard_limit: 150)
+
+    # Unlimited - no restrictions
+    # feature def projects = unlimited("Projects", group: "Limits", quantity: user.projects_count)
+
+    protected
+
+    def feature(...) = Features::Base.new(...)
+  end
+end

data/lib/generators/superfeature/install/templates/features/base.rb

@@ -0,0 +1,13 @@
+module Plans
+  module Features
+    class Base < Superfeature::Feature
+      attr_reader :name, :group
+
+      def initialize(name = nil, group: nil, **)
+        super(**)
+        @name = name
+        @group = group
+      end
+    end
+  end
+end

data/lib/generators/superfeature/install/templates/free.rb

@@ -0,0 +1,9 @@
+module Plans
+  class Free < Base
+    def name = "Free"
+    def price = 0
+    def description = "Get started for free"
+
+    def next = plan(Paid)
+  end
+end

data/lib/generators/superfeature/install/templates/paid.rb

@@ -0,0 +1,13 @@
+module Plans
+  class Paid < Free
+    def name = "Paid"
+    def price = 9.99
+    def description = "Full access to all features"
+
+    # Override features from Base to enable them
+    # def priority_support = super.enable
+
+    def next = nil
+    def previous = plan(Free)
+  end
+end

data/lib/generators/superfeature/install/templates/plans_initializer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Plans
+  module Features
+  end
+end
+
+Rails.autoloaders.main.push_dir(
+  Rails.root.join("app/plans"), namespace: Plans
+)

data/lib/generators/superfeature/plan/plan_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators'
+
+module Superfeature
+  module Generators
+    class PlanGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      def create_plan_file
+        template "plan.rb.tt", "app/plans/#{file_name}.rb"
+      end
+
+      private
+
+      def file_name
+        # Remove "_plan" suffix if provided
+        name = super
+        name.delete_suffix("_plan")
+      end
+
+      def class_name
+        # Remove "Plan" suffix if provided
+        name = super
+        name.delete_suffix("Plan")
+      end
+    end
+  end
+end

data/lib/generators/superfeature/plan/templates/plan.rb.tt

@@ -0,0 +1,14 @@
+module Plans
+  class <%= class_name %> < Base
+    def name = "<%= class_name %>"
+    def price = 0
+    def description = "Description for <%= class_name %> plan"
+
+    # Override features from Base to enable them
+    # def priority_support = super.enable
+
+    # Link to adjacent plans for navigation
+    # def next = plan(NextPlan)
+    # def previous = plan(PreviousPlan)
+  end
+end

data/lib/superfeature/feature.rb

@@ -0,0 +1,41 @@
+require "forwardable"
+
+module Superfeature
+  class Feature
+    extend Forwardable
+
+    attr_reader :limit
+    def_delegators :limit, :enabled?, :disabled?
+    def_delegators :limit, :quantity, :maximum, :remaining, :exceeded?
+
+    def initialize(limit: Limit::Base.new)
+      @limit = limit
+    end
+
+    def enable
+      @limit = Limit::Boolean.new(enabled: true)
+      self
+    end
+
+    def disable
+      @limit = Limit::Boolean.new(enabled: false)
+      self
+    end
+
+    def boolean?
+      limit.is_a?(Limit::Boolean)
+    end
+
+    def hard_limit?
+      limit.instance_of?(Limit::Hard)
+    end
+
+    def soft_limit?
+      limit.instance_of?(Limit::Soft)
+    end
+
+    def unlimited?
+      limit.is_a?(Limit::Unlimited)
+    end
+  end
+end

data/lib/superfeature/limit.rb

@@ -0,0 +1,66 @@
+module Superfeature
+  module Limit
+    class Base
+      def enabled?
+        false
+      end
+
+      def disabled?
+        not enabled?
+      end
+    end
+
+    class Hard < Base
+      attr_accessor :quantity, :maximum
+
+      def initialize(quantity: , maximum: )
+        @quantity = quantity
+        @maximum = maximum
+      end
+
+      def remaining
+        maximum - quantity
+      end
+
+      def exceeded?
+        quantity > maximum if quantity and maximum
+      end
+
+      def enabled?
+        not exceeded?
+      end
+    end
+
+    class Soft < Hard
+      attr_accessor :soft_limit, :hard_limit
+
+      def initialize(quantity:, soft_limit:, hard_limit:)
+        @quantity = quantity
+        @soft_limit = soft_limit
+        @hard_limit = hard_limit
+      end
+
+      def maximum
+        @soft_limit
+      end
+    end
+
+    class Unlimited < Soft
+      INFINITY = Float::INFINITY
+
+      def initialize(quantity: nil, hard_limit: INFINITY, soft_limit: INFINITY, **)
+        super(quantity:, hard_limit:, soft_limit:, **)
+      end
+    end
+
+    class Boolean < Base
+      def initialize(enabled:)
+        @enabled = enabled
+      end
+
+      def enabled?
+        @enabled
+      end
+    end
+  end
+end

data/lib/superfeature/plan/collection.rb

@@ -0,0 +1,71 @@
+module Superfeature
+  class Plan
+    class Collection
+      include Enumerable
+
+      def initialize(plan)
+        @plan = plan
+      end
+
+      def each(&)
+        return enum_for(:each) unless block_given?
+
+        downgrades.each(&)
+        yield @plan
+        upgrades.each(&)
+      end
+
+      def find(key)
+        key = normalize_key(key)
+        each.find { |p| p.key.to_s == key }
+      end
+
+      def slice(*keys)
+        keys.filter_map { |key| find(key) }
+      end
+
+      private
+
+      def next_plan
+        return nil unless @plan.class.method_defined?(:next, false)
+        @plan.next
+      end
+
+      def previous_plan
+        return nil unless @plan.class.method_defined?(:previous, false)
+        @plan.previous
+      end
+
+      def upgrades
+        Enumerator.new do |y|
+          node = @plan
+          while (node = node.class.method_defined?(:next, false) ? node.next : nil)
+            y << node
+          end
+        end
+      end
+
+      def downgrades
+        Enumerator.new do |y|
+          node = @plan
+          nodes = []
+          while (node = node.class.method_defined?(:previous, false) ? node.previous : nil)
+            nodes.unshift(node)
+          end
+          nodes.each { |n| y << n }
+        end
+      end
+
+      def normalize_key(key)
+        case key
+        when Class
+          key.name.demodulize.underscore
+        when Symbol
+          key.to_s
+        when String
+          key
+        end
+      end
+    end
+  end
+end

data/lib/superfeature/plan.rb

@@ -0,0 +1,62 @@
+module Superfeature
+  class Plan
+    class << self
+      def features
+        ((superclass.respond_to?(:features) ? superclass.features : []) + @features.to_a).uniq
+      end
+
+      def feature(method_name)
+        (@features ||= []) << method_name
+        method_name
+      end
+
+      def exclusively(method_name)
+        klass = self
+        original = instance_method(method_name)
+        define_method(method_name) do
+          original.bind(self).call if instance_of?(klass)
+        end
+      end
+    end
+
+    def key
+      self.class.name.split("::").last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+    end
+
+    alias_method :to_param, :key
+
+    def features
+      self.class.features.map { |m| send(m) }
+    end
+
+    protected
+
+    def plan(klass)
+      klass.new(user)
+    end
+
+    def feature(*, **, &)
+      Feature.new(*, **, &)
+    end
+
+    def enable(*, **)
+      feature(*, **, limit: Limit::Boolean.new(enabled: true))
+    end
+
+    def disable(*, **)
+      feature(*, **, limit: Limit::Boolean.new(enabled: false))
+    end
+
+    def hard_limit(*, quantity:, maximum:, **)
+      feature(*, **, limit: Limit::Hard.new(quantity:, maximum:))
+    end
+
+    def soft_limit(*, quantity:, soft_limit:, hard_limit:, **)
+      feature(*, **, limit: Limit::Soft.new(quantity:, soft_limit:, hard_limit:))
+    end
+
+    def unlimited(*, quantity: nil, **)
+      feature(*, **, limit: Limit::Unlimited.new(quantity:))
+    end
+  end
+end

data/lib/superfeature/price.rb

@@ -0,0 +1,97 @@
+module Superfeature
+  # Convenience method for creating Price objects.
+  # Use Superfeature::Price(100) or after `include Superfeature`, just Price(100)
+  def Price(amount, **options)
+    Price.new(amount, **options)
+  end
+  module_function :Price
+  public :Price
+
+  class Price
+    DEFAULT_AMOUNT_PRECISION = 2
+    DEFAULT_PERCENT_PRECISION = 4
+
+    attr_reader :amount, :original, :amount_precision, :percent_precision
+
+    def initialize(amount, original: nil, amount_precision: DEFAULT_AMOUNT_PRECISION, percent_precision: DEFAULT_PERCENT_PRECISION)
+      @amount = amount.to_f
+      @original = original
+      @amount_precision = amount_precision
+      @percent_precision = percent_precision
+    end
+
+    # Apply a discount by parsing the input:
+    # - "25%" → 25% off
+    # - "$20" → $20 off
+    # - 20 → $20 off (numeric = always dollars)
+    def discount(value)
+      case value
+      # Matches: "25%", "10.5%", "100 %"
+      when /\A(\d+(?:\.\d+)?)\s*%\z/
+        discount_percent($1.to_f / 100)
+      # Matches: "$20", "$ 20", "20", "19.99", "$19.99"
+      when /\A\$?\s*(\d+(?:\.\d+)?)\z/
+        discount_fixed($1.to_f)
+      when Numeric
+        discount_fixed(value)
+      else
+        raise ArgumentError, "Invalid discount format: #{value.inspect}"
+      end
+    end
+
+    # Apply a fixed dollar discount
+    def discount_fixed(amount)
+      new_amount = ([@amount - amount.to_f, 0].max).round(@amount_precision)
+      Price.new(new_amount, original: self, amount_precision: @amount_precision, percent_precision: @percent_precision)
+    end
+
+    # Apply a percentage discount (decimal, e.g., 0.25 for 25%)
+    def discount_percent(percent)
+      discount_amount = @amount * percent.to_f
+      new_amount = (@amount - discount_amount).round(@amount_precision)
+      Price.new(new_amount, original: self, amount_precision: @amount_precision, percent_precision: @percent_precision)
+    end
+
+    # Dollars saved from original price
+    def fixed_discount
+      return 0.0 unless @original
+      (@original.amount - @amount).round(@amount_precision)
+    end
+
+    # Percent saved as decimal (e.g., 0.25 for 25%)
+    def percent_discount
+      return 0.0 unless @original
+      return 0.0 if @original.amount.zero?
+      ((@original.amount - @amount) / @original.amount).round(@percent_precision)
+    end
+
+    def discounted?
+      !@original.nil?
+    end
+
+    def full_price
+      @original ? @original.amount : @amount
+    end
+
+    # Format amount as string with configured precision
+    def to_formatted_s
+      "%.#{@amount_precision}f" % @amount
+    end
+
+    def to_f
+      @amount
+    end
+
+    def to_s
+      @amount.to_s
+    end
+
+    def inspect
+      if discounted?
+        "#<Price #{to_formatted_s} (was #{@original.to_formatted_s}, #{(percent_discount * 100).round(1)}% off)>"
+      else
+        "#<Price #{to_formatted_s}>"
+      end
+    end
+  end
+end

data/lib/superfeature/version.rb

@@ -1,3 +1,3 @@
 module Superfeature
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/superfeature.rb

@@ -1,123 +1,10 @@
 require "superfeature/version"
-require "superfeature/engine"
+require "superfeature/engine" if defined?(Rails)
+require "superfeature/limit"
+require "superfeature/feature"
+require "superfeature/plan"
+require "superfeature/plan/collection"
+require "superfeature/price"
 
 module Superfeature
-  def self.plan(&)
-    Class.new(Superfeature::Plan, &)
-  end
-
-  class Feature
-    attr_reader :plan, :limit, :name
-    delegate :enabled?, :disabled?, to: :limit
-    delegate :upgrade, :downgrade, to: :plan
-
-    def initialize(plan:, name:, limit: Limit::Base.new)
-      @plan = plan
-      @limit = limit
-      @name = name
-    end
-  end
-
-  module Limit
-    class Base
-      def enabled?
-        false
-      end
-
-      def disabled?
-        not enabled?
-      end
-    end
-
-    class Hard < Base
-      attr_accessor :quantity, :maximum
-
-      def initialize(quantity: , maximum: )
-        @quantity = quantity
-        @maximum = maximum
-      end
-
-      def remaining
-        maximum - quantity
-      end
-
-      def exceeded?
-        quantity > maximum if quantity and maximum
-      end
-
-      def enabled?
-        not exceeded?
-      end
-    end
-
-    class Soft < Hard
-      attr_accessor :quantity, :soft_limit, :hard_limit
-
-      def initialize(quantity:, soft_limit:, hard_limit:)
-        @quantity = quantity
-        @soft_limit = soft_limit
-        @hard_limit = hard_limit
-      end
-
-      def maximum
-        @soft_limit
-      end
-    end
-
-    # Unlimited is treated like a Soft, initialized with infinity values.
-    # It is recommended to set a `soft_limit` value based on the technical limitations
-    # of your application unless you're running a theoritcal Turing Machine.
-    #
-    # See https://en.wikipedia.org/wiki/Turing_machine for details.
-    class Unlimited < Soft
-      INFINITY = Float::INFINITY
-
-      def initialize(quantity: nil, hard_limit: INFINITY, soft_limit: INFINITY, **)
-        super(quantity:, hard_limit:, soft_limit:, **)
-      end
-    end
-
-    class Boolean < Base
-      def initialize(enabled:)
-        @enabled = enabled
-      end
-
-      def enabled?
-        @enabled
-      end
-    end
-  end
-
-  class Plan
-    def upgrade
-    end
-
-    def downgrade
-    end
-
-    protected
-      def hard_limit(**)
-        Limit::Hard.new(**)
-      end
-
-      def soft_limit(**)
-        Limit::Soft.new(**)
-      end
-
-      def unlimited(**)
-        Limit::Unlimited.new(**)
-      end
-
-      def enabled(value = true, **)
-        Limit::Boolean.new enabled: value, **
-      end
-
-      def disabled(value = true)
-        enabled !value
-      end
-
-      def feature(name, **)
-        Feature.new(plan: self, name:, **)
-      end
-  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: superfeature
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Brad Gessler
 bindir: bin
 cert_chain: []
-date: 2025-10-11 00:00:00.000000000 Z
+date: 2026-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -44,8 +44,21 @@ files:
 - app/models/superfeature/application_record.rb
 - app/views/layouts/superfeature/application.html.erb
 - config/routes.rb
+- lib/generators/superfeature/install/install_generator.rb
+- lib/generators/superfeature/install/templates/base.rb
+- lib/generators/superfeature/install/templates/features/base.rb
+- lib/generators/superfeature/install/templates/free.rb
+- lib/generators/superfeature/install/templates/paid.rb
+- lib/generators/superfeature/install/templates/plans_initializer.rb
+- lib/generators/superfeature/plan/plan_generator.rb
+- lib/generators/superfeature/plan/templates/plan.rb.tt
 - lib/superfeature.rb
 - lib/superfeature/engine.rb
+- lib/superfeature/feature.rb
+- lib/superfeature/limit.rb
+- lib/superfeature/plan.rb
+- lib/superfeature/plan/collection.rb
+- lib/superfeature/price.rb
 - lib/superfeature/version.rb
 - lib/tasks/superfeature_tasks.rake
 homepage: https://github.com/rubymonolith/superfeature