jazz_model 0.1.0 → 0.2.0

data/lib/jazz_model/definitions/keys.rb

@@ -1,48 +1,48 @@
 JazzModel::Definition.define :keys do
-  JazzModel::Key.create!(:name => 'C', :long_name => 'C', :index => 0, :letter_index => 0, :cycle_index => 0)
-  JazzModel::Key.create!(:name => 'B#', :long_name => 'B Sharp', :index => 0, :letter_index => 6, :cycle_index => 0, :primary => false)
-  JazzModel::Key.create!(:name => 'Dbb', :long_name => 'D Double-Flat', :index => 0, :letter_index => 1, :cycle_index => 0, :primary => false)
+  JazzModel::Key.create!(name: "C", long_name: "C", index: 0, letter_index: 0, cycle_index: 0)
+  JazzModel::Key.create!(name: "B#", long_name: "B Sharp", index: 0, letter_index: 6, cycle_index: 0, primary: false)
+  JazzModel::Key.create!(name: "Dbb", long_name: "D Double-Flat", index: 0, letter_index: 1, cycle_index: 0, primary: false)
 
-  JazzModel::Key.create!(:name => 'F', :long_name => 'F', :index => 5, :letter_index => 3, :cycle_index => 1)
-  JazzModel::Key.create!(:name => 'E#', :long_name => 'E Sharp', :index => 5, :letter_index => 2, :cycle_index => 1, :primary => false)
-  JazzModel::Key.create!(:name => 'Gbb', :long_name => 'G Double-Flat', :index => 5, :letter_index => 4, :cycle_index => 1, :primary => false)
+  JazzModel::Key.create!(name: "F", long_name: "F", index: 5, letter_index: 3, cycle_index: 1)
+  JazzModel::Key.create!(name: "E#", long_name: "E Sharp", index: 5, letter_index: 2, cycle_index: 1, primary: false)
+  JazzModel::Key.create!(name: "Gbb", long_name: "G Double-Flat", index: 5, letter_index: 4, cycle_index: 1, primary: false)
 
-  JazzModel::Key.create!(:name => 'Bb', :long_name => 'B Flat', :index => 10, :letter_index => 6, :cycle_index => 2)
-  JazzModel::Key.create!(:name => 'A#', :long_name => 'A Sharp', :index => 10, :letter_index => 5, :cycle_index => 2, :primary => false)
-  JazzModel::Key.create!(:name => 'Cbb', :long_name => 'C Double-Flat', :index => 10, :letter_index => 0, :cycle_index => 2, :primary => false)
+  JazzModel::Key.create!(name: "Bb", long_name: "B Flat", index: 10, letter_index: 6, cycle_index: 2)
+  JazzModel::Key.create!(name: "A#", long_name: "A Sharp", index: 10, letter_index: 5, cycle_index: 2, primary: false)
+  JazzModel::Key.create!(name: "Cbb", long_name: "C Double-Flat", index: 10, letter_index: 0, cycle_index: 2, primary: false)
 
-  JazzModel::Key.create!(:name => 'Eb', :long_name => 'E Flat', :index => 3, :letter_index => 2, :cycle_index => 3)
-  JazzModel::Key.create!(:name => 'D#', :long_name => 'D Sharp', :index => 3, :letter_index => 1, :cycle_index => 3, :primary => false)
-  JazzModel::Key.create!(:name => 'Fbb', :long_name => 'F Double Flat', :index => 3, :letter_index => 3, :cycle_index => 3, :primary => false)
+  JazzModel::Key.create!(name: "Eb", long_name: "E Flat", index: 3, letter_index: 2, cycle_index: 3)
+  JazzModel::Key.create!(name: "D#", long_name: "D Sharp", index: 3, letter_index: 1, cycle_index: 3, primary: false)
+  JazzModel::Key.create!(name: "Fbb", long_name: "F Double Flat", index: 3, letter_index: 3, cycle_index: 3, primary: false)
 
-  JazzModel::Key.create!(:name => 'Ab', :long_name => 'A Flat', :index => 8, :letter_index => 5, :cycle_index => 4)
-  JazzModel::Key.create!(:name => 'G#', :long_name => 'G Sharp', :index => 8, :letter_index => 4, :cycle_index => 4, :primary => false)
+  JazzModel::Key.create!(name: "Ab", long_name: "A Flat", index: 8, letter_index: 5, cycle_index: 4)
+  JazzModel::Key.create!(name: "G#", long_name: "G Sharp", index: 8, letter_index: 4, cycle_index: 4, primary: false)
 
