ace_of_spades 0.0.1.pre

data/.gitignore

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

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p327

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/lib/.+_spec\.rb$})
+  watch(%r{^lib/ace_of_spades/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('lib/ace_of_spades.rb') { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Dom Kiva-Meyer
+
+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,188 @@
+# Ace Of Spades
+
+A simple and flexible playing cards library.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ace_of_spades'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ace_of_spades
+
+## Usage
+
+    require "ace_of_spades"
+    include AceOfSpades
+
+### Deck
+
+Deck accepts an optional hash for initialization. Defaults are: `{aces_high: true, shuffle: true, jokers: false}`
+
+    deck = Deck.new(shuffle: false, jokers: true)
+    => [Two of Clubs, Three of Clubs, Four of Clubs, Five of Clubs, . . . Jack of Spades, Queen of Spades, King of Spades, Ace of Spades, Joker, Joker]
+
+Deck also accepts `false` to initialize without initializing cards.
+
+    deck = Deck.new(false)
+    => []
+
+Cards can be initialized later with `#initialize_cards`
+
+    deck.initialize_cards(shuffle: false, jokers: true)
+    => [Two of Clubs, Three of Clubs, Four of Clubs, Five of Clubs, . . . Jack of Spades, Queen of Spades, King of Spades, Ace of Spades, Joker, Joker]
+    
+Deck is array-like and can be manipulated like an array. All Array and Enumerable methods are available.
+
+    deck.first
+    => Two of Clubs
+    
+Ace ranking can be retrieved and set with `#aces_high?` and `#aces_high=`
+
+    deck.aces_high?
+    => true
+    deck.aces_high = false
+    => false
+    deck.aces_high?
+    => false
+    
+Cards can be added with `#add_card`
+
+    deck.add_card(:ace, :spades)
+    deck.last
+    => Ace of Spades
+
+Any card-related methods on Deck accept valid arguments for Card.new (outlined below).
+
+Specific cards can be found with `#find_cards`. It can accept arguments and/or a block. It will return all cards that match the arguments or for which the block evaluates to true.
+
+    deck.find_cards(:ace) { |card| card.joker? }
+    =>[Ace of Clubs, Ace of Diamonds, Ace of Hearts, Ace of Spades, Joker, Joker]
+
+Similarly, `#find_card` will return the first card that the arguments match or for which the block evaluates to true.
+
+    deck.find_card(:spade) { |card| card.ace? }
+    => Ace of Clubs
+
+`Ace of Clubs` was returned because the block evaluated to true. If no matching cards are found, `#find_cards` will return `nil`.
+
+`#remove_cards` works just like `#find_cards`, but will remove all matching cards from the deck.
+
+    deck.jokers?
+    => true
+    deck.remove_cards(:joker)
+    => [Joker, Joker]
+    deck.jokers?
+    => false
+    
+`#deal` will remove the specified number of cards from the deck, store them separately, and return them. The default argument is 1.
+
+    deck.deal
+    => Two of Clubs
+    deck.count
+    => 51
+    deck.deal(9)
+    => [Three of Clubs, Four of Clubs, Five of Clubs, Six of Clubs, Seven of Clubs, Eight of Clubs, Nine of Clubs, Ten of Clubs, Jack of Clubs]
+    deck.count
+    => 42
+    
+`#shuffle`, `#shuffle!`, `#unshuffle`, `#unshuffle!`, do exactly what you'd think. The first two shuffle the deck and the last two unshuffle it (sorted from lowest to highest card). The bang versions are destructive.
+
+`#valid?` returns true if the deck consists of 13 different cards from each suit and 0 or 2 jokers.
+
+    deck.valid?
+    => true
+    deck.remove_cards(:ace, :spades)
+    deck.valid?
+    => false
+
+### Card
+
+Card accepts a value and a suit for initialization. The value can be an integer (1-14), a face card name, or the first letter of a face card name. The latter two can be symbols or strings and are case insensitive. The suit can be the plural or singular name of a suit or the first letter of the name of the suit. Again, symbols or strings are accepted and are case insensitive. Example: `Card.new` with `(:ace, :spades)`, `("ACE", :spades)`, `(:ace, "Spade")`, `(1, :spades)`, `(14, :spades)`, `(:A, :S)`, `("a", :spade)`,  etc., would all produce the same card.
+
+    card = Card.new(:ace, :spades)
+    => Ace of Spades
+    
+A joker is a card with neither a value or suit and can be initialized by passing in `joker`.
+
+    joker = Card.new(:joker)
+    => Joker
+    
+`.wrap` will return the same instance of Card that is passed in if a Card instance is passed in, a new Card instance if valid arguments are passed in, or nil if invalid arguments are passed.
+    
+    Card.wrap(card)
+    => Ace of Spades
+    Card.wrap('ace', 'spade')
+    => Ace of Spades
+    Card.wrap('foo')
+    => nil
+    
+Both suit and value have readers and writers defined. Setting a suit or value will first wrap the argument in the proper class.
+
+    card.value
+    => Ace
+    card.value = 5
+    card.value
+    => Five
+    
+Cards can be compared.
+
+    ace = Card.new(:ace, :spades)
+    king = Card.new(:king, :spades)
+    ace > king
+    => true
+
+Cards are compared by suit first and, in the event of a tie, by value. Aces respect the `aces_high` boolean value of the parent deck.
+
+`#to_s` and `#to_sym` convert a card to a String and Symbol respectively.
+
+    ace.to_s
+    => "Ace of Spades"
+    ace.to_sym
+    => :"Ace of Spades"
+
+Cards respond to valid predicate methods that are dynamically defined based on valid values and suits.
+
+    ace.joker? || ace.heart?
+    => false
+    ace.ace? && ace.spade? && ace.spades? && ace.ace_of_spades? && ace.a? && ace.s?
+    => true
+    ace.foo?
+    => NoMethodError: undefined method 'foo?'
+
+`#valid` checks whether a card is valid. A card is considered valid if it has a valid value and suit or if both the value and suit are `nil` (joker).
+  
+    ace.valid?
+    => true
+    ace.suit = :foo
+    ace.valid?
+    => false
+
+### Value & Suit
+
+In general you shouldn't have to touch Value and Suit since Deck and Card handle this for you. However, their interfaces are very similar to Card, if you need to use them directly.
+
+## Roadmap
+
+* Abstract Deck functionality into a container class (Cardtainer?) from which Deck, Metadeck (deck of decks), Hand, and Game will inherit
+* Implement Hand, Metadeck, and Game
+* Implement customizable logic for joker comparison, Hand comparison, Suit ranking, and Deck validation
+* Extract shared parsing functionality into a Parser module
+* Extract shared functionality of Value and Suit into a module
+* Separate unit and integration tests
+* Add YARD documentation
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes and tests (`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/ace_of_spades.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.name          = "ace_of_spades"
+  gem.version       = "0.0.1.pre"
+  gem.authors       = ["Dom Kiva-Meyer"]
+  gem.email         = ["hello@domkm.com"]
+  gem.description   = "A simple and flexible playing cards library."
+  gem.summary       = "A simple and flexible playing cards library."
+  gem.homepage      = "https://github.com/domkm/ace_of_spades"
+
+  gem.files         = `git ls-files`.split($/)
+  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_development_dependency "rspec", "~> 2.11.0"
+  gem.add_development_dependency "guard", "~> 1.5.3"
+  gem.add_development_dependency "guard-rspec", "~> 2.1.1"
+end

data/lib/ace_of_spades.rb

@@ -0,0 +1,8 @@
+module AceOfSpades
+  VALUES = [:Ace, :Two, :Three, :Four, :Five, :Six, :Seven, :Eight, :Nine, :Ten, :Jack, :Queen, :King, :Ace]
+  SUITS  = [:Clubs, :Diamonds, :Hearts, :Spades]
+end
+
+%w[deck card value suit].each do |file|
+  require "ace_of_spades/#{file}"
+end

data/lib/ace_of_spades/card.rb

@@ -0,0 +1,88 @@
+class AceOfSpades::Card
+  include Comparable
+  attr_reader :value, :suit
+  attr_accessor :deck
+
+  def initialize(*args)
+    first, second  = args[0] || false, args[1] || false
+    @value, @suit  = Value.wrap(first), Suit.wrap(second)
+    @value, @suit  = first, second if @value.nil? && @suit.nil?
+    @value = @suit = nil if args.count == 1 && /\Ajoker\z/i === first
+    @value.card = @suit.card = self unless joker?
+    validate!
+  end
+
+  def self.wrap(*args)
+    return args.first if args.first.instance_of?(Card)
+    Card.new(*args)
+  rescue
+    nil
+  end
+
+  def value=(v)
+    @value = Value.wrap(v)
+  end
+
+  def suit=(s)
+    @suit = Suit.wrap(s)
+  end
+
+  def <=>(card)
+    return nil if !card.instance_of?(Card) || card.joker?
+    suit_comparison = suit <=> card.suit
+    return suit_comparison unless suit_comparison == 0
+    value <=> card.value
+  end
+
+  def aces_high?
+    return true if deck.nil?
+    deck.aces_high?
+  end
+    
+  def joker?
+    value.nil? && suit.nil?
+  end
+
+  def to_s
+    return 'Joker' if joker?
+    "#{value.to_s} of #{suit.to_s}"
+  end
+
+  def to_sym
+    to_s.to_sym
+  end
+
+  def valid?
+    return true if joker?
+    value.instance_of?(Value) && suit.instance_of?(Suit)
+  end
+
+  def validate!
+    valid? ? self : invalidate!
+  end
+
+  def method_missing(method, *args, &block)
+    return super unless match = %r(.+\?\z).match(method).to_s.chop.split('_')
+    v, s = match.first, match.last
+    valuable, suitable = Value.valuable?(v), Suit.suitable?(s)
+    if joker? && (suitable || valuable)
+      false
+    elsif valuable && suitable
+      value.send("#{v}?") && suit.send("#{s}?")
+    elsif match.count >= 2
+      super
+    elsif valuable
+      value.send("#{v}?")
+    elsif suitable
+      suit.send("#{s}?")
+    else
+      super
+    end
+  end
+
+  private
+
+  def invalidate!
+    raise "Invalid Card: @value = #{value}, @suit = #{suit}"
+  end
+end

data/lib/ace_of_spades/deck.rb

@@ -0,0 +1,95 @@
+class AceOfSpades::Deck < Array
+  attr_reader :dealt
+  attr_writer :aces_high
+
+  def initialize(opts = {})
+    super()
+    @dealt, @aces_high = [], true
+    return self unless opts
+    opts = {shuffle: true, jokers: false, aces_high: true, jokers: false}.merge(opts)
+    @aces_high = opts[:aces_high]
+    initialize_cards(opts)
+  end
+
+  def find_card(*args, &block)
+    find_cards(*args, &block).first
+  end
+
+  def find_cards(*args, &block)
+    args.map! { |arg| Value.parse(arg) || Suit.parse(arg) || (:joker if %r(\Ajoker\z)i === arg) }.compact!
+    cards.each_with_object([]) do |card, arr|
+      arr.push(card) if ( !args.empty? && args.all? { |arg| card.send("#{arg}?") } ) || ( block.call(card) if block_given? )
+    end
+  end
+
+  def add_card(*args)
+    card = Card.new(*args)
+    card.deck = self
+    push(card)
+  end
+
+  def remove_cards(*args, &block)
+    to_be_removed = find_cards(*args, &block)
+    delete_if { |card| to_be_removed.include?(card) }
+    @dealt.delete_if { |card| to_be_removed.include?(card) }
+    to_be_removed
+  end
+
+  def aces_high?
+    !!@aces_high
+  end
+
+  def jokers?
+    cards.any? { |card| card.joker? }
+  end
+
+  def deal(num = 1)
+    dealt = shift(num)
+    @dealt.concat(dealt)
+    num > 1 ? dealt : dealt.first
+  end
+
+  def shuffle!
+    concat(@dealt)
+    @dealt.clear
+    super
+  end
+
+  def shuffle
+    dup.shuffle!
+  end
+
+  def unshuffle!
+    concat(@dealt)
+    @dealt.clear
+    jokers = remove_cards(:joker)
+    sort!.concat(jokers)
+  end
+
+  def unshuffle
+    dup.unshuffle!
+  end
+  
+  def initialize_cards(opts = {})
+    VALUES[1..-1].product(SUITS) { |value, suit| add_card(value, suit) }
+    2.times { add_card(:joker) } if opts[:jokers]
+    opts[:shuffle] ? shuffle! : unshuffle!
+  end
+  
+  def valid?
+    deck = unshuffle
+    return true if deck.remove_cards(:joker).count == 2 && deck.valid?
+    deck.reduce  do |memo, card| 
+      return false unless memo < card
+      card
+    end
+    return false unless deck.count == 52
+    true
+  end
+
+  private
+  
+  def cards
+    self + @dealt
+  end
+end