coltrane 2.2.1 → 3.0.0.pre

data/lib/cli/text.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # A text representation
-    class Text < Representation
-      def render
-        case Cli.config.flavor
-        when :marks, :notes, :degrees then @notes.pretty_names.join(' ')
-        when :intervals then @notes.map { |n| (@notes.first - n).name }.join(' ')
-        else raise WrongFlavorError
-        end
-      end
-    end
-  end
-end

data/lib/cli/ukulele.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module Cli
-    # Renders notes in a common most popular ukulele scheme
-    class Ukulele < Guitar
-      SPECIAL_FRETS = [5, 7, 9, 12].freeze
-
-      def initialize(notes, tuning: %w[G C E A], frets: 12)
-        super
-      end
-    end
-  end
-end

data/lib/coltrane/cache.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # A simple caching based on serializing objects into files
-  # maybe this should changed to save in a single json file
-  class Cache
-    class << self
-      def find_or_record(key, &block)
-        if @disabled || !(cached = fetch(key))
-          cached = yield block
-          record(key, cached)
-        end
-        cached
-      end
-
-      def disable
-        @disabled = true
-      end
-
-      def enable
-        @disabled = false
-      end
-
-      private
-
-      def dir
-        dir = File.expand_path('../../../', __FILE__) + '/cache/'
-        Dir.mkdir(dir) unless Dir.exist?(dir)
-        dir
-      end
-
-      def fetch(key)
-        Marshal.load File.read(dir + key) if File.file?(dir + key)
-      end
-
-      def record(key, contents)
-        File.open(dir + key, 'w') do |f|
-          f.write Marshal.dump(contents)
-        end
-      end
-    end
-  end
-end

data/lib/coltrane/cadence.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # Not done yet
-  class Cadence
-  end
-end