-  JazzModel::Key.create!(:name => 'Db', :long_name => 'D Flat', :index => 1, :letter_index => 1, :cycle_index => 5)
-  JazzModel::Key.create!(:name => 'C#', :long_name => 'C Sharp', :index => 1, :letter_index => 0, :cycle_index => 5, :primary => false)
-  JazzModel::Key.create!(:name => 'B##', :long_name => 'B Double-Sharp', :index => 1, :letter_index => 6, :cycle_index => 5, :primary => false)
+  JazzModel::Key.create!(name: "Db", long_name: "D Flat", index: 1, letter_index: 1, cycle_index: 5)
+  JazzModel::Key.create!(name: "C#", long_name: "C Sharp", index: 1, letter_index: 0, cycle_index: 5, primary: false)
+  JazzModel::Key.create!(name: "B##", long_name: "B Double-Sharp", index: 1, letter_index: 6, cycle_index: 5, primary: false)
 
-  JazzModel::Key.create!(:name => 'Gb', :long_name => 'G Flat', :index => 6, :letter_index => 4, :cycle_index => 6)
-  JazzModel::Key.create!(:name => 'F#', :long_name => 'F Sharp', :index => 6, :letter_index => 3, :cycle_index => 6, :primary => false)
-  JazzModel::Key.create!(:name => 'E##', :long_name => 'E Double-Sharp', :index => 6, :letter_index => 2, :cycle_index => 6, :primary => false)   
+  JazzModel::Key.create!(name: "Gb", long_name: "G Flat", index: 6, letter_index: 4, cycle_index: 6)
+  JazzModel::Key.create!(name: "F#", long_name: "F Sharp", index: 6, letter_index: 3, cycle_index: 6, primary: false)
+  JazzModel::Key.create!(name: "E##", long_name: "E Double-Sharp", index: 6, letter_index: 2, cycle_index: 6, primary: false)
 
-  JazzModel::Key.create!(:name => 'B', :long_name => 'B', :index => 11, :letter_index => 6, :cycle_index => 7)
-  JazzModel::Key.create!(:name => 'Cb', :long_name => 'C Flat', :index => 11, :letter_index => 0, :cycle_index => 7, :primary => false)
-  JazzModel::Key.create!(:name => 'A##', :long_name => 'A Double-Sharp', :index => 11, :letter_index => 5, :cycle_index => 7, :primary => false)
+  JazzModel::Key.create!(name: "B", long_name: "B", index: 11, letter_index: 6, cycle_index: 7)
+  JazzModel::Key.create!(name: "Cb", long_name: "C Flat", index: 11, letter_index: 0, cycle_index: 7, primary: false)
+  JazzModel::Key.create!(name: "A##", long_name: "A Double-Sharp", index: 11, letter_index: 5, cycle_index: 7, primary: false)
 
-  JazzModel::Key.create!(:name => 'E', :long_name => 'E', :index => 4, :letter_index => 2, :cycle_index => 8)
-  JazzModel::Key.create!(:name => 'Fb', :long_name => 'F Flat', :index => 4, :letter_index => 3, :cycle_index => 8, :primary => false)
-  JazzModel::Key.create!(:name => 'D##', :long_name => 'D Double-Sharp', :index => 4, :letter_index => 1, :cycle_index => 8, :primary => false)
+  JazzModel::Key.create!(name: "E", long_name: "E", index: 4, letter_index: 2, cycle_index: 8)
+  JazzModel::Key.create!(name: "Fb", long_name: "F Flat", index: 4, letter_index: 3, cycle_index: 8, primary: false)
+  JazzModel::Key.create!(name: "D##", long_name: "D Double-Sharp", index: 4, letter_index: 1, cycle_index: 8, primary: false)
 
