head_music 0.1.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8379f9a907ea8dd73018b1cd9a8da6a055510735
-  data.tar.gz: f3de473d170a910e26a5b4318232a5a9d7eb4258
+  metadata.gz: 67e0581fd0dc08759395cc97286a1e96b538147d
+  data.tar.gz: dc985557ff8d0e1aa4720a4732a8b29a643251d8
 SHA512:
-  metadata.gz: 05c161185607fd4f4ac48b5ad9389ee6d15fda24deaed1bf1a8f4e88b7140615ef60cdf695266c6e6a714cf66dc9db3a5f47e056c7c6096a9c0fde6e0d5fb0fa
-  data.tar.gz: f7142b9a29669c3a885c6ee9edf68330c9912ff8e71622efb1d95f7c3f314dea05dc2443c5f1c092988ceb236ba7a7768ac28a0ba43651c5954085595e57b295
+  metadata.gz: 09fcb0a4675636f67580e095b73e5640d122d7ad72df17b0677456f0234778df1a43137eb1d3c7c5e2852a0f8acada492a179bb0e8da3e6b64252164cc554fe2
+  data.tar.gz: b1b1809ed935b1a03688220039cdce9ecd8c98a55d31d71a818077ce2b2a4e416d8a00ae6dbbba7fe742cf0dc4f507ce173b4a395d4638b4d0adef497f64fb18

data/lib/head_music/accidental.rb

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

data/lib/head_music/interval.rb

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

data/lib/head_music/letter.rb

@@ -18,11 +18,11 @@ class HeadMusic::Letter
   end
 
   def self.get(identifier)
-    @letters ||= {}
     from_name(identifier) || from_pitch_class(identifier)
   end
 
   def self.from_name(name)
+    @letters ||= {}
     name = name.to_s.first.upcase
     @letters[name] ||= new(name) if NAMES.include?(name)
   end

data/lib/head_music/octave.rb

@@ -6,19 +6,20 @@ class HeadMusic::Octave
   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 ||= {}
     @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 ||= {}
       @octaves[octave_string.to_i] ||= new(octave_string.to_i) if octave_string
     end
   end

data/lib/head_music/pitch.rb

@@ -4,11 +4,14 @@ class HeadMusic::Pitch
   attr_reader :spelling
   attr_reader :octave
 
-  delegate :letter, :accidental, :pitch_class, to: :spelling
+  delegate :letter, to: :spelling
+  delegate :accidental, :sharp?, :flat?, to: :spelling
+  delegate :pitch_class, to: :spelling
+
+  delegate :smallest_interval_to, to: :pitch_class
 
   def self.get(value)
-    @pitches ||= {}
-    @pitches[value] ||= from_name(value) || from_number(value)
+    from_name(value) || from_number(value)
   end
 
   def self.from_name(name)
@@ -23,7 +26,19 @@ class HeadMusic::Pitch
     fetch_or_create(spelling, octave)
   end
 
+  def self.from_number_and_letter(number, letter)
+    letter = HeadMusic::Letter.get(letter)
+    natural_letter_pitch = get(HeadMusic::Letter.get(letter).pitch_class)
+    natural_letter_pitch += 12 while (number - natural_letter_pitch.to_i) >= 12
+    natural_letter_pitch = get(natural_letter_pitch)
+    accidental_interval = natural_letter_pitch.smallest_interval_to(HeadMusic::PitchClass.get(number))
+    accidental = HeadMusic::Accidental.for_interval(accidental_interval)
+    spelling = HeadMusic::Spelling.fetch_or_create(letter, accidental)
+    fetch_or_create(spelling, natural_letter_pitch.octave)
+  end
+
   def self.fetch_or_create(spelling, octave)
+    @pitches ||= {}
     if spelling && (-1..9).include?(octave)
       key = [spelling, octave].join
       @pitches[key] ||= new(spelling, octave)
@@ -57,6 +72,14 @@ class HeadMusic::Pitch
     self.midi_note_number == other.midi_note_number
   end
 
+  def +(value)
+    Pitch.get(self.to_i + value.to_i)
+  end
+
+  def -(value)
+    Pitch.get(self.to_i - value.to_i)
+  end
+
   def ==(value)
     to_s == value.to_s
   end

