coltrane 1.2.4 → 2.0.0

data/lib/coltrane/pitch_class.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Coltrane
+  #
+  # Pitch classes, and by classes here we don't mean in the sense of a ruby class
+  # are all the classes of pitches (frequencies) that are in a whole number of
+  # octaves apart.
+  #
+  # For example, C1, C2, C3 are all pitches from the C pitch class. Take a look into
+  # Notes description if you somehow feel this is confuse and that it could just be
+  # called as notes instead.
+  #
+  class PitchClass
+    attr_reader :integer
+
+    NOTATION = %w[C C# D D# E F F# G G# A A# B].freeze
+
+    def self.all
+      NOTATION.map { |n| new(n) }
+    end
+
+    def initialize(arg, frequency: nil)
+      @integer = case arg
+                 when String then NOTATION.index(arg)
+                 when Frequency, Float then frequency_to_integer(Frequency.new(arg))
+                 when Integer then (arg % 12)
+                 when NilClass then frequency_to_integer(Frequency.new(frequency))
+                 when PitchClass then arg.integer
+                 else raise(InvalidArgumentError)
+                 end
+    end
+
+    def self.[](arg, frequency: nil)
+      new(arg, frequency: nil)
+    end
+
+    def ==(other)
+      integer == other.integer
+    end
+
+    alias eql? ==
+    alias hash integer
+
+    def true_notation
+      NOTATION[integer]
+    end
+
+    alias name true_notation
+
+    def pretty_name
+      name.tr('b', "\u266D").tr('#', "\u266F")
+    end
+
+    def accidental?
+      notation.match? /#|b/
+    end
+
+    alias notation true_notation
+    alias to_s true_notation
+
+    def +(other)
+      case other
+      when Interval   then PitchClass[integer + other.semitones]
+      when Integer    then PitchClass[integer + other]
+      when PitchClass then Note.new(integer + other.integer)
+      when Frequency  then PitchClass.new(frequency: frequency + other)
+      end
+    end
+
+    def -(other)
+      case other
+      when Interval   then PitchClass[integer - other.semitones]
+      when Integer    then PitchClass[integer - other]
+      when PitchClass then IntervalClass[frequency / other.frequency]
+      when Frequency  then PitchClass.new(frequency: frequency - other)
+      end
+    end
+
+    def fundamental_frequency
+      @fundamental_frequency ||=
+        Frequency[
+          Coltrane.base_tuning *
+          (2**((integer - Coltrane::BASE_PITCH_INTEGER.to_f) / 12))
+        ]
+    end
+
+    alias frequency fundamental_frequency
+
+    def self.size
+      NOTATION.size
+    end
+
+    def size
+      self.class.size
+    end
+
+    def enharmonic?(other)
+      case other
+      when String then integer == Note[other].integer
+      when Note then integer == other.integer
+      end
+    end
+
+    private
+
+    def frequency_to_integer(f)
+      begin
+        (Coltrane::BASE_PITCH_INTEGER +
+          size * Math.log(f.to_f / Coltrane.base_tuning.to_f, 2)) % size
+      end.round
+    end
+  end
+end

data/lib/coltrane/progression.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Coltrane
-
   # Allows the creation of chord progressions using standard notations.
   # Ex: Progression.new('I-IV-V', key: 'Am')
   class Progression
@@ -10,9 +9,7 @@ module Coltrane
     attr_reader :scale, :chords, :notation
 
     def self.find(*chords)
-      if chords[0].is_a?(String)
-        chords.map! { |c| Chord.new(name: c) }
-      end
+      chords.map! { |c| Chord.new(name: c) } if chords[0].is_a?(String)
 
       root_notes = NoteSet[*chords.map(&:root_note)]
 
@@ -24,12 +21,12 @@ module Coltrane
       progressions.sort_by(&:notes_out_size)
     end
 
-    def initialize(notation=nil, chords: nil, roman_chords: nil, key: nil, scale: nil)
+    def initialize(notation = nil, chords: nil, roman_chords: nil, key: nil, scale: nil)
       if notation.nil? && chords.nil? && roman_chords.nil? || key.nil? && scale.nil?
         raise WrongKeywordsError,
-          '[chords:, [scale: || key:]] '\
-          '[roman_chords:, [scale: || key:]] '\
-          '[notation:, [scale: || key:]] '\
+              '[chords:, [scale: || key:]] '\
+              '[roman_chords:, [scale: || key:]] '\
+              '[notation:, [scale: || key:]] '\
       end
 
       @scale  = scale || Scale.from_key(key)
@@ -40,7 +37,7 @@ module Coltrane
           roman_chords.map(&:chord)
         elsif !notation.nil?
           @notation = notation
-          notation.split('-').map {|c| RomanChord.new(c, scale: @scale).chord }
+          notation.split('-').map { |c| RomanChord.new(c, scale: @scale).chord }
         end
     end
 

data/lib/coltrane/roman_chord.rb

@@ -4,27 +4,27 @@ module Coltrane
   # This class deals with chords in roman notation. Ex: IVº.
   class RomanChord
     DIGITS = %w[I II III IV V VI VII].freeze
-    NOTATION_REGEX = %r{
+    NOTATION_REGEX = /
       (?<degree>b?[ivIV]*)
       (?<quality>.*)
-    }x
+    /x
 
     NOTATION_SUBSTITUTIONS = [
       %w[º dim],
       %w[o dim],
       %w[ø m7b5]
-    ]
+    ].freeze
 