-  JazzModel::Key.create!(:name => 'A', :long_name => 'A', :index => 9, :letter_index => 5, :cycle_index => 9)
-  JazzModel::Key.create!(:name => 'Bbb', :long_name => 'B Double-Flat', :index => 9, :letter_index => 6, :cycle_index => 9, :primary => false)
-  JazzModel::Key.create!(:name => 'G##', :long_name => 'G Double-Sharp', :index => 9, :letter_index => 4, :cycle_index => 9, :primary => false)   
+  JazzModel::Key.create!(name: "A", long_name: "A", index: 9, letter_index: 5, cycle_index: 9)
+  JazzModel::Key.create!(name: "Bbb", long_name: "B Double-Flat", index: 9, letter_index: 6, cycle_index: 9, primary: false)
+  JazzModel::Key.create!(name: "G##", long_name: "G Double-Sharp", index: 9, letter_index: 4, cycle_index: 9, primary: false)
 
-  JazzModel::Key.create!(:name => 'D', :long_name => 'D', :index => 2, :letter_index => 1, :cycle_index => 10)
-  JazzModel::Key.create!(:name => 'C##', :long_name => 'C Double-Sharp', :index => 2, :letter_index => 0, :cycle_index => 10, :primary => false)
-  JazzModel::Key.create!(:name => 'Ebb', :long_name => 'E Double-Flat', :index => 2, :letter_index => 2, :cycle_index => 10, :primary => false)
+  JazzModel::Key.create!(name: "D", long_name: "D", index: 2, letter_index: 1, cycle_index: 10)
+  JazzModel::Key.create!(name: "C##", long_name: "C Double-Sharp", index: 2, letter_index: 0, cycle_index: 10, primary: false)
+  JazzModel::Key.create!(name: "Ebb", long_name: "E Double-Flat", index: 2, letter_index: 2, cycle_index: 10, primary: false)
 
-  JazzModel::Key.create!(:name => 'G', :long_name => 'G', :index => 7, :letter_index => 4, :cycle_index => 11)
-  JazzModel::Key.create!(:name => 'F##', :long_name => 'F Double-Sharp', :index => 7, :letter_index => 3, :cycle_index => 11, :primary => false)
-  JazzModel::Key.create!(:name => 'Abb', :long_name => 'A Double-Flat', :index => 7, :letter_index => 5, :cycle_index => 11, :primary => false)
-end
+  JazzModel::Key.create!(name: "G", long_name: "G", index: 7, letter_index: 4, cycle_index: 11)
+  JazzModel::Key.create!(name: "F##", long_name: "F Double-Sharp", index: 7, letter_index: 3, cycle_index: 11, primary: false)
+  JazzModel::Key.create!(name: "Abb", long_name: "A Double-Flat", index: 7, letter_index: 5, cycle_index: 11, primary: false)
+end

data/lib/jazz_model/definitions.rb

@@ -0,0 +1,3 @@
+require "jazz_model"
+
+JazzModel::Base.load_definitions

data/lib/jazz_model/key.rb

@@ -1,49 +1,46 @@
 module JazzModel
-  # A key represents a specific theoretic tone mapped to a pitch and a letter 
-  # index.  Keys are defined for all letters A-G and all sharp/flat values 
+  # A key represents a specific theoretic tone mapped to a pitch and a letter
+  # index.  Keys are defined for all letters A-G and all sharp/flat values
   # within two semitons (e.g. Dbb, D Double-Flat enharmonic with C).
   #
-  # Each key is associated an index between 0-11 to represent the actual pitch 
-  # within the chromatic scale.  
-  # Each key is also assigned a "letter index" which represents a relative letter 
-  # value.  This index is crucial as it disambiguates theoretical tone differences 
-  # such as Eb and D#.  Doing so also supports correct double-sharp and double-flat 
-  # interpretations which are rare but theoretically different from their enharmonic 
+  # Each key is associated an index between 0-11 to represent the actual pitch
+  # within the chromatic scale.
+  # Each key is also assigned a "letter index" which represents a relative letter
+  # value.  This index is crucial as it disambiguates theoretical tone differences
+  # such as Eb and D#.  Doing so also supports correct double-sharp and double-flat
+  # interpretations which are rare but theoretically different from their enharmonic
   # counterparts.
-  # 
+  #
   class Key < JazzModel::Base
-    Letters = ['C' => 0, 'D' => 1, 'E' => 2, 'F' => 3, 'G' => 4, 'A' => 5, 'B' => 6]
-  
     # Finds a key given a tonal index 0-11 and a letter index (to disambiguate enharmonic keys)
     def self.from_index(value, preferred_letter = nil)
