head_music 0.1.1 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 161df8f1795f4e70adcdc8d7298cdbf1dd2af984
-  data.tar.gz: 621aac81ec102840a879186df55eb9aeed040b8b
+  metadata.gz: 8379f9a907ea8dd73018b1cd9a8da6a055510735
+  data.tar.gz: f3de473d170a910e26a5b4318232a5a9d7eb4258
 SHA512:
-  metadata.gz: 947631876b0c2c74a807515783a22783836838d75d2a21eab2f66e8863a5b25d5849e92874885007a99dd0596acacb5c795ad0ffc153d47cac616322ec566fef
-  data.tar.gz: 9ff5a2e01209ccd7f515d9d152f49159a0f18518f7bfb17e289609cb519395b96e7ae4399dd321346b3b971f05ae970d2095fb4556ca1bb666b36d268f46fe2c
+  metadata.gz: 05c161185607fd4f4ac48b5ad9389ee6d15fda24deaed1bf1a8f4e88b7140615ef60cdf695266c6e6a714cf66dc9db3a5f47e056c7c6096a9c0fde6e0d5fb0fa
+  data.tar.gz: f7142b9a29669c3a885c6ee9edf68330c9912ff8e71622efb1d95f7c3f314dea05dc2443c5f1c092988ceb236ba7a7768ac28a0ba43651c5954085595e57b295

data/lib/head_music/accidental.rb

@@ -10,15 +10,15 @@ class HeadMusic::Accidental
 
   def self.get(identifier)
     @accidentals ||= {}
-    @accidentals[identifier] ||= for_symbol(identifier) || for_interval(identifier)
+    for_symbol(identifier) || for_interval(identifier)
   end
 
   def self.for_symbol(identifier)
-    new(identifier) if ACCIDENTAL_SEMITONES.keys.include?(identifier)
+    @accidentals[identifier.to_s] ||= new(identifier.to_s) if ACCIDENTAL_SEMITONES.keys.include?(identifier.to_s)
   end
 
   def self.for_interval(semitones)
-    ACCIDENTAL_SEMITONES.key(semitones.to_i)
+    @accidentals[semitones.to_i] ||= ACCIDENTAL_SEMITONES.key(semitones.to_i)
   end
 
   def initialize(string)

data/lib/head_music/interval.rb

@@ -9,7 +9,7 @@ class HeadMusic::Interval
 
   def self.get(semitones)
     @intervals_memo ||= {}
-    @intervals_memo[semitones] ||= new(semitones)
+    @intervals_memo[semitones.to_i] ||= new(semitones.to_i)
   end
 
   def self.named(name)

data/lib/head_music/key_signature.rb

@@ -7,9 +7,9 @@ class HeadMusic::KeySignature
 
   delegate :pitch_class, to: :tonic_spelling, prefix: :tonic
 
-  def initialize(tonic_spelling, scale_type = :major)
+  def initialize(tonic_spelling, scale_type = nil)
     @tonic_spelling = tonic_spelling
-    @scale_type = scale_type
+    @scale_type = scale_type || :major
   end
 
   def sharps

data/lib/head_music/letter.rb

@@ -19,12 +19,12 @@ class HeadMusic::Letter
 
   def self.get(identifier)
     @letters ||= {}
-    @letters[identifier] ||= from_name(identifier) || from_pitch_class(identifier)
+    from_name(identifier) || from_pitch_class(identifier)
   end
 
   def self.from_name(name)
     name = name.to_s.first.upcase
-    new(name) if NAMES.include?(name)
+    @letters[name] ||= new(name) if NAMES.include?(name)
   end
 
   def self.from_pitch_class(pitch_class)
@@ -33,7 +33,7 @@ class HeadMusic::Letter
     pitch_class = pitch_class.to_i % 12
     name = NAMES.detect { |name| pitch_class == NATURAL_PITCH_CLASS_NUMBERS[name] }
     name ||= HeadMusic::PitchClass::PREFERRED_SPELLINGS[pitch_class].first
-    return new(name) if NAMES.include?(name)
+    @letters[name] ||= new(name) if NAMES.include?(name)
   end
 
   attr_reader :name

data/lib/head_music/octave.rb

@@ -0,0 +1,42 @@
+class HeadMusic::Octave
+  include Comparable
+
+  DEFAULT = 4
+
+  MATCHER = /(-?\d+)$/
+
+  def self.get(identifier)
+    @octaves ||= {}
+    from_number(identifier) || from_name(identifier) || default
+  end
+
+  def self.from_number(identifier)
+    return nil unless identifier.to_s == identifier.to_i.to_s
+    return nil unless (-2..12).include?(identifier.to_i)
+    @octaves[identifier.to_i] ||= new(identifier.to_i)
+  end
+
+  def self.from_name(string)
+    if string.to_s.match(HeadMusic::Spelling::MATCHER)
+      _letter, _accidental, octave_string = string.to_s.match(HeadMusic::Spelling::MATCHER).captures
+      @octaves[octave_string.to_i] ||= new(octave_string.to_i) if octave_string
+    end
+  end
+
+  def self.default
+    @octaves[DEFAULT] ||= new(DEFAULT)
+  end
+
+  attr_reader :number
+  delegate :to_i, :to_s, to: :number
+
+  def initialize(number)
+    @number ||= number
+  end
+
+  def <=>(other)
+    self.to_i <=> other.to_i
+  end
+
+  private_class_method :new
+end

