coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/errors.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Style/Documentation
-
-module Coltrane
-  class ColtraneError < StandardError
-    def initialize(msg)
-      super msg
-    end
-  end
-
-  class BadConstructorError < ColtraneError
-    def initialize(msg = nil)
-      super "Bad constructor. #{msg}"
-    end
-  end
-
-  class WrongKeywordsError < BadConstructorError
-    def initialize(msg)
-      super "Use one of the following set of keywords: #{msg}"
-    end
-  end
-
-  class WrongArgumentsError < BadConstructorError
-    def initialize(_msg)
-      super 'Wrong argument(s).'
-    end
-  end
-
-  class InvalidNoteError < BadConstructorError
-    def initialize(note)
-      super "#{note} is not a valid note"
-    end
-  end
-
-  class InvalidNotesError < BadConstructorError
-    def initialize(notes)
-      super "#{notes} are not a valid set of notes"
-    end
-  end
-
-  class HasNoNotesError < BadConstructorError
-    def initialize
-      super 'The given object does not respond to :notes, '\
-            "thereby it can't be used for this operation)"
-    end
-  end
-
-  class WrongDegreeError
-    def initialize(degree)
-      super "#{degree} is not a valid degree. Degrees for this scale must be"\
-            "between 1 and #{degrees}"
-    end
-  end
-
-  class ChordNotFoundError < ColtraneError
-    def initialize
-      super "The chord you provided wasn't found. "\
-            "If you're sure this chord exists, "\
-            "would you mind to suggest it's inclusion here: "\
-            'https://github.com/pedrozath/coltrane/issues '\
-            "\n\nA tip tho: always include the letter M for major"
-    end
-  end
-
-  class IntervalNotFoundError < ColtraneError
-    def initialize(arg)
-      super "The interval \"#{arg}\" that was provided wasn't found. "\
-            "If you're sure this interval exists, "\
-            "would you mind to suggest it's inclusion here: "\
-            'https://github.com/pedrozath/coltrane/issues '\
-    end
-  end
-
-  class InvalidPitchClassError < ColtraneError
-    def initialize(arg)
-      super "The given frequency(#{arg}) is not considered "\
-            'part of a pitch class'\
-    end
-  end
-
-  class InvalidNoteSymbolError < ColtraneError
-    def initialize(arg)
-      super "The musical notation included an unrecognizable symbol (#{arg})."
-    end
-  end
-
-  class InvalidNoteLetterError < ColtraneError
-    def initialize(arg)
-      super "The musical notation included an unrecognizable letter (#{arg})."
-    end
-  end
-end
-
-# rubocop:enable Style/Documentation

data/lib/coltrane/frequency.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  class Frequency
-    attr_reader :frequency
-
-    def initialize(frequency)
-      @frequency = frequency.to_f
-    end
-
-    class << self
-      alias [] new
-    end
-
-    def to_s
-      "#{frequency}hz"
-    end
-
-    def to_f
-      frequency
-    end
-
-    def octave(n)
-      Frequency[frequency * 2**n]
-    end
-
-    def ==(other)
-      frequency == (other.is_a?(Frequency) ? other.frequency : other)
-    end
-
-    def octave_up(n = 1)
-      octave(n)
-    end
-
-    def octave_down(n = 1)
-      octave(-n)
-    end
-
-    def /(other)
-      case other
-      when Frequency then FrequencyInterval[1200 * Math.log2(other.frequency / frequency)]
-      when Numeric then Frequency[frequency / other]
-      end
-    end
-
-    def method_missing(method, *args)
-      Frequency[frequency.send(method, args[0].to_f)]
-    end
-  end
-end

