carter 0.5.5

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Louis Gillies
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+# carter
+
+A simple shopping cart for ruby.
+
+  [Carter]("http://en.wikipedia.org/wiki/Carter_(name)/") - "transports goods by cart"
+  
+* Anything can be added to the cart using 
+  `acts_as_cartable`
+* Any page can load a cart from session.
+* Can be included without a need for a complete e-commerce solution.
+
+## Contributing to carter
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Louis Gillies. See LICENSE.txt for
+further details.
+

data/app/controllers/cart_items_controller.rb

@@ -0,0 +1,34 @@
+class CartItemsController < ApplicationController
+  load_cart_and_cartable
+  before_filter :find_cart_item, :only => [:update, :destroy]
+  
+  # RESTful equiv of add
+  def create
+    persist_cart if @cart.new_record?
+    @cart.add_item(find_cartable)
+  end
+  
+  def update
+    if @cart_item.update_attributes(params[:cart_item])
+      flash[:notice] = t(:cart_updated)
+      redirect_to cart_path(cart)
+    else
+      flash[:notice] = t(:cart_update_failed)
+    end
+  end
+  
+  def destroy
+    if @cart_item.destroy
+      flash[:notice] = t(:cart_item_removed)
+      redirect_to cart_path(@cart)
+    else
+      flash[:notice] = t(:cart_update_failed)
+    end
+  end
+  
+  protected
+  
+  def find_cart_item
+    @cart_item = @cart.cart_items.find(params[:id])
+  end
+end

data/app/controllers/carts_controller.rb

@@ -0,0 +1,11 @@
+class CartsController < ApplicationController
+  load_cart_and_cartable
+
+  def show
+
+  end
+  
+  def destroy
+    cart.destroy
+  end
+end

data/app/models/cart.rb

@@ -0,0 +1,34 @@
+class Cart < ActiveRecord::Base
+  belongs_to :shopper, :polymorphic => true # for extra persistance
+  has_many :cart_items, :dependent => :destroy
+
+  include Carter::Cart
+  extend Carter::ActiveRecord::Extensions
+
+  attr_accessor :gateway_response
+  
+  def add_item(cartable, quantity = 1, owner=nil)
+    existing_cart_item = cart_item_for_cartable_and_owner(cartable, owner)
+    Cart.transaction do
+      if existing_cart_item.blank?
+        cart_items.create!(:cartable => cartable, :name => cartable.cartable_name, :price => cartable.cartable_price, :quantity => quantity, :owner => owner)
+      else
+        if cartable.allow_multiples?
+          existing_cart_item.update_attributes(:quantity => existing_cart_item.quantity + quantity)
+        else
+          raise Carter::MultipleCartItemsNotAllowed, "#{cartable.cartable_name} is already in your basket"
+        end
+      end
+    end
+  end
+  
+  # TODO cache this value
+  def total
+    cart_items.reload.map.sum(&:total_price).to_money
+  end
+  
+  def empty?
+    cart_items.blank?
+  end
+  
+end

data/app/models/cart_item.rb

@@ -0,0 +1,40 @@
+class CartItem < ActiveRecord::Base
+  belongs_to :cart
+  belongs_to :cartable, :polymorphic => true
+  belongs_to :owner, :polymorphic => true
+  delegate :shopper, :to => :cart
+  
+  extend Carter::ActiveRecord::Extensions
+  include Carter::StateMachine::CartItem
+  
+  after_update :check_quantity
+  
+  # Match a cart_item by owner and cartable
+  named_scope :for_cartable, lambda { |cartable|
+    { :conditions => { :cartable_type => cartable.class.to_s, :cartable_id => cartable.id } }
+  }
+  
+  named_scope :for_owner, lambda {|owner|
+    { :conditions => { :owner_id => (owner ? owner.id : nil), :owner_type =>  (owner ? owner.class.to_s : nil) } }
+  }
+  
+  named_scope :for_cartable_and_owner, lambda {|cartable, owner| 
+    { :conditions => for_owner(owner).proxy_options[:conditions].merge!(for_cartable(cartable).proxy_options[:conditions])}
+  }
+   
+  money_composed_column :total_price, 
+    :mapping => [[:price, :cents], [:quantity]], 
+    :constructor => Proc.new{|value, quantity| Money.new(value.to_i * quantity.to_i)}
+  
+  money_composed_column :price
+  
+  def refresh
+    update_attributes :price => cartable.cartable_price, :name => cartable.cartable_name 
+  end
+  
+  protected
+  
+  def check_quantity
+    self.destroy if self.quantity < 1
+  end
+end

data/generators/carter_generator.rb

@@ -0,0 +1,21 @@
+class CarterGenerator < Rails::Generator::Base
+  default_options :skip_migration => false
+  
+  def manifest
+    record do |m|
+      if !options[:skip_migration] && defined?(ActiveRecord)
+        m.migration_template "migration.rb", 'db/migrate',
+                             :migration_file_name => "create_carter"
+      end
+    end
+  end
+  
+protected
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on("--skip-migration", "Don't generate a migration") { |v| options[:skip_migration] = v }
+  end
+  
+end

data/generators/carter_install_generator.rb

@@ -0,0 +1,20 @@
+class CarterInstallGenerator < Rails::Generator::Base
+  default_options :skip_migration => false
+  
+  def copy_controller_file
+    copy_file "cart_items_controller.rb", "app/controllers"
+    copy_file "carts_controller.rb", "app/controllers"
+  end
+  
+  def copy_view_file
+    copy_file "carts/show.html.erb", "app/views/carts"
+  end
+protected
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on("--skip-migration", "Don't generate a migration") { |v| options[:skip_migration] = v }
+  end
+  
+end

data/generators/templates/migration.rb

@@ -0,0 +1,37 @@
+class CreateCarter < ActiveRecord::Migration
+  def self.up
+    create_table :carts do |t|
+      t.string :session_id, :state
+      t.belongs_to :shopper, :polymorphic => true
+      t.timestamps
+    end
+    
+    add_index :carts, :shopper_id
+    add_index :carts, :state
+    add_index :carts, :shopper_type
+    
+    create_table :cart_items do |t|
+      t.string :name, :state
+      t.belongs_to :cartable, :polymorphic => true
+      t.belongs_to :owner, :polymorphic => true
+      t.belongs_to :cart
+      t.column :price, :float, :default => "0.00" 
+      t.column :quantity, :integer
+      t.timestamps
+    end
+    
+    add_index :cart_items, :name
+    add_index :cart_items, :state
+    add_index :cart_items, :cartable_id
+    add_index :cart_items, :cart_id
+    add_index :cart_items, :cartable_type
+    add_index :cart_items, :owner_id
+    add_index :cart_items, :owner_type
+  end
+
+  def self.down
+    drop_table :carts
+    drop_table :cart_items
+  end
+end
+

data/init.rb

@@ -0,0 +1 @@
+require 'rails/init.rb'

data/lib/carter.rb

@@ -0,0 +1,8 @@
+require 'carter/cartable'
+require 'carter/initializer'
+require 'carter/cart'
+require 'carter/controller_additions'
+require 'carter/controller_resource'
+require 'carter/state_machine'
+require 'carter/errors'
+require 'carter/active_record/extensions'

data/lib/carter/active_record/extensions.rb

@@ -0,0 +1,22 @@
+module Carter
+  module ActiveRecord
+    module Extensions
+      def money_converter
+        Proc.new { |value| value.respond_to?(:to_money) ? value.to_money : Money.empty }
+      end
+      
+      def money_constructor
+        Proc.new { |value| value.respond_to?(:to_money) && !value.blank? ? Money.new(value) : Money.empty }
+      end
+      
+      def money_composed_column(*args)
+        options = args.extract_options!
+        args.each do |column_name|
+          composed_options = {:class_name => '::Money', :mapping => ["#{column_name}", "cents"],
+          :converter => money_converter, :constructor => money_constructor}.update(options)
+          composed_of column_name, composed_options
+        end
+      end
+    end
+  end
+end

data/lib/carter/cart.rb

@@ -0,0 +1,66 @@
+module Carter
+  module Cart
+    
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.send :include, Carter::StateMachine::Cart
+      base.extend ClassMethods
+    end
+    
+    module InstanceMethods
+      def cartables
+        Carter.settings.cartables.inject([]) do |result, cartable_type|
+          result.concat self.send(cartable_type.downcase.pluralize)
+          result
+        end
+      end
+      
+      def on_checkout
+        if Carter.settings.on_checkout.is_a?(Proc)
+          Carter.settings.on_checkout.call(self)
+        end
+      end
+      
+      # On success from checkout call the add event on each cart item.
+      def on_success
+        self.cart_items.each{|cart_item| cart_item.add_to_owner }
+      end
+      
+      def on_failed
+        if Carter.settings.on_failed.is_a?(Proc)
+          Carter.settings.on_failed.call(self)
+        end
+      end
+      
+      def in_cart?(cartable, owner=nil)
+        cart_item_for_cartable_and_owner(cartable, owner).nil?
+      end
+      
+      def cart_item_for_cartable_and_owner(cartable, owner)
+        cart_items.for_cartable_and_owner(cartable, owner).first
+      end
+      
+      def refresh
+        cart_items.each{|cart_item| cart_item.refresh }
+      end
+    end
+    
+    module ClassMethods
+      
+      def remove_carts(days=7, state=:active)
+        expiry_date = (Time.now.midnight - days.days.to_i)
+        count = 0
+        self.with_state(state).find_in_batches(:conditions => ["updated_at < ?", expiry_date]) do |batch|
+          count += self.delete(batch.map &:id)
+        end
+        count
+      end
+      
+      # TODO doesn't work for polymorphic assoc
+      def add_cart_association(klass)
+        klass_key = klass.name.downcase.to_sym
+        self.has_many klass_key.to_s.pluralize.to_sym, :through => :cart_items, :source => :cartable, :source_type => klass_key.to_s
+      end
+    end
+  end
+end

data/lib/carter/cartable.rb

@@ -0,0 +1,60 @@
+module Carter
+  module ActiveRecord #:nodoc:
+    module Cartable #:nodoc:
+      
+      # Options
+      #   acts_as_cartable :name => "name_column", :price => "price_column", :unique => true / false
+      #   :unique => true # this allows only one item of this type in the cart.
+      def acts_as_cartable(options = {})
+        configuration = { :name => "name", :price => "price", :unique => false }
+        configuration.update(options) if options.is_a?(Hash)
+        @cartable_configuration = configuration
+        has_many :cart_items, :as => :cartable
+        has_many :carts, :through => :cart_items
+        register_cartable(self)
+        include InstanceMethods
+        true
+      end
+      
+      def cartable_configuration
+        @cartable_configuration ||= {}
+      end
+      
+      protected
+      
+      def register_cartable(klass)
+        Carter.settings.cartables = (Carter.settings.cartables << klass.name).uniq
+        # ::Cart.add_cart_association(klass)
+      end
+    end
+    
+    module InstanceMethods
+    
+      def cartable_price
+        self.send(cartable_configuration_value_by_key(:price))
+      end
+      
+      def cartable_name
+        self.send(cartable_configuration_value_by_key(:name))
+      end
+      
+      def in_cart?(cart, owner=nil)
+        !cart.cart_item_for_cartable_and_owner(self, owner).nil?
+      end
+      
+      def allow_multiples?
+        !cartable_configuration_value_by_key(:unique)
+      end
+      
+      def after_purchase_method
+        cartable_configuration_value_by_key :after_purchase_method
+      end
+      
+      private
+      
+      def cartable_configuration_value_by_key(key)
+        self.class.cartable_configuration[key]
+      end
+    end
+  end
+end

data/lib/carter/controller_additions.rb

@@ -0,0 +1,86 @@
+module Carter
+
+  # This module is automatically included into all controllers.
+
+  module ControllerAdditions
+    module ClassMethods
+      
+      def has_cart(*args)
+        ControllerResource.add_before_filter(self, :load_cart, *args)
+        include InstanceMethods
+      end
+
+      def has_cart_for_checkout(*args)
+        ControllerResource.add_before_filter(self, :load_cart_for_checkout, *args)
+        include InstanceMethods
+      end
+
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_inheritable_accessor :checking_out
+      base.class_inheritable_accessor :shopping
+      base.helper_method :cart, :has_cart?, :shopper
+    end
+    
+    module InstanceMethods
+      def cart
+        @cart
+      end
+      
+      def shopper
+        @shopper
+      end
+      
+      def has_cart?
+        !@cart.nil?
+      end
+      
+      def redirect_to_continue_shopping_or_default(default)
+        redirect_to continue_shopping_or_default_url(default)
+        session[:continue_shopping_url] = nil
+      end
+      
+      def continue_shopping_or_default_url(default)
+        session[:continue_shopping_url] || default || root_url
+      end
+      
+      # to stop the has_cart method called from super class from setting the continue_shopping_url when checking out.
+      def checking_out?
+        checking_out == true
+      end
+      
+      def shopping?
+        shopping == true
+      end
+      
+      protected
+
+      def find_cartable(cartable_id=params[:cartable_id])
+        @cartable = cartable_class.find_by_id(cartable_id)
+      end
+
+      def cartable_class(cartable_type=params[:cartable_type])
+        cartable_type.constantize
+      end
+
+      def add_cartable_to_cart(cartable, quantity = 1, owner = nil)
+        persist_cart
+        cart.add_item(cartable, quantity, owner)
+      end
+      
+      def persist_cart
+        cart.save
+        session[:cart_id] = cart.id
+      end
+    end
+  end
+  
+end
+
+if defined? ActionController
+  ActionController::Base.class_eval do
+    include Carter::ControllerAdditions
+  end
+end