data/lib/head_music/pitch_class.rb

@@ -2,6 +2,8 @@ class HeadMusic::PitchClass
   attr_reader :number
 
   PREFERRED_SPELLINGS = %w[C C# D Eb E F F# G Ab A Bb B]
+  SHARP_SPELLINGS = %w[C C# D D# E F F# G G# A A# B]
+  FLAT_SPELLINGS = %w[C Db D Eb E F Gb G Ab A Bb B]
 
   def self.get(identifier)
     @pitch_classes ||= {}

data/lib/head_music/scale.rb

@@ -1,29 +1,52 @@
 class HeadMusic::Scale
-  PATTERNS = {
-    major: [0, 2, 4, 5, 7, 9, 11, 12],
-    minor: [0, 2, 3, 5, 7, 8, 10, 12],
-    minor_pentatonic: [0, nil, 3, 5, 7, nil, 10, 12],
-  }
-
-  attr_reader :pattern
-
-  def self.major
+  def self.get(root_pitch, scale_type_name = nil)
+    root_pitch = HeadMusic::Pitch.get(root_pitch)
+    scale_type_name ||= :major
+    scale_type ||= HeadMusic::ScaleType.get(scale_type_name)
     @scales ||= {}
-    @scales[:major] ||=  new(PATTERNS[:major])
+    @scales[root_pitch.to_s] ||= {}
+    @scales[root_pitch.to_s][scale_type.name] ||= new(root_pitch, scale_type)
   end
 
-  def self.minor
-    @scales ||= {}
-    @scales[:minor] ||=  new(PATTERNS[:minor])
+  attr_reader :root_pitch, :scale_type
+
+  def initialize(root_pitch, scale_type)
+    @root_pitch = HeadMusic::Pitch.get(root_pitch)
+    @scale_type = HeadMusic::ScaleType.get(scale_type)
   end
 
-  def self.minor_pentatonic
-    @scales ||= {}
-    @scales[:minor_pentatonic] ||=  new(PATTERNS[:minor_pentatonic])
+  def pitches
+    @pitches ||= begin
+      pitches = [root_pitch]
+      letters_cycle = HeadMusic::Letter::NAMES
+      letters_cycle = letters_cycle.rotate while letters_cycle.first != root_pitch.letter.to_s
+      semitones_from_root = 0
+      if scale_type.parent
+        parent_scale_pitches = HeadMusic::Scale.get(root_pitch, scale_type.parent_name).pitches
+      end
+      scale_type.intervals.each_with_index do |semitones, i|
+        semitones_from_root += semitones
+        pitch_number = root_pitch.pitch_class.to_i + semitones_from_root
+        if scale_type.intervals.length == 7
+          current_letter = letters_cycle[(i + 1) % 7]
+        elsif scale_type.intervals.length < 7 && scale_type.parent
+          current_letter = parent_scale_pitches.detect { |parent_scale_pitches|
+            parent_scale_pitches.pitch_class == (root_pitch + semitones_from_root).to_i % 12
+          }.letter
+        elsif root_pitch.flat?
+          current_letter = HeadMusic::PitchClass::FLAT_SPELLINGS[pitch_number % 12]
+        else
+          current_letter = HeadMusic::PitchClass::SHARP_SPELLINGS[pitch_number % 12]
+        end
+        pitch = HeadMusic::Pitch.from_number_and_letter(pitch_number, current_letter)
+        pitches << pitch
+      end
+      pitches
+    end
   end
 
-  def initialize(pattern)
-    @pattern = pattern
+  def pitch_names
+    pitches.map(&:spelling).map(&:to_s)
   end
 
   def in(spelling)

data/lib/head_music/scale_type.rb

@@ -16,17 +16,13 @@ class HeadMusic::ScaleType
   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],
+    i: [:ionian, :major],
     ii: [:dorian],
     iii: [:phrygian],
     iv: [:lydian],
     v: [:mixolydian],
-    vi: [:aeolian, :minor, :natural_minor, :min],
+    vi: [:aeolian, :minor, :natural_minor],
     vii: [:locrian],
   }
   SCALE_TYPES = {}
@@ -40,14 +36,19 @@ class HeadMusic::ScaleType
   SCALE_TYPES[:harmonic_minor] = { ascending: HARMONIC_MINOR }
   SCALE_TYPES[:melodic_minor] = { ascending: MELODIC_MINOR_ASCENDING, descending: VI.reverse }
 
+  CHROMATIC = [H, H, H, H, H, H, H, H, H, H, H, H]
   SCALE_TYPES[:chromatic] = { ascending: CHROMATIC }
 
-  SCALE_TYPES[:minor_pentatonic] = { ascending: MINOR_PENTATONIC }
-  SCALE_TYPES[:major_pentatonic] = { ascending: MAJOR_PENTATONIC }
+  MINOR_PENTATONIC = [3, 2, 2, 3, 2]
+  SCALE_TYPES[:minor_pentatonic] = { ascending: MINOR_PENTATONIC, parent_name: :minor }
+  SCALE_TYPES[:major_pentatonic] = { ascending: MINOR_PENTATONIC.rotate, parent_name: :major }
+  SCALE_TYPES[:egyptian_pentatonic] = { ascending: MINOR_PENTATONIC.rotate(2), parent_name: :minor }
+  SCALE_TYPES[:blues_minor_pentatonic] = { ascending: MINOR_PENTATONIC.rotate(3), parent_name: :minor }
+  SCALE_TYPES[:blues_major_pentatonic] = { ascending: MINOR_PENTATONIC.rotate(4), parent_name: :major }
 
+  # exotic scales
   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|
@@ -60,17 +61,20 @@ class HeadMusic::ScaleType
   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])
+    attributes = SCALE_TYPES[name]
+    @scale_types[name] ||= new(name, attributes)
   end
 
-  attr_reader :name, :ascending_intervals, :descending_intervals
+  attr_reader :name, :ascending_intervals, :descending_intervals, :parent_name
+  alias_method :intervals, :ascending_intervals
+
   delegate :to_s, to: :name
 
-  def initialize(name, ascending_intervals, descending_intervals = nil)
+  def initialize(name, attributes)
     @name = name
-    @ascending_intervals = ascending_intervals
-    @descending_intervals = descending_intervals || ascending_intervals.reverse
+    @ascending_intervals = attributes[:ascending]
+    @descending_intervals = attributes[:descending] || ascending_intervals.reverse
+    @parent_name = attributes[:parent_name]
   end
 
   def ==(other)
@@ -80,4 +84,8 @@ class HeadMusic::ScaleType
   def state
     [ascending_intervals, descending_intervals]
   end
+
+  def parent
+    @parent ||= self.class.get(parent_name) if parent_name
+  end
 end

data/lib/head_music/spelling.rb

@@ -10,7 +10,6 @@ class HeadMusic::Spelling
   delegate :number, to: :pitch_class, prefix: true
 
   def self.get(identifier)
-    @spellings ||= {}
     from_name(identifier) || from_number(identifier)
   end
 
@@ -32,11 +31,19 @@ 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)
-    accidental = HeadMusic::Accidental.for_interval(pitch_class_number - letter.pitch_class.to_i)
+    from_number_and_letter(number, letter)
+  end
+
+  def self.from_number_and_letter(number, letter)
+    letter = HeadMusic::Letter.get(letter)
+    natural_letter_pitch_class = HeadMusic::Letter.get(letter).pitch_class
+    accidental_interval = letter.pitch_class.smallest_interval_to(HeadMusic::PitchClass.get(number))
+    accidental = HeadMusic::Accidental.for_interval(accidental_interval)
     fetch_or_create(letter, accidental)
   end
 
   def self.fetch_or_create(letter, accidental)
+    @spellings ||= {}
     key = [letter, accidental].join
     @spellings[key] ||= new(letter, accidental)
   end
@@ -56,6 +63,14 @@ class HeadMusic::Spelling
     name
   end
 
+  def sharp?
+    accidental && accidental == '#'
+  end
+
+  def flat?
+    accidental && accidental == 'b'
+  end
+
   def ==(value)
     to_s == value.to_s
   end

data/lib/head_music/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Rob Head
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-18 00:00:00.000000000 Z
+date: 2017-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport