paid_up 0.11.7 → 0.12.3

data/lib/paid_up/feature.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 # PaidUp module
 module PaidUp
-  @@feature_object = {}
+  @feature_object = {}
 
   def self.add_feature(params)
     feature = PaidUp::Feature.new(params)
-    @@feature_object[feature.slug.to_sym] = feature
+    @feature_object[feature.slug.to_sym] = feature
   end
 
   def self.features
-    @@feature_object
+    @feature_object
   end
 
   # Feature Class: Not an ActiveRecord object.
@@ -45,7 +47,7 @@ module PaidUp
     end
 
     def feature_model_name
-      acceptable_setting_types = %w( table_rows rolify_rows )
+      acceptable_setting_types = %w(table_rows rolify_rows)
       unless acceptable_setting_types.include? setting_type
         raise :no_implicit_conversion_of_type_features.l(type: setting_type)
       end
@@ -60,6 +62,10 @@ module PaidUp
       raw[slug.to_sym]
     end
 
+    def self.find_by_slug!(slug)
+      find_by_slug(slug) || raise(:feature_not_found.l)
+    end
+
     def self.all
       raw.values
     end
@@ -80,10 +86,7 @@ module PaidUp
       find_all(conditions).first
     end
 
-    # Define on self, since it's  a class method
     def self.method_missing(method_sym, *arguments, &block)
-      # the first argument is a Symbol, so you need to_s it if you want to
-      # pattern match
       if method_sym.to_s =~ /^find_by_(.*)$/
         find(Regexp.last_match[1].to_sym => arguments.first)
       elsif method_sym.to_s =~ /^find_all_by_(.*)$/

data/lib/paid_up/feature_setting_type.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# PaidUp module
+module PaidUp
+  # Feature Setting Type Class: Not an ActiveRecord object.
+  class FeatureSettingType
+    include ActiveModel::Model
+    include ActiveModel::AttributeMethods
+
+    attr_accessor :name, :user
+    delegate :plan, to: :user
+
+    def rows_unlimited?
+      rows_allowed == PaidUp::Unlimited.to_i
+    end
+
+    def rows_remaining
+      rows_allowed - rows_count
+    end
+
+    def rows_allowed
+      plan.feature_setting name
+    end
+
+    def rows
+      scope.where(user: user)
+    end
+
+    def ids
+      rows.ids
+    end
+
+    def rows_count
+      rows.size
+    end
+
+    def model
+      name.classify.constantize
+    end
+
+    def scope
+      model.paid_for_scope
+    end
+  end
+end

data/lib/paid_up/feature_setting_types/rolify.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module PaidUp
+  # Class for 'rolify_rows' feature setting type
+  class RolifyFeatureSettingType < FeatureSettingType
+    def rows
+      scope.with_role(:owner, user)
+    end
+  end
+end

data/lib/paid_up/feature_setting_types/table.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PaidUp
+  # Class for 'table_rows' feature setting type
+  class TableFeatureSettingType < FeatureSettingType
+  end
+end

data/lib/paid_up/localization.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # String Extension
 module StringExtension
   def localize(*args)

data/lib/paid_up/mixins/paid_for.rb

@@ -1,5 +1,13 @@
+# frozen_string_literal: true
+
 module PaidUp
   module Mixins
+    ASSOCIATION_METHODS = {
+      rolify_rows: :associations_for_rolify_rows,
+      table_rows: :associations_for_table_rows,
+      boolean: :true
+    }.freeze
+
     # PaidFor Mixin
     module PaidFor
       extend ActiveSupport::Concern
@@ -7,41 +15,53 @@ module PaidUp
       def paid_for(options = {})
         cattr_accessor :paid_for_scope_symbol # Creates class-level instance var
 
-        send :extend, ClassMethods
-        send :include, InstanceMethods
+        extend ClassMethods
+        include InstanceMethods
 
         self.paid_for_scope_symbol = options.fetch(:scope, :all)
