coltrane 2.2.1 → 3.0.0.pre

data/lib/coltrane/unordered_interval_class.rb

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

data/lib/coltrane/voicing.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Coltrane
-  # This class describes an actual implementation of a Chord, being aware
-  # of exact octaves of each pitch and even repeating pitches across octaves.
-  class Voicing
-    attr_reader :pitches
-
-    def initialize(*pitch_strings, pitches: nil)
-      @pitches = if pitch_strings.any?
-                   pitch_strings.map { |s| Pitch[s] }
-                 elsif pitches
-                   pitches
-                 else
-                   raise WrongArgumentsError
-                 end
-    end
-
-    def self.[](*args)
-      new(*args)
-    end
-
-    def pitch_classes
-      NoteSet[*pitches.map(&:pitch_class).uniq]
-    end
-
-    alias notes pitch_classes
-
-    def chord
-      @chord ||= Chord.new(notes: notes)
-    rescue ChordNotFoundError
-      return false
-    end
-
-    def frequencies
-      pitches.map(&:frequency)
-    end
-  end
-end

data/lib/coltrane_game/question.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module ColtraneGame
-  class Question
-    def generate; end
-  end
-end

data/lib/coltrane_instruments.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'coltrane'
-
-module ColtraneInstruments
-  autoload :Guitar, 'coltrane_instruments/guitar'
-end

data/lib/coltrane_instruments/guitar.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module ColtraneInstruments
-  module Guitar
-    autoload :Base,   'coltrane_instruments/guitar/base'
-    autoload :Chord,  'coltrane_instruments/guitar/chord'
-    autoload :Note,   'coltrane_instruments/guitar/note'
-    autoload :String, 'coltrane_instruments/guitar/string'
-  end
-end

data/lib/coltrane_instruments/guitar/base.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module ColtraneInstruments
-  module Guitar
-    DEFAULT_TUNING = %w[E2 A2 D3 G3 B3 E4].freeze
-    DEFAULT_FRETS = 23
-    # A base class for operations involving Guitars
-    class Base
-      attr_reader :strings, :frets
-
-      def self.find_chords(target_chord)
-        unless target_chord.is_a?(Coltrane::Chord)
-          target_chord = Coltrane::Chord.new(name: target_chord)
-        end
-
-        ColtraneInstruments::Guitar::Chord.new(target_chord, guitar: new)
-                                          .fetch_descendant_chords
-      end
-
-      def initialize(tuning = DEFAULT_TUNING, frets = DEFAULT_FRETS)
-        @strings = tuning.map do |p|
-          String.new(Coltrane::Pitch[p], guitar: self)
-        end
-
-        @frets = frets
-      end
-    end
-  end
-end