-      self.all.find {|k| k.index == value && (preferred_letter.nil? || k.letter_index == preferred_letter)}
+      all.find { |k| k.index == value && (preferred_letter.nil? || k.letter_index == preferred_letter) }
     end
-  
+
     # Finds a key object given the name (such as Eb)
     def self.from_name(value)
-      self.all.find {|k| k.name == value}
+      all.find { |k| k.name == value }
     end
-  
+
     # Finds a key object based on the name:
     # +Key['Eb']+
-    # 
+    #
     def self.[](value)
-      self.from_name(value) || self.from_index(value)
+      from_name(value) || from_index(value)
     end
-  
+
     # Returns an array of the 12 primary keys (definitions around the cycle of fourths)
     def self.primaries
-      self.find_all_by_primary(true)
+      where(primary: true).to_a
     end
-  
+
     def self.default
-      self['C']
+      self["C"]
     end
-  
+
     # Tests whether the current key is enharmonic with +another_key+.
     def enharmonic_with?(another_key)
-      self.index == another_key.index
+      index == another_key.index
     end
-  
   end
-end
+end

data/lib/jazz_model/key_context.rb

@@ -1,28 +1,37 @@
 module JazzModel
-  # Key context is a module intended to be mixed in to classes requiring 
-  # the notion of "key context".  Concepts such as chords and scales exist 
+  # Key context is a module intended to be mixed in to classes requiring
+  # the notion of "key context".  Concepts such as chords and scales exist
   # as mathematical relationships absent key, but can be put into key context.
-  # Adds a key instance variable to the including class and two new methods:
-  # 
+  # Adds a key attribute to the including class and two new methods:
+  #
   # * +in_key_of+(new_key) - Sets the key context to the specified new_key.
   # * +without_key+ - Removes key context.
-  # 
+  #
   module KeyContext
-  	def self.included(klass)
-  		klass.class_eval do
-  			attr_accessor :key
-			
-  			def in_key_of(name)
-  				self.key = Key.find_by_name(name)
-  				self
-  			end
-  			alias_method :in, :in_key_of
-			
-  			def without_key
-  				self.key = nil
-  				self
-  			end
-  		end
-  	end
+    attr_accessor :key
+
+    def in_key_of(name)
+      self.key = name.is_a?(Key) ? name : Key.find_by_name(name)
+      self
+    end
+    alias_method :in, :in_key_of
+
+    def without_key
+      self.key = nil
+      self
+    end
+
+    # Yields each way +symbol+ can be read as an optional key prefix followed
+    # by the rest of the symbol, longest key first and finally with no key at
+    # all.  For example "Cb5" yields [Cb, "5"], [C, "b5"], then [nil, "Cb5"],
+    # letting callers pick the first reading that resolves to something.
+    def self.each_split(symbol)
+      return enum_for(:each_split, symbol) unless block_given?
+
+      Key.all.sort_by { |k| -k.name.length }.each do |k|
+        yield k, symbol.delete_prefix(k.name).strip if symbol.start_with?(k.name)
+      end
+      yield nil, symbol
+    end
   end
-end
+end

data/lib/jazz_model/mode.rb

@@ -1,47 +1,42 @@
 module JazzModel
-  # In music theory a mode is essentially a slice of a scale with an offset. 
-  # For example second mode of the C major scale would begin and end on D 
+  # In music theory a mode is essentially a slice of a scale with an offset.
+  # For example second mode of the C major scale would begin and end on D
   # but otherwise have the exact same tones as the C major scale.
-  # 
-  # This class represents a mode within the context of a +Scale+.  
-  # 
+  #
+  # This class represents a mode within the context of a +Scale+.
+  #
   # == Associations
-  # 
+  #
   # * +scale+ - The related scale.
   # * +chord_scales+ - +ChordScale+ relationships to this mode.
   # * +chords+ - Direct access to a collection of chords through +chord_scales+.
-  # 
+  #
   # == Tones and Mode Context
-  # 
-  # Tones are directly related to scales, not modes.  There is a +tones+ method 
-  # (and a +notes+ method that delegates to +tones+) here that simulates the tones for 
-  # the mode by setting the mode context of the scale tones, effectively returning 
+  #
+  # Tones are directly related to scales, not modes.  There is a +tones+ method
+  # (and a +notes+ method that delegates to +tones+) here that simulates the tones for
+  # the mode by setting the mode context of the scale tones, effectively returning
   # the tones shifted by X where X is the mode number.