-        feature.nil? && raise(
-          :feature_not_found_feature.l(feature: table_name)
-        )
-        case feature.setting_type
-        when 'boolean'
-          # Nothing needs doing
-        when 'rolify_rows'
-          resourcify
-          attr_accessor :owner
-        when 'table_rows'
-          belongs_to :user
-          User.has_many table_name.to_sym
-        else
-          raise(
-            :value_is_not_a_valid_setting_type.l(
-              value: feature.setting_type
-            )
-          )
-        end
+
+        validate_feature
+        associations
       end
 
+      # Extended by paid_for mixin
       module ClassMethods
         def feature
           PaidUp::Feature.find_by_slug(table_name)
         end
 
         def paid_for_scope
-          send(self.paid_for_scope_symbol)
+          send(paid_for_scope_symbol)
+        end
+
+        private
+
+        def validate_feature
+          return true unless feature.nil?
+          raise(:feature_not_found_feature.l(feature: table_name))
+        end
+
+        def associations
+          setting_type = feature.setting_type
+          method = ASSOCIATION_METHODS[setting_type.to_sym] ||
+                   raise(
+                     :value_is_not_a_valid_setting_type.l(value: setting_type)
+                   )
+          send(method)
+        end
+
+        def associations_for_rolify_rows
+          resourcify
+          attr_accessor :owner
+        end
+
+        def associations_for_table_rows
+          belongs_to :user
+          User.has_many table_name.to_sym
         end
       end
 
+      # Included by paid_for mixin
       module InstanceMethods
         def owners
           case self.class.feature.setting_type
@@ -71,40 +91,32 @@ module PaidUp
         end
 
         def owners_records
-          ids = []
-          owners.each do |subscriber|
-            case self.class.feature.setting_type
-            when 'table_rows'
-              ids += subscriber.send(self.class.table_name)
-              .paid_for_scope
-              .ids
-            when 'rolify_rows'
-              ids += self.class
-              .with_role(:owner, subscriber)
-              .paid_for_scope
-              .ids
-            else
-              raise(
-                :no_features_associated_with_table.l(
-                  table: self.class.table_name
-                )
-              )
-            end
+          self.class.where(id: owners_records_ids)
+        end
+
+        def owners_records_ids
+          setting = self.class.feature.setting_type
+                        .gsub('_rows', '_setting')
+          table_name = self.class.table_name
+          unless %w(table_setting rolify_setting).include? setting
+            raise :no_features_associated_with_table.l(table: table_name)
           end
-          self.class.where(id: ids)
+          owners.map do |subscriber|
+            subscriber.send(setting, table_name).ids
+          end.flatten
         end
 
         def owners_records_count
-          owners_records.count
+          owners_records.size
         end
 
-        def enabled
+        def enabled?
           if owners_enabled_count >= owners_records_count
             true
           else
-            enabled_records = owners_records.order('created_at ASC')
-            .limit(owners_enabled_count)
-            enabled_records.include? self
+            owners_records.order(id: :asc)
+                          .limit(owners_enabled_count)
+                          .include? self
           end
         end
       end

data/lib/paid_up/mixins/subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PaidUp
   module Mixins
     # Subscriber Mixin
@@ -10,12 +12,15 @@ module PaidUp
           has_many feature.slug.to_sym
         end
 
+        delegate :plan, to: :paid_up_subscription
         after_initialize :set_default_attributes, :load_stripe_data
+        after_save :load_stripe_data
         before_save :remove_anonymous_association
         before_destroy { |record| record.stripe_data.delete }
-        send :include, InstanceMethods
+        include InstanceMethods
       end
 
+      # Included by subscriber mixin
       module InstanceMethods
         def reload(*args, &blk)
           super(*args, &blk)
@@ -31,144 +36,71 @@ module PaidUp
           stripe_data.present? && stripe_data.sources.all(object: 'card')
         end
 
-        def subscribe_to_plan(plan_to_set, stripe_token = nil, trial_end = nil)
+        def subscribe_to_plan(
+          new_plan, stripe_token = nil, coupon = nil, trial_end = nil
+        )
           # If there is an existing subscription
