stave 0.1.0

data/lib/stave/theory/degree.rb

@@ -0,0 +1,117 @@
+module Stave
+  module Theory
+    class Degree < Core::Lookup
+      with_options position: 1 do
+        variant :root,
+                interval: Interval.perfect_unison,
+                accidental: Accidental.natural
+
+        variant :octave,
+                interval: Interval.perfect_octave,
+                accidental: Accidental.natural
+      end
+
+      with_options position: 2 do
+        variant :flat_two,
+                interval: Interval.minor_second,
+                accidental: Accidental.flat
+
+        variant :two,
+                interval: Interval.major_second,
+                accidental: Accidental.natural
+
+        variant :sharp_two,
+                interval: Interval.augmented_second,
+                accidental: Accidental.sharp
+      end
+
+      with_options position: 3 do
+        variant :flat_three,
+                interval: Interval.minor_third,
+                accidental: Accidental.flat
+
+        variant :three,
+                interval: Interval.major_third,
+                accidental: Accidental.natural
+
+        variant :sharp_three,
+                interval: Interval.augmented_third,
+                accidental: Accidental.sharp
+      end
+
+      with_options position: 4 do
+        variant :flat_four,
+                interval: Interval.diminished_fourth,
+                accidental: Accidental.flat
+
+        variant :four,
+                interval: Interval.perfect_fourth,
+                accidental: Accidental.natural
+
+        variant :sharp_four,
+                interval: Interval.augmented_fourth,
+                accidental: Accidental.sharp
+      end
+
+      with_options position: 5 do
+        variant :flat_five,
+                interval: Interval.diminished_fifth,
+                accidental: Accidental.flat
+
+        variant :five,
+                interval: Interval.perfect_fifth,
+                accidental: Accidental.natural
+
+        variant :sharp_five,
+                interval: Interval.augmented_fifth,
+                accidental: Accidental.sharp
+      end
+
+      with_options position: 6 do
+        variant :flat_six,
+                interval: Interval.minor_sixth,
+                accidental: Accidental.flat
+
+        variant :six,
+                interval: Interval.major_sixth,
+                accidental: Accidental.natural
+
+        variant :sharp_six,
+                interval: Interval.augmented_sixth,
+                accidental: Accidental.sharp
+      end
+
+      with_options position: 7 do
+        variant :flat_seven,
+                interval: Interval.minor_seventh,
+                accidental: Accidental.flat
+
+        variant :seven,
+                interval: Interval.major_seventh,
+                accidental: Accidental.natural
+      end
+
+      def symbol
+        return "R" if (to_i % 12).zero?
+
+        "#{accidental.symbol}#{interval.number.symbol}"
+      end
+
+      def to_i
+        interval.to_i
+      end
+
+      def +(other)
+        new_interval = interval + other.interval
+
+        Degree.find_by(interval: new_interval)
+      end
+
+      def -(other)
+        new_interval = interval - other.interval
+
+        Degree.find_by(interval: new_interval)
+      end
+    end
+  end
+end

data/lib/stave/theory/interval.rb

