coltrane 1.0.1 → 1.0.2

data/lib/cli/scale.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Coltrane
   module Cli
+    # Interfaces commands with the scales functionality
     class Scale
       def self.parse(str)
         *scale_name, tone = str.split('-')
@@ -12,8 +15,10 @@ module Coltrane
           notes = NoteSet[*notes]
         elsif chords.any?
           puts "\nSearching for scales containing #{chords.join(', ')}:\n\n"
-          notes = chords.reduce(NoteSet[]) {|memo, c| memo + Coltrane::Chord.new(name: c).notes }
-        else raise BadFindScales.new
+          notes = chords.reduce(NoteSet[]) do |memo, c|
+            memo + Coltrane::Chord.new(name: c).notes
+          end
+        else raise BadFindScales
         end
         render_search(notes)
         puts "\nUnderlined means the scale has all notes"
@@ -24,25 +29,24 @@ module Coltrane
         output = []
         scale_width = search.results.keys.map(&:size).max
         search.results.each do |name, scales_by_tone|
-          output << name.ljust(scale_width+1, ' ')
+          output << name.ljust(scale_width + 1, ' ')
           scales_by_tone.each do |tone_number, notes|
-            p = notes.size.to_f / searched_notes.size
-            l = p == 1 ? p : (p + 0.2) * 0.4
-            hue, val, sat = 30, val = (l * 100).round, sat = p
-            und = p == 1 ? :underline : nil
-            color = "hsv(#{hue},#{sat},#{val})".paint.to_hex
+            p     = (notes.size.to_f / searched_notes.size) * 100
+            l     = p == 100 ? p : (p + 20) * 0.4
+            und   = p == 100 ? :underline : nil
+            color = Color::HSL.new(30, p, l / 2).html
             output << Paint["#{Note[tone_number].name}(#{notes.size})", color, und]
-            output << " "
+            output << ' '
           end
           output << "\n"
         end
         puts output.join
       end
 
-      def initialize(scale, on: :text, flavor: 'degrees', notes: [], chords: [])
+      def initialize(scale, on: :text, flavor: 'degrees')
         desc = "This is the #{scale.tone.name} #{scale.name} scale:"
         Coltrane::Cli::Notes.new(scale.notes, on: on, desc: desc, flavor: flavor)
       end
     end
   end
-end
+end

data/lib/cli/text.rb

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

data/lib/cli/ukulele.rb

@@ -1,11 +1,14 @@
+# 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]
+      SPECIAL_FRETS = [5, 7, 9, 12].freeze
 
       def initialize(notes, flavor, tuning: %w[G C E A], frets: 12)
         super
       end
     end
   end
-end
+end

data/lib/coltrane.rb

@@ -1,9 +1,9 @@
-require 'bundler'
-Bundler.require
+# frozen_string_literal: true
 
+require 'forwardable'
 require 'facets/multiton'
+require 'core_ext'
 require 'ostruct'
-require 'paint'
 
 require 'coltrane/version'
 require 'coltrane/errors'
@@ -23,11 +23,8 @@ require 'coltrane/roman_chord'
 require 'coltrane/classic_scales'
 require 'coltrane/classic_progressions'
 
-require 'coltrane/piano_representation'
-
 require 'coltrane/note'
-
 require 'coltrane/pitch'
 require 'coltrane/progression'
 require 'coltrane/scale'
-require 'coltrane/mode'
+require 'coltrane/mode'

data/lib/coltrane/cache.rb

@@ -1,34 +1,35 @@
+# 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 (cached = fetch(key))
-          return cached
-        else
+        unless (cached = fetch(key))
           cached = yield block
           record(key, cached)
-          cached
         end
+        cached
       end
 
       private
 
       def dir
-        dir = File.expand_path('../../../', __FILE__) + "/cache/"
+        dir = File.expand_path('../../../', __FILE__) + '/cache/'
         Dir.mkdir(dir) unless Dir.exist?(dir)
         dir
       end
 
       def fetch(key)
-        return unless File.file?(dir+key)
-        Marshal.load File.read(dir+key)
+        Marshal.load File.read(dir + key) if File.file?(dir + key)
       end
 
       def record(key, contents)
-        File.open(dir+key, "w") do |f|
+        File.open(dir + key, 'w') do |f|
           f.write Marshal.dump(contents)
         end
       end
     end
   end
-end
+end

data/lib/coltrane/cadence.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module Coltrane
   class Cadence
   end
-end
+end

data/lib/coltrane/chord.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Coltrane
   # It describe a chord
   class Chord < NoteSet
