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
51
52
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 44

def consecutive_leap_marks
  return [] if maximum_consecutive_leaps.nil?

  melodic_note_pairs.chunk { |pair| qualifies?(pair) }
    .select { |qualifying, _run| qualifying }
    .map { |_qualifying, run| run }
    .select { |run| run.length > maximum_consecutive_leaps }
    .map { |run| HeadMusic::Style::Mark.for_all(run.flat_map(&:notes).uniq) }
end

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

Returns:

  • (Boolean) 


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

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

#direction_of(pair) ⇒ Object (private) 



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

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

  :none
end

#direction_settings(direction) ⇒ Object (private) 



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

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

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

#forbidden?(pair) ⇒ Boolean (private)

Returns:

  • (Boolean) 


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

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

#forbidden_number_for(direction) ⇒ Object (private) 



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

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) 



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

def forbidden_numbers
  @forbidden_numbers ||= {}
end

#interval_number(value) ⇒ Object (private) 



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

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) 



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

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) 



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

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

#minimum_numbers ⇒ Object (private) 



131
132
133
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 131

def minimum_numbers
  @minimum_numbers ||= {}
end

#qualifies?(pair) ⇒ Boolean (private)

Returns:

  • (Boolean) 


65
66
67
 
# File 'lib/head_music/style/guidelines/large_leaps.rb', line 65

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

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

Returns:

  • (Boolean) 


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

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) 


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

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

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

Returns:

  • (Boolean) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 



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

def recovery_modes
  config.fetch(:recovery)
end

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

Returns:

  • (Boolean) 


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

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

  !recovered?(first, second, third)
end