reji 1.0.0 → 1.1.0

data/lib/reji/concerns/manages_invoices.rb

@@ -6,64 +6,61 @@ module Reji
 
     # Add an invoice item to the customer's upcoming invoice.
     def tab(description, amount, options = {})
-      self.assert_customer_exists
+      assert_customer_exists
 
       options = {
-        :customer => self.stripe_id,
-        :amount => amount,
-        :currency => self.preferred_currency,
-        :description => description,
+        customer: stripe_id,
+        amount: amount,
+        currency: preferred_currency,
+        description: description,
       }.merge(options)
 
-      Stripe::InvoiceItem.create(options, self.stripe_options)
+      Stripe::InvoiceItem.create(options, stripe_options)
     end
 
     # Invoice the customer for the given amount and generate an invoice immediately.
     def invoice_for(description, amount, tab_options = {}, invoice_options = {})
-      self.tab(description, amount, tab_options)
+      tab(description, amount, tab_options)
 
-      self.invoice(invoice_options)
+      invoice(invoice_options)
     end
 
     # Invoice the billable entity outside of the regular billing cycle.
     def invoice(options = {})
-      self.assert_customer_exists
-
-      parameters = options.merge({:customer => self.stripe_id})
+      assert_customer_exists
 
       begin
-        stripe_invoice = Stripe::Invoice.create(parameters, self.stripe_options)
+        stripe_invoice = Stripe::Invoice.create(options.merge({ customer: stripe_id }), stripe_options)
 
-        if stripe_invoice.collection_method == 'charge_automatically'
-          stripe_invoice = stripe_invoice.pay
-        else
-          stripe_invoice = stripe_invoice.send_invoice
-        end
+        stripe_invoice =
+          if stripe_invoice.collection_method == 'charge_automatically'
+            stripe_invoice.pay
+          else
+            stripe_invoice.send_invoice
+          end
 
         Invoice.new(self, stripe_invoice)
-      rescue Stripe::InvalidRequestError => e
+      rescue Stripe::InvalidRequestError => _e
         false
-      rescue Stripe::CardError => e
-        payment = Payment.new(
+      rescue Stripe::CardError => _e
+        Payment.new(
           Stripe::PaymentIntent.retrieve(
-            {:id => stripe_invoice.payment_intent, :expand => ['invoice.subscription']},
-            self.stripe_options
+            { id: stripe_invoice.payment_intent, expand: ['invoice.subscription'] },
+            stripe_options
           )
-        )
-
-        payment.validate
+        ).validate
       end
     end
 
     # Get the entity's upcoming invoice.
     def upcoming_invoice
-      return unless self.has_stripe_id
+      return unless stripe_id?
 
       begin
-        stripe_invoice = Stripe::Invoice.upcoming({:customer => self.stripe_id}, self.stripe_options)
+        stripe_invoice = Stripe::Invoice.upcoming({ customer: stripe_id }, stripe_options)
 
         Invoice.new(self, stripe_invoice)
-      rescue Stripe::InvalidRequestError => e
+      rescue Stripe::InvalidRequestError => _e
         #
       end
     end
@@ -73,8 +70,8 @@ module Reji
       stripe_invoice = nil
 
       begin
-        stripe_invoice = Stripe::Invoice.retrieve(id, self.stripe_options)
-      rescue => e
+        stripe_invoice = Stripe::Invoice.retrieve(id, stripe_options)
+      rescue StandardError => _e
         #
       end
 
@@ -84,9 +81,9 @@ module Reji
     # Find an invoice or throw a 404 or 403 error.
     def find_invoice_or_fail(id)
       begin
-        invoice = self.find_invoice(id)
+        invoice = find_invoice(id)
       rescue InvalidInvoiceError => e
-        raise Reji::AccessDeniedHttpError.new(e.message)
+        raise Reji::AccessDeniedHttpError, e.message
       end
 
       raise ActiveRecord::RecordNotFound if invoice.nil?
@@ -96,33 +93,29 @@ module Reji
 
     # Create an invoice download response.
     def download_invoice(id, data, filename = nil)
