head_music 0.23.4 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2560dc1ecfabf9f035a6c9349f6764582dd803edaad98cf6edf70b73ba67452b
-  data.tar.gz: 8f48d2ac8336316478854efd66eb80e2a05d47b9a015cbbebf0b25a709518c3c
+  metadata.gz: 46aae73acea5e3331b19a08a02ded3c00fea5731e920207fc9d2b61dd9ebc359
+  data.tar.gz: c2cfdbb52641ad27bd96308fe99da5f59b2e66efdf2f40a4932e8bc6552510c4
 SHA512:
-  metadata.gz: 125db0856552fee0160105993dd57c8566d96c904ba4df58d8292cd4becc9422638bb75b1da8c25e636c59f81ba0e4b518625e57c6cffacd336ee992918735b0
-  data.tar.gz: 55b3a99f40051c9c4f3929e0a15930c4325441a3d18c43125daae0730e718eee0f3e6b3a0fbb851e01d916c040a499d6c577638716ea61298f458f3bc3037b80
+  metadata.gz: 23a9cc4013e6058892effeeaf940947a90ce2e5950eb4c3c622b7036fecbaa14dd4cd4aa5d5dbe5b6ffdefe1ce8e37681b1d8d040e135b1a4c737fca23c84fa6
+  data.tar.gz: 15d30c56ea0b08db8bde6b0d69b38a9605751b370086e6a66db5a74029b1f4c87ab408b0e567e092f0e2418d4f65e1dfe5644358c0fd0f6f676548466b5544ec

data/.rubocop.yml

@@ -1,6 +1,9 @@
 Layout/DotPosition:
   EnforcedStyle: trailing
 
+Layout/LineLength:
+  Max: 120
+
 Metrics/BlockLength:
   Exclude:
     - 'Gemfile'
@@ -10,9 +13,6 @@ Metrics/BlockLength:
 Metrics/ClassLength:
   Max: 155
 
-Metrics/LineLength:
-  Max: 120
-
 Style/ClassAndModuleChildren:
   EnforcedStyle: compact
 

data/Rakefile

@@ -9,5 +9,5 @@ task default: :spec
 
 desc 'Open an irb session preloaded with this library'
 task :console do
-  sh 'irb -rubygems -I lib -r head_music.rb'
+  sh 'irb -I lib -r head_music.rb'
 end

data/lib/head_music/chromatic_interval.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# An interval is the distance between two pitches.
+# A chromatic interval is the distance between two pitches measured in half-steps.
 class HeadMusic::ChromaticInterval
   include Comparable
 
@@ -40,6 +40,10 @@ class HeadMusic::ChromaticInterval
     semitones
   end
 
+  def diatonic_name
+    NAMES[simple.semitones].gsub(/_/, ' ')
+  end
+
   # diatonic set theory
   alias specific_interval semitones
 

data/lib/head_music/circle.rb

@@ -5,39 +5,50 @@ require 'head_music/interval_cycle'
 # A Circle of Fifths or Fourths shows relationships between pitch classes
 class HeadMusic::Circle < HeadMusic::IntervalCycle
   def self.of_fifths
-    get(7)
+    get(:perfect_fifth)
   end
 
   def self.of_fourths
-    get(5)
+    get(:perfect_fourth)
   end
 
-  def self.get(interval = 7)
+  def self.get(interval = :perfect_fifth)
     @circles ||= {}
-    @circles[interval.to_i] ||= new(interval)
-  end
-
-  attr_reader :interval, :pitch_classes
-
-  # Accepts an interval (as an integer number of semitones)
-  def initialize(interval)
-    @interval = interval.to_i
-    @pitch_classes = pitch_classes_by_interval
+    diatonic_interval = HeadMusic::DiatonicInterval.get(interval)
+    @circles[interval] ||= new(interval: diatonic_interval, starting_pitch: 'C4')
   end
 
   def index(pitch_class)
-    @pitch_classes.index(HeadMusic::Spelling.get(pitch_class).pitch_class)
+    pitch_classes.index(HeadMusic::Spelling.get(pitch_class).pitch_class)
   end
 
-  private_class_method :new
+  alias spellings_up spellings
 