data/lib/coltrane/frequency_interval.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # Interval describe the logarithmic distance between 2 frequencies.
-  # It's measured in cents.
-  class FrequencyInterval
-    include Comparable
-
-    attr_reader :cents
-
-    class << self
-      alias [] new
-    end
-
-    def initialize(cents)
-      @cents = cents.round
-    end
-
-    def semitones
-      (cents.to_f / 100).round
-    end
-
-    def ascending
-      self.class[cents.abs]
-    end
-
-    def descending
-      self.class[-cents.abs]
-    end
-
-    def ascending?
-      cents > 0
-    end
-
-    def descending?
-      cents < 0
-    end
-
-    def inversion
-      self.class[(-cents.abs % 1200) * (ascending? ? +1 : -1)]
-    end
-
-    def opposite
-      self.class.new(-cents)
-    end
-
-    def interval_class
-      IntervalClass.new(semitones)
-    end
-
-    def ==(other)
-      return false unless other.is_a? FrequencyInterval
-      cents == other.cents
-    end
-
-    alias eql? ==
-    alias hash cents
-
-    def +(other)
-      case other
-      when Numeric then FrequencyInterval[cents + other]
-      when Interval then FrequencyInterval[cents + other.cents]
-      end
-    end
-
-    def -(other)
-      case other
-      when Numeric then FrequencyInterval[cents - other]
-      when Interval then FrequencyInterval[cents - other.cents]
-      end
-    end
-
-    def -@
-      FrequencyInterval[-cents]
-    end
-
-    def <=>(other)
-      cents <=> other.cents
-    end
-  end
-end

