cart 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jakub Stastny aka Botanicus
+
+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.textile

@@ -0,0 +1,88 @@
+h1. About
+
+Cart is framework agnostic solution for shopping cart. There are two existing imlementations. First is *Cart::Simple* which is just basic cart which can store only ID of products without any metadata. The second is *Cart::Advanced* and it is good when you have not just product, but also some metadata as size or color of product etc.
+
+h1. Initialization
+
+h2. Cart::Simple
+
+<pre>
+require "cart/simple"
+Cart.product_model = Product
+</pre>
+
+h2. Cart::Advanced
+
+<pre>
+require "cart/advanced"
+Cart.metadata_model = OrderItem
+</pre>
+
+Metadata model must respond to serialize object method and deserialize class method for storing and restoring data:
+
+<pre>
+class OrderItem
+  include DataMapper::Resource
+  class << self
+    def deserialize(data)
+      self.new(YAML::load(data))
+    end
+  end
+
+  def serialize
+    {:size => self.size, :product_id => self.product.id}.to_yaml
+  end
+end
+</pre>
+
+h2. Logger
+
+Cart is just simple API for your favorite framework, so it haven't any logger itself and it just use the logger of your framework. The only thing you need is setup it:
+
+<pre>
+# whatever what respond to debug method
+Cart.logger = Merb.logger
+</pre>
+
+Maybe you would like to hook the logger, for example add information that the message comes from cart or maybe you just use framework which hasn't any logger at all. In this case you can set logger to lambda or whatever callable object:
+
+<pre>
+# or whatever what respond to to_proc method
+Cart.logger = method(:puts)
+Cart.logger = lambda { |msg| puts(msg) }
+</pre>
+
+h1. Usage
+
+<pre>
+class Application < Merb::Controller
+  # it must be deserialized in each request,
+  # even with memory session store
+  before :initialize_cart
+  
+  def initialize_cart
+    @cart = cookies[:cart] ? Cart.load(cookies[:cart]) : Cart.new
+  end
+
+  def save_cart
+    cookies[:cart] = @cart.save
+  end
+
+  def reset_cart
+    cookies.delete(:cart)
+    @cart = Cart.new
+  end
+
+  def add_to_cart(order_item)
+    self.initialize_cart unless @cart
+    @cart.add(order_item)
+    self.save_cart
+  end
+
+  # Remove all the items with responding product and inverted values from cart
+  def remove_from_cart(order_item)
+    @cart.remove(order_item)
+    self.save_cart
+  end
+end
+</pre>

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+GEM_NAME = "cart"
+AUTHOR = "Jakub Stastny aka Botanicus"
+EMAIL = "knava.bestvinensis@gmail.com"
+HOMEPAGE = "http://101Ideas.cz/"
+SUMMARY = "Framework agnostic cart solution"
+GEM_VERSION = "0.0.1"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.textile", "LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.textile Rakefile) + Dir.glob("{lib,spec,app,public,stubs}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+def sudo_gem(cmd)
+  sh "#{SUDO} #{RUBY} -S gem #{cmd}", :verbose => false
+end
+
+desc "Install #{GEM_NAME} #{GEM_VERSION}"
+task :install => [ :package ] do
+  sudo_gem "install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
+end
+
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION}"
+task :uninstall => [ :clobber ] do
+  sudo_gem "uninstall #{GEM_NAME} -v#{GEM_VERSION} -Ix"
+end
+
+require 'spec/rake/spectask'
+desc 'Default: run spec examples'
+task :default => 'spec'

data/TODO

@@ -0,0 +1,7 @@
+- spec advanced and simple carts (other stuff should work)
+- simple and advanced carts should have same interface
+- it should works without logger
+- move all the stuff into model (Cart::Simple.new etc)
+- config should take strings as well (Cart.product_model = "Product")
+- config should have default values (Product, OrderItem)
+- standalone configuration class (maybe something like configatron?) => easier testing

data/cart.gemspec

