lib/pay/billable.rb in pay-2.3.1 vs lib/pay/billable.rb in pay-2.4.0

@@ -34,11 +34,11 @@
       self.processor_id = nil if processor_changed?
     end
 
     def customer
       check_for_processor
-      raise Pay::Error, "Email is required to create a customer" if email.nil?
+      raise Pay::Error, I18n.t("errors.email_required") if email.nil?
 
       customer = send("#{processor}_customer")
       update_card(card_token) if card_token.present?
       customer
     end
@@ -50,22 +50,22 @@
     def charge(amount_in_cents, options = {})
       check_for_processor
       send("create_#{processor}_charge", amount_in_cents, options)
     end
 
-    def subscribe(name: "default", plan: "default", **options)
+    def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
       check_for_processor
       send("create_#{processor}_subscription", name, plan, options)
     end
 
     def update_card(token)
       check_for_processor
       customer if processor_id.nil?
       send("update_#{processor}_card", token)
     end
 
-    def on_trial?(name: "default", plan: nil)
+    def on_trial?(name: Pay.default_product_name, plan: nil)
       return true if default_generic_trial?(name, plan)
 
       sub = subscription(name: name)
       return sub&.on_trial? if plan.nil?
 
@@ -79,26 +79,26 @@
     def processor_subscription(subscription_id, options = {})
       check_for_processor
       send("#{processor}_subscription", subscription_id, options)
     end
 
-    def subscribed?(name: "default", processor_plan: nil)
+    def subscribed?(name: Pay.default_product_name, processor_plan: nil)
       subscription = subscription(name: name)
 
       return false if subscription.nil?
       return subscription.active? if processor_plan.nil?
 
       subscription.active? && subscription.processor_plan == processor_plan
     end
 
-    def on_trial_or_subscribed?(name: "default", processor_plan: nil)
+    def on_trial_or_subscribed?(name: Pay.default_product_name, processor_plan: nil)
       on_trial?(name: name, plan: processor_plan) ||
         subscribed?(name: name, processor_plan: processor_plan)
     end
 
-    def subscription(name: "default")
-      subscriptions.for_name(name).last
+    def subscription(name: Pay.default_product_name)
+      subscriptions.loaded? ? subscriptions.reverse.detect { |s| s.name == name } : subscriptions.for_name(name).last
     end
 
     def invoice!(options = {})
       send("#{processor}_invoice!", options)
     end
@@ -121,17 +121,17 @@
 
     def paddle?
       processor == "paddle"
     end
 
-    def has_incomplete_payment?(name: "default")
+    def has_incomplete_payment?(name: Pay.default_product_name)
       subscription(name: name)&.has_incomplete_payment?
     end
 
     private
 
     def check_for_processor
-      raise StandardError, "No payment processor selected. Make sure to set the #{self.class.name}'s `processor` attribute to either 'stripe' or 'braintree'." unless processor
+      raise StandardError, I18n.t("errors.no_processor", class_name: self.class.name) unless processor
     end
 
     # Used for creating a Pay::Subscription in the database
     def create_subscription(subscription, processor, name, plan, options = {})
       options[:quantity] ||= 1