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

Inherits:
HeadMusic::Style::Guideline 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 - violation_key: names an alternative violation template

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
}.freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

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

Class Method Details

.render_violation(config) ⇒ Object 



28
29
30
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 28

def self.render_violation(config)
  HeadMusic::Style::Template.render(violation_key(config))
end

.violation_key(config = {}) ⇒ Object

A guide may name a different template.



24
25
26
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 24

def self.violation_key(config = {})
  config[:violation_key] || super()
end

Instance Method Details

#config ⇒ Object (private) 



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

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

#consecutive_leap_marks ⇒ Object (private) 



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

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) 


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

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

#direction_of(pair) ⇒ Object (private) 



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

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

  :none
end

#direction_settings(direction) ⇒ Object (private) 



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

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

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

#excessive_leap_runs ⇒ Object (private) 



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

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

#forbidden?(pair) ⇒ Boolean (private)

Returns:

  • (Boolean) 


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

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

#forbidden_number_for(direction) ⇒ Object (private) 



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

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) 



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

def forbidden_numbers
  @forbidden_numbers ||= {}
end

#interval_number(value) ⇒ Object (private) 



160
161
162
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 160

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

#marks ⇒ Object 



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

def marks
  @marks ||= recovery_marks + consecutive_leap_marks
end

#maximum_consecutive_leaps ⇒ Object (private) 



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

def maximum_consecutive_leaps
  config.fetch(:maximum_consecutive_leaps)
end

#minimum_number_for(direction) ⇒ Object (private) 



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

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

#minimum_numbers ⇒ Object (private) 



145
146
147
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 145

def minimum_numbers
  @minimum_numbers ||= {}
end

#qualifies?(pair) ⇒ Boolean (private)

Returns:

  • (Boolean) 


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

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

#qualifying_leap_runs ⇒ Object (private) 



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

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) 


88
89
90
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 88

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) 


104
105
106
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 104

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

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

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 96

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) 


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

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) 


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

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) 


100
101
102
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 100

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) 


108
109
110
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 108

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

#recovery_marks ⇒ Object (private) 



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

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) 



92
93
94
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 92

def recovery_modes
  config.fetch(:recovery)
end

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

Returns:

  • (Boolean) 


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

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

  !recovered?(first, second, third)
end