stall 0.1.1 → 0.1.2

data/lib/generators/stall/service/templates/service.rb.erb

@@ -0,0 +1,16 @@
+class <%= service_class_name %> < Stall::<%= service_class_name %>
+  # The call call method is the entry point for the service to process the data
+  # it was given at initialization
+  #
+  # Many overrides would want to call `super` to let the service do its
+  # classical job, then do something depending on the success or failure of
+  # the original work. This pattern is shown below.
+  #
+  # def call
+  #   if super
+  #     # Do something when it worked
+  #   else
+  #     # Do something when it didn't
+  #   end
+  # end
+end

data/lib/generators/stall/shipping/calculator/calculator_generator.rb

@@ -0,0 +1,17 @@
+module Stall
+  module Shipping
+    class CalculatorGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_calculator_template
+        template 'calculator.rb.erb', "lib/#{ file_path }.rb"
+      end
+
+      def register_calculator_in_initializer
+        insert_into_file "config/initializers/stall.rb", after: "Stall.configure do |config|\n" do
+          indent "config.shipping.register_calculator :#{ singular_name }, #{ class_name }\n"
+        end
+      end
+    end
+  end
+end

data/lib/generators/stall/shipping/calculator/templates/calculator.rb.erb

@@ -0,0 +1,29 @@
+class <%= class_name %> < Stall::Shipping::Calculator
+  # Use this method to handle the related shipping method availibility depending
+  # on the cart data available to the calculator
+  #
+  def available?
+    true
+  end
+
+  # Write your logic here and return the price for the current cart
+  #
+  # You can access `cart` and `shipping_method` (the model) here.
+  #
+  def price
+    0
+  end
+
+  # Allows you to override how calculator's eot_price price is calculated
+  #
+  # def eot_price
+  #   price / (1 + (vat_rate / 100.0))
+  # end
+
+  # Allows you to override the VAT for the calculator which allows calculating
+  # the EOT price
+  #
+  # def vat_rate
+  #   Stall.config.vat_rate
+  # end
+end

data/lib/stall.rb

@@ -5,6 +5,7 @@ require 'request_store'
 require 'haml-rails'
 require 'simple_form'
 require 'country_select'
+require 'cocoon'
 
 require 'stall/rails/routing_mapper'
 require 'stall/rails/currency_helper'
@@ -15,12 +16,15 @@ module Stall
 
   autoload :Sellable
   autoload :Addressable
+  autoload :Priceable
+  autoload :Payable
 
   autoload :Checkout
   autoload :Shipping
   autoload :Payments
 
   autoload :Routes
+  autoload :CartHelper
   autoload :Config
   autoload :Utils
 

data/lib/stall/addressable.rb

@@ -6,7 +6,9 @@ module Stall
     extend ActiveSupport::Concern
 
     included do
-      has_many :address_ownerships, as: :addressable, dependent: :destroy
+      has_many :address_ownerships, as: :addressable, dependent: :destroy,
+                                    inverse_of: :addressable
+
       has_many :addresses, through: :address_ownerships
       accepts_nested_attributes_for :address_ownerships, allow_destroy: true
     end
@@ -26,7 +28,16 @@ module Stall
       define_method(:"#{ type }_address=") do |address|
         ownership = address_ownership_for(type) || address_ownerships.build(type => true)
         ownership.address = address
-        ownership.save if persisted?
+        instance_variable_set(instance_variable_name, address)
+      end
+
+      define_method(:"build_#{ type }_address") do |attributes = {}|
+        if (ownership = address_ownership_for(type))
+          ownership.send(:"#{ type }=", false)
+        end
+
+        ownership = address_ownerships.build(type => true)
+        address = ownership.build_address(attributes)
         instance_variable_set(instance_variable_name, address)
       end
 
@@ -39,6 +50,21 @@ module Stall
           instance_variable_set(instance_variable_name, ownership.address)
         end
       end
+
+      define_method(:"#{ type }_address_attributes=") do |attributes|
+        attributes.delete(:id)
+
+        ownership = address_ownership_for(type) || address_ownerships.build(type => true)
+        address = ownership.address || ownership.build_address
+        address.assign_attributes(attributes)
+        instance_variable_set(instance_variable_name, address)
+      end
+
+      define_method(:"mark_address_ownership_as_#{ type }") do |ownership|
+        ownership.send(:"mark_as_#{ type }").tap do
+          instance_variable_set(instance_variable_name, ownership.address)
+        end
+      end
     end
   end
 end

data/lib/stall/cart_helper.rb