-          if stripe_id.present? && !subscription.nil?
-            if stripe_token.present? # The customer has entered a new card
-              subscription.source = stripe_token
-              subscription.save
-              reload
-            end
-            if coupon_code.present?
-              stripe_data.coupon = coupon_code
-              stripe_data.save
-            end
-            if trial_end.present?
-              stripe_data.subscription.trial_end = trial_end
-              stripe_data.subscription.save
-            end
-            subscription.plan = plan_to_set.stripe_id
-            result = subscription.save ||
-              (raise(:could_not_update_subscription.l) && false)
+          if stripe_id.present? && paid_up_subscription.present?
+            paid_up_subscription.update(new_plan, stripe_token, coupon, trial_end)
           else # Totally new subscription
-            args = {
-              source: stripe_token,
-              plan: plan_to_set.stripe_id,
-              email: email,
-              trial_end: trial_end
-            }
-            coupon_code.present? && args[:coupon] = coupon_code
-            customer = Stripe::Customer.create(args) ||
-              (raise(:could_not_create_subscription.l) && false)
-
-            # If there is an update to be made, we go ahead
-            if stripe_id != customer.id
-              result = update_attributes(stripe_id: customer.id) ||
-                (raise(:could_not_associate_subscription.l) && false)
-            else
-              result = true
-            end
+            paid_up_subscription.create(new_plan, stripe_token, coupon, trial_end)
           end
-          result && Rails.cache.delete("#{stripe_id}/stripe_data") && reload
+          Rails.cache.delete("#{stripe_id}/stripe_data")
+          reload
         end
 
         def subscribe_to_free_plan
           subscribe_to_plan PaidUp::Plan.free
         end
 
-        def plan
-          if subscription.present?
-            PaidUp::Plan.find_by_stripe_id(subscription.plan.id)
-          else
-            PaidUp::Plan.free
-          end
-        end
-
-        def table_rows_unlimited?(table_name)
-          table_rows_allowed(table_name) == PaidUp::Unlimited.to_i
-        end
-
-        def table_rows_remaining(table_name)
-          table_rows_allowed(table_name) - table_rows(table_name)
-        end
-
-        def table_rows_allowed(table_name)
-          plan.feature_setting table_name
-        end
-
-        def table_rows(table_name)
-          model = table_name.classify.constantize
-          model.where(user: self).paid_for_scope.size
-        end
-
-        def rolify_rows_unlimited?(table_name)
-          rolify_rows_allowed(table_name) == PaidUp::Unlimited.to_i
-        end
-
-        def rolify_rows_remaining(table_name)
-          rolify_rows_allowed(table_name) - rolify_rows(table_name)
+        def table_setting(table_name)
+          PaidUp::TableFeatureSettingType.new(name: table_name, user: self)
         end
 
-        def rolify_rows_allowed(table_name)
-          plan.feature_setting table_name
-        end
-
-        def rolify_rows(table_name)
-          model = table_name.classify.constantize
-          model.with_role(:owner, self).paid_for_scope.size
+        def rolify_setting(table_name)
+          PaidUp::RolifyFeatureSettingType.new(name: table_name, user: self)
         end
 
         def plan_stripe_id
-          subscription.nil? && return
-          subscription.plan.id
+          paid_up_subscription&.stripe_data&.plan&.id
         end
 
-        def subscription
+        def paid_up_subscription
           stripe_data.nil? && subscribe_to_free_plan
-          stripe_data.subscriptions.data.first
+          @subscription
         end
 
-        def is_subscribed_to?(plan_to_check)
+        def subscribed_to?(plan_to_check)
           plan.present? && plan.id == plan_to_check.id
         end
 
         def can_upgrade_to?(plan_to_check)
           plan.nil? || (
-            !is_subscribed_to?(plan_to_check) &&
+            !subscribed_to?(plan_to_check) &&
             (plan_to_check.sort_order.to_i > plan.sort_order.to_i)
           )
         end
 
         def can_downgrade_to?(plan_to_check)
