superfeature 0.1.4 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1cb9113e0c87858b70dfd215f524b9359baf10cf69d51fbcadf5e80010e3929
-  data.tar.gz: 0c1b5ad5c8068a211300431b3e881fd164ef04dedc54ba9da4c263108145cdfe
+  metadata.gz: 49aa8d4e0fec4908fb0ef75f2775154ed4824e79565ffde44f39ccbf723f0e7f
+  data.tar.gz: e9e7e20b7eb9c9ac39baeeb68d1311ccad33b843e88270b0cefd7fc023ac251a
 SHA512:
-  metadata.gz: da1075eb85dfb9fa91f73ba8fc07c095997ddfa762599da8484ba546e07b64973c33dabe911151f86a5b10513cd52390828154dfde631bc2fff99b82945674eb
-  data.tar.gz: fa0bea7dda490f95f9be6fa2736858b526ba2247254d74e22b9f8986e9e42b78cb7d1de534833076045ae2dc3f72b0a92d0dd489522177c0a1c32838ac80cd4f
+  metadata.gz: 865e638f07b0667a2bfe1eec952877489f75fa8e5dfdf891289fa559de9dae9dab421d71929962bca15c12525ecb8626a8daaa46223803302d455621db1d15c5
+  data.tar.gz: '08b0e605470738e1be904119b2e1db03fb1b413b386b3cc19ebfb53e0e710f2e7db23d7f0e276302d1a3b9b596ae85e99c3f891f68e3c650a75f489755882519'

data/README.md

@@ -301,6 +301,10 @@ module Plans
 
     # Override features from Base to enable them
     # def priority_support = super.enable
+    #
+    # Conditionally enable/disable based on a boolean:
+    # def dark_mode = super.enable(user.premium?)
+    # def legacy_feature = super.disable(user.migrated?)
 
     # Link to adjacent plans for navigation
     # def next = plan NextPlan
@@ -366,6 +370,56 @@ price = Superfeature::Price.new(99.999, amount_precision: 3, percent_precision:
 price.to_formatted_s  # => "99.999"
 ```
 
+### Discount objects
+
+For more control, use typed Discount objects directly:
+
+```ruby
+# Fixed dollar discount
+Superfeature::Discount::Fixed(20)     # $20 off
+
+# Percentage discount
+Superfeature::Discount::Percent(25)   # 25% off
+Superfeature::Discount::Percent(10.5) # 10.5% off
+
+# Bundle multiple discounts (note: splat args, not array)
+Superfeature::Discount::Bundle(
+  Superfeature::Discount::Fixed(5),
+  Superfeature::Discount::Percent(20)
+)
+```
+
+Or with `include Superfeature`:
+
+```ruby
+include Superfeature
+
+Price(100).discount(Percent(25))
+Price(100).discount(Fixed(20))
+Price(100).discount(Bundle(Fixed(5), Percent(20)))
+```
+
+### Custom discount sources with `to_discount`
+
+Any object can be passed to `Price#discount` if it implements `to_discount`:
+
+```ruby
+class Promotion < ApplicationRecord
+  def to_discount
+    Superfeature::Discount::Percent.new(percent_off)
+  end
+end
+
+promo = Promotion.find(1)
+price = Superfeature::Price.new(100).discount(promo)
+
+price.amount          # => discounted amount
+price.discount_source # => the Promotion instance
+price.discount_source.name # => access promotion metadata
+```
+
+This allows rich domain objects (promotions, deals, coupons) to be used directly with Price while preserving access to their metadata via `discount_source`.
+
 ## 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.

data/lib/superfeature/discount.rb

@@ -0,0 +1,44 @@
+module Superfeature
+  module Discount
+    class Base
+      def to_discount = self
+    end
+
+    class Fixed < Base
+      attr_reader :amount
+
+      def initialize(amount)
+        @amount = amount
+      end
+
+      def apply(price) = price - amount
+    end
+
+    class Percent < Base
+      attr_reader :percent
+
+      def initialize(percent)
+        @percent = percent
+      end
+
+      def apply(price) = price * (1 - percent / 100.0)
+    end
+
+    class Bundle < Base
+      attr_reader :discounts
+
+      def initialize(*discounts)
+        @discounts = discounts.flatten
+      end
+
+      def apply(price)
+        discounts.reduce(price) { |amt, d| d.to_discount.apply(amt) }
+      end
+    end
+
+    # Convenience methods: Discount::Fixed(20) instead of Discount::Fixed.new(20)
+    def self.Fixed(amount) = Fixed.new(amount)
+    def self.Percent(percent) = Percent.new(percent)
+    def self.Bundle(...) = Bundle.new(...)
+  end
+end

data/lib/superfeature/feature.rb

@@ -12,14 +12,13 @@ module Superfeature
       @limit = limit
     end
 
-    def enable
-      @limit = Limit::Boolean.new(enabled: true)
+    def enable(value = true)
+      @limit = Limit::Boolean.new(enabled: value)
       self
     end
 
-    def disable
-      @limit = Limit::Boolean.new(enabled: false)
-      self
+    def disable(value = true)
+      enable(!value)
     end
 
     def boolean?

data/lib/superfeature/plan.rb

@@ -39,8 +39,8 @@ module Superfeature
       Feature.new(*, **, &)
     end
 
-    def enable(*, **)
-      feature(*, **, limit: Limit::Boolean.new(enabled: true))
+    def enable(flag = true, *, **)
+      feature(*, **, limit: Limit::Boolean.new(enabled: flag))
     end
 
     def disable(*, **)

data/lib/superfeature/price.rb

@@ -11,38 +11,39 @@ module Superfeature
     DEFAULT_AMOUNT_PRECISION = 2
     DEFAULT_PERCENT_PRECISION = 4
 
-    attr_reader :amount, :original, :amount_precision, :percent_precision
+    attr_reader :amount, :original, :discount_source, :amount_precision, :percent_precision
 
-    def initialize(amount, original: nil, amount_precision: DEFAULT_AMOUNT_PRECISION, percent_precision: DEFAULT_PERCENT_PRECISION)
+    def initialize(amount, original: nil, discount_source: nil, amount_precision: DEFAULT_AMOUNT_PRECISION, percent_precision: DEFAULT_PERCENT_PRECISION)
       @amount = amount.to_f
       @original = original
+      @discount_source = discount_source
       @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
+    # Apply a discount from various sources:
+    # - String: "25%" → 25% off, "$20" → $20 off
+    # - Numeric: 20 → $20 off
+    # - Discount object: Discount::Percent.new(25) → 25% off
+    # - Any object responding to to_discount
+    # - nil: no discount, returns self
+    def discount(source)
+      return self if source.nil?
+      
+      discount_obj = coerce_discount(source)
+      new_amount = [discount_obj.apply(@amount), 0].max.round(@amount_precision)
+
+      Price.new(new_amount,
+        original: self,
+        discount_source: source,
+        amount_precision: @amount_precision,
+        percent_precision: @percent_precision
+      )
     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)
+      discount(Discount::Fixed.new(amount.to_f))
     end
 
     # Set the price to a specific amount (calculates discount from current amount)
@@ -53,9 +54,7 @@ module Superfeature
 
     # 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)
+      discount(Discount::Percent.new(percent.to_f * 100))
     end
 
     # Dollars saved from original price
@@ -99,5 +98,26 @@ module Superfeature
         "#<Price #{to_formatted_s}>"
       end
     end
+
+    private
+
+    def coerce_discount(source)
+      case source
+      when String then parse_discount_string(source)
+      when Numeric then Discount::Fixed.new(source)
+      else source.to_discount
+      end
+    end
+
+    def parse_discount_string(str)
+      case str
+      when /\A(\d+(?:\.\d+)?)\s*%\z/
+        Discount::Percent.new($1.to_f)
+      when /\A\$?\s*(\d+(?:\.\d+)?)\z/
+        Discount::Fixed.new($1.to_f)
+      else
+        raise ArgumentError, "Invalid discount format: #{str.inspect}"
+      end
+    end
   end
 end

data/lib/superfeature/version.rb

@@ -1,3 +1,3 @@
 module Superfeature
-  VERSION = "0.1.4"
+  VERSION = "0.1.7"
 end

data/lib/superfeature.rb

@@ -4,7 +4,15 @@ require "superfeature/limit"
 require "superfeature/feature"
 require "superfeature/plan"
 require "superfeature/plan/collection"
+require "superfeature/discount"
 require "superfeature/price"
 
 module Superfeature
-end
+  # Convenience methods for creating Discount objects.
+  # Use Superfeature::Fixed(20) or after `include Superfeature`, just Fixed(20)
+  def Fixed(...) = Discount::Fixed.new(...)
+  def Percent(...) = Discount::Percent.new(...)
+  def Bundle(...) = Discount::Bundle.new(...)
+  module_function :Fixed, :Percent, :Bundle
+  public :Fixed, :Percent, :Bundle
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: superfeature
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.7
 platform: ruby
 authors:
 - Brad Gessler
 bindir: bin
 cert_chain: []
-date: 2026-01-05 00:00:00.000000000 Z
+date: 2026-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -53,6 +53,7 @@ files:
 - lib/generators/superfeature/plan/plan_generator.rb
 - lib/generators/superfeature/plan/templates/plan.rb.tt
 - lib/superfeature.rb
+- lib/superfeature/discount.rb
 - lib/superfeature/engine.rb
 - lib/superfeature/feature.rb
 - lib/superfeature/limit.rb