-      invoice = self.find_invoice_or_fail(id)
+      invoice = find_invoice_or_fail(id)
 
       filename ? invoice.download_as(filename, data) : invoice.download(data)
     end
 
     # Get a collection of the entity's invoices.
     def invoices(include_pending = false, parameters = {})
-      return [] unless self.has_stripe_id
+      return [] unless stripe_id?
 
       invoices = []
 
-      parameters = {:limit => 24}.merge(parameters)
+      parameters = { limit: 24 }.merge(parameters)
 
       stripe_invoices = Stripe::Invoice.list(
-        {:customer => self.stripe_id}.merge(parameters),
-        self.stripe_options
+        { customer: stripe_id }.merge(parameters),
+        stripe_options
       )
 
       # Here we will loop through the Stripe invoices and create our own custom Invoice
       # instances that have more helper methods and are generally more convenient to
       # work with than the plain Stripe objects are. Then, we'll return the array.
-      unless stripe_invoices.nil?
-        stripe_invoices.data.each do |invoice|
-          if invoice.paid || include_pending
-            invoices << Invoice.new(self, invoice)
-          end
-        end
+      stripe_invoices&.data&.each do |invoice|
+        invoices << Invoice.new(self, invoice) if invoice.paid || include_pending
       end
 
       invoices
@@ -130,7 +123,7 @@ module Reji
 
     # Get an array of the entity's invoices.
     def invoices_include_pending(parameters = {})
-      self.invoices(true, parameters)
+      invoices(true, parameters)
     end
   end
 end

data/lib/reji/concerns/manages_payment_methods.rb

@@ -6,29 +6,29 @@ module Reji
 
     # Create a new SetupIntent instance.
     def create_setup_intent(options = {})
-      Stripe::SetupIntent.create(options, self.stripe_options)
+      Stripe::SetupIntent.create(options, stripe_options)
     end
 
     # Determines if the customer currently has a default payment method.
-    def has_default_payment_method
-      ! self.card_brand.blank?
+    def default_payment_method?
+      card_brand.present?
     end
 
     # Determines if the customer currently has at least one payment method.
-    def has_payment_method
-      ! self.payment_methods.empty?
+    def payment_method?
+      !payment_methods.empty?
     end
 
     # Get a collection of the entity's payment methods.
     def payment_methods(parameters = {})
-      return [] unless self.has_stripe_id
+      return [] unless stripe_id?
 
-      parameters = {:limit => 24}.merge(parameters)
+      parameters = { limit: 24 }.merge(parameters)
 
       # "type" is temporarily required by Stripe...
       payment_methods = Stripe::PaymentMethod.list(
-        {customer: self.stripe_id, type: 'card'}.merge(parameters),
-        self.stripe_options
+        { customer: stripe_id, type: 'card' }.merge(parameters),
+        stripe_options
       )
 
       payment_methods.data.map { |payment_method| PaymentMethod.new(self, payment_method) }
@@ -36,13 +36,13 @@ module Reji
 
     # Add a payment method to the customer.
     def add_payment_method(payment_method)
-      self.assert_customer_exists
+      assert_customer_exists
 
-      stripe_payment_method = self.resolve_stripe_payment_method(payment_method)
+      stripe_payment_method = resolve_stripe_payment_method(payment_method)
 
-      if stripe_payment_method.customer != self.stripe_id
+      if stripe_payment_method.customer != stripe_id
         stripe_payment_method = stripe_payment_method.attach(
-          {:customer => self.stripe_id}, self.stripe_options
+          { customer: stripe_id }, stripe_options
         )
       end
 
@@ -51,74 +51,64 @@ module Reji
 
     # Remove a payment method from the customer.
     def remove_payment_method(payment_method)
-      self.assert_customer_exists
+      assert_customer_exists
 
-      stripe_payment_method = self.resolve_stripe_payment_method(payment_method)
+      stripe_payment_method = resolve_stripe_payment_method(payment_method)
 
-      return if stripe_payment_method.customer != self.stripe_id
+      return if stripe_payment_method.customer != stripe_id
 