@@ -16,19 +18,25 @@ module Coltrane
       elsif !name.nil?
         @root_note, @quality, @notes = parse_from_name(name)
       else
-        raise WrongKeywords.new('[notes:] || [root_note:, quality:] || [name:]')
+        raise WrongKeywordsError,
+              '[notes:] || [root_note:, quality:] || [name:]'
       end
     end
 
     def name
-      return @notes.names.join('/') if !named?
+      return @notes.names.join('/') unless named?
       "#{root_note.name}#{quality.name}"
     end
 
+    def pretty_name
+      return @notes.names.join('/') unless named?
+      "#{root_note.pretty_name}#{quality.name}"
+    end
+
     def named?
       notes.size >= 3 &&
-      !root_note.nil? &&
-      !quality&.name.nil?
+        !root_note.nil? &&
+        !quality&.name.nil?
     end
 
     def intervals
@@ -40,14 +48,14 @@ module Coltrane
     end
 
     def scales
-      Scale.having_chord(self.name)
+      Scale.having_chord(name)
     end
 
     def next_inversion
       Chord.new(notes.rotate(1))
     end
 
-    def invert(n=1)
+    def invert(n = 1)
       Chord.new(notes.rotate(n))
     end
 
@@ -58,11 +66,11 @@ module Coltrane
     protected
 
     def parse_from_name(name)
-      _, name, quality_name = name.match(/([A-Z]#?)(.*)/).to_a
+      _, name, quality_name = name.match(/([A-Z](?:#|b)?)(.*)/).to_a
       root    = Note[name]
       quality = ChordQuality.new(name: quality_name)
       notes   = quality.notes_for(root)
       [root, quality, notes]
     end
   end
-end
+end

data/lib/coltrane/chord_quality.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Coltrane
   # It describe the quality of a chord, like maj7 or dim.
   class ChordQuality < IntervalSequence
@@ -6,18 +8,15 @@ module Coltrane
 
     def initialize(name: nil, notes: nil)
       if !name.nil?
-        if(intervals = CHORD_QUALITIES[name])
-          @name = name
-          super(intervals: intervals)
-        else
-          raise ChordNotFoundError.new
-        end
+        raise ChordNotFoundError unless (intervals = CHORD_QUALITIES[name])
+        @name = name
+        super(intervals: intervals)
       elsif !notes.nil?
         super(notes: notes)
         @name = CHORD_QUALITIES.key(intervals_semitones)
       else
-        raise WrongKeywords.new('[name:] || [notes:]')
+        raise WrongKeywordsError, '[name:] || [notes:]'
       end
     end
   end
-end
+end

data/lib/coltrane/classic_progressions.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 module Coltrane
+  # It's totally a wip yet.
   module ClassicProgressions
     PROGRESSIONS = {
-      pop:        [:major, [1,5,6,4]],
-      fifties:    [:major, [1,6,4,5]],
-      blues:      [:major, [1,4,1,5,4,1]],
-      jazz:       [:major, [2,5,1]],
-      jazz_minor: [:minor, [2,5,1]],
-      andalusian: [:minor, [1,7,6,5]]
-    }
+      pop:        [:major, [1, 5, 6, 4]],
+      fifties:    [:major, [1, 6, 4, 5]],
+      blues:      [:major, [1, 4, 1, 5, 4, 1]],
+      jazz:       [:major, [2, 5, 1]],
+      jazz_minor: [:minor, [2, 5, 1]],
+      andalusian: [:minor, [1, 7, 6, 5]]
+    }.freeze
 
     def pop(tone)
       scale, degrees = PROGRESSIONS[:pop]

data/lib/coltrane/classic_scales.rb

@@ -1,36 +1,28 @@
+# frozen_string_literal: true
+
 module Coltrane
+  # This module deals with well known scales on music
   module ClassicScales
-
     SCALES = {
-      'Major'            => [2,2,1,2,2,2,1],
-      'Pentatonic Major' => [2,2,3,2,3],
-      'Blues Major'      => [2,1,1,3,2,3],
-      'Natural Minor'    => [2,1,2,2,1,2,2],
-      '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]
-    }
+      'Major'            => [2, 2, 1, 2, 2, 2, 1],
+      'Pentatonic Major' => [2, 2, 3, 2, 3],
+      'Blues Major'      => [2, 1, 1, 3, 2, 3],
+      'Natural Minor'    => [2, 1, 2, 2, 1, 2, 2],
+      '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]
+    }.freeze
 
     MODES = {
       'Major' => %w[Ionian Dorian Phrygian Lydian Mixolydian Aeolian Locrian]
-    }
-
-    private
-
-    # A little helper to build method names
-    # just make the code more clear
-    def self.methodize(string)
-      string.downcase.gsub(' ', '_')
-    end
-
-    public
+    }.freeze
 
     # Creates factories for scales
     SCALES.each do |name, distances|
-      define_method methodize(name) do |tone='C', mode=1|
+      define_method name.underscore do |tone = 'C', mode = 1|
         new(*distances, tone: tone, mode: mode, name: name)
       end
     end
@@ -38,34 +30,33 @@ module Coltrane
     # Creates factories for Greek Modes and possibly others
     MODES.each do |scale, modes|
       modes.each_with_index do |mode, index|
-        scale_method = methodize(scale)
         mode_name = mode
         mode_n = index + 1
-        define_method methodize(mode) do |tone='C'|
+        define_method mode.underscore do |tone = 'C'|
           new(*SCALES[scale], tone: tone, mode: mode_n, name: mode_name)
         end
       end
     end
 
-    alias_method :minor,      :natural_minor
-    alias_method :pentatonic, :pentatonic_major
-    alias_method :blues,      :blues_major
+    alias minor natural_minor
+    alias pentatonic pentatonic_major
+    alias blues blues_major
 
     def known_scales
       SCALES.keys
     end
 
-    def fetch(name, tone=nil)
+    def fetch(name, tone = nil)
       Coltrane::Scale.public_send(name, tone)
     end
 
     def from_key(key)
-      scale = key.delete!('m') ? :minor : :major
-      note  = key
-      Scale.public_send(scale.nil? || scale == 'M' ? :major : :minor, note)
+      key_regex = /([A-G][#b]?)([mM]?)/
+      _, note, s = *key.match(key_regex)
+      scale = s == 'm' ? :minor : :major
+      Scale.public_send(scale, note)
     end
 
-
     # Will output a OpenStruct like the following:
     # {
     #   scales: [array of scales]
@@ -77,19 +68,15 @@ module Coltrane
     # }
 
     def having_notes(notes)
-
       format = { scales: [], results: {} }
       OpenStruct.new(
         SCALES.each_with_object(format) do |(name, intervals), output|
           Note.all.each.map do |tone|
             scale = new(*intervals, tone: tone, name: scale)
             output[:results][name] ||= {}
-            if output[:results][name].has_key?(tone.number)
-              next
-            else
-              output[:scales] << scale if scale.include?(notes)
-              output[:results][name][tone.number] = scale.notes & notes
-            end
+            next if output[:results][name].key?(tone.number)
+            output[:scales] << scale if scale.include?(notes)
+            output[:results][name][tone.number] = scale.notes & notes
           end
         end
       )
@@ -103,6 +90,6 @@ module Coltrane
       having_notes(notes)
     end
 
-    alias_method :having_chord, :having_chords
+    alias having_chord having_chords
   end
-end
+end

data/lib/coltrane/errors.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/Documentation
+
 module Coltrane
   class ColtraneError < StandardError
     def initialize(msg)
@@ -5,40 +9,41 @@ module Coltrane
     end
   end
 
-  class BadConstructor < ColtraneError
-    def initialize(msg=nil)
+  class BadConstructorError < ColtraneError
+    def initialize(msg = nil)
       super "Bad constructor. #{msg}"
     end
   end
 
-  class WrongKeywords < BadConstructor
+  class WrongKeywordsError < BadConstructorError
     def initialize(msg)
       super "Use one of the following set of keywords: #{msg}"
     end
   end
 
-  class InvalidNote < BadConstructor
+  class InvalidNoteError < BadConstructorError
     def initialize(note)
       super "#{note} is not a valid note"
     end
   end
 
-  class InvalidNotes < BadConstructor
+  class InvalidNotesError < BadConstructorError
     def initialize(notes)
       super "#{notes} are not a valid set of notes"
     end
   end
 
-  class HasNoNotes < BadConstructor
+  class HasNoNotesError < BadConstructorError
     def initialize(obj)
       super "The given object (#{obj.inspect} does not respond to :notes, "\
             "thereby it can't be used for this operation)"
     end
   end
 
-  class WrongDegree
+  class WrongDegreeError
     def initialize(degree)
-      super "#{degree} is not a valid degree. Degrees for this scale must be between 1 and #{degrees}"
+      super "#{degree} is not a valid degree. Degrees for this scale must be"\
+            "between 1 and #{degrees}"
     end
   end
 
@@ -47,8 +52,10 @@ module Coltrane
       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 "\
+            'https://github.com/pedrozath/coltrane/issues '\
             "\n\nA tip tho: always include the letter M for major"
     end
   end
-end
+end
+
+# rubocop:enable Style/Documentation