data/lib/coltrane/interval.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  class Interval < IntervalClass
-    attr_reader :letter_distance, :cents
-    alias compound? compound
-
-    class << self
-      def all
-        @all ||= super.map(&:interval)
-      end
-
-      def all_compound
-        @all_compound ||= all.map(&:compound)
-      end
-
-      def all_including_compound
-        @all_including_compound ||= all + all_compound
-      end
-
-      def all_augmented
-        @all_augmented ||= all_including_compound.select(&:has_augmented?)
-                                                 .map(&:augmented)
-      end
-
-      def all_diminished
-        @all_diminished ||= all_including_compound.select(&:has_diminished?)
-                                                  .map(&:diminished)
-      end
-
-      def all_including_compound_and_altered
-        @all_including_compound_and_altered ||=
-          all_including_compound +
-          all_diminished +
-          all_augmented
-      end
-    end
-
-    def initialize(arg_1 = nil, arg_2 = nil, ascending: true,
-                   letter_distance: nil,
-                   semitones: nil,
-                   compound: false)
-      if arg_1 && !arg_2 # assumes arg_1 is a letter
-        @compound = compound
-        IntervalClass[arg_1].interval.yield_self do |interval|
-          @letter_distance = interval.letter_distance
-          @cents = interval.cents
-        end
-      elsif arg_1 && arg_2 # assumes those are notes
-        if ascending
-          @compound = compound
-          @cents =
-            (arg_1.frequency / arg_2.frequency)
-            .interval_class
-            .cents
-
-          @letter_distance = calculate_letter_distance arg_1.letter,
-                                                       arg_2.letter,
-                                                       ascending
-        else
-          self.class.new(arg_1, arg_2).descending.yield_self do |base_interval|
-            @compound        = base_interval.compound?
-            @cents           = base_interval.cents
-            @letter_distance = base_interval.letter_distance
-          end
-        end
-      elsif letter_distance && semitones
-        @compound        = compound || letter_distance > 8
-        @cents           = semitones * 100
-        @letter_distance = letter_distance
-      else
-        raise WrongKeywordsError,
-              '[interval_class_name]' \
-              'Provide: [first_note, second_note] || ' \
-              '[letter_distance:, semitones:]'
-      end
-    end
-
-    def self.[](arg)
-      new(arg)
-    end
-
-    def interval_class
-      FrequencyInterval[cents].interval_class
-    end
-
-    def compound?
-      @compound
-    end
-
-    def has_augmented?
-      name.match?(%r{M|P|A})
-    end
-
-    def has_diminished?
-      name.match?(%r{m|P|d})
-    end
-
-    def accidentals
-      case
-      when distance_to_starting.positive? then 'A'
-      when distance_to_starting.negative? then 'd'
-      else return ''
-      end * distance_to_starting.abs
-    end
-
-    def name
-      @name ||= begin
-        if distance_to_starting.zero? || distance_to_starting.abs > 2
-          compound? ? interval_class.compound_name : interval_class.name
-        else
-          "#{accidentals}#{starting_interval.distance + (compound? ? 7 : 0)}"
-        end
-      end
-    end
-
-    def as(n)
-      i = clone(letter_distance: n)
-      i if i.name.match?(n.to_s)
-    end
-
-    def as!(n)
-      i = as(n)
-      i unless i&.name&.match?(/d|A/)
-    end
-
-    def as_diminished(n = 1)
-      as(letter_distance + n)
-    end
-
-    def as_augmented(n = 1)
-      as(letter_distance - n)
-    end
-
-    def clone(override_args = {})
-      self.class.new({
-        semitones: semitones,
-        letter_distance: letter_distance,
-        compound: compound?
-      }.merge(override_args))
-    end
-
-    def diminish(n = 1)
-      clone(semitones: semitones - n)
-    end
-
-    alias diminished diminish
-
-    def augment(n = 1)
-      clone(semitones: semitones + n)
-    end
-
-    alias augmented augment
-
-    def opposite
-      clone(semitones: -semitones, letter_distance: (-letter_distance % 8) + 1)
-    end
-
-    def ascending
-      ascending? ? self : opposite
-    end
-
-    def descending
-      descending? ? self : opposite
-    end
-
-    private
-
-    def starting_interval # select the closest interval possible to start from
-      @starting_interval ||= begin
-        IntervalClass.all
-                     .select { |i| i.distance == normalized_letter_distance }
-                     .sort_by do |i|
-          (cents - i.cents)
-            .yield_self { |d| [(d % 1200), (d % -1200)].min_by(&:abs) }
-            .abs
-        end
-                     .first
-      end
-    end
-
-    def normalized_letter_distance
-      return letter_distance if letter_distance < 8
-      (letter_distance % 8) + 1
-    end
-
-    def distance_to_starting # calculate the closts distance to it
-      d = semitones - starting_interval.semitones
-      [(d % 12), (d % -12)].min_by(&:abs)
-    end
-
-    def all_letters
-      PitchClass.all_letters
-    end
-
-    def calculate_letter_distance(a, b, asc)
-      all_letters
-        .rotate(all_letters.index(asc ? a : b))
-        .index(b) + 1
-    end
-
-    public
-
-    all_including_compound_and_altered.each do |interval|
-      self.class.define_method(interval.full_name.underscore) { interval.clone }
-    end
-  end
-end