-      customer = self.as_stripe_customer
+      customer = as_stripe_customer
 
       default_payment_method = customer.invoice_settings.default_payment_method
 
-      stripe_payment_method.detach({}, self.stripe_options)
+      stripe_payment_method.detach({}, stripe_options)
 
       # If the payment method was the default payment method, we'll remove it manually...
-      if stripe_payment_method.id == default_payment_method
-        self.update({
-          :card_brand => nil,
-          :card_last_four => nil,
-        })
-      end
+      update({ card_brand: nil, card_last_four: nil }) if stripe_payment_method.id == default_payment_method
     end
 
     # Get the default payment method for the entity.
     def default_payment_method
-      return unless self.has_stripe_id
+      return unless stripe_id?
 
       customer = Stripe::Customer.retrieve({
-        :id => self.stripe_id,
-        :expand => [
+        id: stripe_id,
+        expand: [
           'invoice_settings.default_payment_method',
           'default_source',
-        ]
-      }, self.stripe_options)
-
-      if customer.invoice_settings.default_payment_method
-        return PaymentMethod.new(
-          self,
-          customer.invoice_settings.default_payment_method
-        )
-      end
+        ],
+      }, stripe_options)
 
       # If we can't find a payment method, try to return a legacy source...
-      customer.default_source
+      return customer.default_source unless customer.invoice_settings.default_payment_method
+
+      PaymentMethod.new(self, customer.invoice_settings.default_payment_method)
     end
 
     # Update customer's default payment method.
     def update_default_payment_method(payment_method)
-      self.assert_customer_exists
+      assert_customer_exists
 
-      customer = self.as_stripe_customer
+      customer = as_stripe_customer
 
-      stripe_payment_method = self.resolve_stripe_payment_method(payment_method)
+      stripe_payment_method = resolve_stripe_payment_method(payment_method)
 
       # If the customer already has the payment method as their default, we can bail out
       # of the call now. We don't need to keep adding the same payment method to this
       # model's account every single time we go through this specific process call.
       return if stripe_payment_method.id == customer.invoice_settings.default_payment_method
 
-      payment_method = self.add_payment_method(stripe_payment_method)
+      payment_method = add_payment_method(stripe_payment_method)
 
-      customer.invoice_settings = {:default_payment_method => payment_method.id}
+      customer.invoice_settings = { default_payment_method: payment_method.id }
 
       customer.save
 
       # Next we will get the default payment method for this user so we can update the
       # payment method details on the record in the database. This will allow us to
       # show that information on the front-end when updating the payment methods.
-      self.fill_payment_method_details(payment_method)
-      self.save
+      fill_payment_method_details(payment_method)
+      save
 
       payment_method
     end
@@ -129,17 +119,12 @@ module Reji
 
       if default_payment_method
         if default_payment_method.instance_of? PaymentMethod
-          self.fill_payment_method_details(
-            default_payment_method.as_stripe_payment_method
-          ).save
+          fill_payment_method_details(default_payment_method.as_stripe_payment_method).save
         else
-          self.fill_source_details(default_payment_method).save
+          fill_source_details(default_payment_method).save
         end
       else
-        self.update({
-          :card_brand => nil,
-          :card_last_four => nil,
-        })
+        update({ card_brand: nil, card_last_four: nil })
       end
 
       self
@@ -147,9 +132,9 @@ module Reji
 
     # Deletes the entity's payment methods.
     def delete_payment_methods
-      self.payment_methods.each { |payment_method| payment_method.delete }
+      payment_methods.each(&:delete)
 
-      self.update_default_payment_method_from_stripe
+      update_default_payment_method_from_stripe
     end
 
     # Find a PaymentMethod by ID.
@@ -157,18 +142,16 @@ module Reji
       stripe_payment_method = nil
 
       begin
-        stripe_payment_method = self.resolve_stripe_payment_method(payment_method)
-      rescue => e
+        stripe_payment_method = resolve_stripe_payment_method(payment_method)
+      rescue StandardError => _e
         #
       end
 
       stripe_payment_method ? PaymentMethod.new(self, stripe_payment_method) : nil
     end
 