-  private
+  def key_signatures_up
+    spellings_up.map { |spelling| HeadMusic::KeySignature.new(spelling) }
+  end
 
-  def interval_cycle
-    @interval_cycle ||= HeadMusic::IntervalCycle.get(interval)
+  def key_signatures_down
+    spellings_down.map { |spelling| HeadMusic::KeySignature.new(spelling) }
   end
 
-  def pitch_classes_by_interval
-    interval_cycle.send(:pitch_classes_by_interval)
+  def spellings_down
+    pitches_down.map(&:spelling)
   end
+
+  def pitches_down
+    @pitches_down ||= begin
+      [starting_pitch].tap do |list|
+        loop do
+          next_pitch = list.last - interval
+          next_pitch += octave while starting_pitch - next_pitch > 12
+          break if next_pitch.pitch_class == list.first.pitch_class
+
+          list << next_pitch
+        end
+      end
+    end
+  end
+
+  private_class_method :new
 end

data/lib/head_music/diatonic_interval.rb

@@ -280,6 +280,8 @@ class HeadMusic::DiatonicInterval
     to: :naming
   )
 
+  alias to_i semitones
+
   # Accepts a name and returns the interval with middle c on the bottom
   def self.get(identifier)
     name = Parser.new(identifier)

data/lib/head_music/interval_cycle.rb

@@ -2,35 +2,56 @@
 
 # An Interval Cycle is a collection of pitch classes created from a sequence of the same interval class.
 class HeadMusic::IntervalCycle
+  attr_reader :interval, :starting_pitch
+
   def self.get(interval = 7)
-    @circles ||= {}
+    @interval_cycles ||= {}
     interval = interval.to_s.gsub(/^C/i, '').to_i
-    @circles[interval.to_i] ||= new(interval)
+    interval = HeadMusic::ChromaticInterval.get(interval)
+    @interval_cycles[interval.to_i] ||= new(interval: interval, starting_pitch: 'C4')
   end
 
-  attr_reader :interval, :pitch_classes
+  def initialize(interval:, starting_pitch: 'C4')
+    @interval = interval if interval.is_a?(HeadMusic::DiatonicInterval)
+    @interval ||= interval if interval.is_a?(HeadMusic::ChromaticInterval)
+    @interval ||= HeadMusic::ChromaticInterval.get(interval) if interval.to_s.match?(/\d/)
+    @interval ||= HeadMusic::DiatonicInterval.get(interval)
+    @starting_pitch = HeadMusic::Pitch.get(starting_pitch)
+  end
 
-  def initialize(interval)
-    @interval = interval.to_i
-    @pitch_classes = pitch_classes_by_interval
+  def pitches
+    @pitches ||= pitches_up
   end
 
-  def index(pitch_class)
-    @pitch_classes.index(HeadMusic::Spelling.get(pitch_class).pitch_class)
+  def pitch_classes
+    @pitch_classes ||= pitches.map(&:pitch_class)
   end
 
-  private_class_method :new
+  def pitch_class_set
+    @pitch_class_set ||= HeadMusic::PitchClassSet.new(pitches)
+  end
 
-  private
+  def spellings
+    @spellings ||= pitches.map(&:spelling)
+  end
 
-  def pitch_classes_by_interval
-    [HeadMusic::PitchClass.get(0)].tap do |list|
-      loop do
-        next_pitch_class = list.last + interval
-        break if next_pitch_class == list.first
+  protected
 
-        list << next_pitch_class
+  def pitches_up
+    @pitches_up ||= begin
+      [starting_pitch].tap do |list|
+        loop do
+          next_pitch = list.last + interval
+          next_pitch -= octave while next_pitch - starting_pitch > 12
+          break if next_pitch.pitch_class == list.first.pitch_class
+
+          list << next_pitch
+        end
       end
     end
   end
+
+  def octave
+    @octave ||= HeadMusic::DiatonicInterval.get(:perfect_octave)
+  end
 end

data/lib/head_music/key_signature.rb

@@ -6,8 +6,8 @@ class HeadMusic::KeySignature
   attr_reader :scale_type
   attr_reader :scale
 
-  SHARPS = %w[F♯ C♯ G♯ D♯ A♯ E♯ B♯].freeze
-  FLATS = %w[B♭ E♭ A♭ D♭ G♭ C♭ F♭].freeze
+  ORDERED_LETTER_NAMES_OF_SHARPS = %w[F C G D A E B].freeze
+  ORDERED_LETTER_NAMES_OF_FLATS = ORDERED_LETTER_NAMES_OF_SHARPS.reverse.freeze
 
   def self.default
     @default ||= new('C', :major)
@@ -39,19 +39,35 @@ class HeadMusic::KeySignature
   end
 
   def sharps
-    spellings.select(&:sharp?).sort_by { |sharp| SHARPS.index(sharp.to_s) }
+    spellings.select(&:sharp?).sort_by do |spelling|
+      ORDERED_LETTER_NAMES_OF_SHARPS.index(spelling.letter_name.to_s)
+    end
+  end
+
+  def double_sharps
+    spellings.select(&:double_sharp?).sort_by do |spelling|
+      ORDERED_LETTER_NAMES_OF_SHARPS.index(spelling.letter_name.to_s)
+    end
   end
 
   def flats
-    spellings.select(&:flat?).sort_by { |flat| FLATS.index(flat.to_s) }
+    spellings.select(&:flat?).sort_by do |spelling|
+      ORDERED_LETTER_NAMES_OF_FLATS.index(spelling.letter_name.to_s)
+    end
+  end
+
+  def double_flats
+    spellings.select(&:double_flat?).sort_by do |spelling|
+      ORDERED_LETTER_NAMES_OF_FLATS.index(spelling.letter_name.to_s)
+    end
   end
 
   def num_sharps
-    sharps.length
+    sharps.length + double_sharps.length * 2
   end
 
   def num_flats
-    flats.length
+    flats.length + double_flats.length * 2
   end
 
   def signs

data/lib/head_music/named.rb

@@ -25,5 +25,21 @@ module HeadMusic::Named
       key = HeadMusic::Utilities::HashKey.for(name)
       @instances_by_name[key] ||= new(name)
     end
+
+    def aliases
+      {}
+    end
+  end
+
+  # An Alias encapsulates an alternative name for a rudiment.
+  class Alias
+    attr_reader :key, :name, :abbreviation, :locale
+
+    def initialize(key:, name:, abbreviation: nil, locale: nil)
+      @key = key
+      @name = name
+      @abbreviation = abbreviation
+      @locale = locale
+    end
   end
 end

data/lib/head_music/pitch.rb

@@ -21,8 +21,17 @@ class HeadMusic::Pitch
   delegate :enharmonic_equivalent?, :enharmonic?, to: :enharmonic_equivalence
   delegate :octave_equivalent?, to: :octave_equivalence
 
+  # Fetches a pitch identified by the information passed in.
+  #
+  # Accepts:
+  #   - a Pitch instance
+  #   - a PitchClass instance
+  #   - a name string, such as 'Ab4'
+  #   - a number corresponding to the midi note number
   def self.get(value)
-    from_pitch_class(value) || from_name(value) || from_number(value)
+    from_pitch_class(value) ||
+      from_name(value) ||
+      from_number(value)
   end
 
   def self.middle_c
@@ -48,9 +57,7 @@ class HeadMusic::Pitch
   def self.from_number(number)
     return nil unless number == number.to_i
 
-    spelling = HeadMusic::Spelling.from_number(number)
-    octave = (number.to_i / 12) - 1
-    fetch_or_create(spelling, octave)
+    fetch_or_create(HeadMusic::Spelling.from_number(number), (number.to_i / 12) - 1)
   end
 
   def self.from_number_and_letter(number, letter_name)

data/lib/head_music/pitch_class.rb

@@ -7,8 +7,8 @@ class HeadMusic::PitchClass
   attr_reader :number
   attr_reader :spelling
 
