Class: HeadMusic::Style::Guidelines::LargeLeaps

Inherits:
Annotation
  • Object
show all
Defined in:
lib/head_music/style/guidelines/large_leaps.rb

Overview

A configurable guideline for the treatment of large melodic leaps.

Options: - minimum: the smallest interval (compared by diatonic number) treated as a large leap - ascending/descending: per-direction override; an interval shorthand or forbidden: - recovery: symbols naming the acceptable recovery gestures - maximum_consecutive_leaps: cap on a run of consecutive qualifying leaps - message: the annotation message

Constant Summary collapse

DEFAULTS = 
{
  minimum: :perfect_fourth,
  ascending: nil,
  descending: nil,
  recovery: %i[consonant_triad any_step repetition opposite_leap_within],
  maximum_consecutive_leaps: nil,
  message: "Recover leaps by step, repetition, opposite direction, or spelling triad."
}.freeze

Instance Method Summary collapse

Constructor Details

This class inherits a constructor from HeadMusic::Style::Annotation

Instance Method Details

#config ⇒ Object (private) 



32
33
34
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 32

def config
  @config ||= DEFAULTS.merge(options)
end

#consecutive_leap_marks ⇒ Object (private) 



44
45
46
47
48
49
50
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 44

def consecutive_leap_marks
  return [] if maximum_consecutive_leaps.nil?

  excessive_leap_runs.map do |run|
    HeadMusic::Style::Mark.for_all(run.flat_map(&:notes).uniq)
  end
end

#direction_changed?(first, second) ⇒ Boolean (private)

Returns:

  • (Boolean) 


115
116
117
118
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 115

def direction_changed?(first, second)
  first.ascending? && second.descending? ||
    first.descending? && second.ascending?
end

#direction_of(pair) ⇒ Object (private) 



120
121
122
123
124
125
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 120

def direction_of(pair)
  return :ascending if pair.ascending?
  return :descending if pair.descending?

  :none
end

#direction_settings(direction) ⇒ Object (private) 



147
148
149
150
151
152
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 147

def direction_settings(direction)
  setting = config[direction]
  return {} if setting.nil?

  setting.is_a?(Hash) ? setting : {minimum: setting}
end

#excessive_leap_runs ⇒ Object (private) 



52
53
54
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 52

def excessive_leap_runs
  qualifying_leap_runs.select { |run| run.length > maximum_consecutive_leaps }
end

#forbidden?(pair) ⇒ Boolean (private)

Returns:

  • (Boolean) 


77
78
79
80
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 77

def forbidden?(pair)
  ceiling = forbidden_number_for(direction_of(pair))
  !ceiling.nil? && pair.melodic_interval.number >= ceiling
end

#forbidden_number_for(direction) ⇒ Object (private) 



132
133
134
135
136
137
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 132

def forbidden_number_for(direction)
  return forbidden_numbers[direction] if forbidden_numbers.key?(direction)

  forbidden = direction_settings(direction)[:forbidden]
  forbidden_numbers[direction] = forbidden && interval_number(forbidden)
end

#forbidden_numbers ⇒ Object (private) 



143
144
145
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 143

def forbidden_numbers
  @forbidden_numbers ||= {}
end

#interval_number(value) ⇒ Object (private) 



154
155
156
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 154

def interval_number(value)
  HeadMusic::Analysis::DiatonicInterval.get(value).number
end

#marks ⇒ Object 



26
27
28
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 26

def marks
  @marks ||= recovery_marks + consecutive_leap_marks
end

#maximum_consecutive_leaps ⇒ Object (private) 



62
63
64
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 62

def maximum_consecutive_leaps
  config.fetch(:maximum_consecutive_leaps)
end

#message ⇒ Object 



22
23
24
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 22

def message
  config.fetch(:message)
end

#minimum_number_for(direction) ⇒ Object (private) 



127
128
129
130
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 127

def minimum_number_for(direction)
  minimum_numbers[direction] ||=
    interval_number(direction_settings(direction)[:minimum] || config.fetch(:minimum))
end

#minimum_numbers ⇒ Object (private) 



139
140
141
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 139

def minimum_numbers
  @minimum_numbers ||= {}
end

#qualifies?(pair) ⇒ Boolean (private)

Returns:

  • (Boolean) 


73
74
75
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 73

def qualifies?(pair)
  pair.melodic_interval.number >= minimum_number_for(direction_of(pair))
end

#qualifying_leap_runs ⇒ Object (private) 



56
57
58
59
60
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 56

def qualifying_leap_runs
  melodic_note_pairs.chunk { |pair| qualifies?(pair) }
    .select { |qualifying, _run| qualifying }
    .map { |_qualifying, run| run }
end

#recovered?(first, second, third) ⇒ Boolean (private)

Returns:

  • (Boolean) 


82
83
84
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 82

def recovered?(first, second, third)
  recovery_modes.any? { |mode| send(:"recovered_by_#{mode}?", first, second, third) }
end

#recovered_by_any_step?(_first, second, _third) ⇒ Boolean (private)

Returns:

  • (Boolean) 


98
99
100
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 98

def recovered_by_any_step?(_first, second, _third)
  second.step?
end

#recovered_by_consonant_triad?(first, second, third) ⇒ Boolean (private)

Returns:

  • (Boolean) 


90
91
92
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 90

def recovered_by_consonant_triad?(first, second, third)
  first.spells_consonant_triad_with?(second) || second.spells_consonant_triad_with?(third)
end

#recovered_by_opposite_leap?(first, second, _third) ⇒ Boolean (private)

Returns:

  • (Boolean) 


106
107
108
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 106

def recovered_by_opposite_leap?(first, second, _third)
  direction_changed?(first, second) && second.leap?
end

#recovered_by_opposite_leap_within?(first, second, third) ⇒ Boolean (private)

Returns:

  • (Boolean) 


110
111
112
113
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 110

def recovered_by_opposite_leap_within?(first, second, third)
  recovered_by_opposite_leap?(first, second, third) &&
    second.melodic_interval.number <= first.melodic_interval.number
end

#recovered_by_opposite_step?(first, second, _third) ⇒ Boolean (private)

Returns:

  • (Boolean) 


94
95
96
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 94

def recovered_by_opposite_step?(first, second, _third)
  direction_changed?(first, second) && second.step?
end

#recovered_by_repetition?(_first, second, _third) ⇒ Boolean (private)

Returns:

  • (Boolean) 


102
103
104
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 102

def recovered_by_repetition?(_first, second, _third)
  second.repetition?
end

#recovery_marks ⇒ Object (private) 



36
37
38
39
40
41
42
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 36

def recovery_marks
  melodic_note_pairs.each_cons(3).map do |first, second, third|
    if unrecovered_leap?(first, second, third)
      HeadMusic::Style::Mark.for_all((first.notes + second.notes).uniq)
    end
  end.compact
end

#recovery_modes ⇒ Object (private) 



86
87
88
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 86

def recovery_modes
  config.fetch(:recovery)
end

#unrecovered_leap?(first, second, third) ⇒ Boolean (private)

Returns:

  • (Boolean) 


66
67
68
69
70
71
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 66

def unrecovered_leap?(first, second, third)
  return false unless qualifies?(first)
  return true if forbidden?(first)

  !recovered?(first, second, third)
end