@@ -0,0 +1,185 @@
+module Stave
+  module Theory
+    class Interval < Core::Lookup
+      class Quality < Core::Lookup
+        variant :diminished,
+                transform: { major: -2, perfect: -1 },
+                inversion: :augmented,
+                symbol: "d"
+
+        variant :minor,
+                transform: { major: -1, perfect: nil },
+                inversion: :major,
+                symbol: "m"
+
+        variant :major,
+                transform: { major: 0, perfect: nil },
+                inversion: :minor,
+                symbol: "M"
+
+        variant :perfect,
+                transform: { major: nil, perfect: 0 },
+                inversion: :perfect,
+                symbol: "P"
+
+        variant :augmented,
+                transform: { major: 1, perfect: 1 },
+                inversion: :diminished,
+                symbol: "A"
+
+        def invert!
+          Quality.new(inversion)
+        end
+      end
+
+      class Number < Core::Lookup
+        variant :one, to_i: 1, size: 0, perfect?: true
+        variant :two, to_i: 2, size: 2, perfect?: false
+        variant :three, to_i: 3, size: 4, perfect?: false
+        variant :four, to_i: 4, size: 5, perfect?: true
+        variant :five, to_i: 5, size: 7, perfect?: true
+        variant :six, to_i: 6, size: 9, perfect?: false
+        variant :seven, to_i: 7, size: 11, perfect?: false
+        variant :eight, to_i: 8, size: 12, perfect?: true
+        variant :nine, to_i: 9, size: 14, perfect?: false
+        variant :eleven, to_i: 11, size: 17, perfect?: true
+        variant :thirteen, to_i: 13, size: 21, perfect?: false
+
+        def symbol = to_i.to_s
+
+        def compound? = size >= 12
+
+        def octave? = (size % 12).zero?
+
+        def degree = compound? ? to_i - 7 : to_i
+
+        def offset = to_i - 1
+
+        def +(other)
+          target_i = to_i + other.relative.offset
+          target_i -= 7 while target_i >= 8
+
+          Number.find_by(to_i: target_i)
+        end
+
+        def relative
+          target_i = to_i
+          target_i -= 7 while target_i >= 8
+
+          Number.find_by(to_i: target_i)
+        end
+
+        def invert!
+          return self if octave?
+
+          Number.find_by(degree: 9 - degree)
+        end
+
+        def self.between(note, other_note)
+          target = other_note.pitch_class.index - note.pitch_class.index + 1
+          target += 7 unless target.positive?
+
+          find_by(to_i: target)
+        end
+      end
+
+      with_options number: Number.one, scope: :unisons do
+        variant :perfect_unison, quality: Quality.perfect
+      end
+
+      with_options number: Number.two, scope: :seconds do
+        variant :minor_second,     quality: Quality.minor
+        variant :major_second,     quality: Quality.major
+        variant :augmented_second, quality: Quality.augmented
+      end
+
+      with_options number: Number.three, scope: :thirds do
+        variant :diminished_third, quality: Quality.diminished
+        variant :minor_third,      quality: Quality.minor
+        variant :major_third,      quality: Quality.major
+        variant :augmented_third,  quality: Quality.augmented
+      end
+
+      with_options number: Number.four, scope: :fourths do
+        variant :diminished_fourth, quality: Quality.diminished
+        variant :perfect_fourth,    quality: Quality.perfect
+        variant :augmented_fourth,  quality: Quality.augmented
+      end
+
+      with_options number: Number.five, scope: :fifths do
+        variant :diminished_fifth, quality: Quality.diminished
+        variant :perfect_fifth,    quality: Quality.perfect
+        variant :augmented_fifth,  quality: Quality.augmented
+      end
+
+      with_options number: Number.six, scope: :sixths do
+        variant :diminished_sixth, quality: Quality.diminished
+        variant :minor_sixth,      quality: Quality.minor
+        variant :major_sixth,      quality: Quality.major
+        variant :augmented_sixth,  quality: Quality.augmented
+      end
+
+      with_options number: Number.seven, scope: :sevenths do
+        variant :diminished_seventh, quality: Quality.diminished
+        variant :minor_seventh,      quality: Quality.minor
+        variant :major_seventh,      quality: Quality.major
+      end
+
+      with_options number: Number.eight, scope: :octaves do
+        variant :perfect_octave, quality: Quality.perfect
+      end
+
+      with_options number: Number.nine, scope: :ninths do
+        variant :minor_ninth,     quality: Quality.minor
+        variant :major_ninth,     quality: Quality.major
+        variant :augmented_ninth, quality: Quality.augmented
+      end
+
+      with_options number: Number.eleven, scope: :elevenths do
+        variant :diminished_eleventh, quality: Quality.diminished
+        variant :perfect_eleventh,    quality: Quality.perfect
+        variant :augmented_eleventh,  quality: Quality.augmented
+      end
+
+      with_options number: Number.thirteen, scope: :thirteenths do
+        variant :diminished_thirteenth, quality: Quality.diminished
+        variant :minor_thirteenth,      quality: Quality.minor
+        variant :major_thirteenth,      quality: Quality.major
+        variant :augmented_thirteenth,  quality: Quality.augmented
+      end
+
+      def to_i
+        transform_key = number.perfect? ? :perfect : :major
+
+        number.size + quality.transform[transform_key]
+      end
+
+      def symbol
+        "#{quality.symbol}#{number.symbol}"
+      end
+
+      def +(other)
+        target_number = number + other.number
+        target_i = (to_i + other.to_i) % 12
+
+        Interval.find_by(number: target_number, to_i: target_i)
+      end
+
+      def -(other)
+        self + other.invert!
+      end
+
+      def invert!
+        Interval.find_by(number: number.invert!, quality: quality.invert!)
+      end
+
+      def self.between(note, other_note)
+        number = Number.between(note, other_note)
+        to_i = other_note.to_i - note.to_i
+        to_i += 12 if to_i.negative?
+
+        Interval.find_by(number:, to_i:)
+      end
+    end
+  end
+end

data/lib/stave/theory/key_signature.rb

@@ -0,0 +1,41 @@
+module Stave
+  module Theory
+    class KeySignature < Core::Lookup
+      class Group < Core::Lookup
+        variant :flats, accidental: Accidental.flat, name: "flats"
+        variant :natural, accidental: Accidental.natural, name: ""
+        variant :sharps, accidental: Accidental.sharp, name: "sharps"
+      end
+
+      variant :natural, group: Group.natural, flat_count: 0, sharp_count: 0
+
+      with_options group: Group.flats, sharp_count: 0 do
+        variant :one_flat, flat_count: 1
+        variant :two_flats, flat_count: 2
+        variant :three_flats, flat_count: 3
+        variant :four_flats, flat_count: 4
+        variant :five_flats, flat_count: 5
+        variant :six_flats, flat_count: 6
+        variant :seven_flats, flat_count: 7
+      end
+
+      with_options group: Group.sharps, flat_count: 0 do
+        variant :one_sharp, sharp_count: 1
+        variant :two_sharps, sharp_count: 2
+        variant :three_sharps, sharp_count: 3
+        variant :four_sharps, sharp_count: 4
+        variant :five_sharps, sharp_count: 5
+        variant :six_sharps, sharp_count: 6
+        variant :seven_sharps, sharp_count: 7
+      end
+
+      def self.parse(scale)
+        accidentals = scale.uniq.map(&:accidental)
+        flat_count  = accidentals.count(&:flat?)
+        sharp_count = accidentals.count(&:sharp?)
+
+        find_by(flat_count:, sharp_count:)
+      end
+    end
+  end
+end

data/lib/stave/theory/mode.rb

@@ -0,0 +1,6 @@
+module Stave
+  module Theory
+    class Mode < Core::NoteCollection
+    end
+  end
+end

data/lib/stave/theory/mode_type.rb

@@ -0,0 +1,19 @@
+module Stave
+  module Theory
+    class ModeType < Core::DegreeCollection
+      with_options scale_type: ScaleType.major do
+        variant :ionian, position: 1
+        variant :dorian, position: 2
+        variant :phrygian, position: 3
+        variant :lydian, position: 4
+        variant :mixolydian, position: 5
+        variant :aeolian, position: 6
+        variant :locrian, position: 7
+      end
+
+      def degrees
+        scale_type.relative_rotate(position)
+      end
+    end
+  end
+end

data/lib/stave/theory/note.rb