-  SHARP_SPELLINGS = %w[C C# D D# E F F# G G# A A# B].freeze
-  FLAT_SPELLINGS = %w[C Db D Eb E F Gb G Ab A Bb B].freeze
+  SHARP_SPELLINGS = %w[C C♯ D D♯ E F F♯ G G♯ A A♯ B].freeze
+  FLAT_SPELLINGS = %w[C D♭ D E♭ E F G♭ G A♭ A B♭ B].freeze
   INTEGER_NOTATION = %w[0 1 2 3 4 5 6 7 8 9 t e].freeze
 
   def self.get(identifier)

data/lib/head_music/reference_pitch.rb

@@ -24,29 +24,30 @@ class HeadMusic::ReferencePitch
     { name: 'Chorton', pitch: 'A4', frequency: 466.0 },
   ].freeze
 
-  ALIASES = {
-    kammerton: :baroque,
-    chamber: :baroque,
-    haydn: :classical,
-    mozart: :classical,
-    philosophic: :scientific,
-    sauveur: :scientific,
-    schiller: :scientific,
-    continental: :french,
-    international: :french,
-    low: :new_philharmonic,
-    concert: :a440,
-    stuttgart: :a440,
-    scheibler: :a440,
-    iso_16: :a440,
-    high: :old_philharmonic,
-    choir: :chorton,
-  }.freeze
-
-  NAMED_REFERENCE_PITCH_NAMES = NAMED_REFERENCE_PITCHES.map { |pitch_data| pitch_data[:name] }
+  ALIAS_DATA = [
+    { key: :baroque, name: 'Kammerton' },
+    { key: :classical, name: 'Haydn' },
+    { key: :classical, name: 'Mozart' },
+    { key: :scientific, name: 'philosophical' },
+    { key: :scientific, name: 'Sauveur' },
+    { key: :scientific, name: 'Schiller' },
+    { key: :french, name: 'continental' },
+    { key: :french, name: 'international' },
+    { key: :new_philharmonic, name: 'low' },
+    { key: :old_philharmonic, name: 'high' },
+    { key: :a440, name: 'concert' },
+    { key: :a440, name: 'Stuttgart' },
+    { key: :a440, name: 'Scheibler' },
+    { key: :a440, name: 'ISO 16' },
+    { key: :chorton, name: 'choir' },
+  ].freeze
 
   attr_reader :pitch, :frequency
 
+  def self.aliases
+    @aliases ||= ALIAS_DATA.map { |attributes| HeadMusic::Named::Alias.new(attributes) }
+  end
+
   def self.get(name)
     return name if name.is_a?(self)
     get_by_name(name)
@@ -56,7 +57,7 @@ class HeadMusic::ReferencePitch
     @name = name.to_s
     reference_pitch_data = NAMED_REFERENCE_PITCHES.detect do |candidate|
       candidate_name_key = HeadMusic::Utilities::HashKey.for(candidate[:name])
-      [candidate_name_key, candidate_name_key.to_s.delete('_').to_sym].include?(normalized_name)
+      [candidate_name_key, candidate_name_key.to_s.delete('_').to_sym].include?(normalized_key)
     end || {}
     @pitch = HeadMusic::Pitch.get(reference_pitch_data.fetch(:pitch, DEFAULT_PITCH_NAME))
     @frequency = reference_pitch_data.fetch(:frequency, DEFAULT_FREQUENCY)
@@ -78,10 +79,12 @@ class HeadMusic::ReferencePitch
 
   private
 
-  def normalized_name
-    @normalized_name ||= begin
+  def normalized_key
+    @normalized_key ||= begin
       key = HeadMusic::Utilities::HashKey.for(name.to_s.gsub(/\W?(pitch|tuning|tone)/, ''))
-      ALIASES[key] || key
+      HeadMusic::ReferencePitch.aliases.detect do |alias_data|
+        HeadMusic::Utilities::HashKey.for(alias_data.name) == key
+      end&.key || key
     end
   end
 end

data/lib/head_music/sign.rb

@@ -8,14 +8,20 @@ class HeadMusic::Sign
 
   attr_reader :identifier, :cents, :musical_symbol
 