-    def initialize(notation=nil, chord: nil, key: nil, scale: nil)
+    def initialize(notation = nil, chord: nil, key: nil, scale: nil)
       if notation.nil? && chord.nil? || key.nil? && scale.nil?
         raise WrongKeywordsError,
-          '[notation, [scale: || key:]] '\
-          '[chord:, [scale: || key:]] '\
+              '[notation, [scale: || key:]] '\
+              '[chord:, [scale: || key:]] '\
       end
       @scale = scale || Scale.from_key(key)
-      if !notation.nil?
+      if notation
         @notation = notation
-      elsif !chord.nil?
+      elsif chord
         @chord = chord.is_a?(String) ? Chord.new(name: chord) : chord
       end
     end
@@ -62,7 +62,7 @@ module Coltrane
     def quality_name
       return @chord.quality.name unless @chord.nil?
       q     = normalize_quality_name(regexed_notation['quality'])
-      minor = 'm' if !q.match?((/dim|m7b5/)) && !upcase?
+      minor = 'm' if !q.match?(/dim|m7b5/) && !upcase?
       q     = [minor, q].join
       q.empty? ? 'M' : q
     end
@@ -79,21 +79,21 @@ module Coltrane
 
     def notation
       q = case quality_name
-      when 'm', 'M' then ''
-      when 'm7', 'M' then '7'
-      else quality_name
+          when 'm', 'M' then ''
+          when 'm7', 'M' then '7'
+          else quality_name
       end
 
       @notation ||= [
         roman_numeral,
-        q,
+        q
       ].join
     end
 
     def function
       return if @scale.name != 'Major'
       %w[Tonic Supertonic Mediant Subdominant
-        Dominant Submediant Leading][degree - 1]
+         Dominant Submediant Leading][degree - 1]
     end
 
     private

data/lib/coltrane/scale.rb

@@ -8,11 +8,11 @@ module Coltrane
 
     def initialize(*distances, tone: 'C', mode: 1, name: nil, notes: nil)
       @name = name
-      if !distances.nil? && !tone.nil?
+      if distances.any? && tone
         @tone              = Note[tone]
         distances          = distances.rotate(mode - 1)
         @interval_sequence = IntervalSequence.new(distances: distances)
-      elsif !notes.nil?
+      elsif notes
         ds = NoteSet[*notes].interval_sequence.distances
         new(*ds, tone: notes.first)
       else
@@ -119,25 +119,23 @@ module Coltrane
       Progression.new(self, degrees)
     end
 
-    def all_chords
-      chords
-    end
-
     def chords(size = 3..12)
       size = (size..size) if size.is_a?(Integer)
-      included_names = []
       scale_rotations = interval_sequence.inversions
       ChordQuality.intervals_per_name.reduce([]) do |memo1, (qname, qintervals)|
         next memo1 unless size.include?(qintervals.size)
-        memo1 + scale_rotations.each_with_index.reduce([]) do |memo2, (rot, index)|
+        memo1 + scale_rotations.each_with_index
+                               .reduce([]) do |memo2, (rot, index)|
           if (rot & qintervals).size == qintervals.size
-            memo2 + [ Chord.new(root_note: degree(index+1),
-                                quality: ChordQuality.new(name: qname)) ]
+            memo2 + [Chord.new(root_note: degree(index + 1),
+                               quality: ChordQuality.new(name: qname))]
           else
             memo2
           end
         end
       end
     end
+
+    alias all_chords chords
   end
 end

data/lib/coltrane/unordered_interval_class.rb

@@ -0,0 +1,7 @@
+
+# frozen_string_literal: true
+
+module Coltrane
+  class UnorderedIntervalClass
+  end
+end

data/lib/coltrane/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coltrane
-  VERSION = '1.2.4'
+  VERSION = '2.0.0'
 end

data/lib/coltrane_instruments.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module ColtraneInstruments
+end

data/lib/coltrane_instruments/guitar.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ColtraneInstruments
+  # This module  represents a guitar
+  module Guitar
+  end
+end

data/lib/coltrane_instruments/guitar/base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ColtraneInstruments
+  module Guitar
+    # A base class for operations involving Guitars
+    class Base
+      def initialize; end
+
+      def find_chord(target_chord)
+        Chord.new(target_chord, guitar: self).fetch_descendant_chords
+      end
+    end
+  end
+end

data/lib/coltrane_instruments/guitar/chord.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ColtraneInstruments
+  module Guitar
+    # This class represents a group of guitar notes, strummed at the same time
+    class Chord
+      def initialize(target_chord, guitar_notes: [],
+                     free_fingers: 4,
+                     barre: nil,
+                     guitar:)
+        @target_chord = target_chord
+        @guitar_notes = guitar_notes
+        @free_fingers = free_fingers
+        @barre = barre
+      end
+
+      def barre?
+        !@barre.nil?
+      end
+
+      def fetch_descendant_chords
+        return self if guitar_notes.size < guitar.strings
+        possible_new_notes.reduce([]) do |memo, n|
+          fingers_change = n.fret == @barre ? 0 : 1
+          return self unless (@free_fingers - fingers_change).negative?
+          guitar.create_chord target_chord,
+                              guitar_notes: @guitar_notes + n,
+                              free_fingers: @free_fingers - fingers_change,
+                              barre: @barre
+                                .fetch_descendant_chords + memo
+        end
+      end
+
+      def possible_new_notes; end
+
+      private
+
+      attr_writer :barre
+    end
+  end
+end

data/lib/coltrane_instruments/guitar/note.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ColtraneInstruments
+  module Guitar
+    class Note
+    end
+  end
+end

data/lib/coltrane_instruments/guitar/string.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ColtraneInstruments
+  module Guitar
+    class String
+    end
+  end
+end

data/lib/core_ext.rb

@@ -24,6 +24,7 @@ class String
   end
 end
 
+# Here we add some syntax sugar to make the code more understandable later
 class Integer
   def interval_name
     {
@@ -46,12 +47,17 @@ class Integer
   end
 end
 
+# Here we add some methods better work with Tries
 class Hash
-  def clone_values(from_keys: nil, to_keys: nil, suffix: nil, branch_a: nil, branch_b: nil)
-    branch_a ||= self.dig(*from_keys)
+  def clone_values(from_keys: nil,
+                   to_keys: nil,
+                   suffix: nil,
+                   branch_a: nil,
+                   branch_b: nil)
+    branch_a ||= dig(*from_keys)
     if branch_b.nil?
-      self.create_branch!(*to_keys)
-      branch_b = self.dig(*to_keys)
+      create_branch!(*to_keys)
+      branch_b = dig(*to_keys)
     end
 
     branch_a.each do |key, val|
@@ -73,30 +79,13 @@ class Hash
 
   def deep_dup
     dup_hash = {}
-    self.each do |k,v|
-      if v.is_a?(Hash)
-        dup_hash[k] = v.deep_dup
-      else
-        dup_hash[k] = v.dup
-      end
+    each do |k, v|
+      dup_hash[k] = if v.is_a?(Hash)
+                      v.deep_dup
+                    else
+                      v.dup
+                    end
     end
     dup_hash
   end
 end
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-