-  # Therefore, you can access tones directly off of the mode because they are proxied 
-  # through scale with the correct offset. 
-  # 
+  # Therefore, you can access tones directly off of the mode because they are proxied
+  # through scale with the correct offset.
+  #
   # == Examples
-  # 
-  # Since modes should be accessed within the context of scales, mode-related examples are 
+  #
+  # Since modes should be accessed within the context of scales, mode-related examples are
   # actually in scale.  See +Scale+.
-  # 
+  #
   class Mode < JazzModel::Base
-  	include KeyContext
-	
-  	belongs_to :scale
-	
-  	has_many :chord_scales
-  	has_many :chords, :through => :chord_scales, :extend => ChordCollection
-	
-  	delegate :notes, :to => :tones
-	
-  	def tones
-  		if self.key
-  			self.scale.tones.in_mode(self.mode).in_key_of(self.key)
-  		else
-  			self.scale.tones.in_mode(self.mode)
-  		end
-  	end
-	
+    include KeyContext
+
+    belongs_to :scale
+
+    has_many :chord_scales
+    has_many :chords, through: :chord_scales, extend: ChordCollection
+
+    delegate :notes, to: :tones
+
+    def tones
+      scale.tones.in_mode(mode).in_key_of(key)
+    end
   end
-end
+end

data/lib/jazz_model/mode_context.rb

@@ -1,32 +1,28 @@
 module JazzModel
-  # Mode context is a module intended to be mixed in to classes requiring 
-  # the notion of "mode context".  Right now the only class that uses this 
-  # is scale.  Mode context allows scales to take on a mode context which 
+  # Mode context is a module intended to be mixed in to classes requiring
+  # the notion of "mode context".  Right now the only class that uses this
+  # is scale.  Mode context allows scales to take on a mode context which
   # effectively offsets tone sequences to retrieve tones in the given scale mode.
-  # 
-  # * +in_mode(new_mode)+ - Sets the mode context to the specified mode (integer).
+  #
+  # * +in_mode(new_mode)+ - Sets the mode context to the specified mode (integer or name).
   # * +without_mode+ - Removes mode context.
   #
   module ModeContext
-  	def self.included(klass)
-  		klass.class_eval do
-  			attr_accessor :mode
-			
-  			def in_mode(value)
-  				if value.is_a?(String)
-  					mode_object = self.respond_to?(:modes) ? self.modes.find_by_name(value) : Mode.find_by_name(value)
-  					self.mode = mode_object.mode unless mode_object.nil?
-  				else
-  					self.mode = value
-  				end
-  				self
-  			end
-			
-  			def without_mode
-  				self.mode = nil
-  				self
-  			end
-  		end
-  	end
+    attr_accessor :mode
+
+    def in_mode(value)
+      if value.is_a?(String)
+        mode_object = respond_to?(:modes) ? modes.find_by_name(value) : Mode.find_by_name(value)
+        self.mode = mode_object.mode unless mode_object.nil?
+      else
+        self.mode = value
+      end
+      self
+    end
+
+    def without_mode
+      self.mode = nil
+      self
+    end
   end
-end
+end

data/lib/jazz_model/mode_sequence.rb

@@ -1,15 +1,16 @@
 module JazzModel
-  # Extends the Scale.modes association by allowing indexed access to modes. 
-  # Whn using it in this manner, key context is passed along.
-  # 
+  # Extends the Scale.modes association by allowing indexed access to modes.
+  # When using it in this manner, key context is passed along.
+  #
   module ModeSequence
-  	def [](value)
-  		mode_object = self.find(:first, :conditions => ["name = ? OR mode = ?", value, value])
-  		return nil if mode_object.nil?
-		
-  		# Pass Along Key Information
-  		mode_object.key = proxy_owner.key if proxy_owner.respond_to?(:key) and !proxy_owner.key.nil?
-  		mode_object
-  	end
+    def [](value)
+      mode_object = where("name = ? OR mode = ?", value, value).first
+      return nil if mode_object.nil?
+
+      # Pass Along Key Information
+      owner = proxy_association.owner
+      mode_object.key = owner.key if owner.respond_to?(:key) && !owner.key.nil?
+      mode_object
+    end
   end
-end
+end

data/lib/jazz_model/notes_collection.rb