@@ -0,0 +1,21 @@
+begin
+  require "rubygems/specification"
+rescue SecurityError
+  # http://gems.github.com
+end
+
+VERSION  = "0.0.1"
+SPECIFICATION = ::Gem::Specification.new do |s|
+  s.name = "cart"
+  s.version = VERSION
+  s.authors = ["Jakub Šťastný aka Botanicus"]
+  s.homepage = "http://github.com/botanicus/cart"
+  s.summary = "Cart is framework agnostic solution for shopping cart."
+  s.description = "Cart is framework agnostic solution for shopping cart. There are two existing imlementations. First is *Cart::Simple* which is just basic cart which can store only ID of products without any metadata. The second is *Cart::Advanced* and it is good when you have not just product, but also some metadata as size or color of product etc."
+  s.cert_chain = nil
+  s.email = ["knava.bestvinensis", "gmail.com"].join("@")
+  s.files = Dir.glob("**/*") - Dir.glob("pkg/*")
+  s.require_paths = ["lib"]
+  # s.required_ruby_version = ::Gem::Requirement.new(">= 1.9.1")
+  # s.rubyforge_project = "cart"
+end

data/lib/cart/advanced.rb

@@ -0,0 +1,108 @@
+require "cart/config"
+
+class Cart
+  def self.load(data)
+    # return new cart if nil or empty string is given
+    return self.new if data.nil? or data.empty?
+    data  = data.split(";")
+    # compact output array, self.metadata_model.deserialize could return nil
+    items = data.map { |item| self.metadata_model.deserialize(item) }.compact
+    return self.new(*items)
+  end
+
+  attr_reader :items
+
+  def initialize(*items)
+    # raise ArgumentError unless items.all? { |item| item.is_a?(@config.metadata_model) || item.nil? }
+    @items = items
+    @config = self.class
+    @config.logger.debug("Cart initialized: #{self.inspect}")
+  end
+
+  # takes array of products
+  def items=(items)
+    raise ArgumentError if not items.respond_to?(:each) # not just arrays
+    raise ArgumentError if not items.all? { |product| product.kind_of?(@config.metadata_model) }
+    @items = items
+  end
+
+  # params_list must be list of hashes or list of @config.metadata_model instances
+  def add(*params_list)
+    params_list.each do |params|
+      if params.is_a?(Hash)
+        new_item = @config.metadata_model.new(params)
+      else
+        new_item = params
+      end
+      @items.map do |item|
+        if items_equal?(item, new_item)
+          item.count += new_item.count
+          @config.logger.debug("Item #{item.inspect} count was increased to #{item.count} (by #{new_item.count})")
+          return # important
+        end
+      end
+      @items.push(new_item)
+      @config.logger.debug("Item #{new_item.inspect} was added to cart")
+      return new_item.product
+    end
+  end
+  
+  def items_equal?(old, new)
+    # this is important, we must compare all the properties exclude count
+    old = old.dup.tap { |old| old.count = 1 }
+    new = new.dup.tap { |new| new.count = 1 }
+    # from form empty values goes as "", but deserialized empty items are nil
+    properties = new.class.properties.map(&:name)
+    properties.each do |property|
+      value = new.send(property)
+      new.send("#{property}=", nil) if value.respond_to?(:empty?) && value.empty?
+    end
+    new.eql?(old)
+  end
+
+  def remove(params)
+    raise ArgumentError unless params.is_a?(Hash)
+    item_to_remove = @config.metadata_model.new(params)
+    p [item_to_remove], @items ####
+    pre = @items.dup
+    @items.delete_if { |item| items_equal?(item, item_to_remove) }
+    removed = pre - @items
+    if removed.first
+      @config.logger.debug("Item #{removed.first.inspect} was removed from cart")
+    else
+      @config.logger.debug("Any item matched")
+    end
+  end
+
+  def price
+    @items.map { |item| item.price }.inject(:+)
+  end
+
+  def vat
+    @items.map { |item| item.vat }.inject(:+)
+  end
+
+  def price_without_vat
+    @items.map { |item| item.price_without_vat }.inject(:+)
+  end
+
+  def save
+    data = @items.map { |item| item.serialize }.join(";")
+    @config.logger.debug("Cart saved: #{data.inspect}")
+    return data
+  end
+
+  def each(&block)
+    @items.each do |item|
+      block.call(item)
+    end
+  end
+  
+  def empty?
+    @items.empty?
+  end
+
+  def count
+    @items.length
+  end
+end

data/lib/cart/config.rb

