head_music 0.6.4 → 0.7.0

data/Gemfile

@@ -2,3 +2,8 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in head_music.gemspec
 gemspec
+
+group :test do
+  gem "simplecov"
+  gem "codeclimate-test-reporter", "~> 1.0.0"
+end

data/README.md

@@ -1,5 +1,9 @@
 # HeadMusic
 
+![Build status](https://circleci.com/gh/roberthead/head_music.svg?style=shield&circle-token=8b39a6f5e809e9baa321e0f13aa06c70c6511794)
+[![Code Climate](https://codeclimate.com/github/roberthead/head_music/badges/gpa.svg)](https://codeclimate.com/github/roberthead/head_music)
+[![Test Coverage](https://codeclimate.com/github/roberthead/head_music/badges/coverage.svg)](https://codeclimate.com/github/roberthead/head_music/coverage)
+
 The *head_music* ruby gem models the elements of western music theory, such as note names, scales, key signatures, intervals, and chords.
 
 ## Installation

data/circle.yml

@@ -6,4 +6,4 @@ machine:
   # Version of ruby to use
   ruby:
     version:
-      2.3.0
+      2.3.1

data/head_music.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '~> 2.3'
+  spec.required_ruby_version = '~> 2.3.1'
 
   spec.add_runtime_dependency "activesupport", "~> 5.0"
   spec.add_runtime_dependency "humanize", "~> 1.3"

data/lib/head_music/composition.rb

@@ -0,0 +1,29 @@
+class HeadMusic::Composition
+  attr_reader :name, :key_signature, :meter, :measures
+
+  def initialize(name:, key_signature: nil, meter: nil)
+    ensure_attributes(name, key_signature, meter)
+    add_measure
+  end
+
+  def add_measure
+    add_measures(1)
+  end
+
+  def add_measures(number)
+    @measures ||= []
+    number.times do
+      @measures << HeadMusic::Measure.new(self)
+    end
+  end
+
+  private
+
+  def ensure_attributes(name, key_signature, meter)
+    @name = name
+    @key_signature = HeadMusic::KeySignature.get(key_signature) if key_signature
+    @key_signature ||= HeadMusic::KeySignature.default
+    @meter = HeadMusic::Meter.get(meter) if meter
+    @meter ||= HeadMusic::Meter.default
+  end
+end

data/lib/head_music/key_signature.rb

@@ -1,15 +1,28 @@
 class HeadMusic::KeySignature
   attr_reader :tonic_spelling
-  attr_reader :scale_type
+  attr_reader :quality_name
 
   SHARPS = %w{F# C# G# D# A# E# B#}
   FLATS = %w{Bb Eb Ab Db Gb Cb Fb}
 
+  def self.default
+    @default ||= new('C', :major)
+  end
+
+  def self.get(identifier)
+    return identifier if identifier.is_a?(HeadMusic::KeySignature)
+    @key_signatures ||= {}
+    tonic_spelling, quality_name = identifier.split(/\s/)
+    hash_key = HeadMusic::Utilities::HashKey.for(identifier)
+    @key_signatures[hash_key] ||= new(tonic_spelling, quality_name)
+  end
+
   delegate :pitch_class, to: :tonic_spelling, prefix: :tonic
+  delegate :to_s, to: :name
 
-  def initialize(tonic_spelling, scale_type = nil)
+  def initialize(tonic_spelling, quality_name = nil)
     @tonic_spelling = tonic_spelling
-    @scale_type = scale_type || :major
+    @quality_name = quality_name || :major
   end
 
   def sharps
@@ -21,11 +34,11 @@ class HeadMusic::KeySignature
   end
 
   def num_sharps
-    (HeadMusic::Circle.of_fifths.index(tonic_pitch_class) - scale_type_adjustment) % 12
+    (HeadMusic::Circle.of_fifths.index(tonic_pitch_class) - quality_name_adjustment) % 12
   end
 
   def num_flats
-    (HeadMusic::Circle.of_fourths.index(tonic_pitch_class) + scale_type_adjustment) % 12
+    (HeadMusic::Circle.of_fourths.index(tonic_pitch_class) + quality_name_adjustment) % 12
   end
 
   def sharps_or_flats
@@ -34,18 +47,26 @@ class HeadMusic::KeySignature
     num_sharps <= num_flats ? sharps : flats
   end
 
+  def name
+    [tonic_spelling.to_s, quality_name.to_s].join(' ')
+  end
+
+  def ==(other)
+    self.to_s == other.to_s
+  end
+
   private
 
-  def scale_type_adjustment
-    scale_type == :minor ? 3 : 0
+  def quality_name_adjustment
+    quality_name == :minor ? 3 : 0
   end
 
   def major?
-    @scale_type.to_sym == :major
+    @quality_name.to_sym == :major
   end
 
   def minor?
-    @scale_type.to_sym == :minor
+    @quality_name.to_sym == :minor
   end
 
   def relative_major_pitch_class

data/lib/head_music/measure.rb

@@ -0,0 +1,14 @@
+class HeadMusic::Measure
+  attr_reader :composition
+
+  delegate :key_signature, :meter, to: :composition
+
+  def initialize(composition)
+    @composition = composition
+  end
+
+  # TODO: encapsulate key changes and meter changes
+  # Assume the key and meter of the previous measure
+  # all the way back to the first measure,
+  # which defaults to the key and meter of the composition
+end

data/lib/head_music/meter.rb

@@ -8,8 +8,22 @@ class HeadMusic::Meter
 
   def self.get(identifier)
     identifer = identifer.to_s
-    identifier = NAMED[identifier.to_sym] || identifier
-    new(*identifier.split('/').map(&:to_i))
+    hash_key = HeadMusic::Utilities::HashKey.for(identifier)
+    time_signature_string = NAMED[hash_key] || identifier
+    @meters ||= {}
+    @meters[hash_key] ||= new(*time_signature_string.split('/').map(&:to_i))
+  end
+
+  def self.default
+    get('4/4')
+  end
+
+  def self.common_time
+    get(:common_time)
+  end
+
+  def self.cut_time
+    get(:cut_time)
   end
 
   def initialize(top_number, bottom_number)
@@ -40,6 +54,43 @@ class HeadMusic::Meter
     compound? ? top_number / 3 : top_number
   end
 
+  def counts_per_measure
+    top_number
+  end
+
+  def beat_strength(count, tick: 0)
+    return 100 if count == 1 && tick == 0
+    return 80 if strong_counts.include?(count) && tick == 0
+    return 60 if tick == 0
+    return 40 if strong_ticks.include?(tick)
+    20
+  end
+
+  def ticks_per_count
+    @ticks_per_count ||= count_unit.ticks
+  end
+
+  def strong_ticks
+    @strong_ticks ||=
+      [2,3,4].map do |sixths|
+        ticks_per_count * (sixths / 6.0)
+      end
+  end
+
+  def count_unit
+    HeadMusic::RhythmicUnit.for_denominator_value(bottom_number)
+  end
+
+  def beat_unit
+    @beat_unit ||=
+      if compound?
+        unit = HeadMusic::RhythmicUnit.for_denominator_value(bottom_number / 2)
+        HeadMusic::RhythmicValue.new(unit, dots: 1)
+      else
+        HeadMusic::RhythmicValue.new(count_unit)
+      end
+  end
+
   def to_s
     [top_number, bottom_number].join('/')
   end
@@ -47,4 +98,18 @@ class HeadMusic::Meter
   def ==(other)
     to_s == other.to_s
   end
+
+  def strong_counts
+    @strong_counts ||= begin
+      (1..counts_per_measure).select do |count|
+        count == 1 ||
+        count == counts_per_measure / 2.0 + 1 ||
+        (
+          counts_per_measure % 3 == 0 &&
+          counts_per_measure > 6 &&
+          count % 3 == 1
+        )
+      end
+    end
+  end
 end

data/lib/head_music/position.rb

@@ -0,0 +1,61 @@
+class HeadMusic::Position
+  attr_reader :composition, :measure_number, :count, :tick
+  delegate :to_s, to: :code
+  delegate :meter, to: :composition
+
+  def initialize(composition, code_or_measure, count = nil, tick = nil)
+    if code_or_measure.is_a?(String) && code_or_measure =~ /\D/
+      ensure_state(composition, *code_or_measure.split(/\D+/))
+    else
+      ensure_state(composition, code_or_measure, count, tick)
+    end
+  end
+
+  def code
+    [measure_number, count, tick].join(':')
+  end
+
+  def state
+    [composition.name, code].join(' ')
+  end
+
+  def ==(other)
+    self.state == other.state
+  end
+
+  private
+
+  def ensure_state(composition, measure_number, count, tick)
+    @composition = composition
+    @measure_number = measure_number.to_i
+    @count = (count || 1).to_i
+    @tick = (tick || 0).to_i
+    roll_over_units
+  end
+
+  def roll_over_units
+    roll_over_ticks
+    roll_over_counts
+  end
+
+  def roll_over_ticks
+    while @tick > meter.ticks_per_count
+      @tick -= meter.ticks_per_count.to_i
+      @count += 1
+    end
+  end
+
+  def roll_over_counts
+    while @count > meter.counts_per_measure
+      @count -= meter.counts_per_measure
+      @measure_number += 1
+    end
+  end
+end
+
+# In Logic Pro X, the 'beat' is determined by the denominator, even if compound.
+# Logic then divides the beat into 'divisions' that are a sixteenth in length.
+# Each division is then divided into 240 ticks (960 PPQN / 4 sixteenths-per-quarter)
+
+# Tempo specifies the beat unit, usually the traditional beat unit in the case of compound meters,
+# so 6/8 would specify [dotted-quarter] = 132 (or whatever).

data/lib/head_music/rhythmic_unit.rb

@@ -1,29 +1,40 @@
 class HeadMusic::RhythmicUnit
   MULTIPLES = ['whole', 'double whole', 'longa', 'maxima']
-  DIVISIONS = ['whole', 'half', 'quarter', 'eighth', 'sixteenth', 'thirty-second', 'sixty-fourth', 'hundred twenty-eighth', 'two hundred fifty-sixth']
+  FRACTIONS = ['whole', 'half', 'quarter', 'eighth', 'sixteenth', 'thirty-second', 'sixty-fourth', 'hundred twenty-eighth', 'two hundred fifty-sixth']
 
   BRITISH_MULTIPLE_NAMES = %w[semibreve breve longa maxima]
   BRITISH_DIVISION_NAMES = %w[semibreve minim crotchet quaver semiquaver demisemiquaver hemidemisemiquaver semihemidemisemiquaver demisemihemidemisemiquaver]
 
+  PPQN = PULSES_PER_QUARTER_NOTE = 960
+
   def self.get(name)
     @rhythmic_units ||= {}
-    @rhythmic_units[name.to_s] ||= new(name.to_s)
+    hash_key = HeadMusic::Utilities::HashKey.for(name)
+    @rhythmic_units[hash_key] ||= new(name.to_s)
   end
   singleton_class.send(:alias_method, :[], :get)
 
+  def self.for_denominator_value(denominator)
+    get(FRACTIONS[Math.log2(denominator).to_i])
+  end
+
   attr_reader :name, :numerator, :denominator
   delegate :to_s, to: :name
 
   def initialize(canonical_name)
     @name ||= canonical_name
     @numerator ||= MULTIPLES.include?(name) ? 2**MULTIPLES.index(name) : 1
-    @denominator ||= DIVISIONS.include?(name) ? 2**DIVISIONS.index(name) : 1
+    @denominator ||= FRACTIONS.include?(name) ? 2**FRACTIONS.index(name) : 1
   end
 
   def relative_value
     @numerator.to_f / @denominator
   end
 
+  def ticks
+    PPQN * 4 * relative_value
+  end
+
   def notehead
     case relative_value
     when 8
@@ -40,7 +51,7 @@ class HeadMusic::RhythmicUnit
   end
 
   def flags
-    DIVISIONS.include?(name) ? [DIVISIONS.index(name) - 2, 0].max : 0
+    FRACTIONS.include?(name) ? [FRACTIONS.index(name) - 2, 0].max : 0
   end
 
   def has_stem?
@@ -50,8 +61,8 @@ class HeadMusic::RhythmicUnit
   def british_name
     if MULTIPLES.include?(name)
       BRITISH_MULTIPLE_NAMES[MULTIPLES.index(name)]
-    elsif DIVISIONS.include?(name)
-      BRITISH_DIVISION_NAMES[DIVISIONS.index(name)]
+    elsif FRACTIONS.include?(name)
+      BRITISH_DIVISION_NAMES[FRACTIONS.index(name)]
     end
   end
 

data/lib/head_music/rhythmic_value.rb

@@ -1,9 +1,8 @@
 class HeadMusic::RhythmicValue
-  PPQN = PULSES_PER_QUARTER_NOTE = 960
-
   attr_reader :unit, :dots, :tied_value
 
   delegate :name, to: :unit, prefix: true
+  delegate :to_s, to: :name
 
   def initialize(unit, dots: nil, tied_value: nil)
     @unit = HeadMusic::RhythmicUnit.get(unit)
@@ -28,7 +27,7 @@ class HeadMusic::RhythmicValue
   end
 
   def ticks
-    PPQN * 4 * total_value
+    HeadMusic::RhythmicUnit::PPQN * 4 * total_value
   end
 
   def per_whole
@@ -57,4 +56,8 @@ class HeadMusic::RhythmicValue
       single_value_name
     end
   end
+
+  def ==(other)
+    to_s == other.to_s
+  end
 end

data/lib/head_music/scale.rb

@@ -1,8 +1,7 @@
 class HeadMusic::Scale
   def self.get(root_pitch, scale_type_name = nil)
     root_pitch = HeadMusic::Pitch.get(root_pitch)
-    scale_type_name ||= :major
-    scale_type ||= HeadMusic::ScaleType.get(scale_type_name)
+    scale_type ||= HeadMusic::ScaleType.get(scale_type_name || :major)
     @scales ||= {}
     @scales[root_pitch.to_s] ||= {}
     @scales[root_pitch.to_s][scale_type.name] ||= new(root_pitch, scale_type)
@@ -18,23 +17,19 @@ class HeadMusic::Scale
   def pitches(direction: :ascending, octaves: 1)
     @pitches ||= {}
     @pitches[direction] ||= {}
-    @pitches[direction][octaves] ||= begin
-      letter_name_cycle = root_pitch.letter_name_cycle
-      semitones_from_root = 0
-      [root_pitch].tap do |pitches|
-        if [:ascending, :both].include?(direction)
-          (1..octaves).each do |i|
-            scale_type.ascending_intervals.each_with_index do |semitones, i|
-              semitones_from_root += semitones
-              pitches << pitch_for_step(i+1, semitones_from_root, :ascending)
-            end
-          end
-        end
-        if [:descending, :both].include?(direction)
+    @pitches[direction][octaves] ||= determine_scale_pitches(direction, octaves)
+  end
+
+  def determine_scale_pitches(direction, octaves)
+    letter_name_cycle = root_pitch.letter_name_cycle
+    semitones_from_root = 0
+    [root_pitch].tap do |pitches|
+      [:ascending, :descending].each do |single_direction|
+        if [single_direction, :both].include?(direction)
           (1..octaves).each do |i|
-            scale_type.descending_intervals.each_with_index do |semitones, i|
-              semitones_from_root -= semitones
-              pitches << pitch_for_step(i+1, semitones_from_root, :descending)
+            direction_intervals(single_direction).each_with_index do |semitones, i|
+              semitones_from_root += semitones * direction_sign(single_direction)
+              pitches << pitch_for_step(i+1, semitones_from_root, single_direction)
             end
           end
         end
@@ -42,6 +37,14 @@ class HeadMusic::Scale
     end
   end
 
+  def direction_sign(direction)
+    direction == :descending ? -1 : 1
+  end
+
+  def direction_intervals(direction)
+    scale_type.send("#{direction}_intervals")
+  end
+
   def spellings(direction: :ascending, octaves: 1)
     pitches(direction: direction, octaves: octaves).map(&:spelling).map(&:to_s)
   end

data/lib/head_music/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "0.6.4"
+  VERSION = "0.7.0"
 end

data/lib/head_music.rb

@@ -14,11 +14,14 @@ require 'head_music/instrument'
 require 'head_music/interval'
 require 'head_music/key_signature'
 require 'head_music/letter_name'
+require 'head_music/composition'
+require 'head_music/measure'
 require 'head_music/meter'
 require 'head_music/note'
 require 'head_music/octave'
 require 'head_music/pitch_class'
 require 'head_music/pitch'
+require 'head_music/position'
 require 'head_music/quality'
 require 'head_music/rhythmic_unit'
 require 'head_music/rhythmic_value'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.7.0
 platform: ruby
 authors:
 - Rob Head
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-26 00:00:00.000000000 Z
+date: 2017-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -104,6 +104,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -118,6 +119,7 @@ files:
 - lib/head_music/accidental.rb
 - lib/head_music/circle.rb
 - lib/head_music/clef.rb
+- lib/head_music/composition.rb
 - lib/head_music/consonance.rb
 - lib/head_music/functional_interval.rb
 - lib/head_music/grand_staff.rb
@@ -125,11 +127,13 @@ files:
 - lib/head_music/interval.rb
 - lib/head_music/key_signature.rb
 - lib/head_music/letter_name.rb
+- lib/head_music/measure.rb
 - lib/head_music/meter.rb
 - lib/head_music/note.rb
 - lib/head_music/octave.rb
 - lib/head_music/pitch.rb
 - lib/head_music/pitch_class.rb
+- lib/head_music/position.rb
 - lib/head_music/quality.rb
 - lib/head_music/rhythmic_unit.rb
 - lib/head_music/rhythmic_value.rb
@@ -151,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: 2.3.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="