-          !plan.nil? && (
-            !is_subscribed_to?(plan_to_check) &&
+          plan.present? && (
+            !subscribed_to?(plan_to_check) &&
             (plan_to_check.sort_order.to_i < plan.sort_order.to_i)
           )
         end
 
         def using_free_plan?
-          plan.nil? ||
-            stripe_data.delinquent ||
-            (plan.stripe_id == PaidUp.configuration.free_plan_stripe_id)
+          plan.nil? || stripe_data.delinquent ||
+            plan.stripe_id == PaidUp.configuration.free_plan_stripe_id
         end
 
         private
 
         def set_default_attributes
-          if new_record?
-            self.stripe_id = PaidUp.configuration.anonymous_customer_stripe_id
-          end
+          return unless new_record?
+          self.stripe_id = PaidUp.configuration.anonymous_customer_stripe_id
         end
 
         def load_stripe_data
-          working_stripe_id = if new_record?
-            PaidUp.configuration
-            .anonymous_customer_stripe_id
-          else
-            !stripe_id.present? && subscribe_to_free_plan
-            stripe_id
-          end
-
           @customer_stripe_data = Rails.cache.fetch(
             "#{working_stripe_id}/stripe_data",
             expires_in: 12.hours
@@ -176,14 +108,26 @@ module PaidUp
             Stripe::Customer.retrieve working_stripe_id
           end
 
-          @customer_stripe_data.nil? && raise(:could_not_load_subscription.l)
+          @subscription = PaidUp::Subscription.new(user: self)
+
+          raise(:could_not_load_subscription.l) if @customer_stripe_data.nil?
+          stripe_data
         end
 
-        def remove_anonymous_association
-          if stripe_id == PaidUp.configuration.anonymous_customer_stripe_id
-            self.stripe_id = nil
+        def working_stripe_id
+          if new_record?
+            PaidUp.configuration.anonymous_customer_stripe_id
+          else
+            subscribe_to_free_plan unless stripe_id.present?
+            stripe_id
           end
         end
+
+        def remove_anonymous_association
+          return unless stripe_id ==
+                        PaidUp.configuration.anonymous_customer_stripe_id
+          self.stripe_id = nil
+        end
       end
     end
   end

data/lib/paid_up/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PaidUp
   class Railtie < Rails::Railtie
   end

data/lib/paid_up/ruby_version_check.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION < '2.3.0' && RUBY_ENGINE == 'ruby'
+  desc = if defined?(RUBY_DESCRIPTION)
+           RUBY_DESCRIPTION
+         else
+           "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+         end
+  abort <<-end_message
+    This version of PaidUp requires Ruby 2.3.0 or newer.
+    You're running
+      #{desc}
+    Please upgrade to Ruby 2.3.0 or newer to continue.
+  end_message
+end

data/lib/paid_up/subscription.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# PaidUp module
+module PaidUp
+  # Subscription Class: Not an ActiveRecord object.
+  class Subscription
+    include ActiveModel::Model
+    include ActiveModel::AttributeMethods
+
+    attr_accessor :stripe_data, :user
+    delegate :status, :trial_start, :trial_end, :current_period_start,
+             :current_period_end, :cancel_at_period_end, to: :stripe_data
+    delegate :email, :stripe_id, to: :user
+
+    def initialize(args)
+      super args
+      self.stripe_data = user.stripe_data.subscriptions.first
+    end
+
+    def plan
+      if stripe_data&.plan&.id.present?
+        PaidUp::Plan.find_by_stripe_id(stripe_data.plan.id)
+      else
+        PaidUp::Plan.free
+      end
+    end
+
+    def update(plan, stripe_token = nil, coupon = nil, trial_end = nil)
+      update_stripe_token(stripe_token)
+      update_coupon(coupon)
+      update_trial_end(trial_end)
+      update_plan(plan)
+      stripe_data.save || raise(:could_not_update_plan.l)
+    end
+
+    def create(plan, stripe_token = nil, coupon = nil, trial_end = nil)
+      customer = Stripe::Customer.create(source: stripe_token, email: email,
+                                         plan: plan.stripe_id, coupon: coupon,
+                                         trial_end: trial_end) ||
+                 raise(:could_not_create_subscription.l)
+
+      # If there is an update to be made, we go ahead
+      return true if stripe_id == customer.id
+      user.update_attributes(stripe_id: customer.id) ||
+        raise(:could_not_associate_subscription.l)
+    end
+
+    private
+
+    def update_stripe_token(stripe_token)
+      return unless stripe_token.present?
+      # The customer has entered a new card
+      # We need to update the info on the Stripe API.
+      stripe_data.source = stripe_token
+    end
+
+    def update_coupon(coupon)
+      return unless coupon.present?
+      # The customer has entered a new coupon code
+      # We need to update the stripe customer.
+      stripe_data.coupon = coupon
+    end
+
+    def update_trial_end(trial_end)
+      return unless trial_end.present?
+      # The customer has cancelled or otherwise altered their trial_end
+      # We need to update the info on the Stripe API.
+      # stripe_data.stripe_data.trial_end = trial_end
+      # stripe_data.stripe_data.save!
+      stripe_data.trial_end = trial_end
+    end
+
+    def update_plan(new_plan)
+      return unless new_plan.present?
+      # The customer has changed plans
+      # We need to update the info on the Stripe API.
+      stripe_data.plan = new_plan.stripe_id
+    end
+  end
+end

data/lib/paid_up/validators/rolify_rows.rb

@@ -1,17 +1,22 @@
+# frozen_string_literal: true
+
 module PaidUp
   module Validators
     # RolifyRows Validator
     class RolifyRows < ActiveModel::Validator
       def validate(record)
+        found_in = options[:found_in]
         if record.send(options[:field]) == options[:comparison] &&
-           !ActiveRecord::Base.connection.table_exists?(
-             record.send(options[:found_in])
-           )
-          record.errors[
-            options[:found_in]
-          ] << :when_using_rolify_rows_table_must_exist.l
+           !found_in_valid?(record, found_in)
+          record.errors[found_in] << :when_using_rolify_rows_table_must_exist.l
         end
       end
+
+      def found_in_valid?(record, found_in)
+        ActiveRecord::Base.connection.data_source_exists?(
+          record.send(found_in)
+        )
+      end
     end
   end
 end

data/lib/paid_up/validators/table_rows.rb

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 module PaidUp
   module Validators
     # Table Rows validator
     class TableRows < ActiveModel::Validator
       def validate(record)
+        found_in = options[:found_in]
         if record.send(options[:field]) == options[:comparison] &&
-           !ActiveRecord::Base.connection.table_exists?(
-             record.send(options[:found_in])
-           )
-          record.errors[
-            options[:found_in]
-          ] << :when_using_table_rows_table_must_exist.l
+           !found_in_valid?(record, found_in)
+          record.errors[found_in] << :when_using_table_rows_table_must_exist.l
         end
       end
+
+      def found_in_valid?(record, found_in)
+        ActiveRecord::Base.connection.data_source_exists? record.send(found_in)
+      end
     end
   end
 end

data/lib/paid_up/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # PaidUp module
 module PaidUp
   VERSION = File.read(File.expand_path('../../../VERSION', __FILE__))

data/lib/paid_up.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # PaidUp Module
 module PaidUp
   require 'active_record/railtie'
@@ -18,10 +20,13 @@ module PaidUp
 
   require 'paid_up/configuration'
   require 'paid_up/feature'
+  require 'paid_up/feature_setting_type'
+  require 'paid_up/subscription'
   require 'paid_up/railtie'
   require 'paid_up/engine'
   require 'paid_up/localization'
   require 'paid_up/version'
+  require 'paid_up/ruby_version_check'
 
   require 'paid_up/extensions/stripe'
   require 'paid_up/extensions/integer'
@@ -29,6 +34,9 @@ module PaidUp
   require 'paid_up/mixins/subscriber'
   require 'paid_up/mixins/paid_for'
 
+  require 'paid_up/feature_setting_types/table'
+  require 'paid_up/feature_setting_types/rolify'
+
   require 'haml-rails'
   require 'bootstrap_leather'