@@ -1,89 +1,82 @@
-require 'set'
-
 module JazzModel
   # NotesCollection represents a collection of notes.  Using this collection,
-  # you can determine chord and scale/mode matches in specific or all keys. 
-  # This class is currently under heavily development and will eventually be home to heavy logic involved 
-  # in associating an arbitrary collection of notes with chords, given that 
+  # you can determine chord and scale/mode matches in specific or all keys.
+  # This class is currently under heavily development and will eventually be home to heavy logic involved
+  # in associating an arbitrary collection of notes with chords, given that
   # some scales tone may be "omitable", etc.
-  # 
+  #
   # == Creating a NotesCollection object
-  # 
-  # Creating the collection of notes should be done by indexing 
+  #
+  # Creating the collection of notes should be done by indexing
   # the Notes class directly with a comma-separated string of notes.
-  # 
+  #
   # == Current Limitations
-  # 
+  #
   # Will only do exact 100% match of notes given and notes in chords.  No fuzzyness
-  # such as the ability to omit the root and other non-important tones.  Does not yet 
+  # such as the ability to omit the root and other non-important tones.  Does not yet
   # find supersets or subsets.
-  # 
+  #
   # == Examples
-  # 
+  #
   # === Finding All Associated Chords
-  # 
+  #
   #   NotesCollection['C, E, G, A'].chords.symbols
   #   # => "Amin7, Cmaj6"
-  #  
+  #
   # === Finding Associated Chords in Given Key
   #
   #   NotesCollection['C, E, G, A'].in_key_of('A').chords.symbols
   #   # => "Amin7"
-  # 
+  #
   class NotesCollection
-  	include Enumerable
-  	include KeyContext
-	
-  	attr_accessor :keys
-  	attr_accessor :invalid_keys
-	
-  	def initialize(value = [])
-  		@value_as_given = value
-  		@keys = []
-  		@invalid_keys = []
-		
-  		value = value.split(/,| /).map(&:strip) if value.instance_of?(String)
-  		value.each do |key_name|
-  			key_object = Key[key_name]
-			
-  			if key_object.nil?
-  				@invalid_keys << key_name
-  			else
-  				@keys << key_object
-  			end
-  		end
-  	end
-	
-  	class << self
-  		alias_method :[], :new
-  	end
-	
-  	delegate :each, :to => :keys
-	
-  	# Chords associated with this collection of notes
-  	def chords
-  		if key
-  			chords_in_key(key)
-  		else
-  			Key.primaries.map do |in_key|
-  				chords_in_key(in_key)
-  			end.flatten
-  		end.extend(ChordCollection)
-  	end
-	
-  	# XML Representation
-  	def to_xml
-  		'<NotesCollection name="' + @value_as_given.to_s + '"></NotesCollection>'
-  	end
-	
-	
-  	private
-	
-  	def chords_in_key(in_key)
-  		Chord.all.select do |c|
-  			c.tones.map(&:tone).to_set == keys.map {|k| (k.index - (in_key ? in_key.index : 0)) % 12 }.to_set
-  		end.map {|c| c.key = in_key; c}
-  	end
-	
+    include Enumerable
+    include KeyContext
+
+    attr_accessor :keys
+    attr_accessor :invalid_keys
+
+    def initialize(value = [])
+      @keys = []
+      @invalid_keys = []
+
+      value = value.split(/,| /).map(&:strip) if value.instance_of?(String)
+      value.each do |key_name|
+        key_object = Key[key_name]
+
+        if key_object.nil?
+          @invalid_keys << key_name
+        else
+          @keys << key_object
+        end
+      end
+    end
+
+    class << self
+      alias_method :[], :new
+    end
+
+    delegate :each, to: :keys
+
+    # Chords associated with this collection of notes
+    def chords
+      if key
+        chords_in_key(key)
+      else
+        Key.primaries.map do |in_key|
+          chords_in_key(in_key)
+        end.flatten
+      end.extend(ChordCollection)
+    end
+
+    private
+
+    def chords_in_key(in_key)
+      Chord.all.select do |c|
+        c.tones.map(&:tone).to_set == keys.map { |k| (k.index - (in_key ? in_key.index : 0)) % 12 }.to_set
+      end.map { |c|
+        c.key = in_key
+        c
+      }
+    end
   end
-end
+end