data/lib/head_music/pitch.rb

@@ -13,16 +13,21 @@ class HeadMusic::Pitch
 
   def self.from_name(name)
     return nil unless name == name.to_s
-    spelling = HeadMusic::Spelling.get(name)
-    octave = name.scan(/-?\d+$/).first.to_i
-    new(spelling, octave) if spelling && (-1..9).include?(octave)
+    fetch_or_create(HeadMusic::Spelling.get(name), HeadMusic::Octave.get(name).to_i)
   end
 
   def self.from_number(number)
     return nil unless number == number.to_i
     spelling = HeadMusic::Spelling.from_number(number)
     octave = (number.to_i / 12) - 1
-    new(spelling, octave) if spelling && (-1..9).include?(octave)
+    fetch_or_create(spelling, octave)
+  end
+
+  def self.fetch_or_create(spelling, octave)
+    if spelling && (-1..9).include?(octave)
+      key = [spelling, octave].join
+      @pitches[key] ||= new(spelling, octave)
+    end
   end
 
   def initialize(spelling, octave)
@@ -38,6 +43,8 @@ class HeadMusic::Pitch
     (octave + 1) * 12 + pitch_class.to_i
   end
 
+  alias_method :midi, :midi_note_number
+
   def to_s
     name
   end

data/lib/head_music/pitch_class.rb

@@ -3,9 +3,10 @@ class HeadMusic::PitchClass
 
   PREFERRED_SPELLINGS = %w[C C# D Eb E F F# G Ab A Bb B]
 
-  def self.get(number)
+  def self.get(identifier)
     @pitch_classes ||= {}
-    number = number.to_i % 12
+    number = Spelling.get(identifier).pitch_class.to_i if Spelling.match(identifier)
+    number ||= identifier.to_i % 12
     @pitch_classes[number] ||= new(number)
   end
 
@@ -14,7 +15,7 @@ class HeadMusic::PitchClass
   end
 
   def initialize(pitch_class_or_midi_number)
-    @number = pitch_class_or_midi_number % 12
+    @number = pitch_class_or_midi_number.to_i % 12
   end
 
   def to_i

data/lib/head_music/quality.rb

@@ -0,0 +1,22 @@
+class HeadMusic::Quality
+  QUALITY_NAMES = %w[perfect major minor diminished augmented].map(&:to_sym)
+
+  def self.get(identifier)
+    @qualities ||= {}
+    identifier = identifier.to_s.to_sym
+    @qualities[identifier] ||= new(identifier) if QUALITY_NAMES.include?(identifier)
+  end
+
+  attr_reader :name
+  delegate :to_s, to: :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def ==(other)
+    self.to_s == other.to_s
+  end
+
+  private_class_method :new
+end

data/lib/head_music/scale_type.rb

@@ -0,0 +1,83 @@
+class HeadMusic::ScaleType
+  H = 1 # whole step
+  W = 2 # half step
+  WH = W + H # augmented second
+
+  # Modal
+  I = [W, W, H, W, W, W, H]
+  II = I.rotate
+  III = I.rotate(2)
+  IV = I.rotate(3)
+  V = I.rotate(4)
+  VI = I.rotate(5)
+  VII = I.rotate(6)
+
+  # Tonal
+  HARMONIC_MINOR = [W, H, W, W, H, WH, H]
+  MELODIC_MINOR_ASCENDING = [W, H, W, W, W, W, H]
+
+  CHROMATIC = [H, H, H, H, H, H, H, H, H, H, H, H]
+  MINOR_PENTATONIC = [3, 2, 2, 3, 2]
+  MAJOR_PENTATONIC = MINOR_PENTATONIC.rotate
+
+  MODE_NAMES = {
+    i: [:ionian, :major, :maj],
+    ii: [:dorian],
+    iii: [:phrygian],
+    iv: [:lydian],
+    v: [:mixolydian],
+    vi: [:aeolian, :minor, :natural_minor, :min],
+    vii: [:locrian],
+  }
+  SCALE_TYPES = {}
+  MODE_NAMES.each do |roman_numeral, aliases|
+    intervals = { ascending: const_get(roman_numeral.upcase) }
+    SCALE_TYPES[roman_numeral] = intervals
+    aliases.each do |name|
+      SCALE_TYPES[name.to_sym] = intervals
+    end
+  end
+  SCALE_TYPES[:harmonic_minor] = { ascending: HARMONIC_MINOR }
+  SCALE_TYPES[:melodic_minor] = { ascending: MELODIC_MINOR_ASCENDING, descending: VI.reverse }
+
+  SCALE_TYPES[:chromatic] = { ascending: CHROMATIC }
+
+  SCALE_TYPES[:minor_pentatonic] = { ascending: MINOR_PENTATONIC }
+  SCALE_TYPES[:major_pentatonic] = { ascending: MAJOR_PENTATONIC }
+
+  SCALE_TYPES[:octatonic] = { ascending: [W, H, W, H, W, H, W, H] }
+  SCALE_TYPES[:whole_tone] = { ascending: [W, W, W, W, W, W] }
+  SCALE_TYPES[:monotonic] = { ascending: [12] }
+
+  class << self
+    SCALE_TYPES.keys.each do |name|
+      define_method(name) do
+        self.get(name)
+      end
+    end
+  end
+
+  def self.get(name)
+    @scale_types ||= {}
+    name = name.to_s.to_sym
+    intervals = SCALE_TYPES[name]
+    @scale_types[name] ||= new(name, intervals[:ascending], intervals[:descending])
+  end
+
+  attr_reader :name, :ascending_intervals, :descending_intervals
+  delegate :to_s, to: :name
+
+  def initialize(name, ascending_intervals, descending_intervals = nil)
+    @name = name
+    @ascending_intervals = ascending_intervals
+    @descending_intervals = descending_intervals || ascending_intervals.reverse
+  end
+
+  def ==(other)
+    self.state == other.state
+  end
+
+  def state
+    [ascending_intervals, descending_intervals]
+  end
+end

data/lib/head_music/spelling.rb

@@ -1,24 +1,30 @@
-# A Spelling is a pitch class with a letter and an accidental
+# A Spelling is a pitch class with a letter and possibly an accidental
 
 class HeadMusic::Spelling
+  MATCHER = /^\s*([A-G])([b#]*)(\-?\d+)?\s*$/
+
+  attr_reader :pitch_class
   attr_reader :letter
   attr_reader :accidental
-  attr_reader :pitch_class
 
-  SPELLING_MATCHER = /^\s*([A-G])([b#]*)(\-?\d+)?\s*$/
+  delegate :number, to: :pitch_class, prefix: true
 
   def self.get(identifier)
     @spellings ||= {}
-    @spellings[identifier] ||= from_name(identifier) || from_number(identifier)
+    from_name(identifier) || from_number(identifier)
+  end
+
+  def self.match(string)
+    string.to_s.match(MATCHER)
   end
 
   def self.from_name(name)
-    return nil unless name == name.to_s
-    match = name.to_s.match(SPELLING_MATCHER)
-    if match
-      letter_name, accidental_string, _octave = match.captures
+    if match(name)
+      letter_name, accidental_string, _octave = match(name).captures
       letter = HeadMusic::Letter.get(letter_name)
-      new(letter, HeadMusic::Accidental.get(accidental_string)) if letter
+      return nil unless letter
+      accidental = HeadMusic::Accidental.get(accidental_string)
+      fetch_or_create(letter, accidental)
     end
   end
 
@@ -26,10 +32,13 @@ class HeadMusic::Spelling
     return nil unless number == number.to_i
     pitch_class_number = number.to_i % 12
     letter = HeadMusic::Letter.from_pitch_class(pitch_class_number)
-    if letter.pitch_class != pitch_class_number
-      accidental = HeadMusic::Accidental.for_interval(pitch_class_number - letter.pitch_class.to_i)
-    end
-    new(letter, accidental)
+    accidental = HeadMusic::Accidental.for_interval(pitch_class_number - letter.pitch_class.to_i)
+    fetch_or_create(letter, accidental)
+  end
+
+  def self.fetch_or_create(letter, accidental)
+    key = [letter, accidental].join
+    @spellings[key] ||= new(letter, accidental)
   end
 
   def initialize(letter, accidental = nil)

data/lib/head_music/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "0.1.1"
+  VERSION = "0.1.5"
 end

data/lib/head_music.rb

@@ -8,9 +8,12 @@ require "head_music/circle"
 require "head_music/interval"
 require "head_music/key_signature"
 require "head_music/letter"
+require "head_music/octave"
 require "head_music/pitch_class"
 require "head_music/pitch"
+require "head_music/quality"
 require "head_music/scale"
+require "head_music/scale_type"
 require "head_music/spelling"
 
 module HeadMusic

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.5
 platform: ruby
 authors:
 - Rob Head
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -105,9 +105,12 @@ files:
 - lib/head_music/interval.rb
 - lib/head_music/key_signature.rb
 - lib/head_music/letter.rb
+- lib/head_music/octave.rb
 - lib/head_music/pitch.rb
 - lib/head_music/pitch_class.rb
+- lib/head_music/quality.rb
 - lib/head_music/scale.rb
+- lib/head_music/scale_type.rb
 - lib/head_music/spelling.rb
 - lib/head_music/version.rb
 homepage: https://github.com/roberthead/head_music