data/lib/coltrane/chord.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # It describe a chord
-
-  class Chord
-    attr_reader :root_note, :quality, :notes
-    include ChordSubstitutions
-
-    def initialize(notes: nil, root_note: nil, quality: nil, name: nil)
-      if notes
-        notes      = NoteSet[*notes] if notes.is_a?(Array)
-        @notes     = notes
-        @root_note = notes.first
-        @quality   = ChordQuality.new(notes: notes)
-      elsif root_note && quality
-        @notes     = quality.notes_for(root_note)
-        @root_note = root_note
-        @quality   = quality
-      elsif name
-        @root_note, @quality, @notes = parse_from_name(name)
-      else
-        raise WrongKeywordsError,
-              '[notes:] || [root_note:, quality:] || [name:]'
-      end
-    end
-
-    def name
-      "#{root_note}#{quality}"
-    end
-
-    alias to_s name
-
-    def pretty_name
-      "#{root_note.pretty_name}#{quality.name}"
-    end
-
-    def intervals
-      IntervalSequence.new(NoteSet.new(notes))
-    end
-
-    def size
-      notes.size
-    end
-
-    def scales
-      Scale.having_chord(name)
-    end
-
-    def next_inversion
-      Chord.new(notes: notes.rotate(1))
-    end
-
-    def invert(n = 1)
-      Chord.new(notes: notes.rotate(n))
-    end
-
-    def previous_inversion
-      Chord.new(notes: notes.rotate(-1))
-    end
-
-    def +(other)
-      case other
-      when Note, NoteSet, Interval then Chord.new(notes: notes + other)
-      when Chord then Chord.new(notes: notes + other.notes)
-      end
-    end
-
-    def -(other)
-      case other
-      when Note, NoteSet, Interval, Numeric then Chord.new(notes: notes - other)
-      when Chord then Chord.new(notes: notes - other.notes)
-      end
-    end
-
-    protected
-
-    def parse_from_name(name)
-      chord_name, bass = name.match?(/\/9/) ? [name, nil] : name.split('/')
-      chord_regex = /([A-Z](?:#|b)?)(.*)/
-      _, root_name, quality_name = chord_name.match(chord_regex).to_a
-      root    = Note[root_name]
-      quality = ChordQuality.new(name: quality_name, bass: bass)
-      notes   = quality.notes_for(root)
-      notes << Note[bass] unless bass.nil?
-      [root, quality, notes]
-    end
-  end
-end

data/lib/coltrane/chord_quality.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # It describe the quality of a chord, like maj7 or dim.
-  class ChordQuality < IntervalSequence
-    include Qualities
-    attr_reader :name
-    # QUALITIES_FILE  = File.expand_path("#{'../' * 3}data/qualities.json", __FILE__)
-
-    private
-
-    def self.chord_trie
-      File.expand_path("#{'../' * 3}data/qualities.json", __FILE__)
-      trie = QUALITIES
-
-      trie.clone_values from_keys: ['Perfect Unison', 'Major Third'],
-                        to_keys: ['Perfect Unison', 'Major Second'],
-                        suffix: 'sus2'
-
-      trie.clone_values from_keys: ['Perfect Unison', 'Major Third'],
-                        to_keys: ['Perfect Unison', 'Perfect Fourth'],
-                        suffix: 'sus4'
-      trie.deep_dup
-    end
-
-    def self.intervals_per_name(quality_names: {}, intervals: [], hash: nil)
-      hash ||= chord_trie
-      return quality_names if hash.empty?
-      if hash['name']
-        quality_names[hash.delete('name')] = intervals.map { |n| Interval.public_send(n.underscore) }
-      end
-      hash.reduce(quality_names) do |memo, (interval, values)|
-        memo.merge intervals_per_name(hash:  values,
-                                      quality_names: quality_names,
-                                      intervals: intervals + [interval])
-      end
-    end
-
-    NAMES = intervals_per_name
-
-    def find_chord(given_interval_names, trie: self.class.chord_trie, last_name: nil)
-      return if trie.nil?
-      if given_interval_names.empty?
-        @found = true
-        return trie['name']
-      end
-      interval = given_interval_names.shift
-      new_trie = trie[interval.full_name]
-      find_chord given_interval_names, last_name: (trie['name'] || last_name),
-                                       trie: new_trie
-    end
-
-    def normal_sequence
-      %i[unison third! fifth sixth! seventh ninth eleventh! thirteenth]
-    end
-
-    def sus2_sequence
-      %i[unison second! fifth sixth! seventh ninth eleventh! thirteenth]
-    end
-
-    def sus4_sequence
-      %i[unison fourth! fifth sixth! seventh ninth eleventh! thirteenth]
-    end
-
-    def retrieve_chord_intervals(chord_sequence = normal_sequence)
-      ints = IntervalSequence.new(*self)
-      chord_sequence.map do |int_sym|
-        next unless interval_name = ints.public_send(int_sym)
-        ints.delete_if { |i| i.cents == IntervalClass.new(interval_name).cents }
-        interval_name
-      end
-    end
-
-    public
-
-    def get_name
-      find_chord(retrieve_chord_intervals.compact) ||
-        find_chord(retrieve_chord_intervals(sus2_sequence).compact) ||
-        find_chord(retrieve_chord_intervals(sus4_sequence).compact) ||
-        raise(ChordNotFoundError)
-    end
-
-    def suspension_type
-      if has_major_second?
-        'sus2'
-      else has_fourth?
-           'sus4'
-      end
-    end
-
-    def initialize(name: nil, notes: nil, bass: nil)
-      if name
-        @name = bass.nil? ? name : [name, bass].join('/')
-        super(*intervals_from_name(name))
-      elsif notes
-        super(notes: notes)
-        @name = get_name
-      else
-        raise WrongKeywordsError, '[name:] || [notes:]'
-      end
-    end
-
-    alias to_s name
-
-    private
-
-    def intervals_from_name(name)
-      NAMES[name] || NAMES["M#{name}"] || raise(ChordNotFoundError)
-    end
-  end
-end

data/lib/coltrane/chord_substitutions.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  module ChordSubstitutions
-    def tritone_substitution
-      self + Interval.augmented_fourth
-    end
-  end
-end

data/lib/coltrane/circle_of_fifths.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  class CircleOfFifths
-    attr_reader :notes
-
-    LETTER_SEQUENCE = %w[C G D A E B F].freeze
-
-    def initialize(start_note = Note['C'], size = Float::INFINITY)
-      index  = letters.index(start_note.name[0])
-      @notes = fifths(note: start_note - Interval.perfect_fifth,
-                      size: size,
-                      index: (index - 1) % LETTER_SEQUENCE.size)
-    end
-
-    private
-
-    def fifths(note:, index: nil, notes: [], size:)
-      return notes if size == 0
-      return notes if notes.any? && note.as(letters(index)).name == notes.first.name
-      fifths note: note + Interval.perfect_fifth,
-             notes: notes + [note.as(letters(index))],
-             index: index + 1,
-             size:  size - 1
-    end
-
-    def letters(i = nil)
-      i.nil? ? LETTER_SEQUENCE : LETTER_SEQUENCE[i % LETTER_SEQUENCE.size]
-    end
-  end
-end

data/lib/coltrane/classic_scales.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # This module deals with well known scales on music
-  module ClassicScales
-    SCALES = {
-      'Pentatonic Major' => [2, 2, 3, 2, 3],
-      'Blues Major'      => [2, 1, 1, 3, 2, 3],
-      'Harmonic Minor'   => [2, 1, 2, 2, 1, 3, 1],
-      'Hungarian Minor'  => [2, 1, 2, 1, 1, 3, 1],
-      'Pentatonic Minor' => [3, 2, 2, 3, 2],
-      'Blues Minor'      => [3, 2, 1, 1, 3, 2],
-      'Whole Tone'       => [2, 2, 2, 2, 2, 2],
-      'Flamenco'         => [1, 3, 1, 2, 1, 2, 2],
-      'Chromatic'        => [1] * 12
-    }.freeze
-
-    GREEK_MODES = %w[
-      Ionian
-      Dorian
-      Phrygian
-      Lydian
-      Mixolydian
-      Aeolian
-      Locrian
-    ].freeze
-
-    # Creates factories for scales
-    SCALES.each do |name, distances|
-      define_method name.underscore do |tone = 'C', mode = 1|
-        new(*distances, tone: tone, mode: mode, name: name)
-      end
-    end
-
-    # Creates factories for Greek Modes
-    GREEK_MODES.each_with_index do |mode, index|
-      mode_name = mode
-      mode_n = index + 1
-      define_method mode.underscore do |tone = 'C'|
-        new(notes: DiatonicScale.new(tone).notes.rotate(index))
-      end
-    end
-
-    # Factories for the diatonic scale
-    def major(note = 'C')
-      DiatonicScale.new(note)
-    end
-
-    def minor(note = 'A')
-      DiatonicScale.new(note, major: false)
-    end
-
-    alias diatonic major
-    alias natural_minor minor
-    alias pentatonic pentatonic_major
-    alias blues blues_major
-
-    def known_scales
-      SCALES.keys + ['Major', 'Natural Minor']
-    end
-
-    # List of scales appropriate for search
-    def standard_scales
-      known_scales - ['Chromatic']
-    end
-
-    def fetch(name, tone = nil)
-      Coltrane::Scale.public_send(name, tone)
-    end
-
-    def having_notes(notes)
-      format = { scales: [], results: {} }
-      standard_scales.each_with_object(format) do |name, output|
-        PitchClass.all.each.map do |tone|
-          scale = send(name.underscore, tone)
-          output[:results][name] ||= {}
-          next if output[:results][name].key?(tone.integer)
-          output[:scales] << scale if scale.include?(notes)
-          output[:results][name][tone.integer] = scale.notes & notes
-        end
-      end
-    end
-
-    def having_chords(*chords)
-      should_create = !chords.first.is_a?(Chord)
-      notes = chords.reduce(NoteSet[]) do |memo, c|
-        memo + (should_create ? Chord.new(name: c) : c).notes
-      end
-      having_notes(notes)
-    end
-
-    alias having_chord having_chords
-  end
-end

data/lib/coltrane/diatonic_scale.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  class DiatonicScale < Scale
-    def initialize(tone, major: true)
-      @major = major
-      tone   = Note[tone]
-      notes  = CircleOfFifths.new(tone - (major? ? 0 : 9), 7).notes.sort
-      super notes: notes.rotate(notes.index(tone))
-    end
-
-    def name
-      major? ? 'Major' : 'Natural Minor'
-    end
-
-    def relative_minor
-      minor? ? self : self.class.new(@tone + 9, major: false)
-    end
-
-    def relative_major
-      major? ? self : self.class.new(@tone - 9, major: true)
-    end
-
-    def relative
-      major? ? relative_minor : relative_major
-    end
-
-    def major?
-      !!@major
-    end
-
-    def minor?
-      !@major
-    end
-  end
-end