+  delegate :ascii, :unicode, :html_entity, to: :musical_symbol
+
+  SIGN_DATA = [
+    { identifier: :sharp, ascii: '#', unicode: '♯', html_entity: '♯', cents: 100 },
+    { identifier: :flat, ascii: 'b', unicode: '♭', html_entity: '♭', cents: -100 },
+    { identifier: :natural, ascii: '', unicode: '♮', html_entity: '♮', cents: 0 },
+    { identifier: :double_sharp, ascii: 'x', unicode: '𝄪', html_entity: '𝄪', cents: 200 },
+    { identifier: :double_flat, ascii: 'bb', unicode: '𝄫', html_entity: '𝄫', cents: -200 },
+  ].freeze
+
+  SIGN_IDENTIFIERS = SIGN_DATA.map { |attributes| attributes[:identifier] }.freeze
+
   def self.all
-    @all ||= [
-      new(identifier: :sharp, ascii: '#', unicode: '♯', html_entity: '♯', cents: 100),
-      new(identifier: :flat, ascii: 'b', unicode: '♭', html_entity: '♭', cents: -100),
-      new(identifier: :natural, ascii: '', unicode: '♮', html_entity: '♮', cents: 0),
-      new(identifier: :double_sharp, ascii: '##', unicode: '𝄪', html_entity: '𝄪', cents: 200),
-      new(identifier: :double_flat, ascii: 'bb', unicode: '𝄫', html_entity: '𝄫', cents: -200),
-    ]
+    SIGN_DATA.map { |attributes| new(attributes) }
   end
 
   def self.symbols
@@ -57,6 +63,10 @@ class HeadMusic::Sign
     cents / 100.0
   end
 
+  SIGN_IDENTIFIERS.each do |key|
+    define_method(:"#{key}?") { identifier == key }
+  end
+
   def to_s
     unicode
   end
@@ -66,14 +76,11 @@ class HeadMusic::Sign
     cents <=> other.cents
   end
 
-  delegate :ascii, :html_entity, :unicode, to: :musical_symbol
-
   private
 
   def initialize(attributes)
     @identifier = attributes[:identifier]
     @cents = attributes[:cents]
-
     @musical_symbol = HeadMusic::MusicalSymbol.new(
       unicode: attributes[:unicode],
       ascii: attributes[:ascii],

data/lib/head_music/spelling.rb

@@ -14,6 +14,7 @@ class HeadMusic::Spelling
   delegate :to_i, to: :pitch_class_number
   delegate :series_ascending, :series_descending, to: :letter_name, prefix: true
   delegate :enharmonic?, to: :enharmonic_equivalence
+  delegate :sharp?, :flat?, :double_sharp?, :double_flat?, to: :sign, allow_nil: true
 
   def self.get(identifier)
     return identifier if identifier.is_a?(HeadMusic::Spelling)
@@ -73,14 +74,6 @@ class HeadMusic::Spelling
     name
   end
 
-  def sharp?
-    sign && sign == '#'
-  end
-
-  def flat?
-    sign && sign == 'b'
-  end
-
   def ==(other)
     other = HeadMusic::Spelling.get(other)
     to_s == other.to_s
@@ -90,6 +83,10 @@ class HeadMusic::Spelling
     HeadMusic::Scale.get(self, scale_type_name)
   end
 
+  def natural?
+    !sign || sign.natural?
+  end
+
   private_class_method :new
 
   private

data/lib/head_music/tuning.rb

@@ -12,12 +12,9 @@ class HeadMusic::Tuning
   end
 
   def frequency_for(pitch)
-    pitch = HeadMusic::Pitch.get(pitch) unless pitch.is_a?(HeadMusic::Pitch)
+    pitch = HeadMusic::Pitch.get(pitch)
     reference_pitch_frequency * (2**(1.0 / 12))**(pitch - reference_pitch.pitch).semitones
   end
 end
 
 # TODO: other tunings
-# Create website that hosts videos on theory and history, handy charts, etc.
-# one of those charts can be a frequency table in various tunings
-# maybe show pythagorean commas and such. or cents sharp or flat relative to either equal temperment or just intonation

data/lib/head_music/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HeadMusic
-  VERSION = '0.23.4'
+  VERSION = '0.24.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 0.23.4
+  version: 0.24.0
 platform: ruby
 authors:
 - Rob Head
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-26 00:00:00.000000000 Z
+date: 2020-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport