carter 0.5.5

data/lib/carter/controller_resource.rb

@@ -0,0 +1,79 @@
+module Carter
+  # Handle the load cart controller logic so we don't clutter up all controllers with non-interface methods.
+  # This class is used internally, so you do not need to call methods directly on it.
+  
+  class ControllerResource # :nodoc:
+    def self.add_before_filter(controller_class, method, *args)
+      options = args.extract_options!
+      resource_name = args.first
+      controller_class.before_filter(options.slice(:only, :except)) do |controller|
+        ControllerResource.new(controller, resource_name, options.except(:only, :except)).send(method)
+      end
+    end
+
+    def initialize(controller, *args)
+      @controller = controller
+      @params = controller.params
+      @session = controller.session
+      @options = args.extract_options!
+      @name = args.first
+    end
+
+    def load_cart
+      store_shopping_location if @controller.shopping? && !@controller.checking_out?
+      @controller.instance_variable_set("@cart", load_cart_instance)
+      @controller.instance_variable_set("@shopper", current_shopper)
+    end
+
+    def load_cart_for_checkout
+      @controller.instance_variable_set("@cart", load_cart_instance)
+      @controller.instance_variable_set("@shopper", current_shopper)
+    end
+    
+    private
+    
+    def load_cart_instance
+      find_cart_by_session || find_cart_by_shopper  || ::Cart.new
+    end
+
+    def member_action?
+      !collection_actions.include? @params[:action].to_sym
+    end
+    
+    def find_cart_by_shopper
+      ::Cart.with_state(default_cart_state).first(:conditions => {:shopper_id => current_shopper.id, :shopper_type => current_shopper.class.name} ) if current_shopper && Carter.settings.persist_by_shopper?
+    end
+    
+    def find_cart_by_session
+      ::Cart.with_state(default_cart_state).find_by_id(@session[:cart_id]) 
+    end
+    
+    def current_shopper
+      @controller.respond_to?(:current_user) ? @controller.send(:current_user) : nil
+    end
+    
+    def store_shopping_location
+      @session[:continue_shopping_url] = @controller.request.request_uri 
+    end
+    
+    def name
+      @name || name_from_controller
+    end
+
+    def name_from_controller
+      @params[:controller].sub("Controller", "").underscore.split('/').last.singularize
+    end
+
+    def collection_actions
+      [:index] + [@options[:collection]].flatten
+    end
+
+    def new_actions
+      [:new, :create] + [@options[:new]].flatten
+    end
+    
+    def default_cart_state
+      @options[:state] || :active
+    end
+  end
+end

data/lib/carter/engine.rb

@@ -0,0 +1,8 @@
+require 'carter'
+require 'rails'
+
+module Carter
+  class Engine < Rails::Engine
+  
+  end
+end

data/lib/carter/errors.rb

@@ -0,0 +1,2 @@
+require 'carter/errors/multiple_cart_items_not_allowed'
+require 'carter/errors/setup_error'

data/lib/carter/errors/multiple_cart_items_not_allowed.rb

@@ -0,0 +1,5 @@
+module Carter
+  class MultipleCartItemsNotAllowed < StandardError
+    
+  end
+end

data/lib/carter/errors/setup_error.rb

@@ -0,0 +1,5 @@
+module Carter
+  class SetupError < StandardError
+    
+  end
+end

data/lib/carter/initializer.rb

@@ -0,0 +1,61 @@
+module Carter
+  class << self
+    # The Settings instance used to configure the Carter environment
+    def settings
+      @@settings
+    rescue
+      raise SetupError, "You must create the Carter settings using the Carter::Initializer.setup method"
+    end
+    
+    def settings=(settings)
+      @@settings = settings
+    end
+    
+  end
+  
+  class Initializer
+    attr_reader :settings
+    
+    def initialize(settings)
+      @settings = settings
+    end
+    
+    # setup any defaults in here.
+    def process
+      Carter.settings = settings
+    end
+      
+    class << self
+      
+      # This is useful if you only want the load path initialized, without
+      # incurring the overhead of completely loading the entire environment.
+      def setup(command = :process, settings = Settings.new)
+        yield settings if block_given?
+        initializer = new settings
+        initializer.send(command)
+        initializer
+      end
+
+    end
+  end
+  
+  class Settings
+    attr_accessor :persist_by_shopper
+    attr_accessor :on_checkout
+    attr_accessor :on_failed
+    attr_accessor :cartables
+    attr_accessor :default_currency
+    attr_accessor :payment_method
+    
+    def persist_by_shopper?
+      @persist_by_shopper
+    end
+
+    
+    def initialize
+      self.cartables = []
+    end
+    
+  end
+     
+end

data/lib/carter/routing.rb

@@ -0,0 +1,11 @@
+module Carter #:nodoc:
+  module Routing #:nodoc:
+    module MapperExtensions
+      def carter_routes(options={})
+        self.resources :carts
+        self.resources :cart_items
+        
+      end
+    end
+  end
+end

data/lib/carter/state_machine.rb

@@ -0,0 +1,81 @@
+require 'state_machine'
+module Carter
+  module StateMachine
+    module Cart
+      def self.included(base)
+        base.extend ClassMethods
+        base.init_states        
+      end
+      
+      module ClassMethods
+        def init_states
+          
+          state_machine :state, :initial => :active do
+            state :active, :processing, :failure, :success, :expired
+            
+            event :checkout do 
+              transition [:active, :failure] => :processing
+            end
+          
+            event :succeeded do
+              transition :processing => :success
+            end
+          
+            event :failed do
+              transition :processing => :failure
+            end
+          
+            event :expire do
+              transition :active => :expired
+            end
+            
+            after_transition :on => :succeeded, :do => :on_success # gateway says yes - to what is needed to add the products to the buyer.
+            
+            # +checkout hook+ - probably goes off to payment gateway.
+            # expects another transition to be made in here to continue the cart lifecycle
+            # possible actions are `cart.failed`, `cart.succeeded` for now that should do it.
+            after_transition :on => :checkout, :do => :on_checkout 
+            after_transition :on => :failed, :do => :on_failed
+          end
+        end
+      end
+    end
+    
+    module CartItem
+      def self.included(base)
+        base.extend ClassMethods
+        base.send(:include, InstanceMethods)
+        base.init_states        
+      end
+      
+      module ClassMethods
+        def init_states
+          
+          state_machine :state, :initial => :in_cart do
+            state :in_cart, :processing, :failure, :purchased
+            event :add_to_owner do 
+              transition [:in_cart] => :processing
+            end
+          
+            event :succeeded do
+              transition :processing => :purchased
+            end
+          
+            event :failed do
+              transition :processing => :failure
+            end
+            
+            after_transition :on => :add_to_owner, :do => :on_purchase
+          end
+        end
+      end
+      
+      module InstanceMethods        
+        def on_purchase
+          self.cartable.send(self.cartable.after_purchase_method, self) if self.cartable.after_purchase_method
+        end
+      end
+      
+    end
+  end
+end

data/lib/tasks/carter.rake

@@ -0,0 +1,13 @@
+namespace :carter do
+  desc "cleans up expired carts - default is 30 days old but this can be changed by entering the command line argument days=60"
+  task :clear_expired_carts => :environment do
+    days = (ENV['days'] || 30).to_i.days
+
+    count = Cart.remove_carts(days)
+    
+    
+    puts "#{count} carts deleted."
+  end
+  
+
+end

data/rails/init.rb

@@ -0,0 +1,7 @@
+if defined?(Rails)
+  require 'carter/engine' if Rails::VERSION::MAJOR == 3
+  ActiveRecord::Base.extend Carter::ActiveRecord::Cartable if defined?(ActiveRecord)
+  require 'carter/routing'
+  ActionController::Routing::RouteSet::Mapper.send :include, Carter::Routing::MapperExtensions
+end
+

data/spec/active_record/cart_item_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe CartItem do
+  before(){ Product.acts_as_cartable }
+  it {should belong_to :cart}
+  it {should belong_to :cartable }
+  it {should belong_to :owner }
+
+  describe "named scopes" do
+    let(:owner_1) { Factory(:user) }
+    let(:product_1){ Factory(:product) }
+    let(:product_2){ Factory(:product) }
+    let(:cart) { Factory(:cart) }
+    
+    before(:each){
+      cart.add_item(product_1)
+      cart.add_item(product_1, 1, owner_1)
+      cart.add_item(product_2, 1, owner_1)
+    }
+    
+    it "should find the cart_item by product and owner" do
+      cart.cart_items.for_cartable_and_owner(product_2, owner_1).size.should == 1
+      cart.cart_items.for_cartable_and_owner(product_2, owner_1).first.cartable.should == product_2
+      cart.cart_items.for_cartable_and_owner(product_2, owner_1).first.owner.should == owner_1
+    end
+    
+    it "should find the cart_item by product and owner is blank" do
+      cart.cart_items.for_cartable_and_owner(product_2, nil).size.should == 0
+      cart.cart_items.for_cartable_and_owner(product_1, nil).size.should == 1
+      cart.cart_items.for_cartable_and_owner(product_1, nil).first.cartable.should == product_1
+      cart.cart_items.for_cartable_and_owner(product_1, nil).first.owner.should == nil
+    end
+    
+    it "should find the cart_items by product" do
+      cart.cart_items.for_cartable(product_1).size.should == 2
+      cart.cart_items.for_cartable(product_1).first.cartable.should == product_1
+      cart.cart_items.for_cartable(product_1).last.cartable.should == product_1
+    end
+  end
+  
+  describe "an instance" do
+    let(:cart){ Factory(:cart) }
+    let(:cart_item) {Factory(:cart_item, :cart => cart ) }
+    it "should respond to shopper" do
+      cart_item.should respond_to :shopper
+    end
+    
+    it "should delegate shopper to the cart" do
+      cart_item.shopper.should == cart.shopper
+    end
+  end
+  
+  describe "adding to a cart" do
+    let(:cart) {Factory(:cart)}
+    let(:cartable) {Factory(:product)}
+
+    it "should respond to add_item" do
+      cart.should respond_to :add_item
+    end
+    
+    it "should increment cart items by one" do
+      proc{ cart.add_item(cartable) }.should change(cart.cart_items, :size).by(1)
+    end
+    
+    it "should bump the quatity value of an exisitng item if the cart_item already exists" do
+      cart.add_item(cartable)
+      cart.cart_items.size.should == 1
+      proc{ cart.add_item(cartable) }.should_not change(cart.cart_items, :size)
+      cart.total.should == (cartable.price * 2)
+    end
+    
+    it "should remove the item if the quantity is 0" do
+      cart.add_item(cartable)
+      cart_item = cart.cart_items.first
+      lambda{ cart_item.update_attributes(:quantity => 0) }.should change(cart.cart_items, :size).from(1).to(0)
+    end
+
+    it "should remove the item if the quantity is less than zero" do
+      cart.add_item(cartable)
+      cart_item = cart.cart_items.first
+      lambda{ cart_item.update_attributes(:quantity => -1) }.should change(cart.cart_items, :size).from(1).to(0)
+    end
+    
+    describe "cart totals" do
+      before do
+        cart.add_item(cartable, 2)
+      end
+      
+      it "should return the total price of the cart" do
+        cart.total.should == (2 * cartable.price)
+        cart.add_item(cartable)
+        cart.total.should == (3 * cartable.price)
+      end
+    end
+    
+  end
+end

