awesome_o 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30a48a2ae38fffe8accddd03c162793b902a9001
+  data.tar.gz: 102caa5f774e27de2f0c5d220d60f2071a677e47
+SHA512:
+  metadata.gz: aaf745d0d79bf6184e792919b663e8fdf575ab5c892f037994fe2f4e443e30697ec3be05da2c9f6257afe112e30dc0ee7bfa939062d741d3824cdb201fbe44f9
+  data.tar.gz: f8b853877ad3d3d5ddd0e7e852c7ccf9d9e16844c9cdf541085140c0810ca58a97f7ecccdecec8a0d6a521e3ffe8e27c8d29e177510d61e59684fe37f6281060

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp
+*.un~
+*.rdb

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+services:
+  - redis
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in awesome_o.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Will Cosgrove
+
+MIT License
+
+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,114 @@
+# AwesomeO
+[![Build Status](https://travis-ci.org/hadees/awesome_o.svg?branch=master)](https://travis-ci.org/hadees/awesome_o)
+
+![](http://i.imgur.com/rziNSZZ.png)
+
+AwesomeO is a framework agnostic, redis backed, cart system.  It is not a POS, or a full fledged ecommerce system.  Just the cart, man.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'awesome_o'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install awesome_o
+
+## Setup
+
+AwesomeO has a few (read 3) configuration options you can set, most likely in an initializer file.  Here's an example configuration:
+
+```ruby
+# config/initializers/awesome_o.rb
+AwesomeO.config do |c|
+  c.cart_expires_in = 604800 # one week, in seconds.  This is the default
+  c.unit_cost_field = :unit_cost # for cart totaling
+  c.quantity_field = :quantity # for quantity totaling
+  c.redis = Redis.new # set the redis connection here
+end
+```
+
+- The `cart_expires_in=` setting will let you set how long a cart should live.  If no items are added to the cart before the time expires, the cart will be cleared.  If you want to disable cart expiration, set this to `-1`.
+- `unit_cost_field=` lets you tell AwesomeO where you're storing the unit_cost of each item, so that you can use the `cost` method on the item, and the `total` method on `Cart`.
+- `quantity_field=` lets you tell AwesomeO where you're storing the quantity of each item.  The `Item#cost` method uses this along with the `unit_cost` field to determine the cost.
+- `redis=` lets you set the redis connection you want to use.  Note that this is not redis connection options, this is an actual instance of `Redis`.
+
+## Usage
+
+To create a new shopping cart, just call `AwesomeO::Cart.new(user.id)`.  The parameter for `Cart.new()` is a unique id.  If you don't want a user to have more than one cart at a time, it's generally best to set this to the user's id.  Then to add an item to the cart, just call `cart.add_item(data)` which takes a hash of data that you want to store.  Then to retrieve the items, you just call `cart.items` which will give you an array of all the items they've added.
+
+The returned Items come back as `AwesomeO::Item` instances, which have a few special methods to be aware of:
+
+- `cost` - which will return the `:unit_cost` multiplied by the `:quantity`.
+- `destroy` - which will remove the item from the cart
+- `cart` - which will return the parent cart, think ActiveRecord association
+- `_id` - which will return the id of the item, if you need that for whatever reason
+- `_key` - which will return the redis key the data is stored in.  Probably won't need that, but it's there.
+- `#{attribute}=` - this is a setter defined for all of the items attributes that you gave it.  It will instantly save to redis also, so no need to call `save` (which is why there isn't a `save`).
+
+The `Cart` object also has some handy methods that you should be aware of:
+
+- `add_item(data)` - which is the life blood of AwesomeO.  This method takes a hash of data you would like to store with the item.  Here's a few suggestions of keys you may want in your hash:
+  - `:id` - (*required*) to store the ID of the model you're adding
+  - `:type` - (*required*) to store the class of the model you're adding.
+  - `:unit_cost` - This field is required if you want to take advantage of the `Item#cost` method, and the `Cart#total` method.
+  - `:quantity` - which if you use will let you use the `Cart#quantity` and `Cart#total` methods without any extra configuration.
+- `remove_item(item)` - which, you guessed it, removes an item.  This method takes an Item object, not a hash.
+- `contains?(Product)` - This is a biggie.  It will tell you if a certain item is in the cart.  And the way it works is you pass it an object, like an instance of a Product model, and it will examine the class, and the id, and look to see if it's in the cart already.  This method only works if the `:id` and `:type` keys are set in the item's data hash.
+- `find(Product)` - This will return the `Item` object that represents the object passed in.  It works like `contains?` and uses class, and id.  It only works if the `:id` and `:type` keys are set in the item's data hash.
+- `items` - this returns a magic array of all the items.  You can also pass in a type string, which will return a magic array of all the items with a matching type.  I call it magic because you can call on it:
+  - `each_with_object` - which will act like a regular `each` call, but the block will yield the `Item` and the object it represents by using the `:type` and `:id` keys.
+- `total` - will sum all of the `cost` return values of all of the items in the cart.  For this to work, the `:unit_cost` and `:quantity` fields need to be set for all items.
+- `count` - which will give you the total number of items in the cart.  Faster than `cart.items.size` because it doesn't load all of the item data from redis.
+- `quantity` - which will return the total quantity of all the items.  The quantity field is set in the config block, by default it's `:quantity`
+- `ttl` - will tell you how many seconds until the cart expires.  It will return -1 if the cart will never expire.
+- `touch` - which will reset the ttl back to whatever expiration length is set in the config.  Touch is automatically called after `add_item` and `remove_item`.
+- `destroy!` - which will delete the cart, and all the line_items out of it.
+- `reassign(id)` - this method will reassign the cart's unique identifier.  So to access this cart at a later time after reassigning, you would put `Cart.new(reassigned_id)`.  This is useful for having a cart for an unsigned in user.  You can use their session ID while they're unauthenticated, and then when they sign in, you can reassign the cart to the user's ID.  NOTE: Reassigning will overwrite any cart in it's way.
+
+Lets walk through an example implementation with a Rails app that has a User model and a Product model.
+
+```ruby
+# app/models/user.rb
+class User < ActiveRecord::Base
+  #...
+  def cart
+    AwesomeO::Cart.new(id)
+  end
+  #...
+end
+```
+
+```ruby
+# app/controllers/products_controller.rb
+class ProductsController < ApplicationController
+  #...
+  # /products/:id/add_to_cart
+  def add_to_cart
+    @product = Product.find(params[:id])
+    current_user.cart.add_item(id: @product.id, name: @product.name, unit_cost: @product.cost, cost: @product.cost * params[:quantity], quantity: params[:quantity])
+  end
+  #...
+end
+```
+
+```haml
+-# app/view/cart/show.html.haml
+%h1 Cart - Total: #{@cart.total}
+%ul
+  - @cart.items.each do |item|
+    %li #{item.name} - #{item.cost}
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/awesome_o.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'awesome_o/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'awesome_o'
+  gem.version       = AwesomeO::VERSION
+  gem.authors       = ['Evan Alter']
+  gem.email         = ['evan.alter@gmail.com']
+  gem.description   = 'AwesomeO is a frameworke agnostic, redis-backed, shopping cart system'
+  gem.summary       = 'Originaly forked from the gem Cartman'
+  gem.homepage      = 'http://github.com/hadees/awesome-o'
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency('redis')
+
+  gem.add_development_dependency('rspec', '~> 3.0.0')
+end

data/lib/awesome_o.rb

@@ -0,0 +1,13 @@
+require 'awesome_o/version'
+require 'awesome_o/configuration'
+require 'awesome_o/cart'
+require 'awesome_o/item'
+require 'awesome_o/item_collection'
+
+module AwesomeO
+  def self.config
+    @config ||= Configuration.new
+    yield @config if block_given?
+    @config
+  end
+end

data/lib/awesome_o/cart.rb

@@ -0,0 +1,170 @@
+module AwesomeO
+  class Cart
+    CART_LINE_ITEM_ID_KEY = 'awesome_o:line_item:id'.freeze
+
+    def initialize(uid)
+      @uid = uid
+    end
+
+    def add_item(options)
+      raise 'Must specify both :id and :type' unless options.key?(:id) && options.key?(:type)
+      line_item_id = redis.incr CART_LINE_ITEM_ID_KEY
+      redis.pipelined do
+        redis.mapped_hmset("awesome_o:line_item:#{line_item_id}", options)
+        redis.hincrby("awesome_o:line_item:#{line_item_id}", :_version, 1)
+        redis.sadd key, line_item_id
+        redis.sadd index_key, "#{options[:type]}:#{options[:id]}"
+        redis.set index_key_for(options), line_item_id
+      end
+      touch
+      get_item(line_item_id)
+    end
+
+    def remove_item(item)
+      redis.del "awesome_o:line_item:#{item._id}"
+      redis.srem key, item._id
+      redis.srem index_key, "#{item.type}:#{item.id}"
+      redis.del index_key_for(item)
+      touch
+    end
+
+    def items(type = nil)
+      if type
+        items = line_item_ids.collect { |item_id| get_item(item_id) }.select { |item| item.type == type }
+        return ItemCollection.new(items)
+      else
+        return ItemCollection.new(line_item_ids.collect { |item_id| get_item(item_id) })
+      end
+    end
+
+    def contains?(object)
+      redis.sismember index_key, "#{object.class}:#{object.id}"
+    end
+
+    def find(object)
+      get_item(redis.get(index_key_for(object)).to_i) if contains?(object)
+    end
+
+    def count
+      redis.scard key
+    end
+
+    def quantity
+      line_item_keys.collect do |item_key|
+        redis.hget item_key, AwesomeO.config.quantity_field
+      end.inject(0) { |sum, quantity| sum += quantity.to_i }
+    end
+
+    def total
+      items.collect do |item|
+        (item.cost * 100).to_i
+      end.inject(0) { |sum, cost| sum += cost } / 100.0
+    end
+
+    def ttl
+      redis.ttl key
+    end
+
+    def destroy!
+      keys = line_item_keys
+      keys << key
+      keys << index_key
+      keys << index_keys
+      keys.flatten!
+      redis.pipelined do
+        keys.each do |key|
+          redis.del key
+        end
+      end
+    end
+
+    def touch
+      keys_to_expire = line_item_keys
+      keys_to_expire << key
+      if redis.exists index_key
+        keys_to_expire << index_key
+        keys_to_expire << index_keys
+        keys_to_expire.flatten!
+      end
+      redis.pipelined do
+        keys_to_expire.each do |item|
+          redis.expire item, AwesomeO.config.cart_expires_in
+        end
+      end
+      redis.hincrby self.class.versions_key, version_key, 1
+    end
+
+    def version
+      redis.hget(self.class.versions_key, version_key).to_i
+    end
+
+    def reassign(new_id)
+      if redis.exists key
+        new_index_keys = items.collect do |item|
+          index_key_for(item, new_id)
+        end
+        redis.rename key, key(new_id)
+        redis.rename index_key, index_key(new_id)
+        index_keys.zip(new_index_keys).each do |key, value|
+          redis.rename key, value
+        end
+      end
+      @uid = new_id
+    end
+
+    def cache_key
+      "cart/#{@uid}-#{version}"
+    end
+
+    private
+
+    def key(id = @uid)
+      "awesome_o:cart:#{id}"
+    end
+
+    def index_key(id = @uid)
+      key(id) + ':index'
+    end
+
+    def version_key(id = @uid)
+      id
+    end
+
+    def self.versions_key
+      'awesome_o:cart:versions'
+    end
+
+    def index_keys(id = @uid)
+      redis.keys "#{index_key(id)}:*"
+    end
+
+    def index_key_for(object, id = @uid)
+      case object
+      when Hash
+        index_key(id) + ":#{object[:type]}:#{object[:id]}"
+      when Item
+        index_key(id) + ":#{object.type}:#{object.id}"
+      else
+        index_key(id) + ":#{object.class}:#{object.id}"
+      end
+    end
+
+    def line_item_ids
+      redis.smembers key
+    end
+
+    def line_item_keys
+      line_item_ids.collect { |id| "awesome_o:line_item:#{id}" }
+    end
+
+    def get_item(id)
+      Item.new(id, @uid, redis.hgetall("awesome_o:line_item:#{id}").each_with_object({}) { |(k, v), hash| hash[k.to_sym] = v; hash })
+    end
+
+    private
+
+    def redis
+      AwesomeO.config.redis
+    end
+  end
+end

data/lib/awesome_o/configuration.rb

@@ -0,0 +1,18 @@
+require 'redis'
+
+module AwesomeO
+  class Configuration
+    attr_accessor :cart_expires_in, :unit_cost_field, :quantity_field
+    attr_writer :redis
+
+    def initialize
+      @cart_expires_in = 604_800
+      @unit_cost_field = :unit_cost
+      @quantity_field = :quantity
+    end
+
+    def redis
+      @redis ||= Redis.new
+    end
+  end
+end

data/lib/awesome_o/item.rb

@@ -0,0 +1,71 @@
+module AwesomeO
+  class Item
+    def initialize(item_id, cart_id, data)
+      @id = item_id
+      @cart_id = cart_id
+      @data = data
+    end
+
+    def _id
+      @id
+    end
+
+    def cost
+      unit_cost = (@data.fetch(AwesomeO.config.unit_cost_field).to_f * 100).to_i
+      quantity = @data.fetch(AwesomeO.config.quantity_field).to_i
+      (unit_cost * quantity) / 100.0
+    end
+
+    def cart
+      @cart ||= Cart.new(@cart_id)
+    end
+
+    def destroy
+      cart.remove_item(self)
+    end
+
+    def ==(item)
+      @id == item._id
+    end
+
+    def touch
+      cart.touch
+      redis.hincrby _key, :_version, 1
+    end
+
+    def _key
+      "awesome_o:line_item:#{@id}"
+    end
+
+    def _version
+      super.to_i
+    end
+
+    def cache_key
+      "item/#{@id}-#{_version}"
+    end
+
+    def method_missing(method, *args, &block)
+      if method.to_s.end_with?('=')
+        redis.hset _key, method[0..-2], args[0].to_s
+        @data.store(method[0..-2].to_sym, args[0].to_s)
+        version = touch
+        @data.store(:_version, version)
+      elsif @data.keys.include?(method)
+        @data.fetch(method)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      method.to_s.end_with?('=') || @data.keys.include?(method) || super
+    end
+
+    private
+
+    def redis
+      AwesomeO.config.redis
+    end
+  end
+end

data/lib/awesome_o/item_collection.rb

@@ -0,0 +1,18 @@
+require 'delegate'
+
+module AwesomeO
+  class ItemCollection < DelegateClass(Array)
+    include Enumerable
+
+    def initialize(array)
+      @results = array
+      super(@results)
+    end
+
+    def each_with_object
+      @results.each do |result|
+        yield result, eval(result.type).send(:find, result.id)
+      end
+    end
+  end
+end

data/lib/awesome_o/version.rb

@@ -0,0 +1,3 @@
+module AwesomeO
+  VERSION = '0.0.1'.freeze
+end

data/spec/cart_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+describe AwesomeO do
+  describe AwesomeO::Cart do
+    let(:Bottle) { Struct.new(:id) }
+    let(:cart) { AwesomeO::Cart.new(1) }
+
+    before(:each) do
+      AwesomeO.config.redis.flushdb
+    end
+
+    describe '#key' do
+      it 'should return a proper key string' do
+        expect(cart.send(:key)).to eq('awesome_o:cart:1')
+      end
+    end
+
+    describe '#add_item' do
+      before(:each) do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+      end
+
+      it 'creates a line item key' do
+        expect(AwesomeO.config.redis.exists('awesome_o:line_item:1')).to be true
+      end
+
+      it "adds that line item key's id to the cart set" do
+        expect(AwesomeO.config.redis.sismember(cart.send(:key), 1)).to be true
+      end
+
+      it 'should expire the line_item_keys in the amount of time specified' do
+        expect(cart.ttl).to eq(AwesomeO.config.cart_expires_in)
+        expect(AwesomeO.config.redis.ttl('awesome_o:line_item:1')).to eq(AwesomeO.config.cart_expires_in)
+      end
+
+      it 'should add an index key to be able to look up by type and ID' do
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index')).to be true
+        expect(AwesomeO.config.redis.sismember('awesome_o:cart:1:index', 'Bottle:17')).to be true
+      end
+
+      it 'should squack if type and/or ID are not set' do
+        expect { cart.add_item(id: 18, name: 'Cordeux', unit_cost: 92.12, quantity: 2) }.to raise_error('Must specify both :id and :type')
+        expect { cart.add_item(type: 'Bottle', name: 'Cordeux', unit_cost: 92.12, quantity: 2) }.to raise_error('Must specify both :id and :type')
+        expect { cart.add_item(name: 'Cordeux', unit_cost: 92.12, quantity: 2) }.to raise_error('Must specify both :id and :type')
+      end
+
+      it 'should return an Item' do
+        item = cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, quantity: 2)
+        expect(item.class).to eq(AwesomeO::Item)
+      end
+    end
+
+    describe '#remove_item' do
+      it 'should remove the id from the set, and delete the line_item key' do
+        item = cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        item_id = item._id
+        cart.remove_item(item)
+        expect(AwesomeO.config.redis.sismember(cart.send(:key), item_id)).to be false
+        expect(AwesomeO.config.redis.exists("awesome_o:line_item:#{item_id}")).to be false
+      end
+
+      it 'should not delete the indecies for other items' do
+        item = cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        item2 = cart.add_item(id: 18, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index:Bottle:17')).to be true
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index:Bottle:18')).to be true
+        cart.remove_item(item)
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index:Bottle:17')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index:Bottle:18')).to be true
+      end
+    end
+
+    describe '#items' do
+      before(:each) do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, quantity: 2)
+        cart.add_item(id: 35, type: 'GiftCard', name: 'Gift Card', unit_cost: 100.00, quantity: 1)
+      end
+
+      it 'should return an ItemCollection of Items' do
+        expect(cart.items.class).to be(AwesomeO::ItemCollection)
+        expect(cart.items.first.class).to be(AwesomeO::Item)
+        expect(cart.items.first.id).to eq('17')
+        expect(cart.items.first.name).to eq('Bordeux')
+      end
+
+      it 'should return all items in cart if no filter is given' do
+        expect(cart.items.size).to eq(3)
+      end
+
+      it 'should return a subset of the items if a filter is given' do
+        expect(cart.items('Bottle').size).to eq(2)
+        expect(cart.items('GiftCard').size).to eq(1)
+        expect(cart.items('SomethingElse').size).to eq(0)
+      end
+    end
+
+    describe '#contains?(item)' do
+      before(:all) do
+        Bottle = Struct.new(:id)
+      end
+
+      before(:each) do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, quantity: 2)
+      end
+
+      it 'should be able to tell you that an item in the cart is present' do
+        expect(cart.contains?(Bottle.new(17))).to be true
+      end
+
+      it 'should be able to tell you that an item in the cart is absent' do
+        expect(cart.contains?(Bottle.new(20))).to be false
+      end
+
+      it "should be able to tell you that an item in the cart is absent if it's been removed" do
+        cart.remove_item(cart.items.first)
+        expect(cart.contains?(Bottle.new(17))).to be false
+        cart.remove_item(cart.items.last)
+        expect(cart.contains?(Bottle.new(34))).to be false
+      end
+    end
+
+    describe '#find(item)' do
+      before(:each) do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, quantity: 2)
+      end
+
+      it 'should take some object, and return the Item that corresponds to it' do
+        expect(cart.find(Bottle.new(17)).quantity).to eq('2')
+        expect(cart.find(Bottle.new(17)).name).to eq('Bordeux')
+        expect(cart.find(Bottle.new(34)).name).to eq('Cabernet')
+      end
+
+      it 'should return nil if the Item is not in the cart' do
+        expect(cart.find(Bottle.new(23))).to be(nil)
+      end
+    end
+
+    describe '#count' do
+      it 'should return the number of items in the cart' do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, quantity: 2)
+        expect(cart.count).to eq(2)
+      end
+    end
+
+    describe '#quantity' do
+      it 'should return the sum of the default quantity field' do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, quantity: 2)
+        expect(cart.quantity).to eq(4)
+      end
+
+      it 'should return the sum of the defined quantity field' do
+        AwesomeO.config do |c|
+          c.quantity_field = :qty
+        end
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, qty: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, qty: 2)
+        expect(cart.quantity).to eq(4)
+        AwesomeO.config do |c|
+          c.quantity_field = :quantity
+        end
+      end
+    end
+
+    describe '#total' do
+      it 'should return 0 when no items are in the cart' do
+        expect(cart.total).to eq(0)
+      end
+
+      it 'should total the default costs field' do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, quantity: 2)
+        expect(cart.total).to eq(368.48)
+      end
+
+      it 'should total whatever cost field the user sets' do
+        AwesomeO.config do |c|
+          c.unit_cost_field = :unit_cost_in_cents
+        end
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost_in_cents: 9212, quantity: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost_in_cents: 9212, quantity: 2)
+        expect(cart.total).to eq(36_848)
+        AwesomeO.config do |c|
+          c.unit_cost_field = :unit_cost
+        end
+      end
+    end
+
+    describe '#destroy' do
+      it 'should delete the line_item keys, the index key, and the cart key' do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, cost_in_cents: 18_424, quantity: 2)
+        cart.add_item(id: 34, type: 'Bottle', name: 'Cabernet', unit_cost: 92.12, cost_in_cents: 18_424, quantity: 2)
+        cart.destroy!
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:line_item:1')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:line_item:2')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index:Bottle:17')).to be false
+      end
+    end
+
+    describe '#touch' do
+      it 'should reset the TTL' do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, cost_in_cents: 18_424, quantity: 2)
+        cart.touch
+        expect(cart.ttl).to eq(AwesomeO.config.cart_expires_in)
+        expect(AwesomeO.config.redis.ttl('awesome_o:cart:1:index')).to eq(AwesomeO.config.cart_expires_in)
+        expect(AwesomeO.config.redis.ttl('awesome_o:cart:1:index:Bottle:17')).to eq(AwesomeO.config.cart_expires_in)
+      end
+
+      it 'should record that the cart was updated' do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, cost_in_cents: 18_424, quantity: 2)
+        cart.touch
+        expect(cart.version).to eq(2)
+      end
+    end
+
+    describe '#reassign' do
+      it 'should only change the @uid if no key exists' do
+        cart.reassign(2)
+        expect(cart.send(:key)[-1]).to eq('2')
+      end
+
+      it 'should rename the key, and index_key if it exists' do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, cost_in_cents: 18_424, quantity: 1)
+        cart.add_item(id: 18, type: 'Bottle', name: 'Merlot', unit_cost: 92.12, cost_in_cents: 18_424, quantity: 3)
+        expect(cart.quantity).to be(4)
+        cart.reassign(2)
+        expect(cart.items.size).to be(2)
+        expect(AwesomeO::Cart.new(2).quantity).to be(4)
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index:Bottle:17')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:2')).to be true
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:2:index')).to be true
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:2:index:Bottle:17')).to be true
+        expect(cart.send(:key)[-1]).to eq('2')
+        cart.add_item(id: 19, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, cost_in_cents: 18_424, quantity: 2)
+        cart.reassign(1)
+        expect(cart.items.size).to be(3)
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:2')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:2:index')).to be false
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1')).to be true
+        expect(AwesomeO.config.redis.exists('awesome_o:cart:1:index')).to be true
+        expect(cart.send(:key)[-1]).to eq('1')
+      end
+    end
+
+    describe '#cache_key' do
+      it 'should return /cart/{cart_id}-{version}/' do
+        expect(cart.cache_key).to eq("cart/#{cart.instance_variable_get(:@uid)}-#{cart.version}")
+      end
+    end
+  end
+end

data/spec/item_collection_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe AwesomeO do
+  describe AwesomeO::ItemCollection do
+    let(:cart) { AwesomeO::Cart.new(1) }
+
+    before(:each) do
+      AwesomeO.config.redis.flushdb
+      Object.send(:remove_const, :Bottle) if defined?(Bottle)
+      Bottle = double
+      allow(Bottle).to receive(:find).and_return(bottle)
+    end
+
+    describe '#each_with_object' do
+      let(:bottle) { double('Bottle') }
+
+      it 'should be magical' do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, cost: 184.24, quantity: 2)
+        expect { |b| cart.items.each_with_object(&b) }.to yield_successive_args([cart.items.first, bottle])
+      end
+
+      it "should work with items('Type')" do
+        cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, cost: 184.24, quantity: 2)
+        cart.add_item(id: 27, type: 'UserGiftCard', unit_cost: 25, quantity: 1)
+        expect { cart.items('Bottle').each_with_object {} }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/item_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe AwesomeO do
+  describe AwesomeO::Item do
+    let(:cart) { AwesomeO::Cart.new(1) }
+    let(:item) { cart.add_item(id: 17, type: 'Bottle', name: 'Bordeux', unit_cost: 92.12, quantity: 2) }
+
+    describe 'data getters and setters' do
+      it 'should let me get data stored for the item' do
+        expect(item.id).to eq('17')
+        expect(item.type).to eq('Bottle')
+        expect(item.cost).to eq(184.24)
+      end
+
+      it 'should let me modify data stored for the item' do
+        expect(item.quantity).to eq('2')
+        item.quantity = 3
+        expect(item.quantity).to eq('3')
+      end
+
+      it 'should immediately save data back to redis' do
+        expect(item.quantity).to eq('2')
+        item.quantity = 3
+        new_item = cart.send(:get_item, item._id)
+        expect(new_item.quantity).to eq('3')
+      end
+
+      it 'should touch the item and cart' do
+        expect { item.quantity = 4 }.to change { item._version }.by(1)
+      end
+
+      it "should raise NoMethodError if you use a getter that there isn't a key for" do
+        expect { item.weight }.to raise_error(NoMethodError)
+      end
+
+      it 'should respond_to the getters and setters' do
+        expect(item.respond_to?(:name)).to be true
+        expect(item.respond_to?(:name=)).to be true
+      end
+    end
+
+    describe '#cost' do
+      it 'should be equal to the unit_cost multiplied by the quantity' do
+        expect(item.cost).to eq(184.24)
+        item.quantity = 3
+        expect(item.cost).to eq(276.36)
+      end
+    end
+
+    describe '#destroy' do
+      it 'should remove the item from the cart' do
+        item_id = item._id
+        item.destroy
+        expect(AwesomeO.config.redis.sismember(cart.send(:key), item_id)).to be false
+        expect(AwesomeO.config.redis.exists("awesome_o:line_item:#{item_id}")).to be false
+      end
+    end
+
+    describe '#touch' do
+      it 'should record that the record was changed' do
+        item.touch
+        expect(item._version).to eq(1)
+      end
+    end
+
+    describe '#cache_key' do
+      it 'should return item/{id}-{version}' do
+        expect(item.cache_key).to eq("item/#{item._id}-#{item._version}")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative '../lib/awesome_o'

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: awesome_o
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Evan Alter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: AwesomeO is a frameworke agnostic, redis-backed, shopping cart system
+email:
+- evan.alter@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- awesome_o.gemspec
+- lib/awesome_o.rb
+- lib/awesome_o/cart.rb
+- lib/awesome_o/configuration.rb
+- lib/awesome_o/item.rb
+- lib/awesome_o/item_collection.rb
+- lib/awesome_o/version.rb
+- spec/cart_spec.rb
+- spec/item_collection_spec.rb
+- spec/item_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/hadees/awesome-o
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Originaly forked from the gem Cartman
+test_files:
+- spec/cart_spec.rb
+- spec/item_collection_spec.rb
+- spec/item_spec.rb
+- spec/spec_helper.rb