data/lib/coltrane/interval_class.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # Interval class here is not related to the Object Oriented Programming context
-  # but to the fact that there is a class of intervals that can all be categorized
-  # as having the same quality.
-  #
-  # This class in specific still takes into account the order of intervals.
-  # C to D is a major second, but D to C is a minor seventh.
-  class IntervalClass < FrequencyInterval
-    QUALITY_SEQUENCE = [
-      %w[P],
-      %w[m M],
-      %w[m M],
-      %w[P A],
-      %w[P],
-      %w[m M],
-      %w[m M]
-    ].freeze
-
-    ALTERATIONS = {
-      'A' => +1,
-      'd' => -1
-    }.freeze
-
-    SINGLE_DISTANCES_NAMES = %w[
-      Unison
-      Second
-      Third
-      Fourth
-      Fifth
-      Sixth
-      Seventh
-    ].freeze
-
-    COMPOUND_DISTANCES_NAMES = [
-      'Octave',
-      'Ninth',
-      'Tenth',
-      'Eleventh',
-      'Twelfth',
-      'Thirteenth',
-      'Fourteenth',
-      'Double Octave'
-    ].freeze
-
-    DISTANCES_NAMES = (SINGLE_DISTANCES_NAMES + COMPOUND_DISTANCES_NAMES).freeze
-
-    QUALITY_NAMES = {
-      'P' => 'Perfect',
-      'm' => 'Minor',
-      'M' => 'Major',
-      'A' => 'Augmented',
-      'd' => 'Diminished'
-    }.freeze
-
-    class << self
-      def distances_names
-        DISTANCES_NAMES
-      end
-
-      def distance_name(n)
-        DISTANCES_NAMES[n - 1]
-      end
-
-      def quality_name(q)
-        QUALITY_NAMES[q]
-      end
-
-      def names
-        @names ||= begin
-          SINGLE_DISTANCES_NAMES.each_with_index.reduce([]) do |i_names, (_d, i)|
-            i_names + QUALITY_SEQUENCE[i % 7].reduce([]) do |qs, q|
-              qs + ["#{q}#{i + 1}"]
-            end
-          end
-        end
-      end
-
-      def compound_names
-        @compound_names ||= all.map(&:compound_name)
-      end
-
-      def all_names_including_compound
-        @all_names_including_compound ||= names + compound_names
-      end
-
-      def full_names
-        @full_names ||= names.map { |n| expand_name(n) }
-      end
-
-      def all
-        @all ||= names.map { |n| IntervalClass[n] }
-      end
-
-      def full_names_including_compound
-        @full_names_including_compound ||=
-          all_names_including_compound.map { |n| expand_name(n) }
-      end
-
-      def split(interval)
-        interval.scan(/(\w)(\d\d?)/)[0]
-      end
-
-      def expand_name(name)
-        q, n = split(name)
-        (
-          case name
-          when /AA|dd/ then 'Double '
-          when /AAA|ddd/ then 'Triple '
-          else ''
-          end
-        ) + "#{quality_name(q)} #{distance_name(n.to_i)}"
-      end
-    end
-
-    def initialize(arg)
-      super case arg
-            when FrequencyInterval then arg.semitones
-            when String
-              self.class.names.index(arg) ||
-                self.class.full_names.index(arg) ||
-                self.class.all_names_including_compound.index(arg) ||
-                self.class.full_names_including_compound.index(arg)
-            when Numeric then arg
-            else
-              raise WrongArgumentsError,
-                    'Provide: [interval] || [name] || [number of semitones]'
-            end % 12 * 100
-    end
-
-    instance_eval { alias [] new }
-
-    def interval
-      Interval.new(letter_distance: distance, semitones: semitones)
-    end
-
-    def compound_interval
-      Interval.new(
-        letter_distance: distance,
-        semitones: semitones,
-        compound: true
-      )
-    end
-
-    alias compound compound_interval
-
-    def ==(other)
-      return false unless other.is_a? FrequencyInterval
-      (semitones % 12) == (other.semitones % 12)
-    end
-
-    def alteration
-      name.chars.reduce(0) { |a, s| a + (ALTERATIONS[s] || 0) }
-    end
-
-    def ascending
-      self.class[semitones.abs]
-    end
-
-    def descending
-      self.class[-semitones.abs]
-    end
-
-    def inversion
-      self.class[-semitones % 12]
-    end
-
-    def full_name
-      self.class.expand_name(name)
-    end
-
-    def name
-      self.class.names[semitones % 12]
-    end
-
-    def compound_name
-      "#{quality}#{distance + 7}"
-    end
-
-    def distance
-      self.class.split(name)[1].to_i
-    end
-
-    def quality
-      self.class.split(name)[0]
-    end
-
-    def +(other)
-      IntervalClass[semitones + other]
-    end
-
-    def -(other)
-      IntervalClass[semitones - other]
-    end
-
-    def -@
-      IntervalClass[-semitones]
-    end
-
-    private
-
-    def self.interval_by_full_name(arg)
-      NAMES.invert.each do |full_names, interval_name|
-        return INTERVALS.index(interval_name) if full_names.include?(arg)
-      end
-      raise IntervalNotFoundError, arg
-    end
-  end
-end