data/spec/active_record/cart_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Cart do
+  before(){ Product.acts_as_cartable }
+  it {should have_many :cart_items}
+  it {should belong_to :shopper }
+  
+  describe "removing carts" do
+    let(:cartable) {Factory(:product)}
+    before do 
+      Cart.destroy_all
+      @one_day_old = Factory(:cart, :updated_at => Time.now - 2.day)
+      @one_week_old = Factory(:cart, :updated_at => Time.now - 8.days)
+      @cart_item_one = Factory(:cart_item, :cart_id => @one_day_old.id)
+    end
+    
+    it "should remove carts a week old" do
+      d = (Time.now.midnight - 7.to_i.days)
+      scoped_carts = mock("carts")
+      scoped_carts.should_receive(:find_in_batches).with(:conditions => ["updated_at < ?", d])
+      Cart.should_receive(:with_state).with(:active).and_return(scoped_carts)
+      Cart.remove_carts
+    end
+    
+    it "should remove carts a 2 days old" do
+      d = (Time.now.midnight - 2.to_i.days)
+      scoped_carts = mock("carts")
+      scoped_carts.should_receive(:find_in_batches).with(:conditions => ["updated_at < ?", d])
+      Cart.should_receive(:with_state).with(:active).and_return(scoped_carts)
+      Cart.remove_carts(2)
+    end
+    
+    it "should delete the carts over a week old" do
+      proc{ Cart.remove_carts() }.should change(Cart, :count).by(-1)
+    end
+    
+    it "should delete the carts over a day old" do
+      proc{ Cart.remove_carts(1) }.should change(Cart, :count).by(-2)
+    end
+    
+    it "should not delete the any carts when not old enough" do
+      proc{ Cart.remove_carts(14) }.should_not change(Cart, :count)
+    end
+    
+    it "should return the number of deleted carts" do
+      Cart.remove_carts(1).should == 2
+    end
+    
+    it "should remove carts with another state" do
+      d = (Time.now.midnight - 2.to_i.days)
+      scoped_carts = mock("carts")
+      scoped_carts.should_receive(:find_in_batches).with(:conditions => ["updated_at < ?", d])
+      Cart.should_receive(:with_state).with(:failed).and_return(scoped_carts)
+      Cart.remove_carts(2, :failed)
+    end
+  end
+  
+  describe "adding to a cart" do
+    let(:cart) {Factory(:cart)}
+    let(:cartable) {Factory(:product)}
+    
+    it "should respond to add_item" do
+      cart.should respond_to :add_item
+    end
+    
+    it "should respond to empty?" do
+      cart.should respond_to :empty?
+    end
+    
+    it "should be empty" do
+      cart.should be_empty
+    end
+    
+    it "should increment cart items by one" do
+      proc{ cart.add_item(cartable) }.should change(cart.cart_items, :size).by(1)
+    end
+    
+    describe "cart totals" do
+      before do
+        cart.add_item(cartable, 2)
+      end
+      
+      it "should not be empty" do
+        cart.should_not be_empty
+      end
+      
+      it "should return the total price of the cart" do
+        cart.total.should == (2 * cartable.price)
+        cart.add_item(cartable)
+        cart.total.should == (3 * cartable.price)
+      end
+      
+      # it "should have many cartables" do
+      #   cart.cartables.should include(cartable)
+      # end
+      
+      # it "should have many products" do
+      #   cart.should respond_to(:products)
+      # end
+    end
+    
+  end
+end