-    protected
-
     # Fills the model's properties with the payment method from Stripe.
-    def fill_payment_method_details(payment_method)
+    protected def fill_payment_method_details(payment_method)
       if payment_method.type == 'card'
         self.card_brand = payment_method.card.brand
         self.card_last_four = payment_method.card.last4
@@ -178,7 +161,7 @@ module Reji
     end
 
     # Fills the model's properties with the source from Stripe.
-    def fill_source_details(source)
+    protected def fill_source_details(source)
       if source.instance_of? Stripe::Card
         self.card_brand = source.brand
         self.card_last_four = source.last4
@@ -191,11 +174,11 @@ module Reji
     end
 
     # Resolve a PaymentMethod ID to a Stripe PaymentMethod object.
-    def resolve_stripe_payment_method(payment_method)
+    protected def resolve_stripe_payment_method(payment_method)
       return payment_method if payment_method.instance_of? Stripe::PaymentMethod
 
       Stripe::PaymentMethod.retrieve(
-        payment_method, self.stripe_options
+        payment_method, stripe_options
       )
     end
   end

data/lib/reji/concerns/manages_subscriptions.rb

@@ -15,54 +15,54 @@ module Reji
 
     # Determine if the Stripe model is on trial.
     def on_trial(name = 'default', plan = nil)
-      return true if name == 'default' && plan.nil? && self.on_generic_trial
+      return true if name == 'default' && plan.nil? && on_generic_trial
 
       subscription = self.subscription(name)
 
-      return false unless subscription && subscription.on_trial
+      return false unless subscription&.on_trial
 
-      plan ? subscription.has_plan(plan) : true
+      plan ? subscription.plan?(plan) : true
     end
 
     # Determine if the Stripe model is on a "generic" trial at the model level.
     def on_generic_trial
-      !! self.trial_ends_at && self.trial_ends_at.future?
+      !!trial_ends_at && trial_ends_at.future?
     end
 
     # Determine if the Stripe model has a given subscription.
     def subscribed(name = 'default', plan = nil)
       subscription = self.subscription(name)
 
-      return false unless subscription && subscription.valid?
+      return false unless subscription&.valid?
 
-      plan ? subscription.has_plan(plan) : true
+      plan ? subscription.plan?(plan) : true
     end
 
     # Get a subscription instance by name.
     def subscription(name = 'default')
-      self.subscriptions
+      subscriptions
         .sort_by { |subscription| subscription.created_at.to_i }
         .reverse
         .find { |subscription| subscription.name == name }
     end
 
     # Determine if the customer's subscription has an incomplete payment.
-    def has_incomplete_payment(name = 'default')
+    def incomplete_payment?(name = 'default')
       subscription = self.subscription(name)
 
-      subscription ? subscription.has_incomplete_payment : false
+      subscription ? subscription.incomplete_payment? : false
     end
 
     # Determine if the Stripe model is actively subscribed to one of the given plans.
     def subscribed_to_plan(plans, name = 'default')
       subscription = self.subscription(name)
 
-      return false unless subscription && subscription.valid?
+      return false unless subscription&.valid?
 
       plans = [plans] unless plans.instance_of? Array
 
       plans.each do |plan|
-        return true if subscription.has_plan(plan)
+        return true if subscription.plan?(plan)
       end
 
       false
@@ -70,7 +70,7 @@ module Reji
 
     # Determine if the entity has a valid subscription on the given plan.
     def on_plan(plan)
-      self.subscriptions.any? { |subscription| subscription.valid && subscription.has_plan(plan) }
+      subscriptions.any? { |subscription| subscription.valid && subscription.plan?(plan) }
     end
 
     # Get the tax percentage to apply to the subscription.
@@ -80,7 +80,7 @@ module Reji
 
     # Get the tax rates to apply to the subscription.
     def tax_rates
-      {}
+      []
     end
 
     # Get the tax rates to apply to individual subscription items.