@@ -0,0 +1,84 @@
+module Stall
+  module CartHelper
+    extend ActiveSupport::Concern
+
+    included do
+      if respond_to?(:helper_method)
+        helper_method :current_cart, :current_cart_key
+      end
+
+      if respond_to?(:after_action)
+        after_action :store_cart_to_cookies
+      end
+    end
+
+    def current_cart
+      RequestStore.store[cart_key] ||= load_current_cart
+    end
+
+    protected
+
+    def current_cart_key
+      params[:cart_key].try(:to_sym) || :default
+    end
+
+    def load_current_cart(identifier = current_cart_key)
+      if (cart = find_cart(identifier))
+        return prepare_cart(cart)
+      end
+
+      # If no token was stored or the token does not exist anymore, create a
+      # new cart and store the new token
+      #
+      prepare_cart(cart_class.new(identifier: identifier))
+    end
+
+    def prepare_cart(cart)
+      cart.tap do |cart|
+        # Keep track of potential customer locale switching to allow e-mailing
+        # him in his last used locale
+        cart.customer.locale = I18n.locale if cart.customer
+
+        # Only update locale change for existing carts. New carts don't need
+        # to be saved, avoiding each robot or simple visitors to create a
+        # cart on large shops.
+        cart.save unless cart.new_record?
+      end
+    end
+
+    def find_cart(identifier)
+      if (cart_token = cookies.encrypted[cart_key(identifier)])
+        if (current_cart = ProductList.find_by_token(cart_token)) && current_cart.active?
+          return current_cart
+        else
+          # Remove any cart that can't be fetched, either because it's already
+          # paid, or because it was cleaned out
+          remove_cart_from_cookies(identifier)
+          nil
+        end
+      end
+    end
+
+    def remove_cart_from_cookies(identifier = current_cart_key)
+      cookies.delete(cart_key(identifier))
+    end
+
+    def cart_key(identifier = current_cart_key)
+      ['stall', 'cart', identifier.to_s].join('.')
+    end
+
+    def cart_class
+      Cart
+    end
+
+    def store_cart_to_cookies
+      if current_cart.persisted?
+        store_cart_cookie_for(current_cart.identifier, current_cart)
+      end
+    end
+
+    def store_cart_cookie_for(identifier, cart)
+      cookies.encrypted.permanent[cart_key(identifier)] = cart.token
+    end
+  end
+end

data/lib/stall/carts_cleaner.rb

@@ -0,0 +1,46 @@
+module Stall
+  class CartsCleaner
+    attr_reader :cart_model
+
+    def initialize(cart_model)
+      @cart_model = cart_model
+    end
+
+    def clean!
+      clean_empty_carts
+      clean_aborted_carts
+    end
+
+    private
+
+    # Empty carts are cleaned with a .delete_all call for optimization.
+    #
+    # Empty carts should not need to run destroy callbacks, not being related to
+    # any external model.
+    #
+    def clean_empty_carts
+      carts = cart_model.empty.older_than(Stall.config.empty_carts_expires_after.ago)
+
+      log "Cleaning #{ carts.count } empty carts ..."
+      carts.delete_all
+      log "Done."
+    end
+
+    # Unpaid carts have line items and other models related. Since empty carts
+    # are already cleaned, there should not be too many carts to destroy here
+    # and we can safely use .destroy_all to deeply clean carts.
+    #
+    # Note : The given cart model should implement the `.unpaid` method
+    def clean_aborted_carts
+      carts = cart_model.aborted(before: Stall.config.aborted_carts_expires_after.ago)
+
+      log "Cleaning #{ carts.count } aborted carts ..."
+      carts.destroy_all
+      log "Done."
+    end
+
+    def log(*args)
+      puts(*args) unless Rails.env.test?
+    end
+  end
+end

data/lib/stall/checkout.rb

@@ -4,11 +4,13 @@ module Stall
 
     autoload :Wizard
     autoload :Step
+    autoload :StepForm
 
     autoload :InformationsCheckoutStep
     autoload :ShippingMethodCheckoutStep
     autoload :PaymentMethodCheckoutStep
     autoload :PaymentCheckoutStep
+    autoload :PaymentReturnCheckoutStep
 
     class WizardNotFoundError < StandardError; end
   end

data/lib/stall/checkout/informations_checkout_step.rb

@@ -10,7 +10,7 @@ module Stall
       def process
         cart.assign_attributes(cart_params)
         process_addresses
-        cart.save!
+        cart.save if valid?
       end
 
       private
@@ -20,10 +20,8 @@ module Stall
       end
 
       def ensure_address(type)
-        unless cart.address_ownership_for(type)
-          ownership = cart.address_ownerships.build(type => true)
-          ownership.build_address
-        end
+        ownership = cart.address_ownership_for(type) || cart.address_ownerships.build(type => true)
+        ownership.address || ownership.build_address
       end
 
       def process_addresses

data/lib/stall/checkout/payment_checkout_step.rb

@@ -1,6 +1,9 @@
 module Stall
   module Checkout
     class PaymentCheckoutStep < Stall::Checkout::Step
+      def process
+        return true if params[:succeeded]
+      end
     end
   end
 end

data/lib/stall/checkout/payment_return_checkout_step.rb

@@ -0,0 +1,11 @@
+module Stall
+  module Checkout
+    class PaymentReturnCheckoutStep < Stall::Checkout::Step
+      include Stall::CartHelper
+
+      def prepare
+        remove_cart_from_cookies(cart.identifier)
+      end
+    end
+  end
+end

data/lib/stall/checkout/shipping_method_checkout_step.rb

@@ -13,7 +13,8 @@ module Stall
       private
 
       def calculate_shipping_fee!
-        Stall::ShippingFeeCalculatorService.new(cart).call
+        service_class = Stall.config.service_for(:shipping_fee_calculator)
+        service_class.new(cart).call
       end
     end
   end

data/lib/stall/checkout/step.rb

@@ -3,11 +3,10 @@ module Stall
     class StepNotFoundError < StandardError; end
 
     class Step
-      attr_reader :cart, :params
+      attr_reader :cart
 
-      def initialize(cart, params)
+      def initialize(cart)
         @cart = cart
-        @params = params
       end
 
       # Allow injecting dependencies on step initialization and accessing
@@ -25,32 +24,69 @@ module Stall
       end
 
       def process
-        cart.update_attributes(cart_params)
+        save
       end
 
       def cart_params
-        @cart_params ||= params.require(:cart).permit!
+        @cart_params ||= if params[:cart]
+          params.require(:cart).permit!
+        else
+          {}.with_indifferent_access
+        end
       end
 
       def skip?
         false
       end
 
+      def is?(key)
+        identifier == key
+      end
+
+      def identifier
+        @identifier ||= begin
+          class_name = self.class.name.demodulize
+          class_name.gsub(/CheckoutStep$/, '').underscore.to_sym
+        end
+      end
+
+      # Abstracts the simple case of assigning the submitted parameters to the
+      # cart object, running the step validations and saving the cart
+      def save
+        cart.assign_attributes(cart_params)
+        cart.save if valid?
+      end
+
       # Handles conversion from an identifier to a checkout step class, allowing
       # us to specify a list of symbols in our wizard's .step macro
       #
       def self.for(identifier)
         name = identifier.to_s.camelize
         step_name = [name, 'CheckoutStep'].join
+        # Try loading step from app
+        step = Stall::Utils.try_load_constant(step_name)
+        # Try loading step from stall core or lib if not found in app
+        step = Stall::Utils.try_load_constant(
+          ['Stall', 'Checkout', step_name.demodulize].join('::')
+        ) unless step
+
+        unless step
+          raise StepNotFoundError,
+            "No checkout step was found for #{ identifier }. You can generate " +
+            "it with `rails g stall:checkout:step #{ identifier }`"
+        end
 
-        step = Stall::Utils.try_load_constant(step_name) ||
-          Stall::Utils.try_load_constant(['Stall', 'Checkout', step_name.demodulize].join('::'))
+        step
+      end
 
-        return step if step
+      def self.validations(&block)
+        return @validations unless block
+        @validations = Stall::Checkout::StepForm.build(&block)
+      end
 
-        raise StepNotFoundError,
-          "No checkout step was found for #{ identifier }. You can generate " +
-          "it with `rails g stall:checkout:step #{ identifier }`"
+      def valid?
+        return true unless (validations = self.class.validations)
+        validations.new(cart, self).validate
       end
     end
   end

data/lib/stall/checkout/step_form.rb

@@ -0,0 +1,71 @@
+module Stall
+  module Checkout
+    class StepForm
+      include ActiveModel::Validations
+
+      class_attribute :nested_forms
+
+      attr_reader :object, :step
+
+      delegate :errors, to: :object
+
+      def initialize(object, step)
+        @object = object
+        @step = step
+      end
+
+      def validate
+        super && validate_nested_forms
+      end
+
+      def self.nested(type, &block)
+        self.nested_forms ||= {}
+        nested_forms[type] = build(&block)
+      end
+
+      def self.build(&block)
+        Class.new(StepForm, &block)
+      end
+
+      def method_missing(method, *args, &block)
+        if object.respond_to?(method, true)
+          object.send(method, *args, &block)
+        elsif step.respond_to?(method, true)
+          step.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      # Override model name instanciation to add a name, since the form classes
+      # are anonymous, and ActiveModel::Name does not support unnamed classes
+      def model_name
+        @model_name ||= ActiveModel::Name.new(self, nil, object.class.name)
+      end
+
+      private
+
+      # Validates all registered nested forms
+      #
+      # Note : We use `forms.map.all?` instead if `forms.all?` to ensure
+      # all the validations are called and the iteration does not stop as soon
+      # as a validation fails
+      #
+      def validate_nested_forms
+        # If no nested forms are present in the class, just return true since
+        # no validation should be tested
+        return true unless self.class.nested_forms
+
+        # Run all validations on all nested forms and ensure they're all valid
+        self.class.nested_forms.map do |name, form|
+          if object.respond_to?(name) && (model = object.send(name))
+            Array.wrap(model).map { |m| form.new(m, step).validate }.all?
+          else
+            # Nested validations shouldn't be run on undefined relations
+            true
+          end
+        end.all?
+      end
+    end
+  end
+end