coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/interval_sequence.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # It describes a sequence of intervals
-  class IntervalSequence
-    extend Forwardable
-    attr_reader :intervals
-
-    def_delegators :@intervals, :map, :each, :[], :size,
-                   :reduce, :delete, :reject!, :delete_if, :detect, :to_a
-
-    def initialize(*intervals, notes: nil, relative_intervals: nil)
-      if intervals.any?
-        @intervals = if intervals.first.is_a?(Interval)
-                       intervals
-                     else
-                       intervals.map { |i| Interval[i] }
-        end
-
-      elsif notes
-        notes = NoteSet[*notes] if notes.is_a?(Array)
-        @intervals = intervals_from_notes(notes)
-      elsif relative_intervals
-        @relative_intervals = relative_intervals
-        @intervals = intervals_from_relative_intervals(relative_intervals)
-      else
-        raise WrongKeywordsError,
-              'Provide: [notes:] || [intervals:] || [relative_intervals:]'
-      end
-    end
-
-    Interval.all_including_compound_and_altered.each do |interval|
-      # Creates methods such as major_third, returning it if it finds
-      define_method(interval.full_name.underscore.to_s) { find(interval) }
-      # Creates methods such as has_major_third?, returning a boolean
-      define_method("has_#{interval.full_name.underscore}?") { has?(interval) }
-    end
-
-    Interval.distances_names.map(&:underscore).each_with_index do |distance, i|
-      # Creates methods such as has_third?, returning a boolean
-      define_method("has_#{distance}?") { !!find_by_distance(i + 1) }
-      # Creates methods such third, returning any third it finds
-      define_method(distance.to_s) { find_by_distance(i + 1) }
-      # Creates methods such third!, returning thirds that arent aug or dim
-      define_method("#{distance}!") { find_by_distance(i + 1, false) }
-    end
-
-    instance_eval { alias [] new }
-
-    def relative_intervals
-      intervals_semitones[1..-1].each_with_index.map do |n, i|
-        if i.zero?
-          n
-        elsif i < intervals_semitones.size
-          n - intervals_semitones[i]
-        end
-      end + [12 - intervals_semitones.last]
-    end
-
-    def names
-      intervals.map(&:name)
-    end
-
-    def find(interval)
-      interval.clone if detect { |i| interval == i }
-    end
-
-    def has?(interval)
-      !!find(interval)
-    end
-
-    def find_by_distance(n, accept_altered = true)
-      strategy = (accept_altered ? :as : :as!)
-      map { |interval| interval.send(strategy, n) }
-        .compact
-        .sort_by { |i| i.alteration.abs }
-        .first
-    end
-
-    alias interval_names names
-
-    def all
-      intervals
-    end
-
-    def [](x)
-      intervals[x]
-    end
-
-    def shift(ammount)
-      self.class.new(*intervals.map do |i|
-        (i.semitones + ammount) % 12
-      end)
-    end
-
-    def zero_it
-      shift(-intervals.first.semitones)
-    end
-
-    def inversion(index)
-      self.class.new(*intervals.rotate(index)).zero_it
-    end
-
-    def next_inversion
-      inversion(index + 1)
-    end
-
-    def previous_inversion
-      inversion(index - 1)
-    end
-
-    def inversions
-      Array.new(intervals.length) { |i| inversion(i) }
-    end
-
-    def intervals_semitones
-      map(&:semitones)
-    end
-
-    def names
-      map(&:name)
-    end
-
-    def full_names
-      map(&:full_name)
-    end
-
-    def notes_for(root_note)
-      NoteSet[
-        *intervals.reduce([]) do |memo, interval|
-          memo + [root_note + interval]
-        end
-      ]
-    end
-
-    def &(other)
-      case other
-      when Array then intervals & other
-      when IntervalSequence then intervals & other.semitones
-      end
-    end
-
-    private
-
-    def intervals_from_relative_intervals(relative_intervals)
-      relative_intervals[0..-2].reduce([Interval[0]]) do |memo, d|
-        memo + [memo.last + d]
-      end
-    end
-
-    def intervals_from_notes(notes)
-      notes.map { |n| notes.root - n }.sort_by(&:semitones)
-    end
-  end
-end

