superfeature 0.1.7 → 0.1.8

data/lib/superfeature/discount.rb

@@ -1,44 +1,204 @@
+require 'bigdecimal'
+
 module Superfeature
+  # Discount types that can be applied to a Price.
+  #
+  #   Price(100).apply_discount(Discount::Percent.new(20))  # => 80
+  #   Price(100).apply_discount(Discount::Fixed.new(15))    # => 85
+  #
   module Discount
+    # Base class for all discount types
     class Base
+      # Allows any discount to be passed to apply_discount
       def to_discount = self
+
+      private
+
+      def to_decimal(value)
+        case value
+        when BigDecimal then value
+        when Float then BigDecimal(value, 15)
+        else BigDecimal(value.to_s)
+        end
+      end
+    end
+
+    # Wraps a discount after it's been applied to a price.
+    # Holds the computed savings (fixed and percent) for display.
+    class Applied
+      attr_reader :source, :fixed, :percent
+
+      def initialize(source, fixed:, percent:)
+        @source = source
+        @fixed = fixed
+        @percent = percent
+      end
+
+      def to_formatted_s = source.to_formatted_s
+      def to_receipt_s = source.to_receipt_s
+      def none? = false
+
+      def to_fixed_s(decimals: 2)
+        "%.#{decimals}f" % fixed.abs.to_f
+      end
+
+      def to_percent_s(decimals: 0)
+        decimals.zero? ? "#{percent.to_i}%" : "%.#{decimals}f%%" % percent.to_f
+      end
+
+      def amount
+        source.amount if source.respond_to?(:amount)
+      end
+    end
+
+    # Null object for when no discount is applied.
+    # Allows safe method chaining without nil checks.
+    class None
+      def source = nil
+      def fixed = BigDecimal("0")
+      def percent = BigDecimal("0")
+      def amount = nil
+      def to_formatted_s = ""
+      def to_receipt_s = "Discount"
+      def none? = true
+
+      def to_fixed_s(decimals: 2)
+        "%.#{decimals}f" % 0
+      end
+
+      def to_percent_s(decimals: 0)
+        decimals.zero? ? "0%" : "%.#{decimals}f%%" % 0
+      end
+    end
+
+    NONE = None.new.freeze
+
+    # Cumulative savings from original price
+    class Savings
+      attr_reader :fixed, :percent
+
+      def initialize(fixed:, percent:)
+        @fixed = fixed
+        @percent = percent
+      end
+
+      def to_fixed_s(decimals: 2)
+        "%.#{decimals}f" % fixed.abs.to_f
+      end
+
+      def to_percent_s(decimals: 0)
+        decimals.zero? ? "#{percent.abs.to_i}%" : "%.#{decimals}f%%" % percent.abs.to_f
+      end
+
+      def none?
+        fixed.zero?
+      end
+
+      def to_s
+        to_fixed_s
+      end
     end
 
+    # Fixed dollar amount discount (e.g., "$20 off your first month")
     class Fixed < Base
+      PATTERN = /\A\$?\s*(\d+(?:\.\d+)?)\z/
+
+      def self.parse(str)
+        str.match(PATTERN) { |m| new(BigDecimal(m.captures.first)) }
+      end
+
       attr_reader :amount
 
       def initialize(amount)
-        @amount = amount
+        @amount = to_decimal(amount)
       end
 
-      def apply(price) = price - amount
+      def to_formatted_s = @amount.to_i.to_s
+      def to_receipt_s = "%.2f off" % @amount.to_f
+
+      def apply(price)
+        to_decimal(price) - @amount
+      end
     end
 
+    # Percentage discount (e.g., "20% off annual plans")
     class Percent < Base
+      PATTERN = /\A(\d+(?:\.\d+)?)\s*%\z/
+
+      def self.parse(str)
+        str.match(PATTERN) { |m| new(BigDecimal(m.captures.first)) }
+      end
+
       attr_reader :percent
 
       def initialize(percent)
-        @percent = percent
+        @percent = to_decimal(percent)
       end
 
-      def apply(price) = price * (1 - percent / 100.0)
+      def to_formatted_s = "#{@percent.to_i}%"
+      def to_receipt_s = "#{@percent.to_i}% off"
+
+      def apply(price)
+        to_decimal(price) * (1 - @percent / 100)
+      end
     end
 
-    class Bundle < Base
-      attr_reader :discounts
+    # Rounding discounts.
+    # Rounds price to a specified ending like .99 or 9.
+    #
+    #   Round::Up.new(9).apply(50)      # => 59
+    #   Round::Down.new(9).apply(50)    # => 49
+    #   Round::Nearest.new(9).apply(50) # => 49
+    #
+    module Round
+      class Up < Base
+        attr_reader :ending
 
-      def initialize(*discounts)
-        @discounts = discounts.flatten
+        def initialize(ending)
+          @ending = to_decimal(ending)
+        end
+
+        def apply(price)
+          Superfeature::Round.new(@ending).up(price)
+        end
+
+        def to_formatted_s = "Round up"
+        def to_receipt_s = "Round up"
       end
 
-      def apply(price)
-        discounts.reduce(price) { |amt, d| d.to_discount.apply(amt) }
+      class Down < Base
+        attr_reader :ending
+
+        def initialize(ending)
+          @ending = to_decimal(ending)
+        end
+
+        def apply(price)
+          Superfeature::Round.new(@ending).down(price)
+        end
+
+        def to_formatted_s = "Round down"
+        def to_receipt_s = "Round down"
+      end
+
+      class Nearest < Base
+        attr_reader :ending
+
+        def initialize(ending)
+          @ending = to_decimal(ending)
+        end
+
+        def apply(price)
+          Superfeature::Round.new(@ending).nearest(price)
+        end
+
+        def to_formatted_s = "Round"
+        def to_receipt_s = "Round"
       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/engine.rb

@@ -1,5 +1,9 @@
 module Superfeature
   class Engine < ::Rails::Engine
     isolate_namespace Superfeature
+
+    initializer "superfeature.core_ext" do
+      require "superfeature/core_ext"
+    end
   end
 end

data/lib/superfeature/plan/collection.rb

@@ -24,22 +24,10 @@ module Superfeature
         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)
+          while (node = next_plan(node))
             y << node
           end
         end
@@ -49,13 +37,25 @@ module Superfeature
         Enumerator.new do |y|
           node = @plan
           nodes = []
-          while (node = node.class.method_defined?(:previous, false) ? node.previous : nil)
+          while (node = previous_plan(node))
             nodes.unshift(node)
           end
           nodes.each { |n| y << n }
         end
       end
 
+      private
+
+      def next_plan(node)
+        return nil unless node.class.method_defined?(:next, false)
+        node.next
+      end
+
+      def previous_plan(node)
+        return nil unless node.class.method_defined?(:previous, false)
+        node.previous
+      end
+
       def normalize_key(key)
         case key
         when Class

data/lib/superfeature/plan.rb

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