@@ -0,0 +1,30 @@
+require "cart/logger_stub"
+
+class NotInitializedError < StandardError ; end
+
+class Cart
+  class << self
+    attr_writer :product_model, :metadata_model
+    def product_model
+      @product_model || raise(NotInitializedError)
+    end
+
+    def metadata_model
+      @metadata_model || raise(NotInitializedError)
+    end
+
+    def logger
+      @logger || raise(NotInitializedError)
+    end
+
+    def logger=(logger)
+      if logger.respond_to?(:to_proc)
+        @logger = LoggerStub.new(logger)
+      elsif logger.respond_to?(:debug)
+        @logger = logger
+      else
+        raise "Given logger must be callable object (Proc or Method for example) or an object with debug method."
+      end
+    end
+  end
+end

data/lib/cart/logger_stub.rb

@@ -0,0 +1,15 @@
+# This class is just a wrapper which give you 
+# chance to give callable object instead of logger.
+# See README file for more informations.
+
+# LoggerStub.new lambda { |message| puts message }
+# LoggerStub.new(method(:puts))
+class LoggerStub
+  def initialize(callable)
+    @callable = callable
+  end
+
+  def debug(message)
+    @callable.call(message)
+  end
+end

data/lib/cart/simple.rb

@@ -0,0 +1,78 @@
+require "ostruct"
+require "cart/config"
+
+class CartItem < OpenStruct
+  undef :id
+end
+
+# NOTE: all public methods works with products, not with their IDs
+class Cart
+  def self.load(data)
+    cart = Cart.new
+    unless data.nil?
+      data = YAML::load(data)
+      cart.items = data.map { |id| @config.product_model.get(id) }
+    end
+    return cart
+  end
+
+  # returns array of products
+  def items
+    @items.map { |item| @config.product_model.get(item) }
+  end
+
+  def inspect
+    %{<cart @items=#{@config.product_model}#{@items.map { |i| i.id }.inspect}>}
+  end
+
+  # takes array of products
+  def items=(products)
+    raise ArgumentError if not products.respond_to?(:each) # not just arrays
+    raise ArgumentError if not products.all? { |product| product.kind_of?(@config.product_model) }
+    @items = products.to_a
+  end
+
+  def initialize
+    @items = Array.new
+    @config = self.class
+  end
+
+  def save
+    @items.map { |product| product.id }.to_yaml
+  end
+
+  def add(product, count = 1)
+    raise ArgumentError unless product.kind_of(@config.product_model)
+    if item = find(product)
+      item.count += count
+    else
+      struct = CartItem.new
+      struct.id = id
+      struct.count = count
+      @items.push(struct)
+    end
+  end
+
+  # remove all products with id 1
+  # cart.remove(1)
+  # remove 2 products with id 1
+  # cart.remove(1, 2)
+  def remove(product, count = nil)
+    if item = find(product)
+      if count.nil? || item.count <= count
+        @items.delete(item)
+      elsif item.count > count
+        item.count = (item.count - count)
+      end
+    end
+  end
+
+  def empty?
+    @items.empty?
+  end
+
+  protected
+  def find(product)
+    @items.find { |item| item.id.eql?(product.id) }
+  end
+end

data/spec/cart/advanced_spec.rb

@@ -0,0 +1,135 @@
+require File.join(File.dirname(__FILE__), '..', "spec_helper")
+require "cart/advanced"
+
+Cart.metadata_model = OrderItem
+Cart.logger = lambda { }
+
+describe Cart do
+  before(:each) do
+    items = 10.of { OrderItem.make(:saved_products) }
+    # we need to save all the products otherwise we can't
+    # serialize the cart (we need to know product ID)
+    @cart = Cart.new(*items)
+  end
+
+  describe ".load" do
+    it "should load serialized items" do
+      loaded_cart = Cart.load(@cart.save)
+      loaded_cart.items.should eql(@cart.items)
+    end
+
+    it "should return empty cart if first (and only) argument is nil" do
+      Cart.load(nil).items.should eql(Array.new)
+    end
+
+    it "should return empty cart if first (and only) argument is empty string" do
+      Cart.load(String.new).items.should eql(Array.new)
+    end
+  end
+
+  describe "#items" do
+    it "should create new cart with empty items" do
+      Cart.new.items.should be_empty
+    end
+
+    it "should be array of order items" do
+      @cart.items.all? { |item| item.kind_of?(OrderItem) }.should be_true
+    end
+  end
+
+  describe "#items=" do
+    it "should raise ArgumentError if first (and only) argument isn't collection" do
+      lambda { @cart.items = 1 }.should raise_error(ArgumentError)
+    end
+
+    it "should raise ArgumentError if some of items isn't integer" do
+      lambda { @cart.items = [1, "foo"] }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#save" do
+    it "should serialize items" do
+      @cart.save.should be_kind_of(String)
+    end
+
+    it "should be in valid format" do
+      pattern = 10.of {'\d+,\d,\d+'}.join(";")
+      @cart.save.should match(/^#{pattern}$/)
+    end
+  end
+
+  describe "#add" do
+    before do
+      # NOTE: when inspecting @item, u can see that
+      # product_id is nil althought we set the product.
+      # It is OK, product_id is set when product is saving
+      @item = OrderItem.make
+      @cart = Cart.new(@item)
+      @item.product.category = Category.generate(:standalone)
+      @item.product.save
+      @params = {:product => @item.product, :inverted => @item.inverted}
+    end
+
+    it "should add one order item into cart's items by default" do
+      lambda { @cart.add(@params) }.should_not change { @cart.count }
+    end
+
+    it "should increase count of order item if product and inverted are same" do
+      item = @cart.items.find { |item| item.product.eql?(@item.product) }
+      lambda { @cart.add(@params) }.should change { item.count }.by(1)
+    end
+
+    it "should add more order items into cart's items if product is different" do
+      another = Product.generate(:standalone)
+      params = @params.merge(:product => another)
+      lambda { @cart.add(params) }.should change { @cart.count }.by(1)
+    end
+
+    it "should add more order items into cart's items if product is same, but inverted is different" do
+      params = @params.merge(:inverted => (not @item.inverted))
+      lambda { @cart.add(params) }.should change { @cart.count }.by(1)
+    end
+
+    it "should raise error if params are not hash" do
+      lambda { @cart.add(@item) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#remove" do
+    before do
+      # NOTE: when inspecting @item, u can see that
+      # product_id is nil althought we set the product.
+      # It is OK, product_id is set when product is saving
+      @item = OrderItem.make
+      @cart = Cart.new(@item)
+      @item.product.category = Category.generate(:standalone)
+      @item.product.save
+      @params = {:product => @item.product, :inverted => @item.inverted}
+    end
+
+    it "should remove order item with coresponding product and inverted options from cart's items" do
+      lambda { @cart.remove(@params) }.should change { @cart.count }.by(-1)
+    end
+
+    it "should raise error if params are not hash" do
+      lambda { @cart.remove(@item) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#empty?" do
+    it "should returns true if there aren't any items" do
+      Cart.new.should be_empty
+    end
+
+    it "should returns false if there aren't any items" do
+      @cart.should_not be_empty
+    end
+  end
+
+  describe "#count" do
+    it "should returns count of items" do
+      Cart.new.count.should eql(0)
+      @cart.count.should eql(10)
+    end
+  end
+end

data/spec/cart/config_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '..', "spec_helper")
+require "cart/config"
+
+class Logger
+  def debug(message)
+    puts(message)
+  end
+end
+
+describe Cart do
+  describe "#product_model & #product_model=" do
+    it "should returns given model if configured" do
+      Cart.product_model = Product
+      Cart.product_model.should eql(Product)
+    end
+
+    it "should raise an exception unless configured" do
+      Cart.product_model = nil
+      lambda { Cart.product_model }.should raise_error(NotInitializedError)
+    end
+  end
+
+  describe "#metadata_model & #metadata_model=" do
+    it "should returns given model if configured" do
+      Cart.metadata_model = Product
+      Cart.metadata_model.should eql(Product)
+    end
+
+    it "should raise an exception unless configured" do
+      Cart.metadata_model = nil
+      lambda { Cart.metadata_model }.should raise_error(NotInitializedError)
+    end
+  end
+
+  describe "#logger & #logger=" do
+    it "should works with lambdas" do
+      Cart.logger = Logger.new
+      Cart.logger.should be_kind_of(Logger)
+    end
+
+    it "should raise exception when object is not callable and not respond to debug method" do
+      lambda { Cart.logger = Class.new }.should raise_error
+    end
+
+    it "should works with lambdas" do
+      Cart.logger = lambda { |msg| puts(msg) }
+      Cart.logger.should be_kind_of(LoggerStub)
+    end
+
+    it "should works with references to method" do
+      Cart.logger = method(:puts)
+      Cart.logger.should be_kind_of(LoggerStub)
+    end
+  end
+end

data/spec/cart/logger_stub_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), '..', "spec_helper")
+require "cart/logger_stub"
+
+describe LoggerStub do
+  it "should works with lambdas" do
+    # just return the message
+    proc = lambda { |message| message }
+    logger = LoggerStub.new(proc)
+    logger.debug("Hey, it works!").should eql("Hey, it works!")
+  end
+
+  it "should works with methods" do
+    # just return the message
+    def just_return(message) ; message ; end
+    logger = LoggerStub.new(method(:just_return))
+    logger.debug("Hey, it works!").should eql("Hey, it works!")
+  end
+end

data/spec/cart/simple_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), '..', "spec_helper")
+require "cart/simple"
+
+Cart.product_model = Product
+Cart.logger = lambda { }
+
+describe Cart do
+  before(:each) do
+    @cart = Cart.new
+    10.times { Product.create }
+    @cart.items = Product.all
+  end
+
+  describe ".load" do
+    it "should load serialized items" do
+      pending "works, but this spec do not"
+      loaded_cart = Cart.load(@cart.save)
+      loaded_cart.items.should eql(@cart.items)
+    end
+
+    it "should return empty cart if first (and only) argument is nil" do
+      Cart.load(nil).items.should eql(Array.new)
+    end
+  end
+
+  describe "#items" do
+    it "should create new cart with empty items" do
+      Cart.new.items.should be_empty
+    end
+
+    it "should be array of products" do
+      pending "works, but this spec do not"
+      @cart.items.all? { |item| item.kind_of?(Product) }.should be_true
+    end
+  end
+
+  describe "#items=" do
+    it "should raise ArgumentError if first (and only) argument isn't collection" do
+      lambda { @cart.items = 1 }.should raise_error(ArgumentError)
+    end
+
+    it "should raise ArgumentError if some of items isn't integer" do
+      lambda { @cart.items = [1, "foo"] }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#inspect" do
+    it "should show id of products in items"
+  end
+
+  describe "#save" do
+    it "should serialize items" do
+      @cart.save.should be_kind_of(String)
+    end
+
+    it "should be regular YAML" do
+      lambda { YAML::load(@cart.save) }.should_not raise_error
+    end
+  end
+
+  describe "#add" do
+    it "should add one product into cart's items by default"
+    it "should add more product into cart's items when optional argument given"
+  end
+
+  describe "#remove" do
+    it "should remove one product into cart's items by default"
+    it "should remove more product into cart's items when optional argument given"
+  end
+
+  describe "#empty?" do
+    it "should returns true if there aren't any items" do
+      Cart.new.should be_empty
+    end
+
+    it "should returns false if there aren't any items" do
+      @cart.should_not be_empty
+    end
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,22 @@
+class Product
+  include DataMapper::Resource
+  property :id, Serial
+end
+
+class OrderItem
+  include DataMapper::Resource
+  property :id, Serial
+  property :size, Enum["10x20", "20x30", "25x40"]
+  property :inverted, Boolean
+
+  def serialize
+  end
+
+  class << self
+    def restore(data)
+    end
+
+    def fixture(params = Hash.new)
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--format
+progress
+--loadby
+mtime

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$: << File.dirname(__FILE__) + "/../lib"
+
+require "dm-core"
+require "dm-types"
+require File.dirname(__FILE__) + "/factories"
+
+DataMapper.setup(:default, "sqlite3::memory")
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    DataMapper.auto_migrate!
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: cart
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Jakub \xC5\xA0\xC5\xA5astn\xC3\xBD aka Botanicus"
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2009-11-26 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Cart is framework agnostic solution for shopping cart. There are two existing imlementations. First is *Cart::Simple* which is just basic cart which can store only ID of products without any metadata. The second is *Cart::Advanced* and it is good when you have not just product, but also some metadata as size or color of product etc.
+email: knava.bestvinensis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- cart.gemspec
+- lib/cart/advanced.rb
+- lib/cart/config.rb
+- lib/cart/logger_stub.rb
+- lib/cart/simple.rb
+- LICENSE
+- Rakefile
+- README.textile
+- spec/cart/advanced_spec.rb
+- spec/cart/config_spec.rb
+- spec/cart/logger_stub_spec.rb
+- spec/cart/simple_spec.rb
+- spec/factories.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- TODO
+has_rdoc: true
+homepage: http://github.com/botanicus/cart
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Cart is framework agnostic solution for shopping cart.
+test_files: []
+