data/lib/coltrane/key.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  class Key < DiatonicScale
-    KEY_REGEX = /([A-G][#b]?)([mM]?)/
-
-    def initialize(notation)
-      _, note, s = *notation.match(KEY_REGEX)
-      super(note, major: s != 'm')
-    end
-
-    def self.[](notation)
-      new(notation)
-    end
-  end
-end

data/lib/coltrane/notable_progressions.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # This module takes care of adding to progressions knowledge that is more
-  # based on common standards and practices.
-  module NotableProgressions
-    PROGRESSIONS = {
-      'Pop' => ['I-V-vi-IV', :major],
-      'Jazzy Pop' =>  ['IM7-V7-vi7-IVM7',      :major],
-      'Jazz' =>       ['ii7-V7-I7',            :major],
-      'Jazz Minor' => ['ii7-V7-i7',            :major],
-      'Blues' =>      ['IM7-IV7-I7-V7-IV7-I7', :major],
-      'Jazz Blues' => ['I7-IV7-I7-V7-IV7-I7',  :major],
-      'Fifties' =>    ['I-vi-IV-V',            :major],
-      'Circle' =>     ['vi-ii-V-I',            :major],
-      'Tune Up' =>    ['ii7-V7-IM7-i7-IV7-IVM7-VIIM7', :minor]
-    }.freeze
-
-    PROGRESSIONS.each do |name, values|
-      notation, scale_name = values
-      define_method name.underscore do |note|
-        note  = note.is_a?(Note) ? note : Note[note]
-        scale = Scale.public_send(scale_name, note)
-        new(notation, scale: scale)
-      end
-    end
-  end
-end

data/lib/coltrane/note.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # Notes are different ways of calling pitch classes. In the context of equal
-  # tempered scales, they're more like a conceptual subject for
-  # matters of convention than an actual thing.
-  #
-  # Take for example A# and Bb. Those are different notes. Nevertheless, in the
-  # context of equal tempered scales they represent pretty much the same
-  # frequency.
-  #
-  # The theory of notes have changed too much in the course of time, which
-  # lead us with a lot of conventions and strategies when dealing with music.
-  # That's what this class is for.
-  class Note < PitchClass
-    attr_reader :alteration
-
-    ALTERATIONS = {
-      'b' => -1,
-      '#' => 1
-    }.freeze
-
-    def initialize(arg)
-      note_name = case arg
-                  when String then arg
-                  when PitchClass then arg.true_notation
-                  when Numeric, Frequency then PitchClass.new(arg).true_notation
-                  else raise(WrongArgumentsError, arg)
-                  end
-
-      chars  = note_name.chars
-      letter = chars.shift
-      raise InvalidNoteLetterError, arg unless ('A'..'G').cover?(letter)
-      @alteration = chars.reduce(0) do |alt, symbol|
-        raise InvalidNoteLetterError, arg unless ALTERATIONS.include?(symbol)
-        alt + ALTERATIONS[symbol]
-      end
-      super((PitchClass[letter].integer + @alteration) % PitchClass.size)
-    end
-
-    def self.[](arg)
-      new(arg)
-    end
-
-    def name
-      "#{base_pitch_class}#{accidents}".gsub(/#b|b#/, '')
-    end
-
-    def base_pitch_class
-      PitchClass[integer - alteration]
-    end
-
-    def alteration=(a)
-      @alteration = a unless PitchClass[integer - a].accidental?
-    end
-
-    def alter(x)
-      Note.new(name).tap { |n| n.alteration = x }
-    end
-
-    def sharp?
-      alteration == 1
-    end
-
-    def double_sharp?
-      alteration == 2
-    end
-
-    def flat?
-      alteration == -1
-    end
-
-    def double_flat?
-      alteration == -2
-    end
-
-    def natural?
-      alteration == 0
-    end
-
-    def accidents
-      (@alteration > 0 ? '#' : 'b') * alteration.abs
-    end
-
-    def -(other)
-      super(other).yield_self { |r| r.is_a?(Note) ? r.alter(alteration) : r }
-    end
-
-    def +(other)
-      super(other).yield_self { |r| r.is_a?(Note) ? r.alter(alteration) : r }
-    end
-
-    def as(letter)
-      a = (Note[letter] - self)
-      alter([a.semitones, -(-a).semitones].min_by(&:abs))
-    end
-  end
-end

data/lib/coltrane/note_set.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # It describes a set of notes
-  class NoteSet
-    extend Forwardable
-
-    def_delegators :@notes, :first, :each, :size, :map, :reduce, :index,
-                   :[], :index, :empty?, :permutation, :include?, :<<, :any?,
-                   :count, :rotate
-
-    attr_reader :notes
-
-    alias root first
-    alias all notes
-
-    def self.[](*notes)
-      new(notes)
-    end
-
-    def initialize(arg)
-      @notes =
-        case arg
-        when NoteSet then arg.notes
-        when Array   then arg.compact.map { |n| n.is_a?(PitchClass) ? n : Note[n] }.uniq
-        else raise InvalidNotesError, arg
-        end
-    end
-
-    def &(other)
-      NoteSet[*(notes & other.notes)]
-    end
-
-    def degree(note)
-      index(note) + 1
-    end
-
-    def +(other)
-      case other
-      when Note then NoteSet[*(notes + [other])]
-      when NoteSet then NoteSet[*notes, *other.notes]
-      when Interval then NoteSet[*notes.map { |n| n + other }]
-      end
-    end
-
-    def -(other)
-      case other
-      when NoteSet then NoteSet[*(notes - other.notes)]
-      when Interval then NoteSet[*notes.map { |n| n - other }]
-      end
-    end
-
-    def pretty_names
-      map(&:pretty_name)
-    end
-
-    def names
-      map(&:name)
-    end
-
-    def integers
-      map(&:integer)
-    end
-
-    def accidentals
-      count(&:accidental?)
-    end
-
-    def sharps
-      count(&:sharp?)
-    end
-
-    def flats
-      count(&:flat?)
-    end
-
-    def alter(alteration)
-      NoteSet[*map { |n| n.alter(alteration) }]
-    end
-
-    def alter_accidentals(alteration)
-      NoteSet[*map { |n| n.alter(alteration) if n.accidental? }]
-    end
-
-    def interval_sequence
-      IntervalSequence.new(notes: self)
-    end
-  end
-end

data/lib/coltrane/pitch.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # It describes a pitch, like E4 or Bb5. It's like a note, but it has an octave
-  class Pitch
-    attr_reader :integer
-
-    def initialize(notation_arg = nil,
-                   note: nil,
-                   octave: nil,
-                   notation: nil,
-                   frequency: nil)
-
-      @integer = begin
-        if (n = notation_arg || notation)
-          n.is_a?(Integer) ? n : integer_from_notation(n)
-        elsif note && octave
-          integer_from_note_and_octave(Note[note], octave)
-        elsif frequency
-          integer_from_frequency(frequency)
-        else
-          raise(InvalidArgumentsError)
-        end
-      end
-    end
-
-    def self.[](*args)
-      new *args
-    end
-
-    def scientific_notation
-      "#{pitch_class}#{octave}"
-    end
-
-    def pitch_class
-      PitchClass[integer]
-    end
-
-    def octave
-      (integer / 12) - 1
-    end
-
-    alias notation scientific_notation
-    alias name     scientific_notation
-    alias to_s     scientific_notation
-
-    alias hash integer
-    alias midi integer
-
-    def ==(other)
-      integer == other.integer
-    end
-
-    def frequency
-      pitch_class.frequency.octave(octave)
-    end
-
-    alias eql? ==
-    alias eq ==
-
-    def +(other)
-      case other
-      when Integer then Pitch[integer + other]
-      end
-    end
-
-    def -(other)
-      case other
-      when Integer then Pitch[integer - other]
-      end
-    end
-
-    private
-
-    def integer_from_notation(the_notation)
-      _, n, o = *the_notation.match(/(\D+)(\d+)/)
-      integer_from_note_and_octave(Note[n], o)
-    end
-
-    def integer_from_note_and_octave(p, o)
-      12 * (o.to_i + 1) + p.integer
-    end
-
-    def integer_from_frequency(f)
-      octave_from_frequency(f) * 12 + PitchClass.new(frequency: f).integer
-    end
-
-    def octave_from_frequency(f)
-      Math.log(f.to_f / PitchClass['C'].frequency.to_f, 2).ceil
-    end
-  end
-end