data/lib/coltrane_instruments/guitar/chord.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-module ColtraneInstruments
-  module Guitar
-    # This class represents a group of guitar notes, strummed at the same time
-    class Chord
-      include Comparable
-      attr_reader :guitar_notes, :guitar, :free_fingers, :target_chord, :barre
-
-      MAX_FRET_SPAN = 3
-
-      def self.find(chord)
-        new(chord).fetch_descendant_chords
-      end
-
-      def initialize(target_chord,
-                     guitar_notes: [],
-                     free_fingers: 4,
-                     barre: nil,
-                     guitar:)
-
-        @target_chord = target_chord
-        @guitar_notes = guitar_notes
-        @free_fingers = free_fingers
-        @guitar       = guitar
-        @barre        = barre
-      end
-
-      def <=>(other)
-        rank <=> other.rank
-      end
-
-      def rank
-        +completeness * 10_000 +
-          +fullness * 1000 +
-          -spreadness * 100 +
-          +easyness * 1
-      end
-
-      def analysis
-        {
-          completeness: completeness,
-          fullness: fullness,
-          easyness: easyness,
-          spreadness: spreadness
-        }
-      end
-
-      def spreadness
-        fret_range.size.to_f / MAX_FRET_SPAN
-      end
-
-      def completeness
-        (target_chord.notes.size.to_f - notes_left.size) / target_chord.notes.size
-      end
-
-      def easyness
-        frets.count(0).to_f / guitar_notes.size
-      end
-
-      def fullness
-        (guitar.strings.size.to_f - frets.count(nil)) / guitar.strings.size
-      end
-
-      def barre?
-        !@barre.nil?
-      end
-
-      def fetch_descendant_chords
-        return [self] if guitar_notes.size >= guitar.strings.size
-        possible_new_notes(notes_available.positive?).reduce([]) do |memo, n|
-          barre = n.fret if guitar_notes.last == n.fret
-          fingers_change = n.fret == barre || n.fret.zero? ? 0 : 1
-          next memo if (free_fingers - fingers_change).negative?
-          Chord.new(target_chord, guitar_notes: guitar_notes + [n],
-                                  free_fingers: free_fingers - fingers_change,
-                                  guitar: guitar,
-                                  barre: barre)
-               .fetch_descendant_chords + memo
-        end
-      end
-
-      def notes_available
-        strings_available - notes_left.size
-      end
-
-      def strings_available
-        guitar.strings.size - guitar_notes.size
-      end
-
-      def notes_left
-        @notes_left ||= begin
-                          target_chord.notes - Coltrane::NoteSet[
-                          *guitar_notes.map do |n|
-                            next if n.pitch.nil?
-                            n.pitch.pitch_class
-                          end
-                        ]
-                        end
-      end
-
-      def target_notes
-        notes_left.any? ? notes_left : target_chord.notes
-      end
-
-      def notes
-        guitar_notes.map(&:pitch)
-      end
-
-      def frets
-        @frets ||= guitar_notes.map(&:fret)
-      end
-
-      def non_zero_frets
-        frets.reject { |f| f.nil? || f.zero? }
-      end
-
-      def lowest_fret
-        non_zero_frets.any? ? non_zero_frets.min : 0
-      end
-
-      def highest_fret
-        non_zero_frets.max || 0
-      end
-
-      def fret_range
-        (lowest_fret..highest_fret)
-      end
-
-      def lowest_possible_fret
-        lowest_fret.zero? ? 0 : [(lowest_fret - possible_span), 0].max
-      end
-
-      def highest_possible_fret
-        [(possible_span + (highest_fret == 0 ? guitar.frets : highest_fret)), guitar.frets].min
-      end
-
-      def possible_span
-        MAX_FRET_SPAN - fret_range.size
-      end
-
-      def fret_expansion_range
-        (lowest_possible_fret..highest_possible_fret).to_a +
-          [(0 unless barre?)].compact
-      end
-
-      def to_s
-        guitar_notes.map { |n| n.fret.nil? ? 'x' : n.fret }.join('-')
-      end
-
-      def voicing
-        Coltrane::Voicing.new(pitches: guitar_notes.map(&:pitch).compact)
-      end
-
-      private
-
-      attr_writer :barre
-
-      def next_string
-        guitar.strings[guitar_notes.size]
-      end
-
-      def possible_new_notes(include_mute_note = false)
-        target_notes.notes.map do |note|
-          next_string.find(note, possible_frets: fret_expansion_range)
-        end.flatten + [(Guitar::Note.new(next_string, nil) if include_mute_note)].compact
-      end
-    end
-  end
-end

data/lib/coltrane_instruments/guitar/note.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module ColtraneInstruments
-  module Guitar
-    class Note
-      attr_reader :string, :fret
-
-      def initialize(string, fret = nil)
-        @string = string
-        @fret   = fret
-      end
-
-      def pitch
-        string + fret unless fret.nil?
-      end
-
-      def pitch_class
-        pitch.pitch_class unless fret.nil?
-      end
-
-      alias note pitch_class
-    end
-  end
-end

data/lib/coltrane_instruments/guitar/string.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module ColtraneInstruments
-  module Guitar
-    class String
-      attr_reader :pitch, :guitar
-
-      def initialize(pitch, guitar:)
-        @guitar = guitar
-        @pitch = pitch
-      end
-
-      def find(pitch_class, possible_frets: (0..guitar.frets).to_a)
-        output = []
-        n = 0
-        loop do
-          f = (pitch_class.integer - pitch.integer) % 12 + 12 * n
-          possible_frets.include?(f) ? output << Note.new(self, f) : break
-          n += 1
-        end
-        output
-      end
-
-      def +(fret)
-        pitch + fret
-      end
-    end
-  end
-end

data/lib/os.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module OS
-  class << self
-    def windows?
-      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
-    end
-
-    def mac?
-      (/darwin/ =~ RUBY_PLATFORM) != nil
-    end
-
-    def unix?
-      !windows?
-    end
-
-    def OS.linux?
-      unix? && !mac?
-    end
-  end
-end