Creating a dynamic function in Ruby - ruby

Question

I'm creating a module for a deck of cards. I want the Deck object to be able to accept another implementation of the shuffle method I have written below.
I was originally thinking that my shuffle method should accept a parameter that is any object that responds to shuffle. Is that a good approach here?
I'm not sure exactly how to approach this in Ruby.
module PlayingCards
class Deck
RANKS = [*2..10, 'Jack', 'Queen', 'King', 'Ace']
SUITS = %w{ Clubs Diamonds Hearts Spades }
attr_accessor :cards, :discarded
def initialize(options={})
#cards = []
#discarded = []
options[:number_decks] ||= 1
options[:number_decks].times do
(RANKS).product(SUITS).each do |rank, suit|
#cards << Card.new(rank, suit)
end
end
end
def shuffle()
cards.push(*discarded).shuffle!
discarded = []
self
end
end
end
This is the hand class that is responsible for drawing cards from the deck and also folding a hand.
module PlayingCards
class Hand
attr_accessor :deck, :draw_count, :cards, :discarded
def initialize(args = {})
#deck = args[:deck]
#discarded = args[:deck].discarded
#draw_count = args[:draw_count]
#cards = []
end
def draw
draw_count.times do
cards.push(deck.cards[0])
deck.cards.shift
end
cards
end
def fold
discarded.push(cards).flatten!
end
end
end

Answer 1

I want the Deck object to be able to accept another implementation of the shuffle method I have written below.
There are a few ways to implement this. There's no single right answer. Here's a few techniques:
Just define multiple methods:
def shuffle
cards.push(*discarded).shuffle!
discarded = []
self
end
# For example
def shuffle_before_replacing
cards.shuffle!
cards.push(*discarded)
discarded = []
self
end
Define a higher order method, for example:
SHUFFLE_MODES = {
standard: ->(cards, discarded) { cards.push(*discarded).shuffle },
# ...
}
def shuffle(mode: :standard)
cards = SHUFFLE_MODES.fetch(mode).call(cards, discarded)
discarded = []
self
end
Inject a dependency to perform the shuffling, for example:
def shuffle(shuffler: Shuffler::Standard)
shuffler = shuffler.new(cards, discarded)
shuffler.shuffle
cards = shuffler.cards
shuffler = shuffler.discarded
self
end
# ...
module Shuffler
class Base
attr_reader :cards, :discarded
def initialize(cards, discarded)
#cards = cards
#discarded = discarded
end
end
end
module Shuffler
class Standard < Base
def shuffle
#cards.push(*discarded).shuffle
#discarded = []
self
end
end
end
module Shuffler
class BeforeReplacing < Base
def shuffle
#cards.shuffle!
#cards.push(*discarded)
#discarded = []
self
end
end
end
end
One main benefits of this third approach is that you can define Shufflers independently to the Deck class - so for example, perhaps you'll eventually have multiple types of Deck that can each use the Shuffler interface in different ways. (For example, maybe you'll want to shuffle different things, or shuffle multiple times.)
Likewise, you can also test the Shufflers independently to the Deck. This works both ways; you can also now test the Deck independently to the Shuffler (by passing a mock object into the Deck#shuffle method).
This technique is the most advanced of the three, and is something I'd only usually expect an experienced developer to fully utilise, in more complex scenarios. It's hard to say whether such an abstraction is even with the effort yet in your case, given the limited information I have!
All code above is untested, so may not be spot on, but hopefully this gives you some inspiration.