@@ -0,0 +1,140 @@
+module Stave
+  module Theory
+    class Note < Core::Lookup
+      class PitchClass < Core::Lookup
+        variant :c, index: 0, symbol: "C", to_i: 0
+        variant :d, index: 1, symbol: "D", to_i: 2
+        variant :e, index: 2, symbol: "E", to_i: 4
+        variant :f, index: 3, symbol: "F", to_i: 5
+        variant :g, index: 4, symbol: "G", to_i: 7
+        variant :a, index: 5, symbol: "A", to_i: 9
+        variant :b, index: 6, symbol: "B", to_i: 11
+
+        def +(other)
+          case other
+          when Integer then PitchClass.find_by(index: (index + other) % 7)
+          else raise TypeError
+          end
+        end
+
+        def -(other)
+          case other
+          when Integer then PitchClass.find_by(index: (index - other) % 7)
+          else raise TypeError
+          end
+        end
+      end
+
+      with_options pitch_class: PitchClass.a do
+        variant :a_double_flat,  accidental: Accidental.double_flat
+        variant :a_flat,         accidental: Accidental.flat
+        variant :a_natural,      accidental: Accidental.natural
+        variant :a_sharp,        accidental: Accidental.sharp
+        variant :a_double_sharp, accidental: Accidental.double_sharp
+      end
+
+      with_options pitch_class: PitchClass.b do
+        variant :b_double_flat,  accidental: Accidental.double_flat
+        variant :b_flat,         accidental: Accidental.flat
+        variant :b_natural,      accidental: Accidental.natural
+        variant :b_sharp,        accidental: Accidental.sharp
+        variant :b_double_sharp, accidental: Accidental.double_sharp
+      end
+
+      with_options pitch_class: PitchClass.c do
+        variant :c_double_flat,  accidental: Accidental.double_flat
+        variant :c_flat,         accidental: Accidental.flat
+        variant :c_natural,      accidental: Accidental.natural
+        variant :c_sharp,        accidental: Accidental.sharp
+        variant :c_double_sharp, accidental: Accidental.double_sharp
+      end
+
+      with_options pitch_class: PitchClass.d do
+        variant :d_double_flat,  accidental: Accidental.double_flat
+        variant :d_flat,         accidental: Accidental.flat
+        variant :d_natural,      accidental: Accidental.natural
+        variant :d_sharp,        accidental: Accidental.sharp
+        variant :d_double_sharp, accidental: Accidental.double_sharp
+      end
+
+      with_options pitch_class: PitchClass.e do
+        variant :e_double_flat,  accidental: Accidental.double_flat
+        variant :e_flat,         accidental: Accidental.flat
+        variant :e_natural,      accidental: Accidental.natural
+        variant :e_sharp,        accidental: Accidental.sharp
+        variant :e_double_sharp, accidental: Accidental.double_sharp
+      end
+
+      with_options pitch_class: PitchClass.f do
+        variant :f_double_flat,  accidental: Accidental.double_flat
+        variant :f_flat,         accidental: Accidental.flat
+        variant :f_natural,      accidental: Accidental.natural
+        variant :f_sharp,        accidental: Accidental.sharp
+        variant :f_double_sharp, accidental: Accidental.double_sharp
+      end
+
+      with_options pitch_class: PitchClass.g do
+        variant :g_double_flat,  accidental: Accidental.double_flat
+        variant :g_flat,         accidental: Accidental.flat
+        variant :g_natural,      accidental: Accidental.natural
+        variant :g_sharp,        accidental: Accidental.sharp
+        variant :g_double_sharp, accidental: Accidental.double_sharp
+      end
+
+      def +(other)
+        case other
+        when Interval then note_above(other)
+        when Integer then Note.find_by(to_i: (to_i + other) % 12)
+        else raise
+        end
+      end
+
+      def -(other)
+        case other
+        when Interval then note_below(other)
+        when Integer then Note.find_by(to_i: (to_i - other) % 12)
+        else raise
+        end
+      end
+
+      def symbol
+        "#{pitch_class.symbol}#{accidental.symbol}"
+      end
+
+      def to_i
+        (pitch_class.to_i + accidental.transform) % 12
+      end
+
+      def note_above(interval)
+        target_pitch_class = pitch_class + interval.number.offset
+        target_integer = (to_i + interval.to_i) % 12
+
+        Note.find_by(pitch_class: target_pitch_class, to_i: target_integer)
+      end
+
+      def note_below(interval)
+        note_above(interval.invert!)
+      end
+
+      def self.flats
+        where(accidental: Accidental.flat)
+      end
+
+      def self.naturals
+        where(accidental: Accidental.natural)
+      end
+
+      def self.sharps
+        where(accidental: Accidental.sharp)
+      end
+
+      def self.single_accidental
+        flats + naturals + sharps
+      end
+
+      def self.circle_of_fifths
+        Circle.new(type: CircleType.fifths, root: Note.c_natural).notes
+      end
+    end
+  end
+end

data/lib/stave/theory/scale.rb

@@ -0,0 +1,38 @@
+module Stave
+  module Theory
+    class Scale < Core::NoteCollection
+      def key_signature
+        KeySignature.parse(self)
+      end
+
+      def triads
+        return unless type.hexatonic?
+
+        harmonise!(type.triad_types)
+      end
+
+      def sevenths
+        return unless type.hexatonic?
+
+        harmonise!(type.seventh_types)
+      end
+
+      def mode(position)
+        return if type.mode_types.empty?
+
+        Mode.new(
+          type: type.mode_type_at(position),
+          root: note_at(position)
+        )
+      end
+
+      private
+
+      def harmonise!(chord_types)
+        chord_types.zip(notes).map do |chord_type, note|
+          Chord.new(type: chord_type, root: note)
+        end
+      end
+    end
+  end
+end

data/lib/stave/theory/scale_type.rb

@@ -0,0 +1,77 @@
+module Stave
+  module Theory
+    class ScaleType < Core::DegreeCollection
+      variant :major, degrees: [
+        Degree.root,
+        Degree.two,
+        Degree.three,
+        Degree.four,
+        Degree.five,
+        Degree.six,
+        Degree.seven,
+        Degree.octave
+      ]
+
+      variant :minor, degrees: [
+        Degree.root,
+        Degree.two,
+        Degree.flat_three,
+        Degree.four,
+        Degree.five,
+        Degree.flat_six,
+        Degree.flat_seven,
+        Degree.octave
+      ]
+
+      with_options suffix: :pentatonic do
+        variant :major, degrees: [
+          Degree.root,
+          Degree.two,
+          Degree.three,
+          Degree.five,
+          Degree.six,
+          Degree.octave
+        ]
+
+        variant :minor, degrees: [
+          Degree.root,
+          Degree.flat_three,
+          Degree.four,
+          Degree.five,
+          Degree.flat_seven,
+          Degree.octave
+        ]
+      end
+
+      def pentatonic?
+        count == 5
+      end
+
+      def hexatonic?
+        count == 7
+      end
+
+      def triad_types
+        Core::ScaleHarmoniser
+          .new(scale_type: self, chord_set: ChordType::Set.triad)
+          .harmonise!
+      end
+
+      def seventh_types
+        Core::ScaleHarmoniser
+          .new(scale_type: self, chord_set: ChordType::Set.seventh)
+          .harmonise!
+      end
+
+      def mode_types
+        ModeType.where(scale_type: self).sort_by(&:position)
+      end
+
+      def mode_type_at(position)
+        position -= 7 while position >= 8
+
+        mode_types[position - 1]
+      end
+    end
+  end
+end

data/lib/stave/version.rb

@@ -0,0 +1,3 @@
+module Stave
+  VERSION = "0.1.0".freeze
+end

data/lib/stave.rb

@@ -0,0 +1,13 @@
+require "forwardable"
+require "zeitwerk"
+
+module Stave
+  INFLECTIONS = {}.freeze
+
+  COLLAPSED_DIRS = [].freeze
+
+  Zeitwerk::Loader.for_gem(warn_on_extra_files: false).tap do |loader|
+    loader.inflector.inflect(INFLECTIONS)
+    loader.collapse(COLLAPSED_DIRS)
+  end.setup
+end

data/sig/stave.rbs

@@ -0,0 +1,3 @@
+module Stave
+  VERSION: String
+end

data/stave.gemspec

@@ -0,0 +1,29 @@
+require_relative "lib/stave/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "stave"
+  spec.version = Stave::VERSION
+  spec.authors = ["Chris Welham"]
+  spec.email = ["71787007+apexatoll@users.noreply.github.com"]
+
+  spec.summary = "Music theory object library"
+  spec.description = "A Ruby gem that abstracts and models music theory"
+  spec.homepage = "https://github.com/apexatoll/stave"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.3.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      next false if File.expand_path(f) == __FILE__
+
+      f.start_with?(*%w[bin/ spec/ .git Gemfile])
+    end
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "zeitwerk"
+end